1 #include <u.h>
2 #include <libc.h>
3 #include <draw.h>
4 #include <cursor.h>
5 #include <event.h>
6 #include <bio.h>
7 
8 typedef struct	Thing	Thing;
9 
10 struct Thing
11 {
12 	Image	*b;
13 	Subfont 	*s;
14 	char		*name;	/* file name */
15 	int		face;		/* is 48x48 face file or cursor file*/
16 	Rectangle r;		/* drawing region */
17 	Rectangle tr;		/* text region */
18 	Rectangle er;		/* entire region */
19 	long		c;		/* character number in subfont */
20 	int		mod;	/* modified */
21 	int		mag;		/* magnification */
22 	Rune		off;		/* offset for subfont indices */
23 	Thing	*parent;	/* thing of which i'm an edit */
24 	Thing	*next;
25 };
26 
27 enum
28 {
29 	Border	= 1,
30 	Up		= 1,
31 	Down	= 0,
32 	Mag		= 4,
33 	Maxmag	= 20
34 };
35 
36 enum
37 {
38 	NORMAL	=0,
39 	FACE	=1,
40 	CURSOR	=2
41 };
42 
43 enum
44 {
45 	Mopen,
46 	Mread,
47 	Mwrite,
48 	Mcopy,
49 	Mchar,
50 	Mpixels,
51 	Mclose,
52 	Mexit
53 };
54 
55 enum
56 {
57 	Blue	= 54
58 };
59 
60 char	*menu3str[] = {
61 	"open",
62 	"read",
63 	"write",
64 	"copy",
65 	"char",
66 	"pixels",
67 	"close",
68 	"exit",
69 	0
70 };
71 
72 Menu	menu3 = {
73 	menu3str
74 };
75 
76 Cursor sweep0 = {
77 	{-7, -7},
78 	{0x03, 0xC0, 0x03, 0xC0, 0x03, 0xC0, 0x03, 0xC0,
79 	 0x03, 0xC0, 0x03, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF,
80 	 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0xC0, 0x03, 0xC0,
81 	 0x03, 0xC0, 0x03, 0xC0, 0x03, 0xC0, 0x03, 0xC0},
82 	{0x00, 0x00, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80,
83 	 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x7F, 0xFE,
84 	 0x7F, 0xFE, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80,
85 	 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x00, 0x00}
86 };
87 
88 Cursor box = {
89 	{-7, -7},
90 	{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
91 	 0xFF, 0xFF, 0xF8, 0x1F, 0xF8, 0x1F, 0xF8, 0x1F,
92 	 0xF8, 0x1F, 0xF8, 0x1F, 0xF8, 0x1F, 0xFF, 0xFF,
93 	 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
94 	{0x00, 0x00, 0x7F, 0xFE, 0x7F, 0xFE, 0x7F, 0xFE,
95 	 0x70, 0x0E, 0x70, 0x0E, 0x70, 0x0E, 0x70, 0x0E,
96 	 0x70, 0x0E, 0x70, 0x0E, 0x70, 0x0E, 0x70, 0x0E,
97 	 0x7F, 0xFE, 0x7F, 0xFE, 0x7F, 0xFE, 0x00, 0x00}
98 };
99 
100 Cursor sight = {
101 	{-7, -7},
102 	{0x1F, 0xF8, 0x3F, 0xFC, 0x7F, 0xFE, 0xFB, 0xDF,
103 	 0xF3, 0xCF, 0xE3, 0xC7, 0xFF, 0xFF, 0xFF, 0xFF,
104 	 0xFF, 0xFF, 0xFF, 0xFF, 0xE3, 0xC7, 0xF3, 0xCF,
105 	 0x7B, 0xDF, 0x7F, 0xFE, 0x3F, 0xFC, 0x1F, 0xF8,},
106 	{0x00, 0x00, 0x0F, 0xF0, 0x31, 0x8C, 0x21, 0x84,
107 	 0x41, 0x82, 0x41, 0x82, 0x41, 0x82, 0x7F, 0xFE,
108 	 0x7F, 0xFE, 0x41, 0x82, 0x41, 0x82, 0x41, 0x82,
109 	 0x21, 0x84, 0x31, 0x8C, 0x0F, 0xF0, 0x00, 0x00,}
110 };
111 
112 Cursor pixel = {
113 	{-7, -7},
114 	{0x1f, 0xf8, 0x3f, 0xfc,  0x7f, 0xfe,  0xf8, 0x1f,
115 	0xf0, 0x0f,  0xe0, 0x07, 0xe0, 0x07, 0xfe, 0x7f,
116 	0xfe, 0x7f, 0xe0, 0x07, 0xe0, 0x07, 0xf0, 0x0f,
117 	0x78, 0x1f, 0x7f, 0xfe, 0x3f, 0xfc, 0x1f, 0xf8, },
118 	{0x00, 0x00, 0x0f, 0xf0, 0x31, 0x8c, 0x21, 0x84,
119 	0x41, 0x82, 0x41, 0x82, 0x41, 0x82, 0x40, 0x02,
120 	0x40, 0x02, 0x41, 0x82, 0x41, 0x82, 0x41, 0x82,
121 	0x21, 0x84, 0x31, 0x8c, 0x0f, 0xf0, 0x00, 0x00, }
122 };
123 
124 Cursor busy = {
125 	{-7, -7},
126 	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
127 	 0x00, 0x00, 0x00, 0x0c, 0x00, 0x8e, 0x1d, 0xc7,
128 	 0xff, 0xe3, 0xff, 0xf3, 0xff, 0xff, 0x7f, 0xfe,
129 	 0x3f, 0xf8, 0x17, 0xf0, 0x03, 0xe0, 0x00, 0x00,},
130 	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
131 	 0x00, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00, 0x82,
132 	 0x04, 0x41, 0xff, 0xe1, 0x5f, 0xf1, 0x3f, 0xfe,
133 	 0x17, 0xf0, 0x03, 0xe0, 0x00, 0x00, 0x00, 0x00,}
134 };
135 
136 Cursor skull = {
137 	{-7,-7},
138 	{0x00, 0x00, 0x00, 0x00, 0xc0, 0x03, 0xe7, 0xe7,
139 	 0xff, 0xff, 0xff, 0xff, 0x3f, 0xfc, 0x1f, 0xf8,
140 	 0x0f, 0xf0, 0x3f, 0xfc, 0xff, 0xff, 0xff, 0xff,
141 	 0xef, 0xf7, 0xc7, 0xe3, 0x00, 0x00, 0x00, 0x00,},
142 	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03,
143 	 0xE7, 0xE7, 0x3F, 0xFC, 0x0F, 0xF0, 0x0D, 0xB0,
144 	 0x07, 0xE0, 0x06, 0x60, 0x37, 0xEC, 0xE4, 0x27,
145 	 0xC3, 0xC3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,}
146 };
147 
148 Rectangle	cntlr;		/* control region */
149 Rectangle	editr;		/* editing region */
150 Rectangle	textr;		/* text region */
151 Thing		*thing;
152 Mouse		mouse;
153 char		hex[] = "0123456789abcdefABCDEF";
154 jmp_buf		err;
155 char		*file;
156 int		mag;
157 int		but1val = 0;
158 int		but2val = 255;
159 int		invert = 0;
160 Image		*values[256];
161 Image		*greyvalues[256];
162 uchar		data[8192];
163 
164 Thing*	tget(char*, int);
165 void	mesg(char*, ...);
166 void	drawthing(Thing*, int);
167 void	xselect(void);
168 void	menu(void);
169 void	error(Display*, char*);
170 void	buttons(int);
171 void	drawall(void);
172 void	tclose1(Thing*);
173 
174 void
175 usage(void)
176 {
177 	fprint(2, "usage: tweak [-W winsize] file...\n");
178 	exits("usage");
179 }
180 
181 void
182 main(volatile int argc, char **volatile argv)
183 {
184 	volatile int i;
185 	Event e;
186 	Thing *t;
187 	Thing *nt;
188 
189 	ARGBEGIN{
190 	case 'W':
191 		winsize = EARGF(usage());
192 		break;
193 	default:
194 		usage();
195 	}ARGEND
196 	mag = Mag;
197 	if(initdraw(error, 0, "tweak") < 0){
198 		fprint(2, "tweak: initdraw failed: %r\n");
199 		exits("initdraw");
200 	}
201 	for(i=0; i<256; i++){
202 		values[i] = allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, cmap2rgba(i));
203 		greyvalues[i] = allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, (i<<24)|(i<<16)|(i<<8)|0xFF);
204 		if(values[i] == 0 || greyvalues[i] == 0)
205 			drawerror(display, "can't allocate image");
206 	}
207 	einit(Emouse|Ekeyboard);
208 	eresized(0);
209 	i = 0;
210 	setjmp(err);
211 	for(; i<argc; i++){
212 		file = argv[i];
213 		t = tget(argv[i], 1);
214 		if(t) {
215 			nt = t->next;
216 			t->next = 0;
217 			drawthing(t, 1);
218 			if(nt)
219 				drawthing(nt, 1);
220 		}
221 		flushimage(display, 1);
222 	}
223 	file = 0;
224 	setjmp(err);
225 	for(;;)
226 		switch(event(&e)){
227 		case Ekeyboard:
228 			break;
229 		case Emouse:
230 			mouse = e.mouse;
231 			if(mouse.buttons & 3){
232 				xselect();
233 				break;
234 			}
235 			if(mouse.buttons & 4)
236 				menu();
237 		}
238 }
239 
240 int
241 xlog2(int n)
242 {
243 	int i;
244 
245 	for(i=0; (1<<i) <= n; i++)
246 		if((1<<i) == n)
247 			return i;
248 	fprint(2, "log2 %d = 0\n", n);
249 	return 0;
250 }
251 
252 void
253 error(Display *d, char *s)
254 {
255 	USED(d);
256 
257 	if(file)
258 		mesg("can't read %s: %s: %r", file, s);
259 	else
260 		mesg("/dev/bitblt error: %s", s);
261 	if(err[0])
262 		longjmp(err, 1);
263 	exits(s);
264 }
265 
266 void
267 redraw(Thing *t)
268 {
269 	Thing *nt;
270 	Point p;
271 
272 	if(thing==0 || thing==t)
273 		draw(screen, editr, display->white, nil, ZP);
274 	if(thing == 0)
275 		return;
276 	if(thing != t){
277 		for(nt=thing; nt->next!=t; nt=nt->next)
278 			;
279 		draw(screen, Rect(screen->r.min.x, nt->er.max.y, editr.max.x, editr.max.y),
280 			display->white, nil, ZP);
281 	}
282 	for(nt=t; nt; nt=nt->next){
283 		drawthing(nt, 0);
284 		if(nt->next == 0){
285 			p = Pt(editr.min.x, nt->er.max.y);
286 			draw(screen, Rpt(p, editr.max), display->white, nil, ZP);
287 		}
288 	}
289 	mesg("");
290 }
291 
292 void
293 eresized(int new)
294 {
295 	if(new && getwindow(display, Refnone) < 0)
296 		error(display, "can't reattach to window");
297 	cntlr = insetrect(screen->clipr, 1);
298 	editr = cntlr;
299 	textr = editr;
300 	textr.min.y = textr.max.y - font->height;
301 	cntlr.max.y = cntlr.min.y + font->height;
302 	editr.min.y = cntlr.max.y+1;
303 	editr.max.y = textr.min.y-1;
304 	draw(screen, screen->clipr, display->white, nil, ZP);
305 	draw(screen, Rect(editr.min.x, editr.max.y, editr.max.x+1, editr.max.y+1), display->black, nil, ZP);
306 	replclipr(screen, 0, editr);
307 	drawall();
308 }
309 
310 void
311 mesgstr(Point p, int line, char *s)
312 {
313 	Rectangle c, r;
314 
315 	r.min = p;
316 	r.min.y += line*font->height;
317 	r.max.y = r.min.y+font->height;
318 	r.max.x = editr.max.x;
319 	c = screen->clipr;
320 	replclipr(screen, 0, r);
321 	draw(screen, r, values[0xDD], nil, ZP);
322 	r.min.x++;
323 	string(screen, r.min, display->black, ZP, font, s);
324 	replclipr(screen, 0, c);
325 	flushimage(display, 1);
326 }
327 
328 void
329 mesg(char *fmt, ...)
330 {
331 	char buf[1024];
332 	va_list arg;
333 
334 	va_start(arg, fmt);
335 	vseprint(buf, buf+sizeof(buf), fmt, arg);
336 	va_end(arg);
337 	mesgstr(textr.min, 0, buf);
338 }
339 
340 void
341 tmesg(Thing *t, int line, char *fmt, ...)
342 {
343 	char buf[1024];
344 	va_list arg;
345 
346 	va_start(arg, fmt);
347 	vseprint(buf, buf+sizeof(buf), fmt, arg);
348 	va_end(arg);
349 	mesgstr(t->tr.min, line, buf);
350 }
351 
352 
353 void
354 scntl(char *l)
355 {
356 	sprint(l, "mag: %d  but1: %d  but2: %d  invert-on-copy: %c", mag, but1val, but2val, "ny"[invert]);
357 }
358 
359 void
360 cntl(void)
361 {
362 	char buf[256];
363 
364 	scntl(buf);
365 	mesgstr(cntlr.min, 0, buf);
366 }
367 
368 void
369 stext(Thing *t, char *l0, char *l1)
370 {
371 	Fontchar *fc;
372 	char buf[256];
373 
374 	l1[0] = 0;
375 	sprint(buf, "depth:%d r:%d %d  %d %d ",
376 		t->b->depth, t->b->r.min.x, t->b->r.min.y,
377 		t->b->r.max.x, t->b->r.max.y);
378 	if(t->parent)
379 		sprint(buf+strlen(buf), "mag: %d ", t->mag);
380 	sprint(l0, "%s file: %s", buf, t->name);
381 	if(t->c >= 0){
382 		fc = &t->parent->s->info[t->c];
383 		sprint(l1, "c(hex): %x c(char): %C x: %d "
384 			   "top: %d bottom: %d left: %d width: %d iwidth: %d",
385 			(int)(t->c+t->parent->off), (int)(t->c+t->parent->off),
386 			fc->x, fc->top, fc->bottom, fc->left,
387 			fc->width, Dx(t->b->r));
388 	}else if(t->s)
389 		sprint(l1, "offset(hex): %ux n:%d  height:%d  ascent:%d",
390 			t->off, t->s->n, t->s->height, t->s->ascent);
391 	else if(t->face == CURSOR)
392 		sprint(l0+strlen(l0), " cursor:%d", Dx(t->b->r));
393 }
394 
395 void
396 text(Thing *t)
397 {
398 	char l0[256], l1[256];
399 
400 	stext(t, l0, l1);
401 	tmesg(t, 0, l0);
402 	if(l1[0])
403 		tmesg(t, 1, l1);
404 }
405 
406 void
407 drawall(void)
408 {
409 	Thing *t;
410 
411 	cntl();
412 	for(t=thing; t; t=t->next)
413 		drawthing(t, 0);
414 }
415 
416 int
417 value(Image *b, int x)
418 {
419 	int v, l, w;
420 	uchar mask;
421 
422 	w = b->depth;
423 	if(w > 8){
424 		mesg("ldepth too large");
425 		return 0;
426 	}
427 	l = xlog2(w);
428 	mask = (1<<w)-1;		/* ones at right end of word */
429 	x -= b->r.min.x&~(7>>l);	/* adjust x relative to first pixel */
430 	v = data[x>>(3-l)];
431 	v >>= ((7>>l)<<l) - ((x&(7>>l))<<l);	/* pixel at right end of word */
432 	v &= mask;			/* pixel at right end of word */
433 	return v;
434 }
435 
436 int
437 bvalue(int v, int d)
438 {
439 	v &= (1<<d)-1;
440 	if(d > screen->depth)
441 		v >>= d - screen->depth;
442 	else
443 		while(d < screen->depth && d < 8){
444 			v |= v << d;
445 			d <<= 1;
446 		}
447 	if(v<0 || v>255){
448 		mesg("internal error: bad color");
449 		return Blue;
450 	}
451 	return v;
452 }
453 
454 void
455 drawthing(Thing *nt, int link)
456 {
457 	int n, nl, nf, i, x, y, sx, sy, fdx, dx, dy, v;
458 	Thing *t;
459 	Subfont *s;
460 	Image *b, *col;
461 	Point p, p1, p2;
462 
463 	if(link){
464 		nt->next = 0;
465 		if(thing == 0){
466 			thing = nt;
467 			y = editr.min.y;
468 		}else{
469 			for(t=thing; t->next; t=t->next)
470 				;
471 			t->next = nt;
472 			y = t->er.max.y;
473 		}
474 	}else{
475 		if(thing == nt)
476 			y = editr.min.y;
477 		else{
478 			for(t=thing; t->next!=nt; t=t->next)
479 				;
480 			y = t->er.max.y;
481 		}
482 	}
483 	s = nt->s;
484 	b = nt->b;
485 	nl = font->height;
486 	if(s || nt->c>=0)
487 		nl += font->height;
488 	fdx = Dx(editr) - 2*Border;
489 	dx = Dx(b->r);
490 	dy = Dy(b->r);
491 	if(nt->mag > 1){
492 		dx *= nt->mag;
493 		dy *= nt->mag;
494 		fdx -= fdx%nt->mag;
495 	}
496 	nf = 1 + dx/fdx;
497 	nt->er.min.y = y;
498 	nt->er.min.x = editr.min.x;
499 	nt->er.max.x = nt->er.min.x + Border + dx + Border;
500 	if(nt->er.max.x > editr.max.x)
501 		nt->er.max.x = editr.max.x;
502 	nt->er.max.y = nt->er.min.y + Border + nf*(dy+Border);
503 	nt->r = insetrect(nt->er, Border);
504 	nt->er.max.x = editr.max.x;
505 	draw(screen, nt->er, display->white, nil, ZP);
506 	for(i=0; i<nf; i++){
507 		p1 = Pt(nt->r.min.x-1, nt->r.min.y+i*(Border+dy));
508 		/* draw portion of bitmap */
509 		p = Pt(p1.x+1, p1.y);
510 		if(nt->mag == 1)
511 			draw(screen, Rect(p.x, p.y, p.x+fdx+Dx(b->r), p.y+Dy(b->r)),
512 				b, nil, Pt(b->r.min.x+i*fdx, b->r.min.y));
513 		else{
514 			for(y=b->r.min.y; y<b->r.max.y; y++){
515 				sy = p.y+(y-b->r.min.y)*nt->mag;
516 				if((n=unloadimage(b, Rect(b->r.min.x, y, b->r.max.x, y+1), data, sizeof data)) < 0)
517 					fprint(2, "unloadimage: %r\n");
518 				for(x=b->r.min.x+i*(fdx/nt->mag); x<b->r.max.x; x++){
519 					sx = p.x+(x-i*(fdx/nt->mag)-b->r.min.x)*nt->mag;
520 					if(sx >= nt->r.max.x)
521 						break;
522 					v = bvalue(value(b, x), b->depth);
523 					if(v == 255)
524 						continue;
525 					if(b->chan == GREY8)
526 						draw(screen, Rect(sx, sy, sx+nt->mag, sy+nt->mag),
527 							greyvalues[v], nil, ZP);
528 					else
529 						draw(screen, Rect(sx, sy, sx+nt->mag, sy+nt->mag),
530 							values[v], nil, ZP);
531 				}
532 
533 			}
534 		}
535 		/* line down left */
536 		if(i == 0)
537 			col = display->black;
538 		else
539 			col = display->white;
540 		draw(screen, Rect(p1.x, p1.y, p1.x+1, p1.y+dy+Border), col, nil, ZP);
541 		/* line across top */
542 		draw(screen, Rect(p1.x, p1.y-1, nt->r.max.x+Border, p1.y), display->black, nil, ZP);
543 		p2 = p1;
544 		if(i == nf-1){
545 			p2.x += 1 + dx%fdx;
546 			col = display->black;
547 		}else{
548 			p2.x = nt->r.max.x;
549 			col = display->white;
550 		}
551 		/* line down right */
552 		draw(screen, Rect(p2.x, p2.y, p2.x+1, p2.y+dy+Border), col, nil, ZP);
553 		/* line across bottom */
554 		if(i == nf-1){
555 			p1.y += Border+dy;
556 			draw(screen, Rect(p1.x, p1.y-1, p2.x,p1.y), display->black, nil, ZP);
557 		}
558 	}
559 	nt->tr.min.x = editr.min.x;
560 	nt->tr.max.x = editr.max.x;
561 	nt->tr.min.y = nt->er.max.y + Border;
562 	nt->tr.max.y = nt->tr.min.y + nl;
563 	nt->er.max.y = nt->tr.max.y + Border;
564 	text(nt);
565 }
566 
567 int
568 tohex(int c)
569 {
570 	if('0'<=c && c<='9')
571 		return c - '0';
572 	if('a'<=c && c<='f')
573 		return 10 + (c - 'a');
574 	if('A'<=c && c<='F')
575 		return 10 + (c - 'A');
576 	return 0;
577 }
578 
579 Thing*
580 tget(char *file, int extra)
581 {
582 	int i, j, fd, face, x, y, c, chan;
583 	Image *b;
584 	Subfont *s;
585 	Thing *t;
586 	Dir *volatile d;
587 	jmp_buf oerr;
588 	uchar buf[300];
589 	char *data;
590 	Rectangle r;
591 
592 	buf[0] = '\0';
593 	errstr((char*)buf, sizeof buf);	/* flush pending error message */
594 	memmove(oerr, err, sizeof err);
595 	d = nil;
596 	if(setjmp(err)){
597    Err:
598 		free(d);
599 		memmove(err, oerr, sizeof err);
600 		return 0;
601 	}
602 	fd = open(file, OREAD);
603 	if(fd < 0){
604 		mesg("can't open %s: %r", file);
605 		goto Err;
606 	}
607 	d = dirfstat(fd);
608 	if(d == nil){
609 		mesg("can't stat bitmap file %s: %r", file);
610 		close(fd);
611 		goto Err;
612 	}
613 	if(read(fd, buf, 11) != 11){
614 		mesg("can't read %s: %r", file);
615 		close(fd);
616 		goto Err;
617 	}
618 	seek(fd, 0, 0);
619 	data = (char*)buf;
620 	if(*data == '{')
621 		data++;
622 	if(memcmp(data, "0x", 2)==0 && data[4]==','){
623 		/*
624 		 * cursor file
625 		 */
626 		face = CURSOR;
627 		s = 0;
628 		data = malloc(d->length+1);
629 		if(data == 0){
630 			mesg("can't malloc buffer: %r");
631 			close(fd);
632 			goto Err;
633 		}
634 		data[d->length] = 0;
635 		if(read(fd, data, d->length) != d->length){
636 			mesg("can't read cursor file %s: %r", file);
637 			close(fd);
638 			goto Err;
639 		}
640 		i = 0;
641 		for(x=0;; ){
642 			if((c=data[i]) == '\0' || x > 256) {
643 				if(x == 64 || x == 256)
644 					goto HaveCursor;
645 				mesg("ill-formed cursor file %s", file);
646 				close(fd);
647 				goto Err;
648 			}
649 			if(c=='0' && data[i+1] == 'x'){
650 				i += 2;
651 				continue;
652 			}
653 			if(strchr(hex, c)){
654 				buf[x++] = (tohex(c)<<4) | tohex(data[i+1]);
655 				i += 2;
656 				continue;
657 			}
658 			i++;
659 		}
660 	HaveCursor:
661 		if(x == 64)
662 			r = Rect(0, 0, 16, 32);
663 		else
664 			r = Rect(0, 0, 32, 64);
665 		b = allocimage(display, r, GREY1, 0, DNofill);
666 		if(b == 0){
667 			mesg("image alloc failed file %s: %r", file);
668 			free(data);
669 			close(fd);
670 			goto Err;
671 		}
672 		loadimage(b, r, buf, sizeof buf);
673 		free(data);
674 	}else if(memcmp(buf, "0x", 2)==0){
675 		/*
676 		 * face file
677 		 */
678 		face = FACE;
679 		s = 0;
680 		data = malloc(d->length+1);
681 		if(data == 0){
682 			mesg("can't malloc buffer: %r");
683 			close(fd);
684 			goto Err;
685 		}
686 		data[d->length] = 0;
687 		if(read(fd, data, d->length) != d->length){
688 			mesg("can't read bitmap file %s: %r", file);
689 			close(fd);
690 			goto Err;
691 		}
692 		for(y=0,i=0; i<d->length; i++)
693 			if(data[i] == '\n')
694 				y++;
695 		if(y == 0){
696 	ill:
697 			mesg("ill-formed face file %s", file);
698 			close(fd);
699 			free(data);
700 			goto Err;
701 		}
702 		for(x=0,i=0; (c=data[i])!='\n'; ){
703 			if(c==',' || c==' ' || c=='\t'){
704 				i++;
705 				continue;
706 			}
707 			if(c=='0' && data[i+1] == 'x'){
708 				i += 2;
709 				continue;
710 			}
711 			if(strchr(hex, c)){
712 				x += 4;
713 				i++;
714 				continue;
715 			}
716 			goto ill;
717 		}
718 		if(x % y)
719 			goto ill;
720 		switch(x / y){
721 		default:
722 			goto ill;
723 		case 1:
724 			chan = GREY1;
725 			break;
726 		case 2:
727 			chan = GREY2;
728 			break;
729 		case 4:
730 			chan = GREY4;
731 			break;
732 		case 8:
733 			chan = CMAP8;
734 			break;
735 		}
736 		b = allocimage(display, Rect(0, 0, y, y), chan, 0, -1);
737 		if(b == 0){
738 			mesg("image alloc failed file %s: %r", file);
739 			free(data);
740 			close(fd);
741 			goto Err;
742 		}
743 		i = 0;
744 		for(j=0; j<y; j++){
745 			for(x=0; (c=data[i])!='\n'; ){
746 				if(c=='0' && data[i+1] == 'x'){
747 					i += 2;
748 					continue;
749 				}
750 				if(strchr(hex, c)){
751 					buf[x++] = ~((tohex(c)<<4) | tohex(data[i+1]));
752 					i += 2;
753 					continue;
754 				}
755 				i++;
756 			}
757 			i++;
758 			loadimage(b, Rect(0, j, y, j+1), buf, sizeof buf);
759 		}
760 		free(data);
761 	}else{
762 		face = NORMAL;
763 		s = 0;
764 		b = readimage(display, fd, 0);
765 		if(b == 0){
766 			mesg("can't read bitmap file %s: %r", file);
767 			close(fd);
768 			goto Err;
769 		}
770 		if(seek(fd, 0, 1) < d->length)
771 			s = readsubfonti(display, file, fd, b, 0);
772 	}
773 	close(fd);
774 	t = mallocz(sizeof(Thing), 1);
775 	if(t == 0){
776    nomem:
777 		mesg("malloc failed: %r");
778 		if(s)
779 			freesubfont(s);
780 		else
781 			freeimage(b);
782 		goto Err;
783 	}
784 	t->name = strdup(file);
785 	if(t->name == 0){
786 		free(t);
787 		goto nomem;
788 	}
789 	t->b = b;
790 	t->s = s;
791 	t->face = face;
792 	t->mod = 0;
793 	t->parent = 0;
794 	t->c = -1;
795 	t->mag = 1;
796 	t->off = 0;
797 	if(face == CURSOR && extra && Dx(t->b->r) == 16) {
798 		// Make 32x32 cursor as second image.
799 		Thing *nt;
800 		Cursor c;
801 		Cursor2 c2;
802 
803 		nt = mallocz(sizeof(Thing), 1);
804 		if(nt == 0)
805 			goto nomem;
806 		nt->name = strdup("");
807 		if(nt->name == 0) {
808 			free(nt);
809 			goto nomem;
810 		}
811 		b = allocimage(display, Rect(0, 0, 32, 64), GREY1, 0, DNofill);
812 		if(b == nil) {
813 			free(nt->name);
814 			free(nt);
815 			goto nomem;
816 		}
817 		memmove(c.clr, buf, 64);
818 		scalecursor(&c2, &c);
819 		memmove(buf, c2.clr, 256);
820 		loadimage(b, b->r, buf, sizeof buf);
821 		t->next = nt;
822 		nt->b = b;
823 		nt->s = 0;
824 		nt->face = CURSOR;
825 		nt->mod = 0;
826 		nt->parent = 0;
827 		nt->c = -1;
828 		nt->mag = 1;
829 		nt->off = 0;
830 	}
831 	memmove(err, oerr, sizeof err);
832 	return t;
833 }
834 
835 int
836 atline(int x, Point p, char *line, char *buf)
837 {
838 	char *s, *c, *word, *hit;
839 	int w, wasblank;
840 	Rune r;
841 
842 	wasblank = 1;
843 	hit = 0;
844 	word = 0;
845 	for(s=line; *s; s+=w){
846 		w = chartorune(&r, s);
847 		x += runestringnwidth(font, &r, 1);
848 		if(wasblank && r!=' ')
849 			word = s;
850 		wasblank = 0;
851 		if(r == ' '){
852 			if(x >= p.x)
853 				break;
854 			wasblank = 1;
855 		}
856 		if(r == ':')
857 			hit = word;
858 	}
859 	if(x < p.x)
860 		return 0;
861 	c = utfrune(hit, ':');
862 	strncpy(buf, hit, c-hit);
863 	buf[c-hit] = 0;
864 	return 1;
865 }
866 
867 int
868 attext(Thing *t, Point p, char *buf)
869 {
870 	char l0[256], l1[256];
871 
872 	if(!ptinrect(p, t->tr))
873 		return 0;
874 	stext(t, l0, l1);
875 	if(p.y < t->tr.min.y+font->height)
876 		return atline(t->r.min.x, p, l0, buf);
877 	else
878 		return atline(t->r.min.x, p, l1, buf);
879 }
880 
881 int
882 type(char *buf, char *tag)
883 {
884 	Rune r;
885 	char *p;
886 
887 	esetcursor(&busy);
888 	p = buf;
889 	for(;;){
890 		*p = 0;
891 		mesg("%s: %s", tag, buf);
892 		r = ekbd();
893 		switch(r){
894 		case '\n':
895 			mesg("");
896 			esetcursor(0);
897 			return p-buf;
898 		case 0x15:	/* control-U */
899 			p = buf;
900 			break;
901 		case '\b':
902 			if(p > buf)
903 				--p;
904 			break;
905 		default:
906 			p += runetochar(p, &r);
907 		}
908 	}
909 	/* return 0;	shut up compiler */
910 }
911 
912 void
913 textedit(Thing *t, char *tag)
914 {
915 	char buf[256];
916 	char *s;
917 	Image *b;
918 	Subfont *f;
919 	Fontchar *fc, *nfc;
920 	Rectangle r;
921 	ulong chan;
922 	int i, ld, d, w, c, doredraw, fdx, x;
923 	Thing *nt;
924 
925 	buttons(Up);
926 	if(type(buf, tag) == 0)
927 		return;
928 	if(strcmp(tag, "file") == 0){
929 		for(s=buf; *s; s++)
930 			if(*s <= ' '){
931 				mesg("illegal file name");
932 				return;
933 			}
934 		if(strcmp(t->name, buf) != 0){
935 			if(t->parent)
936 				t->parent->mod = 1;
937 			else
938 				t->mod = 1;
939 		}
940 		for(nt=thing; nt; nt=nt->next)
941 			if(t==nt || t->parent==nt || nt->parent==t){
942 				free(nt->name);
943 				nt->name = strdup(buf);
944 				if(nt->name == 0){
945 					mesg("malloc failed: %r");
946 					return;
947 				}
948 				text(nt);
949 			}
950 		return;
951 	}
952 	if(strcmp(tag, "depth") == 0){
953 		if(buf[0]<'0' || '9'<buf[0] || (d=atoi(buf))<0 || d>8 || xlog2(d)<0){
954 			mesg("illegal ldepth");
955 			return;
956 		}
957 		if(d == t->b->depth)
958 			return;
959 		if(t->parent)
960 			t->parent->mod = 1;
961 		else
962 			t->mod = 1;
963 		if(d == 8)
964 			chan = CMAP8;
965 		else
966 			chan = CHAN1(CGrey, d);
967 		for(nt=thing; nt; nt=nt->next){
968 			if(nt!=t && nt!=t->parent && nt->parent!=t)
969 				continue;
970 			b = allocimage(display, nt->b->r, chan, 0, 0);
971 			if(b == 0){
972 	nobmem:
973 				mesg("image alloc failed: %r");
974 				return;
975 			}
976 			draw(b, b->r, nt->b, nil, nt->b->r.min);
977 			freeimage(nt->b);
978 			nt->b = b;
979 			if(nt->s){
980 				b = allocimage(display, nt->b->r, chan, 0, -1);
981 				if(b == 0)
982 					goto nobmem;
983 				draw(b, b->r, nt->b, nil, nt->b->r.min);
984 				f = allocsubfont(t->name, nt->s->n, nt->s->height, nt->s->ascent, nt->s->info, b);
985 				if(f == 0){
986 	nofmem:
987 					freeimage(b);
988 					mesg("can't make subfont: %r");
989 					return;
990 				}
991 				nt->s->info = 0;	/* prevent it being freed */
992 				nt->s->bits = 0;
993 				freesubfont(nt->s);
994 				nt->s = f;
995 			}
996 			drawthing(nt, 0);
997 		}
998 		return;
999 	}
1000 	if(strcmp(tag, "mag") == 0){
1001 		if(buf[0]<'0' || '9'<buf[0] || (ld=atoi(buf))<=0 || ld>Maxmag){
1002 			mesg("illegal magnification");
1003 			return;
1004 		}
1005 		if(t->mag == ld)
1006 			return;
1007 		t->mag = ld;
1008 		redraw(t);
1009 		return;
1010 	}
1011 	if(strcmp(tag, "r") == 0){
1012 		if(t->s){
1013 			mesg("can't change rectangle of subfont\n");
1014 			return;
1015 		}
1016 		s = buf;
1017 		r.min.x = strtoul(s, &s, 0);
1018 		r.min.y = strtoul(s, &s, 0);
1019 		r.max.x = strtoul(s, &s, 0);
1020 		r.max.y = strtoul(s, &s, 0);
1021 		if(Dx(r)<=0 || Dy(r)<=0){
1022 			mesg("illegal rectangle");
1023 			return;
1024 		}
1025 		if(t->parent)
1026 			t = t->parent;
1027 		for(nt=thing; nt; nt=nt->next){
1028 			if(nt->parent==t && !rectinrect(nt->b->r, r))
1029 				tclose1(nt);
1030 		}
1031 		b = allocimage(display, r, t->b->chan, 0, 0);
1032 		if(b == 0)
1033 			goto nobmem;
1034 		draw(b, r, t->b, nil, r.min);
1035 		freeimage(t->b);
1036 		t->b = b;
1037 		b = allocimage(display, r, t->b->chan, 0, 0);
1038 		if(b == 0)
1039 			goto nobmem;
1040 		redraw(t);
1041 		t->mod = 1;
1042 		return;
1043 	}
1044 	if(strcmp(tag, "ascent") == 0){
1045 		if(buf[0]<'0' || '9'<buf[0] || (ld=atoi(buf))<0 || ld>t->s->height){
1046 			mesg("illegal ascent");
1047 			return;
1048 		}
1049 		if(t->s->ascent == ld)
1050 			return;
1051 		t->s->ascent = ld;
1052 		text(t);
1053 		t->mod = 1;
1054 		return;
1055 	}
1056 	if(strcmp(tag, "height") == 0){
1057 		if(buf[0]<'0' || '9'<buf[0] || (ld=atoi(buf))<0){
1058 			mesg("illegal height");
1059 			return;
1060 		}
1061 		if(t->s->height == ld)
1062 			return;
1063 		t->s->height = ld;
1064 		text(t);
1065 		t->mod = 1;
1066 		return;
1067 	}
1068 	if(strcmp(tag, "left")==0 || strcmp(tag, "width") == 0){
1069 		if(buf[0]<'0' || '9'<buf[0] || (ld=atoi(buf))<0){
1070 			mesg("illegal value");
1071 			return;
1072 		}
1073 		fc = &t->parent->s->info[t->c];
1074 		if(strcmp(tag, "left")==0){
1075 			if(fc->left == ld)
1076 				return;
1077 			fc->left = ld;
1078 		}else{
1079 			if(fc->width == ld)
1080 				return;
1081 			fc->width = ld;
1082 		}
1083 		text(t);
1084 		t->parent->mod = 1;
1085 		return;
1086 	}
1087 	if(strcmp(tag, "offset(hex)") == 0){
1088 		if(!strchr(hex, buf[0])){
1089 	illoff:
1090 			mesg("illegal offset");
1091 			return;
1092 		}
1093 		s = 0;
1094 		ld = strtoul(buf, &s, 16);
1095 		if(*s)
1096 			goto illoff;
1097 		t->off = ld;
1098 		text(t);
1099 		for(nt=thing; nt; nt=nt->next)
1100 			if(nt->parent == t)
1101 				text(nt);
1102 		return;
1103 	}
1104 	if(strcmp(tag, "n") == 0){
1105 		if(buf[0]<'0' || '9'<buf[0] || (w=atoi(buf))<=0){
1106 			mesg("illegal n");
1107 			return;
1108 		}
1109 		f = t->s;
1110 		if(w == f->n)
1111 			return;
1112 		doredraw = 0;
1113 	again:
1114 		for(nt=thing; nt; nt=nt->next)
1115 			if(nt->parent == t){
1116 				doredraw = 1;
1117 				tclose1(nt);
1118 				goto again;
1119 			}
1120 		r = t->b->r;
1121 		if(w < f->n)
1122 			r.max.x = f->info[w].x;
1123 		b = allocimage(display, r, t->b->chan, 0, 0);
1124 		if(b == 0)
1125 			goto nobmem;
1126 		draw(b, b->r, t->b, nil, r.min);
1127 		fdx = Dx(editr) - 2*Border;
1128 		if(Dx(t->b->r)/fdx != Dx(b->r)/fdx)
1129 			doredraw = 1;
1130 		freeimage(t->b);
1131 		t->b = b;
1132 		b = allocimage(display, r, t->b->chan, 0, 0);
1133 		if(b == 0)
1134 			goto nobmem;
1135 		draw(b, b->r, t->b, nil, r.min);
1136 		nfc = malloc((w+1)*sizeof(Fontchar));
1137 		if(nfc == 0){
1138 			mesg("malloc failed");
1139 			freeimage(b);
1140 			return;
1141 		}
1142 		fc = f->info;
1143 		for(i=0; i<=w && i<=f->n; i++)
1144 			nfc[i] = fc[i];
1145 		if(i < w+1)
1146 			memset(nfc+i, 0, ((w+1)-i)*sizeof(Fontchar));
1147 		x = fc[f->n].x;
1148 		for(; i<=w; i++)
1149 			nfc[i].x = x;
1150 		f = allocsubfont(t->name, w, f->height, f->ascent, nfc, b);
1151 		if(f == 0)
1152 			goto nofmem;
1153 		t->s->bits = nil;	/* don't free it */
1154 		freesubfont(t->s);
1155 		f->info = nfc;
1156 		t->s = f;
1157 		if(doredraw)
1158 			redraw(thing);
1159 		else
1160 			drawthing(t, 0);
1161 		t->mod = 1;
1162 		return;
1163 	}
1164 	if(strcmp(tag, "iwidth") == 0){
1165 		if(buf[0]<'0' || '9'<buf[0] || (w=atoi(buf))<0){
1166 			mesg("illegal iwidth");
1167 			return;
1168 		}
1169 		w -= Dx(t->b->r);
1170 		if(w == 0)
1171 			return;
1172 		r = t->parent->b->r;
1173 		r.max.x += w;
1174 		c = t->c;
1175 		t = t->parent;
1176 		f = t->s;
1177 		b = allocimage(display, r, t->b->chan, 0, 0);
1178 		if(b == 0)
1179 			goto nobmem;
1180 		fc = &f->info[c];
1181 		draw(b, Rect(b->r.min.x, b->r.min.y,
1182 				b->r.min.x+(fc[1].x-t->b->r.min.x), b->r.min.y+Dy(t->b->r)),
1183 				t->b, nil, t->b->r.min);
1184 		draw(b, Rect(fc[1].x+w, b->r.min.y, w+t->b->r.max.x, b->r.min.y+Dy(t->b->r)),
1185 			t->b, nil, Pt(fc[1].x, t->b->r.min.y));
1186 		fdx = Dx(editr) - 2*Border;
1187 		doredraw = 0;
1188 		if(Dx(t->b->r)/fdx != Dx(b->r)/fdx)
1189 			doredraw = 1;
1190 		freeimage(t->b);
1191 		t->b = b;
1192 		b = allocimage(display, r, t->b->chan, 0, 0);
1193 		if(b == 0)
1194 			goto nobmem;
1195 		draw(b, b->r, t->b, nil, t->b->r.min);
1196 		fc = &f->info[c+1];
1197 		for(i=c+1; i<=f->n; i++, fc++)
1198 			fc->x += w;
1199 		f = allocsubfont(t->name, f->n, f->height, f->ascent,
1200 			f->info, b);
1201 		if(f == 0)
1202 			goto nofmem;
1203 		/* t->s and f share info; free carefully */
1204 		fc = f->info;
1205 		t->s->bits = nil;
1206 		t->s->info = 0;
1207 		freesubfont(t->s);
1208 		f->info = fc;
1209 		t->s = f;
1210 		if(doredraw)
1211 			redraw(t);
1212 		else
1213 			drawthing(t, 0);
1214 		/* redraw all affected chars */
1215 		for(nt=thing; nt; nt=nt->next){
1216 			if(nt->parent!=t || nt->c<c)
1217 				continue;
1218 			fc = &f->info[nt->c];
1219 			r.min.x = fc[0].x;
1220 			r.min.y = nt->b->r.min.y;
1221 			r.max.x = fc[1].x;
1222 			r.max.y = nt->b->r.max.y;
1223 			b = allocimage(display, r, nt->b->chan, 0, 0);
1224 			if(b == 0)
1225 				goto nobmem;
1226 			draw(b, r, t->b, nil, r.min);
1227 			doredraw = 0;
1228 			if(Dx(nt->b->r)/fdx != Dx(b->r)/fdx)
1229 				doredraw = 1;
1230 			freeimage(nt->b);
1231 			nt->b = b;
1232 			if(c != nt->c)
1233 				text(nt);
1234 			else{
1235 				if(doredraw)
1236 					redraw(nt);
1237 				else
1238 					drawthing(nt, 0);
1239 			}
1240 		}
1241 		t->mod = 1;
1242 		return;
1243 	}
1244 	mesg("cannot edit %s in file %s", tag, t->name);
1245 }
1246 
1247 void
1248 cntledit(char *tag)
1249 {
1250 	char buf[256];
1251 	ulong l;
1252 
1253 	buttons(Up);
1254 	if(type(buf, tag) == 0)
1255 		return;
1256 	if(strcmp(tag, "mag") == 0){
1257 		if(buf[0]<'0' || '9'<buf[0] || (l=atoi(buf))<=0 || l>Maxmag){
1258 			mesg("illegal magnification");
1259 			return;
1260 		}
1261 		mag = l;
1262 		cntl();
1263 		return;
1264 	}
1265 	if(strcmp(tag, "but1")==0
1266 	|| strcmp(tag, "but2")==0){
1267 		if(buf[0]<'0' || '9'<buf[0] || (long)(l=atoi(buf))<0 || l>255){
1268 			mesg("illegal value");
1269 			return;
1270 		}
1271 		if(strcmp(tag, "but1") == 0)
1272 			but1val = l;
1273 		else if(strcmp(tag, "but2") == 0)
1274 			but2val = l;
1275 		cntl();
1276 		return;
1277 	}
1278 	if(strcmp(tag, "invert-on-copy")==0){
1279 		if(buf[0]=='y' || buf[0]=='1')
1280 			invert = 1;
1281 		else if(buf[0]=='n' || buf[0]=='0')
1282 			invert = 0;
1283 		else{
1284 			mesg("illegal value");
1285 			return;
1286 		}
1287 		cntl();
1288 		return;
1289 	}
1290 	mesg("cannot edit %s", tag);
1291 }
1292 
1293 void
1294 buttons(int ud)
1295 {
1296 	while((mouse.buttons==0) != ud)
1297 		mouse = emouse();
1298 }
1299 
1300 Point
1301 screenpt(Thing *t, Point realp)
1302 {
1303 	int fdx, n;
1304 	Point p;
1305 
1306 	fdx = Dx(editr)-2*Border;
1307 	if(t->mag > 1)
1308 		fdx -= fdx%t->mag;
1309 	p = mulpt(subpt(realp, t->b->r.min), t->mag);
1310 	if(fdx < Dx(t->b->r)*t->mag){
1311 		n = p.x/fdx;
1312 		p.y += n * (Dy(t->b->r)*t->mag+Border);
1313 		p.x -= n * fdx;
1314 	}
1315 	p = addpt(p, t->r.min);
1316 	return p;
1317 }
1318 
1319 Point
1320 realpt(Thing *t, Point screenp)
1321 {
1322 	int fdx, n, dy;
1323 	Point p;
1324 
1325 	fdx = (Dx(editr)-2*Border);
1326 	if(t->mag > 1)
1327 		fdx -= fdx%t->mag;
1328 	p.y = screenp.y-t->r.min.y;
1329 	p.x = 0;
1330 	if(fdx < Dx(t->b->r)*t->mag){
1331 		dy = Dy(t->b->r)*t->mag+Border;
1332 		n = (p.y/dy);
1333 		p.x = n * fdx;
1334 		p.y -= n * dy;
1335 	}
1336 	p.x += screenp.x-t->r.min.x;
1337 	p = addpt(divpt(p, t->mag), t->b->r.min);
1338 	return p;
1339 }
1340 
1341 int
1342 sweep(int but, Rectangle *r)
1343 {
1344 	Thing *t;
1345 	Point p, q, lastq;
1346 
1347 	esetcursor(&sweep0);
1348 	buttons(Down);
1349 	if(mouse.buttons != (1<<(but-1))){
1350 		buttons(Up);
1351 		esetcursor(0);
1352 		return 0;
1353 	}
1354 	p = mouse.xy;
1355 	for(t=thing; t; t=t->next)
1356 		if(ptinrect(p, t->r))
1357 			break;
1358 	if(t)
1359 		p = screenpt(t, realpt(t, p));
1360 	r->min = p;
1361 	r->max = p;
1362 	esetcursor(&box);
1363 	lastq = ZP;
1364 	while(mouse.buttons == (1<<(but-1))){
1365 		edrawgetrect(insetrect(*r, -Borderwidth), 1);
1366 		mouse = emouse();
1367 		edrawgetrect(insetrect(*r, -Borderwidth), 0);
1368 		q = mouse.xy;
1369 		if(t)
1370 			q = screenpt(t, realpt(t, q));
1371 		if(eqpt(q, lastq))
1372 			continue;
1373 		*r = canonrect(Rpt(p, q));
1374 		lastq = q;
1375 	}
1376 	esetcursor(0);
1377 	if(mouse.buttons){
1378 		buttons(Up);
1379 		return 0;
1380 	}
1381 	return 1;
1382 }
1383 
1384 void
1385 openedit(Thing *t, Point pt, int c)
1386 {
1387 	int x, y;
1388 	Point p;
1389 	Rectangle r;
1390 	Rectangle br;
1391 	Fontchar *fc;
1392 	Thing *nt;
1393 
1394 	if(t->b->depth > 8){
1395 		mesg("image has depth %d; can't handle >8", t->b->depth);
1396 		return;
1397 	}
1398 	br = t->b->r;
1399 	if(t->s == 0){
1400 		c = -1;
1401 		/* if big enough to bother, sweep box */
1402 		if(Dx(br)<=16 && Dy(br)<=16)
1403 			r = br;
1404 		else{
1405 			if(!sweep(1, &r))
1406 				return;
1407 			r = rectaddpt(r, subpt(br.min, t->r.min));
1408 			if(!rectclip(&r, br))
1409 				return;
1410 			if(Dx(br) <= 8){
1411 				r.min.x = br.min.x;
1412 				r.max.x = br.max.x;
1413 			}else if(Dx(r) < 4){
1414 	    toosmall:
1415 				mesg("rectangle too small");
1416 				return;
1417 			}
1418 			if(Dy(br) <= 8){
1419 				r.min.y = br.min.y;
1420 				r.max.y = br.max.y;
1421 			}else if(Dy(r) < 4)
1422 				goto toosmall;
1423 		}
1424 	}else if(c >= 0){
1425 		fc = &t->s->info[c];
1426 		r.min.x = fc[0].x;
1427 		r.min.y = br.min.y;
1428 		r.max.x = fc[1].x;
1429 		r.max.y = br.min.y + Dy(br);
1430 	}else{
1431 		/* just point at character */
1432 		fc = t->s->info;
1433 		p = addpt(pt, subpt(br.min, t->r.min));
1434 		x = br.min.x;
1435 		y = br.min.y;
1436 		for(c=0; c<t->s->n; c++,fc++){
1437 	    again:
1438 			r.min.x = x;
1439 			r.min.y = y;
1440 			r.max.x = x + fc[1].x - fc[0].x;
1441 			r.max.y = y + Dy(br);
1442 			if(ptinrect(p, r))
1443 				goto found;
1444 			if(r.max.x >= br.min.x+Dx(t->r)){
1445 				x -= Dx(t->r);
1446 				y += t->s->height;
1447 				if(fc[1].x > fc[0].x)
1448 					goto again;
1449 			}
1450 			x += fc[1].x - fc[0].x;
1451 		}
1452 		return;
1453 	   found:
1454 		r = br;
1455 		r.min.x = fc[0].x;
1456 		r.max.x = fc[1].x;
1457 	}
1458 	nt = malloc(sizeof(Thing));
1459 	if(nt == 0){
1460    nomem:
1461 		mesg("can't allocate: %r");
1462 		return;
1463 	}
1464 	memset(nt, 0, sizeof(Thing));
1465 	nt->c = c;
1466 	nt->b = allocimage(display, r, t->b->chan, 0, DNofill);
1467 	if(nt->b == 0){
1468 		free(nt);
1469 		goto nomem;
1470 	}
1471 	draw(nt->b, r, t->b, nil, r.min);
1472 	nt->name = strdup(t->name);
1473 	if(nt->name == 0){
1474 		freeimage(nt->b);
1475 		free(nt);
1476 		goto nomem;
1477 	}
1478 	nt->parent = t;
1479 	nt->mag = mag;
1480 	drawthing(nt, 1);
1481 }
1482 
1483 void
1484 ckinfo(Thing *t, Rectangle mod)
1485 {
1486 	int i, j, k, top, bot, n, zero;
1487 	Fontchar *fc;
1488 	Rectangle r;
1489 	Image *b;
1490 	Thing *nt;
1491 
1492 	if(t->parent)
1493 		t = t->parent;
1494 	if(t->s==0 || Dy(t->b->r)==0)
1495 		return;
1496 	b = 0;
1497 	/* check bounding boxes */
1498 	fc = &t->s->info[0];
1499 	r.min.y = t->b->r.min.y;
1500 	r.max.y = t->b->r.max.y;
1501 	for(i=0; i<t->s->n; i++, fc++){
1502 		r.min.x = fc[0].x;
1503 		r.max.x = fc[1].x;
1504 		if(!rectXrect(mod, r))
1505 			continue;
1506 		if(b==0 || Dx(b->r)<Dx(r)){
1507 			if(b)
1508 				freeimage(b);
1509 			b = allocimage(display, rectsubpt(r, r.min), t->b->chan, 0, 0);
1510 			if(b == 0){
1511 				mesg("can't alloc image");
1512 				break;
1513 			}
1514 		}
1515 		draw(b, b->r, display->white, nil, ZP);
1516 		draw(b, b->r, t->b, nil, r.min);
1517 		top = 100000;
1518 		bot = 0;
1519 		n = 2+((Dx(r)/8)*t->b->depth);
1520 		for(j=0; j<b->r.max.y; j++){
1521 			memset(data, 0, n);
1522 			unloadimage(b, Rect(b->r.min.x, j, b->r.max.x, j+1), data, sizeof data);
1523 			zero = 1;
1524 			for(k=0; k<n; k++)
1525 				if(data[k]){
1526 					zero = 0;
1527 					break;
1528 				}
1529 			if(!zero){
1530 				if(top > j)
1531 					top = j;
1532 				bot = j+1;
1533 			}
1534 		}
1535 		if(top > j)
1536 			top = 0;
1537 		if(top!=fc->top || bot!=fc->bottom){
1538 			fc->top = top;
1539 			fc->bottom = bot;
1540 			for(nt=thing; nt; nt=nt->next)
1541 				if(nt->parent==t && nt->c==i)
1542 					text(nt);
1543 		}
1544 	}
1545 	if(b)
1546 		freeimage(b);
1547 }
1548 
1549 void
1550 twidpix(Thing *t, Point p, int set)
1551 {
1552 	Image *b, *v;
1553 	int c;
1554 
1555 	b = t->b;
1556 	if(!ptinrect(p, b->r))
1557 		return;
1558 	if(set)
1559 		c = but1val;
1560 	else
1561 		c = but2val;
1562 	if(b->chan == GREY8)
1563 		v = greyvalues[c];
1564 	else
1565 		v = values[c];
1566 	draw(b, Rect(p.x, p.y, p.x+1, p.y+1), v, nil, ZP);
1567 	p = screenpt(t, p);
1568 	draw(screen, Rect(p.x, p.y, p.x+t->mag, p.y+t->mag), v, nil, ZP);
1569 }
1570 
1571 void
1572 twiddle(Thing *t)
1573 {
1574 	int set;
1575 	Point p, lastp;
1576 	Image *b;
1577 	Thing *nt;
1578 	Rectangle mod;
1579 
1580 	if(mouse.buttons!=1 && mouse.buttons!=2){
1581 		buttons(Up);
1582 		return;
1583 	}
1584 	set = mouse.buttons==1;
1585 	b = t->b;
1586 	lastp = addpt(b->r.min, Pt(-1, -1));
1587 	mod = Rpt(addpt(b->r.max, Pt(1, 1)), lastp);
1588 	while(mouse.buttons){
1589 		p = realpt(t, mouse.xy);
1590 		if(!eqpt(p, lastp)){
1591 			lastp = p;
1592 			if(ptinrect(p, b->r)){
1593 				for(nt=thing; nt; nt=nt->next)
1594 					if(nt->parent==t->parent || nt==t->parent)
1595 						twidpix(nt, p, set);
1596 				if(t->parent)
1597 					t->parent->mod = 1;
1598 				else
1599 					t->mod = 1;
1600 				if(p.x < mod.min.x)
1601 					mod.min.x = p.x;
1602 				if(p.y < mod.min.y)
1603 					mod.min.y = p.y;
1604 				if(p.x >= mod.max.x)
1605 					mod.max.x = p.x+1;
1606 				if(p.y >= mod.max.y)
1607 					mod.max.y = p.y+1;
1608 			}
1609 		}
1610 		mouse = emouse();
1611 	}
1612 	ckinfo(t, mod);
1613 }
1614 
1615 void
1616 xselect(void)
1617 {
1618 	Thing *t;
1619 	char line[128], buf[128];
1620 	Point p;
1621 
1622 	if(ptinrect(mouse.xy, cntlr)){
1623 		scntl(line);
1624 		if(atline(cntlr.min.x, mouse.xy, line, buf)){
1625 			if(mouse.buttons == 1)
1626 				cntledit(buf);
1627 			else
1628 				buttons(Up);
1629 			return;
1630 		}
1631 		return;
1632 	}
1633 	for(t=thing; t; t=t->next){
1634 		if(attext(t, mouse.xy, buf)){
1635 			if(mouse.buttons == 1)
1636 				textedit(t, buf);
1637 			else
1638 				buttons(Up);
1639 			return;
1640 		}
1641 		if(ptinrect(mouse.xy, t->r)){
1642 			if(t->parent == 0){
1643 				if(mouse.buttons == 1){
1644 					p = mouse.xy;
1645 					buttons(Up);
1646 					openedit(t, p, -1);
1647 				}else
1648 					buttons(Up);
1649 				return;
1650 			}
1651 			twiddle(t);
1652 			return;
1653 		}
1654 	}
1655 }
1656 
1657 void
1658 twrite(Thing *t)
1659 {
1660 	int i, j, x, y, fd, ws, ld;
1661 	Biobuf buf;
1662 	Rectangle r;
1663 
1664 	if(t->parent)
1665 		t = t->parent;
1666 	esetcursor(&busy);
1667 	fd = create(t->name, OWRITE, 0666);
1668 	if(fd < 0){
1669 		mesg("can't write %s: %r", t->name);
1670 		return;
1671 	}
1672 	if(t->face && t->b->depth <= 4){
1673 		r = t->b->r;
1674 		ld = xlog2(t->b->depth);
1675 		/* This heuristic reflects peculiarly different formats */
1676 		ws = 4;
1677 		if(t->face == 2)	/* cursor file */
1678 			ws = 1;
1679 		else if(Dx(r)<32 || ld==0)
1680 			ws = 2;
1681 		Binit(&buf, fd, OWRITE);
1682 		if(t->face == CURSOR)
1683 			Bprint(&buf, "{");
1684 		for(y=r.min.y; y<r.max.y; y++){
1685 			unloadimage(t->b, Rect(r.min.x, y, r.max.x, y+1), data, sizeof data);
1686 			j = 0;
1687 			for(x=r.min.x; x<r.max.x; j+=ws,x+=ws*8>>ld){
1688 				Bprint(&buf, "0x");
1689 				for(i=0; i<ws; i++)
1690 					Bprint(&buf, "%.2x", data[i+j]);
1691 				Bprint(&buf, ", ");
1692 			}
1693 			if(t->face == CURSOR) {
1694 				if(y == Dy(r)/2-1)
1695 					Bprint(&buf, "},\n{");
1696 				else if(y == Dy(r)-1)
1697 					Bprint(&buf, "}\n");
1698 				else
1699 					Bprint(&buf, "\n\t");
1700 			}else
1701 				Bprint(&buf, "\n");
1702 		}
1703 		Bterm(&buf);
1704 	}else
1705 		if(writeimage(fd, t->b, 0)<0 || (t->s && writesubfont(fd, t->s)<0)){
1706 			close(fd);
1707 			mesg("can't write %s: %r", t->name);
1708 		}
1709 	t->mod = 0;
1710 	close(fd);
1711 	mesg("wrote %s", t->name);
1712 }
1713 
1714 void
1715 tpixels(void)
1716 {
1717 	Thing *t;
1718 	Point p, lastp;
1719 
1720 	esetcursor(&pixel);
1721 	for(;;){
1722 		buttons(Down);
1723 		if(mouse.buttons != 4)
1724 			break;
1725 		for(t=thing; t; t=t->next){
1726 			lastp = Pt(-1, -1);
1727 			if(ptinrect(mouse.xy, t->r)){
1728 				while(ptinrect(mouse.xy, t->r) && mouse.buttons==4){
1729 					p = realpt(t, mouse.xy);
1730 					if(!eqpt(p, lastp)){
1731 						if(p.y != lastp.y)
1732 							unloadimage(t->b, Rect(t->b->r.min.x, p.y, t->b->r.max.x, p.y+1), data, sizeof data);
1733 						mesg("[%d,%d] = %d=0x%ux", p.x, p.y, value(t->b, p.x), value(t->b, p.x));
1734 						lastp = p;
1735 					}
1736 					mouse = emouse();
1737 				}
1738 				goto Continue;
1739 			}
1740 		}
1741 		mouse = emouse();
1742     Continue:;
1743 	}
1744 	buttons(Up);
1745 	esetcursor(0);
1746 }
1747 
1748 void
1749 tclose1(Thing *t)
1750 {
1751 	Thing *nt;
1752 
1753 	if(t == thing)
1754 		thing = t->next;
1755 	else{
1756 		for(nt=thing; nt->next!=t; nt=nt->next)
1757 			;
1758 		nt->next = t->next;
1759 	}
1760 	do
1761 		for(nt=thing; nt; nt=nt->next)
1762 			if(nt->parent == t){
1763 				tclose1(nt);
1764 				break;
1765 			}
1766 	while(nt);
1767 	if(t->s)
1768 		freesubfont(t->s);
1769 	else
1770 		freeimage(t->b);
1771 	free(t->name);
1772 	free(t);
1773 }
1774 
1775 void
1776 tclose(Thing *t)
1777 {
1778 	Thing *ct;
1779 
1780 	if(t->mod){
1781 		mesg("%s modified", t->name);
1782 		t->mod = 0;
1783 		return;
1784 	}
1785 	/* fiddle to save redrawing unmoved things */
1786 	if(t == thing)
1787 		ct = 0;
1788 	else
1789 		for(ct=thing; ct; ct=ct->next)
1790 			if(ct->next==t || ct->next->parent==t)
1791 				break;
1792 	tclose1(t);
1793 	if(ct)
1794 		ct = ct->next;
1795 	else
1796 		ct = thing;
1797 	redraw(ct);
1798 }
1799 
1800 void
1801 tread(Thing *t)
1802 {
1803 	Thing *nt, *new;
1804 	Fontchar *i;
1805 	Rectangle r;
1806 	int nclosed;
1807 
1808 	if(t->parent)
1809 		t = t->parent;
1810 	new = tget(t->name, 0);
1811 	if(new == 0)
1812 		return;
1813 	nclosed = 0;
1814     again:
1815 	for(nt=thing; nt; nt=nt->next)
1816 		if(nt->parent == t){
1817 			if(!rectinrect(nt->b->r, new->b->r)
1818 			|| new->b->depth!=nt->b->depth){
1819     closeit:
1820 				nclosed++;
1821 				nt->parent = 0;
1822 				tclose1(nt);
1823 				goto again;
1824 			}
1825 			if((t->s==0) != (new->s==0))
1826 				goto closeit;
1827 			if((t->face==0) != (new->face==0))
1828 				goto closeit;
1829 			if(t->s){	/* check same char */
1830 				if(nt->c >= new->s->n)
1831 					goto closeit;
1832 				i = &new->s->info[nt->c];
1833 				r.min.x = i[0].x;
1834 				r.max.x = i[1].x;
1835 				r.min.y = new->b->r.min.y;
1836 				r.max.y = new->b->r.max.y;
1837 				if(!eqrect(r, nt->b->r))
1838 					goto closeit;
1839 			}
1840 			nt->parent = new;
1841 			draw(nt->b, nt->b->r, new->b, nil, nt->b->r.min);
1842 		}
1843 	new->next = t->next;
1844 	if(t == thing)
1845 		thing = new;
1846 	else{
1847 		for(nt=thing; nt->next!=t; nt=nt->next)
1848 			;
1849 		nt->next = new;
1850 	}
1851 	if(t->s)
1852 		freesubfont(t->s);
1853 	else
1854 		freeimage(t->b);
1855 	free(t->name);
1856 	free(t);
1857 	for(nt=thing; nt; nt=nt->next)
1858 		if(nt==new || nt->parent==new)
1859 			if(nclosed == 0)
1860 				drawthing(nt, 0);	/* can draw in place */
1861 			else{
1862 				redraw(nt);	/* must redraw all below */
1863 				break;
1864 			}
1865 }
1866 
1867 void
1868 tchar(Thing *t)
1869 {
1870 	char buf[256], *p;
1871 	Rune r;
1872 	ulong c, d;
1873 
1874 	if(t->s == 0){
1875 		t = t->parent;
1876 		if(t==0 || t->s==0){
1877 			mesg("not a subfont");
1878 			return;
1879 		}
1880 	}
1881 	if(type(buf, "char (hex or character or hex-hex)") == 0)
1882 		return;
1883 	if(utflen(buf) == 1){
1884 		chartorune(&r, buf);
1885 		c = r;
1886 		d = r;
1887 	}else{
1888 		if(!strchr(hex, buf[0])){
1889 			mesg("illegal hex character");
1890 			return;
1891 		}
1892 		c = strtoul(buf, 0, 16);
1893 		d = c;
1894 		p = utfrune(buf, '-');
1895 		if(p){
1896 			d = strtoul(p+1, 0, 16);
1897 			if(d < c){
1898 				mesg("invalid range");
1899 				return;
1900 			}
1901 		}
1902 	}
1903 	c -= t->off;
1904 	d -= t->off;
1905 	while(c <= d){
1906 		if((long)c<0 || c>=t->s->n){
1907 			mesg("0x%lux not in font %s", c+t->off, t->name);
1908 			return;
1909 		}
1910 		openedit(t, Pt(0, 0), c);
1911 		c++;
1912 	}
1913 }
1914 
1915 void
1916 apply(void (*f)(Thing*))
1917 {
1918 	Thing *t;
1919 
1920 	esetcursor(&sight);
1921 	buttons(Down);
1922 	if(mouse.buttons == 4)
1923 		for(t=thing; t; t=t->next)
1924 			if(ptinrect(mouse.xy, t->er)){
1925 				buttons(Up);
1926 				f(t);
1927 				break;
1928 			}
1929 	buttons(Up);
1930 	esetcursor(0);
1931 }
1932 
1933 int
1934 complement(Image *t)
1935 {
1936 	int i, n;
1937 	uchar *buf;
1938 
1939 	n = Dy(t->r)*bytesperline(t->r, t->depth);
1940 	buf = malloc(n);
1941 	if(buf == 0)
1942 		return 0;
1943 	unloadimage(t, t->r, buf, n);
1944 	for(i=0; i<n; i++)
1945 		buf[i] = ~buf[i];
1946 	loadimage(t, t->r, buf, n);
1947 	free(buf);
1948 	return 1;
1949 }
1950 
1951 void
1952 copy(void)
1953 {
1954 	Thing *st, *dt, *nt;
1955 	Rectangle sr, dr, fr;
1956 	Image *tmp;
1957 	Point p1, p2;
1958 	int but, up;
1959 
1960 	if(!sweep(3, &sr))
1961 		return;
1962 	for(st=thing; st; st=st->next)
1963 		if(rectXrect(sr, st->r))
1964 			break;
1965 	if(st == 0)
1966 		return;
1967 	/* click gives full rectangle */
1968 	if(Dx(sr)<4 && Dy(sr)<4)
1969 		sr = st->r;
1970 	rectclip(&sr, st->r);
1971 	p1 = realpt(st, sr.min);
1972 	p2 = realpt(st, Pt(sr.min.x, sr.max.y));
1973 	up = 0;
1974 	if(p1.x != p2.x){	/* swept across a fold */
1975    onafold:
1976 		mesg("sweep spans a fold");
1977 		goto Return;
1978 	}
1979 	p2 = realpt(st, sr.max);
1980 	sr.min = p1;
1981 	sr.max = p2;
1982 	fr.min = screenpt(st, sr.min);
1983 	fr.max = screenpt(st, sr.max);
1984 	p1 = subpt(p2, p1);	/* diagonal */
1985 	if(p1.x==0 || p1.y==0)
1986 		return;
1987 	border(screen, fr, -1, values[Blue], ZP);
1988 	esetcursor(&box);
1989 	for(; mouse.buttons==0; mouse=emouse()){
1990 		for(dt=thing; dt; dt=dt->next)
1991 			if(ptinrect(mouse.xy, dt->er))
1992 				break;
1993 		if(up)
1994 			edrawgetrect(insetrect(dr, -Borderwidth), 0);
1995 		up = 0;
1996 		if(dt == 0)
1997 			continue;
1998 		dr.max = screenpt(dt, realpt(dt, mouse.xy));
1999 		dr.min = subpt(dr.max, mulpt(p1, dt->mag));
2000 		if(!rectXrect(dr, dt->r))
2001 			continue;
2002 		edrawgetrect(insetrect(dr, -Borderwidth), 1);
2003 		up = 1;
2004 	}
2005 	/* if up==1, we had a hit */
2006 	esetcursor(0);
2007 	if(up)
2008 		edrawgetrect(insetrect(dr, -Borderwidth), 0);
2009 	but = mouse.buttons;
2010 	buttons(Up);
2011 	if(!up || but!=4)
2012 		goto Return;
2013 	dt = 0;
2014 	for(nt=thing; nt; nt=nt->next)
2015 		if(rectXrect(dr, nt->r)){
2016 			if(dt){
2017 				mesg("ambiguous sweep");
2018 				return;
2019 			}
2020 			dt = nt;
2021 		}
2022 	if(dt == 0)
2023 		goto Return;
2024 	p1 = realpt(dt, dr.min);
2025 	p2 = realpt(dt, Pt(dr.min.x, dr.max.y));
2026 	if(p1.x != p2.x)
2027 		goto onafold;
2028 	p2 = realpt(dt, dr.max);
2029 	dr.min = p1;
2030 	dr.max = p2;
2031 
2032 	if(invert){
2033 		tmp = allocimage(display, dr, dt->b->chan, 0, 255);
2034 		if(tmp == 0){
2035     nomem:
2036 			mesg("can't allocate temporary");
2037 			goto Return;
2038 		}
2039 		draw(tmp, dr, st->b, nil, sr.min);
2040 		if(!complement(tmp))
2041 			goto nomem;
2042 		draw(dt->b, dr, tmp, nil, dr.min);
2043 		freeimage(tmp);
2044 	}else
2045 		draw(dt->b, dr, st->b, nil, sr.min);
2046 	if(dt->parent){
2047 		draw(dt->parent->b, dr, dt->b, nil, dr.min);
2048 		dt = dt->parent;
2049 	}
2050 	drawthing(dt, 0);
2051 	for(nt=thing; nt; nt=nt->next)
2052 		if(nt->parent==dt && rectXrect(dr, nt->b->r)){
2053 			draw(nt->b, dr, dt->b, nil, dr.min);
2054 			drawthing(nt, 0);
2055 		}
2056 	ckinfo(dt, dr);
2057 	dt->mod = 1;
2058 
2059 Return:
2060 	/* clear blue box */
2061 	drawthing(st, 0);
2062 }
2063 
2064 void
2065 menu(void)
2066 {
2067 	Thing *t;
2068 	char *mod;
2069 	int sel;
2070 	char buf[256];
2071 
2072 	sel = emenuhit(3, &mouse, &menu3);
2073 	switch(sel){
2074 	case Mopen:
2075 		if(type(buf, "file")){
2076 			t = tget(buf, 0);
2077 			if(t)
2078 				drawthing(t, 1);
2079 		}
2080 		break;
2081 	case Mwrite:
2082 		apply(twrite);
2083 		break;
2084 	case Mread:
2085 		apply(tread);
2086 		break;
2087 	case Mchar:
2088 		apply(tchar);
2089 		break;
2090 	case Mcopy:
2091 		copy();
2092 		break;
2093 	case Mpixels:
2094 		tpixels();
2095 		break;
2096 	case Mclose:
2097 		apply(tclose);
2098 		break;
2099 	case Mexit:
2100 		mod = 0;
2101 		for(t=thing; t; t=t->next)
2102 			if(t->mod){
2103 				mod = t->name;
2104 				t->mod = 0;
2105 			}
2106 		if(mod){
2107 			mesg("%s modified", mod);
2108 			break;
2109 		}
2110 		esetcursor(&skull);
2111 		buttons(Down);
2112 		if(mouse.buttons == 4){
2113 			buttons(Up);
2114 			exits(0);
2115 		}
2116 		buttons(Up);
2117 		esetcursor(0);
2118 		break;
2119 	}
2120 }