Subversion Repositories planix.SVN

#include	<u.h>

#include	<libc.h>

#include	"compat.h"

#include	"error.h"

#define	Image	IMAGE

#include	<draw.h>

#include	<memdraw.h>

#include	<cursor.h>

#include	"screen.h"

typedef struct Mouseinfo	Mouseinfo;

typedef struct Mousestate	Mousestate;

struct Mousestate

{

	Point	xy;			/* mouse.xy */

	int	buttons;		/* mouse.buttons */

	ulong	counter;	/* increments every update */

	ulong	msec;	/* time of last event */

};

struct Mouseinfo

{

	Mousestate;

	int	dx;

	int	dy;

	int	track;		/* dx & dy updated */

	int	redraw;		/* update cursor on screen */

	ulong	lastcounter;	/* value when /dev/mouse read */

	Rendez	r;

	Ref;

	QLock;

	int	open;

	int	acceleration;

	int	maxacc;

	Mousestate 	queue[16];	/* circular buffer of click events */

	int	ri;	/* read index into queue */

	int	wi;	/* write index into queue */

	uchar	qfull;	/* queue is full */

};

Mouseinfo	mouse;

Cursorinfo	cursor;

int		mouseshifted;

Cursor		curs;

void	Cursortocursor(Cursor*);

int	mousechanged(void*);

static void mouseclock(void);

enum{

	Qdir,

	Qcursor,

	Qmouse,

};

static Dirtab mousedir[]={

	".",	{Qdir, 0, QTDIR},	0,			DMDIR|0555,

	"cursor",	{Qcursor},	0,			0666,

	"mouse",	{Qmouse},	0,			0666,

};

static uchar buttonmap[8] = {

	0, 1, 2, 3, 4, 5, 6, 7,

};

static int mouseswap;

extern	Memimage*	gscreen;

extern	void mousewarpnote(Point);

static void

mousereset(void)

{

	curs = arrow;

	Cursortocursor(&arrow);

}

static void

mouseinit(void)

{

	cursoron(1);

}

static Chan*

mouseattach(char *spec)

{

	return devattach('m', spec);

}

static Walkqid*

mousewalk(Chan *c, Chan *nc, char **name, int nname)

{

	Walkqid *wq;

	wq = devwalk(c, nc, name, nname, mousedir, nelem(mousedir), devgen);

	if(wq != nil && wq->clone != c && (wq->clone->qid.type&QTDIR)==0)

		incref(&mouse);

	return wq;

}

static int

mousestat(Chan *c, uchar *db, int n)

{

	return devstat(c, db, n, mousedir, nelem(mousedir), devgen);

}

static Chan*

mouseopen(Chan *c, int omode)

{

	switch((ulong)c->qid.path){

	case Qdir:

		if(omode != OREAD)

			error(Eperm);

		break;

	case Qmouse:

		lock(&mouse);

		if(mouse.open){

			unlock(&mouse);

			error(Einuse);

		}

		mouse.open = 1;

		mouse.ref++;

		unlock(&mouse);

		break;

	default:

		incref(&mouse);

	}

	c->mode = openmode(omode);

	c->flag |= COPEN;

	c->offset = 0;

	return c;

}

static void

mousecreate(Chan*, char*, int, ulong)

{

	error(Eperm);

}

static void

mouseclose(Chan *c)

{

	if((c->qid.type&QTDIR)==0 && (c->flag&COPEN)){

		lock(&mouse);

		if(c->qid.path == Qmouse)

			mouse.open = 0;

		if(--mouse.ref == 0){

			cursoroff(1);

			curs = arrow;

			Cursortocursor(&arrow);

			cursoron(1);

		}

		unlock(&mouse);

	}

}

static long

mouseread(Chan *c, void *va, long n, vlong off)

{

	char buf[4*12+1];

	uchar *p;

	static int map[8] = {0, 4, 2, 6, 1, 5, 3, 7 };

	ulong offset = off;

	Mousestate m;

	int b;

	p = va;

	switch((ulong)c->qid.path){

	case Qdir:

		return devdirread(c, va, n, mousedir, nelem(mousedir), devgen);

	case Qcursor:

		if(offset != 0)

			return 0;

		if(n < 2*4+2*2*16)

			error(Eshort);

		n = 2*4+2*2*16;

		lock(&cursor);

		BPLONG(p+0, curs.offset.x);

		BPLONG(p+4, curs.offset.y);

		memmove(p+8, curs.clr, 2*16);

		memmove(p+40, curs.set, 2*16);

		unlock(&cursor);

		return n;

	case Qmouse:

		while(mousechanged(0) == 0)

			rendsleep(&mouse.r, mousechanged, 0);

		mouse.qfull = 0;

		/*

		 * No lock of the indicies is necessary here, because ri is only

		 * updated by us, and there is only one mouse reader

		 * at a time.  I suppose that more than one process

		 * could try to read the fd at one time, but such behavior

		 * is degenerate and already violates the calling

		 * conventions for sleep above.

		 */

		if(mouse.ri != mouse.wi){

			m = mouse.queue[mouse.ri];

			if(++mouse.ri == nelem(mouse.queue))

				mouse.ri = 0;

		} else {

			lock(&cursor);

			m = mouse.Mousestate;

			unlock(&cursor);

		}

		b = buttonmap[m.buttons&7];

		/* put buttons 4 and 5 back in */

		b |= m.buttons & (3<<3);

		sprint(buf, "m%11d %11d %11d %11lud",

			m.xy.x, m.xy.y,

			b,

			m.msec);

		mouse.lastcounter = m.counter;

		if(n > 1+4*12)

			n = 1+4*12;

		memmove(va, buf, n);

		return n;

	}

	return 0;

}

static void

setbuttonmap(char* map)

{

	int i, x, one, two, three;

	one = two = three = 0;

	for(i = 0; i < 3; i++){

		if(map[i] == 0)

			error(Ebadarg);

		if(map[i] == '1'){

			if(one)

				error(Ebadarg);

			one = 1<<i;

		}

		else if(map[i] == '2'){

			if(two)

				error(Ebadarg);

			two = 1<<i;

		}

		else if(map[i] == '3'){

			if(three)

				error(Ebadarg);

			three = 1<<i;

		}

		else

			error(Ebadarg);

	}

	if(map[i])

		error(Ebadarg);

	memset(buttonmap, 0, 8);

	for(i = 0; i < 8; i++){

		x = 0;

		if(i & 1)

			x |= one;

		if(i & 2)

			x |= two;

		if(i & 4)

			x |= three;

		buttonmap[x] = i;

	}

}

static long

mousewrite(Chan *c, void *va, long n, vlong)

{

	char *p;

	Point pt;

	char buf[64];

	p = va;

	switch((ulong)c->qid.path){

	case Qdir:

		error(Eisdir);

	case Qcursor:

		cursoroff(1);

		if(n < 2*4+2*2*16){

			curs = arrow;

			Cursortocursor(&arrow);

		}else{

			n = 2*4+2*2*16;

			curs.offset.x = BGLONG(p+0);

			curs.offset.y = BGLONG(p+4);

			memmove(curs.clr, p+8, 2*16);

			memmove(curs.set, p+40, 2*16);

			Cursortocursor(&curs);

		}

		qlock(&mouse);

		mouse.redraw = 1;

		mouseclock();

		qunlock(&mouse);

		cursoron(1);

		return n;

	case Qmouse:

		if(n > sizeof buf-1)

			n = sizeof buf -1;

		memmove(buf, va, n);

		buf[n] = 0;

		p = 0;

		pt.x = strtoul(buf+1, &p, 0);

		if(p == 0)

			error(Eshort);

		pt.y = strtoul(p, 0, 0);

		qlock(&mouse);

		if(ptinrect(pt, gscreen->r)){

			mousetrack(pt.x, pt.y, mouse.buttons, nsec()/(1000*1000LL));

			mousewarpnote(pt);

		}

		qunlock(&mouse);

		return n;

	}

	error(Egreg);

	return -1;

}

Dev mousedevtab = {

	'm',

	"mouse",

	mousereset,

	mouseinit,

	mouseattach,

	mousewalk,

	mousestat,

	mouseopen,

	mousecreate,

	mouseclose,

	mouseread,

	devbread,

	mousewrite,

	devbwrite,

	devremove,

	devwstat,

};

void

Cursortocursor(Cursor *c)

{

	lock(&cursor);

	memmove(&cursor.Cursor, c, sizeof(Cursor));

	setcursor(c);

	unlock(&cursor);

}

static int

scale(int x)

{

	int sign = 1;

	if(x < 0){

		sign = -1;

		x = -x;

	}

	switch(x){

	case 0:

	case 1:

	case 2:

	case 3:

		break;

	case 4:

		x = 6 + (mouse.acceleration>>2);

		break;

	case 5:

		x = 9 + (mouse.acceleration>>1);

		break;

	default:

		x *= mouse.maxacc;

		break;

	}

	return sign*x;

}

static void

mouseclock(void)

{

	lock(&cursor);

	if(mouse.redraw){

		mouse.redraw = 0;

		cursoroff(0);

		mouse.redraw = cursoron(0);

	}

	unlock(&cursor);

}

/*

 *  called at interrupt level to update the structure and

 *  awaken any waiting procs.

 */

void

mousetrack(int x, int y, int b, int msec)

{

	int lastb;

	lastb = mouse.buttons;

	mouse.xy = Pt(x, y);

	mouse.buttons = b;

	mouse.redraw = 1;

	mouse.counter++;

	mouse.msec = msec;

	/*

	 * if the queue fills, we discard the entire queue and don't

	 * queue any more events until a reader polls the mouse.

	 */

	if(!mouse.qfull && lastb != b){	/* add to ring */

		mouse.queue[mouse.wi] = mouse.Mousestate;

		if(++mouse.wi == nelem(mouse.queue))

			mouse.wi = 0;

		if(mouse.wi == mouse.ri)

			mouse.qfull = 1;

	}

	rendwakeup(&mouse.r);

	mouseclock();

}

int

mousechanged(void*)

{

	return mouse.lastcounter != mouse.counter;

}

Point

mousexy(void)

{

	return mouse.xy;

}

void

mouseaccelerate(int x)

{

	mouse.acceleration = x;

	if(mouse.acceleration < 3)

		mouse.maxacc = 2;

	else

		mouse.maxacc = mouse.acceleration;

}