Subversion Repositories openrisc_me

/*
 * Copyright (c) 1999, 2000 Greg Haerr <greg@censoft.com>
 * Copyright (C) 1999 Bradley D. LaRonde (brad@ltc.com)
 * Copyright (c) 1991 David I. Bell
 * Permission is granted to use, distribute, or modify this source,
 * provided that this copyright notice remains intact.
 *
 * Device-independent top level mouse and cursor routines
 *
 * Reads data from mouse driver and tracks real position on the screen.
 * Intersection detection for cursor with auto removal
 *
 * Bradley D. LaRonde added absolute coordinates and z (pen pressure) Oct-1999
 */
#include <string.h>
#include "device.h"
 
/*
 * The following define specifies whether returned mouse
 * driver coordinates are adjusted when running in portrait
 * mode.  If the mouse driver doesn't adjust returned values
 * when in portrait mode (as is the case for the iPAQ), then
 * this define should be set on.
 */
#define FLIP_MOUSE_IN_PORTRAIT_MODE	1
 
static MWCOORD	xpos;		/* current x position of mouse */
static MWCOORD	ypos;		/* current y position of mouse */
static MWCOORD	minx;		/* minimum allowed x position */
static MWCOORD	maxx;		/* maximum allowed x position */
static MWCOORD	miny;		/* minimum allowed y position */
static MWCOORD	maxy;		/* maximum allowed y position */
static int	scale;		/* acceleration scale factor */
static int	thresh;		/* acceleration threshhold */
static int	buttons;	/* current state of buttons */
static MWBOOL	changed;	/* mouse state has changed */
 
static MWCOORD 	curminx;	/* minimum x value of cursor */
static MWCOORD 	curminy;	/* minimum y value of cursor */
static MWCOORD 	curmaxx;	/* maximum x value of cursor */
static MWCOORD 	curmaxy;	/* maximum y value of cursor */
static int	curvisible;	/* >0 if cursor is visible*/
static MWBOOL 	curneedsrestore;/* cursor needs restoration after drawing*/
static MWCOORD 	cursavx;	/* saved cursor location*/
static MWCOORD 	cursavy;
static MWCOORD	cursavx2;
static MWCOORD	cursavy2;
static MWPIXELVAL curfg;		/* foreground color of cursor */
static MWPIXELVAL curbg;		/* background color of cursor */
static MWPIXELVAL cursavbits[MWMAX_CURSOR_SIZE * MWMAX_CURSOR_SIZE];
static MWIMAGEBITS cursormask[MWMAX_CURSOR_SIZE];
static MWIMAGEBITS cursorcolor[MWMAX_CURSOR_SIZE];
 
extern int gr_mode;
 
/*
 * Initialize the mouse.
 * This sets its position to (0, 0) with no boundaries and no buttons pressed.
 * Returns < 0 on error, or mouse fd on success
 */
int
GdOpenMouse(void)
{
	int fd;
 
	/* init mouse position info*/
	buttons = 0;
	xpos = 0;
	ypos = 0;
	minx = MIN_MWCOORD;
	miny = MIN_MWCOORD;
	maxx = MAX_MWCOORD;
	maxy = MAX_MWCOORD;
	changed = TRUE;
 
	/* init cursor position and size info*/
	curvisible = 0;
	curneedsrestore = FALSE;
	curminx = minx;
	curminy = miny;
	curmaxx = curminx + MWMAX_CURSOR_SIZE - 1;
	curmaxy = curminy + MWMAX_CURSOR_SIZE - 1;
 
	if ((fd = mousedev.Open(&mousedev)) == -1)
		return -1;
 
	/* get default acceleration settings*/
	mousedev.GetDefaultAccel(&scale, &thresh);
 
	/* handle null mouse driver by hiding cursor*/
	if(fd == -2)
		GdHideCursor(&scrdev);
	return fd;
}
 
/*
 * Terminate the use of the mouse.
 */
void
GdCloseMouse(void)
{
	mousedev.Close();
}
 
void
GdGetButtonInfo(int *buttons)
{
	*buttons = mousedev.GetButtonInfo();
}
 
/*
 * Restrict the coordinates of the mouse to the specified coordinates.
 */
void
GdRestrictMouse(MWCOORD newminx, MWCOORD newminy, MWCOORD newmaxx,
	MWCOORD newmaxy)
{
	minx = newminx;
	miny = newminy;
	maxx = newmaxx;
	maxy = newmaxy;
	GdMoveMouse(xpos, ypos);
}
 
/*
 * Set the acceleration threshhold and scale factors.
 * Acceleration makes the cursor move further for faster movements.
 * Basically, at mouse speeds above the threshold, the excess distance
 * moved is multiplied by the scale factor.  For example, with a threshhold
 * of 5 and a scale of 3, the following gives examples of the original and
 * modified mouse movements:
 *	input:		0	4	5	6	9	20
 *	output:		0	4	5	8	17	50
 */
void
GdSetAccelMouse(int newthresh, int newscale)
{
	if (newthresh < 0)
		newthresh = 0;
	if (newscale < 0)
		newscale = 0;
	thresh = newthresh;
	scale = newscale;
}
 
/*
 * Move the mouse to the specified coordinates.
 * The location is limited by the current mouse coordinate restrictions.
 */
void
GdMoveMouse(MWCOORD newx, MWCOORD newy)
{
	if (newx < minx)
		newx = minx;
	if (newx > maxx)
		newx = maxx;
	if (newy < miny)
		newy = miny;
	if (newy > maxy)
		newy = maxy;
	if (newx == xpos && newy == ypos)
		return;
 
	changed = TRUE;
	xpos = newx;
	ypos = newy;
}
 
/*
 * Read the current location and button states of the mouse.
 * Returns -1 on read error.
 * Returns 0 if no new data is available from the mouse driver,
 * or if the new data shows no change in button state or position.
 * Returns 1 if the mouse driver tells us a changed button state
 * or position. Button state and position are always both returned,
 * even if only one or the other changes.
 * Do not block.
 */
int
GdReadMouse(MWCOORD *px, MWCOORD *py, int *pb)
{
	MWCOORD	x, y, z;
	int	newbuttons;	/* new button state */
	int	sign;		/* sign of change */
	int	status;		/* status of reading mouse */
 
	*px = xpos;
	*py = ypos;
	*pb = buttons;
 
	if (changed) {
		changed = FALSE;
		return 1;
	}
 
	/* read the mouse position */
	status = mousedev.Read(&x, &y, &z, &newbuttons);
	if (status < 0)
		return -1;
 
	/* no new info from the mouse driver? */
	if (status == 0)
		return 0;
 
	/* has the button state changed? */
	if (buttons != newbuttons) {
		changed = TRUE;
		buttons = newbuttons;
	}
 
	/* depending on the kind of data that we have */
	switch(status) {
	case 1:	/* relative position change reported, figure new position */
		sign = 1;
		if (x < 0) {
			sign = -1;
			x = -x;
		}
		if (x > thresh)
			x = thresh + (x - thresh) * scale;
		x *= sign;
 
		sign = 1;
		if (y < 0) {
			sign = -1;
			y = -y;
		}
		if (y > thresh)
			y = thresh + (y - thresh) * scale;
		y *= sign;
 
#if FLIP_MOUSE_IN_PORTRAIT_MODE
		if (scrdev.portrait == MWPORTRAIT_RIGHT)
			GdMoveMouse(xpos + y, ypos - x);	/* right*/
		else if (scrdev.portrait == MWPORTRAIT_LEFT)
			GdMoveMouse(xpos - y, ypos + x);	/* left*/
		else if (scrdev.portrait == MWPORTRAIT_DOWN)
			GdMoveMouse(xpos + x, ypos - y);	/* down*/
		else 
#endif
			GdMoveMouse(xpos + x, ypos + y);
		break;
 
	case 2:	/* absolute position reported */
#if FLIP_MOUSE_IN_PORTRAIT_MODE
		if (scrdev.portrait == MWPORTRAIT_RIGHT)
			GdMoveMouse(y, scrdev.xres - x - 1);	/* right*/
		else if (scrdev.portrait == MWPORTRAIT_LEFT)
			GdMoveMouse(scrdev.yres - y - 1, x);	/* left*/
		else if (scrdev.portrait == MWPORTRAIT_DOWN)
			GdMoveMouse(x, scrdev.yres - y - 1);	/* down?*/
		else 
#endif
			GdMoveMouse(x, y);
		break;
 
	case 3:	/* only button data is available */
		break;
	}
 
	/* didn't anything change? */
	if (!changed)
		return 0;
 
	/* report new mouse data */
	changed = FALSE;
	*px = xpos;
	*py = ypos;
	*pb = buttons;
	return 1;
}
 
/*
 * Set the cursor position.
 */
void
GdMoveCursor(MWCOORD newx, MWCOORD newy)
{
	MWCOORD shiftx;
	MWCOORD shifty;
 
	shiftx = newx - curminx;
	shifty = newy - curminy;
	if(shiftx == 0 && shifty == 0)
		return;
	curminx += shiftx;
	curmaxx += shiftx;
	curminy += shifty;
	curmaxy += shifty;
 
	/* Restore the screen under the mouse pointer*/
	GdHideCursor(&scrdev);
 
	/* Draw the new pointer*/
	GdShowCursor(&scrdev);
}
 
/* return current mouse position in x, y*/
MWBOOL
GdGetCursorPos(MWCOORD *px, MWCOORD *py)
{
	*px = xpos;
	*py = ypos;
	return curvisible > 0;	/* return TRUE if visible*/
}
 
/*
 * Set the cursor size and bitmaps.
 */
void
GdSetCursor(PMWCURSOR pcursor)
{
	int	bytes;
 
	GdHideCursor(&scrdev);
	curmaxx = curminx + pcursor->width - 1;
	curmaxy = curminy + pcursor->height - 1;
 
	curfg = GdFindColor(pcursor->fgcolor);
	curbg = GdFindColor(pcursor->bgcolor);
	bytes = MWIMAGE_WORDS(pcursor->width) * pcursor->height
			* sizeof(MWIMAGEBITS);
	memcpy(cursorcolor, pcursor->image, bytes);
	memcpy(cursormask, pcursor->mask, bytes);
 
	GdShowCursor(&scrdev);
}
 
 
/*
 * Draw the mouse pointer.  Save the screen contents underneath
 * before drawing. Returns previous cursor state.
 */
int
GdShowCursor(PSD psd)
{
	MWCOORD 		x;
	MWCOORD 		y;
	MWPIXELVAL *	saveptr;
	MWIMAGEBITS *	cursorptr;
	MWIMAGEBITS *	maskptr;
	MWIMAGEBITS 	curbit, cbits, mbits;
	MWPIXELVAL 	oldcolor;
	MWPIXELVAL 	newcolor;
	int 		oldmode;
	int		prevcursor = curvisible;
 
	if(++curvisible != 1)
		return prevcursor;
	oldmode = gr_mode;
	gr_mode = MWMODE_COPY;
 
	saveptr = cursavbits;
	cursavx = curminx;
	cursavy = curminy;
	cursavx2 = curmaxx;
	cursavy2 = curmaxy;
	cursorptr = cursorcolor;
	maskptr = cursormask;
 
	for (y = curminy; y <= curmaxy; y++) {
		cbits = *cursorptr++;
		mbits = *maskptr++;
		curbit = MWIMAGE_FIRSTBIT;
		for (x = curminx; x <= curmaxx; x++) {
			if(x >= 0 && x < psd->xvirtres &&
			   y >= 0 && y < psd->yvirtres) {
				oldcolor = psd->ReadPixel(psd, x, y);
				if (curbit & mbits) {
					newcolor = (curbit&cbits)? curbg: curfg;
					if (oldcolor != newcolor)
					       psd->DrawPixel(psd, x, y, newcolor);
				}
				*saveptr++ = oldcolor;
			}
			curbit = MWIMAGE_NEXTBIT(curbit);
		}
	}
 
	gr_mode = oldmode;
	return prevcursor;
}
 
/*
 * Restore the screen overwritten by the cursor.
 */
int
GdHideCursor(PSD psd)
{
	MWPIXELVAL *	saveptr;
	MWCOORD 		x, y;
	int 		oldmode;
	int		prevcursor = curvisible;
 
	if(curvisible-- <= 0)
		return prevcursor;
	oldmode = gr_mode;
	gr_mode = MWMODE_COPY;
 
	saveptr = cursavbits;
	for (y = cursavy; y <= cursavy2; y++) {
		for (x = cursavx; x <= cursavx2; x++) {
			if(x >= 0 && x < psd->xvirtres &&
			   y >= 0 && y < psd->yvirtres) {
				psd->DrawPixel(psd, x, y, *saveptr++);
			}
		}
	}
 	gr_mode = oldmode;
	return prevcursor;
}
 
/* Check to see if the mouse pointer is about to be overwritten.
 * If so, then remove the cursor so that the graphics operation
 * works correctly.  If the cursor is removed, then this fact will
 * be remembered and a later call to GdFixCursor will restore it.
 */
void
GdCheckCursor(PSD psd,MWCOORD x1,MWCOORD y1,MWCOORD x2,MWCOORD y2)
{
	MWCOORD temp;
 
	if (curvisible <= 0 || (psd->flags & PSF_SCREEN) == 0)
		return;
 
	if (x1 > x2) {
		temp = x1;
		x1 = x2;
		x2 = temp;
	}
	if (y1 > y2) {
		temp = y1;
		y1 = y2;
		y2 = temp;
	}
	if (x1 > curmaxx || x2 < curminx || y1 > curmaxy || y2 < curminy)
		return;
 
	GdHideCursor(psd);
	curneedsrestore = TRUE;
}
 
 
/* Redisplay the cursor if it was removed because of a graphics operation. */
void
GdFixCursor(PSD psd)
{
	if (curneedsrestore && (psd->flags & PSF_SCREEN)) {
		GdShowCursor(psd);
		curneedsrestore = FALSE;
	}
}