Subversion Repositories shark

/*
 * Project: S.Ha.R.K.
 *
 * Coordinators:
 *   Giorgio Buttazzo    <giorgio@sssup.it>
 *   Paolo Gai           <pj@gandalf.sssup.it>
 *
 * Authors     :
 *   Paolo Gai           <pj@gandalf.sssup.it>
 *   Massimiliano Giorgi <massy@gandalf.sssup.it>
 *   Luca Abeni          <luca@gandalf.sssup.it>
 *   Tullio Facchinetti  <tullio.facchinetti@unipv.it>
 *   (see the web pages for full authors list)
 *
 * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
 *
 * http://www.sssup.it
 * http://retis.sssup.it
 * http://shark.sssup.it
 */

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

/*---------------*
 * GRX Management*
 *---------------*/

#include <kernel/kern.h>
//#include <drivers/glib.h>

#include "../include/drivers/shark_input26.h"
#include "../include/drivers/shark_mouse26.h"

/* External functions */
extern void grx_getimage(WORD x1, WORD y1, WORD x2, WORD y2, WORD *buf);  // Tool
extern void grx_putimage(WORD x1, WORD y1, WORD x2, WORD y2, WORD *buf);  // Tool
extern int _mouse_cursor_init(int cmd, void(*my_show_cursor)(int, int), void(*my_restore_cursor)(int, int));
extern void _mouse_cursor_getposition(int *xptr, int *yptr);

extern int autocursormode;

static BYTE left_ptr_bits[] = { 0x00, 0x00, 0x08, 0x00, 0x18, 0x00, 0x38, 0x00,
                                0x78, 0x00, 0xf8, 0x00, 0xf8, 0x01, 0xf8, 0x03,
                                0xf8, 0x07, 0xf8, 0x00, 0xd8, 0x00, 0x88, 0x01,
                                0x80, 0x01, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00 };


static BYTE left_ptrmsk_bits[] = { 0x0c, 0x00, 0x1c, 0x00, 0x3c, 0x00, 0x7c, 0x00,
                                   0xfc, 0x00, 0xfc, 0x01, 0xfc, 0x03, 0xfc, 0x07,
                                   0xfc, 0x0f, 0xfc, 0x0f, 0xfc, 0x01, 0xdc, 0x03,
                                   0xcc, 0x03, 0x80, 0x07, 0x80, 0x07, 0x00, 0x03 };

/* dimensions (16x16) */
#define SHAPE_DX MOUSESHAPEDX
#define SHAPE_DY MOUSESHAPEDY

/* shape hot spot (3,1) */
#define HOTSPOT_X MOUSEHOTSPOTX
#define HOTSPOT_Y MOUSEHOTSPOTY

/* cursor shape */
static BYTE shape[SHAPE_DX * SHAPE_DY * 4];
/* cursor mask */
static BYTE mask[SHAPE_DX * SHAPE_DY * 4];

/* old memory buffer */
static BYTE saved_shape[SHAPE_DX * SHAPE_DY * 4];
/* new memory buffer */
static BYTE new_shape[SHAPE_DX * SHAPE_DY * 4];

static BYTE *saved_shapeptr = (void*)DEFAULT;
static BYTE *saved_maskptr = (void*)DEFAULT;

static int bpp; // bytes per pixel

/* if called with NULL -> retrieve next bit of a bits-stream
 * else                -> initialize the bit stream
 */
static int get_bit(BYTE *p)
{
        static BYTE *ptr;
        static BYTE val;
        static int  c;

        if (p != NULL) {
                ptr = p;
                val = 0;
                c = 8;
                return 0;
        }

        if (c==8) {
                c = 0;
                val = *ptr;
                ptr++;
        } else
                val >>= 1;

        c++;
        return val&1;
}

/* show grx cursor */
static void show_grx_cursor(int x, int y)
{
        int i;
       
        x -= HOTSPOT_X - 1;
        y -= HOTSPOT_Y - 1;
        grx_getimage(x, y, x+SHAPE_DX-1, y+SHAPE_DY-1, saved_shape);
        for(i=0; i < SHAPE_DX*SHAPE_DY*bpp/4; i++)
                ((DWORD*)new_shape)[i] = ( ((DWORD*)saved_shape)[i] & ((DWORD*)mask)[i] ) | ((DWORD*)shape)[i];
        grx_putimage(x, y, x+SHAPE_DX-1, y+SHAPE_DY-1, new_shape);
}

/* restore grx cursor */
static void restore_grx_cursor(int x, int y)
{
        x -= HOTSPOT_X - 1;
        y -= HOTSPOT_Y - 1;
        grx_putimage(x, y, x+SHAPE_DX-1, y+SHAPE_DY-1, saved_shape);
}

int mouse_grxcursor(int cmd, int bpp)
{
        mouse_grxshape(saved_shapeptr, saved_maskptr, bpp);
        return _mouse_cursor_init(cmd|GRXCURSOR, show_grx_cursor, restore_grx_cursor);
}

/* compute the shape and mask array */
int mouse_grxshape(BYTE *shapeptr, BYTE *maskptr, int bpp_in)
{
        BYTE b;
        int  pc;
        int  i,j;
        int  saved_x, saved_y;
        int  cond;
        /*int  result;
        grx_vga_modeinfo info;*/
 
        /* Autocalculate bpp */
        /*result = gd_getmodeinfo(&info);
        if (result == -1)
                return -1;
        bpp = info.bytesperpixel;*/

        cond = ( ((autocursormode & STATUSMASK) == ENABLE) && ((autocursormode & GRXCURSOR) == GRXCURSOR) );

        if (cond) {
                _mouse_cursor_getposition(&saved_x,&saved_y);
                restore_grx_cursor(saved_x,saved_y);
        }

        if (bpp_in != -1)
                bpp = bpp_in;

        if (shapeptr == (void*)DEFAULT) {
                shapeptr = left_ptr_bits;
                pc = 0;
                get_bit(left_ptr_bits);
                for (i = 0; i < SHAPE_DX*SHAPE_DY; i++) {
                        b = get_bit(NULL) ? 255 : 0;
                        for (j = 0; j < bpp; j++)
                                shape[pc++] = b;
                }
        } else {
                memcpy(shape, shapeptr, SHAPE_DX*SHAPE_DY*bpp);
                saved_shapeptr = shapeptr;
        }

        if (maskptr == (void*)DEFAULT) {
                maskptr = left_ptrmsk_bits;
                pc = 0;
                get_bit(left_ptrmsk_bits);
                for (i = 0; i < SHAPE_DX*SHAPE_DY; i++) {
                        b=get_bit(NULL)?0:255;
                        for (j = 0; j < bpp; j++)
                                mask[pc++] = b;
                }
        } else {
                memcpy(mask, maskptr, SHAPE_DX*SHAPE_DY*bpp);
                saved_maskptr = maskptr;
        }

        if (cond)
                show_grx_cursor(saved_x,saved_y);

        return 0;
}