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