1 /*
2  * the actual viewer that handles screen stuff
3  */
4 
5 #include <u.h>
6 #include <libc.h>
7 #include <9pclient.h>
8 #include <draw.h>
9 #include <cursor.h>
10 #include <mouse.h>
11 #include <keyboard.h>
12 #include <thread.h>
13 #include <bio.h>
14 #include <plumb.h>
15 #include <ctype.h>
16 #include "page.h"
17 
18 Document *doc;
19 Mousectl *mc;
20 Image *im;
21 Image *tofree;
22 int page;
23 int angle = 0;
24 int showbottom = 0;		/* on the next showpage, move the image so the bottom is visible. */
25 
26 Rectangle ulrange;	/* the upper left corner of the image must be in this rectangle */
27 Point ul;			/* the upper left corner of the image is at this point on the screen */
28 
29 Point pclip(Point, Rectangle);
30 Rectangle mkrange(Rectangle screenr, Rectangle imr);
31 void redraw(Image*);
32 void plumbproc(void*);
33 
34 Cursor reading={
35 	{-1, -1},
36 	{0xff, 0x80, 0xff, 0x80, 0xff, 0x00, 0xfe, 0x00,
37 	 0xff, 0x00, 0xff, 0x80, 0xff, 0xc0, 0xef, 0xe0,
38 	 0xc7, 0xf0, 0x03, 0xf0, 0x01, 0xe0, 0x00, 0xc0,
39 	 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, },
40 	{0x00, 0x00, 0x7f, 0x00, 0x7e, 0x00, 0x7c, 0x00,
41 	 0x7e, 0x00, 0x7f, 0x00, 0x6f, 0x80, 0x47, 0xc0,
42 	 0x03, 0xe0, 0x01, 0xf0, 0x00, 0xe0, 0x00, 0x40,
43 	 0x00, 0x00, 0x01, 0xb6, 0x01, 0xb6, 0x00, 0x00, }
44 };
45 
46 Cursor query = {
47 	{-7,-7},
48 	{0x0f, 0xf0, 0x1f, 0xf8, 0x3f, 0xfc, 0x7f, 0xfe,
49 	 0x7c, 0x7e, 0x78, 0x7e, 0x00, 0xfc, 0x01, 0xf8,
50 	 0x03, 0xf0, 0x07, 0xe0, 0x07, 0xc0, 0x07, 0xc0,
51 	 0x07, 0xc0, 0x07, 0xc0, 0x07, 0xc0, 0x07, 0xc0, },
52 	{0x00, 0x00, 0x0f, 0xf0, 0x1f, 0xf8, 0x3c, 0x3c,
53 	 0x38, 0x1c, 0x00, 0x3c, 0x00, 0x78, 0x00, 0xf0,
54 	 0x01, 0xe0, 0x03, 0xc0, 0x03, 0x80, 0x03, 0x80,
55 	 0x00, 0x00, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, }
56 };
57 
58 enum {
59 	Left = 1,
60 	Middle = 2,
61 	Right = 4,
62 
63 	RMenu = 3,
64 };
65 
66 static void
67 delayfreeimage(Image *m)
68 {
69 	if(m == tofree)
70 		return;
71 	if(tofree)
72 		freeimage(tofree);
73 	tofree = m;
74 }
75 
76 void
77 unhide(void)
78 {
79 	USED(nil);
80 }
81 
82 int
83 max(int a, int b)
84 {
85 	return a > b ? a : b;
86 }
87 
88 int
89 min(int a, int b)
90 {
91 	return a < b ? a : b;
92 }
93 
94 
95 char*
96 menugen(int n)
97 {
98 	static char menustr[32];
99 	char *p;
100 	int len;
101 
102 	if(n == doc->npage)
103 		return "exit";
104 	if(n > doc->npage)
105 		return nil;
106 
107 	if(reverse)
108 		n = doc->npage-1-n;
109 
110 	p = doc->pagename(doc, n);
111 	len = (sizeof menustr)-2;
112 
113 	if(strlen(p) > len && strrchr(p, '/'))
114 		p = strrchr(p, '/')+1;
115 	if(strlen(p) > len)
116 		p = p+strlen(p)-len;
117 
118 	strcpy(menustr+1, p);
119 	if(page == n)
120 		menustr[0] = '>';
121 	else
122 		menustr[0] = ' ';
123 	return menustr;
124 }
125 
126 void
127 showpage(int page, Menu *m)
128 {
129 	if(doc->fwdonly)
130 		m->lasthit = 0;	/* this page */
131 	else
132 		m->lasthit = reverse ? doc->npage-1-page : page;
133 
134 	setcursor(mc, &reading);
135 	delayfreeimage(nil);
136 	im = cachedpage(doc, angle, page);
137 	if(im == nil)
138 		wexits(0);
139 	if(resizing)
140 		resize(Dx(im->r), Dy(im->r));
141 
142 	setcursor(mc, nil);
143 	if(showbottom){
144 		ul.y = screen->r.max.y - Dy(im->r);
145 		showbottom = 0;
146 	}
147 
148 	if((doc->type == Tgfx) && fitwin)
149 		fit();
150 	else{
151 		redraw(screen);
152 	 	flushimage(display, 1);
153 	}
154 }
155 
156 char*
157 writebitmap(void)
158 {
159 	char basename[64];
160 	char name[64+30];
161 	static char result[200];
162 	char *p, *q;
163 	int fd = -1;
164 
165 	if(im == nil)
166 		return "no image";
167 
168 	memset(basename, 0, sizeof basename);
169 	if(doc->docname)
170 		strncpy(basename, doc->docname, sizeof(basename)-1);
171 	else if((p = menugen(page)) && p[0] != '\0')
172 		strncpy(basename, p+1, sizeof(basename)-1);
173 
174 	if(basename[0]) {
175 		if(q = strrchr(basename, '/'))
176 			q++;
177 		else
178 			q = basename;
179 		if(p = strchr(q, '.'))
180 			*p = 0;
181 
182 		memset(name, 0, sizeof name);
183 		snprint(name, sizeof(name)-1, "%s.%d.bit", q, page+1);
184 		if(access(name, 0) >= 0) {
185 			strcat(name, "XXXX");
186 			fd = mkstemp(name);
187 		}
188 		if(fd < 0)
189 			return "couldn't think of a name for bitmap";
190 	} else {
191 		strcpy(name, "bitXXXX");
192 		mkstemp(name);
193 		if(fd < 0)
194 			return "couldn't think of a name for bitmap";
195 	}
196 
197 	if(fd < 0) {
198 		snprint(result, sizeof result, "cannot create %s: %r", name);
199 		return result;
200 	}
201 
202 	if(writeimage(fd, im, 0) < 0) {
203 		snprint(result, sizeof result, "cannot writeimage: %r");
204 		close(fd);
205 		return result;
206 	}
207 	close(fd);
208 
209 	snprint(result, sizeof result, "wrote %s", name);
210 	return result;
211 }
212 
213 static void translate(Point);
214 
215 static int
216 showdata(Plumbmsg *msg)
217 {
218 	char *s;
219 
220 	s = plumblookup(msg->attr, "action");
221 	return s && strcmp(s, "showdata")==0;
222 }
223 
224 /* correspond to entries in miditems[] below,
225  * changing one means you need to change
226  */
227 enum{
228 	Restore = 0,
229 	Zin,
230 	Fit,
231 	Rot,
232 	Upside,
233 	Empty1,
234 	Next,
235 	Prev,
236 	Zerox,
237 	Empty2,
238 	Reverse,
239 	Del,
240 	Write,
241 	Empty3,
242 	Exit,
243 };
244 
245 void
246 viewer(Document *dd)
247 {
248 	int i, fd, n, oldpage;
249 	int nxt, a;
250 	Channel *cp;
251 	Menu menu, midmenu;
252 	Mouse m;
253 	Keyboardctl *kc;
254 	Point dxy, oxy, xy0;
255 	Rune run;
256 	Rectangle r;
257 	int size[2];
258 	Image *tmp;
259 	PDFInfo *pdf;
260 	PSInfo *ps;
261 	static char *fwditems[] = { "this page", "next page", "exit", 0 };
262  	static char *miditems[] = {
263  		"orig size",
264  		"zoom in",
265  		"fit window",
266  		"rotate 90",
267  		"upside down",
268  		"",
269  		"next",
270  		"prev",
271 		"zerox",
272  		"",
273  		"reverse",
274  		"discard",
275  		"write",
276  		"",
277  		"quit",
278  		0
279  	};
280 	char *s;
281 	enum {
282 	    CMouse,
283 	    CResize,
284 	    CKeyboard,
285 	    CPlumb,
286 	    CN
287 	};
288 	Alt alts[CN+1];
289 	Plumbmsg *pm;
290 
291 	cp = chancreate(sizeof pm, 0);
292 	assert(cp);
293 
294 	doc = dd;    /* save global for menuhit */
295 	ul = screen->r.min;
296 	mc = initmouse(nil, screen);
297 	kc = initkeyboard(nil);
298 	alts[CMouse].c = mc->c;
299 	alts[CMouse].v = &m;
300 	alts[CMouse].op = CHANRCV;
301 	alts[CResize].c = mc->resizec;
302 	alts[CResize].v = &size;
303 	alts[CResize].op = CHANRCV;
304 	alts[CKeyboard].c = kc->c;
305 	alts[CKeyboard].v = &run;
306 	alts[CKeyboard].op = CHANRCV;
307 	alts[CPlumb].c = cp;
308 	alts[CPlumb].v = &pm;
309 	alts[CPlumb].op = CHANNOP;
310 	alts[CN].op = CHANEND;
311 
312 	/* XXX: Event */
313 	if(doc->addpage != nil) {
314 		alts[CPlumb].op = CHANRCV;
315 		proccreate(plumbproc, cp, 16384);
316 	}
317 
318 	setcursor(mc, &reading);
319 	r.min = ZP;
320 
321 	/*
322 	 * im is a global pointer to the current image.
323 	 * eventually, i think we will have a layer between
324 	 * the display routines and the ps/pdf/whatever routines
325 	 * to perhaps cache and handle images of different
326 	 * sizes, etc.
327 	 */
328 	im = 0;
329 	page = reverse ? doc->npage-1 : 0;
330 
331 	if(doc->fwdonly) {
332 		menu.item = fwditems;
333 		menu.gen = 0;
334 		menu.lasthit = 0;
335 	} else {
336 		menu.item = 0;
337 		menu.gen = menugen;
338 		menu.lasthit = 0;
339 	}
340 
341 	midmenu.item = miditems;
342 	midmenu.gen = 0;
343 	midmenu.lasthit = Next;
344 
345 	showpage(page, &menu);
346 	setcursor(mc, nil);
347 
348 	nxt = 0;
349 	for(;;) {
350 		/*
351 		 * throughout, if doc->fwdonly is set, we restrict the functionality
352 		 * a fair amount.  we don't care about doc->npage anymore, and
353 		 * all that can be done is select the next page.
354 		 */
355 		unlockdisplay(display);
356 		a = alt(alts);
357 		lockdisplay(display);
358 		switch(a) {
359 		case CKeyboard:
360 			if(run <= 0xFF && isdigit(run)) {
361 				nxt = nxt*10+run-'0';
362 				break;
363 			} else if(run != '\n')
364 				nxt = 0;
365 			switch(run) {
366 			case 'r':	/* reverse page order */
367 				if(doc->fwdonly)
368 					break;
369 				reverse = !reverse;
370 				menu.lasthit = doc->npage-1-menu.lasthit;
371 
372 				/*
373 				 * the theory is that if we are reversing the
374 				 * document order and are on the first or last
375 				 * page then we're just starting and really want
376 		 	 	 * to view the other end.  maybe the if
377 				 * should be dropped and this should happen always.
378 				 */
379 				if(page == 0 || page == doc->npage-1) {
380 					page = doc->npage-1-page;
381 					showpage(page, &menu);
382 				}
383 				break;
384 			case 'w':	/* write bitmap of current screen */
385 				setcursor(mc, &reading);
386 				s = writebitmap();
387 				if(s)
388 					string(screen, addpt(screen->r.min, Pt(5,5)), display->black, ZP,
389 						display->defaultfont, s);
390 				setcursor(mc, nil);
391 				flushimage(display, 1);
392 				break;
393 			case 'd':	/* remove image from working set */
394 				if(doc->rmpage && page < doc->npage) {
395 					if(doc->rmpage(doc, page) >= 0) {
396 						if(doc->npage < 0)
397 							wexits(0);
398 						if(page >= doc->npage)
399 							page = doc->npage-1;
400 						showpage(page, &menu);
401 					}
402 				}
403 				break;
404 			case 'q':
405 			case 0x04: /* ctrl-d */
406 				wexits(0);
407 			case 'u':
408 				if(im==nil)
409 					break;
410 				setcursor(mc, &reading);
411 				rot180(im);
412 				setcursor(mc, nil);
413 				angle = (angle+180) % 360;
414 				redraw(screen);
415 				flushimage(display, 1);
416 				break;
417 			case '-':
418 			case '\b':
419 			case Kleft:
420 				if(page > 0 && !doc->fwdonly) {
421 					--page;
422 					showpage(page, &menu);
423 				}
424 				break;
425 			case '\n':
426 				if(nxt) {
427 					nxt--;
428 					if(nxt >= 0 && nxt < doc->npage && !doc->fwdonly)
429 						showpage(page=nxt, &menu);
430 					nxt = 0;
431 					break;
432 				}
433 				goto Gotonext;
434 			case Kright:
435 			case ' ':
436 			Gotonext:
437 				if(doc->npage && ++page >= doc->npage && !doc->fwdonly)
438 					wexits(0);
439 				showpage(page, &menu);
440 				break;
441 
442 			/*
443 			 * The upper y coordinate of the image is at ul.y in screen->r.
444 			 * Panning up means moving the upper left corner down.  If the
445 			 * upper left corner is currently visible, we need to go back a page.
446 			 */
447 			case Kup:
448 				if(screen->r.min.y <= ul.y && ul.y < screen->r.max.y){
449 					if(page > 0 && !doc->fwdonly){
450 						--page;
451 						showbottom = 1;
452 						showpage(page, &menu);
453 					}
454 				} else {
455 					i = Dy(screen->r)/2;
456 					if(i > 10)
457 						i -= 10;
458 					if(i+ul.y > screen->r.min.y)
459 						i = screen->r.min.y - ul.y;
460 					translate(Pt(0, i));
461 				}
462 				break;
463 
464 			/*
465 			 * If the lower y coordinate is on the screen, we go to the next page.
466 			 * The lower y coordinate is at ul.y + Dy(im->r).
467 			 */
468 			case Kdown:
469 				i = ul.y + Dy(im->r);
470 				if(screen->r.min.y <= i && i <= screen->r.max.y){
471 					ul.y = screen->r.min.y;
472 					goto Gotonext;
473 				} else {
474 					i = -Dy(screen->r)/2;
475 					if(i < -10)
476 						i += 10;
477 					if(i+ul.y+Dy(im->r) <= screen->r.max.y)
478 						i = screen->r.max.y - Dy(im->r) - ul.y - 1;
479 					translate(Pt(0, i));
480 				}
481 				break;
482 			default:
483 				setcursor(mc, &query);
484 				sleep(1000);
485 				setcursor(mc, nil);
486 				break;
487 			}
488 			break;
489 
490 		case CMouse:
491 			switch(m.buttons){
492 			case Left:
493 				oxy = m.xy;
494 				xy0 = oxy;
495 				do {
496 					dxy = subpt(m.xy, oxy);
497 					oxy = m.xy;
498 					translate(dxy);
499 					recv(mc->c, &m);
500 				} while(m.buttons == Left);
501 				if(m.buttons) {
502 					dxy = subpt(xy0, oxy);
503 					translate(dxy);
504 				}
505 				break;
506 
507 			case Middle:
508 				if(doc->npage == 0)
509 					break;
510 
511 				n = menuhit(Middle, mc, &midmenu, nil);
512 				if(n == -1)
513 					break;
514 				switch(n){
515 				case Next: 	/* next */
516 					if(reverse)
517 						page--;
518 					else
519 						page++;
520 					if(page < 0) {
521 						if(reverse) return;
522 						else page = 0;
523 					}
524 
525 					if((page >= doc->npage) && !doc->fwdonly)
526 						return;
527 
528 					showpage(page, &menu);
529 					nxt = 0;
530 					break;
531 				case Prev:	/* prev */
532 					if(reverse)
533 						page++;
534 					else
535 						page--;
536 					if(page < 0) {
537 						if(reverse) return;
538 						else page = 0;
539 					}
540 
541 					if((page >= doc->npage) && !doc->fwdonly && !reverse)
542 						return;
543 
544 					showpage(page, &menu);
545 					nxt = 0;
546 					break;
547 				case Zerox:	/* prev */
548 					zerox();
549 					break;
550 				case Zin:	/* zoom in */
551 					if (dd->type == Tpdf){		/* pdf */
552 						pdf = (PDFInfo *) dd->extra;
553 						if (pdf != nil){
554 							ppi+= 50;
555 							setdim(&pdf->gs, Rect(0,0,0,0), ppi, 0);
556 							showpage(page, &menu);
557 						}
558 						break;
559 					}
560 					if (dd->type == Tps){		/* ps */
561 						ps = (PSInfo *) dd->extra;
562 						if (ps != nil){
563 							ppi+= 50;
564 							setdim(&ps->gs, Rect(0,0,0,0), ppi, 0);
565 							showpage(page, &menu);
566 						}
567 						break;
568 					}
569 					else{ 	/* image */
570 						double delta;
571 						Rectangle r;
572 
573 						r = getrect(Middle, mc);
574 						if((rectclip(&r, rectaddpt(im->r, ul)) == 0) ||
575 							Dx(r) == 0 || Dy(r) == 0)
576 							break;
577 						/* use the smaller side to expand */
578 						if(Dx(r) < Dy(r))
579 							delta = (double)Dx(im->r)/(double)Dx(r);
580 						else
581 							delta = (double)Dy(im->r)/(double)Dy(r);
582 
583 						setcursor(mc, &reading);
584 						tmp = xallocimage(display,
585 								Rect(0, 0, (int)((double)Dx(im->r)*delta), (int)((double)Dy(im->r)*delta)),
586 								im->chan, 0, DBlack);
587 						if(tmp == nil) {
588 							fprint(2, "out of memory during zoom: %r\n");
589 							wexits("memory");
590 						}
591 						resample(im, tmp);
592 						im = tmp;
593 						delayfreeimage(tmp);
594 						setcursor(mc, nil);
595 						ul = screen->r.min;
596 						redraw(screen);
597 						flushimage(display, 1);
598 						break;
599 					}
600 				case Fit:	/* fit */
601 					/* no op if pdf or ps*/
602 					if (dd->type == Tgfx){
603 						fitwin = 1;
604 						fit();
605 					}
606 					break;
607 				case Rot:	/* rotate 90 */
608 					angle = (angle+90) % 360;
609 					showpage(page, &menu);
610 					break;
611 				case Upside: 	/* upside-down */
612 					angle = (angle+180) % 360;
613 					showpage(page, &menu);
614 					break;
615 				case Restore:	/* restore */
616 					if (dd->type == Tpdf){		/* pdf */
617 						pdf = (PDFInfo *) dd->extra;
618 						if (pdf != nil){
619 							ppi = 100;
620 							setdim(&pdf->gs, Rect(0,0,0,0), ppi, 0);
621 						}
622 						showpage(page, &menu);
623 						break;
624 					}
625 					if (dd->type == Tps){		/* ps */
626 						ps = (PSInfo *) dd->extra;
627 						if (ps != nil){
628 							ppi = 100;
629 							setdim(&ps->gs, Rect(0,0,0,0), ppi, 0);
630 						}
631 						showpage(page, &menu);
632 						break;
633 					}
634 					fitwin = 0;
635 					showpage(page, &menu);
636 					break;
637 				case Reverse:	/* reverse */
638 					if(doc->fwdonly)
639 						break;
640 					reverse = !reverse;
641 					menu.lasthit = doc->npage-1-menu.lasthit;
642 
643 					if(page == 0 || page == doc->npage-1) {
644 						page = doc->npage-1-page;
645 						showpage(page, &menu);
646 					}
647 					break;
648 				case Write: /* write */
649 					setcursor(mc, &reading);
650 					s = writebitmap();
651 					if(s)
652 						string(screen, addpt(screen->r.min, Pt(5,5)), display->black, ZP,
653 							display->defaultfont, s);
654 					setcursor(mc, nil);
655 					flushimage(display, 1);
656 					break;
657 				case Del: /* delete */
658 					if(doc->rmpage && page < doc->npage) {
659 						if(doc->rmpage(doc, page) >= 0) {
660 							if(doc->npage < 0)
661 								wexits(0);
662 							if(page >= doc->npage)
663 								page = doc->npage-1;
664 							showpage(page, &menu);
665 						}
666 					}
667 					break;
668 				case Exit:	/* exit */
669 					return;
670 				case Empty1:
671 				case Empty2:
672 				case Empty3:
673 					break;
674 
675 				};
676 
677 
678 
679 			case Right:
680 				if(doc->npage == 0)
681 					break;
682 
683 				oldpage = page;
684 				n = menuhit(RMenu, mc, &menu, nil);
685 				if(n == -1)
686 					break;
687 
688 				if(doc->fwdonly) {
689 					switch(n){
690 					case 0:	/* this page */
691 						break;
692 					case 1:	/* next page */
693 						showpage(++page, &menu);
694 						break;
695 					case 2:	/* exit */
696 						return;
697 					}
698 					break;
699 				}
700 
701 				if(n == doc->npage)
702 					return;
703 				else
704 					page = reverse ? doc->npage-1-n : n;
705 
706 				if(oldpage != page)
707 					showpage(page, &menu);
708 				nxt = 0;
709 				break;
710 			}
711 			break;
712 		case CResize:
713 			r = screen->r;
714 			if(getwindow(display, Refnone) < 0)
715 				fprint(2,"can't reattach to window");
716 			ul = addpt(ul, subpt(screen->r.min, r.min));
717 			redraw(screen);
718 			flushimage(display, 1);
719 			break;
720 		case CPlumb:
721 			if(pm->ndata <= 0){
722 				plumbfree(pm);
723 				break;
724 			}
725 			if(showdata(pm)) {
726 				s = estrdup("/tmp/pageplumbXXXXXXX");
727 				fd = opentemp(s, ORDWR|ORCLOSE);
728 				write(fd, pm->data, pm->ndata);
729 				/* lose fd reference on purpose; the file is open ORCLOSE */
730 			} else if(pm->data[0] == '/') {
731 				s = estrdup(pm->data);
732 			} else {
733 				s = emalloc(strlen(pm->wdir)+1+pm->ndata+1);
734 				sprint(s, "%s/%s", pm->wdir, pm->data);
735 				cleanname(s);
736 			}
737 			if((i = doc->addpage(doc, s)) >= 0) {
738 				page = i;
739 				unhide();
740 				showpage(page, &menu);
741 			}
742 			free(s);
743 			plumbfree(pm);
744 			break;
745 		}
746 	}
747 }
748 
749 Image *gray;
750 
751 /*
752  * A draw operation that touches only the area contained in bot but not in top.
753  * mp and sp get aligned with bot.min.
754  */
755 static void
756 gendrawdiff(Image *dst, Rectangle bot, Rectangle top,
757 	Image *src, Point sp, Image *mask, Point mp, int op)
758 {
759 	Rectangle r;
760 	Point origin;
761 	Point delta;
762 
763 	USED(op);
764 
765 	if(Dx(bot)*Dy(bot) == 0)
766 		return;
767 
768 	/* no points in bot - top */
769 	if(rectinrect(bot, top))
770 		return;
771 
772 	/* bot - top ≡ bot */
773 	if(Dx(top)*Dy(top)==0 || rectXrect(bot, top)==0){
774 		gendrawop(dst, bot, src, sp, mask, mp, op);
775 		return;
776 	}
777 
778 	origin = bot.min;
779 	/* split bot into rectangles that don't intersect top */
780 	/* left side */
781 	if(bot.min.x < top.min.x){
782 		r = Rect(bot.min.x, bot.min.y, top.min.x, bot.max.y);
783 		delta = subpt(r.min, origin);
784 		gendrawop(dst, r, src, addpt(sp, delta), mask, addpt(mp, delta), op);
785 		bot.min.x = top.min.x;
786 	}
787 
788 	/* right side */
789 	if(bot.max.x > top.max.x){
790 		r = Rect(top.max.x, bot.min.y, bot.max.x, bot.max.y);
791 		delta = subpt(r.min, origin);
792 		gendrawop(dst, r, src, addpt(sp, delta), mask, addpt(mp, delta), op);
793 		bot.max.x = top.max.x;
794 	}
795 
796 	/* top */
797 	if(bot.min.y < top.min.y){
798 		r = Rect(bot.min.x, bot.min.y, bot.max.x, top.min.y);
799 		delta = subpt(r.min, origin);
800 		gendrawop(dst, r, src, addpt(sp, delta), mask, addpt(mp, delta), op);
801 		bot.min.y = top.min.y;
802 	}
803 
804 	/* bottom */
805 	if(bot.max.y > top.max.y){
806 		r = Rect(bot.min.x, top.max.y, bot.max.x, bot.max.y);
807 		delta = subpt(r.min, origin);
808 		gendrawop(dst, r, src, addpt(sp, delta), mask, addpt(mp, delta), op);
809 		bot.max.y = top.max.y;
810 	}
811 }
812 
813 static void
814 drawdiff(Image *dst, Rectangle bot, Rectangle top, Image *src, Image *mask, Point p, int op)
815 {
816 	gendrawdiff(dst, bot, top, src, p, mask, p, op);
817 }
818 
819 /*
820  * Translate the image in the window by delta.
821  */
822 static void
823 translate(Point delta)
824 {
825 	Point u;
826 	Rectangle r, or;
827 
828 	if(im == nil)
829 		return;
830 
831 	u = pclip(addpt(ul, delta), ulrange);
832 	delta = subpt(u, ul);
833 	if(delta.x == 0 && delta.y == 0)
834 		return;
835 
836 	/*
837 	 * The upper left corner of the image is currently at ul.
838 	 * We want to move it to u.
839 	 */
840 	or = rectaddpt(Rpt(ZP, Pt(Dx(im->r), Dy(im->r))), ul);
841 	r = rectaddpt(or, delta);
842 
843 	drawop(screen, r, screen, nil, ul, S);
844 	ul = u;
845 
846 	/* fill in gray where image used to be but isn't. */
847 	drawdiff(screen, insetrect(or, -2), insetrect(r, -2), gray, nil, ZP, S);
848 
849 	/* fill in black border */
850 	drawdiff(screen, insetrect(r, -2), r, display->black, nil, ZP, S);
851 
852 	/* fill in image where it used to be off the screen. */
853 	if(rectclip(&or, screen->r))
854 		drawdiff(screen, r, rectaddpt(or, delta), im, nil, im->r.min, S);
855 	else
856 		drawop(screen, r, im, nil, im->r.min, S);
857 	flushimage(display, 1);
858 }
859 
860 void
861 redraw(Image *screen)
862 {
863 	Rectangle r;
864 
865 	if(im == nil)
866 		return;
867 
868 	ulrange.max = screen->r.max;
869 	ulrange.min = subpt(screen->r.min, Pt(Dx(im->r), Dy(im->r)));
870 
871 	ul = pclip(ul, ulrange);
872 	drawop(screen, screen->r, im, nil, subpt(im->r.min, subpt(ul, screen->r.min)), S);
873 
874 	if(im->repl)
875 		return;
876 
877 	/* fill in any outer edges */
878 	/* black border */
879 	r = rectaddpt(im->r, subpt(ul, im->r.min));
880 	border(screen, r, -2, display->black, ZP);
881 	r.min = subpt(r.min, Pt(2,2));
882 	r.max = addpt(r.max, Pt(2,2));
883 
884 	/* gray for the rest */
885 	if(gray == nil) {
886 		gray = xallocimage(display, Rect(0,0,1,1), RGB24, 1, 0x888888FF);
887 		if(gray == nil) {
888 			fprint(2, "g out of memory: %r\n");
889 			wexits("mem");
890 		}
891 	}
892 	border(screen, r, -4000, gray, ZP);
893 //	flushimage(display, 0);
894 }
895 
896 /* clip p to be in r */
897 Point
898 pclip(Point p, Rectangle r)
899 {
900 	if(p.x < r.min.x)
901 		p.x = r.min.x;
902 	else if(p.x >= r.max.x)
903 		p.x = r.max.x-1;
904 
905 	if(p.y < r.min.y)
906 		p.y = r.min.y;
907 	else if(p.y >= r.max.y)
908 		p.y = r.max.y-1;
909 
910 	return p;
911 }
912 
913 /*
914  * resize is perhaps a misnomer.
915  * this really just grows the window to be at least dx across
916  * and dy high.  if the window hits the bottom or right edge,
917  * it is backed up until it hits the top or left edge.
918  */
919 void
920 resize(int dx, int dy)
921 {
922 	static Rectangle sr;
923 	Rectangle r, or;
924 
925 	r = screen->r;
926 	if(Dx(sr)*Dy(sr) == 0) {
927 		sr = screenrect();
928 		/* Start with the size of the first image */
929 		r.max.x = r.min.x;
930 		r.max.y = r.min.y;
931 	}
932 
933 	if(Dx(r) >= dx && Dy(r) >= dy)
934 		return;
935 
936 	or = r;
937 
938 	r.max.x = max(r.min.x+dx, r.max.x);
939 	r.max.y = max(r.min.y+dy, r.max.y);
940 	if(r.max.x > sr.max.x){
941 		if(Dx(r) > Dx(sr)){
942 			r.min.x = 0;
943 			r.max.x = sr.max.x;
944 		}else
945 			r = rectaddpt(r, Pt(sr.max.x-r.max.x, 0));
946 	}
947 	if(r.max.y > sr.max.y){
948 		if(Dy(r) > Dy(sr)){
949 			r.min.y = 0;
950 			r.max.y = sr.max.y;
951 		}else
952 			r = rectaddpt(r, Pt(0, sr.max.y-r.max.y));
953 	}
954 
955 	/*
956 	 * Sometimes we can't actually grow the window big enough,
957 	 * and resizing it to the same shape makes it flash.
958 	 */
959 	if(Dx(r) == Dx(or) && Dy(r) == Dy(or))
960 		return;
961 
962 	drawresizewindow(r);
963 }
964 
965 /*
966  * If we allocimage after a resize but before flushing the draw buffer,
967  * we won't have seen the reshape event, and we won't have called
968  * getwindow, and allocimage will fail.  So we flushimage before every alloc.
969  */
970 Image*
971 xallocimage(Display *d, Rectangle r, ulong chan, int repl, ulong val)
972 {
973 	flushimage(display, 0);
974 	return allocimage(d, r, chan, repl, val);
975 }
976 
977 void
978 plumbproc(void *c)
979 {
980 	Channel *cp;
981 	CFid *fd;
982 
983 	cp = c;
984 	fd = plumbopenfid("image", OREAD|OCEXEC);
985 	if(fd == nil) {
986 		fprint(2, "Cannot connect to the plumber");
987 		threadexits("plumber");
988 	}
989 	for(;;) {
990 		send(cp, plumbrecvfid(fd));
991 	}
992 }
993 
994 /* XXX: This function is ugly and hacky. There may be a better way... or not */
995 Rectangle
996 screenrect(void)
997 {
998 	int fd[3], pfd[2];
999 	int n, w, h;
1000 	char buf[64];
1001 	char *p, *pr;
1002 
1003 	if(pipe(pfd) < 0)
1004 		wexits("pipe failed");
1005 
1006 	fd[0] = open("/dev/null", OREAD);
1007 	fd[1] = pfd[1];
1008 	fd[2] = dup(2, -1);
1009 	if(threadspawnl(fd, "rc", "rc", "-c", "xdpyinfo | grep 'dimensions:'", nil) == -1)
1010 		wexits("threadspawnl failed");
1011 
1012 	if((n = read(pfd[0], buf, 63)) <= 0)
1013 		wexits("read xdpyinfo failed");
1014 	close(fd[0]);
1015 
1016 	buf[n] = '\0';
1017 	for(p = buf; *p; p++)
1018 		if(*p >= '0' && *p <= '9') break;
1019 	if(*p == '\0')
1020 		wexits("xdpyinfo parse failed");
1021 
1022 	w = strtoul(p, &pr, 10);
1023 	if(p == pr || *pr == '\0' || *(++pr) == '\0')
1024 		wexits("xdpyinfo parse failed");
1025 	h = strtoul(pr, &p, 10);
1026 	if(p == pr)
1027 		wexits("xdpyinfo parse failed");
1028 
1029 	return Rect(0, 0, w, h);
1030 }
1031 
1032 void
1033 zerox(void)
1034 {
1035 	int pfd[2];
1036 	int fd[3];
1037 
1038 	pipe(pfd);
1039 	fd[0] = pfd[0];
1040 	fd[1] = dup(1, -1);
1041 	fd[2] = dup(2, -1);
1042 	threadspawnl(fd, "page", "page", "-R", nil);
1043 
1044 	writeimage(pfd[1], im, 0);
1045 	close(pfd[1]);
1046 }
1047 
1048 void
1049 fit()
1050 {
1051 	double delta;
1052 	Rectangle r;
1053 	Image* tmp;
1054 
1055 	delta = (double)Dx(screen->r)/(double)Dx(im->r);
1056 	if((double)Dy(im->r)*delta > Dy(screen->r))
1057 		delta = (double)Dy(screen->r)/(double)Dy(im->r);
1058 	r = Rect(0, 0, (int)((double)Dx(im->r)*delta), (int)((double)Dy(im->r)*delta));
1059 	setcursor(mc, &reading);
1060 	tmp = xallocimage(display, r, im->chan, 0, DBlack);
1061 	if(tmp == nil) {
1062 		fprint(2, "out of memory during fit: %r\n");
1063 		wexits("memory");
1064 	}
1065 	resample(im, tmp);
1066 	im = tmp;
1067 	delayfreeimage(tmp);
1068 	setcursor(mc, nil);
1069 	ul = screen->r.min;
1070 	redraw(screen);
1071 	flushimage(display, 1);
1072 }