1 /*
2  * /dev/draw simulator -- handles the messages prepared by the draw library.
3  * Includes all the memlayer code even though most programs don't use it.
4  * This whole approach is overkill, but cpu is cheap and it keeps things simple.
5  */
6 
7 #include <u.h>
8 #include <libc.h>
9 #include <draw.h>
10 #include <memdraw.h>
11 #include <memlayer.h>
12 
13 extern void _flushmemscreen(Rectangle);
14 
15 #define NHASH (1<<5)
16 #define HASHMASK (NHASH-1)
17 
18 typedef struct Client Client;
19 typedef struct Draw Draw;
20 typedef struct DImage DImage;
21 typedef struct DScreen DScreen;
22 typedef struct CScreen CScreen;
23 typedef struct FChar FChar;
24 typedef struct Refresh Refresh;
25 typedef struct Refx Refx;
26 typedef struct DName DName;
27 
28 struct Draw
29 {
30 	QLock		lk;
31 	int		clientid;
32 	int		nclient;
33 	Client*		client[1];
34 	int		nname;
35 	DName*		name;
36 	int		vers;
37 	int		softscreen;
38 };
39 
40 struct Client
41 {
42 	/*Ref		r;*/
43 	DImage*		dimage[NHASH];
44 	CScreen*	cscreen;
45 	Refresh*	refresh;
46 	Rendez		refrend;
47 	uchar*		readdata;
48 	int		nreaddata;
49 	int		busy;
50 	int		clientid;
51 	int		slot;
52 	int		refreshme;
53 	int		infoid;
54 	int		op;
55 };
56 
57 struct Refresh
58 {
59 	DImage*		dimage;
60 	Rectangle	r;
61 	Refresh*	next;
62 };
63 
64 struct Refx
65 {
66 	Client*		client;
67 	DImage*		dimage;
68 };
69 
70 struct DName
71 {
72 	char			*name;
73 	Client	*client;
74 	DImage*		dimage;
75 	int			vers;
76 };
77 
78 struct FChar
79 {
80 	int		minx;	/* left edge of bits */
81 	int		maxx;	/* right edge of bits */
82 	uchar		miny;	/* first non-zero scan-line */
83 	uchar		maxy;	/* last non-zero scan-line + 1 */
84 	schar		left;	/* offset of baseline */
85 	uchar		width;	/* width of baseline */
86 };
87 
88 /*
89  * Reference counts in DImages:
90  *	one per open by original client
91  *	one per screen image or fill
92  * 	one per image derived from this one by name
93  */
94 struct DImage
95 {
96 	int		id;
97 	int		ref;
98 	char		*name;
99 	int		vers;
100 	Memimage*	image;
101 	int		ascent;
102 	int		nfchar;
103 	FChar*		fchar;
104 	DScreen*	dscreen;	/* 0 if not a window */
105 	DImage*	fromname;	/* image this one is derived from, by name */
106 	DImage*		next;
107 };
108 
109 struct CScreen
110 {
111 	DScreen*	dscreen;
112 	CScreen*	next;
113 };
114 
115 struct DScreen
116 {
117 	int		id;
118 	int		public;
119 	int		ref;
120 	DImage	*dimage;
121 	DImage	*dfill;
122 	Memscreen*	screen;
123 	Client*		owner;
124 	DScreen*	next;
125 };
126 
127 static	Draw		sdraw;
128 static	Client		*client0;
129 static	Memimage	*screenimage;
130 static	Rectangle	flushrect;
131 static	int		waste;
132 static	DScreen*	dscreen;
133 static	int		drawuninstall(Client*, int);
134 static	Memimage*	drawinstall(Client*, int, Memimage*, DScreen*);
135 static	void		drawfreedimage(DImage*);
136 
137 void
138 _initdisplaymemimage(Display *d, Memimage *m)
139 {
140 	screenimage = m;
141 	m->screenref = 1;
142 	client0 = mallocz(sizeof(Client), 1);
143 	if(client0 == nil){
144 		fprint(2, "initdraw: allocating client0: out of memory");
145 		abort();
146 	}
147 	client0->slot = 0;
148 	client0->clientid = ++sdraw.clientid;
149 	client0->op = SoverD;
150 	sdraw.client[0] = client0;
151 	sdraw.nclient = 1;
152 	sdraw.softscreen = 1;
153 }
154 
155 void
156 _drawreplacescreenimage(Memimage *m)
157 {
158 	/*
159 	 * Replace the screen image because the screen
160 	 * was resized.
161 	 * 
162 	 * In theory there should only be one reference
163 	 * to the current screen image, and that's through
164 	 * client0's image 0, installed a few lines above.
165 	 * Once the client drops the image, the underlying backing 
166 	 * store freed properly.  The client is being notified
167 	 * about the resize through external means, so all we
168 	 * need to do is this assignment.
169 	 */
170 	Memimage *om;
171 
172 	qlock(&sdraw.lk);
173 	om = screenimage;
174 	screenimage = m;
175 	m->screenref = 1;
176 	if(om && --om->screenref == 0){
177 		_freememimage(om);
178 	}
179 	qunlock(&sdraw.lk);
180 }
181 
182 static
183 void
184 drawrefreshscreen(DImage *l, Client *client)
185 {
186 	while(l != nil && l->dscreen == nil)
187 		l = l->fromname;
188 	if(l != nil && l->dscreen->owner != client)
189 		l->dscreen->owner->refreshme = 1;
190 }
191 
192 static
193 void
194 drawrefresh(Memimage *m, Rectangle r, void *v)
195 {
196 	Refx *x;
197 	DImage *d;
198 	Client *c;
199 	Refresh *ref;
200 
201 	USED(m);
202 
203 	if(v == 0)
204 		return;
205 	x = v;
206 	c = x->client;
207 	d = x->dimage;
208 	for(ref=c->refresh; ref; ref=ref->next)
209 		if(ref->dimage == d){
210 			combinerect(&ref->r, r);
211 			return;
212 		}
213 	ref = mallocz(sizeof(Refresh), 1);
214 	if(ref){
215 		ref->dimage = d;
216 		ref->r = r;
217 		ref->next = c->refresh;
218 		c->refresh = ref;
219 	}
220 }
221 
222 static void
223 addflush(Rectangle r)
224 {
225 	int abb, ar, anbb;
226 	Rectangle nbb;
227 
228 	if(sdraw.softscreen==0 || !rectclip(&r, screenimage->r))
229 		return;
230 
231 	if(flushrect.min.x >= flushrect.max.x){
232 		flushrect = r;
233 		waste = 0;
234 		return;
235 	}
236 	nbb = flushrect;
237 	combinerect(&nbb, r);
238 	ar = Dx(r)*Dy(r);
239 	abb = Dx(flushrect)*Dy(flushrect);
240 	anbb = Dx(nbb)*Dy(nbb);
241 	/*
242 	 * Area of new waste is area of new bb minus area of old bb,
243 	 * less the area of the new segment, which we assume is not waste.
244 	 * This could be negative, but that's OK.
245 	 */
246 	waste += anbb-abb - ar;
247 	if(waste < 0)
248 		waste = 0;
249 	/*
250 	 * absorb if:
251 	 *	total area is small
252 	 *	waste is less than half total area
253 	 * 	rectangles touch
254 	 */
255 	if(anbb<=1024 || waste*2<anbb || rectXrect(flushrect, r)){
256 		flushrect = nbb;
257 		return;
258 	}
259 	/* emit current state */
260 	if(flushrect.min.x < flushrect.max.x)
261 		_flushmemscreen(flushrect);
262 	flushrect = r;
263 	waste = 0;
264 }
265 
266 static
267 void
268 dstflush(int dstid, Memimage *dst, Rectangle r)
269 {
270 	Memlayer *l;
271 
272 	if(dstid == 0){
273 		combinerect(&flushrect, r);
274 		return;
275 	}
276 	/* how can this happen? -rsc, dec 12 2002 */
277 	if(dst == 0){
278 		print("nil dstflush\n");
279 		return;
280 	}
281 	l = dst->layer;
282 	if(l == nil)
283 		return;
284 	do{
285 		if(l->screen->image->data != screenimage->data)
286 			return;
287 		r = rectaddpt(r, l->delta);
288 		l = l->screen->image->layer;
289 	}while(l);
290 	addflush(r);
291 }
292 
293 static
294 void
295 drawflush(void)
296 {
297 	if(flushrect.min.x < flushrect.max.x)
298 		_flushmemscreen(flushrect);
299 	flushrect = Rect(10000, 10000, -10000, -10000);
300 }
301 
302 static
303 int
304 drawcmp(char *a, char *b, int n)
305 {
306 	if(strlen(a) != n)
307 		return 1;
308 	return memcmp(a, b, n);
309 }
310 
311 static
312 DName*
313 drawlookupname(int n, char *str)
314 {
315 	DName *name, *ename;
316 
317 	name = sdraw.name;
318 	ename = &name[sdraw.nname];
319 	for(; name<ename; name++)
320 		if(drawcmp(name->name, str, n) == 0)
321 			return name;
322 	return 0;
323 }
324 
325 static
326 int
327 drawgoodname(DImage *d)
328 {
329 	DName *n;
330 
331 	/* if window, validate the screen's own images */
332 	if(d->dscreen)
333 		if(drawgoodname(d->dscreen->dimage) == 0
334 		|| drawgoodname(d->dscreen->dfill) == 0)
335 			return 0;
336 	if(d->name == nil)
337 		return 1;
338 	n = drawlookupname(strlen(d->name), d->name);
339 	if(n==nil || n->vers!=d->vers)
340 		return 0;
341 	return 1;
342 }
343 
344 static
345 DImage*
346 drawlookup(Client *client, int id, int checkname)
347 {
348 	DImage *d;
349 
350 	d = client->dimage[id&HASHMASK];
351 	while(d){
352 		if(d->id == id){
353 			/*
354 			 * BUG: should error out but too hard.
355 			 * Return 0 instead.
356 			 */
357 			if(checkname && !drawgoodname(d))
358 				return 0;
359 			return d;
360 		}
361 		d = d->next;
362 	}
363 	return 0;
364 }
365 
366 static
367 DScreen*
368 drawlookupdscreen(int id)
369 {
370 	DScreen *s;
371 
372 	s = dscreen;
373 	while(s){
374 		if(s->id == id)
375 			return s;
376 		s = s->next;
377 	}
378 	return 0;
379 }
380 
381 static
382 DScreen*
383 drawlookupscreen(Client *client, int id, CScreen **cs)
384 {
385 	CScreen *s;
386 
387 	s = client->cscreen;
388 	while(s){
389 		if(s->dscreen->id == id){
390 			*cs = s;
391 			return s->dscreen;
392 		}
393 		s = s->next;
394 	}
395 	/* caller must check! */
396 	return 0;
397 }
398 
399 static
400 Memimage*
401 drawinstall(Client *client, int id, Memimage *i, DScreen *dscreen)
402 {
403 	DImage *d;
404 
405 	d = mallocz(sizeof(DImage), 1);
406 	if(d == 0)
407 		return 0;
408 	d->id = id;
409 	d->ref = 1;
410 	d->name = 0;
411 	d->vers = 0;
412 	d->image = i;
413 	if(i->screenref)
414 		++i->screenref;
415 	d->nfchar = 0;
416 	d->fchar = 0;
417 	d->fromname = 0;
418 	d->dscreen = dscreen;
419 	d->next = client->dimage[id&HASHMASK];
420 	client->dimage[id&HASHMASK] = d;
421 	return i;
422 }
423 
424 static
425 Memscreen*
426 drawinstallscreen(Client *client, DScreen *d, int id, DImage *dimage, DImage *dfill, int public)
427 {
428 	Memscreen *s;
429 	CScreen *c;
430 
431 	c = mallocz(sizeof(CScreen), 1);
432 	if(dimage && dimage->image && dimage->image->chan == 0){
433 		print("bad image %p in drawinstallscreen", dimage->image);
434 		abort();
435 	}
436 
437 	if(c == 0)
438 		return 0;
439 	if(d == 0){
440 		d = mallocz(sizeof(DScreen), 1);
441 		if(d == 0){
442 			free(c);
443 			return 0;
444 		}
445 		s = mallocz(sizeof(Memscreen), 1);
446 		if(s == 0){
447 			free(c);
448 			free(d);
449 			return 0;
450 		}
451 		s->frontmost = 0;
452 		s->rearmost = 0;
453 		d->dimage = dimage;
454 		if(dimage){
455 			s->image = dimage->image;
456 			dimage->ref++;
457 		}
458 		d->dfill = dfill;
459 		if(dfill){
460 			s->fill = dfill->image;
461 			dfill->ref++;
462 		}
463 		d->ref = 0;
464 		d->id = id;
465 		d->screen = s;
466 		d->public = public;
467 		d->next = dscreen;
468 		d->owner = client;
469 		dscreen = d;
470 	}
471 	c->dscreen = d;
472 	d->ref++;
473 	c->next = client->cscreen;
474 	client->cscreen = c;
475 	return d->screen;
476 }
477 
478 static
479 void
480 drawdelname(DName *name)
481 {
482 	int i;
483 
484 	i = name-sdraw.name;
485 	memmove(name, name+1, (sdraw.nname-(i+1))*sizeof(DName));
486 	sdraw.nname--;
487 }
488 
489 static
490 void
491 drawfreedscreen(DScreen *this)
492 {
493 	DScreen *ds, *next;
494 
495 	this->ref--;
496 	if(this->ref < 0)
497 		print("negative ref in drawfreedscreen\n");
498 	if(this->ref > 0)
499 		return;
500 	ds = dscreen;
501 	if(ds == this){
502 		dscreen = this->next;
503 		goto Found;
504 	}
505 	while(next = ds->next){	/* assign = */
506 		if(next == this){
507 			ds->next = this->next;
508 			goto Found;
509 		}
510 		ds = next;
511 	}
512 	/*
513 	 * Should signal Enodrawimage, but too hard.
514 	 */
515 	return;
516 
517     Found:
518 	if(this->dimage)
519 		drawfreedimage(this->dimage);
520 	if(this->dfill)
521 		drawfreedimage(this->dfill);
522 	free(this->screen);
523 	free(this);
524 }
525 
526 static
527 void
528 drawfreedimage(DImage *dimage)
529 {
530 	int i;
531 	Memimage *l;
532 	DScreen *ds;
533 
534 	dimage->ref--;
535 	if(dimage->ref < 0)
536 		print("negative ref in drawfreedimage\n");
537 	if(dimage->ref > 0)
538 		return;
539 
540 	/* any names? */
541 	for(i=0; i<sdraw.nname; )
542 		if(sdraw.name[i].dimage == dimage)
543 			drawdelname(sdraw.name+i);
544 		else
545 			i++;
546 	if(dimage->fromname){	/* acquired by name; owned by someone else*/
547 		drawfreedimage(dimage->fromname);
548 		goto Return;
549 	}
550 	ds = dimage->dscreen;
551 	l = dimage->image;
552 	if(ds){
553 		if(l->data == screenimage->data)
554 			addflush(l->layer->screenr);
555 		if(l->layer->refreshfn == drawrefresh)	/* else true owner will clean up */
556 			free(l->layer->refreshptr);
557 		l->layer->refreshptr = nil;
558 		if(drawgoodname(dimage))
559 			memldelete(l);
560 		else
561 			memlfree(l);
562 		drawfreedscreen(ds);
563 	}else{
564 		if(l->screenref==0)
565 			freememimage(l);
566 		else if(--l->screenref==0)
567 			_freememimage(l);
568 	}
569     Return:
570 	free(dimage->fchar);
571 	free(dimage);
572 }
573 
574 static
575 void
576 drawuninstallscreen(Client *client, CScreen *this)
577 {
578 	CScreen *cs, *next;
579 
580 	cs = client->cscreen;
581 	if(cs == this){
582 		client->cscreen = this->next;
583 		drawfreedscreen(this->dscreen);
584 		free(this);
585 		return;
586 	}
587 	while(next = cs->next){	/* assign = */
588 		if(next == this){
589 			cs->next = this->next;
590 			drawfreedscreen(this->dscreen);
591 			free(this);
592 			return;
593 		}
594 		cs = next;
595 	}
596 }
597 
598 static
599 int
600 drawuninstall(Client *client, int id)
601 {
602 	DImage *d, *next;
603 
604 	d = client->dimage[id&HASHMASK];
605 	if(d == 0)
606 		return -1;
607 	if(d->id == id){
608 		client->dimage[id&HASHMASK] = d->next;
609 		drawfreedimage(d);
610 		return 0;
611 	}
612 	while(next = d->next){	/* assign = */
613 		if(next->id == id){
614 			d->next = next->next;
615 			drawfreedimage(next);
616 			return 0;
617 		}
618 		d = next;
619 	}
620 	return -1;
621 }
622 
623 static
624 int
625 drawaddname(Client *client, DImage *di, int n, char *str, char **err)
626 {
627 	DName *name, *ename, *new, *t;
628 	char *ns;
629 
630 	name = sdraw.name;
631 	ename = &name[sdraw.nname];
632 	for(; name<ename; name++)
633 		if(drawcmp(name->name, str, n) == 0){
634 			*err = "image name in use";
635 			return -1;
636 		}
637 	t = mallocz((sdraw.nname+1)*sizeof(DName), 1);
638 	ns = malloc(n+1);
639 	if(t == nil || ns == nil){
640 		free(t);
641 		free(ns);
642 		*err = "out of memory";
643 		return -1;
644 	}
645 	memmove(t, sdraw.name, sdraw.nname*sizeof(DName));
646 	free(sdraw.name);
647 	sdraw.name = t;
648 	new = &sdraw.name[sdraw.nname++];
649 	new->name = ns;
650 	memmove(new->name, str, n);
651 	new->name[n] = 0;
652 	new->dimage = di;
653 	new->client = client;
654 	new->vers = ++sdraw.vers;
655 	return 0;
656 }
657 
658 static int
659 drawclientop(Client *cl)
660 {
661 	int op;
662 
663 	op = cl->op;
664 	cl->op = SoverD;
665 	return op;
666 }
667 
668 static
669 Memimage*
670 drawimage(Client *client, uchar *a)
671 {
672 	DImage *d;
673 
674 	d = drawlookup(client, BGLONG(a), 1);
675 	if(d == nil)
676 		return nil;	/* caller must check! */
677 	return d->image;
678 }
679 
680 static
681 void
682 drawrectangle(Rectangle *r, uchar *a)
683 {
684 	r->min.x = BGLONG(a+0*4);
685 	r->min.y = BGLONG(a+1*4);
686 	r->max.x = BGLONG(a+2*4);
687 	r->max.y = BGLONG(a+3*4);
688 }
689 
690 static
691 void
692 drawpoint(Point *p, uchar *a)
693 {
694 	p->x = BGLONG(a+0*4);
695 	p->y = BGLONG(a+1*4);
696 }
697 
698 static
699 Point
700 drawchar(Memimage *dst, Point p, Memimage *src, Point *sp, DImage *font, int index, int op)
701 {
702 	FChar *fc;
703 	Rectangle r;
704 	Point sp1;
705 
706 	fc = &font->fchar[index];
707 	r.min.x = p.x+fc->left;
708 	r.min.y = p.y-(font->ascent-fc->miny);
709 	r.max.x = r.min.x+(fc->maxx-fc->minx);
710 	r.max.y = r.min.y+(fc->maxy-fc->miny);
711 	sp1.x = sp->x+fc->left;
712 	sp1.y = sp->y+fc->miny;
713 	memdraw(dst, r, src, sp1, font->image, Pt(fc->minx, fc->miny), op);
714 	p.x += fc->width;
715 	sp->x += fc->width;
716 	return p;
717 }
718 
719 static
720 uchar*
721 drawcoord(uchar *p, uchar *maxp, int oldx, int *newx)
722 {
723 	int b, x;
724 
725 	if(p >= maxp)
726 		return nil;
727 	b = *p++;
728 	x = b & 0x7F;
729 	if(b & 0x80){
730 		if(p+1 >= maxp)
731 			return nil;
732 		x |= *p++ << 7;
733 		x |= *p++ << 15;
734 		if(x & (1<<22))
735 			x |= ~0<<23;
736 	}else{
737 		if(b & 0x40)
738 			x |= ~0<<7;
739 		x += oldx;
740 	}
741 	*newx = x;
742 	return p;
743 }
744 
745 int
746 _drawmsgread(Display *d, void *a, int n)
747 {
748 	Client *cl;
749 
750 	qlock(&sdraw.lk);
751 	cl = client0;
752 	if(cl->readdata == nil){
753 		werrstr("no draw data");
754 		goto err;
755 	}
756 	if(n < cl->nreaddata){
757 		werrstr("short read");
758 		goto err;
759 	}
760 	n = cl->nreaddata;
761 	memmove(a, cl->readdata, cl->nreaddata);
762 	free(cl->readdata);
763 	cl->readdata = nil;
764 	qunlock(&sdraw.lk);
765 	return n;
766 
767 err:
768 	qunlock(&sdraw.lk);
769 	return -1;
770 }
771 
772 int
773 _drawmsgwrite(Display *d, void *v, int n)
774 {
775 	char cbuf[40], *err, ibuf[12*12+1], *s;
776 	int c, ci, doflush, dstid, e0, e1, esize, j, m;
777 	int ni, nw, oesize, oldn, op, ox, oy, repl, scrnid, y; 
778 	uchar *a, refresh, *u;
779 	u32int chan, value;
780 	Client *client;
781 	CScreen *cs;
782 	DImage *di, *ddst, *dsrc, *font, *ll;
783 	DName *dn;
784 	DScreen *dscrn;
785 	FChar *fc;
786 	Memimage *dst, *i, *l, **lp, *mask, *src;
787 	Memscreen *scrn;
788 	Point p, *pp, q, sp;
789 	Rectangle clipr, r;
790 	Refreshfn reffn;
791 	Refx *refx;
792 
793 	qlock(&sdraw.lk);
794 	d->obufp = d->obuf;
795 	a = v;
796 	m = 0;
797 	oldn = n;
798 	client = client0;
799 
800 	while((n-=m) > 0){
801 		a += m;
802 //fprint(2, "msgwrite %d(%d)...", n, *a);
803 		switch(*a){
804 		default:
805 //fprint(2, "bad command %d\n", *a);
806 			err = "bad draw command";
807 			goto error;
808 
809 		/* allocate: 'b' id[4] screenid[4] refresh[1] chan[4] repl[1]
810 			R[4*4] clipR[4*4] rrggbbaa[4]
811 		 */
812 		case 'b':
813 			m = 1+4+4+1+4+1+4*4+4*4+4;
814 			if(n < m)
815 				goto Eshortdraw;
816 			dstid = BGLONG(a+1);
817 			scrnid = BGSHORT(a+5);
818 			refresh = a[9];
819 			chan = BGLONG(a+10);
820 			repl = a[14];
821 			drawrectangle(&r, a+15);
822 			drawrectangle(&clipr, a+31);
823 			value = BGLONG(a+47);
824 			if(drawlookup(client, dstid, 0))
825 				goto Eimageexists;
826 			if(scrnid){
827 				dscrn = drawlookupscreen(client, scrnid, &cs);
828 				if(!dscrn)
829 					goto Enodrawscreen;
830 				scrn = dscrn->screen;
831 				if(repl || chan!=scrn->image->chan){
832 					err = "image parameters incompatibile with screen";
833 					goto error;
834 				}
835 				reffn = 0;
836 				switch(refresh){
837 				case Refbackup:
838 					break;
839 				case Refnone:
840 					reffn = memlnorefresh;
841 					break;
842 				case Refmesg:
843 					reffn = drawrefresh;
844 					break;
845 				default:
846 					err = "unknown refresh method";
847 					goto error;
848 				}
849 				l = memlalloc(scrn, r, reffn, 0, value);
850 				if(l == 0)
851 					goto Edrawmem;
852 				addflush(l->layer->screenr);
853 				l->clipr = clipr;
854 				rectclip(&l->clipr, r);
855 				if(drawinstall(client, dstid, l, dscrn) == 0){
856 					memldelete(l);
857 					goto Edrawmem;
858 				}
859 				dscrn->ref++;
860 				if(reffn){
861 					refx = nil;
862 					if(reffn == drawrefresh){
863 						refx = mallocz(sizeof(Refx), 1);
864 						if(refx == 0){
865 							if(drawuninstall(client, dstid) < 0)
866 								goto Enodrawimage;
867 							goto Edrawmem;
868 						}
869 						refx->client = client;
870 						refx->dimage = drawlookup(client, dstid, 1);
871 					}
872 					memlsetrefresh(l, reffn, refx);
873 				}
874 				continue;
875 			}
876 			i = allocmemimage(r, chan);
877 			if(i == 0)
878 				goto Edrawmem;
879 			if(repl)
880 				i->flags |= Frepl;
881 			i->clipr = clipr;
882 			if(!repl)
883 				rectclip(&i->clipr, r);
884 			if(drawinstall(client, dstid, i, 0) == 0){
885 				freememimage(i);
886 				goto Edrawmem;
887 			}
888 			memfillcolor(i, value);
889 			continue;
890 
891 		/* allocate screen: 'A' id[4] imageid[4] fillid[4] public[1] */
892 		case 'A':
893 			m = 1+4+4+4+1;
894 			if(n < m)
895 				goto Eshortdraw;
896 			dstid = BGLONG(a+1);
897 			if(dstid == 0)
898 				goto Ebadarg;
899 			if(drawlookupdscreen(dstid))
900 				goto Escreenexists;
901 			ddst = drawlookup(client, BGLONG(a+5), 1);
902 			dsrc = drawlookup(client, BGLONG(a+9), 1);
903 			if(ddst==0 || dsrc==0)
904 				goto Enodrawimage;
905 			if(drawinstallscreen(client, 0, dstid, ddst, dsrc, a[13]) == 0)
906 				goto Edrawmem;
907 			continue;
908 
909 		/* set repl and clip: 'c' dstid[4] repl[1] clipR[4*4] */
910 		case 'c':
911 			m = 1+4+1+4*4;
912 			if(n < m)
913 				goto Eshortdraw;
914 			ddst = drawlookup(client, BGLONG(a+1), 1);
915 			if(ddst == nil)
916 				goto Enodrawimage;
917 			if(ddst->name){
918 				err = "can't change repl/clipr of shared image";
919 				goto error;
920 			}
921 			dst = ddst->image;
922 			if(a[5])
923 				dst->flags |= Frepl;
924 			drawrectangle(&dst->clipr, a+6);
925 			continue;
926 
927 		/* draw: 'd' dstid[4] srcid[4] maskid[4] R[4*4] P[2*4] P[2*4] */
928 		case 'd':
929 			m = 1+4+4+4+4*4+2*4+2*4;
930 			if(n < m)
931 				goto Eshortdraw;
932 			dst = drawimage(client, a+1);
933 			dstid = BGLONG(a+1);
934 			src = drawimage(client, a+5);
935 			mask = drawimage(client, a+9);
936 			if(!dst || !src || !mask)
937 				goto Enodrawimage;
938 			drawrectangle(&r, a+13);
939 			drawpoint(&p, a+29);
940 			drawpoint(&q, a+37);
941 			op = drawclientop(client);
942 			memdraw(dst, r, src, p, mask, q, op);
943 			dstflush(dstid, dst, r);
944 			continue;
945 
946 		/* toggle debugging: 'D' val[1] */
947 		case 'D':
948 			m = 1+1;
949 			if(n < m)
950 				goto Eshortdraw;
951 			drawdebug = a[1];
952 			continue;
953 
954 		/* ellipse: 'e' dstid[4] srcid[4] center[2*4] a[4] b[4] thick[4] sp[2*4] alpha[4] phi[4]*/
955 		case 'e':
956 		case 'E':
957 			m = 1+4+4+2*4+4+4+4+2*4+2*4;
958 			if(n < m)
959 				goto Eshortdraw;
960 			dst = drawimage(client, a+1);
961 			dstid = BGLONG(a+1);
962 			src = drawimage(client, a+5);
963 			if(!dst || !src)
964 				goto Enodrawimage;
965 			drawpoint(&p, a+9);
966 			e0 = BGLONG(a+17);
967 			e1 = BGLONG(a+21);
968 			if(e0<0 || e1<0){
969 				err = "invalid ellipse semidiameter";
970 				goto error;
971 			}
972 			j = BGLONG(a+25);
973 			if(j < 0){
974 				err = "negative ellipse thickness";
975 				goto error;
976 			}
977 			
978 			drawpoint(&sp, a+29);
979 			c = j;
980 			if(*a == 'E')
981 				c = -1;
982 			ox = BGLONG(a+37);
983 			oy = BGLONG(a+41);
984 			op = drawclientop(client);
985 			/* high bit indicates arc angles are present */
986 			if(ox & ((ulong)1<<31)){
987 				if((ox & ((ulong)1<<30)) == 0)
988 					ox &= ~((ulong)1<<31);
989 				memarc(dst, p, e0, e1, c, src, sp, ox, oy, op);
990 			}else
991 				memellipse(dst, p, e0, e1, c, src, sp, op);
992 			dstflush(dstid, dst, Rect(p.x-e0-j, p.y-e1-j, p.x+e0+j+1, p.y+e1+j+1));
993 			continue;
994 
995 		/* free: 'f' id[4] */
996 		case 'f':
997 			m = 1+4;
998 			if(n < m)
999 				goto Eshortdraw;
1000 			ll = drawlookup(client, BGLONG(a+1), 0);
1001 			if(ll && ll->dscreen && ll->dscreen->owner != client)
1002 				ll->dscreen->owner->refreshme = 1;
1003 			if(drawuninstall(client, BGLONG(a+1)) < 0)
1004 				goto Enodrawimage;
1005 			continue;
1006 
1007 		/* free screen: 'F' id[4] */
1008 		case 'F':
1009 			m = 1+4;
1010 			if(n < m)
1011 				goto Eshortdraw;
1012 			if(!drawlookupscreen(client, BGLONG(a+1), &cs))
1013 				goto Enodrawscreen;
1014 			drawuninstallscreen(client, cs);
1015 			continue;
1016 
1017 		/* initialize font: 'i' fontid[4] nchars[4] ascent[1] */
1018 		case 'i':
1019 			m = 1+4+4+1;
1020 			if(n < m)
1021 				goto Eshortdraw;
1022 			dstid = BGLONG(a+1);
1023 			if(dstid == 0){
1024 				err = "can't use display as font";
1025 				goto error;
1026 			}
1027 			font = drawlookup(client, dstid, 1);
1028 			if(font == 0)
1029 				goto Enodrawimage;
1030 			if(font->image->layer){
1031 				err = "can't use window as font";
1032 				goto error;
1033 			}
1034 			ni = BGLONG(a+5);
1035 			if(ni<=0 || ni>4096){
1036 				err = "bad font size (4096 chars max)";
1037 				goto error;
1038 			}
1039 			free(font->fchar);	/* should we complain if non-zero? */
1040 			font->fchar = mallocz(ni*sizeof(FChar), 1);
1041 			if(font->fchar == 0){
1042 				err = "no memory for font";
1043 				goto error;
1044 			}
1045 			memset(font->fchar, 0, ni*sizeof(FChar));
1046 			font->nfchar = ni;
1047 			font->ascent = a[9];
1048 			continue;
1049 
1050 		/* set image 0 to screen image */
1051 		case 'J':
1052 			m = 1;
1053 			if(n < m)
1054 				goto Eshortdraw;
1055 			if(drawlookup(client, 0, 0))
1056 				goto Eimageexists;
1057 			drawinstall(client, 0, screenimage, 0);
1058 			client->infoid = 0;
1059 			continue;
1060 
1061 		/* get image info: 'I' */
1062 		case 'I':
1063 			m = 1;
1064 			if(n < m)
1065 				goto Eshortdraw;
1066 			if(client->infoid < 0)
1067 				goto Enodrawimage;
1068 			if(client->infoid == 0){
1069 				i = screenimage;
1070 				if(i == nil)
1071 					goto Enodrawimage;
1072 			}else{
1073 				di = drawlookup(client, client->infoid, 1);
1074 				if(di == nil)
1075 					goto Enodrawimage;
1076 				i = di->image;
1077 			}
1078 			ni = sprint(ibuf, "%11d %11d %11s %11d %11d %11d %11d %11d"
1079 					" %11d %11d %11d %11d ",
1080 					client->clientid,
1081 					client->infoid,	
1082 					chantostr(cbuf, i->chan),
1083 					(i->flags&Frepl)==Frepl,
1084 					i->r.min.x, i->r.min.y, i->r.max.x, i->r.max.y,
1085 					i->clipr.min.x, i->clipr.min.y, 
1086 					i->clipr.max.x, i->clipr.max.y);
1087 			free(client->readdata);
1088 			client->readdata = malloc(ni);
1089 			if(client->readdata == nil)
1090 				goto Enomem;
1091 			memmove(client->readdata, ibuf, ni);
1092 			client->nreaddata = ni;
1093 			client->infoid = -1;
1094 			continue;	
1095 
1096 		/* load character: 'l' fontid[4] srcid[4] index[2] R[4*4] P[2*4] left[1] width[1] */
1097 		case 'l':
1098 			m = 1+4+4+2+4*4+2*4+1+1;
1099 			if(n < m)
1100 				goto Eshortdraw;
1101 			font = drawlookup(client, BGLONG(a+1), 1);
1102 			if(font == 0)
1103 				goto Enodrawimage;
1104 			if(font->nfchar == 0)
1105 				goto Enotfont;
1106 			src = drawimage(client, a+5);
1107 			if(!src)
1108 				goto Enodrawimage;
1109 			ci = BGSHORT(a+9);
1110 			if(ci >= font->nfchar)
1111 				goto Eindex;
1112 			drawrectangle(&r, a+11);
1113 			drawpoint(&p, a+27);
1114 			memdraw(font->image, r, src, p, memopaque, p, S);
1115 			fc = &font->fchar[ci];
1116 			fc->minx = r.min.x;
1117 			fc->maxx = r.max.x;
1118 			fc->miny = r.min.y;
1119 			fc->maxy = r.max.y;
1120 			fc->left = a[35];
1121 			fc->width = a[36];
1122 			continue;
1123 
1124 		/* draw line: 'L' dstid[4] p0[2*4] p1[2*4] end0[4] end1[4] radius[4] srcid[4] sp[2*4] */
1125 		case 'L':
1126 			m = 1+4+2*4+2*4+4+4+4+4+2*4;
1127 			if(n < m)
1128 				goto Eshortdraw;
1129 			dst = drawimage(client, a+1);
1130 			dstid = BGLONG(a+1);
1131 			drawpoint(&p, a+5);
1132 			drawpoint(&q, a+13);
1133 			e0 = BGLONG(a+21);
1134 			e1 = BGLONG(a+25);
1135 			j = BGLONG(a+29);
1136 			if(j < 0){
1137 				err = "negative line width";
1138 				goto error;
1139 			}
1140 			src = drawimage(client, a+33);
1141 			if(!dst || !src)
1142 				goto Enodrawimage;
1143 			drawpoint(&sp, a+37);
1144 			op = drawclientop(client);
1145 			memline(dst, p, q, e0, e1, j, src, sp, op);
1146 			/* avoid memlinebbox if possible */
1147 			if(dstid==0 || dst->layer!=nil){
1148 				/* BUG: this is terribly inefficient: update maximal containing rect*/
1149 				r = memlinebbox(p, q, e0, e1, j);
1150 				dstflush(dstid, dst, insetrect(r, -(1+1+j)));
1151 			}
1152 			continue;
1153 
1154 		/* create image mask: 'm' newid[4] id[4] */
1155 /*
1156  *
1157 		case 'm':
1158 			m = 4+4;
1159 			if(n < m)
1160 				goto Eshortdraw;
1161 			break;
1162  *
1163  */
1164 
1165 		/* attach to a named image: 'n' dstid[4] j[1] name[j] */
1166 		case 'n':
1167 			m = 1+4+1;
1168 			if(n < m)
1169 				goto Eshortdraw;
1170 			j = a[5];
1171 			if(j == 0)	/* give me a non-empty name please */
1172 				goto Eshortdraw;
1173 			m += j;
1174 			if(n < m)
1175 				goto Eshortdraw;
1176 			dstid = BGLONG(a+1);
1177 			if(drawlookup(client, dstid, 0))
1178 				goto Eimageexists;
1179 			dn = drawlookupname(j, (char*)a+6);
1180 			if(dn == nil)
1181 				goto Enoname;
1182 			s = malloc(j+1);
1183 			if(s == nil)
1184 				goto Enomem;
1185 			if(drawinstall(client, dstid, dn->dimage->image, 0) == 0)
1186 				goto Edrawmem;
1187 			di = drawlookup(client, dstid, 0);
1188 			if(di == 0)
1189 				goto Eoldname;
1190 			di->vers = dn->vers;
1191 			di->name = s;
1192 			di->fromname = dn->dimage;
1193 			di->fromname->ref++;
1194 			memmove(di->name, a+6, j);
1195 			di->name[j] = 0;
1196 			client->infoid = dstid;
1197 			continue;
1198 
1199 		/* name an image: 'N' dstid[4] in[1] j[1] name[j] */
1200 		case 'N':
1201 			m = 1+4+1+1;
1202 			if(n < m)
1203 				goto Eshortdraw;
1204 			c = a[5];
1205 			j = a[6];
1206 			if(j == 0)	/* give me a non-empty name please */
1207 				goto Eshortdraw;
1208 			m += j;
1209 			if(n < m)
1210 				goto Eshortdraw;
1211 			di = drawlookup(client, BGLONG(a+1), 0);
1212 			if(di == 0)
1213 				goto Enodrawimage;
1214 			if(di->name)
1215 				goto Enamed;
1216 			if(c)
1217 				if(drawaddname(client, di, j, (char*)a+7, &err) < 0)
1218 					goto error;
1219 			else{
1220 				dn = drawlookupname(j, (char*)a+7);
1221 				if(dn == nil)
1222 					goto Enoname;
1223 				if(dn->dimage != di)
1224 					goto Ewrongname;
1225 				drawdelname(dn);
1226 			}
1227 			continue;
1228 
1229 		/* position window: 'o' id[4] r.min [2*4] screenr.min [2*4] */
1230 		case 'o':
1231 			m = 1+4+2*4+2*4;
1232 			if(n < m)
1233 				goto Eshortdraw;
1234 			dst = drawimage(client, a+1);
1235 			if(!dst)
1236 				goto Enodrawimage;
1237 			if(dst->layer){
1238 				drawpoint(&p, a+5);
1239 				drawpoint(&q, a+13);
1240 				r = dst->layer->screenr;
1241 				ni = memlorigin(dst, p, q);
1242 				if(ni < 0){
1243 					err = "image origin failed";
1244 					goto error;
1245 				}
1246 				if(ni > 0){
1247 					addflush(r);
1248 					addflush(dst->layer->screenr);
1249 					ll = drawlookup(client, BGLONG(a+1), 1);
1250 					drawrefreshscreen(ll, client);
1251 				}
1252 			}
1253 			continue;
1254 
1255 		/* set compositing operator for next draw operation: 'O' op */
1256 		case 'O':
1257 			m = 1+1;
1258 			if(n < m)
1259 				goto Eshortdraw;
1260 			client->op = a[1];
1261 			continue;
1262 
1263 		/* filled polygon: 'P' dstid[4] n[2] wind[4] ignore[2*4] srcid[4] sp[2*4] p0[2*4] dp[2*2*n] */
1264 		/* polygon: 'p' dstid[4] n[2] end0[4] end1[4] radius[4] srcid[4] sp[2*4] p0[2*4] dp[2*2*n] */
1265 		case 'p':
1266 		case 'P':
1267 			m = 1+4+2+4+4+4+4+2*4;
1268 			if(n < m)
1269 				goto Eshortdraw;
1270 			dstid = BGLONG(a+1);
1271 			dst = drawimage(client, a+1);
1272 			ni = BGSHORT(a+5);
1273 			if(ni < 0){
1274 				err = "negative cout in polygon";
1275 				goto error;
1276 			}
1277 			e0 = BGLONG(a+7);
1278 			e1 = BGLONG(a+11);
1279 			j = 0;
1280 			if(*a == 'p'){
1281 				j = BGLONG(a+15);
1282 				if(j < 0){
1283 					err = "negative polygon line width";
1284 					goto error;
1285 				}
1286 			}
1287 			src = drawimage(client, a+19);
1288 			if(!dst || !src)
1289 				goto Enodrawimage;
1290 			drawpoint(&sp, a+23);
1291 			drawpoint(&p, a+31);
1292 			ni++;
1293 			pp = mallocz(ni*sizeof(Point), 1);
1294 			if(pp == nil)
1295 				goto Enomem;
1296 			doflush = 0;
1297 			if(dstid==0 || (dst->layer && dst->layer->screen->image->data == screenimage->data))
1298 				doflush = 1;	/* simplify test in loop */
1299 			ox = oy = 0;
1300 			esize = 0;
1301 			u = a+m;
1302 			for(y=0; y<ni; y++){
1303 				q = p;
1304 				oesize = esize;
1305 				u = drawcoord(u, a+n, ox, &p.x);
1306 				if(!u)
1307 					goto Eshortdraw;
1308 				u = drawcoord(u, a+n, oy, &p.y);
1309 				if(!u)
1310 					goto Eshortdraw;
1311 				ox = p.x;
1312 				oy = p.y;
1313 				if(doflush){
1314 					esize = j;
1315 					if(*a == 'p'){
1316 						if(y == 0){
1317 							c = memlineendsize(e0);
1318 							if(c > esize)
1319 								esize = c;
1320 						}
1321 						if(y == ni-1){
1322 							c = memlineendsize(e1);
1323 							if(c > esize)
1324 								esize = c;
1325 						}
1326 					}
1327 					if(*a=='P' && e0!=1 && e0 !=~0)
1328 						r = dst->clipr;
1329 					else if(y > 0){
1330 						r = Rect(q.x-oesize, q.y-oesize, q.x+oesize+1, q.y+oesize+1);
1331 						combinerect(&r, Rect(p.x-esize, p.y-esize, p.x+esize+1, p.y+esize+1));
1332 					}
1333 					if(rectclip(&r, dst->clipr))		/* should perhaps be an arg to dstflush */
1334 						dstflush(dstid, dst, r);
1335 				}
1336 				pp[y] = p;
1337 			}
1338 			if(y == 1)
1339 				dstflush(dstid, dst, Rect(p.x-esize, p.y-esize, p.x+esize+1, p.y+esize+1));
1340 			op = drawclientop(client);
1341 			if(*a == 'p')
1342 				mempoly(dst, pp, ni, e0, e1, j, src, sp, op);
1343 			else
1344 				memfillpoly(dst, pp, ni, e0, src, sp, op);
1345 			free(pp);
1346 			m = u-a;
1347 			continue;
1348 
1349 		/* read: 'r' id[4] R[4*4] */
1350 		case 'r':
1351 			m = 1+4+4*4;
1352 			if(n < m)
1353 				goto Eshortdraw;
1354 			i = drawimage(client, a+1);
1355 			if(!i)
1356 				goto Enodrawimage;
1357 			drawrectangle(&r, a+5);
1358 			if(!rectinrect(r, i->r))
1359 				goto Ereadoutside;
1360 			c = bytesperline(r, i->depth);
1361 			c *= Dy(r);
1362 			free(client->readdata);
1363 			client->readdata = mallocz(c, 0);
1364 			if(client->readdata == nil){
1365 				err = "readimage malloc failed";
1366 				goto error;
1367 			}
1368 			client->nreaddata = memunload(i, r, client->readdata, c);
1369 			if(client->nreaddata < 0){
1370 				free(client->readdata);
1371 				client->readdata = nil;
1372 				err = "bad readimage call";
1373 				goto error;
1374 			}
1375 			continue;
1376 
1377 		/* string: 's' dstid[4] srcid[4] fontid[4] P[2*4] clipr[4*4] sp[2*4] ni[2] ni*(index[2]) */
1378 		/* stringbg: 'x' dstid[4] srcid[4] fontid[4] P[2*4] clipr[4*4] sp[2*4] ni[2] bgid[4] bgpt[2*4] ni*(index[2]) */
1379 		case 's':
1380 		case 'x':
1381 			m = 1+4+4+4+2*4+4*4+2*4+2;
1382 			if(*a == 'x')
1383 				m += 4+2*4;
1384 			if(n < m)
1385 				goto Eshortdraw;
1386 
1387 			dst = drawimage(client, a+1);
1388 			dstid = BGLONG(a+1);
1389 			src = drawimage(client, a+5);
1390 			if(!dst || !src)
1391 				goto Enodrawimage;
1392 			font = drawlookup(client, BGLONG(a+9), 1);
1393 			if(font == 0)
1394 				goto Enodrawimage;
1395 			if(font->nfchar == 0)
1396 				goto Enotfont;
1397 			drawpoint(&p, a+13);
1398 			drawrectangle(&r, a+21);
1399 			drawpoint(&sp, a+37);
1400 			ni = BGSHORT(a+45);
1401 			u = a+m;
1402 			m += ni*2;
1403 			if(n < m)
1404 				goto Eshortdraw;
1405 			clipr = dst->clipr;
1406 			dst->clipr = r;
1407 			op = drawclientop(client);
1408 			if(*a == 'x'){
1409 				/* paint background */
1410 				l = drawimage(client, a+47);
1411 				if(!l)
1412 					goto Enodrawimage;
1413 				drawpoint(&q, a+51);
1414 				r.min.x = p.x;
1415 				r.min.y = p.y-font->ascent;
1416 				r.max.x = p.x;
1417 				r.max.y = r.min.y+Dy(font->image->r);
1418 				j = ni;
1419 				while(--j >= 0){
1420 					ci = BGSHORT(u);
1421 					if(ci<0 || ci>=font->nfchar){
1422 						dst->clipr = clipr;
1423 						goto Eindex;
1424 					}
1425 					r.max.x += font->fchar[ci].width;
1426 					u += 2;
1427 				}
1428 				memdraw(dst, r, l, q, memopaque, ZP, op);
1429 				u -= 2*ni;
1430 			}
1431 			q = p;
1432 			while(--ni >= 0){
1433 				ci = BGSHORT(u);
1434 				if(ci<0 || ci>=font->nfchar){
1435 					dst->clipr = clipr;
1436 					goto Eindex;
1437 				}
1438 				q = drawchar(dst, q, src, &sp, font, ci, op);
1439 				u += 2;
1440 			}
1441 			dst->clipr = clipr;
1442 			p.y -= font->ascent;
1443 			dstflush(dstid, dst, Rect(p.x, p.y, q.x, p.y+Dy(font->image->r)));
1444 			continue;
1445 
1446 		/* use public screen: 'S' id[4] chan[4] */
1447 		case 'S':
1448 			m = 1+4+4;
1449 			if(n < m)
1450 				goto Eshortdraw;
1451 			dstid = BGLONG(a+1);
1452 			if(dstid == 0)
1453 				goto Ebadarg;
1454 			dscrn = drawlookupdscreen(dstid);
1455 			if(dscrn==0 || (dscrn->public==0 && dscrn->owner!=client))
1456 				goto Enodrawscreen;
1457 			if(dscrn->screen->image->chan != BGLONG(a+5)){
1458 				err = "inconsistent chan";
1459 				goto error;
1460 			}
1461 			if(drawinstallscreen(client, dscrn, 0, 0, 0, 0) == 0)
1462 				goto Edrawmem;
1463 			continue;
1464 
1465 		/* top or bottom windows: 't' top[1] nw[2] n*id[4] */
1466 		case 't':
1467 			m = 1+1+2;
1468 			if(n < m)
1469 				goto Eshortdraw;
1470 			nw = BGSHORT(a+2);
1471 			if(nw < 0)
1472 				goto Ebadarg;
1473 			if(nw == 0)
1474 				continue;
1475 			m += nw*4;
1476 			if(n < m)
1477 				goto Eshortdraw;
1478 			lp = mallocz(nw*sizeof(Memimage*), 1);
1479 			if(lp == 0)
1480 				goto Enomem;
1481 			for(j=0; j<nw; j++){
1482 				lp[j] = drawimage(client, a+1+1+2+j*4);
1483 				if(lp[j] == nil){
1484 					free(lp);
1485 					goto Enodrawimage;
1486 				}
1487 			}
1488 			if(lp[0]->layer == 0){
1489 				err = "images are not windows";
1490 				free(lp);
1491 				goto error;
1492 			}
1493 			for(j=1; j<nw; j++)
1494 				if(lp[j]->layer->screen != lp[0]->layer->screen){
1495 					err = "images not on same screen";
1496 					free(lp);
1497 					goto error;
1498 				}
1499 			if(a[1])
1500 				memltofrontn(lp, nw);
1501 			else
1502 				memltorearn(lp, nw);
1503 			if(lp[0]->layer->screen->image->data == screenimage->data)
1504 				for(j=0; j<nw; j++)
1505 					addflush(lp[j]->layer->screenr);
1506 			free(lp);
1507 			ll = drawlookup(client, BGLONG(a+1+1+2), 1);
1508 			drawrefreshscreen(ll, client);
1509 			continue;
1510 
1511 		/* visible: 'v' */
1512 		case 'v':
1513 			m = 1;
1514 			drawflush();
1515 			continue;
1516 
1517 		/* write: 'y' id[4] R[4*4] data[x*1] */
1518 		/* write from compressed data: 'Y' id[4] R[4*4] data[x*1] */
1519 		case 'y':
1520 		case 'Y':
1521 			m = 1+4+4*4;
1522 			if(n < m)
1523 				goto Eshortdraw;
1524 			dstid = BGLONG(a+1);
1525 			dst = drawimage(client, a+1);
1526 			if(!dst)
1527 				goto Enodrawimage;
1528 			drawrectangle(&r, a+5);
1529 			if(!rectinrect(r, dst->r))
1530 				goto Ewriteoutside;
1531 			y = memload(dst, r, a+m, n-m, *a=='Y');
1532 			if(y < 0){
1533 				err = "bad writeimage call";
1534 				goto error;
1535 			}
1536 			dstflush(dstid, dst, r);
1537 			m += y;
1538 			continue;
1539 		}
1540 	}
1541 	qunlock(&sdraw.lk);
1542 	return oldn - n;
1543 
1544 Enodrawimage:
1545 	err = "unknown id for draw image";
1546 	goto error;
1547 Enodrawscreen:
1548 	err = "unknown id for draw screen";
1549 	goto error;
1550 Eshortdraw:
1551 	err = "short draw message";
1552 	goto error;
1553 /*
1554 Eshortread:
1555 	err = "draw read too short";
1556 	goto error;
1557 */
1558 Eimageexists:
1559 	err = "image id in use";
1560 	goto error;
1561 Escreenexists:
1562 	err = "screen id in use";
1563 	goto error;
1564 Edrawmem:
1565 	err = "image memory allocation failed";
1566 	goto error;
1567 Ereadoutside:
1568 	err = "readimage outside image";
1569 	goto error;
1570 Ewriteoutside:
1571 	err = "writeimage outside image";
1572 	goto error;
1573 Enotfont:
1574 	err = "image not a font";
1575 	goto error;
1576 Eindex:
1577 	err = "character index out of range";
1578 	goto error;
1579 /*
1580 Enoclient:
1581 	err = "no such draw client";
1582 	goto error;
1583 Edepth:
1584 	err = "image has bad depth";
1585 	goto error;
1586 Enameused:
1587 	err = "image name in use";
1588 	goto error;
1589 */
1590 Enoname:
1591 	err = "no image with that name";
1592 	goto error;
1593 Eoldname:
1594 	err = "named image no longer valid";
1595 	goto error;
1596 Enamed:
1597 	err = "image already has name";
1598 	goto error;
1599 Ewrongname:
1600 	err = "wrong name for image";
1601 	goto error;
1602 Enomem:
1603 	err = "out of memory";
1604 	goto error;
1605 Ebadarg:
1606 	err = "bad argument in draw message";
1607 	goto error;
1608 
1609 error:
1610 	werrstr("%s", err);
1611 	qunlock(&sdraw.lk);
1612 	return -1;
1613 }
1614 
1615