## diffname carrera/screen.c 1993/0906
## diff -e /dev/null /n/fornaxdump/1993/0906/sys/src/brazil/carrera/screen.c
0a
#include	"u.h"
#include	"../port/lib.h"
#include	"mem.h"
#include	"dat.h"
#include	"fns.h"
#include	"io.h"
#include	"ureg.h"
#include	"../port/error.h"

#include	<libg.h>
#include	<gnot.h>

#define	MINX	8

enum
{
	EMISCR=		0x3CC,		/* control sync polarity */
	EMISCW=		0x3C2,
	EFCW=		0x3DA,		/* feature control */
	EFCR=		0x3CA,
	GRX=		0x3CE,		/* index to graphics registers */
	GR=		0x3CF,		/* graphics registers */
	 Grms=		 0x04,		/*  read map select register */
	SRX=		0x3C4,		/* index to sequence registers */
	SR=		0x3C5,		/* sequence registers */
	 Smmask=	 0x02,		/*  map mask */
	CRX=		0x3D4,		/* index to crt registers */
	CR=		0x3D5,		/* crt registers */
	 Cvre=		 0x11,		/*  vertical retrace end */
	ARW=		0x3C0,		/* attribute registers (writing) */
	ARR=		0x3C1,		/* attribute registers (reading) */
	CMRX=		0x3C7,		/* color map read index */
	CMWX=		0x3C8,		/* color map write index */
	CM=		0x3C9,		/* color map data reg */
};

typedef struct VGAmode	VGAmode;
struct VGAmode
{
	uchar	general[2];
	uchar	sequencer[5];
	uchar	crt[0x19];
	uchar	graphics[9];
	uchar	attribute[0x15];
	uchar	special[12];
};

void	setmode(VGAmode*);

extern	struct GBitmap	gscreen;

VGAmode dfltmode = 
{
	/* general */
	0xef, 0x00, 
	/* sequence */
	0x03, 0x01, 0x0f, 0x00, 0x0e, 
	/* crt */
	0xa1, 0x7f, 0x7f, 0x85, 0x85, 0x96, 0x24, 0xf5, 
	0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
	0x02, 0x88, 0xff, 0x80, 0x60, 0xff, 0x25, 0xab, 
	0xff, 
	/* graphics */
	0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0f, 
	0xff, 
	/* attribute */
	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
	0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 
	0x01, 0x00, 0x0f, 0x00, 0x00,
	/* special */
	0x00, 0x00, 0xbc, 0x00, 0x00, 0x00, 0x28, 0x00, 
	0x0a, 0x00, 0x43, 0x1f, 
};

extern	GSubfont	defont0;
GSubfont		*defont;

static ulong rep(ulong, int);

struct{
	Point	pos;
	int	bwid;
}out;

Lock	screenlock;

GBitmap	gscreen =
{
	EISAUNCACHED(0xA0000),
	0,
	(1024*(1<<3))/32,
	3,
	{ 0, 0, 1024, 768 },
	{ 0, 0, 1024, 768 },
	0
};

static GBitmap hwcursor=
{
	0,		/* base filled in by malloc when needed */
	0,
	4,
	1,
	{0, 0, 64, 64},
	{0, 0, 64, 64}
};

uchar bdata[] =
{
	0xC0,
};

GBitmap bgrnd =
{
	(ulong*)bdata,
	0,
	4,
	3,
	{ 0, 0, 1, 1 },
	{ 0, 0, 1, 1 },
	0
};

/*
 *  a fatter than usual cursor for the safari
 */
Cursor fatarrow = {
	{ -1, -1 },
	{
		0xff, 0xff, 0x80, 0x01, 0x80, 0x02, 0x80, 0x0c, 
		0x80, 0x10, 0x80, 0x10, 0x80, 0x08, 0x80, 0x04, 
		0x80, 0x02, 0x80, 0x01, 0x80, 0x02, 0x8c, 0x04, 
		0x92, 0x08, 0x91, 0x10, 0xa0, 0xa0, 0xc0, 0x40, 
	},
	{
		0x00, 0x00, 0x7f, 0xfe, 0x7f, 0xfc, 0x7f, 0xf0, 
		0x7f, 0xe0, 0x7f, 0xe0, 0x7f, 0xf0, 0x7f, 0xf8, 
		0x7f, 0xfc, 0x7f, 0xfe, 0x7f, 0xfc, 0x73, 0xf8, 
		0x61, 0xf0, 0x60, 0xe0, 0x40, 0x40, 0x00, 0x00, 
	},
};

static Rectangle window;
static Point cursor;
static int h, w;
extern Cursor arrow;

void
gborder(GBitmap *l, Rectangle r, int i, Fcode c)
{
	if(i < 0){
		r = inset(r, i);
		i = -i;
	}
	gbitblt(l, r.min, l, Rect(r.min.x, r.min.y, r.max.x, r.min.y+i), c);
	gbitblt(l, Pt(r.min.x, r.max.y-i),
		l, Rect(r.min.x, r.max.y-i, r.max.x, r.max.y), c);
	gbitblt(l, Pt(r.min.x, r.min.y+i),
		l, Rect(r.min.x, r.min.y+i, r.min.x+i, r.max.y-i), c);
	gbitblt(l, Pt(r.max.x-i, r.min.y+i),
		l, Rect(r.max.x-i, r.min.y+i, r.max.x, r.max.y-i), c);
}

void
screenwin(void)
{
	gtexture(&gscreen, gscreen.r, &bgrnd, S);
	w = defont0.info[' '].width;
	h = defont0.height;

	window.min = Pt(100, 100);
	window.max = add(window.min, Pt(10+w*120, 10+h*60));

	gbitblt(&gscreen, window.min, &gscreen, window, Zero);
	window = inset(window, 5);
	cursor = window.min;
	window.max.y = window.min.y+((window.max.y-window.min.y)/h)*h;

	hwcurs = 0;
}

void
screeninit(void)
{
	setmode(&dfltmode);

	memmove(&arrow, &fatarrow, sizeof(fatarrow));

	/* save space; let bitblt do the conversion work */
	defont = &defont0;	
	gbitblt(&gscreen, Pt(0, 0), &gscreen, gscreen.r, 0);
	out.pos.x = MINX;
	out.pos.y = 0;
	out.bwid = defont0.info[' '].width;

	screenwin();
}

static void
scroll(void)
{
	int o;
	Rectangle r;

	o = 5*h;
	r = Rpt(Pt(window.min.x, window.min.y+o), window.max);
	gbitblt(&gscreen, window.min, &gscreen, r, S);
	r = Rpt(Pt(window.min.x, window.max.y-o), window.max);
	gbitblt(&gscreen, r.min, &gscreen, r, Zero);
	cursor.y -= o;
}

static void
screenputc(char *buf)
{
	int pos;

	switch(buf[0]) {
	case '\n':
		if(cursor.y+h >= window.max.y)
			scroll();
		cursor.y += h;
		screenputc("\r");
		break;
	case '\r':
		cursor.x = window.min.x;
		break;
	case '\t':
		pos = (cursor.x-window.min.x)/w;
		pos = 8-(pos%8);
		cursor.x += pos*w;
		break;
	case '\b':
		if(cursor.x-w >= 0)
			cursor.x -= w;
		break;
	default:
		if(cursor.x >= window.max.x-w)
			screenputc("\n");
		cursor = gsubfstring(&gscreen, cursor, &defont0, buf, S);
	}
}

#ifdef USEME
void
screenputs(char *s, int n)
{
	int i;
	Rune r;
	char buf[4];

	if((getstatus() & IEC) == 0) {
		/* don't deadlock trying to print in interrupt */
		if(!canlock(&screenlock))
			return;	
	}
	else
		lock(&screenlock);

	while(n > 0){
		i = chartorune(&r, s);
		if(i == 0){
			s++;
			--n;
			continue;
		}
		memmove(buf, s, i);
		buf[i] = 0;
		n -= i;
		s += i;
		screenputc(buf);
	}
	unlock(&screenlock);
}
#endif

/* replicate (from top) value in v (n bits) until it fills a ulong */
static ulong
rep(ulong v, int n)
{
	int o;
	ulong rv;

	rv = 0;
	for(o = 32 - n; o >= 0; o -= n)
		rv |= (v << o);
	return rv;
}

void
getcolor(ulong p, ulong *pr, ulong *pg, ulong *pb)
{
	ulong ans;

	/*
	 * The gnot says 0 is white (max intensity)
	 */
	if(gscreen.ldepth == 0){
		if(p == 0)
				ans = ~0;
		else
				ans = 0;
	}else{
		switch(p){
		case 0:		ans = ~0;		break;
		case 1:		ans = 0xAAAAAAAA;	break;
		case 2:		ans = 0x55555555;	break;
		default:	ans = 0;		break;
		}
	}
	*pr = *pg = *pb = ans;
}

int
setcolor(ulong p, ulong r, ulong g, ulong b)
{
	USED(p, r, g, b);
	return 0;	/* can't change mono screen colormap */
}

void
hwcursset(ulong *s, ulong *c, int ox, int oy)
{
	USED(s, c, ox, oy);
}

void
hwcursmove(int x, int y)
{
	USED(x, y);
}

/* only 1 flavor mouse */
void
mousectl(char *x)
{
	USED(x);
}

/* bits per pixel */
int
screenbits(void)
{
	return 1<<gscreen.ldepth;
}

void
mbbrect(Rectangle r)
{
	USED(r);
}

void
mbbpt(Point p)
{
	USED(p);
}

void
srout(int reg, int val)
{
	EISAOUTB(SRX, reg);
	EISAOUTB(SR, val);
}

void
grout(int reg, int val)
{
	EISAOUTB(GRX, reg);
	EISAOUTB(GR, val);
}

void
genout(int reg, int val)
{
	if(reg == 0)
		EISAOUTB(EMISCW, val);
	else if (reg == 1)
		EISAOUTB(EFCW, val);
}

void
arout(int reg, int val)
{
	uchar junk;

	junk = EISAINB(0x3DA);
	USED(junk);

	if (reg <= 0xf) {
		EISAOUTB(ARW, reg | 0x0);
		EISAOUTB(ARW, val);
		junk = EISAINB(0x3DA);
		USED(junk);
		EISAOUTB(ARW, reg | 0x20);
	} else {
		EISAOUTB(ARW, reg | 0x20);
		EISAOUTB(ARW, val);
	}
}

void
crout(int reg, int val)
{
	EISAOUTB(CRX, reg);
	EISAOUTB(CR, val);
}

void
setmode(VGAmode *v)
{
	int i;

	/* turn screen off (to avoid damage) */
	srout(1, 0x21);

	for(i = 0; i < sizeof(v->general); i++)
		genout(i, v->general[i]);

	for(i = 0; i < sizeof(v->sequencer); i++)
		if(i == 1)
			srout(i, v->sequencer[i]|0x20);
		else
			srout(i, v->sequencer[i]);

	crout(Cvre, 0);	/* allow writes to CRT registers 0-7 */
	for(i = 0; i < sizeof(v->crt); i++)
		crout(i, v->crt[i]);

	for(i = 0; i < sizeof(v->graphics); i++)
		grout(i, v->graphics[i]);

	for(i = 0; i < sizeof(v->attribute); i++)
		arout(i, v->attribute[i]);

	/* turn screen on */
	srout(1, v->sequencer[1]);
}
.
## diffname carrera/screen.c 1993/0907
## diff -e /n/fornaxdump/1993/0906/sys/src/brazil/carrera/screen.c /n/fornaxdump/1993/0907/sys/src/brazil/carrera/screen.c
434a

	EISAOUTB(0x3C6, 0xFF);	/* pel mask */
	EISAOUTB(0x3C8, 0x00);	/* pel write address */
	EISAOUTB(0x3bf, 0x03);	/* hercules compatibility reg */
	EISAOUTB(0x3d8, 0xa0);	/* display mode control register */

	srout(0x06, v->tseng.sr6);
	srout(0x07, v->tseng.sr7);
	i = EISAINB(0x3da); /* reset flip-flop. inp stat 1*/
	USED(i);
	arout(0x16, v->tseng.ar16);	/* misc */
	arout(0x17, v->tseng.ar17);	/* misc 1*/
	crout(0x31, v->tseng.crt31);	/* extended start. */
	crout(0x32, v->tseng.crt32);	/* extended start. */
	crout(0x33, v->tseng.crt33);	/* extended start. */
	crout(0x34, v->tseng.crt34);	/* stub: 46ee + other bits */
	crout(0x35, v->tseng.crt35);	/* overflow bits */
	crout(0x36, v->tseng.crt36);	/* overflow bits */
	crout(0x37, v->tseng.crt37);	/* overflow bits */
	EISAOUTB(0x3c3, v->tseng.viden);/* video enable */
.
426c
	/* allow writes to CRT registers 0-7 */
	crout(Cvre, 0);
.
416a
	EISAOUTB(0x3bf, 0x03);		/* hercules compatibility reg */
	EISAOUTB(0x3d8, 0xa0);		/* display mode control register */
	EISAOUTB(0x3cd, 0x00);		/* segment select */

	srout(0x00, srin(0x00) & 0xFD);	/* synchronous reset*/

.
396c
	}
	else {
.
378c
	else
	if (reg == 1)
.
365a
uchar
srin(ushort i) {
        EISAOUTB(SRX, i);
        return EISAINB(SR);
}

.
191a
iprint("done\n");
.
190c
	defont = &defont0;
iprint("gbitblt\n");	
.
188a
	scr = (uchar*)EISA(0xA0000);
iprint("%lux\n", scr);
*scr = 0xaa;
i = *scr;
iprint("%2.2ux\n", i);
*scr = 0x55;
i = *scr;
iprint("%2.2ux\n", i);

	for(j = 0; j < 768; j++)
		for(i = 0; i < 1024; i++)
			*(scr+i+(j*1024)) = i;

.
184a
	int i, j;
	uchar *scr;

.
124,126d
98,107d
89c
	EISA(0xA0000),
.
45a
	struct {
		uchar viden;
		uchar sr6;
		uchar sr7;
		uchar ar16;
		uchar ar17;
		uchar crt31;
		uchar crt32;
		uchar crt33;
		uchar crt34;
		uchar crt35;
		uchar crt36;
		uchar crt37;
	} tseng;
.
## diffname carrera/screen.c 1993/0908
## diff -e /n/fornaxdump/1993/0907/sys/src/brazil/carrera/screen.c /n/fornaxdump/1993/0908/sys/src/brazil/carrera/screen.c
491a
}

uchar
grin(ushort i)
{
	EISAOUTB(GRX, i);
	return EISAINB(GR);
}

uchar
arin(ushort i)
{
	uchar junk;
	junk = EISAINB(0x3DA);
	USED(junk);
	EISAOUTB(ARW, i | 0x20);
	return EISAINB(ARR);
}

uchar
crin(ushort i) {
	EISAOUTB(CRX, i);
	return EISAINB(CR);
}

void
getvmode(VGAmode *v)
{
	int i;

	v->general[0] = EISAINB(EMISCR);	/* misc output */
	v->general[1] = EISAINB(EFCR);	/* feature control */
	for(i = 0; i < sizeof(v->sequencer); i++)
		v->sequencer[i] = srin(i);
	for(i = 0; i < sizeof(v->crt); i++) 
		v->crt[i] = crin(i);
	for(i = 0; i < sizeof(v->graphics); i++) 
		v->graphics[i] = grin(i);
	for(i = 0; i < sizeof(v->attribute); i++)
		v->attribute[i] = arin(i);

	v->tseng.viden = EISAINB(0x3c3);
	v->tseng.sr6  = srin(6);
	v->tseng.sr7  = srin(7);
	v->tseng.ar16 = arin(0x16);
	v->tseng.ar17 = arin(0x17);
	v->tseng.crt31= crin(0x31);
	v->tseng.crt32= crin(0x32);
	v->tseng.crt33= crin(0x33);
	v->tseng.crt34= crin(0x34);
	v->tseng.crt35= crin(0x35);
	v->tseng.crt36= crin(0x36);
	v->tseng.crt37= crin(0x37);
}

void
writeregisters(VGAmode *v)
{
	int i;

	print("\t/* general */\n\t");
	for (i=0; i<sizeof(v->general); i++)
		print("0x%.2x, ", v->general[i]);
	print("\n\t/* sequence */\n\t");
	for (i=0; i<sizeof(v->sequencer); i++) {
		if (i>0 && i%8 == 0)
			print("\n\t");
		print("0x%.2x, ", v->sequencer[i]);
	}
	print("\n\t/* crt */\n\t");
	for (i=0; i<sizeof(v->crt); i++) {
		if (i>0 && i%8 == 0)
			print("\n\t");
		print("0x%.2x, ", v->crt[i]);
	}
	print("\n\t/* graphics */\n\t");
	for (i=0; i<sizeof(v->graphics); i++) {
		if (i>0 && i%8 == 0)
			print("\n\t");
		print("0x%.2x, ", v->graphics[i]);
	}
	print("\n\t/* attribute */\n\t");
	for (i=0; i<sizeof(v->attribute); i++) {
		if (i>0 && i%8 == 0)
			print("\n\t");
		print("0x%.2x, ", v->attribute[i]);
	}
	print("\n");
	print("\t/* special */\n");

	for (i=0; i<12; i++) {
		if (i%8 == 0)
			print("\n\t");
		print("0x%.2x, ", ((uchar*)(&v->tseng))[i]);
	}
	print("\n");
.
450,452d
440a
	for(i = 0; i < sizeof(v->general); i++)
		genout(i, v->general[i]);

.
386c
srin(ushort i)
{
.
193c
	scr = (uchar*)EISA(0xC0000);
.
190c
	getvmode(&x);
	writeregisters(&x);
return;
.
182a
void	getvmode(VGAmode *v);
void	writeregisters(VGAmode *v);
VGAmode x;

.
## diffname carrera/screen.c 1993/0909
## diff -e /n/fornaxdump/1993/0908/sys/src/brazil/carrera/screen.c /n/fornaxdump/1993/0909/sys/src/brazil/carrera/screen.c
458a

	for(i = 0; i < sizeof(v->general); i++)
		genout(i, v->general[i]);
.
448,450d
192a
	EISAOUTB(0x3c3, 1);
	delay(1);
	EISAOUTB(0x46e8, 0x8);

.
## diffname carrera/screen.c 1993/0910
## diff -e /n/fornaxdump/1993/0909/sys/src/brazil/carrera/screen.c /n/fornaxdump/1993/0910/sys/src/brazil/carrera/screen.c
196a
	setmode(&dfltmode);
.
193,195c
EISAOUTB(0x3C3, 1);
EISAOUTB(0x46e8, 8);
EISAOUTB(0x3bf, 1);
i = EISAINB(0x3b8);
print("=%2.2ux\n", i);
EISAOUTB(0x3bf, 3);
i = EISAINB(0x3b8);
print("=%2.2ux\n", i);
EISAOUTB(0x3bf, 1);
i = EISAINB(0x3d8);
print("=%2.2ux\n", i);
EISAOUTB(0x3bf, 3);
i = EISAINB(0x3d8);
print("=%2.2ux\n", i);
EISAOUTB(0x3d8, 0xa0);
.
## diffname carrera/screen.c 1993/0916
## diff -e /n/fornaxdump/1993/0910/sys/src/brazil/carrera/screen.c /n/fornaxdump/1993/0916/sys/src/brazil/carrera/screen.c
193,209d
148a
#define IOPORT	((uchar*)0xE0010000)

static uchar
inb(int port)
{
	return IOPORT[port^7];
}

static void
outb(int port, int val)
{
	IOPORT[port^7] = val;
}

.
## diffname carrera/screen.c 1993/0918
## diff -e /n/fornaxdump/1993/0916/sys/src/brazil/carrera/screen.c /n/fornaxdump/1993/0918/sys/src/brazil/carrera/screen.c
608d
603,606c
	inc = gscreen.width*4;
	off = r.min.y * inc + r.min.x;
	sp = ((uchar*)gscreen.base) + off;

	page = off>>16;
	off &= (1<<16)-1;
	hp = edisp = 0;
	for(y = r.min.y; y < r.max.y; y++){
		if(hp >= edisp){
			hp = ((uchar*)vgascreen.base) + off;
			edisp = ((uchar*)vgascreen.base) + 64*1024;
			EISAOUTB(0x3cd, (page<<4) | page);
			off = r.min.x;
			page++;
		}
		for(i = 0; i < len; i += 8)
			twizzle(sp+i, hp+i);
		hp += inc;
		sp += inc;
.
573,601c
	r.min.x &= ~7;
	len = r.max.x - r.min.x;
	len = (len+7)&~7;
	if(len <= 0)
		return;
.
568,571c
	if(r.min.x < 0)
		r.min.x = 0;
	if(r.min.y < 0)
		r.min.y = 0;
	if(r.max.x > gscreen.r.max.x)
		r.max.x = gscreen.r.max.x;
	if(r.max.y > gscreen.r.max.y)
		r.max.y = gscreen.r.max.y;
.
554,566c
	if(Dy(r) < 0)
		return;
.
543,552c
	r = mbb;
	mbb = NULLMBB;
.
541c
	uchar *sp, *hp, *edisp;
	int i, y, len, off, page, inc;
	Rectangle r;
.
539c
screenupdate(void)
.
532,535c
	in1 = *(ulong*)f;
	in2 = *(ulong*)(f+4);
	*(ulong*)t = swiz(in2);
	*(ulong*)(t+4) = swiz(in1);
.
525,530c
	ulong in1, in2;
.
522,523c
void
twizzle(uchar *f, uchar *t)
.
515,520c
#define swiz(s)	(s<<24)|((s>>8)&0xff00)|((s<<8)&0xff0000)|(s>>24)
.
492a

.
387,398d
356,357c
	p &= (1<<(1<<gscreen.ldepth))-1;
	colormap[p][0] = r;
	colormap[p][1] = g;
	colormap[p][2] = b;
	EISAOUTB(CMWX, 255-p);
	EISAOUTB(CM, r>>(32-6));
	EISAOUTB(CM, g>>(32-6));
	EISAOUTB(CM, b>>(32-6));
	return ~0;
.
332,350c
	p &= (1<<(1<<gscreen.ldepth))-1;
	*pr = colormap[p][0];
	*pg = colormap[p][1];
	*pb = colormap[p][2];
.
316,328d
314d
311a
	if(isscroll) {
		mbb = window;
		isscroll = 0;
	}
	else
		mbbpt(Pt(cursor.x, cursor.y+h));

	screenupdate();
.
299c
	mbbpt(cursor);
	while(n > 0) {
.
291c
	if((getstatus() & IE) == 0) {
.
283d
278a

.
251a
void
mbbrect(Rectangle r)
{
	if (r.min.x < mbb.min.x)
		mbb.min.x = r.min.x;
	if (r.min.y < mbb.min.y)
		mbb.min.y = r.min.y;
	if (r.max.x > mbb.max.x)
		mbb.max.x = r.max.x;
	if (r.max.y > mbb.max.y)
		mbb.max.y = r.max.y;
}

void
mbbpt(Point p)
{
	if (p.x < mbb.min.x)
		mbb.min.x = p.x;
	if (p.y < mbb.min.y)
		mbb.min.y = p.y;
	if (p.x >= mbb.max.x)
		mbb.max.x = p.x+1;
	if (p.y >= mbb.max.y)
		mbb.max.y = p.y+1;
}

.
249a
	isscroll = 1;
.
234a
	memmove(&arrow, &fatarrow, sizeof(fatarrow));

.
230,233d
222,228d
213,220c
	/* allocate a new soft bitmap area */
	gscreen.base = xalloc(1024*1024);
.
208,211c
	for(i = 0; i < 256; i++)
		setcolor(i, x3to32(i>>5), x3to32(i>>2), x3to32(i<<1));
.
204,205c
	int i;
.
200a
	x = x&7;
	x= (x<<3)|x;
	y = (x<<(32-6))|(x<<(32-12))|(x<<(32-18))|(x<<(32-24))|(x<<(32-30));
	return y;
}

.
197,199c
/*
 *  expand 3 and 6 bits of color to 32
 */
static ulong
x3to32(uchar x)
{
	ulong y;
.
194a

	mbb = gscreen.r;
	screenupdate();
.
193d
186,187c
	window.min = Pt(50, 50);
	window.max = add(window.min, Pt(10+w*100, 10+h*40));
.
184a
	defont = &defont0;	
.
164,179d
149,162d
147a
static ulong colormap[256][3];
static Rectangle mbb;
static Rectangle NULLMBB = {10000, 10000, -10000, -10000};
static int isscroll;
.
102a
	0,
	0,
	(1024*(1<<3))/32,
	3,
	{ 0, 0, 1024, 768 },
	{ 0, 0, 1024, 768 },
	0
};

GBitmap	vgascreen =
{
.
92,98d
45d
## diffname carrera/screen.c 1993/0930
## diff -e /n/fornaxdump/1993/0918/sys/src/brazil/carrera/screen.c /n/fornaxdump/1993/0930/sys/src/brazil/carrera/screen.c
550a
}

/*
 * graphics
 */
void
screenload(Rectangle r, uchar *data, long n)
{
	int y, ws, l, t, lpart, rpart, mx, m, mr;
	uchar *q;

	if(!rectclip(&r, gscreen.r))
		return;
	lock(&screenlock);
	ws = 8>>gscreen.ldepth;	/* pixels per byte */
	/* set l to number of bytes of data per scan line */
	if(r.min.x >= 0)
		l = (r.max.x+ws-1)/ws - r.min.x/ws;
	else{		/* make positive before divide */
		t = (-r.min.x)+ws-1;
		t = (t/ws)*ws;
		l = (t+r.max.x+ws-1)/ws;
	}
	if(n != l*Dy(r)){
		unlock(&screenlock);
		error("bad tile size");
	}
	q = gbaddr(&gscreen, r.min);
	mx = 7>>gscreen.ldepth;
	lpart = (r.min.x & mx) << gscreen.ldepth;
	rpart = (r.max.x & mx) << gscreen.ldepth;
	m = 0xFF >> lpart;
	mr = 0xFF ^ (0xFF >> rpart);
	/* may need to do bit insertion on edges */
	if(l == 1){	/* all in one byte */
		if(rpart)
			m ^= 0xFF >> rpart;
		for(y=r.min.y; y<r.max.y; y++){
			*q ^= (*data^*q) & m;
			q += gscreen.width*sizeof(ulong);
			data++;
		}
	}else if(lpart==0 && rpart==0){	/* easy case */
		for(y=r.min.y; y<r.max.y; y++){
			memmove(q, data, l);
			q += gscreen.width*sizeof(ulong);
			data += l;
		}
	}else if(rpart==0){
		for(y=r.min.y; y<r.max.y; y++){
			*q ^= (*data^*q) & m;
			if(l > 1)
				memmove(q+1, data+1, l-1);
			q += gscreen.width*sizeof(ulong);
			data += l;
		}
	}else if(lpart == 0){
		for(y=r.min.y; y<r.max.y; y++){
			if(l > 1)
				memmove(q, data, l-1);
			q[l-1] ^= (data[l-1]^q[l-1]) & mr;
			q += gscreen.width*sizeof(ulong);
			data += l;
		}
	}else for(y=r.min.y; y<r.max.y; y++){
			*q ^= (*data^*q) & m;
			if(l > 2)
				memmove(q+1, data+1, l-2);
			q[l-1] ^= (data[l-1]^q[l-1]) & mr;
			q += gscreen.width*sizeof(ulong);
			data += l;
		}
	mbbrect(r);
	screenupdate();
	unlock(&screenlock);
.
316,317d
298d
280a
	mbbpt(Pt(cursor.x, cursor.y+h));
.
255a
	mbbpt(cursor);
.
## diffname carrera/screen.c 1993/1001
## diff -e /n/fornaxdump/1993/0930/sys/src/brazil/carrera/screen.c /n/fornaxdump/1993/1001/sys/src/brazil/carrera/screen.c
273c
		if(cursor.x-w >= window.min.x)
.
## diffname carrera/screen.c 1993/1003
## diff -e /n/fornaxdump/1993/1001/sys/src/brazil/carrera/screen.c /n/fornaxdump/1993/1003/sys/src/brazil/carrera/screen.c
549a
}

void
mousescreenupdate(void)
{
	if(canlock(&screenlock) == 0)
		return;

	screenupdate();
	unlock(&screenlock);
.
545,546c
		for(i = 0; i < len; i += 8) {
			s = (ulong*)(sp+i);
			h = (ulong*)(hp+i);
			in1 = s[0];
			in2 = s[1];
			h[0] = swiz(in2);
			h[1] = swiz(in1);
		}
.
536c
	hp = 0;
	edisp = 0;
.
531a

.
507d
504a
	Rectangle r;
	ulong *s, *h, in1, in2;
.
205,206d
131,146d
## diffname carrera/screen.c 1993/1006
## diff -e /n/fornaxdump/1993/1003/sys/src/brazil/carrera/screen.c /n/fornaxdump/1993/1006/sys/src/brazil/carrera/screen.c
143c
	memset(gscreen.base, 0xC0, gscreen.width*sizeof(ulong)*Dy(gscreen.r));
.
115,130d
## diffname carrera/screen.c 1993/1008
## diff -e /n/fornaxdump/1993/1006/sys/src/brazil/carrera/screen.c /n/fornaxdump/1993/1008/sys/src/brazil/carrera/screen.c
607a
	cursoron(1);
.
561a
	cursoroff(1);
.
## diffname carrera/screen.c 1993/1026
## diff -e /n/fornaxdump/1993/1008/sys/src/brazil/carrera/screen.c /n/fornaxdump/1993/1026/sys/src/brazil/carrera/screen.c
609c
	screenupdate();
	cursorunlock();
.
603,604c
				memmove(q+1, data+1, tl-2);
			q[tl-1] ^= (data[tl-1]^q[l-1]) & mr;
.
594,596c
			if(tl > 1)
				memmove(q, data, tl-1);
			q[tl-1] ^= (data[tl-1]^q[tl-1]) & mr;
.
587,588c
			if(tl > 1)
				memmove(q+1, data+1, tl-1);
.
580c
			memmove(q, data, tl);
.
576c
			data += l;
.
549,562c
	cursorlock(r);
	screenupdate();
.
546c
	if(!rectclip(&r, gscreen.r) || tl<=0)
.
543c
	int y, lpart, rpart, mx, m, mr;
.
541c
screenload(Rectangle r, uchar *data, int tl, int l)
.
538c
 * paste tile into screen.
 * tile is at location r, first pixel in *data.  tl is length of scan line to insert,
 * l is amount to advance data after each scan line.
.
536a
extern	cursorlock(Rectangle);
extern	cursorunlock(void);
.
## diffname carrera/screen.c 1993/1221
## diff -e /n/fornaxdump/1993/1026/sys/src/brazil/carrera/screen.c /n/fornaxdump/1993/1221/sys/src/brazil/carrera/screen.c
594c
			if(tl > 2)
.
564c
			m &= mr;
.
458,468d
127d
108,111c
	(1280*(1<<0))/32,
	0,
	{ 0, 0, 1280, 1024 },
	{ 0, 0, 1280, 1024 },
.
97,100c
	(1280*(1<<0))/32,
	0,
	{ 0, 0, 1280, 1024 },
	{ 0, 0, 1280, 1024 },
.
85c
	0x0a, 0x9b, 0x43, 0x1f, 
.
80,82c
	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 
	0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 
	0x01, 0x00, 0x0f, 0x00, 0x00, 
.
77c
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0f, 
.
72,74c
	0xcb, 0x9f, 0xa0, 0x8e, 0xa9, 0x04, 0x4f, 0x52, 
	0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
	0x11, 0x89, 0xff, 0x50, 0x00, 0x09, 0x46, 0xc3, 
.
70c
	0x03, 0x01, 0x0f, 0x00, 0x06, 
.
68c
	0x23, 0x00, 
.
13,14d
## diffname carrera/screen.c 1993/1222
## diff -e /n/fornaxdump/1993/1221/sys/src/brazil/carrera/screen.c /n/fornaxdump/1993/1222/sys/src/brazil/carrera/screen.c
582c
			q[tl-1] ^= (data[tl-1]^q[tl-1]) & mr;
.
492,493c
	for(y = r.min.y; y < r.max.y; y++) {
		if(hp >= edisp) {
.
482a
	pixshft = 3-gscreen.ldepth;
	len = (len>>pixshft)+8;
	r.min.x = (r.min.x>>pixshft) & ~7;
	
.
460c
	int i, y, len, off, page, inc, pixshft;
.
301c
	EISAOUTB(CMWX, p);
.
164a
	gscreen.ldepth = 3;
	for(i = 0; i < 16; i++){
		x = x6to32((i*63)/15);
		setcolor(i, x, x, x);
	}
	gscreen.ldepth = 0;

.
162,163d
159c
	int i, x;
.
155a
	x = x&0x3f;
	y = (x<<(32-6))|(x<<(32-12))|(x<<(32-18))|(x<<(32-24))|(x<<(32-30));
	return y;
}

.
154a
static ulong
x6to32(uchar x)
{
	ulong y;
.
124a
	int i;

	for(i = 0; i < 768; i += 2) {
		memset(gscreen.base+(i*gscreen.width), 0xCC, 160);
		memset(gscreen.base+((i+1)*gscreen.width), 0xCC^0xff, 160);
	}
.
108,109c
	{ 0, 0, 1024, 768 },
	{ 0, 0, 1024, 768 },
.
106c
	(1024*(1<<0))/32,
.
97,98c
	{ 0, 0, 1024, 768 },
	{ 0, 0, 1024, 768 },
.
95c
	(1024*(1<<0))/32,
.
83c
	0x0a, 0x00, 0x43, 0x1f, 
.
70,72c
	0xa1, 0x7f, 0x7f, 0x85, 0x85, 0x96, 0x24, 0xf5, 
	0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
	0x02, 0x88, 0xff, 0x40, 0x00, 0xff, 0x25, 0xc3, 
.
65,66c
	0xef, 0x00, 
.
## diffname carrera/screen.c 1993/1224
## diff -e /n/fornaxdump/1993/1222/sys/src/brazil/carrera/screen.c /n/fornaxdump/1993/1224/sys/src/brazil/carrera/screen.c
526,527c
			in1 = ~s[0];
			in2 = ~s[1];
.
446c
	EISAOUTB(0x3C6, 0x0F);	/* pel mask */
.
77,78c
	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
	0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 
.
## diffname carrera/screen.c 1993/1228
## diff -e /n/fornaxdump/1993/1224/sys/src/brazil/carrera/screen.c /n/fornaxdump/1993/1228/sys/src/brazil/carrera/screen.c
550c
 * tile is at location r, first pixel in *data. 
 * tl is length of scan line to insert,
.
186d
159a

.
88,89d
86d
84a
	Lock		screenlock;
	GSubfont*	defont;
.
## diffname carrera/screen.c 1993/1230
## diff -e /n/fornaxdump/1993/1228/sys/src/brazil/carrera/screen.c /n/fornaxdump/1993/1230/sys/src/brazil/carrera/screen.c
525,526c
			in1 = s[0];
			in2 = s[1];
.
445c
	switch(gscreen.ldepth){
	case 3:
		EISAOUTB(0x3C6, 0xFF);	/* pel mask */
		break;
	default:
		EISAOUTB(0x3C6, 0x0F);	/* pel mask */
		break;
	}
.
315c
	ulong x;

	switch(gscreen.ldepth){
	default:
		x = 0xf;
		break;
	case 3:
		x = 0xff;
		break;
	}
	p &= x;
	p ^= x;
.
306c
	ulong x;

	switch(gscreen.ldepth){
	default:
		x = 0xf;
		break;
	case 3:
		x = 0xff;
		break;
	}
	p &= x;
	p ^= x;
.
182d
177d
174a
	gscreen.ldepth = 0;

.
## diffname carrera/screen.c 1994/0210
## diff -e /n/fornaxdump/1993/1230/sys/src/brazil/carrera/screen.c /n/fornaxdump/1994/0210/sys/src/brazil/carrera/screen.c
638,641d
591,592c

.
589a

.
586a
	int y, lpart, rpart, mx, m, mr;
.
585d
575a

.
433,573d
429,430c
	return 1<<gscreen.ldepth;
.
426,427c
int
screenbits(void)
.
410,423c
	x += 379;		/* adjusted by experiment */
	y += 11;		/* adjusted by experiment */
	d->cr1 = 03;
	d->cr0 = 01;
	d->cr2 = x&0xFF;
	d->cr2 = (x>>8)&0xF;
	d->cr2 = y&0xFF;
	d->cr2 = (y>>8)&0xF;
.
405,408c
	d = DAC;
.
398,403c
	Dac *d;
.
396c
hwcursmove(int x, int y)
.
388,392c
	d = DAC;
	/* have to set y offscreen before writing cursor bits */
	d->cr1 = 0x03;
	d->cr0 = 0x03;
	ylow = d->cr2;
	yhigh = d->cr2;
	d->cr1 = 0x03;
	d->cr0 = 0x03;
	d->cr2 = 0xFF;
	d->cr2 = 0xFF;
	/* now set the bits */
	d->cr1 = 0x04;
	d->cr0 = 0x00;
	for(x = 0; x < 1024; x++)
		d->cr2 = ((uchar *)hwcursor.base)[x];
	/* set y back */
	d->cr1 = 0x03;
	d->cr0 = 0x03;
	d->cr2 = ylow;
	d->cr2 = yhigh;
	free(hwcursor.base);
.
381,386c
	hwcursor.base = (ulong *)malloc(1024);
	if(hwcursor.base == 0)
		error(Enomem);
	/* hw cursor is 64x64 with hot point at (32,32) */
	org = add(Pt(32,32), Pt(offx,offy)); 
	for(x = 0; x < 16; x++)
		for(y = 0; y < 16; y++) {
			spix = (s[y]>>(31-(x&0x1F)))&1;
			cpix = (c[y]>>(31-(x&0x1F)))&1;
			dpix = (spix<<1) | cpix;
			gpoint(&hwcursor, add(Pt(x,y), org), dpix, S);
		}
.
377,379c
	Dac *d;
	int x, y;
	Point org;
	uchar ylow, yhigh;
	ulong spix, cpix, dpix;
.
375c
hwcursset(ulong *s, ulong *c, int offx, int offy)
.
367,373d
360,364c
	rv = 0;
	for(o = 32 - n; o >= 0; o -= n)
		rv |= (v << o);
	return rv;
.
357,358c
	int o;
	ulong rv;
.
354,355c
/* replicate (from top) value in v (n bits) until it fills a ulong */
static ulong
rep(ulong v, int n)
.
348,351c
	d->cr0 = revtab0[p & 0xFF];
	d->cr1 = 0;
	d->cr3 = r >> 24;
	d->cr3 = g >> 24;
	d->cr3 = b >> 24;
	return 1;
.
328,346c
	d = DAC;
.
326c
	Dac *d;
	extern uchar revtab0[];
.
308,320c
	d = DAC;

	d->cr0 = revtab0[p & 0xFF];
	d->cr1 = 0;
	r = d->cr3;
	g = d->cr3;
	b = d->cr3;
	*pr = (r<<24) | (r<<16) | (r<<8) | r;
	*pg = (g<<24) | (g<<16) | (g<<8) | g;
	*pb = (b<<24) | (b<<16) | (b<<8) | b;
.
306c
	Dac *d;
	uchar r, g, b;
	extern uchar revtab0[];
.
302a
uchar revtab0[] = {
 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
};

.
294,299d
281c
	while(n > 0){
.
263d
260d
254c
		if(cursor.x-w >= 0)
.
237d
206,231d
203d
187a
	for(i = 0; i<256; i++) {
		r = ~rep((i>>5) & 7, 3);
		g = ~rep((i>>2) & 7, 3);
		b = ~rep(i & 3, 2);
		setcolor(i, r, g, b);
	}
	setcolor(85, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA);
	setcolor(170, 0x55555555, 0x55555555, 0x55555555);

.
186a
	out.pos.x = MINX;
	out.pos.y = 0;
	out.bwid = defont0.info[' '].width;
.
179,185c
	defont = &defont0;	
.
177c
	memmove(&arrow, &fatarrow, sizeof(fatarrow));
.
175c
	dacinit();
.
173c
	int i;
	ulong r, g, b;
.
165,167c
	/* Cursor programming */
	d->cr0 = 0x00;
	d->cr1 = 0x03;
	d->cr2 = 0xC0;
	for(i = 0; i < 12; i++)
		d->cr2 = 0;

	/* Load Cursor Ram */
	d->cr0 = 0x00;
	d->cr1 = 0x04;
	for(i = 0; i < 0x400; i++)
		d->cr2 = 0xff;

	for(i = 0; i<256; i++) {
		r = ~rep((i>>5) & 7, 3);
		g = ~rep((i>>2) & 7, 3);
		b = ~rep(i & 3, 2);
		setcolor(i, r, g, b);
	}
	setcolor(85, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA);
	setcolor(170, 0x55555555, 0x55555555, 0x55555555);

	/* Overlay Palette Ram */
	d->cr0 = 0x00;
	d->cr1 = 0x01;
	for(i = 0; i < 0x10; i++) {
		d->cr2 = 0xff;
		d->cr2 = 0xff;
		d->cr2 = 0xff;
	}

	/* Overlay Palette Ram */
	d->cr0 = 0x81;
	d->cr1 = 0x01;
	for(i = 0; i < 3; i++) {
		d->cr2 = 0xff;
		d->cr2 = 0xff;
		d->cr2 = 0xff;
	}
.
160,163c
	/* Control registers */
	d->cr0 = 0x01;
	d->cr1 = 0x02;
	for(i = 0; i < sizeof s1; i++)
		d->cr2 = s1[i];
.
154,158c
	d = DAC;
.
152c
	Dac *d;
	int i;
	ulong r, g, b;
.
146,150c
void
dacinit(void)
.
142,143c
	hwcurs = 1;
	d = DAC;
	/* cursor color 1: white */
	d->cr1 = 0x01;
	d->cr0 = 0x81;
	d->cr2 = 0xFF;
	d->cr2 = 0xFF;
	d->cr2 = 0xFF;
	/* cursor color 2: noir */
	d->cr1 = 0x01;
	d->cr0 = 0x82;
	d->cr2 = 0;
	d->cr2 = 0;
	d->cr2 = 0;
	/* cursor color 3: schwarz */
	d->cr1 = 0x01;
	d->cr0 = 0x83;
	d->cr2 = 0;
	d->cr2 = 0;
	d->cr2 = 0;
	/* initialize with all-transparent cursor */
	memset(zbuf, 0, sizeof zbuf);
	hwcursset(zbuf, zbuf, 0, 0);
	/* enable both planes of cursor */
	d->cr1 = 0x03;
	d->cr0 = 0x00;
	d->cr2 = 0xc0;
.
140d
133,134c
	window.min = Pt(100, 100);
	window.max = add(window.min, Pt(10+w*120, 10+h*60));
.
131d
125,128c
	gtexture(&gscreen, gscreen.r, &bgrnd, S);
.
123c
	Dac *d;
	ulong zbuf[16];
.
120a
gborder(GBitmap *l, Rectangle r, int i, Fcode c)
{
	if(i < 0){
		r = inset(r, i);
		i = -i;
	}
	gbitblt(l, r.min, l, Rect(r.min.x, r.min.y, r.max.x, r.min.y+i), c);
	gbitblt(l, Pt(r.min.x, r.max.y-i),
		l, Rect(r.min.x, r.max.y-i, r.max.x, r.max.y), c);
	gbitblt(l, Pt(r.min.x, r.min.y+i),
		l, Rect(r.min.x, r.min.y+i, r.min.x+i, r.max.y-i), c);
	gbitblt(l, Pt(r.max.x-i, r.min.y+i),
		l, Rect(r.max.x-i, r.min.y+i, r.max.x, r.max.y-i), c);
}

void
.
115,118d
110a
Cursor fatarrow = {
	{ -1, -1 },
	{
		0xff, 0xff, 0x80, 0x01, 0x80, 0x02, 0x80, 0x0c, 
		0x80, 0x10, 0x80, 0x10, 0x80, 0x08, 0x80, 0x04, 
		0x80, 0x02, 0x80, 0x01, 0x80, 0x02, 0x8c, 0x04, 
		0x92, 0x08, 0x91, 0x10, 0xa0, 0xa0, 0xc0, 0x40, 
	},
	{
		0x00, 0x00, 0x7f, 0xfe, 0x7f, 0xfc, 0x7f, 0xf0, 
		0x7f, 0xe0, 0x7f, 0xe0, 0x7f, 0xf0, 0x7f, 0xf8, 
		0x7f, 0xfc, 0x7f, 0xfe, 0x7f, 0xfc, 0x73, 0xf8, 
		0x61, 0xf0, 0x60, 0xe0, 0x40, 0x40, 0x00, 0x00, 
	},
};

.
106,107c
	4,
	3,
	{ 0, 0, 1, 1 },
	{ 0, 0, 1, 1 },
.
104c
	4,
	1,
	{0, 0, 64, 64},
	{0, 0, 64, 64}
};

uchar bdata[] =
{
	0xC0,
};

GBitmap bgrnd =
{
	(ulong*)bdata,
.
102c
	0,		/* base filled in by malloc when needed */
.
100c
static GBitmap hwcursor=
.
92,96c
	512,
	3,
	{ 0, 0, 1599, 1239 },
	{ 0, 0, 1599, 1239 },
.
90a
	Screenvirt+0x00017924,
.
88a
struct{
	Point	pos;
	int	bwid;
}out;

Lock	screenlock;

.
87a
static	ulong		rep(ulong, int);
.
61,85d
59c
char s1[] = { 0x40, 0x00, 0xC0, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
.
38,56c
	uchar	pad0[7];
	uchar	cr0;
	uchar	pad1[7];
	uchar	cr1;
	uchar	pad2[7];
	uchar	cr2;
	uchar	pad3[7];
	uchar	cr3;
.
35,36c
#define DAC	((Dac*)BTDac)
typedef struct Dac Dac;
struct Dac
.
13,33c
#define	MINX	8
.
11a
#include	"screen.h"
.
## diffname carrera/screen.c 1994/0211
## diff -e /n/fornaxdump/1994/0210/sys/src/brazil/carrera/screen.c /n/fornaxdump/1994/0211/sys/src/brazil/carrera/screen.c
30c
char s1[] = { 0x00, 0x00, 0xC0, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
.
## diffname carrera/screen.c 1994/0213
## diff -e /n/fornaxdump/1994/0211/sys/src/brazil/carrera/screen.c /n/fornaxdump/1994/0213/sys/src/brazil/carrera/screen.c
459c
	x += 371;		/* adjusted by experiment */
.
45c
	Screenvirt+0x00017918,
.
## diffname carrera/screen.c 1994/0215
## diff -e /n/fornaxdump/1994/0213/sys/src/brazil/carrera/screen.c /n/fornaxdump/1994/0215/sys/src/brazil/carrera/screen.c
122a
	memset(Screenvirt, 0, 3*1024*1024);

.
## diffname carrera/screen.c 1994/0216
## diff -e /n/fornaxdump/1994/0215/sys/src/brazil/carrera/screen.c /n/fornaxdump/1994/0216/sys/src/brazil/carrera/screen.c
133a
	for(i = 0; i < h+6; i += 2) {
		y = window.min.y+i;
		gsegment(&gscreen, Pt(window.min.x, y), Pt(window.max.x, y), ~0, F);
	}
	p = add(window.min, Pt(10, 2));
	gsubfstring(&gscreen, p, &defont0, "Brazil Console ", S);
	window.min.y += h+6;
.
132a
	gborder(&gscreen, window, 4, F);
.
131a
	gbitblt(&gscreen, add(window.min, Pt(5, 5)), &gscreen, window, F);
.
130c
	window.max = add(window.min, Pt(10+w*80, 10+h*40));
.
123c
	memset((void*)Screenvirt, 0xff, 3*1024*1024);
.
120a
	Point p;
	int i, y;
.
## diffname carrera/screen.c 1994/0227
## diff -e /n/fornaxdump/1994/0216/sys/src/brazil/carrera/screen.c /n/fornaxdump/1994/0227/sys/src/brazil/carrera/screen.c
132c
	window.max = add(window.min, Pt(10+w*120, 10+h*60));
.
## diffname carrera/screen.c 1994/0228
## diff -e /n/fornaxdump/1994/0227/sys/src/brazil/carrera/screen.c /n/fornaxdump/1994/0228/sys/src/brazil/carrera/screen.c
472c
	x += 295;		/* adjusted by experiment */
.
49,50c
	{ 0, 0, 1599, 1240 },
	{ 0, 0, 1599, 1240 },
.
45c
	Screenvirt+0x000178cc,
.
## diffname carrera/screen.c 1994/0306
## diff -e /n/fornaxdump/1994/0228/sys/src/brazil/carrera/screen.c /n/fornaxdump/1994/0306/sys/src/brazil/carrera/screen.c
472c
	x += 380;		/* adjusted by experiment */
.
49,50c
	{ 0, 0, 1599, 1239 },
	{ 0, 0, 1599, 1239 },
.
45c
	Screenvirt+0x00017924,
.
## diffname carrera/screen.c 1994/0401
## diff -e /n/fornaxdump/1994/0306/sys/src/brazil/carrera/screen.c /n/fornaxdump/1994/0401/sys/src/brazil/carrera/screen.c
297a
		}
.
296c
		if(cursor.x-w >= 0){
			r.min.x = cursor.x-w;
			r.max.x = cursor.x;
			r.min.y = cursor.y;
			r.max.y = cursor.y+defont0.height;
			gbitblt(&gscreen, r.min, &gscreen, r, Zero);
.
278a
	Rectangle r;
.
49,50c
	{ 0, 0, 1600, 1240 },
	{ 0, 0, 1600, 1240 },
.
## diffname carrera/screen.c 1994/0407
## diff -e /n/fornaxdump/1994/0401/sys/src/brazil/carrera/screen.c /n/fornaxdump/1994/0407/sys/src/brazil/carrera/screen.c
516,559c
	for(y=r.min.y; y<r.max.y; y++){
		memmove(q, data, tl);
		q += gscreen.width*sizeof(ulong);
		data += l;
	}
.
514d
508c
	int y;
.
502a
 * gscreen.ldepth is known to be >= 3
.
## diffname carrera/screen.c 1994/0412
## diff -e /n/fornaxdump/1994/0407/sys/src/brazil/carrera/screen.c /n/fornaxdump/1994/0412/sys/src/brazil/carrera/screen.c
517a
		q += gscreen.width*sizeof(ulong);
		data += l;
	}
	unlock(&screenlock);
}

/*
 * get a tile from screen memory.
 * tile is at location r, first pixel in *data. 
 * tl is length of scan line to insert,
 * l is amount to advance data after each scan line.
 * gscreen.ldepth is known to be >= 3
 */
void
screenunload(Rectangle r, uchar *data, int tl, int l, int dolock)
{
	uchar *q;
	int y;

	USED(dolock);

	if(!rectclip(&r, gscreen.r) || tl<=0)
		return;

	lock(&screenlock);
	q = gbaddr(&gscreen, r.min);
	for(y=r.min.y; y<r.max.y; y++){
		memmove(data, q, tl);
.
510a
	USED(dolock);

.
506c
screenload(Rectangle r, uchar *data, int tl, int l, int dolock)
.
## diffname carrera/screen.c 1994/0413
## diff -e /n/fornaxdump/1994/0412/sys/src/brazil/carrera/screen.c /n/fornaxdump/1994/0413/sys/src/brazil/carrera/screen.c
545c
	q = byteaddr(&gscreen, r.min);
.
541,543d
531c
 * gscreen.ldepth is known to be >= 3.
 * screenunload() doesn't clip, so must be
 * called correctly.
.
517c
	q = byteaddr(&gscreen, r.min);
.
446c
			point(&hwcursor, add(Pt(x,y), org), dpix, S);
.
309c
		cursor = subfstring(&gscreen, cursor, &defont0, buf, S);
.
302c
			bitblt(&gscreen, r.min, &gscreen, r, Zero);
.
271c
	bitblt(&gscreen, r.min, &gscreen, r, Zero);
.
269c
	bitblt(&gscreen, window.min, &gscreen, r, S);
.
243,244c
	bitblt(&gscreen, Pt(0, 0), &gscreen, gscreen.r, 0);
.
143c
	subfstring(&gscreen, p, &defont0, "Brazil Console ", S);
.
140c
		bitblt(&gscreen, Pt(window.min.x, y),
			&gscreen, Rect(window.min.x, y, window.max.x, y+1), F);
.
134,136c
	bitblt(&gscreen, add(window.min, Pt(5, 5)), &gscreen, window, F);
	bitblt(&gscreen, window.min, &gscreen, window, Zero);
	border(&gscreen, window, 4, F);
.
127c
	texture(&gscreen, gscreen.r, &bgrnd, S);
.
102,117d
74,76d
70a
	{ 0, 0, 1, 1 },
	{ 0, 0, 1, 1 },
	3,
.
69c
Bitmap bgrnd =
.
59,61c
	0,
.
55a
	{0, 0, 64, 64},
	{0, 0, 64, 64},
	1,
.
54c
static Bitmap hwcursor=
.
48,50d
44a
	{ 0, 0, 1600, 1240 },
	{ 0, 0, 1600, 1240 },
	3,
.
43c
Bitmap	gscreen =
.
32,33c
extern	Subfont	defont0;
.
11d
## diffname carrera/screen.c 1994/0414
## diff -e /n/fornaxdump/1994/0413/sys/src/brazil/carrera/screen.c /n/fornaxdump/1994/0414/sys/src/brazil/carrera/screen.c
466,469c
	d->cr2 = p.x&0xFF;
	d->cr2 = (p.x>>8)&0xF;
	d->cr2 = p.y&0xFF;
	d->cr2 = (p.y>>8)&0xF;

	if(dolock)
		unlock(&cursor);
.
462,463c
	if(dolock)
		lock(&cursor);

	p.x += 380;		/* adjusted by experiment */
	p.y += 11;		/* adjusted by experiment */
.
459a
	p = mousexy();

.
458a
	Point p;
.
456c
cursoron(int dolock)
.
411c
setcursor(ulong *s, ulong *c, int offx, int offy)
.
292c
		curpos = subfstring(&gscreen, curpos, &defont0, buf, S);
.
290c
		if(curpos.x >= window.max.x-w)
.
286c
			curpos.x -= w;
.
280,284c
		if(curpos.x-w >= 0){
			r.min.x = curpos.x-w;
			r.max.x = curpos.x;
			r.min.y = curpos.y;
			r.max.y = curpos.y+defont0.height;
.
277c
		curpos.x += pos*w;
.
275c
		pos = (curpos.x-window.min.x)/w;
.
272c
		curpos.x = window.min.x;
.
268c
		curpos.y += h;
.
266c
		if(curpos.y+h >= window.max.y)
.
255c
	curpos.y -= o;
.
154c
	setcursor(zbuf, zbuf, 0, 0);
.
132d
129c
	curpos = window.min;
.
96c
static Point curpos;
.
## diffname carrera/screen.c 1994/0520
## diff -e /n/fornaxdump/1994/0414/sys/src/brazil/carrera/screen.c /n/fornaxdump/1994/0520/sys/src/brazil/carrera/screen.c
422c
	org = add(Pt(32,32), curs->offset); 
.
417a
	for(i=0; i<16; i++){
		p = (uchar*)&s[i];
		*p = curs->set[2*i];
		*(p+1) = curs->set[2*i+1];
		p = (uchar*)&c[i];
		*p = curs->clr[2*i];
		*(p+1) = curs->clr[2*i+1];
	}
.
416a
	ulong s[16], c[16];
.
415c
	uchar ylow, yhigh, *p;
.
413c
	int x, y, i;
.
410c
setcursor(Cursor *curs)
.
152,153c
	memset(&zero, 0, sizeof zero);
	setcursor(&zero);
.
106c
	Cursor zero;
.
## diffname carrera/screen.c 1994/0521
## diff -e /n/fornaxdump/1994/0520/sys/src/brazil/carrera/screen.c /n/fornaxdump/1994/0521/sys/src/brazil/carrera/screen.c
223,224d
98d
79,94d
## diffname carrera/screen.c 1994/0525
## diff -e /n/fornaxdump/1994/0521/sys/src/brazil/carrera/screen.c /n/fornaxdump/1994/0525/sys/src/brazil/carrera/screen.c
457c
	p.x += 296;		/* adjusted by experiment */
.
46c
	Screenvirt+0x000178D0,
.
43,44c
	{ 0, 0, 1597, 1234 },
	{ 0, 0, 1597, 1234 },
.
## diffname carrera/screen.c 1994/0624
## diff -e /n/fornaxdump/1994/0525/sys/src/brazil/carrera/screen.c /n/fornaxdump/1994/0624/sys/src/brazil/carrera/screen.c
467a
	return 0;
.
444c
int
.
## diffname carrera/screen.c 1994/0909
## diff -e /n/fornaxdump/1994/0624/sys/src/brazil/carrera/screen.c /n/fornaxdump/1994/0909/sys/src/brazil/carrera/screen.c
369c
	d->cr0 = revtab0[255 - (p & 0xFF)];
.
351c
	d->cr0 = revtab0[255 - (p & 0xFF)];
.
212,220d
202,204d
177,178c
	setcolor(170, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA);
	setcolor(85, 0x55555555, 0x55555555, 0x55555555);
.
172,174c
		r = rep((i>>5) & 7, 3);
		g = rep((i>>2) & 7, 3);
		b = rep(i & 3, 2);
.
## diffname carrera/screen.c 1995/0531
## diff -e /n/fornaxdump/1994/0909/sys/src/brazil/carrera/screen.c /n/fornaxdump/1995/0531/sys/src/brazil/carrera/screen.c
428a
	
.
409a

.
361a

	unlock(&cursor);

.
356a
	/* to protect DAC from mouse movement */
	lock(&cursor);

.
346a

	unlock(&cursor);
.
338a
	/* to protect DAC from mouse movement */
	lock(&cursor);

.
## diffname carrera/screen.c 1996/0216
## diff -e /n/fornaxdump/1995/0531/sys/src/brazil/carrera/screen.c /n/fornaxdump/1996/0216/sys/src/brazil/carrera/screen.c
171,178c
	graphicscmap(0);
.
148d
## diffname carrera/screen.c 1996/0219
## diff -e /n/fornaxdump/1996/0216/sys/src/brazil/carrera/screen.c /n/fornaxdump/1996/0219/sys/src/brazil/carrera/screen.c
65c
	0xa0,
.
## diffname carrera/screen.c 1997/0129
## diff -e /n/fornaxdump/1996/0219/sys/src/brazil/carrera/screen.c /n/fornaxdump/1997/0129/sys/src/brazil/carrera/screen.c
93d
91a
	for(y=gscreen.r.min.y; y<gscreen.r.max.y; y++)
		memset(byteaddr(&gscreen, Pt(gscreen.r.min.x, y)), 0xa0, Dx(gscreen.r));
.
63,78d
## diffname carrera/screen.c 1997/0327
## diff -e /n/fornaxdump/1997/0129/sys/src/brazil/carrera/screen.c /n/emeliedump/1997/0327/sys/src/brazil/carrera/screen.c
248c
	if(!islo()) {
.
## diffname carrera/screen.c 1997/1101
## diff -e /n/emeliedump/1997/0327/sys/src/brazil/carrera/screen.c /n/emeliedump/1997/1101/sys/src/brazil/carrera/screen.c
419c
	free(hwcursor.data->data);
.
412c
		d->cr2 = ((uchar *)hwcursor.data->data)[x];
.
394c
			/* point(&hwcursor, addpt(Pt(x,y), org), dpix, S), by hand */
			*byteaddr(&hwcursor, Pt(x+org.x, y+org.y)) |= dpix<<(6-(2*((x+org.x)&3)));
.
388,390c
	org = addpt(Pt(32,32), curs->offset); 
	for(y = 0; y < 16; y++)
		for(x = 0; x < 16; x++) {
.
384,385c
	hwcursor.data->data = (ulong *)malloc(1024);
	if(hwcursor.data->data == 0)
.
237c

		*xp++ = curpos.x;
		r = Rect(curpos.x, curpos.y, curpos.x+w, curpos.y + h);
		memimagedraw(&gscreen, r, back, back->r.min, memones, back->r.min);
		memimagestring(&gscreen, curpos, &conscol, memdefont, buf);
		curpos.x += w;
.
234a
		p = memsubfontwidth(memdefont, buf);
		w = p.x;

.
225,232c
		if(xp <= xbuf)
			break;
		xp--;
		r = Rect(*xp, curpos.y, curpos.x, curpos.y + h);
		memimagedraw(&gscreen, r, back, back->r.min, memones, back->r.min);
		curpos.x = *xp;
.
221a
		r = Rect(curpos.x, curpos.y, curpos.x+pos*w, curpos.y + h);
		memimagedraw(&gscreen, r, back, back->r.min, memones, back->r.min);
.
219a
		p = memsubfontwidth(memdefont, " ");
		w = p.x;
		*xp++ = curpos.x;
.
216a
		xp = xbuf;
.
208a
	if(xp < xbuf || xp >= &xbuf[sizeof(xbuf)])
		xp = xbuf;

.
207a
	static int *xp;
	static int xbuf[256];
.
206c
	Point p;
	int w, pos;
.
202a
/* 
 * export screen to devdraw
 */
ulong*
attachscreen(Rectangle *r, int *ld, int *width)
{
	*r = gscreen.r;
	*ld = gscreen.ldepth;
	*width = gscreen.width;

	return gscreendata.data;
}

/*
 * update screen (no-op: frame buffer is direct-mapped)
 */
void
flushmemscreen(Rectangle)
{
}

.
199c
	memimagedraw(&gscreen, r, back, ZP, memones, ZP);

.
195,197c
	o = 8*h;
	r = Rpt(window.min, Pt(window.max.x, window.max.y-o));
	p = Pt(window.min.x, window.min.y+o);
	memimagedraw(&gscreen, r, &gscreen, p, memones, p);
.
192a
	Point p;
.
184c
	out.bwid = memdefont->info[' '].width;
.
181c
	memdefont = getmemdefont();

.
155c
	drawcmap(0);
.
85,95c
	memimagedraw(&gscreen, window, memones, ZP, memones, ZP);
	window = insetrect(window, 4);
	memimagedraw(&gscreen, window, back, ZP, memones, ZP);
	/* hack to get a grey color */
	memzeros->data->data[0] = 0x33333333;
	memimagedraw(&gscreen, Rect(window.min.x, window.min.y,
			window.max.x, window.min.y+h+5+6), memzeros, ZP, memones, ZP);
	memzeros->data->data[0] = 0;
	window = insetrect(window, 5);

	greet = " Brazil Console: Draw version ";
	p = addpt(window.min, Pt(10, 0));
	q = memsubfontwidth(memdefont, greet);
	memimagestring(&gscreen, p, &conscol, memdefont, greet);
.
83c
	window.max = addpt(window.min, Pt(10+w*120, 10+h*60));
.
79,80c
	w = memdefont->info[' '].width;
	h = memdefont->height;
.
77c
		memset(byteaddr(&gscreen, Pt(gscreen.r.min.x, y)), 0xba, Dx(gscreen.r));
.
73a
	char *greet;
.
71,72c
	Point p, q;
	int y;
.
62a
ulong	consbits = ~0;
Memdata	consdata = {
	nil,
	&consbits
};
Memimage conscol =
{
	{ 0, 0, 1, 1 },
	{ -100000, -100000, 100000, 100000 },
	3,
	1,
	&consdata,
	0,
	1
};

ulong	onesbits = ~0;
Memdata	onesdata = {
	nil,
	&onesbits,
};
Memimage	xones =
{
	{ 0, 0, 1, 1 },
	{ -100000, -100000, 100000, 100000 },
	3,
	1,
	&onesdata,
	0,
	1
};
Memimage *memones = &xones;

ulong	zerosbits = 0;
Memdata	zerosdata = {
	nil,
	&zerosbits,
};
Memimage	xzeros =
{
	{ 0, 0, 1, 1 },
	{ -100000, -100000, 100000, 100000 },
	3,
	1,
	&zerosdata,
	0,
	1
};
Memimage *memzeros = &xzeros;

ulong	backbits = (Backgnd<<24)|(Backgnd<<16)|(Backgnd<<8)|Backgnd;
Memdata	backdata = {
	nil,
	&backbits
};
Memimage	xback =
{
	{ 0, 0, 1, 1 },
	{ -100000, -100000, 100000, 100000 },
	3,
	1,
	&backdata,
	0,
	1
};
Memimage *back = &xback;

.
58a
	&hwcursordata,		/* base filled in by malloc when needed */
	0,
.
57d
53a
	{ 0, 0, 1597, 1234 },	/* r */
	{ 0, 0, 1597, 1234 },	/* clipr */
	3,	/* ldepth */
	0,	/* repl */
	&gscreendata,	/* data */
	0,	/* zero */
	512,	/* width */
	0,	/* layer */
};

static Memimage hwcursor=
{
.
52c
Memimage gscreen =
.
43,49c
	nil,
	(ulong*)(Screenvirt+0x000178D0),
	1,
.
41c
Point	ZP = {0, 0};

static Memdata	hwcursordata;

static Memdata gscreendata =
.
31c
		Memsubfont	*memdefont;
.
29a
#define	Backgnd		0x00
.
10c
#define	Image	IMAGE
#include	<draw.h>
#include	<memdraw.h>
.
## diffname carrera/screen.c 1998/0109
## diff -e /n/emeliedump/1997/1101/sys/src/brazil/carrera/screen.c /n/emeliedump/1998/0109/sys/src/brazil/carrera/screen.c
312a
	USED(r);
/*
	DEBUG version flashes the screen to indicate what's being painted
	Memimage *x;
	int i;

	if(Dx(r)<=0 || Dy(r)<=0)
		return;
	x = allocmemimage(r, 3);
	memimagedraw(x, r, &gscreen, r.min, memones, r.min);
	memimagedraw(&gscreen, r, memones, r.min, memones, r.min);
	for(i=1000000; --i>0; );
	memimagedraw(&gscreen, r, x, r.min, memones, r.min);
	freememimage(x);
*/
.
311c
flushmemscreen(Rectangle r)
.
302a
	*softscreen = 0;
.
298c
attachscreen(Rectangle *r, int *ld, int *width, int *softscreen)
.
## diffname carrera/screen.c 1998/0209
## diff -e /n/emeliedump/1998/0109/sys/src/brazil/carrera/screen.c /n/emeliedump/1998/0209/sys/src/brazil/carrera/screen.c
145a
Cursor	arrow = {
	{ -1, -1 },
	{ 0xFF, 0xFF, 0x80, 0x01, 0x80, 0x02, 0x80, 0x0C, 
	  0x80, 0x10, 0x80, 0x10, 0x80, 0x08, 0x80, 0x04, 
	  0x80, 0x02, 0x80, 0x01, 0x80, 0x02, 0x8C, 0x04, 
	  0x92, 0x08, 0x91, 0x10, 0xA0, 0xA0, 0xC0, 0x40, 
	},
	{ 0x00, 0x00, 0x7F, 0xFE, 0x7F, 0xFC, 0x7F, 0xF0, 
	  0x7F, 0xE0, 0x7F, 0xE0, 0x7F, 0xF0, 0x7F, 0xF8, 
	  0x7F, 0xFC, 0x7F, 0xFE, 0x7F, 0xFC, 0x73, 0xF8, 
	  0x61, 0xF0, 0x60, 0xE0, 0x40, 0x40, 0x00, 0x00, 
	},
};

.
## diffname carrera/screen.c 1998/0630
## diff -e /n/emeliedump/1998/0209/sys/src/brazil/carrera/screen.c /n/emeliedump/1998/0630/sys/src/brazil/carrera/screen.c
597c
	p.y += 9;		/* adjusted by experiment */
.
551,552c
			spix = (s[y]>>(15-x))&1;
			cpix = (c[y]>>(15-x))&1;
.
534c
	ushort s[16], c[16];
.
## diffname carrera/screen.c 1999/0119
## diff -e /n/emeliedump/1998/0630/sys/src/brazil/carrera/screen.c /n/emeliedump/1999/0119/sys/src/brazil/carrera/screen.c
12a
#include	<cursor.h>
.
## diffname carrera/screen.c 1999/0326
## diff -e /n/emeliedump/1999/0119/sys/src/brazil/carrera/screen.c /n/emeliedump/1999/0326/sys/src/brazil/carrera/screen.c
605a
	splx(s);
.
595a
	s = splhi();
.
588a
	int s;
.
## diffname carrera/screen.c 1999/0327
## diff -e /n/emeliedump/1999/0326/sys/src/brazil/carrera/screen.c /n/emeliedump/1999/0327/sys/src/brazil/carrera/screen.c
608d
597d
589d
## diffname carrera/screen.c 1999/1005
## diff -e /n/emeliedump/1999/0327/sys/src/brazil/carrera/screen.c /n/emeliedump/1999/1005/sys/src/brazil/carrera/screen.c
669c
		q += gscreen->width*sizeof(ulong);
.
666c
	q = byteaddr(gscreen, r.min);
.
642c
		q += gscreen->width*sizeof(ulong);
.
639c
	q = byteaddr(gscreen, r.min);
.
635c
	if(!rectclip(&r, gscreen->r) || tl<=0)
.
614c
	return gscreen->depth;
.
580,581d
574c
		d->cr2 = hwcursor->data->bdata[x];
.
556c
			*byteaddr(hwcursor, Pt(x+org.x, y+org.y)) |= (dpix<<(6-(2*((x+org.x)&3))));
.
545,547c
	memset(hwcursor->data->bdata, 0, sizeof(long)*hwcursor->width*Dy(hwcursor->r));
.
396,397c
		memimagedraw(gscreen, r, back, back->r.min, nil, back->r.min);
		memimagestring(gscreen, curpos, conscol, memdefont, buf);
.
384c
		memimagedraw(gscreen, r, back, back->r.min, nil, back->r.min);
.
376c
		memimagedraw(gscreen, r, back, back->r.min, nil, back->r.min);
.
341c
	memimagedraw(&gscreen, r, x, r.min, memopaque, r.min);
.
338,339c
	memimagedraw(x, r, &gscreen, r.min, memopaque, r.min);
	memimagedraw(&gscreen, r, memblack, r.min, memopaque, r.min);
.
320c
	return gscreendata.bdata;
.
315,317c
	*r = gscreen->r;
	*d = gscreen->depth;
	*chan = gscreen->chan;
	*width = gscreen->width;
.
312,313c
uchar*
attachscreen(Rectangle *r, ulong *chan, int* d, int *width, int *softscreen)
.
304c
	memimagedraw(gscreen, r, back, ZP, nil, ZP);
.
302c
	memimagedraw(gscreen, r, gscreen, p, nil, p);
.
282a
	memimageinit();
.
257c
	drawcmap(1);
.
197c
	memimagestring(gscreen, p, conscol, memdefont, greet);
.
194c
	greet = " Brazil Console: New Draw version ";
.
186,191c
	memimagedraw(gscreen, window, memwhite, ZP, memopaque, ZP);

	/* a lot of work to get a grey color */
	grey = allocmemimage(Rect(0,0,1,1), CMAP8);
	grey->flags |= Frepl;
	grey->clipr = gscreen->r;
	grey->data->bdata[0] = 0xAA;
	memimagedraw(gscreen, Rect(window.min.x, window.min.y,
			window.max.x, window.min.y+h+5+6), grey, ZP, nil, ZP);
	freememimage(grey);
.
184c
	memimagedraw(gscreen, window, memblack, ZP, memopaque, ZP);
.
177a
	memset((void*)Screenvirt, 0, 3*1024*1024);
	memfillcolor(gscreen, 0x444488FF);

.
174,176c
	gscreen = &xgscreen;
	memsetchan(gscreen, CMAP8);
	hwcursor = allocmemimage(Rect(0,0,64,64), GREY2);
	memsetchan(hwcursor, GREY2);
	
	back = memwhite;
	conscol = memblack;
.
172a
	Memimage *grey;
.
170d
163a
int drawdebug;
.
80,146d
68,78c
Memimage *gscreen;
Memimage *conscol;
Memimage *back;
Memimage *hwcursor;
.
65a
	Frepl,	/* flags */
.
60,61c
	8,	/* depth */
	1,	/* nchan */
	CMAP8,	/* chan */
	nil,	/* cmap */
.
56c
static Memimage xgscreen =
.
47,48d
33c
#define	Backgnd		0xFF	/* white */
.
## diffname carrera/screen.c 1999/1013
## diff -e /n/emeliedump/1999/1005/sys/src/brazil/carrera/screen.c /n/emeliedump/1999/1013/sys/src/brazil/carrera/screen.c
444c
	d->cr0 = revtab0[p & 0xFF];
.
421c
	d->cr0 = revtab0[p & 0xFF];
.
196c
	drawcmap();
.
## diffname carrera/screen.c 1999/1031
## diff -e /n/emeliedump/1999/1013/sys/src/brazil/carrera/screen.c /n/emeliedump/1999/1031/sys/src/9/carrera/screen.c
133c
	greet = " Plan 9 Console ";
.
## diffname carrera/screen.c 2000/0104
## diff -e /n/emeliedump/1999/1031/sys/src/9/carrera/screen.c /n/emeliedump/2000/0104/sys/src/9/carrera/screen.c
338c
		memimagestring(gscreen, curpos, conscol, ZP, memdefont, buf);
.
136c
	memimagestring(gscreen, p, conscol, ZP, memdefont, greet);
.
## diffname carrera/screen.c 2000/0504
## diff -e /n/emeliedump/2000/0104/sys/src/9/carrera/screen.c /n/emeliedump/2000/0504/sys/src/9/carrera/screen.c
610a

void
blankscreen(int)
{
}
.
## diffname carrera/screen.c 2000/1021
## diff -e /n/emeliedump/2000/0504/sys/src/9/carrera/screen.c /n/emeliedump/2000/1021/sys/src/9/carrera/screen.c
66c
	0,	/* flags */
.
11c
#include	<draw.h>
.
## diffname carrera/screen.c 2000/1102
## diff -e /n/emeliedump/2000/1021/sys/src/9/carrera/screen.c /n/emeliedump/2000/1102/sys/src/9/carrera/screen.c
326a
		break;
	case '\0':
.
315a
		*xp++ = curpos.x;
.
313c
		if(curpos.x >= window.max.x-8*w)
			screenputc("\n");

.
11c
#include	<draw.h>
.
## diffname carrera/screen.c 2001/0527 # deleted
## diff -e /n/emeliedump/2000/1102/sys/src/9/carrera/screen.c /n/emeliedump/2001/0527/sys/src/9/carrera/screen.c
1,620d