Subversion Repositories planix.SVN

#include	"u.h"

#include	"lib.h"

#include	"dat.h"

#include	"fns.h"

#include	"error.h"

#include	"draw.h"

#include	"memdraw.h"

#include	"screen.h"

int	mousequeue = 1;

Mouseinfo	mouse;

Cursorinfo	cursor;

static int	mousechanged(void*);

enum{

	Qdir,

	Qcursor,

	Qmouse

};

Dirtab mousedir[]={

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

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

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

};

#define	NMOUSE	(sizeof(mousedir)/sizeof(Dirtab))

static Chan*

mouseattach(char *spec)

{

	return devattach('m', spec);

}

static Walkqid*

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

{

	return devwalk(c, nc, name, nname, mousedir, NMOUSE, devgen);

}

static int

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

{

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

}

static Chan*

mouseopen(Chan *c, int omode)

{

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

	case Qdir:

		if(omode != OREAD)

			error(Eperm);

		break;

	case Qmouse:

		lock(&mouse.lk);

		if(mouse.open){

			unlock(&mouse.lk);

			error(Einuse);

		}

		mouse.open = 1;

		unlock(&mouse.lk);

		break;

	}

	c->mode = openmode(omode);

	c->flag |= COPEN;

	c->offset = 0;

	return c;

}

void

mouseclose(Chan *c)

{

	if(!(c->flag&COPEN))

		return;

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

	case Qmouse:

		lock(&mouse.lk);

		mouse.open = 0;

		unlock(&mouse.lk);

		cursorarrow();

	}

}

long

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

{

	char buf[4*12+1];

	uchar *p;

	int i, nn;

	ulong msec;

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

	p = va;

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

	case Qdir:

		return devdirread(c, va, n, mousedir, NMOUSE, 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.lk);

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

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

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

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

		unlock(&cursor.lk);

		return n;

	case Qmouse:

		while(mousechanged(0) == 0)

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

		lock(&screen.lk);

		if(screen.reshaped) {

			screen.reshaped = 0;

			sprint(buf, "t%11d %11d", 0, ticks());

			if(n > 1+2*12)

				n = 1+2*12;

			memmove(va, buf, n);

			unlock(&screen.lk);

			return n;

		}

		unlock(&screen.lk);

		lock(&mouse.lk);

		i = mouse.ri;

		nn = (mouse.wi + Mousequeue - i) % Mousequeue;

		if(nn < 1)

			panic("empty mouse queue");

		msec = ticks();

		while(nn > 1) {

			if(mouse.queue[i].msec + Mousewindow > msec)

				break;

			i = (i+1)%Mousequeue;

			nn--;

		}

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

			mouse.queue[i].xy.x,

			mouse.queue[i].xy.y,

			mouse.queue[i].buttons,

			mouse.queue[i].msec);

		mouse.ri = (i+1)%Mousequeue;

		unlock(&mouse.lk);

		if(n > 1+4*12)

			n = 1+4*12;

		memmove(va, buf, n);

		return n;

	}

	return 0;

}

long

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

{

	char *p;

	Point pt;

	char buf[64];

	USED(offset);

	p = va;

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

	case Qdir:

		error(Eisdir);

	case Qcursor:

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

			cursorarrow();

		}else{

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

			lock(&cursor.lk);

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

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

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

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

			unlock(&cursor.lk);

			setcursor();

		}

		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);

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

			mouseset(pt);

		return n;

	}

	error(Egreg);

	return -1;

}

int

mousechanged(void *a)

{

	USED(a);

	return mouse.ri != mouse.wi || screen.reshaped;

}

Dev mousedevtab = {

	'm',

	"mouse",

	devreset,

	devinit,

	devshutdown,

	mouseattach,

	mousewalk,

	mousestat,

	mouseopen,

	devcreate,

	mouseclose,

	mouseread,

	devbread,

	mousewrite,

	devbwrite,

	devremove,

	devwstat,

};