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