xref: /plan9/sys/src/cmd/abaco/util.c (revision 58da3067adcdccaaa043d0bfde28ba83b7ced07d) 
1 #include <u.h>
2 #include <libc.h>
3 #include <bio.h>
4 #include <draw.h>
5 #include <memdraw.h>
6 #include <thread.h>
7 #include <cursor.h>
8 #include <mouse.h>
9 #include <keyboard.h>
10 #include <frame.h>
11 #include <plumb.h>
12 #include <html.h>
13 #include <regexp.h>
14 #include "dat.h"
15 #include "fns.h"
16 
17 static	Point		prevmouse;
18 static	Window	*mousew;
19 
20 int
21 min(int a, int b)
22 {
23 	if(a < b)
24 		return a;
25 	return b;
26 }
27 
28 int
29 max(int a, int b)
30 {
31 	if(a > b)
32 		return a;
33 	return b;
34 }
35 
36 void
37 cvttorunes(char *p, int n, Rune *r, int *nb, int *nr, int *nulls)
38 {
39 	uchar *q;
40 	Rune *s;
41 	int j, w;
42 
43 	/*
44 	 * Always guaranteed that n bytes may be interpreted
45 	 * without worrying about partial runes.  This may mean
46 	 * reading up to UTFmax-1 more bytes than n; the caller
47 	 * knows this.  If n is a firm limit, the caller should
48 	 * set p[n] = 0.
49 	 */
50 	q = (uchar*)p;
51 	s = r;
52 	for(j=0; j<n; j+=w){
53 		if(*q < Runeself){
54 			w = 1;
55 			*s = *q++;
56 		}else{
57 			w = chartorune(s, (char*)q);
58 			q += w;
59 		}
60 		if(*s)
61 			s++;
62 		else if(nulls)
63 			*nulls = TRUE;
64 	}
65 	*nb = (char*)q-p;
66 	*nr = s-r;
67 }
68 
69 void
70 bytetorunestr(char *s, Runestr *rs)
71 {
72 	Rune *r;
73 	int nb, nr;
74 
75 	nb = strlen(s);
76 	r = runemalloc(nb+1);
77 	cvttorunes(s, nb, r, &nb, &nr, nil);
78 	r[nr] = '\0';
79 	rs->nr = nr;
80 	rs->r = r;
81 }
82 
83 void
84 error(char *s)
85 {
86 	fprint(2, "abaco: %s: %r\n", s);
87 //	abort();
88 	threadexitsall(s);
89 }
90 
91 void*
92 emalloc(ulong n)
93 {
94 	void *p;
95 
96 	p = malloc(n);
97 	if(p == nil)
98 		error("malloc failed");
99 	setmalloctag(p, getcallerpc(&n));
100 	memset(p, 0, n);
101 	return p;
102 }
103 
104 void*
105 erealloc(void *p, ulong n)
106 {
107 	p = realloc(p, n);
108 	if(p == nil)
109 		error("realloc failed");
110 	setmalloctag(p, getcallerpc(&n));
111 	return p;
112 }
113 
114 Rune*
115 erunestrdup(Rune *r)
116 {
117 	void *p;
118 
119 	if(r == nil)
120 		return nil;
121 	p = runestrdup(r);
122 	if(p == nil)
123 		error("runestrdup failed");
124 	setmalloctag(p, getcallerpc(&r));
125 	return p;
126 }
127 
128 char*
129 estrdup(char *s)
130 {
131 	char *t;
132 
133 	t = strdup(s);
134 	if(t == nil)
135 		error("strdup failed");
136 	setmalloctag(t, getcallerpc(&s));
137 	return t;
138 }
139 
140 int
141 runestreq(Runestr a, Runestr b)
142 {
143 	return runeeq(a.r, a.nr, b.r, b.nr);
144 }
145 
146 int
147 runeeq(Rune *s1, uint n1, Rune *s2, uint n2)
148 {
149 	if(n1 != n2)
150 		return FALSE;
151 	return memcmp(s1, s2, n1*sizeof(Rune)) == 0;
152 }
153 
154 void
155 closerunestr(Runestr *rs)
156 {
157 
158 	rs->nr = 0;
159 	if(rs->r)
160 		free(rs->r);
161 	rs->r = nil;
162 }
163 
164 void
165 copyrunestr(Runestr *a, Runestr *b)
166 {
167 	closerunestr(a);
168 	a->r = runemalloc(b->nr+1);
169 	runemove(a->r, b->r, b->nr);
170 	a->r[b->nr] = 0;
171 	a->nr = b->nr;
172 }
173 
174 int
175 isalnum(Rune c)
176 {
177 	/*
178 	 * Hard to get absolutely right.  Use what we know about ASCII
179 	 * and assume anything above the Latin control characters is
180 	 * potentially an alphanumeric.
181 	 */
182 	if(c <= ' ')
183 		return FALSE;
184 	if(0x7F<=c && c<=0xA0)
185 		return FALSE;
186 	if(utfrune("!\"#$%&'()*+,-./:;<=>?@[\\]^`{|}~", c))
187 		return FALSE;
188 	return TRUE;
189 }
190 
191 Rune*
192 skipbl(Rune *r, int n, int *np)
193 {
194 	while(n>0 && (*r==' ' || *r=='\t' || *r=='\n')){
195 		--n;
196 		r++;
197 	}
198 	*np = n;
199 	return r;
200 }
201 
202 Rune*
203 findbl(Rune *r, int n, int *np)
204 {
205 	while(n>0 && *r!=' ' && *r!='\t' && *r!='\n'){
206 		--n;
207 		r++;
208 	}
209 	*np = n;
210 	return r;
211 }
212 
213 int
214 istextfield(Item *i)
215 {
216 	Formfield *ff;
217 
218 	ff = ((Iformfield *)i)->formfield;
219 	if(ff->ftype==Ftext || ff->ftype==Ftextarea || ff->ftype==Fpassword)
220 		return TRUE;
221 
222 	return FALSE;
223 }
224 
225 int
226 forceitem(Item *i)
227 {
228 	if(i->state&IFwrap && i->tag!=Iruletag && i->tag!=Itabletag)
229 		return FALSE;
230 
231 	return TRUE;
232 }
233 
234 int
235 dimwidth(Dimen d, int w)
236 {
237 	int s, k;
238 
239 	k = dimenkind(d);
240 	if(k == Dnone)
241 		return w;
242 	s = dimenspec(d);
243 	if(k == Dpixels)
244 		 w = s;
245 	else if(k==Dpercent && s<100)
246 		w = s*w/100;
247 
248 	return w;
249 }
250 
251 void
252 frdims(Dimen *d, int n, int t, int **ret)
253 {
254 	int totpix, totpcnt, totrel;
255 	double spix, spcnt, relu, vd;
256 	int tt, trest, totpixrel, minrelu, i;
257 	int *x, *spec, *kind;
258 
259 	if(n == 1){
260 		*ret = x = emalloc(sizeof(int));
261 		x[0] = t;
262 		return;
263 	}
264 	totpix = totpcnt = totrel = 0;
265 	spec = emalloc(n*sizeof(int));
266 	kind = emalloc(n*sizeof(int));
267 	for(i=0; i<n; i++){
268 		spec[i] = dimenspec(d[i]);
269 		if(spec[i] < 0)
270 			spec[i] = 0;
271 		kind[i] = dimenkind(d[i]);
272 		switch(kind[i]){
273 		case Dpixels:
274 			totpix += spec[i];
275 			break;
276 		case Dpercent:
277 			totpcnt += spec[i];
278 			break;
279 		case Drelative:
280 			totrel += spec[i];
281 			break;
282 		case Dnone:
283 			totrel++;
284 			break;
285 		}
286 	}
287 	spix = spcnt = 1.0;
288 	minrelu = 0;
289 	if(totrel > 0)
290 		minrelu = Scrollsize+Scrollgap;
291 	relu = (double)minrelu;
292 	tt = totpix + t*totpcnt/100 + totrel*minrelu;
293 	if(tt < t){
294 		if(totrel == 0){
295 			if(totpcnt != 0)
296 				spcnt = (double)((t-totpix)*100)/(double)(t*totpcnt);
297 			else
298 				spix = (double)t/(double)totpix;
299 		}else
300 			relu += (double)(t-tt)/(double)totrel;
301 	}else{
302 		totpixrel = totpix + totrel*minrelu;
303 		if(totpixrel < t)
304 			spcnt = (double)((t-totpixrel)*100)/(double)(t*totpcnt);
305 		else{
306 			trest = t - totrel*minrelu;
307 			if(trest > 0)
308 				spcnt = (double)trest/(double)(totpix + (t*totpcnt/100));
309 			else{
310 				spcnt = (double)t/(double)tt;
311 				relu = 0.0;
312 			}
313 			spix = spcnt;
314 		}
315 	}
316 	x = emalloc(n * sizeof(int));
317 	tt = 0;
318 	for(i=0; i<n-1; i++){
319 		vd = (double)spec[i];
320 		switch(kind[i]){
321 		case Dpixels:
322 			vd = vd*spix;
323 			break;
324 		case Dpercent:
325 			vd = vd*(double)t*spcnt/100.0;
326 			break;
327 		case Drelative:
328 			vd = vd*relu;
329 			break;
330 		case Dnone:
331 			vd = relu;
332 			break;
333 		}
334 		x[i] = (int)(vd+.5);
335 		tt += x[i];
336 	}
337 	x[n - 1] = t - tt;
338 	*ret = x;
339 	free(spec);
340 	free(kind);
341 }
342 
343 Image *
344 getbg(Page *p)
345 {
346 	Docinfo *d;
347 	Cimage *ci;
348 	Image *bg;
349 
350 	d = p->doc;
351 	if(d->backgrounditem){
352 		if(d->backgrounditem->aux){
353 			ci = d->backgrounditem->aux;
354 			if(ci->mi)
355 				getimage(ci, d->backgrounditem->altrep);
356 			bg = ci->i;
357 		}else
358 			bg = display->white;
359 	}else
360 		bg = getcolor(d->background.color);
361 
362 	return bg;
363 }
364 
365 Rune *
366 getbase(Page *p)
367 {
368 	if(p->doc)
369 		return p->doc->base;
370 	if(p->url->act.r)
371 		return p->url->act.r;
372 	return p->url->src.r;
373 }
374 
375 Image *
376 eallocimage(Display *d, Rectangle r, ulong chan, int repl, int col)
377 {
378 	Image *i;
379 
380 	i = allocimage(d, r, chan, repl, col);
381 	if(i == nil)
382 		error("allocimage failed");
383 	return i;
384 }
385 
386 void
387 rect3d(Image *im, Rectangle r, int i, Image **c, Point sp)
388 {
389 	Point p[6];
390 
391 	if(i < 0){
392 		r = insetrect(r, i);
393 		sp = addpt(sp, Pt(i,i));
394 		i = -i;
395 	}
396 	draw(im, Rect(r.min.x+i, r.min.y+i, r.max.x-i, r.max.y-i), c[2], nil, sp);
397 	p[0] = r.min;
398 	p[1] = Pt(r.min.x, r.max.y);
399 	p[2] = Pt(r.min.x+i, r.max.y-i);
400 	p[3] = Pt(r.min.x+i, r.min.y+i);
401 	p[4] = Pt(r.max.x-i, r.min.y+i);
402 	p[5] = Pt(r.max.x, r.min.y);
403 	fillpoly(im, p, 6, 0, c[0], sp);
404 	p[0] = r.max;
405 	p[1] = Pt(r.min.x, r.max.y);
406 	p[2] = Pt(r.min.x+i, r.max.y-i);
407 	p[3] = Pt(r.max.x-i, r.max.y-i);
408 	p[4] = Pt(r.max.x-i, r.min.y+i);
409 	p[5] = Pt(r.max.x, r.min.y);
410 	fillpoly(im, p, 6, 0, c[1], sp);
411 }
412 
413 void
414 ellipse3d(Image *im, Point p, int rad, int i, Image **c, Point sp)
415 {
416 	fillarc(im, p, rad, rad, c[0], sp, 45, 180);
417 	fillarc(im, p, rad, rad, c[1], sp,  45, -180);
418 	fillellipse(im, p, rad-i, rad-i, c[2], sp);
419 }
420 
421 void
422 colarray(Image **c, Image *c0, Image *c1, Image *c2, int checked)
423 {
424 	if(checked){
425 		c[0] = c0;
426 		c[1] = c1;
427 	}else{
428 		c[0] = c1;
429 		c[1] = c0;
430 	}
431 	c[2] = c2;
432 }
433 
434 static char *deffontpaths[] = {
435 #include "fonts.h"
436 };
437 
438 static char *fontpaths[NumFnt];
439 static Font *fonts[NumFnt];
440 
441 void
442 initfontpaths(void)
443 {
444 	Biobufhdr *bp;
445 	char buf[128];
446 	int i;
447 
448 	/* we don't care if getenv(2) fails */
449 	snprint(buf, sizeof(buf)-1, "%s/lib/abaco.fonts", getenv("home"));
450 	if((bp=Bopen(buf, OREAD)) == nil)
451 		goto Default;
452 
453 	for(i=0; i<NumFnt; i++)
454 		if((fontpaths[i]=Brdstr(bp, '\n', 1)) == nil)
455 			goto Error;
456 
457 	Bterm(bp);
458 	return;
459 Error:
460 	fprint(2, "abaco: not enough fontpaths in '%s'\n", buf);
461 	Bterm(bp);
462 	for(i--; i>=0; i--)
463 		free(fontpaths[i]);
464 Default:
465 	for(i=0; i<NumFnt; i++)
466 		fontpaths[i] = deffontpaths[i];
467 }
468 
469 Font *
470 getfont(int i)
471 {
472 	if(fonts[i] == nil){
473 		fonts[i] = openfont(display, fontpaths[i]);
474 		if(fonts[i] == nil)
475 			error("can't open font file");
476 	}
477 	return fonts[i];
478 }
479 
480 typedef struct Color Color;
481 
482 struct Color {
483 	int	rgb;
484 	Image	*i;
485 	Color	*next;
486 };
487 
488 enum {
489 	NHASH = 19,
490 };
491 
492 static Color *colortab[NHASH];
493 
494 Image *
495 getcolor(int rgb)
496 {
497 	Color *c;
498 	int h;
499 
500 	if(rgb == 0xFFFFFF)
501 		return display->white;
502 	else if(rgb == 0x000000)
503 		return display->black;
504 
505 	h = rgb%NHASH;
506 	for(c=colortab[h]; c!=nil; c=c->next)
507 		if(c->rgb == rgb){
508 			flushimage(display, 0);	/* BUG? */
509 			return c->i;
510 		}
511 	c = emalloc(sizeof(Color));
512 	c->i = eallocimage(display, Rect(0,0,1,1), screen->chan, 1, (rgb<<8)|0xFF);
513 	c->rgb = rgb;
514 	c->next = colortab[h];
515 	colortab[h] = c;
516 
517 	return c->i;
518 }
519 
520 int
521 plumbrunestr(Runestr *rs, char *attr)
522 {
523 	Plumbmsg *m;
524 	int i;
525 
526 	i = -1;
527 	if(plumbsendfd >= 0){
528 		m = emalloc(sizeof(Plumbmsg));
529 		m->src = estrdup("abaco");
530 		m->dst = nil;
531 		m->wdir = estrdup("/tmp");
532 		m->type = estrdup("text");
533 		if(attr)
534 			m->attr = plumbunpackattr(attr);
535 		else
536 			m->attr = nil;
537 		m->data = smprint("%.*S", rs->nr, rs->r);
538 		m->ndata = -1;
539 		i = plumbsend(plumbsendfd, m);
540 		plumbfree(m);
541 	}
542 	return i;
543 }
544 
545 int
546 hexdigit(int v)
547 {
548 	if(0<=v && v<=9)
549 		return '0' + v;
550 	else
551 		return 'A' + v - 10;
552 }
553 
554 static int
555 inclass(char c, Rune* cl)
556 {
557 	int n, ans, negate, i;
558 
559 	n = runestrlen(cl);
560 	if(n == 0)
561 		return 0;
562 	ans = 0;
563 	negate = 0;
564 	if(cl[0] == '^'){
565 		negate = 1;
566 		cl++;
567 		n--;
568 	}
569 	for(i=0; i<n; i++){
570 		if(cl[i]=='-' && i>0 && i<n-1){
571 			if(c>=cl[i - 1] && c<=cl[i+1]){
572 				ans = 1;
573 				break;
574 			}
575 			i++;
576 		}
577 		else if(c == cl[i]){
578 			ans = 1;
579 			break;
580 		}
581 	}
582 	if(negate)
583 		ans = !ans;
584 	return ans;
585 }
586 
587 Rune*
588 ucvt(Rune* s)
589 {
590 	Rune* u;
591 	char *t;
592 	int i, c, n, j, len;
593 
594 	t = smprint("%S", s);
595 	n = strlen(t);
596 	len = 0;
597 	for(i=0; i<n; i++){
598 		c = t[i];
599 		if(inclass(c, L"- /$_@.!*'(),a-zA-Z0-9"))
600 			len++;
601 		else
602 			len += 3;
603 	}
604 	u = runemalloc(len+1);
605 	j = 0;
606 
607 	for(i=0; i<n; i++){
608 		c = t[i];
609 		if(inclass(c, L"-/$_@.!*'(),a-zA-Z0-9"))
610 			u[j++] = c;
611 		else if(c == ' ')
612 			u[j++] = '+';
613 		else {
614 			u[j++] = '%';
615 			u[j++] = hexdigit((c >> 4)&15);
616 			u[j++] = hexdigit(c&15);
617 		}
618 	}
619 	u[j] = 0;
620 	free(t);
621 	return u;
622 }
623 
624 void
625 reverseimages(Iimage **head)
626 {
627 	Iimage *r, *c, *n;
628 
629 	r = nil;
630 	for(c=*head; c!=nil; c=n){
631 		n = c->nextimage;
632 		c->nextimage = r;
633 		r = c;
634 	}
635 	*head = r;
636 }
637 
638 char urlexpr[] = "^(https?|ftp|file|gopher|mailto|news|nntp|telnet|wais|"
639 	"prospero)://([a-zA-Z0-9_@\\-]+([.:][a-zA-Z0-9_@\\-]+)*)";
640 Reprog	*urlprog;
641 
642 int
643 validurl(Rune *r)
644 {
645 	Resub rs[10];
646 
647 	if(urlprog == nil){
648 		urlprog = regcomp(urlexpr);
649 		if(urlprog == nil)
650 			error("regcomp");
651 	}
652 	memset(rs, 0, sizeof(rs));
653 	if(rregexec(urlprog, r, rs, nelem(rs)) == 0)
654 		return FALSE;
655 	return TRUE;
656 }
657 
658 void
659 execproc(void *v)
660 {
661 	Channel *sync;
662 	Exec *e;
663 	int p[2], q[2];
664 	char *cmd;
665 
666 	threadsetname("execproc");
667 	e = v;
668 	p[0] = e->p[0];
669 	p[1] = e->p[1];
670 	q[0] = e->q[0];
671 	q[1] = e->q[1];
672 	cmd = e->cmd;
673 	sync = e->sync;
674 	rfork(RFFDG);
675 	free(e);
676 	dup(p[0], 0);
677 	close(p[0]);
678 	close(p[1]);
679 	if(q[0]){
680 		dup(q[1], 1);
681 		close(q[0]);
682 		close(q[1]);
683 	}
684 	if(!procstderr)
685 		close(2);
686 	procexecl(sync, "/bin/rc", "rc", "-c", cmd, 0);
687 	error("can't exec");
688 }
689 
690 static void
691 writeproc(void *v)
692 {
693 	Channel *sync;
694 	void **a;
695 	char *s;
696 	long np;
697 	int fd, i, n;
698 
699 	threadsetname("writeproc");
700 	a = v;
701 	sync = a[0];
702 	fd = (uintptr)a[1];
703 	s = a[2];
704 	np =(uintptr)a[3];
705 	free(a);
706 
707 	for(i=0; i<np; i+=n){
708 		n = np-i;
709 		if(n > BUFSIZE)
710 			n = BUFSIZE;
711 		if(write(fd, s+i, n) != n)
712 			break;
713 	}
714 	close(fd);
715 	sendul(sync, i);
716 }
717 
718 struct {
719 	char *mime;
720 	char *tcs;
721 }tcstab[] = {
722 
723 #include "tcs.h"
724 
725 	/* not generated by the script */
726 	"euc_jp", "jis",
727 	"euc_kr", "euc-k",
728 	"windows-874", "tis",
729 	nil,	nil,
730 };
731 
732 enum {
733 	Winstart = 127,
734 	Winend = 159
735 };
736 
737 static int winchars[] = {
738 	 8226,	/* 8226 is a bullet */
739 	8226, 8226, 8218, 402, 8222, 8230, 8224, 8225,
740 	710, 8240, 352, 8249, 338, 8226, 8226, 8226,
741 	8226, 8216, 8217, 8220, 8221, 8226, 8211, 8212,
742 	732, 8482, 353, 8250, 339, 8226, 8226, 376
743 };
744 
745 char *
746 tcs(char *cs, char *s, long *np)
747 {
748 	Channel *sync;
749 	Exec *e;
750 	Rune r;
751 	long i, n;
752 	void **a;
753 	uchar *us;
754 	char buf[BUFSIZE], cmd[50];
755 	char *t, *u;
756 	int p[2], q[2];
757 
758 
759 	if(s==nil || *s=='\0' || *np==0){
760 		werrstr("tcs failed: no data");
761 		return s;
762 	}
763 
764 	if(cs == nil){
765 		werrstr("tcs failed: no charset");
766 		return s;
767 	}
768 
769 	if(cistrncmp(cs, "utf-8", 5)==0 || cistrncmp(cs, "utf8", 4)==0)
770 		return s;
771 
772 	for(i=0; tcstab[i].mime!=nil; i++)
773 		if(cistrncmp(cs, tcstab[i].mime, strlen(tcstab[i].mime)) == 0)
774 			break;
775 
776 	if(tcstab[i].mime == nil){
777 		fprint(2, "abaco: charset: %s not supported\n", cs);
778 		goto latin1;
779 	}
780 	if(cistrcmp(tcstab[i].tcs, "8859-1")==0 || cistrcmp(tcstab[i].tcs, "ascii")==0){
781 latin1:
782 		n = 0;
783 		for(us=(uchar*)s; *us; us++)
784 			n += runelen(*us);
785 		n++;
786 		t = emalloc(n);
787 		for(us=(uchar*)s, u=t; *us; us++){
788 			if(*us>=Winstart && *us<=Winend)
789 				*u++ = winchars[*us-Winstart];
790 			else{
791 				r = *us;
792 				u += runetochar(u, &r);
793 			}
794 		}
795 		*u = 0;
796 		free(s);
797 		return t;
798 	}
799 
800 	if(pipe(p)<0 || pipe(q)<0)
801 		error("can't create pipe");
802 
803 	sync = chancreate(sizeof(ulong), 0);
804 	if(sync == nil)
805 		error("can't create channel");
806 
807 	snprint(cmd, sizeof cmd, "tcs -f %s", tcstab[i].tcs);
808 	e = emalloc(sizeof(Exec));
809 	e->p[0] = p[0];
810 	e->p[1] = p[1];
811 	e->q[0] = q[0];
812 	e->q[1] = q[1];
813 	e->cmd = cmd;
814 	e->sync = sync;
815 	proccreate(execproc, e, STACK);
816 	recvul(sync);
817 	chanfree(sync);
818 	close(p[0]);
819 	close(q[1]);
820 
821 	/* in case tcs fails */
822 	t = s;
823 	sync = chancreate(sizeof(ulong), 0);
824 	if(sync == nil)
825 		error("can't create channel");
826 
827 	a = emalloc(4*sizeof(void *));
828 	a[0] = sync;
829 	a[1] = (void *)p[1];
830 	a[2] = s;
831 	a[3] = (void *)*np;
832 	proccreate(writeproc, a, STACK);
833 
834 	s = nil;
835 	while((n = read(q[0], buf, sizeof(buf))) > 0){
836 		s = erealloc(s, i+n+1);
837 		memmove(s+i, buf, n);
838 		i += n;
839 		s[i] = '\0';
840 	}
841 	n = recvul(sync);
842 	if(n != *np)
843 		fprint(2, "tcs: did not write %ld; wrote %uld\n", *np, n);
844 
845 	*np = i;
846 	chanfree(sync);
847 	close(q[0]);
848 
849 	if(s == nil){
850 		fprint(2, "tcs failed: can't convert charset=%s to %s\n", cs, tcstab[i].tcs);
851 		return t;
852 	}
853 	free(t);
854 
855 	return s;
856 }
857 
858 static
859 int
860 isspace(char c)
861 {
862 	return c==' ' || c== '\t' || c=='\r' || c=='\n';
863 }
864 
865 static
866 int
867 findctype(char *b, int l, char *keyword, char *s)
868 {
869 	char *p, *e;
870 	int i;
871 
872 	p = cistrstr(s, keyword);
873 	if(!p)
874 		return -1;
875 	p += strlen(keyword);
876 	while(*p && isspace(*p))
877 		p++;
878 	if(*p != '=')
879 		return -1;
880 	p++;
881 	while(*p && isspace(*p))
882 		p++;
883 	if(!*p)
884 		return -1;
885 	if(*p == '"'){
886 		p++;
887 		e = strchr(p, '"');
888 		if(!e)
889 			return -1;
890 	}else
891 		for(e = p; *e < 127 && *e > ' ' ; e++)
892 			;
893 	i = e-p;
894 	if(i < 1)
895 		return -1;
896 	snprint(b, l, "%.*s", i, p);
897 	return 0;
898 }
899 
900 static
901 int
902 finddocctype(char *b, int l, char *s)
903 {
904 	char *p, *e;
905 
906 	p = cistrstr(s, "<meta");
907 	if(!p)
908 		return -1;
909 	p += 5;
910 	e = strchr(s, '>');
911 	if(!e)
912 		return -1;
913 	snprint(b, l, "%.*s", (int)(e-p), p);
914 	return 0;
915 }
916 
917 static
918 int
919 findxmltype(char *b, int l, char *s)
920 {
921 	char *p, *e;
922 
923 	p = cistrstr(s, "<?xml ");
924 	if(!p)
925 		return -1;
926 
927 	p += 6;
928 	e = strstr(p, "?>");
929 	if(!e)
930 		return -1;
931 	snprint(b, l, "%.*s", (int)(e-p), p);
932 
933 	return 0;
934 }
935 
936 /*
937  * servers can lie about lie about the charset,
938  * so we use the charset based on the priority.
939  */
940 char *
941 convert(Runestr ctype, char *s, long *np)
942 {
943 	char t[25], buf[256];
944 
945 	*t = '\0';
946 	if(ctype.nr){
947 		snprint(buf, sizeof(buf), "%.*S", ctype.nr, ctype.r);
948 		findctype(t, sizeof(t), "charset", buf);
949 	}
950 	if(findxmltype(buf, sizeof(buf), s)==0)
951 		findctype(t, sizeof(t), "encoding", buf);
952 	if(finddocctype(buf, sizeof(buf), s) == 0)
953 		findctype(t, sizeof(t), "charset", buf);
954 
955 	if(*t == '\0')
956 		strcpy(t, charset);
957 	return tcs(t, s, np);
958 }
959 
960 int
961 xtofchar(Rune *s, Font *f, long p)
962 {
963 	Rune *r;
964 	int q;
965 
966 	if(p == 0)
967 		return 0;
968 
969 	q = 0;
970 	for(r=s; *r!=L'\0'; r++){
971 		p -= runestringnwidth(f, r, 1);
972 		if(p < 0)
973 			break;
974 		q++;
975 	}
976 	return q;
977 }
978 
979 int
980 istextsel(Page *p, Rectangle r, int *q0, int *q1, Rune *s, Font *f)
981 {
982 	int topinr, botinr;
983 
984 	*q0 = *q1 = 0;
985 	topinr= ptinrect(p->top, r);
986 	if(topinr || (r.min.y>p->top.y && r.max.y<p->bot.y))
987 		p->selecting = TRUE;
988 	botinr = ptinrect(p->bot, r);
989 	if(botinr || r.min.y>p->bot.y)
990 		p->selecting = FALSE;
991 
992 	if(topinr || botinr){
993 		if(topinr)
994 			*q0 = xtofchar(s, f, p->top.x-r.min.x);
995 		if(botinr)
996 			*q1 = xtofchar(s, f, p->bot.x-r.min.x);
997 		if(*q0!=0 || *q1!=0)
998 			return TRUE;
999 	}
1000 	return p->selecting;
1001 }
1002 
1003 Point
1004 getpt(Page *p, Point xy)
1005 {
1006 	xy.x = xy.x-p->r.min.x+p->pos.x;
1007 	xy.y = xy.y-p->r.min.y+p->pos.y;
1008 
1009 	return xy;
1010 }
1011 
1012 void
1013 getimage(Cimage *ci, Rune *altr)
1014 {
1015 	Rectangle r;
1016 	Memimage *mi;
1017 	Image *i, *i2;
1018 	char buf[128];
1019 	uchar *bits;
1020 	int nbits;
1021 
1022 	mi = ci->mi;
1023 	if(mi == nil){
1024 		snprint(buf, sizeof(buf), "[%S]", altr ? altr : L"IMG");
1025 		r.min = Pt(0, 0);
1026 		r.max.x = 2*Space + stringwidth(font, buf);
1027 		r.max.y = 2*Space + font->height;
1028 		ci->i = eallocimage(display, r, GREY1, 1, DBlack);
1029 		r.min.x += Space;
1030 		r.min.y += Space;
1031 		string(ci->i, r.min, display->white, ZP, font, buf);
1032 		return;
1033 	}
1034 	nbits = bytesperline(mi->r, mi->depth)*Dy(mi->r);
1035 	bits = emalloc(nbits);
1036 	unloadmemimage(mi, mi->r, bits, nbits);
1037 /*
1038 	/* get rid of alpha channel from transparent gif * /
1039 
1040 	if(mi->depth == 16){
1041 		for(y=1; y<nbits; y+=2)
1042 			bits[y>>1] = bits[y];
1043 	}
1044 */
1045 	i = eallocimage(display, mi->r, mi->chan, 0, DNofill);
1046 	loadimage(i, i->r, bits, nbits);
1047 	i2 = eallocimage(display, i->r, RGB24, 1, DNofill);
1048 	draw(i2, i2->r, display->black, nil, ZP);
1049 	draw(i2, i2->r, i, nil, i->r.min);
1050 	free(bits);
1051 	freememimage(mi);
1052 	freeimage(i);
1053 	ci->i = i2;
1054 	ci->mi = nil;
1055 }
1056 
1057 static
1058 void
1059 fixtext1(Item **list)
1060 {
1061 	Itext *text, *ntext;
1062 	Item *it, *prev;
1063 	Rune *s, *s1, *s2;
1064 	int n;
1065 
1066 	if(*list == nil)
1067 		return;
1068 
1069 	prev = nil;
1070 	for(it=*list; it!=nil; it=prev->next){
1071 		if(it->tag!=Itexttag || forceitem(it))
1072 			goto Continue;
1073 
1074 		text = (Itext *)it;
1075 		s = text->s;
1076 		while(*s && isspacerune(*s))
1077 			s++;
1078 		if(!*s){
1079 			if(prev == nil)
1080 				prev = *list = it->next;
1081 			else
1082 				prev->next = it->next;
1083 
1084 			it->next = nil;
1085 			freeitems(it);
1086 			if(prev == nil)
1087 				return;
1088 			continue;
1089 		}
1090 		n = 0;
1091 		while(s[n] && !isspacerune(s[n]))
1092 			n++;
1093 
1094 		if(!s[n])
1095 			goto Continue;
1096 
1097 		s1 = runemalloc(n+1);
1098 		s1 = runemove(s1, s, n);
1099 		s1[n] = L'\0';
1100 		s += n;
1101 
1102 		while(*s && isspacerune(*s))
1103 			s++;
1104 
1105 		if(*s){
1106 			n = runestrlen(s);
1107 			s2 = runemalloc(n+1);
1108 			runemove(s2, s, n);
1109 			s2[n] = L'\0';
1110 			ntext = emalloc(sizeof(Itext));
1111 			ntext->s = s2;
1112 			ntext->ascent = text->ascent;
1113 			ntext->anchorid = text->anchorid;
1114 			ntext->state = text->state&~(IFbrk|IFbrksp|IFnobrk|IFcleft|IFcright);
1115 			ntext->tag = text->tag;
1116 			ntext->fnt = text->fnt;
1117 			ntext->fg = text->fg;
1118 			ntext->ul = text->ul;
1119 			ntext->next = (Item *)text->next;
1120 			text->next = (Item *)ntext;
1121 		}
1122 		free(text->s);
1123 		text->s = s1;
1124     Continue:
1125 		prev = it;
1126 	}
1127 }
1128 
1129 void
1130 fixtext(Page *p)
1131 {
1132 	Tablecell *c;
1133 	Table *t;
1134 
1135 	fixtext1(&p->items);
1136 	for(t=p->doc->tables; t!=nil; t=t->next)
1137 		for(c=t->cells; c!=nil; c=c->next)
1138 			fixtext1(&c->content);
1139 }
1140 
1141 typedef struct Refresh Refresh;
1142 
1143 struct Refresh
1144 {
1145 	Page *p;
1146 	Refresh *next;
1147 };
1148 
1149 static Refresh *refreshs = nil;
1150 static QLock refreshlock;
1151 
1152 void
1153 addrefresh(Page *p, char *fmt, ...)
1154 {
1155 	Refresh *r;
1156 	Rune *s;
1157 	va_list arg;
1158 
1159 	if(p->aborting)
1160 		return;
1161 
1162 	va_start(arg, fmt);
1163 	s = runevsmprint(fmt, arg);
1164 	va_end(arg);
1165 	if(s == nil)
1166 		error("runevsmprint failed");
1167 
1168 	if(p->status){
1169 		free(p->status);
1170 		p->status = nil;
1171 	}
1172 	p->status = s;
1173 	qlock(&refreshlock);
1174 	for(r=refreshs; r!=nil; r=r->next)
1175 		if(r->p == p)
1176 			goto Return;
1177 
1178 	incref(p->w);				/* flushrefresh will decref */
1179 	r = emalloc(sizeof(Refresh));
1180 	r->p = p;
1181 	r->next = refreshs;
1182 	refreshs = r;
1183 
1184     Return:
1185 	nbsendp(crefresh, nil);
1186 	qunlock(&refreshlock);
1187 }
1188 
1189 /* called while row is locked */
1190 void
1191 flushrefresh(void)
1192 {
1193 	Refresh *r, *next;
1194 	Page *p;
1195 
1196 	qlock(&refreshlock);
1197 	for(r=refreshs; r!=nil; r=next){
1198 		p = r->p;
1199 		if(p->changed==TRUE && p->aborting==FALSE){
1200 			p->changed = FALSE;
1201 			if(p->parent==nil || p->loading==FALSE)
1202 				pagerender(p);
1203 			if(!p->refresh.t)
1204 				pagesetrefresh(p);
1205 		}
1206 		if(p->status){
1207 			winsetstatus(p->w, p->status);
1208 			free(p->status);
1209 			p->status = nil;
1210 		}
1211 		winseturl(p->w);
1212 		winsettag(p->w);
1213 		decref(p->w);
1214 		next = r->next;
1215 		free(r);
1216 	}
1217 	refreshs = nil;
1218 	qunlock(&refreshlock);
1219 }
1220 
1221 void
1222 savemouse(Window *w)
1223 {
1224 	prevmouse = mouse->xy;
1225 	mousew = w;
1226 }
1227 
1228 void
1229 restoremouse(Window *w)
1230 {
1231 	if(mousew!=nil && mousew==w)
1232 		moveto(mousectl, prevmouse);
1233 	mousew = nil;
1234 }
1235 
1236 void
1237 clearmouse()
1238 {
1239 	mousew = nil;
1240 }
1241 
1242 /*
1243  * Heuristic city.
1244  */
1245 Window*
1246 makenewwindow(Page *p)
1247 {
1248 	Column *c;
1249 	Window *w, *bigw, *emptyw;
1250 	Page *emptyp;
1251 	int i, y, el;
1252 
1253 	if(activecol)
1254 		c = activecol;
1255 	else if(selpage && selpage->col)
1256 		c = selpage->col;
1257 	else if(p && p->col)
1258 		c = p->col;
1259 	else{
1260 		if(row.ncol==0 && rowadd(&row, nil, -1)==nil)
1261 			error("can't make column");
1262 		c = row.col[row.ncol-1];
1263 	}
1264 	activecol = c;
1265 	if(p==nil || p->w==nil || c->nw==0)
1266 		return coladd(c, nil, nil, -1);
1267 
1268 	/* find biggest window and biggest blank spot */
1269 	emptyw = c->w[0];
1270 	bigw = emptyw;
1271 	for(i=1; i<c->nw; i++){
1272 		w = c->w[i];
1273 		/* use >= to choose one near bottom of screen */
1274 		if(Dy(w->page.all) >= Dy(bigw->page.all))
1275 			bigw = w;
1276 		if(w->page.lay==nil && Dy(w->page.all) >= Dy(emptyw->page.all))
1277 			emptyw = w;
1278 	}
1279 	emptyp = &emptyw->page;
1280 	el = Dy(emptyp->all);
1281 	/* if empty space is big, use it */
1282 	if(el>15 || (el>3 && el>(Dy(bigw->page.all)-1)/2))
1283 		y = emptyp->all.max.y;
1284 	else{
1285 		/* if this window is in column and isn't much smaller, split it */
1286 		if(p->col==c && Dy(p->w->r)>2*Dy(bigw->r)/3)
1287 			bigw = p->w;
1288 		y = (bigw->r.min.y + bigw->r.max.y)/2;
1289 	}
1290 	w = coladd(c, nil, nil, y);
1291 	colgrow(w->col, w, 1);
1292 	return w;
1293 }
1294