mirror of
https://github.com/Stichting-MINIX-Research-Foundation/xsrc.git
synced 2025-09-15 15:45:00 -04:00
474 lines
12 KiB
C
474 lines
12 KiB
C
/*
|
|
* Copyright © 1999 Keith Packard
|
|
*
|
|
* Permission to use, copy, modify, distribute, and sell this software and its
|
|
* documentation for any purpose is hereby granted without fee, provided that
|
|
* the above copyright notice appear in all copies and that both that
|
|
* copyright notice and this permission notice appear in supporting
|
|
* documentation, and that the name of Keith Packard not be used in
|
|
* advertising or publicity pertaining to distribution of the software without
|
|
* specific, written prior permission. Keith Packard makes no
|
|
* representations about the suitability of this software for any purpose. It
|
|
* is provided "as is" without express or implied warranty.
|
|
*
|
|
* KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
|
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
|
* EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
|
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
|
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
* PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
/* $XFree86: xc/programs/Xserver/hw/tinyx/trio/s3curs.c,v 1.1 2004/06/02 22:43:03 dawes Exp $ */
|
|
/*
|
|
* Copyright (c) 2004 by The XFree86 Project, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
* a copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject
|
|
* to the following conditions:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions, and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer
|
|
* in the documentation and/or other materials provided with the
|
|
* distribution, and in the same place and form as other copyright,
|
|
* license and disclaimer information.
|
|
*
|
|
* 3. The end-user documentation included with the redistribution,
|
|
* if any, must include the following acknowledgment: "This product
|
|
* includes software developed by The XFree86 Project, Inc
|
|
* (http://www.xfree86.org/) and its contributors", in the same
|
|
* place and form as other third-party acknowledgments. Alternately,
|
|
* this acknowledgment may appear in the software itself, in the
|
|
* same form and location as other such third-party acknowledgments.
|
|
*
|
|
* 4. Except as contained in this notice, the name of The XFree86
|
|
* Project, Inc shall not be used in advertising or otherwise to
|
|
* promote the sale, use or other dealings in this Software without
|
|
* prior written authorization from The XFree86 Project, Inc.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE XFREE86 PROJECT, INC OR ITS CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
|
|
* OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
|
|
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
|
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
|
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
|
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "s3.h"
|
|
#include "s3draw.h"
|
|
#include "cursorstr.h"
|
|
|
|
#define SetupCursor(s) KdScreenPriv(s); \
|
|
s3CardInfo(pScreenPriv); \
|
|
s3ScreenInfo(pScreenPriv); \
|
|
S3Ptr s3 = s3c->s3; \
|
|
S3Cursor *pCurPriv = &s3s->cursor
|
|
|
|
static void
|
|
_s3MoveCursor (ScreenPtr pScreen, int x, int y)
|
|
{
|
|
SetupCursor(pScreen);
|
|
CARD8 xlow, xhigh, ylow, yhigh;
|
|
CARD8 xoff, yoff;
|
|
|
|
x -= pCurPriv->xhot;
|
|
xoff = 0;
|
|
if (x < 0)
|
|
{
|
|
xoff = -x;
|
|
x = 0;
|
|
}
|
|
y -= pCurPriv->yhot;
|
|
yoff = 0;
|
|
if (y < 0)
|
|
{
|
|
yoff = -y;
|
|
y = 0;
|
|
}
|
|
xlow = (CARD8) x;
|
|
xhigh = (CARD8) (x >> 8);
|
|
ylow = (CARD8) y;
|
|
yhigh = (CARD8) (y >> 8);
|
|
|
|
|
|
/* This is the recommended order to move the cursor */
|
|
|
|
_s3WriteIndexRegister (&s3->crt_vga_3d4, 0x46, xhigh);
|
|
_s3WriteIndexRegister (&s3->crt_vga_3d4, 0x47, xlow);
|
|
_s3WriteIndexRegister (&s3->crt_vga_3d4, 0x49, ylow);
|
|
_s3WriteIndexRegister (&s3->crt_vga_3d4, 0x4e, xoff);
|
|
_s3WriteIndexRegister (&s3->crt_vga_3d4, 0x4f, yoff);
|
|
_s3WriteIndexRegister (&s3->crt_vga_3d4, 0x48, yhigh);
|
|
}
|
|
|
|
static void
|
|
s3MoveCursor (ScreenPtr pScreen, int x, int y)
|
|
{
|
|
SetupCursor (pScreen);
|
|
|
|
if (!pCurPriv->has_cursor)
|
|
return;
|
|
|
|
if (!pScreenPriv->enabled)
|
|
return;
|
|
|
|
LockS3(s3c);
|
|
_s3UnlockExt(s3);
|
|
_s3MoveCursor (pScreen, x, y);
|
|
_s3LockExt(s3);
|
|
UnlockS3(s3c);
|
|
}
|
|
|
|
static void
|
|
s3AllocCursorColors (ScreenPtr pScreen)
|
|
{
|
|
SetupCursor (pScreen);
|
|
CursorPtr pCursor = pCurPriv->pCursor;
|
|
|
|
(void)s3;
|
|
|
|
KdAllocateCursorPixels (pScreen, 0, pCursor,
|
|
&pCurPriv->source, &pCurPriv->mask);
|
|
switch (pScreenPriv->screen->fb[0].bitsPerPixel) {
|
|
case 4:
|
|
pCurPriv->source |= pCurPriv->source << 4;
|
|
pCurPriv->mask |= pCurPriv->mask << 4;
|
|
case 8:
|
|
pCurPriv->source |= pCurPriv->source << 8;
|
|
pCurPriv->mask |= pCurPriv->mask << 8;
|
|
case 16:
|
|
pCurPriv->source |= pCurPriv->source << 16;
|
|
pCurPriv->mask |= pCurPriv->mask << 16;
|
|
}
|
|
}
|
|
|
|
static void
|
|
_s3SetCursorColors (ScreenPtr pScreen)
|
|
{
|
|
SetupCursor (pScreen);
|
|
/* set foreground */
|
|
/* Reset cursor color stack pointers */
|
|
(void) _s3ReadIndexRegister(&s3->crt_vga_3d4, 0x45);
|
|
_s3WriteIndexRegister (&s3->crt_vga_3d4, 0x4a, pCurPriv->source);
|
|
_s3WriteIndexRegister (&s3->crt_vga_3d4, 0x4a, pCurPriv->source >> 8);
|
|
_s3WriteIndexRegister (&s3->crt_vga_3d4, 0x4a, pCurPriv->source >> 16);
|
|
|
|
/* set background */
|
|
/* Reset cursor color stack pointers */
|
|
(void) _s3ReadIndexRegister(&s3->crt_vga_3d4, 0x45);
|
|
_s3WriteIndexRegister (&s3->crt_vga_3d4, 0x4b, pCurPriv->mask);
|
|
_s3WriteIndexRegister (&s3->crt_vga_3d4, 0x4b, pCurPriv->mask >> 8);
|
|
_s3WriteIndexRegister (&s3->crt_vga_3d4, 0x4b, pCurPriv->mask >> 16);
|
|
}
|
|
|
|
void
|
|
s3RecolorCursor (ScreenPtr pScreen, int ndef, xColorItem *pdef)
|
|
{
|
|
SetupCursor (pScreen);
|
|
CursorPtr pCursor = pCurPriv->pCursor;
|
|
|
|
if (!pCurPriv->has_cursor || !pCursor)
|
|
return;
|
|
|
|
if (!pScreenPriv->enabled)
|
|
return;
|
|
|
|
if (pdef)
|
|
{
|
|
while (ndef)
|
|
{
|
|
if (pdef->pixel == pCurPriv->source ||
|
|
pdef->pixel == pCurPriv->mask)
|
|
break;
|
|
ndef--;
|
|
}
|
|
if (!ndef)
|
|
return;
|
|
}
|
|
s3AllocCursorColors (pScreen);
|
|
LockS3 (s3c);
|
|
_s3UnlockExt(s3);
|
|
_s3SetCursorColors (pScreen);
|
|
_s3LockExt (s3);
|
|
UnlockS3 (s3c);
|
|
}
|
|
|
|
static void
|
|
s3LoadCursor (ScreenPtr pScreen, int x, int y)
|
|
{
|
|
SetupCursor(pScreen);
|
|
CursorPtr pCursor = pCurPriv->pCursor;
|
|
CursorBitsPtr bits = pCursor->bits;
|
|
int h;
|
|
unsigned long *ram;
|
|
unsigned long *msk, *mskLine, *src, *srcLine;
|
|
unsigned long and, xor;
|
|
int i, j;
|
|
int wsrc;
|
|
|
|
/*
|
|
* Allocate new colors
|
|
*/
|
|
s3AllocCursorColors (pScreen);
|
|
|
|
pCurPriv->pCursor = pCursor;
|
|
pCurPriv->xhot = pCursor->bits->xhot;
|
|
pCurPriv->yhot = pCursor->bits->yhot;
|
|
|
|
/*
|
|
* Stick new image into cursor memory
|
|
*/
|
|
ram = (unsigned long *) s3s->cursor_base;
|
|
mskLine = (unsigned long *) bits->mask;
|
|
srcLine = (unsigned long *) bits->source;
|
|
|
|
h = bits->height;
|
|
if (h > S3_CURSOR_HEIGHT)
|
|
h = S3_CURSOR_HEIGHT;
|
|
|
|
wsrc = BitmapBytePad(bits->width) / 4; /* ulongs per line */
|
|
|
|
for (i = 0; i < S3_CURSOR_HEIGHT; i++)
|
|
{
|
|
msk = mskLine;
|
|
src = srcLine;
|
|
mskLine += wsrc;
|
|
srcLine += wsrc;
|
|
for (j = 0; j < S3_CURSOR_WIDTH / 32; j++) {
|
|
|
|
unsigned long m, s;
|
|
|
|
if (i < h && j < wsrc)
|
|
{
|
|
m = *msk++;
|
|
s = *src++;
|
|
xor = m & s;
|
|
and = ~m;
|
|
}
|
|
else
|
|
{
|
|
and = 0xffffffff;
|
|
xor = 0x00000000;
|
|
}
|
|
|
|
S3AdjustBits32(and);
|
|
S3AdjustBits32(xor);
|
|
*ram++ = (and & 0xffff) | (xor << 16);
|
|
*ram++ = (and >> 16) | (xor & 0xffff0000);
|
|
}
|
|
}
|
|
|
|
_s3WaitIdle (s3);
|
|
_s3UnlockExt (s3);
|
|
|
|
/* Set new color */
|
|
_s3SetCursorColors (pScreen);
|
|
|
|
/* Enable the cursor */
|
|
_s3WriteIndexRegister (&s3->crt_vga_3d4, 0x45, 0x01);
|
|
|
|
/* Wait for VRetrace to make sure the position is read */
|
|
_s3WaitVRetrace (s3);
|
|
|
|
/* Move to new position */
|
|
_s3MoveCursor (pScreen, x, y);
|
|
|
|
_s3LockExt (s3);
|
|
UnlockS3(s3c);
|
|
}
|
|
|
|
static void
|
|
s3UnloadCursor (ScreenPtr pScreen)
|
|
{
|
|
SetupCursor (pScreen);
|
|
|
|
(void)pCurPriv;
|
|
|
|
LockS3 (s3c);
|
|
_s3UnlockExt(s3);
|
|
|
|
/* Disable cursor */
|
|
_s3WriteIndexRegister (&s3->crt_vga_3d4, 0x45, 0);
|
|
|
|
_s3LockExt(s3);
|
|
UnlockS3 (s3c);
|
|
}
|
|
|
|
static Bool
|
|
s3RealizeCursor (ScreenPtr pScreen, CursorPtr pCursor)
|
|
{
|
|
SetupCursor(pScreen);
|
|
|
|
(void)s3;
|
|
|
|
if (!pScreenPriv->enabled)
|
|
return TRUE;
|
|
|
|
/* miRecolorCursor does this */
|
|
if (pCurPriv->pCursor == pCursor)
|
|
{
|
|
if (pCursor)
|
|
{
|
|
#ifdef FB_OLD_SCREEN
|
|
short x, y;
|
|
#else
|
|
int x, y;
|
|
#endif
|
|
|
|
miPointerPosition (&x, &y);
|
|
s3LoadCursor (pScreen, x, y);
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
static Bool
|
|
s3UnrealizeCursor (ScreenPtr pScreen, CursorPtr pCursor)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
s3SetCursor (ScreenPtr pScreen, CursorPtr pCursor, int x, int y)
|
|
{
|
|
SetupCursor(pScreen);
|
|
|
|
(void)s3;
|
|
|
|
pCurPriv->pCursor = pCursor;
|
|
|
|
if (!pScreenPriv->enabled)
|
|
return;
|
|
|
|
if (pCursor)
|
|
s3LoadCursor (pScreen, x, y);
|
|
else
|
|
s3UnloadCursor (pScreen);
|
|
}
|
|
|
|
miPointerSpriteFuncRec s3PointerSpriteFuncs = {
|
|
s3RealizeCursor,
|
|
s3UnrealizeCursor,
|
|
s3SetCursor,
|
|
s3MoveCursor,
|
|
};
|
|
|
|
static void
|
|
s3QueryBestSize (int class,
|
|
unsigned short *pwidth, unsigned short *pheight,
|
|
ScreenPtr pScreen)
|
|
{
|
|
SetupCursor (pScreen);
|
|
|
|
(void)s3;
|
|
|
|
switch (class)
|
|
{
|
|
case CursorShape:
|
|
if (*pwidth > pCurPriv->width)
|
|
*pwidth = pCurPriv->width;
|
|
if (*pheight > pCurPriv->height)
|
|
*pheight = pCurPriv->height;
|
|
if (*pwidth > pScreen->width)
|
|
*pwidth = pScreen->width;
|
|
if (*pheight > pScreen->height)
|
|
*pheight = pScreen->height;
|
|
break;
|
|
default:
|
|
fbQueryBestSize (class, pwidth, pheight, pScreen);
|
|
break;
|
|
}
|
|
}
|
|
|
|
Bool
|
|
s3CursorInit (ScreenPtr pScreen)
|
|
{
|
|
SetupCursor (pScreen);
|
|
|
|
(void)s3;
|
|
|
|
if (!s3s->cursor_base)
|
|
{
|
|
pCurPriv->has_cursor = FALSE;
|
|
return FALSE;
|
|
}
|
|
|
|
pCurPriv->width = S3_CURSOR_WIDTH;
|
|
pCurPriv->height= S3_CURSOR_HEIGHT;
|
|
pScreen->QueryBestSize = s3QueryBestSize;
|
|
miPointerInitialize (pScreen,
|
|
&s3PointerSpriteFuncs,
|
|
&kdPointerScreenFuncs,
|
|
FALSE);
|
|
pCurPriv->has_cursor = TRUE;
|
|
pCurPriv->pCursor = NULL;
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
s3CursorEnable (ScreenPtr pScreen)
|
|
{
|
|
SetupCursor (pScreen);
|
|
|
|
(void)s3;
|
|
|
|
if (pCurPriv->has_cursor)
|
|
{
|
|
if (pCurPriv->pCursor)
|
|
{
|
|
#ifdef FB_OLD_SCREEN
|
|
short x, y;
|
|
#else
|
|
int x, y;
|
|
#endif
|
|
|
|
miPointerPosition (&x, &y);
|
|
s3LoadCursor (pScreen, x, y);
|
|
}
|
|
else
|
|
s3UnloadCursor (pScreen);
|
|
}
|
|
}
|
|
|
|
void
|
|
s3CursorDisable (ScreenPtr pScreen)
|
|
{
|
|
SetupCursor (pScreen);
|
|
|
|
(void)s3;
|
|
|
|
if (!pScreenPriv->enabled)
|
|
return;
|
|
|
|
if (pCurPriv->has_cursor)
|
|
{
|
|
if (pCurPriv->pCursor)
|
|
{
|
|
s3UnloadCursor (pScreen);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
s3CursorFini (ScreenPtr pScreen)
|
|
{
|
|
SetupCursor (pScreen);
|
|
|
|
(void)s3;
|
|
|
|
pCurPriv->pCursor = NULL;
|
|
}
|