op public repos

Blob

Date:: Fri Jan 10 14:54:30 2020 UTC
Message:: Trivial changes: whitespace and modes. Remote whitespace at the ends of lines. Remove blank lines from the ends of files. Change modes on source files so that they are not executable. Signed-off-by: Dan Cross <cross@gajendra.net>
Actions:: History | Blame | Raw File
1 /*
2 This code was taken from 9front repository (https://code.9front.org/hg/plan9front).
3 It is subject to license from 9front, below is a reproduction of the license.
4 
5 Copyright (c) 20XX 9front
6 
7 Permission is hereby granted, free of charge, to any person obtaining a copy
8 of this software and associated documentation files (the "Software"), to deal
9 in the Software without restriction, including without limitation the rights
10 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 copies of the Software, and to permit persons to whom the Software is
12 furnished to do so, subject to the following conditions:
13 
14 The above copyright notice and this permission notice shall be included in all
15 copies or substantial portions of the Software.
16 
17 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23 SOFTWARE.
24 */
25 #include <u.h>
26 #include <libc.h>
27 #include <draw.h>
28 #include <event.h>
29 #include <keyboard.h>
30 
31 /* additional libdraw function needed - defined here to avoid API change */
32 extern int             eenter(char*, char*, int, Mouse*);
33 
34 char *filename;
35 int zoom = 1;
36 int brush = 1;
37 Point spos;		/* position on screen */
38 Point cpos;		/* position on canvas */
39 Image *canvas;
40 Image *ink;
41 Image *back;
42 Image *pal[16];		/* palette */
43 Rectangle palr;		/* palette rect on screen */
44 Rectangle penr;		/* pen size rect on screen */
45 
46 enum {
47 	NBRUSH = 10+1,
48 };
49 
50 int nundo = 0;
51 Image *undo[1024];
52 
53 int c64[] = {		/* c64 color palette */
54 	0x000000,
55 	0xFFFFFF,
56 	0x68372B,
57 	0x70A4B2,
58 	0x6F3D86,
59 	0x588D43,
60 	0x352879,
61 	0xB8C76F,
62 	0x6F4F25,
63 	0x433900,
64 	0x9A6759,
65 	0x444444,
66 	0x6C6C6C,
67 	0x9AD284,
68 	0x6C5EB5,
69 	0x959595,
70 };
71 
72 /*
73  * get bounding rectnagle for stroke from r.min to r.max with
74  * specified brush (size).
75  */
76 static Rectangle
77 strokerect(Rectangle r, int brush)
78 {
79 	r = canonrect(r);
80 	return Rect(r.min.x-brush, r.min.y-brush, r.max.x+brush+1, r.max.y+brush+1);
81 }
82 
83 /*
84  * draw stroke from r.min to r.max to dst with color ink and
85  * brush (size).
86  */
87 static void
88 strokedraw(Image *dst, Rectangle r, Image *ink, int brush)
89 {
90 	if(!eqpt(r.min, r.max))
91 		line(dst, r.min, r.max, Enddisc, Enddisc, brush, ink, ZP);
92 	fillellipse(dst, r.max, brush, brush, ink, ZP);
93 }
94 
95 /*
96  * A draw operation that touches only the area contained in bot but not in top.
97  * mp and sp get aligned with bot.min.
98  */
99 static void
100 gendrawdiff(Image *dst, Rectangle bot, Rectangle top,
101 	Image *src, Point sp, Image *mask, Point mp, int op)
102 {
103 	Rectangle r;
104 	Point origin;
105 	Point delta;
106 
107 	if(Dx(bot)*Dy(bot) == 0)
108 		return;
109 
110 	/* no points in bot - top */
111 	if(rectinrect(bot, top))
112 		return;
113 
114 	/* bot - top ≡ bot */
115 	if(Dx(top)*Dy(top)==0 || rectXrect(bot, top)==0){
116 		gendrawop(dst, bot, src, sp, mask, mp, op);
117 		return;
118 	}
119 
120 	origin = bot.min;
121 	/* split bot into rectangles that don't intersect top */
122 	/* left side */
123 	if(bot.min.x < top.min.x){
124 		r = Rect(bot.min.x, bot.min.y, top.min.x, bot.max.y);
125 		delta = subpt(r.min, origin);
126 		gendrawop(dst, r, src, addpt(sp, delta), mask, addpt(mp, delta), op);
127 		bot.min.x = top.min.x;
128 	}
129 
130 	/* right side */
131 	if(bot.max.x > top.max.x){
132 		r = Rect(top.max.x, bot.min.y, bot.max.x, bot.max.y);
133 		delta = subpt(r.min, origin);
134 		gendrawop(dst, r, src, addpt(sp, delta), mask, addpt(mp, delta), op);
135 		bot.max.x = top.max.x;
136 	}
137 
138 	/* top */
139 	if(bot.min.y < top.min.y){
140 		r = Rect(bot.min.x, bot.min.y, bot.max.x, top.min.y);
141 		delta = subpt(r.min, origin);
142 		gendrawop(dst, r, src, addpt(sp, delta), mask, addpt(mp, delta), op);
143 		bot.min.y = top.min.y;
144 	}
145 
146 	/* bottom */
147 	if(bot.max.y > top.max.y){
148 		r = Rect(bot.min.x, top.max.y, bot.max.x, bot.max.y);
149 		delta = subpt(r.min, origin);
150 		gendrawop(dst, r, src, addpt(sp, delta), mask, addpt(mp, delta), op);
151 		bot.max.y = top.max.y;
152 	}
153 }
154 
155 int
156 alphachan(ulong chan)
157 {
158 	for(; chan; chan >>= 8)
159 		if(TYPE(chan) == CAlpha)
160 			return 1;
161 	return 0;
162 }
163 
164 void
165 zoomdraw(Image *d, Rectangle r, Rectangle top, Image *b, Image *s, Point sp, int f)
166 {
167 	Rectangle dr;
168 	Image *t;
169 	Point a;
170 	int w;
171 
172 	a = ZP;
173 	if(r.min.x < d->r.min.x){
174 		sp.x += (d->r.min.x - r.min.x)/f;
175 		a.x = (d->r.min.x - r.min.x)%f;
176 		r.min.x = d->r.min.x;
177 	}
178 	if(r.min.y < d->r.min.y){
179 		sp.y += (d->r.min.y - r.min.y)/f;
180 		a.y = (d->r.min.y - r.min.y)%f;
181 		r.min.y = d->r.min.y;
182 	}
183 	rectclip(&r, d->r);
184 	w = s->r.max.x - sp.x;
185 	if(w > Dx(r))
186 		w = Dx(r);
187 	dr = r;
188 	dr.max.x = dr.min.x+w;
189 	if(!alphachan(s->chan))
190 		b = nil;
191 	if(f <= 1){
192 		if(b) gendrawdiff(d, dr, top, b, sp, nil, ZP, SoverD);
193 		gendrawdiff(d, dr, top, s, sp, nil, ZP, SoverD);
194 		return;
195 	}
196 	if((t = allocimage(display, dr, s->chan, 0, 0)) == nil)
197 		return;
198 	for(; dr.min.y < r.max.y; dr.min.y++){
199 		dr.max.y = dr.min.y+1;
200 		draw(t, dr, s, nil, sp);
201 		if(++a.y == f){
202 			a.y = 0;
203 			sp.y++;
204 		}
205 	}
206 	dr = r;
207 	for(sp=dr.min; dr.min.x < r.max.x; sp.x++){
208 		dr.max.x = dr.min.x+1;
209 		if(b) gendrawdiff(d, dr, top, b, sp, nil, ZP, SoverD);
210 		gendrawdiff(d, dr, top, t, sp, nil, ZP, SoverD);
211 		for(dr.min.x++; ++a.x < f && dr.min.x < r.max.x; dr.min.x++){
212 			dr.max.x = dr.min.x+1;
213 			gendrawdiff(d, dr, top, d, Pt(dr.min.x-1, dr.min.y), nil, ZP, SoverD);
214 		}
215 		a.x = 0;
216 	}
217 	freeimage(t);
218 }
219 
220 Point
221 s2c(Point p){
222 	p = subpt(p, spos);
223 	if(p.x < 0) p.x -= zoom-1;
224 	if(p.y < 0) p.y -= zoom-1;
225 	return addpt(divpt(p, zoom), cpos);
226 }
227 
228 Point
229 c2s(Point p){
230 	return addpt(mulpt(subpt(p, cpos), zoom), spos);
231 }
232 
233 Rectangle
234 c2sr(Rectangle r){
235 	return Rpt(c2s(r.min), c2s(r.max));
236 }
237 
238 void
239 update(Rectangle *rp){
240 	if(canvas==nil)
241 		draw(screen, screen->r, back, nil, ZP);
242 	else {
243 		if(rp == nil)
244 			rp = &canvas->r;
245 		gendrawdiff(screen, screen->r, c2sr(canvas->r), back, ZP, nil, ZP, SoverD);
246 		zoomdraw(screen, c2sr(*rp), ZR, back, canvas, rp->min, zoom);
247 	}
248 	flushimage(display, 1);
249 }
250 
251 void
252 expand(Rectangle r)
253 {
254 	Rectangle nr;
255 	Image *tmp;
256 
257 	if(canvas==nil){
258 		if((canvas = allocimage(display, r, screen->chan, 0, DNofill)) == nil)
259 			sysfatal("allocimage: %r");
260 		draw(canvas, canvas->r, back, nil, ZP);
261 		return;
262 	}
263 	nr = canvas->r;
264 	combinerect(&nr, r);
265 	if(eqrect(nr, canvas->r))
266 		return;
267 	if((tmp = allocimage(display, nr, canvas->chan, 0, DNofill)) == nil)
268 		return;
269 	draw(tmp, canvas->r, canvas, nil, canvas->r.min);
270 	gendrawdiff(tmp, tmp->r, canvas->r, back, ZP, nil, ZP, SoverD);
271 	freeimage(canvas);
272 	canvas = tmp;
273 }
274 
275 void
276 save(Rectangle r, int mark)
277 {
278 	Image *tmp;
279 	int x;
280 
281 	if(mark){
282 		x = nundo++ % nelem(undo);
283 		if(undo[x])
284 			freeimage(undo[x]);
285 		undo[x] = nil;
286 	}
287 	if(canvas==nil || nundo<0)
288 		return;
289 	if(!rectclip(&r, canvas->r))
290 		return;
291 	if((tmp = allocimage(display, r, canvas->chan, 0, DNofill)) == nil)
292 		return;
293 	draw(tmp, r, canvas, nil, r.min);
294 	x = nundo++ % nelem(undo);
295 	if(undo[x])
296 		freeimage(undo[x]);
297 	undo[x] = tmp;
298 }
299 
300 void
301 restore(int n)
302 {
303 	Image *tmp;
304 	int x;
305 
306 	while(nundo > 0){
307 		if(n-- == 0)
308 			return;
309 		x = --nundo % nelem(undo);
310 		if((tmp = undo[x]) == nil)
311 			return;
312 		undo[x] = nil;
313 		if(canvas == nil || canvas->chan != tmp->chan){
314 			freeimage(canvas);
315 			canvas = tmp;
316 			update(nil);
317 		} else {
318 			expand(tmp->r);
319 			draw(canvas, tmp->r, tmp, nil, tmp->r.min);
320 			update(&tmp->r);
321 			freeimage(tmp);
322 		}
323 	}
324 }
325 
326 typedef struct {
327 	Rectangle	r;
328 	Rectangle	r0;
329 	Image*		dst;
330 
331 	int		yscan;	/* current scanline */
332 	int		wscan;	/* bscan width in bytes */
333 	Image*		iscan;	/* scanline image */
334 	uchar*		bscan;	/* scanline buffer */
335 
336 	int		nmask;	/* size of bmask in bytes */
337 	int		wmask;	/* width of bmask in bytes */
338 	Image*		imask;	/* mask image */
339 	uchar*		bmask;	/* mask buffer */
340 
341 	int		ncmp;
342 	uchar		bcmp[4];
343 } Filldata;
344 
345 void
346 fillscan(Filldata *f, Point p0)
347 {
348 	int x, y;
349 	uchar *b;
350 
351 	x = p0.x;
352 	y = p0.y;
353 	b = f->bmask + y*f->wmask;
354 	if(b[x/8] & 0x80>>(x%8))
355 		return;
356 
357 	if(f->yscan != y){
358 		draw(f->iscan, f->iscan->r, f->dst, nil, Pt(f->r.min.x, f->r.min.y+y));
359 		if(unloadimage(f->iscan, f->iscan->r, f->bscan, f->wscan) < 0)
360 			return;
361 		f->yscan = y;
362 	}
363 
364 	for(x = p0.x; x >= 0; x--){
365 		if(memcmp(f->bscan + x*f->ncmp, f->bcmp, f->ncmp))
366 			break;
367 		b[x/8] |= 0x80>>(x%8);
368 	}
369 	for(x = p0.x+1; x < f->r0.max.x; x++){
370 		if(memcmp(f->bscan + x*f->ncmp, f->bcmp, f->ncmp))
371 			break;
372 		b[x/8] |= 0x80>>(x%8);
373 	}
374 
375 	y = p0.y-1;
376 	if(y >= 0){
377 		for(x = p0.x; x >= 0; x--){
378 			if((b[x/8] & 0x80>>(x%8)) == 0)
379 				break;
380 			fillscan(f, Pt(x, y));
381 		}
382 		for(x = p0.x+1; x < f->r0.max.x; x++){
383 			if((b[x/8] & 0x80>>(x%8)) == 0)
384 				break;
385 			fillscan(f, Pt(x, y));
386 		}
387 	}
388 
389 	y = p0.y+1;
390 	if(y < f->r0.max.y){
391 		for(x = p0.x; x >= 0; x--){
392 			if((b[x/8] & 0x80>>(x%8)) == 0)
393 				break;
394 			fillscan(f, Pt(x, y));
395 		}
396 		for(x = p0.x+1; x < f->r0.max.x; x++){
397 			if((b[x/8] & 0x80>>(x%8)) == 0)
398 				break;
399 			fillscan(f, Pt(x, y));
400 		}
401 	}
402 }
403 
404 void
405 floodfill(Image *dst, Rectangle r, Point p, Image *src)
406 {
407 	Filldata f;
408 
409 	if(!rectclip(&r, dst->r))
410 		return;
411 	if(!ptinrect(p, r))
412 		return;
413 	memset(&f, 0, sizeof(f));
414 	f.dst = dst;
415 	f.r = r;
416 	f.r0 = rectsubpt(r, r.min);
417 	f.wmask = bytesperline(f.r0, 1);
418 	f.nmask = f.wmask*f.r0.max.y;
419 	if((f.bmask = mallocz(f.nmask, 1)) == nil)
420 		goto out;
421 	if((f.imask = allocimage(display, f.r0, GREY1, 0, DNofill)) == nil)
422 		goto out;
423 
424 	r = f.r0;
425 	r.max.y = 1;
426 	if((f.iscan = allocimage(display, r, RGB24, 0, DNofill)) == nil)
427 		goto out;
428 	f.yscan = -1;
429 	f.wscan = bytesperline(f.iscan->r, f.iscan->depth);
430 	if((f.bscan = mallocz(f.wscan, 0)) == nil)
431 		goto out;
432 
433 	r = Rect(0,0,1,1);
434 	f.ncmp = (f.iscan->depth+7) / 8;
435 	draw(f.iscan, r, dst, nil, p);
436 	if(unloadimage(f.iscan, r, f.bcmp, sizeof(f.bcmp)) < 0)
437 		goto out;
438 
439 	fillscan(&f, subpt(p, f.r.min));
440 
441 	loadimage(f.imask, f.imask->r, f.bmask, f.nmask);
442 	draw(f.dst, f.r, src, f.imask, f.imask->r.min);
443 out:
444 	free(f.bmask);
445 	free(f.bscan);
446 	if(f.iscan)
447 		freeimage(f.iscan);
448 	if(f.imask)
449 		freeimage(f.imask);
450 }
451 
452 void
453 translate(Point d)
454 {
455 	Rectangle r, nr;
456 
457 	if(canvas==nil || d.x==0 && d.y==0)
458 		return;
459 	r = c2sr(canvas->r);
460 	nr = rectaddpt(r, d);
461 	rectclip(&r, screen->clipr);
462 	draw(screen, rectaddpt(r, d), screen, nil, r.min);
463 	zoomdraw(screen, nr, rectaddpt(r, d), back, canvas, canvas->r.min, zoom);
464 	gendrawdiff(screen, screen->r, nr, back, ZP, nil, ZP, SoverD);
465 	spos = addpt(spos, d);
466 	flushimage(display, 1);
467 }
468 
469 void
470 setzoom(Point o, int z)
471 {
472 	if(z < 1)
473 		return;
474 	cpos = s2c(o);
475 	spos = o;
476 	zoom = z;
477 	update(nil);
478 }
479 
480 void
481 center(void)
482 {
483 	cpos = ZP;
484 	if(canvas)
485 		cpos = addpt(canvas->r.min,
486 			divpt(subpt(canvas->r.max, canvas->r.min), 2));
487 	spos = addpt(screen->r.min,
488 		divpt(subpt(screen->r.max, screen->r.min), 2));
489 	update(nil);
490 }
491 
492 void
493 drawpal(void)
494 {
495 	Rectangle r, rr;
496 	int i;
497 
498 	r = screen->r;
499 	r.min.y = r.max.y - 20;
500 	replclipr(screen, 0, r);
501 
502 	penr = r;
503 	penr.min.x = r.max.x - NBRUSH*Dy(r);
504 
505 	palr = r;
506 	palr.max.x = penr.min.x;
507 
508 	r = penr;
509 	draw(screen, r, back, nil, ZP);
510 	for(i=0; i<NBRUSH; i++){
511 		r.max.x = penr.min.x + (i+1)*Dx(penr) / NBRUSH;
512 		rr = r;
513 		if(i == brush)
514 			rr.min.y += Dy(r)/3;
515 		if(i == NBRUSH-1){
516 			/* last is special brush for fill draw */
517 			draw(screen, rr, ink, nil, ZP);
518 		} else {
519 			rr.min = addpt(rr.min, divpt(subpt(rr.max, rr.min), 2));
520 			rr.max = rr.min;
521 			strokedraw(screen, rr, ink, i);
522 		}
523 		r.min.x = r.max.x;
524 	}
525 
526 	r = palr;
527 	for(i=1; i<=nelem(pal); i++){
528 		r.max.x = palr.min.x + i*Dx(palr) / nelem(pal);
529 		rr = r;
530 		if(ink == pal[i-1])
531 			rr.min.y += Dy(r)/3;
532 		draw(screen, rr, pal[i-1], nil, ZP);
533 		gendrawdiff(screen, r, rr, back, ZP, nil, ZP, SoverD);
534 		r.min.x = r.max.x;
535 	}
536 
537 	r = screen->r;
538 	r.max.y -= Dy(palr);
539 	replclipr(screen, 0, r);
540 }
541 
542 int
543 hitpal(Mouse m)
544 {
545 	if(ptinrect(m.xy, penr)){
546 		if(m.buttons & 7){
547 			brush = ((m.xy.x - penr.min.x) * NBRUSH) / Dx(penr);
548 			drawpal();
549 		}
550 		return 1;
551 	}
552 	if(ptinrect(m.xy, palr)){
553 		Image *col;
554 
555 		col = pal[(m.xy.x - palr.min.x) * nelem(pal) / Dx(palr)];
556 		switch(m.buttons & 7){
557 		case 1:
558 			ink = col;
559 			drawpal();
560 			break;
561 		case 2:
562 			back = col;
563 			drawpal();
564 			update(nil);
565 			break;
566 		}
567 		return 1;
568 	}
569 	return 0;
570 }
571 
572 void
573 catch(void * _, char *msg)
574 {
575 	USED(_);
576 	if(strstr(msg, "closed pipe"))
577 		noted(NCONT);
578 	noted(NDFLT);
579 }
580 
581 int
582 pipeline(char *fmt, ...)
583 {
584 	char buf[1024];
585 	va_list a;
586 	int p[2];
587 
588 	va_start(a, fmt);
589 	vsnprint(buf, sizeof(buf), fmt, a);
590 	va_end(a);
591 	if(pipe(p) < 0)
592 		return -1;
593 	switch(rfork(RFPROC|RFMEM|RFFDG|RFNOTEG)){ // RFEND not available in libc port
594 	case -1:
595 		close(p[0]);
596 		close(p[1]);
597 		return -1;
598 	case 0:
599 		close(p[1]);
600 		dup(p[0], 0);
601 		dup(p[0], 1);
602 		close(p[0]);
603 		execl("/bin/rc", "rc", "-c", buf, nil);
604 		exits("exec");
605 	}
606 	close(p[0]);
607 	return p[1];
608 }
609 
610 void
611 usage(void)
612 {
613 	fprint(2, "usage: %s [ file ]\n", argv0);
614 	exits("usage");
615 }
616 
617 void
618 main(int argc, char *argv[])
619 {
620 	char *s, buf[1024];
621 	Rectangle r;
622 	Image *img;
623 	int i, fd;
624 	Event e;
625 	Mouse m;
626 	Point p, d;
627 
628 	ARGBEGIN {
629 	default:
630 		usage();
631 	} ARGEND;
632 
633 	if(argc == 1)
634 		filename = strdup(argv[0]);
635 	else if(argc != 0)
636 		usage();
637 
638 	if(initdraw(0, 0, "paint") < 0)
639 		sysfatal("initdraw: %r");
640 
641 	if(filename){
642 		if((fd = open(filename, OREAD)) < 0)
643 			sysfatal("open: %r");
644 		if((canvas = readimage(display, fd, 0)) == nil)
645 			sysfatal("readimage: %r");
646 		close(fd);
647 	}
648 
649 	/* palette initialization */
650 	for(i=0; i<nelem(pal); i++){
651 		pal[i] = allocimage(display, Rect(0, 0, 1, 1), RGB24, 1,
652 			c64[i % nelem(c64)]<<8 | 0xFF);
653 		if(pal[i] == nil)
654 			sysfatal("allocimage: %r");
655 	}
656 	ink = pal[0];
657 	back = pal[1];
658 	drawpal();
659 	center();
660 
661 	einit(Emouse | Ekeyboard);
662 
663 	notify(catch);
664 	for(;;) {
665 		switch(event(&e)){
666 		case Emouse:
667 			if(hitpal(e.mouse))
668 				continue;
669 
670 			img = ink;
671 			switch(e.mouse.buttons & 7){
672 			case 2:
673 				img = back;
674 				/* no break */
675 			case 1:
676 				p = s2c(e.mouse.xy);
677 				if(brush == NBRUSH-1){
678 					/* flood fill brush */
679 					if(canvas == nil || !ptinrect(p, canvas->r)){
680 						back = img;
681 						drawpal();
682 						update(nil);
683 						break;
684 					}
685 					r = canvas->r;
686 					save(r, 1);
687 					floodfill(canvas, r, p, img);
688 					update(&r);
689 
690 					/* wait for mouse release */
691 					while(event(&e) == Emouse && (e.mouse.buttons & 7) != 0)
692 						;
693 					break;
694 				}
695 				r = strokerect(Rpt(p, p), brush);
696 				expand(r);
697 				save(r, 1);
698 				strokedraw(canvas, Rpt(p, p), img, brush);
699 				update(&r);
700 				for(;;){
701 					m = e.mouse;
702 					if(event(&e) != Emouse)
703 						break;
704 					if((e.mouse.buttons ^ m.buttons) & 7)
705 						break;
706 					d = s2c(e.mouse.xy);
707 					if(eqpt(d, p))
708 						continue;
709 					r = strokerect(Rpt(p, d), brush);
710 					expand(r);
711 					save(r, 0);
712 					strokedraw(canvas, Rpt(p, d), img, brush);
713 					update(&r);
714 					p = d;
715 				}
716 				break;
717 			case 4:
718 				for(;;){
719 					m = e.mouse;
720 					if(event(&e) != Emouse)
721 						break;
722 					if((e.mouse.buttons & 7) != 4)
723 						break;
724 					translate(subpt(e.mouse.xy, m.xy));
725 				}
726 				break;
727 			}
728 			break;
729 		case Ekeyboard:
730 			switch(e.kbdc){
731 			case Kesc:
732 				zoom = 1;
733 				center();
734 				break;
735 			case '+':
736 				if(zoom < 0x1000)
737 					setzoom(e.mouse.xy, zoom*2);
738 				break;
739 			case '-':
740 				if(zoom > 1)
741 					setzoom(e.mouse.xy, zoom/2);
742 				break;
743 			case 'c':
744 				if(canvas == nil)
745 					break;
746 				save(canvas->r, 1);
747 				freeimage(canvas);
748 				canvas = nil;
749 				update(nil);
750 				break;
751 			case 'u':
752 				restore(16);
753 				break;
754 			case 'f':
755 				brush = NBRUSH-1;
756 				drawpal();
757 				break;
758 			case '0': case '1': case '2': case '3': case '4':
759 			case '5': case '6': case '7': case '8': case '9':
760 				brush = e.kbdc - '0';
761 				drawpal();
762 				break;
763 			default:
764 				if(e.kbdc == Kdel)
765 					e.kbdc = 'q';
766 				buf[0] = 0;
767 				if(filename && (e.kbdc == 'r' || e.kbdc == 'w'))
768 					snprint(buf, sizeof(buf), "%C %s", e.kbdc, filename);
769 				else if(e.kbdc > 0x20 && e.kbdc < 0x7f)
770 					snprint(buf, sizeof(buf), "%C", e.kbdc);
771 				if(eenter("Cmd", buf, sizeof(buf), &e.mouse) <= 0)
772 					break;
773 				if(strcmp(buf, "q") == 0)
774 					exits(nil);
775 				s = buf+1;
776 				while(*s == ' ' || *s == '\t')
777 					s++;
778 				if(*s == 0)
779 					break;
780 				switch(buf[0]){
781 				case 'r':
782 					if((fd = open(s, OREAD)) < 0){
783 					Error:
784 						snprint(buf, sizeof(buf), "%r");
785 						eenter(buf, nil, 0, &e.mouse);
786 						break;
787 					}
788 					free(filename);
789 					filename = strdup(s);
790 				Readimage:
791 					unlockdisplay(display);
792 					img = readimage(display, fd, 1);
793 					close(fd);
794 					lockdisplay(display);
795 					if(img == nil){
796 						werrstr("readimage: %r");
797 						goto Error;
798 					}
799 					if(canvas){
800 						save(canvas->r, 1);
801 						freeimage(canvas);
802 					}
803 					canvas = img;
804 					center();
805 					break;
806 				case 'w':
807 					if((fd = create(s, OWRITE, 0660)) < 0)
808 						goto Error;
809 					free(filename);
810 					filename = strdup(s);
811 				Writeimage:
812 					if(canvas)
813 					if(writeimage(fd, canvas, 0) < 0){
814 						close(fd);
815 						werrstr("writeimage: %r");
816 						goto Error;
817 					}
818 					close(fd);
819 					break;
820 				case '<':
821 					if((fd = pipeline("%s", s)) < 0)
822 						goto Error;
823 					goto Readimage;
824 				case '>':
825 					if((fd = pipeline("%s", s)) < 0)
826 						goto Error;
827 					goto Writeimage;
828 				case '|':
829 					if(canvas == nil)
830 						break;
831 					if((fd = pipeline("%s", s)) < 0)
832 						goto Error;
833 					switch(rfork(RFMEM|RFPROC|RFFDG)){
834 					case -1:
835 						close(fd);
836 						werrstr("rfork: %r");
837 						goto Error;
838 					case 0:
839 						writeimage(fd, canvas, 1);
840 						exits(nil);
841 					}
842 					goto Readimage;
843 				}
844 				break;
845 			}
846 			break;
847 		}
848 	}
849 }
850 
851 void
852 eresized(int _)
853 {
854 	USED(_);
855 	if(getwindow(display, Refnone) < 0)
856 		sysfatal("resize failed");
857 	drawpal();
858 	update(nil);
859 }