#include "i.h"
enum {
ALERTLINELEN = 80, // max number of characters in an alert line
SP = 8, // a spacer for between controls
SP2 = 4 // half of SP
};
Channel* gochan;
AuthInfo* auths = nil;
Channel* popupans;
int popupactive = 0;
History history;
CtlLayout ctllay;
ProgLayout proglay;
PopupLayout popuplay;
Loc* keyfocus;
int pgrp = 0;
int dbgres = 0;
Frame* top;
Frame* curframe;
Frame* ctlframe;
Frame* progframe;
Frame* popupframe;
Image* popupwin;
static void start(void);
static void redrawctl(int resized);
static void redrawmain(int resized);
static void redrawprog(int resized);
static void dopopup(int kind, Rune* s);
static void redrawpopup(void);
static void finishpopup(int code);
static void freectls(Control** a, int n);
static Rune* ctlentrytext(Control* c);
static Loc* frameloc(Control* c, Frame* f);
static void resetkeyfocus(Frame* oldf);
static GoSpec* handlemouse(EV e);
static GoSpec* handlekey(EV e);
static void go(void* arg);
static void goproc(void* arg);
static int get(GoSpec* g, Frame* f, int origkind, HistNode* hn);
static void go_local(Frame* f, Rune* loc);
static void checkrefresh(Frame* f);
static Frame* findnamedframe(Frame* f, Rune* name);
static Frame* findframe(Frame* f, int id);
static GoSpec* anchorgospec(Item* it, Anchor* a, Point p);
static GoSpec* pushaction(Control* c, Loc* loc);
static GoSpec* form_submit(Frame* fr, Form* frm, Point p, Control* submitctl);
static Rune* ucvt(Rune* s);
static int hexdigit(int v);
static void form_reset(Frame* fr, Form* frm);
static GoSpec* formaction(int frameid, int formid, int ftype);
static ParsedUrl* findhit(Map* map, Point p, int w, int h, int* ptarget);
static int d2pix(Dimen d, int tot);
static GoSpec* newget(ParsedUrl* url, int target);
static GoSpec* newpost(ParsedUrl* url, Rune* body, int target);
static GoSpec* newspecial(int kind, HistNode* hn);
static GoSpec* copygospec(GoSpec* g);
static int gospecequal(GoSpec* a, GoSpec* b);
static int docconfigequal(DocConfig* a, DocConfig* b);
static int docconfigequalarray(DocConfig** a1, int n1, DocConfig** a2, int n2);
static DocConfig* newdocconfig(Rune* fname, Rune* title, int initconfig, GoSpec* g);
static DocConfig* copydocconfig(DocConfig* d);
static HistNode_list* newhistnodelist(HistNode* hn, HistNode_list* l);
static void histaddedge(HistNode* a, HistNode* b, int atob);
static HistNode* histnodecopy(HistNode* a);
static HistNode* newhistnode(DocConfig* top, DocConfig** kids, int nkids,
HistNode_list* preds, HistNode_list* succs);
static void histadd(Frame* f, GoSpec* g, int navkind);
static void histupdate(Frame* f);
static HistNode* histfind(int gokind);
static void histprint();
static HistNode_list* remhnode(HistNode_list* l, HistNode* hn);
static void printhnodeindices(char* label, HistNode_list* l);
static void dumphistory(void);
static AuthInfo* getauth(Rune* chal);
static Rune* tobase64(Rune* a);
static int c64(int c);
static void dosaveas(ByteSource* bsmain);
static void handleprogress(EV e);
static void showstatus(Rune* msg);
static void alert(void *arg);
static void showurl(Rune* u);
void
threadmain(int argc, char* argv[])
{
int showprog;
ResourceState curres;
ResourceState newres;
int v;
GoSpec* g;
void* alertargs[2];
int dfile;
EV ev;
uchar* fname;
meminit(GRmain);
if(initdraw(nil, nil, "i") < 0)
fatalerror("initdraw failed");
iutilsinit(argc, argv);
dbgres = config.dbg['r'];
showprog = config.showprogress;
if(dbg && config.dbgfile != nil) {
fname = fromStr(config.dbgfile, Strlen(config.dbgfile), UTF_8);
dfile = create((char*)fname, OWRITE, 0644);
if(dfile >= 0) {
dup(dfile, 1);
trace("debug output\n");
}
}
curres = curresstate();
if(dbgres) {
resstateprint(startres, "starting resources");
curres = curresstate();
}
guiinit();
if(dbgres) {
newres = curresstate();
resstateprint(resstatesince(newres, curres), "difference after made screen windows");
curres = newres;
}
start();
gochan = chancreate(sizeof(GoSpec*), 1);
if(gochan == nil)
fatalerror("Can't make go channel");
g = newget(config.starturl, FTtop);
if(dbgres) {
newres = curresstate();
resstateprint(resstatesince(newres, curres), "difference after initial configure");
curres = newres;
}
if(threadcreate(netget, nil, STACKSIZE) < 0)
fatalerror("Can't make netget thread!");
if(threadcreate(go, g, STACKSIZE) < 0)
fatalerror("Can't make go thread!");
while(1) {
if(recv(evchan, &ev) == -1)
goto maindone;
if(dbg > 1) {
if(ev.tag == EVmousetag) {
if(dbg > 2 || ev.u.mouse.mtype != Mmove)
trace("Ev: %M\n", &ev);
}
else
trace("Ev: %M\n", &ev);
}
switch(ev.tag) {
case EVkeytag:
switch(ev.u.keychar) {
case Kdown:
yscroll(curframe, CAscrollpage, 1);
break;
case Kup:
yscroll(curframe, CAscrollpage, -1);
break;
case Khome:
yscroll(curframe, CAscrollpage, -10000);
break;
default:
g = handlekey(ev);
break;
}
break;
case EVmousetag:
g = handlemouse(ev);
break;
case EVresizetag:
redrawctl(1);
redrawmain(1);
redrawprog(1);
curframe = top;
g = newspecial(GoHistnode, histfind(0));
break;
case EVexposetag:
g = nil;
break;
case EVhidetag:
g = nil;
break;
case EVquittag:
goto maindone;
break;
case EValerttag:
alertargs[0] = ev.u.alert.msg;
alertargs[1] = ev.u.alert.sync;
if(proccreate(alert, (void*)alertargs, STACKSIZESMALL) < 0) {
trace("can't create alert proc\n");
if(sendul((Channel*)ev.u.alert.sync, 1) < 0)
finish();
}
g = nil;
break;
case EVformtag:
g = formaction(ev.u.form.frameid, ev.u.form.formid, ev.u.form.ftype);
break;
case EVgotag:
if(ev.u.go.url == nil)
g = newspecial(GoHistnode, histfind(0));
else
g = newget(ev.u.go.url, ev.u.go.target);
break;
case EVprogresstag:
if(showprog)
handleprogress(ev);
g = nil;
break;
default:
trace("unknown event tag %d\n", ev.tag);
g = nil;
}
if(g != nil) {
abortgo();
v = nbsend(gochan, &g);
if(v < 0)
goto maindone;
if(v == 0) {
// discard the gospec: last one hasn't been
// acted on yet.
// (We do this to avoid having events pile up
// while waiting for abort to have effect)
trace("go pileup; discard\n");
g = nil;
}
}
}
maindone:
finish();
}
static void
start(void)
{
Image* i;
Image* m;
top = newframe();
ctlframe = newframe(); // not really a frame, but need cim pointer
progframe = newframe(); // not really a frame, but need cim pointer
popupframe = newframe(); // not really a frame, but need cim pointer
curframe = top;
ctllay.logoicon = geticon(IClogo, nil);
i = geticon(ICback, &m);
ctllay.controls[CLCbackbut] = newbutton(ctlframe, i, m, L"Go back", nil, 1, 1);
i = geticon(ICfwd, &m);
ctllay.controls[CLCfwdbut] = newbutton(ctlframe, i, m, L"Go forward", nil, 1, 1);
i = geticon(ICreload, &m);
ctllay.controls[CLCreloadbut] = newbutton(ctlframe, i, m, L"Reload current page", nil, 1, 1);
i = geticon(ICstop, &m);
ctllay.controls[CLCstopbut] = newbutton(ctlframe, i, m, L"Stop", nil, 1, 1);
i = geticon(IChist, &m);
ctllay.controls[CLChistbut] = newbutton(ctlframe, i, m, L"Show history", nil, 1, 1);
i = geticon(ICbmark, &m);
ctllay.controls[CLCbmarkbut] = newbutton(ctlframe, i, m, L"Show bookmarks", nil, 1, 1);
i = geticon(ICexit, &m);
ctllay.controls[CLCexitbut] = newbutton(ctlframe, i, m, L"Exit", nil, 1, 1);
ctllay.controls[CLCentry] = newentry(ctlframe, 30, 1, 0);
disable(ctllay.controls[CLCbackbut]);
disable(ctllay.controls[CLCfwdbut]);
disable(ctllay.controls[CLCstopbut]);
ctllay.status = nil;
keyfocus = frameloc(ctllay.controls[CLCentry], ctlframe);
gainfocus(ctllay.controls[CLCentry]);
popuplay.kind = PopupNone;
popupans = chancreate(sizeof(PopupAns), 0);
redrawctl(1);
redrawmain(1);
redrawprog(1);
}
static void
redrawctl(int resized)
{
Rectangle r;
Point p;
Image* li;
int lw;
int lh;
int i;
Control* b;
int x;
int y;
pushclipr(rctl);
r = insetrect(rctl, ReliefBd);
drawfill(screen, r, Grey);
drawrelief(screen, r, ReliefRaised);
replaceclipr(r);
p = ctllay.logopos;
li = ctllay.logoicon;
lw = Dx(li->r);
lh = Dy(li->r);
if(resized) {
ctlframe->r = insetrect(rctl, 2*ReliefBd);
ctlframe->cr = r;
ctlframe->cim = screen;
p = addpt(r.min, Pt(7, 7));
ctllay.logopos = p;
x = p.x + lw;
y = p.y;
x += SP;
for(i = 0; i < NUMCLCS; i++) {
b = ctllay.controls[i];
b->r = rectsubpt(b->r, b->r.min);
if(i == CLCentry || i == CLCexitbut)
continue;
b->r = rectaddpt(b->r, Pt(x, y));
x += Dx(b->r) + SP2;
}
x += SP2;
ctllay.entrypos = Pt(x, y);
ctllay.controls[CLCentry]->r = Rpt(ctllay.entrypos, Pt(r.max.x - 7, y + 22));
ctllay.controls[CLCentry]->r.max.x -= Dx(ctllay.controls[CLCexitbut]->r) + SP2;
ctllay.controls[CLCexitbut]->r = rectaddpt(ctllay.controls[CLCexitbut]->r,
Pt(ctllay.controls[CLCentry]->r.max.x + SP2, y));
}
ctllay.statuspos = Pt(p.x + lw + SP, p.y + Dy((ctllay.controls[CLCbackbut])->r) + SP);
draw(screen, Rpt(p, addpt(p, Pt(lw, lh))), li, nil, ZP);
for(i = 0; i < NUMCLCS; i++)
drawctl(ctllay.controls[i], 0);
showstatus(ctllay.status);
popclipr();
flushimage(display, 1);
}
static void
redrawmain(int resized)
{
if(resized) {
top->r = insetrect(rmain, 2*ReliefBd);
top->cr = top->r;
top->cim = screen;
resetframe(top);
imcacheresetlimits();
}
pushclipr(rmain);
drawrelief(screen, insetrect(top->r, -ReliefBd), ReliefRaised);
drawrelief(screen, top->r, ReliefSunk);
replaceclipr(top->r);
drawfill(screen, top->r, White);
popclipr();
flushimage(display, 1);
}
static void
redrawprog(int resized)
{
Rectangle r;
int i;
Control** newbox;
Point p;
int nbox;
int nboxold;
Control* c;
int vo;
if(!config.showprogress)
return;
pushclipr(rprog);
r = insetrect(rprog, ReliefBd);
drawfill(screen, r, Grey);
drawrelief(screen, r, ReliefRaised);
replaceclipr(r);
if(resized) {
p = proglay.first;
nbox = proglay.boxlen;
progframe->r = insetrect(rprog, 2*ReliefBd);
progframe->cr = progframe->r;
progframe->cim = screen;
nboxold = nbox;
c = newprogbox(progframe);
vo = (Dy(r) - Dy(c->r))/2;
p = addpt(r.min, Pt(7, vo));
proglay.first = p;
proglay.dx = Dx(c->r) + SP2;
nbox = (Dx(r) - 2*7 - SP2)/proglay.dx;
if(nboxold != nbox) {
newbox = (Control**)erealloc(proglay.box, nbox * sizeof(Control*));
proglay.box = newbox;
proglay.boxlen = nbox;
for(i = nboxold; i < nbox; i++)
proglay.box[i] = newprogbox(progframe);
}
for(i = 0; i < nbox; i++) {
c = proglay.box[i];
c->r = rectsubpt(c->r, c->r.min);
c->r = rectaddpt(c->r, Pt(p.x + i*proglay.dx, p.y));
}
}
for(i = 0; i < proglay.nused; i++)
drawctl(proglay.box[i], 0);
popclipr();
flushimage(display, 1);
}
// Display popup of given kind (s is more info for drawing, depending on kind),
// and return user's answer on popupans as (code, string), where code will
// be -1 for error, 0 when the user hit cancel, and 1 when the user hit OK.
static void
dopopup(int kind, Rune* s)
{
int w;
int h;
int n;
int nw;
int i;
int k;
int nline;
int curlen;
int curlinestart;
Control* cok;
Control* ccancel;
Point p;
Control* oldc;
Control* newc;
Control* chead;
Control* crealm;
Control* cunlab;
Control* cpwlab;
Control* cuser;
Control* cpass;
Control* clab;
Control* cfile;
Rune* l;
Control* c;
PopupAns pans;
Rune* words[BIGBUFSIZE];
int wordlens[BIGBUFSIZE];
Rune* lines[SMALLBUFSIZE];
cok = newbutton(popupframe, nil, nil, L"Ok", nil, 1, 1);
ccancel = newbutton(popupframe, nil, nil, L"Cancel", nil, 1, 1);
p = Pt(0, 0);
switch(kind) {
case PopupAuth:
popuplay.ncontrols = 8;
popuplay.controls = (Control**)emalloc(popuplay.ncontrols*sizeof(Control*));
popuplay.controls[0] = cuser = newentry(popupframe, 30, 1, 0);
popuplay.controls[1] = cpass = newentry(popupframe, 30, 1, 0);
popuplay.controls[2] = chead = newlabel(popupframe, L"Type your user name and password");
popuplay.controls[3] = crealm = newlabel(popupframe, Strdup2(L"Resource: ", s));
popuplay.controls[4] = cunlab = newlabel(popupframe, Strdup(L"User Name: "));
popuplay.controls[5] = cpwlab = newlabel(popupframe, Strdup(L"Password: "));
popuplay.controls[6] = cok;
popuplay.controls[7] = ccancel;
w = SP +
max(chead->r.max.x, max(crealm->r.max.x, cunlab->r.max.x + cuser->r.max.x)) +
SP;
w = min(w, Dx(rmain) - 2*SP);
h = SP + chead->r.max.y + SP + crealm->r.max.y + SP + cuser->r.max.y + SP +
cpass->r.max.y + 2*SP + cok->r.max.y + SP;
popupwin = makepopup(w, h);
if(popupwin == nil) {
pans.code = -1;
pans.s = nil;
if(send(popupans, &pans) < 0)
finish();
freectls(popuplay.controls, popuplay.ncontrols);
return;
}
p = addpt(popupwin->r.min, Pt(SP, SP));
chead->r = rectaddpt(chead->r, p);
p.y += Dy(chead->r) + SP;
crealm->r = rectaddpt(crealm->r, p);
p.y += Dy(crealm->r) + SP;
cunlab->r = rectaddpt(cunlab->r, p);
cuser->r = rectaddpt(cuser->r, addpt(p, Pt(Dx(cunlab->r), 0)));
p.y += Dy(cuser->r) + SP;
cpwlab->r = rectaddpt(cpwlab->r, p);
cpass->r = rectaddpt(cuser->r, Pt(0, Dy(cuser->r) + SP));
p.y += Dy(cpass->r) + 2*SP;
break;
case PopupSaveAs:
popuplay.ncontrols = 4;
popuplay.controls = (Control**)emalloc(popuplay.ncontrols*sizeof(Control*));
popuplay.controls[0] = cfile = newentry(popupframe, 40, 1, 0);
popuplay.controls[1] = clab = newlabel(popupframe, L"Save As: ");
popuplay.controls[2] = cok;
popuplay.controls[3] = ccancel;
((Centry*)cfile)->s = s;
w = SP + clab->r.max.x + cfile->r.max.x + SP;
h = SP + cfile->r.max.y + 2*SP + cok->r.max.y + SP;
popupwin = makepopup(w, h);
if(popupwin == nil) {
pans.code = -1;
pans.s = nil;
if(send(popupans, &pans) < 0)
finish();
freectls(popuplay.controls, popuplay.ncontrols);
return;
}
p = addpt(popupwin->r.min, Pt(SP, SP));
clab->r = rectaddpt(clab->r, p);
cfile->r = rectaddpt(cfile->r, addpt(p, Pt(Dx(clab->r) + SP, 0)));
p.y += Dy(clab->r) + 2*SP;
break;
case PopupAlert:
ccancel = nil;
// split s up into lines of at most ALERTLINELEN characters each
n = splitall(s, Strlen(s), L" \t\n\r", words, wordlens, BIGBUFSIZE);
curlen = 0;
curlinestart = 0;
nline = 0;
for(i = 0; i < n; i++) {
nw = wordlens[i];
if(curlen + nw >= ALERTLINELEN) {
l = newstr(curlen);
if(nline < SMALLBUFSIZE)
lines[nline++] = l;
for(k = curlinestart; k < i; k++) {
l = Stradd(l, words[k], wordlens[k]);
if(k < i-1)
*l++ = ' ';
}
*l = 0;
curlinestart = i;
curlen = nw;
}
else
curlen += nw + (curlen > 0);
}
if(curlen != 0) {
l = newstr(curlen);
if(nline < SMALLBUFSIZE)
lines[nline++] = l;
for(k = curlinestart; k < i; k++) {
l = Stradd(l, words[k], wordlens[k]);
if(k < i-1)
*l++ = ' ';
}
*l = 0;
}
popuplay.ncontrols = nline+1;
popuplay.controls = (Control**)emalloc(popuplay.ncontrols*sizeof(Control*));
popuplay.controls[0] = cok;
w = SP + cok->r.max.x + SP;
h = SP + 2*SP + cok->r.max.y + SP;
for(k = 0; k < nline; k++) {
l = lines[k];
c = newlabel(popupframe, l);
popuplay.controls[k+1] = c;
w = max(w, SP + Dx(c->r) + SP);
h += Dy(c->r);
}
popupwin = makepopup(w, h);
if(popupwin == nil) {
pans.code = -1;
pans.s = nil;
if(send(popupans, &pans) < 0)
finish();
freectls(popuplay.controls, popuplay.ncontrols);
return;
}
p = addpt(popupwin->r.min, Pt(SP, SP));
for(k = 1; k <= nline; k++) {
c = popuplay.controls[k];
c->r = rectaddpt(c->r, p);
p.y += Dy(c->r);
}
p.y += 2*SP;
break;
default:
assert(0);
break;
}
if(ccancel == nil) {
p.x += (Dx(popupwin->r) - cok->r.max.x)/2 - SP;
cok->r = rectaddpt(cok->r, p);
}
else {
p.x += (Dx(popupwin->r) - (cok->r.max.x + SP + ccancel->r.max.x))/2 - SP;
cok->r = rectaddpt(cok->r, p);
p.x += Dx(cok->r) + SP;
ccancel->r = rectaddpt(ccancel->r, p);
}
popupframe->cim = popupwin;
popuplay.kind = kind;
popuplay.okbut = cok;
popuplay.cancelbut = ccancel;
popupactive = 1;
oldc = keyfocus->le[keyfocus->n - 1].control;
if(oldc != nil)
losefocus(oldc);
newc = popuplay.controls[0];
keyfocus = frameloc(newc, popupframe);
gainfocus(newc);
redrawpopup();
}
static void
redrawpopup(void)
{
Rectangle r;
int i;
if(popuplay.kind == PopupNone)
return ;
assert(popupwin != nil);
popupwin->clipr = popupwin->r;
r = insetrect(popupwin->r, ReliefBd);
drawfill(popupwin, r, Grey);
drawrelief(popupwin, r, ReliefRaised);
popupwin->clipr = r;
for(i = 0; i < popuplay.ncontrols; i++)
drawctl(popuplay.controls[i], 0);
flushimage(display, 1);
}
static void
finishpopup(int code)
{
PopupAns pans;
pans.code = code;
pans.s = nil;
switch(popuplay.kind) {
case PopupAuth:
pans.s = Strdup3(ctlentrytext(popuplay.controls[0]), L":",
ctlentrytext(popuplay.controls[1]));
break;
case PopupSaveAs:
pans.s = ctlentrytext(popuplay.controls[0]);
break;
}
popuplay.kind = PopupNone;
popuplay.controls = nil;
popuplay.okbut = nil;
popuplay.cancelbut = nil;
popupframe->cim = nil;
popupwin = nil;
popupactive = 0;
freectls(popuplay.controls, popuplay.ncontrols);
if(send(popupans, &pans) < 0)
finish();
}
// assuming c is an entry control, return its contents
// (caller must dup, if it wants to save the result)
static Rune*
ctlentrytext(Control* c)
{
assert(c->tag == Centrytag);
return ((Centry*)c)->s;
}
// Return a Loc representing a control in the frame f
static Loc*
frameloc(Control* c, Frame* f)
{
Loc* loc;
loc = newloc();
addloc(loc, LEframe, f->r.min);
loc->le[loc->n - 1].frame = f;
addloc(loc, LEcontrol, c->r.min);
loc->le[loc->n - 1].control = c;
return loc;
}
// Frame oldf is being reset, so change keyfocus back to ctllay.entry
static void
resetkeyfocus(Frame* oldf)
{
USED(oldf);
keyfocus = frameloc(ctllay.controls[CLCentry], ctlframe);
}
// If mouse event results in command to navigate somewhere else,
// return a GoSpec ref, else nil.
// TODO: deactivate activated controls if mouse leaves the area;
// perhaps do grabs?
static GoSpec*
handlemouse(EV e)
{
Point p;
GoSpec* g;
Control* oldc;
Control* c;
Anchor* a;
Item* it;
// ScriptEvent* se;
// int hasscripts;
Frame* f;
int n1;
Loc* loc;
Rune* msg;
int i;
Cprogbox* pc;
int ns;
char buf[SMALLBUFSIZE];
p = e.u.mouse.p;
g = nil;
if(popupactive) {
for(i = 0; i < popuplay.ncontrols; i++) {
c = popuplay.controls[i];
if(ptinrect(p, c->r)) {
if(dbg > 1)
trace("mouse in popup control\n");
switch(domouse(c, p, e.u.mouse.mtype)) {
case CAbuttonpush:
if(c == popuplay.okbut)
finishpopup(1);
else if(c == popuplay.cancelbut)
finishpopup(0);
break;
case CAkeyfocus:
if(dbg > 1)
printloc(keyfocus, "old focus");
oldc = keyfocus->le[keyfocus->n - 1].control;
if(oldc != nil)
losefocus(oldc);
keyfocus = frameloc(c, popupframe);
gainfocus(c);
if(dbg > 1)
printloc(keyfocus, "new focus");
break;
}
}
}
}
else if(ptinrect(p, rctl)) {
for(i = 0; i < NUMCLCS; i++) {
c = ctllay.controls[i];
if(ptinrect(p, c->r)) {
if(dbg > 1)
trace("mouse in controlwin control\n");
switch(domouse(c, p, e.u.mouse.mtype)) {
case CAbuttonpush:
switch(i) {
case CLCbackbut:
g = newspecial(GoHistnode, histfind(-1));
break;
case CLCfwdbut:
g = newspecial(GoHistnode, histfind(1));
break;
case CLCreloadbut:
g = newspecial(GoHistnode, histfind(0));
break;
case CLChistbut:
g = newspecial(GoHistory, nil);
break;
case CLCbmarkbut:
g = newspecial(GoBookmarks, nil);
break;
case CLCstopbut:
g = newspecial(GoStop, nil);
break;
case CLCexitbut:
finish();
}
break;
case CAflyover:
if(c->tag == Cbuttontag)
showstatus(((Cbutton*)c)->label);
break;
case CAkeyfocus:
if(dbg > 1)
printloc(keyfocus, "old focus");
oldc = keyfocus->le[keyfocus->n - 1].control;
if(oldc != nil)
losefocus(oldc);
keyfocus = frameloc(c, ctlframe);
gainfocus(c);
if(dbg > 1)
printloc(keyfocus, "new focus");
break;
}
break;
}
}
}
else if(ptinrect(p, rmain)) {
loc = findloc(top, p, nil);
if(loc != nil) {
if(dbg > 1)
printloc(loc, "mouse loc");
f = lastframe(loc);
// hasscripts = f->doc->hasscripts;
if(e.u.mouse.mtype != Mmove)
curframe = f;
n1 = loc->n - 1;
switch(loc->le[n1].kind) {
case LEitem:
it = loc->le[n1].item;
if(it->anchorid >= 0) {
for(a = f->doc->anchors; a != nil; a = a->next) {
if(a->index == it->anchorid) {
if(dbg > 1)
trace("in anchor %d, href=%U\n", a->index, a->href);
if(e.u.mouse.mtype == Mlbuttonup)
g = anchorgospec(it, a, loc->pos);
else if(e.u.mouse.mtype == Mmbuttonup) {
showstatus(a->href->url);
}
}
}
}
break;
case LEcontrol:
c = loc->le[n1].control;
switch(domouse(c, p, e.u.mouse.mtype)) {
case CAbuttonpush:
// if(hasscripts && c->ff != nil && c->ff->events != nil) {
// se = copyScriptEvent((ScriptEvent(Aonclick, f->id,
// c->ff->form->formid, c->ff->fieldid, -1, e->p.x, e->p.y, 1));
// /* TODO spawn */do_on(se);
// return nil;
// }
g = pushaction(c, loc);
break;
case CAkeyfocus:
if(dbg > 1)
printloc(keyfocus, "old focus");
oldc = keyfocus->le[keyfocus->n - 1].control;
if(oldc != nil)
losefocus(oldc);
keyfocus = frameloc(c, ctlframe);
gainfocus(c);
if(dbg > 1)
printloc(keyfocus, "new focus");
break;
}
break;
}
}
}
else if(ptinrect(p, rprog)) {
for(i = 0; i < proglay.boxlen; i++) {
c = proglay.box[i];
if(ptinrect(p, c->r)) {
if(dbg > 1)
trace("mouse in progbox control %d\n", i);
switch(domouse(c, p, e.u.mouse.mtype)) {
case CAbuttonpush:
switch(c->tag) {
case Cprogboxtag:
assert(c->tag == Cprogboxtag);
pc = (Cprogbox*)c;
ns = snprint(buf, sizeof(buf), "%S, %d%% done", pc->src, pc->pcnt);
if(pc->err != nil)
ns += snprint(buf+ns, sizeof(buf)-ns, ", %S", pc->err);
if(dbg)
ns += snprint(buf+ns, sizeof(buf)-ns, ", bsid=%d", pc->bsid);
msg = toStr((uchar*)buf, ns, UTF_8);
showstatus(msg);
break;
}
break;
}
}
}
}
return g;
}
// If key event results in command to navigate somewhere else,
// return a GoSpec ref, else nil.
static GoSpec*
handlekey(EV e)
{
Loc* loc;
int n1;
ParsedUrl* u;
Rune* s;
Centry* ce;
Control* c;
loc = keyfocus;
if(dbg > 1)
printloc(loc, "key focus loc");
n1 = loc->n - 1;
switch(loc->le[n1].kind) {
case LEcontrol:
c = loc->le[n1].control;
switch(c->tag) {
case Centrytag:
ce = (Centry*)c;
switch(dokey(c, e.u.keychar)) {
case CAreturnkey:
if(c == ctllay.controls[CLCentry]) {
s = ce->s;
if(s != nil) {
u = makeurl(s, 1);
return newget(u, FTtop);
}
}
else if(popupactive) {
finishpopup(1);
return nil;
}
else if(c->ff != nil)
return form_submit(c->f, c->ff->form, ZP, c);
break;
case CAtabkey:
break;
}
break;
}
break;
}
return nil;
}
// Run as separate thread
// Arg has first GoSpec* as arg
static void
go(void* arg)
{
GoSpec* g;
int origkind;
int rv;
HistNode* hn;
Frame* f;
ParsedUrl* url;
Rune* s;
EV prog;
g = (GoSpec*)arg;
while(1) {
origkind = g->kind;
hn = nil;
switch(g->kind) {
case GoNormal:
break;
case GoHistnode:
hn = g->histnode;
if(hn == nil)
return;
g = hn->topconfig->gospec;
break;
case GoBookmarks:
s = Strdup3(L"file:", config.userdir, L"/bookmarks.html");
url = makeurl(s, 0);
g = newget(url, FTtop);
break;
case GoHistory:
s = Strdup3(L"file:", config.userdir, L"/history.html");
url = makeurl(s, 0);
dumphistory();
g = newget(url, FTtop);
break;
}
switch(g->target) {
case FTtop:
curframe = top;
break;
case FTself:
break; // curframe is already OK
case FTparent:
if(curframe->parent != nil)
curframe = curframe->parent;
break;
case FTblank:
curframe = top; // we don't create new browsers...
break;
default:
// this is recommended "current practice"
curframe = findnamedframe(curframe, targetname(g->target));
if(curframe == nil) {
curframe = findnamedframe(top, targetname(g->target));
if(curframe == nil)
curframe = top;
}
}
if(g->kind == GoStop) {
if(dbg)
trace("\n\nSTOP\n");
showstatus(L"Stopped");
}
else {
f = curframe;
if(dbg) {
trace("\n\nGO TO %U\n", g->url);
if(g->target != FTtop)
trace("target frame name=%S\n", f->name);
}
if(g->url->nfrag != 0 && origkind == GoNormal
&& f->doc != nil && f->doc->src != nil && urlequal(g->url, f->doc->src)) {
go_local(f, g->url->frag);
return ;
}
if(config.showprogress) {
prog.tag = EVprogresstag;
prog.u.progress.bsid = -1;
prog.u.progress.state = 0;
prog.u.progress.pcnt = 0;
prog.u.progress.s = nil;
if(send(evchan, &prog) < 0)
finish();
}
enable(ctllay.controls[CLCstopbut]);
rv = get(g, f, origkind, hn);
disable(ctllay.controls[CLCstopbut]);
if(rv) {
showstatus(L"Done");
checkrefresh(f);
}
}
if(recv(gochan, &g) < 0)
finish();
}
}
// The important invariant in get/layout is that we keep
// track of every ByteSource returned by startreq, and
// ensure that we freebs each of them.
// And we can't start a new get() until all the ones started
// for the current get() have been freed.
static int
get(GoSpec* g, Frame* f, int origkind, HistNode* hn)
{
ResourceState curres;
ResourceState newres;
Rune* sdest;
ByteSource* bsmain;
Header* hdr;
ReqInfo* ri;
int authtried;
AuthInfo* auth;
int nredirs;
ByteSource* bs;
int use;
int error;
Rune* challenge;
ParsedUrl* newurl;
GoSpec* gs;
Framelist* kl;
Frame* k;
int i;
Rune* msg;
uchar* body;
int bodylen;
if(dbgres) {
imcacheclear();
curres = curresstate();
}
sdest = g->url->url;
msg = Strdup2(L"Fetching ", sdest);
showstatus(msg);
if(g->body != nil) {
body = fromStr(g->body, Strlen(g->body), UTF_8);
bodylen = strlen((char*)body);
}
else {
body = nil;
bodylen = 0;
}
ri = newreqinfo(g->url, g->meth, body, bodylen, g->auth, g->target);
authtried = 0;
auth = nil;
for(nredirs = 0; ; nredirs++) {
bsmain = startreq(ri);
if(bsmain->err) {
showstatus(errphrase(bsmain->err));
freebs(bsmain);
goto errret;
}
bs = waitreq();
if(bs == nil)
goto errret;
assert(bs == bsmain);
if(bsmain->err != 0) {
showstatus(errphrase(bsmain->err));
freebs(bsmain);
goto errret;
}
hdr = bsmain->hdr;
use = hdraction(bsmain, 1, nredirs, &error, &challenge, &newurl);
if(challenge != nil) {
if(authtried) {
error = ERRauthfailed;
use = 1;
}
else {
auth = getauth(challenge);
if(auth != nil) {
ri->auth = auth->credentials;
authtried = 1;
freebs(bsmain);
continue;
}
else {
error = ERRauthfailed;
use = 1;
}
}
}
if(error)
showstatus(errphrase(error));
else {
showstatus(hcphrase(hdr->code));
if(authtried) {
auth->next = auths;
auths = auth;
}
}
if(newurl != nil) {
ri->url = newurl;
ri->method = HGet;
freebs(bsmain);
continue;
}
if(use == 0) {
freebs(bsmain);
goto errret;
}
break;
}
if(dbgres > 1) {
newres = curresstate();
resstateprint(resstatesince(newres, curres), "resources to get header");
curres = newres;
}
if(hdr->length > 0 && (hdr->mtype == TextHtml || hdr->mtype == TextPlain || supported(hdr->mtype))) {
showurl(sdest);
histadd(f, g, origkind);
resetkeyfocus(f);
layout(f, bsmain, nil);
histupdate(f);
if(dbgres > 1) {
newres = curresstate();
resstateprint(resstatesince(newres, curres), "resources to get page and do layout");
curres = newres;
}
if(f->kids != nil) {
i = 0;
for(kl = f->kids; kl != nil; kl = kl->next) {
k = kl->val;
if(k->src != nil) {
if(hn != nil)
gs = hn->kidconfigs[i]->gospec;
else
gs = newget(copyurl(k->src), FTself);
if(dbg)
trace("get child frame %U\n", gs->url);
if(!get(gs, k, GoNormal, nil))
goto errret;
}
i++;
}
}
if(g->url->nfrag != 0)
go_local(f, g->url->frag);
}
else {
if(hdr->length == 0) {
showstatus(L"Empty page");
freebs(bsmain);
}
else {
msg = Strdup2(L"Unsupported media type: ", mnames[hdr->mtype]);
showstatus(msg);
dosaveas(bsmain); // frees bsmain when done
}
}
if(dbgres == 1) {
newres = curresstate();
resstateprint(resstatesince(newres, curres), "resources to do page");
curres = newres;
}
return 1;
errret:
return 0;
}
static void
go_local(Frame* f, Rune* loc)
{
Loc* dloc;
Point p;
DestAnchor* d;
if(dbg)
trace("go to local destination %S\n", loc);
for(d = f->doc->dests; d != nil; d = d->next) {
if(!Strcmp(d->name, loc)) {
dloc = findloc(f, ZP, d->item);
if(dloc == nil) {
if(warn)
trace("couldn't find item for destination anchor %S\n", loc);
return ;
}
p = sptolp(f, dloc->le[dloc->n - 1].pos);
yscroll(f, CAscrollabs, p.y);
return;
}
}
if(warn)
trace("couldn't find destination anchor %S\n", loc);
}
// If refresh has been set in f (i.e., client pull),
// pause the appropriate amount of time and then go to new place
static void
checkrefresh(Frame* f)
{
Rune* s;
int seconds;
ParsedUrl* url;
int n;
EV e;
EV* goe;
Rune* a[2];
int na[2];
if(f->doc != nil && f->doc->refresh != nil) {
seconds = 0;
url = nil;
n = splitall(f->doc->refresh, Strlen(f->doc->refresh), L"; ", a, na, 2);
if(n > 0) {
seconds = Strtol(a[0], nil, 10);
if(n > 1) {
s = a[1];
if(na[1] > 4 && !Strncmpci(s, 4, L"url=")) {
s = Strndup(s+4, na[1]-4);
url = makeurl(s, 0);
url = makeabsoluteurl(url, f->doc->base);
}
}
}
goe = (EV*)emalloc(sizeof(EV));
if(url == nil)
*goe = evgo(nil, FTtop, EGreload, f->id);
else
*goe = evgo(copyurl(url), targetid(f->name), EGnormal, f->id);
e.tag = EVdelaytag;
e.genframeid = f->id;
e.u.delay.millisecs = seconds*1000;
e.u.delay.ev = goe;
if(send(evchan, &e) < 0)
finish();
}
}
// Do depth first search from f, looking for frame with given name.
static Frame*
findnamedframe(Frame* f, Rune* name)
{
Framelist* kl;
Frame* a;
if(!Strcmp(f->name, name))
return f;
for(kl = f->kids; kl != nil; kl = kl->next) {
a = findnamedframe(kl->val, name);
if(a != nil)
return a;
}
return nil;
}
// Similar, but look for frame id, starting from f
static Frame*
findframe(Frame* f, int id)
{
Framelist* kl;
Frame* a;
if(f->id == id)
return f;
for(kl = f->kids; kl != nil; kl = kl->next) {
a = findframe(kl->val, id);
if(a != nil)
return a;
}
return nil;
}
// Return Gospec resulting from button up in anchor a, at offset pos inside item it.
static GoSpec*
anchorgospec(Item* it, Anchor* a, Point p)
{
GoSpec* g;
ParsedUrl* u;
int target;
int x;
int y;
Rune* sx;
Rune* sy;
Rune* q;
CImage* ci;
Iimage* i;
Ifloat* f;
g = nil;
target = a->target;
u = nil;
switch(it->tag) {
case Iimagetag:
i = (Iimage*)it;
ci = i->ci;
if(ci->mims != nil) {
if(i->map != nil) {
u = findhit(i->map, p, ci->width, ci->height, &target);
}
else if(a->href != nil && (it->state&IFsmap)) {
x = min(max(p.x - (i->hspace + i->border), 0), ci->width - 1);
y = min(max(p.y - (i->vspace + i->border), 0), ci->height - 1);
sx = ltoStr(x);
sy = ltoStr(y);
q = Strdup3(sx, L",", sy);
u = makequeryurl(a->href, q);
}
}
break;
case Ifloattag:
f = (Ifloat*)it;
return anchorgospec(f->item, a, p);
default:
u = copyurl(a->href);
}
if(u != nil)
g = newget(u, target);
return g;
}
// Control c has been pushed.
// Find the form it is in and perform required action (reset, or submit).
// If a submit, the return value is the place to go to.
static GoSpec*
pushaction(Control* c, Loc* loc)
{
Formfield* ff;
Frame* f;
Cbutton* b;
if(c->tag == Cbuttontag) {
b = (Cbutton*)c;
ff = b->ff;
f = b->f;
if(ff != nil) {
switch(ff->ftype) {
case Fsubmit:
case Fimage:
return form_submit(c->f, ff->form, loc->pos, c);
break;
case Freset:
form_reset(f, ff->form);
break;
}
}
}
return nil;
}
static GoSpec*
form_submit(Frame* fr, Form* frm, Point p, Control* submitctl)
{
Rune* v;
Rune* sep;
Rune* t;
Rune* z;
Strlist* radiodone;
Formfield* f;
int nnonhidden;
Strlist* rl;
int checked;
int i;
int n;
Cselect* cs;
Rune* val;
Control* c;
ParsedUrl* action;
if(submitctl != nil && submitctl->tag == Centrytag) {
nnonhidden = 0;
for(f = frm->fields; f != nil; f = f->next) {
if(f->ftype != Fhidden)
nnonhidden++;
}
if(nnonhidden > 1)
return nil;
}
v = nil;
sep = nil;
radiodone = nil;
for(f = frm->fields; f != nil; f = f->next) {
if(f->name == nil)
continue;
val = nil;
if(f->ctlid >= 0)
c = fr->controls[f->ctlid];
else
c = nil;
switch(f->ftype) {
case Ftext:
case Fpassword:
case Ftextarea:
if(c != nil)
val = ((Centry*)c)->s;
if(val != nil && !Strcmp(f->name, L"_ISINDEX_")) {
if(sep != nil)
v = Strdup2(v, sep);
t = ucvt(val);
v = Strdup2(v, t);
goto floop_done;
}
break;
case Fcheckbox:
case Fradio:
if(f->ftype == 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 = rl->next)
if(!Strcmp(rl->val, f->name))
goto floop_continue;
}
checked = 0;
if(c != nil)
if(c->tag == Ccheckboxtag)
checked = ((Ccheckbox*)c)->flags&CFactive;
if(checked) {
val = f->value;
if(f->ftype == Fradio)
radiodone = newstrlist(f->name, radiodone);
}
else
goto floop_continue;
break;
case Fhidden:
val = f->value;
break;
case Fsubmit:
if(submitctl != nil && f == submitctl->ff && Strcmp(f->name, L"_no_name_submit_"))
val = f->value;
else
goto floop_continue;
break;
case Fselect:
if(c != nil) {
assert(c->tag == Cselecttag);
cs = (Cselect*)c;
n = listlen((List*)cs->options);
for(i = 0; i < n; i++) {
if(cs->options[i].selected) {
if(sep != nil)
v = Strdup2(v, sep);
sep = L"&";
t = ucvt(f->name);
v = Strdup3(v, t, L"=");
t = ucvt(cs->options[i].value);
v = Strdup2(v, t);
}
}
goto floop_continue;
}
break;
case Fimage:
if(submitctl != nil && f == submitctl->ff) {
if(sep != nil)
v = Strdup2(v, sep);
sep = L"&";
z = Strdup2(f->name, L".x");
t = ucvt(z);
v = Strdup3(v, t, L"=");
z = ltoStr(max(p.x, 0));
t = ucvt(z);
v = Strdup3(v, t, sep);
z = Strdup2(f->name, L".y");
t = ucvt(z);
v = Strdup3(v, t, L"=");
z = ltoStr(max(p.y, 0));
t = ucvt(z);
v = Strdup2(v, t);
goto floop_continue;
}
break;
}
if(val != nil) {
if(sep != nil)
v = Strdup2(v, sep);
sep = L"&";
t = ucvt(f->name);
v = Strdup3(v, t, L"=");
if(val != nil) {
t = ucvt(val);
v = Strdup2(v, t);
}
}
floop_continue:
;
}
floop_done:
if(frm->method == HPost)
return newpost(copyurl(frm->action), v, frm->target);
else {
action = makequeryurl(frm->action, v);
return newget(action, frm->target);
}
}
static Rune*
ucvt(Rune* s)
{
Rune* u;
int i;
int c;
int n;
int j;
int len;
n = Strlen(s);
len = 0;
for(i = 0; i < n; i++) {
c = s[i];
if(inclass(c, L"- /$_@.!*'(),a-zA-Z0-9"))
len++;
else
len += 3;
}
u = newstr(len);
j = 0;
for(i = 0; i < n; i++) {
c = s[i];
if(inclass(c, L"-/$_@.!*'(),a-zA-Z0-9"))
u[j++] = c;
else if(c == ' ')
u[j++] = '+';
else {
u[j++] = '%';
u[j++] = hexdigit((c >> 4)&15);
u[j++] = hexdigit(c&15);
}
}
u[j] = 0;
return u;
}
static int
hexdigit(int v)
{
if(0 <= v && v <= 9)
return '0' + v;
else
return 'A' + v - 10;
}
static void
form_reset(Frame* fr, Form* frm)
{
Formfield* a;
for(a = frm->fields; a != nil; a = a->next) {
if(a->ctlid >= 0)
resetctl(fr->controls[a->ctlid]);
}
flushimage(display, 1);
}
static GoSpec*
formaction(int frameid, int formid, int ftype)
{
Frame* f;
Form* frm;
Docinfo* d;
trace("formaction %d %d %d\n", frameid, formid, ftype);
f = findframe(top, frameid);
if(f != nil) {
d = f->doc;
if(d != nil) {
for(frm = d->forms; frm != nil; frm = frm->next) {
if(frm->formid == formid) {
if(ftype == EFsubmit) {
return form_submit(f, frm, Pt(0, 0), nil);
}
else {
form_reset(f, frm);
return nil;
}
}
}
}
}
return nil;
}
// Find hit in a local map.
// If found, return action url, and target frame in *ptarget.
static ParsedUrl*
findhit(Map* map, Point p, int w, int h, int* ptarget)
{
int x;
int y;
ParsedUrl* dflt;
int dflttarg;
int xd;
int yd;
double xi;
double yi;
double xj;
double yj;
int np;
double xr;
double yr;
int j;
int i;
Area *a;
Dimen* c;
int nc;
int x1;
int y1;
int x2;
int y2;
int hit;
x = p.x;
y = p.y;
dflt = nil;
dflttarg = FTself;
for(a = map->areas; a != nil; a = a->next) {
c = a->coords;
nc = a->ncoords;
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;
switch(a->shape) {
case SHrect:
if(nc == 4)
hit = x1 <= x && x <= x2 && y1 <= y && y <= y2;
break;
case SHcircle:
if(nc == 3) {
xd = x - x1;
yd = y - y1;
hit = xd*xd + yd*yd <= x2*x2;
}
break;
case SHpoly:
np = nc/2;
hit = 0;
xr = (double)x;
yr = (double)y;
j = np - 1;
for(i = 0; i < np; j = i++) {
xi = (double)d2pix(c[2*i], w);
yi = (double)d2pix(c[2*i + 1], h);
xj = (double)d2pix(c[2*j], w);
yj = (double)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;
}
break;
default:
dflt = a->href;
dflttarg = a->target;
}
if(hit) {
*ptarget = a->target;
return copyurl(a->href);
}
}
*ptarget = dflttarg;
return copyurl(dflt);
}
static int
d2pix(Dimen d, int tot)
{
int ans;
ans = dimenspec(d);
if(dimenkind(d) == Dpercent)
ans = (ans*tot)/100;
return ans;
}
static GoSpec*
newget(ParsedUrl* url, int target)
{
GoSpec* g;
g = (GoSpec*)emallocz(sizeof(GoSpec));
g->kind = GoNormal;
g->url = url;
g->meth = HGet;
g->target = target;
return g;
}
static GoSpec*
newpost(ParsedUrl* url, Rune* body, int target)
{
GoSpec* g;
g = (GoSpec*)emallocz(sizeof(GoSpec));
g->kind = GoNormal;
g->url = url;
g->meth = HPost;
g->body = body;
g->target = target;
return g;
}
static GoSpec*
newspecial(int kind, HistNode* hn)
{
GoSpec* g;
g = (GoSpec*)emallocz(sizeof(GoSpec));
g->kind = kind;
g->histnode = hn;
return g;
}
static GoSpec*
copygospec(GoSpec* g)
{
GoSpec* ans;
ans = (GoSpec*)emalloc(sizeof(GoSpec));
ans->kind = g->kind;
ans->url = copyurl(g->url);
ans->meth = g->meth;
ans->body = Strdup(g->body);
ans->auth = g->auth;
ans->histnode = g->histnode;
return ans;
}
static int
gospecequal(GoSpec* a, GoSpec* b)
{
if(a->url == nil || b->url == nil)
return 0;
return urlequal(a->url, b->url) && a->meth == b->meth && !Strcmp(a->body, b->body);
}
static DocConfig*
newdocconfig(Rune* fname, Rune* title, int initconfig, GoSpec* g)
{
DocConfig* d;
d = (DocConfig*)emalloc(sizeof(DocConfig));
d->framename = fname;
d->title = title;
d->initconfig = initconfig;
d->gospec = g;
return d;
}
static DocConfig*
copydocconfig(DocConfig* d)
{
DocConfig* ans;
ans = (DocConfig*)emalloc(sizeof(DocConfig));
ans->framename = d->framename;
ans->title = d->title;
ans->initconfig = d->initconfig;
ans->gospec = d->gospec;
return ans;
}
static int
docconfigequal(DocConfig* a, DocConfig* b)
{
return !Strcmp(a->framename, b->framename) && gospecequal(a->gospec, b->gospec);
}
static int
docconfigequalarray(DocConfig** a1, int n1, DocConfig** a2, int n2)
{
int i;
if(n1 != n2)
return 0;
for(i = 0; i < n1; i++) {
if(a1[i] == nil || a2[i] == nil)
continue;
if(!docconfigequal((a1[i]), a2[i]))
return 0;
}
return 1;
}
static HistNode_list*
newhistnodelist(HistNode* hn, HistNode_list* l)
{
HistNode_list* ans;
ans = (HistNode_list*)emalloc(sizeof(HistNode_list));
ans->histnode = hn;
ans->next = l;
return ans;
}
// 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.
static void
histaddedge(HistNode* a, HistNode* b, int atob)
{
HistNode_list* oldl;
int there;
HistNode_list* l;
HistNode_list* newl;
if(atob)
oldl = a->succs;
else
oldl = a->preds;
there = 0;
for(l = oldl; l != nil; l = l->next)
if(l->histnode == b) {
there = 1;
break;
}
if(there)
newl = newhistnodelist(b, remhnode(oldl, b));
else
newl = newhistnodelist(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).
static HistNode_list*
remhnode(HistNode_list* l, HistNode* hn)
{
HistNode* hdl;
HistNode_list* ans;
if(l == nil)
return nil;
hdl = l->histnode;
if(hdl == hn) {
ans = l->next;
return ans;
}
return newhistnodelist(hdl, remhnode(l->next, hn));
}
static HistNode*
newhistnode(DocConfig* top, DocConfig** kids, int nkids,
HistNode_list* preds, HistNode_list* succs)
{
HistNode* h;
h = (HistNode*)emalloc(sizeof(HistNode));
h->topconfig = top;
h->kidconfigs = kids;
h->nkids = nkids;
h->preds = preds;
h->succs = succs;
return h;
}
// Copy of a, with new kidconfigs array (so that it can be changed independent
// of a), and clear the preds and succs.
static HistNode*
histnodecopy(HistNode* a)
{
int n;
DocConfig** kc;
int i;
n = a->nkids;
kc = nil;
if(n > 0) {
kc = (DocConfig**)emalloc(n * sizeof(DocConfig*));
for(i = 0; i < n; i++)
kc[i] = copydocconfig(a->kidconfigs[i]);
}
return newhistnode(a->topconfig, kc, n, nil, 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.
// In any case reorder the history array to put latest last in array.
static void
histadd(Frame* f, GoSpec* g, int navkind)
{
HistNode* oldcur;
DocConfig* dc;
HistNode* hnode;
int hnodepos;
int i;
DocConfig* kc;
int kidpos;
int k;
if(history.hlen <= history.n) {
history.hlen += 20;
history.h = (HistNode**)erealloc(history.h, history.hlen * sizeof(HistNode*));
}
if(history.n > 0)
oldcur = history.h[history.n - 1];
else
oldcur = nil;
dc = newdocconfig(Strdup(f->name), Strdup(g->url->url), navkind != GoHistnode, copygospec(g));
hnode = newhistnode(dc, nil, 0, nil, nil);
if(f == top)
g->target = FTtop;
else if(oldcur != nil) {
kidpos = -1;
for(i = 0; i < oldcur->nkids; i++) {
kc = oldcur->kidconfigs[i];
if(kc != nil && !Strcmp(kc->framename, f->name)) {
kidpos = i;
break;
}
}
if(kidpos == -1) {
if(dbg)
trace("history botch\n");
}
else {
hnode = histnodecopy(oldcur);
hnode->kidconfigs[kidpos] = dc;
}
}
// see if equivalent node to hnode is already in history
hnodepos = -1;
for(i = 0; i < history.n; i++) {
if(docconfigequal(hnode->topconfig, history.h[i]->topconfig)) {
if((hnode->kidconfigs == nil && history.h[i]->topconfig->initconfig)
|| docconfigequalarray(hnode->kidconfigs, hnode->nkids,
history.h[i]->kidconfigs, history.h[i]->nkids)) {
hnodepos = i;
hnode = history.h[i];
break;
}
}
}
if(hnodepos == -1) {
hnodepos = history.n;
history.h[history.n++] = hnode;
}
if(oldcur != nil && hnode != oldcur && navkind != GoHistnode) {
histaddedge(oldcur, hnode, 1);
histaddedge(hnode, oldcur, 0);
}
if(hnodepos != history.n - 1) {
for(k = hnodepos; k < history.n - 1; k++)
history.h[k] = history.h[k + 1];
history.h[history.n - 1] = hnode;
}
if(hnode->preds != nil)
enable(ctllay.controls[CLCbackbut]);
else
disable(ctllay.controls[CLCbackbut]);
if(hnode->succs != nil)
enable(ctllay.controls[CLCfwdbut]);
else
disable(ctllay.controls[CLCfwdbut]);
}
// This is called just after layout of f.
// Now we can put in correct doctitle, and make kids array if necessary.
static void
histupdate(Frame* f)
{
HistNode* hnode;
Framelist* kl;
Frame* kf;
DocConfig** kc;
DocConfig* dc;
int i;
hnode = history.h[history.n - 1];
if(f == top) {
hnode->topconfig->title = Strdup(f->doc->doctitle);
if(f->kids != nil && hnode->kidconfigs == nil) {
kc = (DocConfig**)emalloc(listlen((List*)f->kids) * sizeof(DocConfig*));
i = 0;
for(kl = f->kids; kl != nil; kl = kl->next) {
kf = kl->val;
if(kf->src != nil)
kc[i] = newdocconfig(Strdup(kf->name), Strdup(kf->src->url), 1,
newget(copyurl(kf->src), FTself));
i++;
}
hnode->kidconfigs = kc;
}
}
else {
for(i = 0; i < hnode->nkids; i++) {
dc = hnode->kidconfigs[i];
if(dc != nil && !Strcmp(dc->framename, f->name)) {
hnode->kidconfigs[i]->title = Strdup(f->doc->doctitle);
return;
}
}
if(dbg)
trace("history update botch\n");
}
}
// Find the gokind node (-1==Back, 0==Same, +1==Forward)
static HistNode*
histfind(int gokind)
{
HistNode* cur;
if(history.n > 0) {
cur = history.h[history.n - 1];
switch(gokind) {
case 1:
if(cur->succs != nil)
return cur->succs->histnode;
break;
case -1:
if(cur->preds != nil)
return cur->preds->histnode;
break;
case 0:
return cur;
break;
}
}
return nil;
}
// for debugging
static void
histprint(void)
{
int i;
int j;
HistNode* hn;
DocConfig* dc;
trace("History\n");
for(i = 0; i < history.n; i++) {
hn = history.h[i];
trace("Node %d:\n", i);
dc = hn->topconfig;
trace("\tframe=%S, target=%S, url=%U\n",
dc->framename, targetname(dc->gospec->target), dc->gospec->url);
if(hn->kidconfigs != nil) {
for(j = 0; j < hn->nkids; j++) {
dc = hn->kidconfigs[j];
if(dc != nil)
trace("\t\t%d: frame=%S, target=%S, url=%U\n",
j, dc->framename, targetname(dc->gospec->target), dc->gospec->url);
}
}
if(hn->preds != nil)
printhnodeindices("Preds", hn->preds);
if(hn->succs != nil)
printhnodeindices("Succs", hn->succs);
}
trace("\n");
}
static void
printhnodeindices(char* label, HistNode_list* l)
{
HistNode* hn;
int i;
trace("\t%s:", label);
for(; l != nil; l = l->next) {
hn = l->histnode;
for(i = 0; i < history.n; i++) {
if(hn == history.h[i]) {
trace(" %d", i);
break;
}
}
if(i == history.n)
trace(" ?");
}
trace("\n");
}
// Create HTML representation of history in "history.html" in user's config directory.
// This is called from go thread group.
static void
dumphistory(void)
{
// TODO
/*
Rune* fname;
FD* fd;
Rune* line;
uchar* buf;
uchar* aline;
int bufpos;
int i;
int j;
int n;
int nl;
HistNode* hn;
DocConfig* dc;
char buf[ATOMICIO];
snprint(buf, sizeof(buf),
fname = Strdup2(config.userdir, L"/history.html", 0);
fd = create(fname, OWRITE, 384);
if(fd == nil) {
if(warn)
trace("can't create history file\n");
return ;
}
line = L"<HEAD> <TITLE>History</TITLE></HEAD>\n<BODY>\n";
nl = Strlen(line);
buf = (uchar*)emalloc(ATOMICIO * sizeof(uchar), 0);
n = 0;
aline = fromStr(line, nl, UTF_8, 0);
memmove(buf, aline, nl);
bufpos = nl;
for(i = history->n - 1; i >= 0; i--) {
hn = history->h[i];
dc = hn->topconfig;
line = Strdup2(Strdup2(Strdup2(Strdup2(L"<A HREF=", tostring(dc->gospec->url)), L" TARGET=\"_top\">"), dc->title), L"</A><BR>\n");
if(hn->kidconfigs != nil) {
Stradd(line, L"<UL>", FIXME);
for(j = 0; j < arraylen(hn->kidconfigs); j++) {
dc = hn->kidconfigs[j];
if(dc != nil) {
Stradd(line, Strdup2(Strdup2(Strdup2(Strdup2(Strdup2(Strdup2(L"<LI><A HREF=", tostring(dc->gospec->url)), L" TARGET=\""), dc->framename), L"\">"), dc->title), L"</A>\n"), FIXME);
}
}
Stradd(line, L"</UL>", FIXME);
}
aline = fromStr(line, arraylen(line), UTF_8);
if(bufpos + arraylen(aline) > ATOMICIO) {
write(fd, buf, bufpos);
bufpos = 0;
}
buf[bufpos:...] = aline;
bufpos += arraylen(aline);
}
if(bufpos > 0)
write(fd, buf, bufpos);
*/
}
static void
freectls(Control** a, int n)
{
// TODO: free the memory
USED(a);
USED(n);
}
static AuthInfo*
getauth(Rune* chal)
{
// TODO
USED(chal);
return nil;
/*
Rune* realm;
AuthInfop_list* al;
int code;
Rune* ans;
AuthInfo* a;
if(Strcmp(tolower(chal[0:12]), L"basic realm=")) {
if(dbg || warn)
trace("unrecognized authorization challenge: %s\n", chal);
return makeRunepRunep_pair(L"", L"");
}
realm = chal[12:];
if(realm[0] == 34)
realm = realm[1:arraylen(realm) - 1];
for(al = auths; al != nil; al = al->tl) {
a = al->hd;
if(!Strcmp(realm, a->realm))
return makeRunepRunep_pair(realm, a->credentials);
}
dopopup(PopupAuth, realm);
tmp_24 = (recv(popupans, &tmp_25);
code = tmp_24.t0;
ans = tmp_24.t1;
if(code == -1)
trace("couldn't create popup window\n");
else if(code == 1)
ans = tobase64(ans);
return makeRunepRunep_pair(realm, ans);
*/
}
static Rune*
tobase64(Rune* a)
{
int n;
int nout;
Rune* out;
int j;
int i;
int nmod3;
int x;
n = Strlen(a);
if(n == 0)
return nil;
j = 0;
i = 0;
nout = n*4;
out = newstr(nout);
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);
}
out[j] = 0;
nmod3 = n%3;
if(nmod3 != 0) {
out[j - 1] = 61;
if(nmod3 == 1)
out[j - 2] = 61;
}
return out;
}
static int
c64(int c)
{
static Rune* v = L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
return v[c&63];
}
static void
dosaveas(ByteSource* bsmain)
{
// TODO
/*
int code;
Rune* ans;
ByteSource* bs;
int n;
int i;
Rune* err;
int flen;
FD* fd;
dopopup(PopupSaveAs, L"");
tmp_26 = (recv(popupans, &tmp_27);
code = tmp_26.t0;
ans = tmp_26.t1;
if(code == -1)
trace("couldn't create popup window\n");
else if(code == 1 && ans != nil) {
if(ans[0] != 47)
ans = Strdup2(Strdup2(config.userdir, L"/"), ans);
fd = create(ans, OWRITE, 420);
if(fd == nil) {
dopopup(PopupAlert, Strdup2(L"Couldn't create ", ans));
tmp_28 =(recv(popupans, &tmp_29);
}
else {
showstatus(Strdup2(L"Saving ", tostring(bsmain->hdr->actual)), 1);
err = L"";
flen = bsmain->hdr->length;
while(bsmain->edata < flen) {
bs = waitreq();
if(bs->refgo == 0)
continue;
assert(bs == bsmain);
if(bs->err != nil) {
err = bs->err;
break;
}
}
if(err == nil) {
i = 0;
while(i < flen) {
n = write(fd, bsmain->data[slice i, flen], flen - i);
if(n <= 0)
break;
i += n;
}
if(i != flen)
err = L"whole file not written";
}
if(err != nil)
dopopup(PopupAlert, err);
else
dopopup(PopupAlert, Strdup2(L"Created ", ans));
tmp_30 = (recv(popupans, &tmp_31);
}
}
*/
freebs(bsmain);
}
static void
handleprogress(EV ev)
{
int i;
Cprogbox* pb;
int bsid;
int state;
int pcnt;
Rune* s;
bsid = ev.u.progress.bsid;
state = ev.u.progress.state;
pcnt = ev.u.progress.pcnt;
s = ev.u.progress.s;
if(bsid == -1) {
for(i = 0; i < proglay.nused; i++) {
pb = (Cprogbox*)proglay.box[i];
pb->state = Punused;
pb->pcnt = 0;
pb->bsid = -1;
pb->src = nil;
pb->err = nil;
}
proglay.nused = 0;
redrawprog(0);
}
else {
if(state == Pstart) {
if(proglay.nused < proglay.boxlen) {
i = proglay.nused;
proglay.nused++;
}
else
i = 0;
pb = (Cprogbox*)proglay.box[i];
pb->state = state;
pb->bsid = bsid;
pb->src = s;
}
else {
for(i = 0; i < proglay.nused; i++) {
pb = (Cprogbox*)proglay.box[i];
if(pb->bsid == bsid)
break;
}
if(i == proglay.nused)
return;
pb = (Cprogbox*)proglay.box[i];
if(pb->state != Perr) {
pb->state = state;
pb->pcnt = pcnt;
pb->err = s;
}
}
drawctl(proglay.box[i], 1);
}
}
static void
showstatus(Rune* msg)
{
Rune* ostatus;
Point p;
Point sp;
ostatus = ctllay.status;
p = ctllay.statuspos;
pushclipr(ctlframe->cr);
if(ostatus != nil && Strcmp(ostatus, msg)) {
sp = measurestring(ostatus);
drawfill(screen, Rpt(p, addpt(p, sp)), Grey);
}
ctllay.status = Strdup(msg);
drawstring(screen, p, msg);
popclipr();
flushimage(display, 1);
}
// Run as separate proc to put up alert popup
static void
alert(void* arg)
{
Rune* msg;
Channel* sync;
PopupAns ans;
void** args;
meminit(GRalert);
args = (void**)arg;
msg = (Rune*)args[0];
sync = (Channel*)args[1];
dopopup(PopupAlert, msg);
if(recv(popupans, &ans) < 0)
finish();
if(sendul(sync, 1) < 0)
finish();
}
static void
showurl(Rune* u)
{
entryset(ctllay.controls[CLCentry], Strdup(u));
}
void
fatalerror(char* msg)
{
trace("Fatal error: %s\n", msg);
finish();
}
void
trace(char* fmt, ...)
{
va_list arg;
va_start(arg, fmt);
vfprint(1, fmt, arg);
va_end(arg);
}
void
finish(void)
{
if(dbg)
trace("finish called\n");
threadexitsall("");
}
|
