ref: 17da0b9dd1e7dc8f6b43eaa55c291a6ecbb00d69
dir: /kern/devdraw.c/
#include "u.h"
#include "lib.h"
#include "dat.h"
#include "fns.h"
#include "error.h"
#define Image IMAGE
#include <draw.h>
#include <memdraw.h>
#include <memlayer.h>
#include <cursor.h>
#include "screen.h"
enum
{
Qtopdir = 0,
Qnew,
Qwinname,
Q3rd,
Q2nd,
Qcolormap,
Qctl,
Qdata,
Qrefresh,
};
/*
* Qid path is:
* 4 bits of file type (qids above)
* 24 bits of mux slot number +1; 0 means not attached to client
*/
#define QSHIFT 4 /* location in qid of client # */
#define QID(q) ((((ulong)(q).path)&0x0000000F)>>0)
#define CLIENTPATH(q) ((((ulong)q)&0x7FFFFFF0)>>QSHIFT)
#define CLIENT(q) CLIENTPATH((q).path)
#define NHASH (1<<5)
#define HASHMASK (NHASH-1)
#define IOUNIT (64*1024)
typedef struct Client Client;
typedef struct Draw Draw;
typedef struct DImage DImage;
typedef struct DScreen DScreen;
typedef struct CScreen CScreen;
typedef struct FChar FChar;
typedef struct Refresh Refresh;
typedef struct Refx Refx;
typedef struct DName DName;
ulong blanktime = 30; /* in minutes; a half hour */
struct Draw
{
int clientid;
int nclient;
Client** client;
int nname;
DName* name;
int vers;
int softscreen;
int blanked; /* screen turned off */
ulong blanktime; /* time of last operation */
};
struct Client
{
Ref r;
DImage* dimage[NHASH];
CScreen* cscreen;
Refresh* refresh;
Rendez refrend;
QLock refq;
uchar* readdata;
int nreaddata;
int busy;
int clientid;
int slot;
int refreshme;
int infoid;
int op;
};
struct Refresh
{
DImage* dimage;
Rectangle r;
Refresh* next;
};
struct Refx
{
Client* client;
DImage* dimage;
};
struct DName
{
char *name;
Client *client;
DImage* dimage;
int vers;
};
struct FChar
{
int minx; /* left edge of bits */
int maxx; /* right edge of bits */
uchar miny; /* first non-zero scan-line */
uchar maxy; /* last non-zero scan-line + 1 */
schar left; /* offset of baseline */
uchar width; /* width of baseline */
};
/*
* Reference counts in DImages:
* one per open by original client
* one per screen image or fill
* one per image derived from this one by name
*/
struct DImage
{
int id;
int ref;
char *name;
int vers;
Memimage* image;
int ascent;
int nfchar;
FChar* fchar;
DScreen* dscreen; /* 0 if not a window */
DImage* fromname; /* image this one is derived from, by name */
DImage* next;
};
struct CScreen
{
DScreen* dscreen;
CScreen* next;
};
struct DScreen
{
int id;
int public;
int ref;
DImage *dimage;
DImage *dfill;
Memscreen* screen;
Client* owner;
DScreen* next;
};
static Draw sdraw;
QLock drawlock;
static Memimage *screenimage;
static DImage* screendimage;
static char screenname[40];
static int screennameid;
static Rectangle flushrect;
static int waste;
static DScreen* dscreen;
extern void flushmemscreen(Rectangle);
void drawmesg(Client*, void*, int);
void drawuninstall(Client*, int);
void drawfreedimage(DImage*);
Client* drawclientofpath(ulong);
DImage* allocdimage(Memimage*);
static char Enodrawimage[] = "unknown id for draw image";
static char Enodrawscreen[] = "unknown id for draw screen";
static char Eshortdraw[] = "short draw message";
static char Eshortread[] = "draw read too short";
static char Eimageexists[] = "image id in use";
static char Escreenexists[] = "screen id in use";
static char Edrawmem[] = "image memory allocation failed";
static char Ereadoutside[] = "readimage outside image";
static char Ewriteoutside[] = "writeimage outside image";
static char Enotfont[] = "image not a font";
static char Eindex[] = "character index out of range";
static char Enoclient[] = "no such draw client";
static char Enameused[] = "image name in use";
static char Enoname[] = "no image with that name";
static char Eoldname[] = "named image no longer valid";
static char Enamed[] = "image already has name";
static char Ewrongname[] = "wrong name for image";
static void
dlock(void)
{
qlock(&drawlock);
}
static void
dunlock(void)
{
qunlock(&drawlock);
}
static int
drawgen(Chan *c, char *n, Dirtab *d, int nd, int s, Dir *dp)
{
int t;
Qid q;
ulong path;
Client *cl;
USED(n);
USED(d);
USED(nd);
q.vers = 0;
if(s == DEVDOTDOT){
switch(QID(c->qid)){
case Qtopdir:
case Q2nd:
mkqid(&q, Qtopdir, 0, QTDIR);
devdir(c, q, "#i", 0, eve, 0500, dp);
break;
case Q3rd:
cl = drawclientofpath(c->qid.path);
if(cl == nil)
strcpy(up->genbuf, "??");
else
sprint(up->genbuf, "%d", cl->clientid);
mkqid(&q, Q2nd, 0, QTDIR);
devdir(c, q, up->genbuf, 0, eve, 0500, dp);
break;
default:
panic("drawwalk %llux", c->qid.path);
}
return 1;
}
/*
* Top level directory contains the name of the device.
*/
t = QID(c->qid);
if(t == Qtopdir || t == Qwinname){
if(s == 1 || t == Qwinname){
mkqid(&q, Qwinname, 0, QTFILE);
devdir(c, q, "winname", 0, eve, 0444, dp);
}
else if(s == 0){
mkqid(&q, Q2nd, 0, QTDIR);
devdir(c, q, "draw", 0, eve, 0555, dp);
}
else
return -1;
return 1;
}
/*
* Second level contains "new" plus all the clients.
*/
if(t == Q2nd || t == Qnew){
if(s == 0){
mkqid(&q, Qnew, 0, QTFILE);
devdir(c, q, "new", 0, eve, 0666, dp);
}
else if(s <= sdraw.nclient){
cl = sdraw.client[s-1];
if(cl == 0)
return 0;
sprint(up->genbuf, "%d", cl->clientid);
mkqid(&q, (s<<QSHIFT)|Q3rd, 0, QTDIR);
devdir(c, q, up->genbuf, 0, eve, 0555, dp);
return 1;
}
else
return -1;
return 1;
}
/*
* Third level.
*/
path = c->qid.path&~((1<<QSHIFT)-1); /* slot component */
q.vers = c->qid.vers;
q.type = QTFILE;
switch(s){
case 0:
q.path = path|Qcolormap;
devdir(c, q, "colormap", 0, eve, 0600, dp);
break;
case 1:
q.path = path|Qctl;
devdir(c, q, "ctl", 0, eve, 0600, dp);
break;
case 2:
q.path = path|Qdata;
devdir(c, q, "data", 0, eve, 0600, dp);
break;
case 3:
q.path = path|Qrefresh;
devdir(c, q, "refresh", 0, eve, 0400, dp);
break;
default:
return -1;
}
return 1;
}
static
int
drawrefactive(void *a)
{
Client *c;
c = a;
return c->refreshme || c->refresh!=0;
}
static
void
drawrefreshscreen(DImage *l, Client *client)
{
while(l != nil && l->dscreen == nil)
l = l->fromname;
if(l != nil && l->dscreen->owner != client)
l->dscreen->owner->refreshme = 1;
}
static
void
drawrefresh(Memimage *i, Rectangle r, void *v)
{
Refx *x;
DImage *d;
Client *c;
Refresh *ref;
USED(i);
if(v == 0)
return;
x = v;
c = x->client;
d = x->dimage;
for(ref=c->refresh; ref; ref=ref->next)
if(ref->dimage == d){
combinerect(&ref->r, r);
return;
}
ref = malloc(sizeof(Refresh));
if(ref){
ref->dimage = d;
ref->r = r;
ref->next = c->refresh;
c->refresh = ref;
}
}
static void
addflush(Rectangle r)
{
int abb, ar, anbb;
Rectangle nbb;
if(sdraw.softscreen==0 || screenimage == nil || !rectclip(&r, screenimage->r))
return;
if(flushrect.min.x >= flushrect.max.x){
flushrect = r;
waste = 0;
return;
}
nbb = flushrect;
combinerect(&nbb, r);
ar = Dx(r)*Dy(r);
abb = Dx(flushrect)*Dy(flushrect);
anbb = Dx(nbb)*Dy(nbb);
/*
* Area of new waste is area of new bb minus area of old bb,
* less the area of the new segment, which we assume is not waste.
* This could be negative, but that's OK.
*/
waste += anbb-abb - ar;
if(waste < 0)
waste = 0;
/*
* absorb if:
* total area is small
* waste is less than half total area
* rectangles touch
*/
if(anbb<=1024 || waste*2<anbb || rectXrect(flushrect, r)){
flushrect = nbb;
return;
}
/* emit current state */
if(flushrect.min.x < flushrect.max.x)
flushmemscreen(flushrect);
flushrect = r;
waste = 0;
}
static
void
dstflush(int dstid, Memimage *dst, Rectangle r)
{
Memlayer *l;
if(dstid == 0){
combinerect(&flushrect, r);
return;
}
if(screenimage == nil || dst == nil || (l = dst->layer) == nil)
return;
do{
if(l->screen->image->data != screenimage->data)
return;
r = rectaddpt(r, l->delta);
l = l->screen->image->layer;
}while(l);
addflush(r);
}
void
drawflush(void)
{
if(screenimage && flushrect.min.x < flushrect.max.x)
flushmemscreen(flushrect);
flushrect = Rect(10000, 10000, -10000, -10000);
}
int
drawcmp(char *a, char *b, int n)
{
if(strlen(a) != n)
return 1;
return memcmp(a, b, n);
}
DName*
drawlookupname(int n, char *str)
{
DName *name, *ename;
name = sdraw.name;
ename = &name[sdraw.nname];
for(; name<ename; name++)
if(drawcmp(name->name, str, n) == 0)
return name;
return 0;
}
int
drawgoodname(DImage *d)
{
DName *n;
/* if window, validate the screen's own images */
if(d->dscreen)
if(drawgoodname(d->dscreen->dimage) == 0
|| drawgoodname(d->dscreen->dfill) == 0)
return 0;
if(d->name == nil)
return 1;
n = drawlookupname(strlen(d->name), d->name);
if(n==nil || n->vers!=d->vers)
return 0;
return 1;
}
DImage*
drawlookup(Client *client, int id, int checkname)
{
DImage *d;
d = client->dimage[id&HASHMASK];
while(d){
if(d->id == id){
if(checkname && !drawgoodname(d))
error(Eoldname);
return d;
}
d = d->next;
}
return 0;
}
DScreen*
drawlookupdscreen(int id)
{
DScreen *s;
s = dscreen;
while(s){
if(s->id == id)
return s;
s = s->next;
}
return 0;
}
DScreen*
drawlookupscreen(Client *client, int id, CScreen **cs)
{
CScreen *s;
s = client->cscreen;
while(s){
if(s->dscreen->id == id){
*cs = s;
return s->dscreen;
}
s = s->next;
}
error(Enodrawscreen);
return 0;
}
DImage*
allocdimage(Memimage *i)
{
DImage *d;
d = malloc(sizeof(DImage));
if(d == 0)
return 0;
d->ref = 1;
d->name = 0;
d->vers = 0;
d->image = i;
d->nfchar = 0;
d->fchar = 0;
d->fromname = 0;
return d;
}
Memimage*
drawinstall(Client *client, int id, Memimage *i, DScreen *dscreen)
{
DImage *d;
d = allocdimage(i);
if(d == 0)
return 0;
d->id = id;
d->dscreen = dscreen;
d->next = client->dimage[id&HASHMASK];
client->dimage[id&HASHMASK] = d;
return i;
}
Memscreen*
drawinstallscreen(Client *client, DScreen *d, int id, DImage *dimage, DImage *dfill, int public)
{
Memscreen *s;
CScreen *c;
c = malloc(sizeof(CScreen));
if(dimage && dimage->image && dimage->image->chan == 0)
panic("bad image %p in drawinstallscreen", dimage->image);
if(c == 0)
return 0;
if(d == 0){
d = malloc(sizeof(DScreen));
if(d == 0){
free(c);
return 0;
}
s = malloc(sizeof(Memscreen));
if(s == 0){
free(c);
free(d);
return 0;
}
s->frontmost = 0;
s->rearmost = 0;
d->dimage = dimage;
if(dimage){
s->image = dimage->image;
dimage->ref++;
}
d->dfill = dfill;
if(dfill){
s->fill = dfill->image;
dfill->ref++;
}
d->ref = 0;
d->id = id;
d->screen = s;
d->public = public;
d->next = dscreen;
d->owner = client;
dscreen = d;
}
c->dscreen = d;
d->ref++;
c->next = client->cscreen;
client->cscreen = c;
return d->screen;
}
void
drawdelname(DName *name)
{
int i;
free(name->name);
i = name-sdraw.name;
memmove(name, name+1, (sdraw.nname-(i+1))*sizeof(DName));
sdraw.nname--;
}
void
drawfreedscreen(DScreen *this)
{
DScreen *ds, *next;
this->ref--;
if(this->ref < 0)
print("negative ref in drawfreedscreen\n");
if(this->ref > 0)
return;
ds = dscreen;
if(ds == this){
dscreen = this->next;
goto Found;
}
while(next = ds->next){ /* assign = */
if(next == this){
ds->next = this->next;
goto Found;
}
ds = next;
}
error(Enodrawimage);
Found:
if(this->dimage)
drawfreedimage(this->dimage);
if(this->dfill)
drawfreedimage(this->dfill);
free(this->screen);
free(this);
}
void
drawfreedimage(DImage *dimage)
{
int i;
Memimage *l;
DScreen *ds;
dimage->ref--;
if(dimage->ref < 0)
print("negative ref in drawfreedimage\n");
if(dimage->ref > 0)
return;
/* any names? */
for(i=0; i<sdraw.nname; )
if(sdraw.name[i].dimage == dimage)
drawdelname(sdraw.name+i);
else
i++;
if(dimage->fromname){ /* acquired by name; owned by someone else*/
drawfreedimage(dimage->fromname);
goto Return;
}
ds = dimage->dscreen;
if(ds){
l = dimage->image;
if(screenimage && l->data == screenimage->data)
addflush(l->layer->screenr);
if(l->layer->refreshfn == drawrefresh) /* else true owner will clean up */
free(l->layer->refreshptr);
l->layer->refreshptr = nil;
if(drawgoodname(dimage))
memldelete(l);
else
memlfree(l);
drawfreedscreen(ds);
}else
freememimage(dimage->image);
Return:
free(dimage->fchar);
free(dimage);
}
void
drawuninstallscreen(Client *client, CScreen *this)
{
CScreen *cs, *next;
cs = client->cscreen;
if(cs == this){
client->cscreen = this->next;
drawfreedscreen(this->dscreen);
free(this);
return;
}
while(next = cs->next){ /* assign = */
if(next == this){
cs->next = this->next;
drawfreedscreen(this->dscreen);
free(this);
return;
}
cs = next;
}
}
void
drawuninstall(Client *client, int id)
{
DImage *d, *next;
d = client->dimage[id&HASHMASK];
if(d == 0)
error(Enodrawimage);
if(d->id == id){
client->dimage[id&HASHMASK] = d->next;
drawfreedimage(d);
return;
}
while(next = d->next){ /* assign = */
if(next->id == id){
d->next = next->next;
drawfreedimage(next);
return;
}
d = next;
}
error(Enodrawimage);
}
void
drawaddname(Client *client, DImage *di, int n, char *str)
{
DName *name, *ename, *new, *t;
name = sdraw.name;
ename = &name[sdraw.nname];
for(; name<ename; name++)
if(drawcmp(name->name, str, n) == 0)
error(Enameused);
t = smalloc((sdraw.nname+1)*sizeof(DName));
memmove(t, sdraw.name, sdraw.nname*sizeof(DName));
free(sdraw.name);
sdraw.name = t;
new = &sdraw.name[sdraw.nname++];
new->name = smalloc(n+1);
memmove(new->name, str, n);
new->name[n] = 0;
new->dimage = di;
new->client = client;
new->vers = ++sdraw.vers;
}
Client*
drawnewclient(void)
{
Client *cl, **cp;
int i;
for(i=0; i<sdraw.nclient; i++){
cl = sdraw.client[i];
if(cl == 0)
break;
}
if(i == sdraw.nclient){
cp = malloc((sdraw.nclient+1)*sizeof(Client*));
if(cp == 0)
return 0;
memmove(cp, sdraw.client, sdraw.nclient*sizeof(Client*));
free(sdraw.client);
sdraw.client = cp;
sdraw.nclient++;
cp[i] = 0;
}
cl = malloc(sizeof(Client));
if(cl == 0)
return 0;
memset(cl, 0, sizeof(Client));
cl->slot = i;
cl->clientid = ++sdraw.clientid;
cl->op = SoverD;
sdraw.client[i] = cl;
return cl;
}
static int
drawclientop(Client *cl)
{
int op;
op = cl->op;
cl->op = SoverD;
return op;
}
int
drawhasclients(void)
{
/*
* if draw has ever been used, we can't resize the frame buffer,
* even if all clients have exited (nclients is cumulative); it's too
* hard to make work.
*/
return sdraw.nclient != 0;
}
Client*
drawclientofpath(ulong path)
{
Client *cl;
int slot;
slot = CLIENTPATH(path);
if(slot == 0)
return nil;
cl = sdraw.client[slot-1];
if(cl==0 || cl->clientid==0)
return nil;
return cl;
}
Client*
drawclient(Chan *c)
{
Client *client;
client = drawclientofpath(c->qid.path);
if(client == nil)
error(Enoclient);
return client;
}
Memimage*
drawimage(Client *client, uchar *a)
{
DImage *d;
d = drawlookup(client, BGLONG(a), 1);
if(d == nil)
error(Enodrawimage);
return d->image;
}
void
drawrectangle(Rectangle *r, uchar *a)
{
r->min.x = BGLONG(a+0*4);
r->min.y = BGLONG(a+1*4);
r->max.x = BGLONG(a+2*4);
r->max.y = BGLONG(a+3*4);
}
void
drawpoint(Point *p, uchar *a)
{
p->x = BGLONG(a+0*4);
p->y = BGLONG(a+1*4);
}
Point
drawchar(Memimage *dst, Memimage *rdst, Point p, Memimage *src, Point *sp, DImage *font, int index, int op)
{
FChar *fc;
Rectangle r;
Point sp1;
static Memimage *tmp;
fc = &font->fchar[index];
r.min.x = p.x+fc->left;
r.min.y = p.y-(font->ascent-fc->miny);
r.max.x = r.min.x+(fc->maxx-fc->minx);
r.max.y = r.min.y+(fc->maxy-fc->miny);
sp1.x = sp->x+fc->left;
sp1.y = sp->y+fc->miny;
/*
* If we're drawing greyscale fonts onto a VGA screen,
* it's very costly to read the screen memory to do the
* alpha blending inside memdraw. If this is really a stringbg,
* then rdst is the bg image (in main memory) which we can
* refer to for the underlying dst pixels instead of reading dst
* directly.
*/
if(ishwimage(dst) && !ishwimage(rdst) && font->image->depth > 1){
if(tmp == nil || tmp->chan != dst->chan || Dx(tmp->r) < Dx(r) || Dy(tmp->r) < Dy(r)){
if(tmp)
freememimage(tmp);
tmp = allocmemimage(Rect(0,0,Dx(r),Dy(r)), dst->chan);
if(tmp == nil)
goto fallback;
}
memdraw(tmp, Rect(0,0,Dx(r),Dy(r)), rdst, r.min, memopaque, ZP, S);
memdraw(tmp, Rect(0,0,Dx(r),Dy(r)), src, sp1, font->image, Pt(fc->minx, fc->miny), op);
memdraw(dst, r, tmp, ZP, memopaque, ZP, S);
}else{
fallback:
memdraw(dst, r, src, sp1, font->image, Pt(fc->minx, fc->miny), op);
}
p.x += fc->width;
sp->x += fc->width;
return p;
}
static DImage*
makescreenimage(void)
{
int width, depth;
ulong chan;
DImage *di;
Memdata *md;
Memimage *i;
Rectangle r;
uchar *data;
if((data = attachscreen(&r, &chan, &depth, &width, &sdraw.softscreen)) == nil)
return nil;
if(sdraw.softscreen == 0xa110c){
/* hack: softscreen is memimage. */
md = *((Memdata**)(data - sizeof(ulong) - sizeof(Memdata*)));
assert(md->bdata == data);
assert(md->ref > 1);
assert(md->allocd);
if((i = allocmemimaged(r, chan, md)) == nil){
md->ref--;
return nil;
}
}else{
if((md = malloc(sizeof *md)) == nil)
return nil;
md->allocd = 1;
md->base = nil;
md->bdata = data;
md->ref = 1;
if((i = allocmemimaged(r, chan, md)) == nil){
free(md);
return nil;
}
}
i->width = width;
i->clipr = r;
di = allocdimage(i);
if(di == nil){
freememimage(i); /* frees md */
return nil;
}
if(!waserror()){
snprint(screenname, sizeof screenname, "noborder.screen.%d", ++screennameid);
drawaddname(nil, di, strlen(screenname), screenname);
poperror();
}
return di;
}
static int
initscreenimage(void)
{
if(screenimage != nil)
return 1;
screendimage = makescreenimage();
if(screendimage == nil)
return 0;
screenimage = screendimage->image;
// iprint("initscreenimage %p %p\n", screendimage, screenimage);
return 1;
}
void
deletescreenimage(void)
{
dlock();
if(screenimage){
/* will be freed via screendimage; disable */
screenimage->clipr = ZR;
screenimage = nil;
}
if(screendimage){
drawfreedimage(screendimage);
screendimage = nil;
}
dunlock();
}
void
resetscreenimage(void)
{
dlock();
initscreenimage();
dunlock();
}
static Chan*
drawattach(char *spec)
{
if(gscreen == nil)
screeninit();
dlock();
if(!initscreenimage()){
dunlock();
error("no frame buffer");
}
dunlock();
return devattach('i', spec);
}
static Walkqid*
drawwalk(Chan *c, Chan *nc, char **name, int nname)
{
if(screenimage == nil)
error("no frame buffer");
return devwalk(c, nc, name, nname, 0, 0, drawgen);
}
static int
drawstat(Chan *c, uchar *db, int n)
{
return devstat(c, db, n, 0, 0, drawgen);
}
static Chan*
drawopen(Chan *c, int omode)
{
Client *cl;
DName *dn;
DImage *di;
if(c->qid.type & QTDIR){
c = devopen(c, omode, 0, 0, drawgen);
c->iounit = IOUNIT;
}
dlock();
if(waserror()){
dunlock();
nexterror();
}
if(QID(c->qid) == Qnew){
cl = drawnewclient();
if(cl == 0)
error(Enodev);
c->qid.path = Qctl|((cl->slot+1)<<QSHIFT);
}
switch(QID(c->qid)){
case Qwinname:
break;
case Qnew:
break;
case Qctl:
cl = drawclient(c);
if(cl->busy)
error(Einuse);
cl->busy = 1;
flushrect = Rect(10000, 10000, -10000, -10000);
dn = drawlookupname(strlen(screenname), screenname);
if(dn == 0)
error("draw: cannot happen 2");
if(drawinstall(cl, 0, dn->dimage->image, 0) == 0)
error(Edrawmem);
di = drawlookup(cl, 0, 0);
if(di == 0)
error("draw: cannot happen 1");
di->vers = dn->vers;
di->name = smalloc(strlen(screenname)+1);
strcpy(di->name, screenname);
di->fromname = dn->dimage;
di->fromname->ref++;
incref(&cl->r);
break;
case Qcolormap:
case Qdata:
case Qrefresh:
cl = drawclient(c);
incref(&cl->r);
break;
}
dunlock();
poperror();
c->mode = openmode(omode);
c->flag |= COPEN;
c->offset = 0;
c->iounit = IOUNIT;
return c;
}
static void
drawclose(Chan *c)
{
int i;
DImage *d, **dp;
Client *cl;
Refresh *r;
if(QID(c->qid) < Qcolormap) /* Qtopdir, Qnew, Q3rd, Q2nd have no client */
return;
dlock();
if(waserror()){
dunlock();
nexterror();
}
cl = drawclient(c);
if(QID(c->qid) == Qctl)
cl->busy = 0;
if((c->flag&COPEN) && (decref(&cl->r)==0)){
while(r = cl->refresh){ /* assign = */
cl->refresh = r->next;
free(r);
}
/* free names */
for(i=0; i<sdraw.nname; )
if(sdraw.name[i].client == cl)
drawdelname(sdraw.name+i);
else
i++;
while(cl->cscreen)
drawuninstallscreen(cl, cl->cscreen);
/* all screens are freed, so now we can free images */
dp = cl->dimage;
for(i=0; i<NHASH; i++){
while((d = *dp) != nil){
*dp = d->next;
drawfreedimage(d);
}
dp++;
}
sdraw.client[cl->slot] = 0;
drawflush(); /* to erase visible, now dead windows */
free(cl);
}
dunlock();
poperror();
}
long
drawread(Chan *c, void *a, long n, vlong off)
{
int index, m;
ulong red, green, blue;
Client *cl;
uchar *p;
Refresh *r;
DImage *di;
Memimage *i;
ulong offset = off;
char buf[16];
if(c->qid.type & QTDIR)
return devdirread(c, a, n, 0, 0, drawgen);
if(QID(c->qid) == Qwinname)
return readstr(off, a, n, screenname);
cl = drawclient(c);
dlock();
if(waserror()){
dunlock();
nexterror();
}
switch(QID(c->qid)){
case Qctl:
if(n < 12*12)
error(Eshortread);
if(cl->infoid < 0)
error(Enodrawimage);
if(cl->infoid == 0){
i = screenimage;
if(i == nil)
error(Enodrawimage);
}else{
di = drawlookup(cl, cl->infoid, 1);
if(di == nil)
error(Enodrawimage);
i = di->image;
}
n = sprint(a, "%11d %11d %11s %11d %11d %11d %11d %11d %11d %11d %11d %11d",
cl->clientid, cl->infoid, chantostr(buf, i->chan), (i->flags&Frepl)==Frepl,
i->r.min.x, i->r.min.y, i->r.max.x, i->r.max.y,
i->clipr.min.x, i->clipr.min.y, i->clipr.max.x, i->clipr.max.y);
((char*)a)[n++] = ' ';
cl->infoid = -1;
break;
case Qcolormap:
p = malloc(4*12*256+1);
if(p == 0)
error(Enomem);
m = 0;
for(index = 0; index < 256; index++){
getcolor(index, &red, &green, &blue);
m += sprint((char*)p+m, "%11d %11lud %11lud %11lud\n", index, red>>24, green>>24, blue>>24);
}
n = readstr(offset, a, n, (char*)p);
free(p);
break;
case Qdata:
if(cl->readdata == nil)
error("no draw data");
if(n < cl->nreaddata)
error(Eshortread);
n = cl->nreaddata;
memmove(a, cl->readdata, cl->nreaddata);
free(cl->readdata);
cl->readdata = nil;
break;
case Qrefresh:
if(n < 5*4)
error(Ebadarg);
for(;;){
if(cl->refreshme || cl->refresh)
break;
dunlock();
if(waserror()){
dlock();
nexterror();
}
qlock(&cl->refq);
if(waserror()){
qunlock(&cl->refq);
nexterror();
}
sleep(&cl->refrend, drawrefactive, cl);
poperror();
qunlock(&cl->refq);
poperror();
dlock();
}
p = a;
while(cl->refresh && n>=5*4){
r = cl->refresh;
BPLONG(p+0*4, r->dimage->id);
BPLONG(p+1*4, r->r.min.x);
BPLONG(p+2*4, r->r.min.y);
BPLONG(p+3*4, r->r.max.x);
BPLONG(p+4*4, r->r.max.y);
cl->refresh = r->next;
free(r);
p += 5*4;
n -= 5*4;
}
cl->refreshme = 0;
n = p-(uchar*)a;
break;
}
dunlock();
poperror();
return n;
}
void
drawwakeall(void)
{
Client *cl;
int i;
for(i=0; i<sdraw.nclient; i++){
cl = sdraw.client[i];
if(cl && (cl->refreshme || cl->refresh))
wakeup(&cl->refrend);
}
}
static long
drawwrite(Chan *c, void *a, long n, vlong off)
{
char buf[128], *fields[4], *q;
Client *cl;
int i, m, red, green, blue, x;
USED(off);
if(c->qid.type & QTDIR)
error(Eisdir);
cl = drawclient(c);
dlock();
if(waserror()){
drawwakeall();
dunlock();
nexterror();
}
switch(QID(c->qid)){
case Qctl:
if(n != 4)
error("unknown draw control request");
cl->infoid = BGLONG((uchar*)a);
break;
case Qcolormap:
m = n;
n = 0;
while(m > 0){
x = m;
if(x > sizeof(buf)-1)
x = sizeof(buf)-1;
q = memccpy(buf, a, '\n', x);
if(q == 0)
break;
i = q-buf;
n += i;
a = (char*)a + i;
m -= i;
*q = 0;
if(tokenize(buf, fields, nelem(fields)) != 4)
error(Ebadarg);
i = strtoul(fields[0], 0, 0);
red = strtoul(fields[1], 0, 0);
green = strtoul(fields[2], 0, 0);
blue = strtoul(fields[3], &q, 0);
if(fields[3] == q)
error(Ebadarg);
if(red>255 || green>255 || blue>255 || i<0 || i>255)
error(Ebadarg);
red |= red<<8;
red |= red<<16;
green |= green<<8;
green |= green<<16;
blue |= blue<<8;
blue |= blue<<16;
setcolor(i, red, green, blue);
}
break;
case Qdata:
drawmesg(cl, a, n);
drawwakeall();
break;
default:
error(Ebadusefd);
}
dunlock();
poperror();
return n;
}
uchar*
drawcoord(uchar *p, uchar *maxp, int oldx, int *newx)
{
int b, x;
if(p >= maxp)
error(Eshortdraw);
b = *p++;
x = b & 0x7F;
if(b & 0x80){
if(p+1 >= maxp)
error(Eshortdraw);
x |= *p++ << 7;
x |= *p++ << 15;
if(x & (1<<22))
x |= ~0<<23;
}else{
if(b & 0x40)
x |= ~0<<7;
x += oldx;
}
*newx = x;
return p;
}
static void
printmesg(char *fmt, uchar *a, int plsprnt)
{
char buf[256];
char *p, *q;
int s;
if(1|| plsprnt==0){
USED(s);
return;
}
q = buf;
*q++ = *a++;
for(p=fmt; *p; p++){
switch(*p){
case 'l':
q += sprint(q, " %ld", (long)BGLONG(a));
a += 4;
break;
case 'L':
q += sprint(q, " %.8lux", (ulong)BGLONG(a));
a += 4;
break;
case 'R':
q += sprint(q, " [%d %d %d %d]", BGLONG(a), BGLONG(a+4), BGLONG(a+8), BGLONG(a+12));
a += 16;
break;
case 'P':
q += sprint(q, " [%d %d]", BGLONG(a), BGLONG(a+4));
a += 8;
break;
case 'b':
q += sprint(q, " %d", *a++);
break;
case 's':
q += sprint(q, " %d", BGSHORT(a));
a += 2;
break;
case 'S':
q += sprint(q, " %.4ux", BGSHORT(a));
a += 2;
break;
}
}
*q++ = '\n';
*q = 0;
iprint("%.*s", (int)(q-buf), buf);
}
void
drawmesg(Client *client, void *av, int n)
{
int c, repl, m, y, dstid, scrnid, ni, ci, j, nw, e0, e1, op, ox, oy, oesize, esize, doflush;
uchar *u, *a, refresh;
char *fmt;
ulong value, chan;
Rectangle r, clipr;
Point p, q, *pp, sp;
Memimage *i, *bg, *dst, *src, *mask;
Memimage *l, **lp;
Memscreen *scrn;
DImage *font, *ll, *di, *ddst, *dsrc;
DName *dn;
DScreen *dscrn;
FChar *fc;
Refx *refx;
CScreen *cs;
Refreshfn reffn;
a = av;
m = 0;
fmt = nil;
if(waserror()){
if(fmt) printmesg(fmt, a, 1);
/* iprint("error: %s\n", up->errstr); */
nexterror();
}
while((n-=m) > 0){
USED(fmt);
a += m;
switch(*a){
default:
error("bad draw command");
/* new allocate: 'b' id[4] screenid[4] refresh[1] chan[4] repl[1] R[4*4] clipR[4*4] rrggbbaa[4] */
case 'b':
printmesg(fmt="LLbLbRRL", a, 0);
m = 1+4+4+1+4+1+4*4+4*4+4;
if(n < m)
error(Eshortdraw);
dstid = BGLONG(a+1);
scrnid = BGLONG(a+5);
refresh = a[9];
chan = BGLONG(a+10);
repl = a[14];
drawrectangle(&r, a+15);
drawrectangle(&clipr, a+31);
value = BGLONG(a+47);
if(drawlookup(client, dstid, 0))
error(Eimageexists);
if(scrnid){
dscrn = drawlookupscreen(client, scrnid, &cs);
scrn = dscrn->screen;
if(repl || chan!=scrn->image->chan)
error("image parameters incompatible with screen");
reffn = nil;
switch(refresh){
case Refbackup:
break;
case Refnone:
reffn = memlnorefresh;
break;
case Refmesg:
reffn = drawrefresh;
break;
default:
error("unknown refresh method");
}
l = memlalloc(scrn, r, reffn, 0, value);
if(l == 0)
error(Edrawmem);
addflush(l->layer->screenr);
l->clipr = clipr;
rectclip(&l->clipr, r);
if(drawinstall(client, dstid, l, dscrn) == 0){
memldelete(l);
error(Edrawmem);
}
dscrn->ref++;
if(reffn){
refx = nil;
if(reffn == drawrefresh){
refx = malloc(sizeof(Refx));
if(refx == 0){
drawuninstall(client, dstid);
error(Edrawmem);
}
refx->client = client;
refx->dimage = drawlookup(client, dstid, 1);
}
memlsetrefresh(l, reffn, refx);
}
continue;
}
i = allocmemimage(r, chan);
if(i == 0)
error(Edrawmem);
if(repl)
i->flags |= Frepl;
i->clipr = clipr;
if(!repl)
rectclip(&i->clipr, r);
if(drawinstall(client, dstid, i, 0) == 0){
freememimage(i);
error(Edrawmem);
}
memfillcolor(i, value);
continue;
/* allocate screen: 'A' id[4] imageid[4] fillid[4] public[1] */
case 'A':
printmesg(fmt="LLLb", a, 1);
m = 1+4+4+4+1;
if(n < m)
error(Eshortdraw);
dstid = BGLONG(a+1);
if(dstid == 0)
error(Ebadarg);
if(drawlookupdscreen(dstid))
error(Escreenexists);
ddst = drawlookup(client, BGLONG(a+5), 1);
dsrc = drawlookup(client, BGLONG(a+9), 1);
if(ddst==0 || dsrc==0)
error(Enodrawimage);
if(drawinstallscreen(client, 0, dstid, ddst, dsrc, a[13]) == 0)
error(Edrawmem);
continue;
/* set repl and clip: 'c' dstid[4] repl[1] clipR[4*4] */
case 'c':
printmesg(fmt="LbR", a, 0);
m = 1+4+1+4*4;
if(n < m)
error(Eshortdraw);
ddst = drawlookup(client, BGLONG(a+1), 1);
if(ddst == nil)
error(Enodrawimage);
if(ddst->name)
error("cannot change repl/clipr of shared image");
dst = ddst->image;
if(a[5])
dst->flags |= Frepl;
drawrectangle(&dst->clipr, a+6);
continue;
/* draw: 'd' dstid[4] srcid[4] maskid[4] R[4*4] P[2*4] P[2*4] */
case 'd':
printmesg(fmt="LLLRPP", a, 0);
m = 1+4+4+4+4*4+2*4+2*4;
if(n < m)
error(Eshortdraw);
dst = drawimage(client, a+1);
dstid = BGLONG(a+1);
src = drawimage(client, a+5);
mask = drawimage(client, a+9);
drawrectangle(&r, a+13);
drawpoint(&p, a+29);
drawpoint(&q, a+37);
op = drawclientop(client);
memdraw(dst, r, src, p, mask, q, op);
dstflush(dstid, dst, r);
continue;
/* toggle debugging: 'D' val[1] */
case 'D':
printmesg(fmt="b", a, 0);
m = 1+1;
if(n < m)
error(Eshortdraw);
drawdebug = a[1];
continue;
/* ellipse: 'e' dstid[4] srcid[4] center[2*4] a[4] b[4] thick[4] sp[2*4] alpha[4] phi[4]*/
case 'e':
case 'E':
printmesg(fmt="LLPlllPll", a, 0);
m = 1+4+4+2*4+4+4+4+2*4+2*4;
if(n < m)
error(Eshortdraw);
dst = drawimage(client, a+1);
dstid = BGLONG(a+1);
src = drawimage(client, a+5);
drawpoint(&p, a+9);
e0 = BGLONG(a+17);
e1 = BGLONG(a+21);
if(e0<0 || e1<0)
error("invalid ellipse semidiameter");
j = BGLONG(a+25);
if(j < 0)
error("negative ellipse thickness");
drawpoint(&sp, a+29);
c = j;
if(*a == 'E')
c = -1;
ox = BGLONG(a+37);
oy = BGLONG(a+41);
op = drawclientop(client);
/* high bit indicates arc angles are present */
if(ox & (1<<31)){
if((ox & (1<<30)) == 0)
ox &= ~(1<<31);
memarc(dst, p, e0, e1, c, src, sp, ox, oy, op);
}else
memellipse(dst, p, e0, e1, c, src, sp, op);
dstflush(dstid, dst, Rect(p.x-e0-j, p.y-e1-j, p.x+e0+j+1, p.y+e1+j+1));
continue;
/* free: 'f' id[4] */
case 'f':
printmesg(fmt="L", a, 1);
m = 1+4;
if(n < m)
error(Eshortdraw);
ll = drawlookup(client, BGLONG(a+1), 0);
if(ll && ll->dscreen && ll->dscreen->owner != client)
ll->dscreen->owner->refreshme = 1;
drawuninstall(client, BGLONG(a+1));
continue;
/* free screen: 'F' id[4] */
case 'F':
printmesg(fmt="L", a, 1);
m = 1+4;
if(n < m)
error(Eshortdraw);
drawlookupscreen(client, BGLONG(a+1), &cs);
drawuninstallscreen(client, cs);
continue;
/* initialize font: 'i' fontid[4] nchars[4] ascent[1] */
case 'i':
printmesg(fmt="Llb", a, 1);
m = 1+4+4+1;
if(n < m)
error(Eshortdraw);
dstid = BGLONG(a+1);
if(dstid == 0)
error("cannot use display as font");
font = drawlookup(client, dstid, 1);
if(font == 0)
error(Enodrawimage);
if(font->image->layer)
error("cannot use window as font");
ni = BGLONG(a+5);
if(ni<=0 || ni>4096)
error("bad font size (4096 chars max)");
free(font->fchar); /* should we complain if non-zero? */
font->fchar = malloc(ni*sizeof(FChar));
if(font->fchar == 0)
error("no memory for font");
memset(font->fchar, 0, ni*sizeof(FChar));
font->nfchar = ni;
font->ascent = a[9];
continue;
/* load character: 'l' fontid[4] srcid[4] index[2] R[4*4] P[2*4] left[1] width[1] */
case 'l':
printmesg(fmt="LLSRPbb", a, 0);
m = 1+4+4+2+4*4+2*4+1+1;
if(n < m)
error(Eshortdraw);
font = drawlookup(client, BGLONG(a+1), 1);
if(font == 0)
error(Enodrawimage);
if(font->nfchar == 0)
error(Enotfont);
src = drawimage(client, a+5);
ci = BGSHORT(a+9);
if(ci >= font->nfchar)
error(Eindex);
drawrectangle(&r, a+11);
drawpoint(&p, a+27);
memdraw(font->image, r, src, p, memopaque, p, S);
fc = &font->fchar[ci];
fc->minx = r.min.x;
fc->maxx = r.max.x;
fc->miny = r.min.y;
fc->maxy = r.max.y;
fc->left = a[35];
fc->width = a[36];
continue;
/* draw line: 'L' dstid[4] p0[2*4] p1[2*4] end0[4] end1[4] radius[4] srcid[4] sp[2*4] */
case 'L':
printmesg(fmt="LPPlllLP", a, 0);
m = 1+4+2*4+2*4+4+4+4+4+2*4;
if(n < m)
error(Eshortdraw);
dst = drawimage(client, a+1);
dstid = BGLONG(a+1);
drawpoint(&p, a+5);
drawpoint(&q, a+13);
e0 = BGLONG(a+21);
e1 = BGLONG(a+25);
j = BGLONG(a+29);
if(j < 0)
error("negative line width");
src = drawimage(client, a+33);
drawpoint(&sp, a+37);
op = drawclientop(client);
memline(dst, p, q, e0, e1, j, src, sp, op);
/* avoid memlinebbox if possible */
if(dstid==0 || dst->layer!=nil){
/* BUG: this is terribly inefficient: update maximal containing rect*/
r = memlinebbox(p, q, e0, e1, j);
dstflush(dstid, dst, insetrect(r, -(1+1+j)));
}
continue;
/* create image mask: 'm' newid[4] id[4] */
/*
*
case 'm':
printmesg("LL", a, 0);
m = 4+4;
if(n < m)
error(Eshortdraw);
break;
*
*/
/* attach to a named image: 'n' dstid[4] j[1] name[j] */
case 'n':
printmesg(fmt="Lz", a, 0);
m = 1+4+1;
if(n < m)
error(Eshortdraw);
j = a[5];
if(j == 0) /* give me a non-empty name please */
error(Eshortdraw);
m += j;
if(n < m)
error(Eshortdraw);
dstid = BGLONG(a+1);
if(drawlookup(client, dstid, 0))
error(Eimageexists);
dn = drawlookupname(j, (char*)a+6);
if(dn == nil)
error(Enoname);
if(drawinstall(client, dstid, dn->dimage->image, 0) == 0)
error(Edrawmem);
di = drawlookup(client, dstid, 0);
if(di == 0)
error("draw: cannot happen");
di->vers = dn->vers;
di->name = smalloc(j+1);
di->fromname = dn->dimage;
di->fromname->ref++;
memmove(di->name, a+6, j);
di->name[j] = 0;
client->infoid = dstid;
continue;
/* name an image: 'N' dstid[4] in[1] j[1] name[j] */
case 'N':
printmesg(fmt="Lbz", a, 0);
m = 1+4+1+1;
if(n < m)
error(Eshortdraw);
c = a[5];
j = a[6];
if(j == 0) /* give me a non-empty name please */
error(Eshortdraw);
m += j;
if(n < m)
error(Eshortdraw);
di = drawlookup(client, BGLONG(a+1), 0);
if(di == 0)
error(Enodrawimage);
if(di->name)
error(Enamed);
if(c)
drawaddname(client, di, j, (char*)a+7);
else{
dn = drawlookupname(j, (char*)a+7);
if(dn == nil)
error(Enoname);
if(dn->dimage != di)
error(Ewrongname);
drawdelname(dn);
}
continue;
/* position window: 'o' id[4] r.min [2*4] screenr.min [2*4] */
case 'o':
printmesg(fmt="LPP", a, 0);
m = 1+4+2*4+2*4;
if(n < m)
error(Eshortdraw);
dst = drawimage(client, a+1);
if(dst->layer){
drawpoint(&p, a+5);
drawpoint(&q, a+13);
r = dst->layer->screenr;
ni = memlorigin(dst, p, q);
if(ni < 0)
error("image origin failed");
if(ni > 0){
addflush(r);
addflush(dst->layer->screenr);
ll = drawlookup(client, BGLONG(a+1), 1);
drawrefreshscreen(ll, client);
}
}
continue;
/* set compositing operator for next draw operation: 'O' op */
case 'O':
printmesg(fmt="b", a, 0);
m = 1+1;
if(n < m)
error(Eshortdraw);
client->op = a[1];
continue;
/* filled polygon: 'P' dstid[4] n[2] wind[4] ignore[2*4] srcid[4] sp[2*4] p0[2*4] dp[2*2*n] */
/* polygon: 'p' dstid[4] n[2] end0[4] end1[4] radius[4] srcid[4] sp[2*4] p0[2*4] dp[2*2*n] */
case 'p':
case 'P':
printmesg(fmt="LslllLPP", a, 0);
m = 1+4+2+4+4+4+4+2*4;
if(n < m)
error(Eshortdraw);
dstid = BGLONG(a+1);
dst = drawimage(client, a+1);
ni = BGSHORT(a+5);
if(ni < 0)
error("negative count in polygon");
e0 = BGLONG(a+7);
e1 = BGLONG(a+11);
j = 0;
if(*a == 'p'){
j = BGLONG(a+15);
if(j < 0)
error("negative polygon line width");
}
src = drawimage(client, a+19);
drawpoint(&sp, a+23);
drawpoint(&p, a+31);
ni++;
pp = malloc(ni*sizeof(Point));
if(pp == nil)
error(Enomem);
doflush = 0;
if(dstid==0 || (screenimage && dst->layer && dst->layer->screen->image->data == screenimage->data))
doflush = 1; /* simplify test in loop */
ox = oy = 0;
esize = 0;
u = a+m;
for(y=0; y<ni; y++){
q = p;
oesize = esize;
u = drawcoord(u, a+n, ox, &p.x);
u = drawcoord(u, a+n, oy, &p.y);
ox = p.x;
oy = p.y;
if(doflush){
esize = j;
if(*a == 'p'){
if(y == 0){
c = memlineendsize(e0);
if(c > esize)
esize = c;
}
if(y == ni-1){
c = memlineendsize(e1);
if(c > esize)
esize = c;
}
}
if(*a=='P' && e0!=1 && e0 !=~0)
r = dst->clipr;
else if(y > 0){
r = Rect(q.x-oesize, q.y-oesize, q.x+oesize+1, q.y+oesize+1);
combinerect(&r, Rect(p.x-esize, p.y-esize, p.x+esize+1, p.y+esize+1));
}
if(rectclip(&r, dst->clipr)) /* should perhaps be an arg to dstflush */
dstflush(dstid, dst, r);
}
pp[y] = p;
}
if(y == 1)
dstflush(dstid, dst, Rect(p.x-esize, p.y-esize, p.x+esize+1, p.y+esize+1));
op = drawclientop(client);
if(*a == 'p')
mempoly(dst, pp, ni, e0, e1, j, src, sp, op);
else
memfillpoly(dst, pp, ni, e0, src, sp, op);
free(pp);
m = u-a;
continue;
/* read: 'r' id[4] R[4*4] */
case 'r':
printmesg(fmt="LR", a, 0);
m = 1+4+4*4;
if(n < m)
error(Eshortdraw);
i = drawimage(client, a+1);
drawrectangle(&r, a+5);
if(!rectinrect(r, i->r))
error(Ereadoutside);
c = bytesperline(r, i->depth);
c *= Dy(r);
free(client->readdata);
client->readdata = mallocz(c, 0);
if(client->readdata == nil)
error("readimage malloc failed");
client->nreaddata = memunload(i, r, client->readdata, c);
if(client->nreaddata < 0){
free(client->readdata);
client->readdata = nil;
error("bad readimage call");
}
continue;
/* string: 's' dstid[4] srcid[4] fontid[4] P[2*4] clipr[4*4] sp[2*4] ni[2] ni*(index[2]) */
/* 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]) */
case 's':
case 'x':
printmesg(fmt="LLLPRPs", a, 0);
m = 1+4+4+4+2*4+4*4+2*4+2;
if(*a == 'x')
m += 4+2*4;
if(n < m)
error(Eshortdraw);
dst = drawimage(client, a+1);
dstid = BGLONG(a+1);
src = drawimage(client, a+5);
font = drawlookup(client, BGLONG(a+9), 1);
if(font == 0)
error(Enodrawimage);
if(font->nfchar == 0)
error(Enotfont);
drawpoint(&p, a+13);
drawrectangle(&r, a+21);
drawpoint(&sp, a+37);
ni = BGSHORT(a+45);
u = a+m;
m += ni*2;
if(n < m)
error(Eshortdraw);
clipr = dst->clipr;
dst->clipr = r;
op = drawclientop(client);
bg = dst;
if(*a == 'x'){
/* paint background */
bg = drawimage(client, a+47);
drawpoint(&q, a+51);
r.min.x = p.x;
r.min.y = p.y-font->ascent;
r.max.x = p.x;
r.max.y = r.min.y+Dy(font->image->r);
j = ni;
while(--j >= 0){
ci = BGSHORT(u);
if(ci<0 || ci>=font->nfchar){
dst->clipr = clipr;
error(Eindex);
}
r.max.x += font->fchar[ci].width;
u += 2;
}
memdraw(dst, r, bg, q, memopaque, ZP, op);
u -= 2*ni;
}
q = p;
while(--ni >= 0){
ci = BGSHORT(u);
if(ci<0 || ci>=font->nfchar){
dst->clipr = clipr;
error(Eindex);
}
q = drawchar(dst, bg, q, src, &sp, font, ci, op);
u += 2;
}
dst->clipr = clipr;
p.y -= font->ascent;
dstflush(dstid, dst, Rect(p.x, p.y, q.x, p.y+Dy(font->image->r)));
continue;
/* use public screen: 'S' id[4] chan[4] */
case 'S':
printmesg(fmt="Ll", a, 0);
m = 1+4+4;
if(n < m)
error(Eshortdraw);
dstid = BGLONG(a+1);
if(dstid == 0)
error(Ebadarg);
dscrn = drawlookupdscreen(dstid);
if(dscrn==0 || (dscrn->public==0 && dscrn->owner!=client))
error(Enodrawscreen);
if(dscrn->screen->image->chan != BGLONG(a+5))
error("inconsistent chan");
if(drawinstallscreen(client, dscrn, 0, 0, 0, 0) == 0)
error(Edrawmem);
continue;
/* top or bottom windows: 't' top[1] nw[2] n*id[4] */
case 't':
printmesg(fmt="bsL", a, 0);
m = 1+1+2;
if(n < m)
error(Eshortdraw);
nw = BGSHORT(a+2);
if(nw < 0)
error(Ebadarg);
if(nw == 0)
continue;
m += nw*4;
if(n < m)
error(Eshortdraw);
lp = malloc(nw*sizeof(Memimage*));
if(lp == 0)
error(Enomem);
if(waserror()){
free(lp);
nexterror();
}
for(j=0; j<nw; j++)
lp[j] = drawimage(client, a+1+1+2+j*4);
if(lp[0]->layer == 0)
error("images are not windows");
for(j=1; j<nw; j++)
if(lp[j]->layer->screen != lp[0]->layer->screen)
error("images not on same screen");
if(a[1])
memltofrontn(lp, nw);
else
memltorearn(lp, nw);
if(screenimage && lp[0]->layer->screen->image->data == screenimage->data)
for(j=0; j<nw; j++)
addflush(lp[j]->layer->screenr);
ll = drawlookup(client, BGLONG(a+1+1+2), 1);
drawrefreshscreen(ll, client);
poperror();
free(lp);
continue;
/* visible: 'v' */
case 'v':
printmesg(fmt="", a, 0);
m = 1;
drawflush();
continue;
/* write: 'y' id[4] R[4*4] data[x*1] */
/* write from compressed data: 'Y' id[4] R[4*4] data[x*1] */
case 'y':
case 'Y':
printmesg(fmt="LR", a, 0);
// iprint("load %c\n", *a);
m = 1+4+4*4;
if(n < m)
error(Eshortdraw);
dstid = BGLONG(a+1);
dst = drawimage(client, a+1);
drawrectangle(&r, a+5);
if(!rectinrect(r, dst->r))
error(Ewriteoutside);
y = memload(dst, r, a+m, n-m, *a=='Y');
if(y < 0)
error("bad writeimage call");
dstflush(dstid, dst, r);
m += y;
continue;
}
}
poperror();
}
Dev drawdevtab = {
'i',
"draw",
devreset,
devinit,
devshutdown,
drawattach,
drawwalk,
drawstat,
drawopen,
devcreate,
drawclose,
drawread,
devbread,
drawwrite,
devbwrite,
devremove,
devwstat,
};
/*
* On 8 bit displays, load the default color map
*/
void
drawcmap(void)
{
int r, g, b, cr, cg, cb, v;
int num, den;
int i, j;
for(r=0,i=0; r!=4; r++)
for(v=0; v!=4; v++,i+=16){
for(g=0,j=v-r; g!=4; g++)
for(b=0;b!=4;b++,j++){
den = r;
if(g > den)
den = g;
if(b > den)
den = b;
if(den == 0) /* divide check -- pick grey shades */
cr = cg = cb = v*17;
else{
num = 17*(4*den+v);
cr = r*num/den;
cg = g*num/den;
cb = b*num/den;
}
setcolor(i+(j&15),
cr*0x01010101, cg*0x01010101, cb*0x01010101);
}
}
}