/***********************************************************
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
and the Massachusetts Institute of Technology, Cambridge, Massachusetts.

                        All Rights Reserved

Permission to use, copy, modify, and distribute this software and its 
documentation for any purpose and without fee is hereby granted, 
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 names of Digital or MIT not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.  

DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
DIGITAL 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.

******************************************************************/
#include <stdio.h>

#include "X.h"
#define  NEED_EVENTS
#include "Xproto.h"
#include "scrnintstr.h"
#include "cursorstr.h"
#include "pixmap.h"
#include "input.h"
#include "windowstr.h"
#include "regionstr.h"
#include "opaque.h"

#include "mfb.h"
#include "mi.h"
#include "os.h"

extern void SetInputCheck();
extern void InitXeroxMap();

mesa long System_PulsesToMicroseconds();
struct driverEvent {
    unsigned short x,y;
    long time;
    short type;
    short key;
    };

struct ptrs {
    int **p1, **p2
    };

mesa struct driverEvent *XEventQ_DeQEvent();
mesa struct ptrs XEventQ_EventQPointers();
mesa void XEventQ_FreeEvent();
mesa void XMKDriver_setMouseInterest();
mesa void XMKDriver_setMouseConstraint();
mesa void XMKDriver_setCursor();
mesa void XMKDriver_setCursorPosition();
mesa long XMKDriver_getLastEventTime();
mesa void XMKDriver_setLastEventTime();
mesa long XMKDriver_getTimeInMillis();
mesa void XMKDriver_enableMouseEvents();
mesa void XMKDriver_enableKeyboardEvents();
mesa void XMKDriver_blinkDisplay();
mesa int *XMKDriver_displayInit();
mesa void XMKDriver_displayClose();
mesa void XMKDriver_displayOn();
mesa void XMKDriver_displayOff();

Bool xeroxRealizeCursor(), xeroxUnrealizeCursor(), xeroxDisplayCursor();
Bool xeroxSetCursorPosition();
void xeroxCursorLimits();
void xeroxPointerNonInterestBox();
void xeroxConstrainCursor();
Bool xeroxScreenClose();
void xeroxQueryBestSize();

extern void miRecolorCursor();
extern int  xeroxGetMotionEvents();
extern void xeroxChangePointerControl(), xeroxChangeKeyboardControl(), xeroxBell();
extern long GetTimeInMillis();

int isItTimeToYield;

static DevicePtr	xeroxKeyboard;
static DevicePtr	xeroxPointer;
static int *bitmap;
static int hotX, hotY;
static BoxRec constraintBox;

static Bool
xeroxSaveScreen(pScreen, on)
    ScreenPtr pScreen;
    int on;
{
    if (on == SCREEN_SAVER_FORCER)
    {
        XMKDriver_setLastEventTime(GetTimeInMillis());	
	return TRUE;
    }
    else
        return FALSE;
}


Bool
xeroxScreenInit(index, pScreen, argc, argv)
    int index;
    ScreenPtr pScreen;
    int argc;		/* these two may NOT be changed */
    char **argv;
{
    register PixmapPtr pPixmap;
    Bool retval;

    bitmap = XMKDriver_displayInit();
    retval = mfbScreenInit(index, pScreen, (char *)bitmap, 1024, 808, 72);
    pScreen->CloseScreen = xeroxScreenClose;
    pScreen->SaveScreen = xeroxSaveScreen;
    pScreen->RealizeCursor = xeroxRealizeCursor;
    pScreen->UnrealizeCursor = xeroxUnrealizeCursor;
    pScreen->DisplayCursor = xeroxDisplayCursor;
    pScreen->SetCursorPosition = xeroxSetCursorPosition;
    pScreen->CursorLimits = xeroxCursorLimits;
    pScreen->PointerNonInterestBox = xeroxPointerNonInterestBox;
    pScreen->ConstrainCursor = xeroxConstrainCursor;
    pScreen->RecolorCursor = miRecolorCursor;
    pScreen->QueryBestSize = xeroxQueryBestSize;

    return(retval);
}

static Bool
xeroxScreenClose(index, pScreen)
    int index;
    ScreenPtr pScreen;

{
    XMKDriver_displayClose();
    return (TRUE);
}

int
xeroxMouseProc(pDev, onoff, argc, argv)
    DevicePtr pDev;
    int onoff;
    int argc;
    char **argv;
{
    int     i;
    struct ptrs qptrs;
    BYTE map[4];

    switch (onoff)
    {
	case DEVICE_INIT: 
	    xeroxPointer = pDev;
	    pDev->devicePrivate = (pointer) NULL;
	    map[1] = 1;
	    map[2] = 2;
	    map[3] = 3;
	    InitPointerDeviceStruct(
		xeroxPointer, map, 3, xeroxGetMotionEvents, xeroxChangePointerControl);
	    qptrs = XEventQ_EventQPointers();
	    /*SetInputCheck(qptrs.p1, qptrs.p2);*/
	    break;
	case DEVICE_ON: 
	    pDev->on = TRUE;
	    hotX = hotY = 0;
	    XMKDriver_enableMouseEvents(TRUE);
	    break;
	case DEVICE_OFF: 
	    pDev->on = FALSE;
	    XMKDriver_enableMouseEvents(FALSE);
/*	RemoveEnabledDevice(fdQVSS);   */
	    break;
	case DEVICE_CLOSE: 
	    XMKDriver_enableMouseEvents(FALSE);
	    break;
    }
    return Success;

}

int
xeroxKeybdProc(pDev, onoff, argc, argv)
    DevicePtr pDev;
    int onoff;
    int argc;
    char **argv;
{
    BYTE map[MAP_LENGTH];
    KeySymsRec keySyms;
    ModifierMapRec modMap;

    switch (onoff)
    {
	case DEVICE_INIT: 
	    xeroxKeyboard = pDev;
	    pDev->devicePrivate = (pointer) NULL;
	    InitXeroxMap(&keySyms, &modMap);
	    InitKeyboardDeviceStruct(
		    xeroxKeyboard, &keySyms, &modMap, xeroxBell,
		    xeroxChangeKeyboardControl);
	    Xfree(keySyms.map);
	    break;
	case DEVICE_ON: 
	    pDev->on = TRUE;
	    XMKDriver_enableKeyboardEvents(TRUE);
	    break;
	case DEVICE_OFF: 
	    pDev->on = FALSE;
	    XMKDriver_enableKeyboardEvents(FALSE);
/*	    RemoveEnabledDevice(fdQVSS);  */
	    break;
	case DEVICE_CLOSE: 
	    XMKDriver_enableKeyboardEvents(FALSE);
	    break;
    }
    return Success;
}


/*****************
 * ProcessInputEvents:
 *    processes all the pending input events
 *****************/

extern int screenIsSaved;

void
ProcessInputEvents()
{
    struct driverEvent *event;

    xEvent	x;

    while ( ( event = XEventQ_DeQEvent() ) != NULL )
	{
	x.u.u.type = event->type;
	x.u.u.detail = event->key;
	x.u.keyButtonPointer.time = System_PulsesToMicroseconds(event->time)/1000L;
	x.u.keyButtonPointer.rootX = event->x + hotX;
	x.u.keyButtonPointer.rootY = event->y + hotY;
	XEventQ_FreeEvent(&event);
	switch(x.u.u.type)
	    {
	    case KeyPress:
	    case KeyRelease:
		(*xeroxKeyboard->processInputProc)(&x, xeroxKeyboard);
		break;
	    case ButtonPress:
	    case ButtonRelease:
	    case MotionNotify:
		(*xeroxPointer->processInputProc)(&x, xeroxPointer);
		break;
	    }
	}
}


TimeSinceLastInputEvent()
{
    if (XMKDriver_getLastEventTime() == 0)
	XMKDriver_setLastEventTime(GetTimeInMillis());
    return GetTimeInMillis() - XMKDriver_getLastEventTime();
}

static void
xeroxChangeKeyboardControl(pDevice, ctrl)
    DevicePtr pDevice;
    KeybdCtrl *ctrl;
{
}

static void
xeroxBell(loud, pDevice)
    int loud;
    DevicePtr pDevice;
{
	XMKDriver_blinkDisplay();
}

static void
xeroxChangePointerControl(pDevice, ctrl)
    DevicePtr pDevice;
    PtrCtrl   *ctrl;
{
}

static int
xeroxGetMotionEvents(buff, start, stop)
    CARD32 start, stop;
    xTimecoord *buff;
{
    return 0;
}

static Bool
xeroxSetCursorPosition( pScr, newx, newy)
    ScreenPtr	pScr;
    unsigned int	newx;
    unsigned int	newy;
{
    XMKDriver_setCursorPosition(newx - hotX,newy - hotY);
    return (TRUE);
}

static Bool
xeroxDisplayCursor( pScr, pCurs, x, y)
    ScreenPtr	pScr;
    CursorPtr	pCurs;
    int x,y;
{
    int i;
    if((hotX != pCurs->xhot) || (hotY != pCurs->yhot))
	{
	hotX = pCurs->xhot;
	hotY = pCurs->yhot;
	xeroxSetCursorPosition(pScr, x, y);
	/*xeroxConstrainCursor(pScr, & constraintBox);*/
	}

    XMKDriver_setCursor((short *)pCurs->devPriv[pScr->myNum]);
}


static void
xeroxPointerNonInterestBox( pScr, pBox)
    ScreenPtr	pScr;
    BoxPtr	pBox;
{
	XMKDriver_setMouseInterest(*pBox);
}

static void
xeroxConstrainCursor( pScr, pBox)
    ScreenPtr	pScr;
    BoxPtr	pBox;
{
	XMKDriver_setMouseConstraint(*pBox);
}

static void
xeroxCursorLimits( pScr, pCurs, pHotBox, pTopLeftBox)
    ScreenPtr	pScr;
    CursorPtr	pCurs;
    BoxPtr	pHotBox;
    BoxPtr	pTopLeftBox;	/* return value */
{
    pTopLeftBox->x1 = max( pHotBox->x1, 0);
    pTopLeftBox->y1 = max( pHotBox->y1, 0);
    pTopLeftBox->x2 = min( pHotBox->x2, 1023);
    pTopLeftBox->y2 = min( pHotBox->y2, 807);
}

Bool
xeroxRealizeCursor( pScr, pCurs)
    ScreenPtr pScr;
    CursorPtr	pCurs;	/* a SERVER-DEPENDENT cursor */
{
    short *	phardbits;	/* qvss-defined */
    short *	pservimbits;	/* server-defined */
				/* assumes severscanlinepad = sizeof(int) */
    int *	pservmskbits;	/* server-defined */
    int		i;

    pCurs->devPriv[pScr->myNum] = (pointer)Xalloc( 16*sizeof(short));
    bzero((char *)pCurs->devPriv[pScr->myNum], 16*sizeof(short));

    /*
     * munge the SERVER-DEPENDENT, device-independent cursor bits into
     * what the device wants, which appears to be 16 contiguous shorts.
     *
     * xerox cursor is brain-damaged, so only look at "image" bits
     */
/* XXX assumes that the DIX cursor format is padded to int boundaries */
    for ( i=0,
	  phardbits = (short *)pCurs->devPriv[ pScr->myNum],
	  pservimbits = (int *)pCurs->source;

	  i < ((pCurs->height < 16) ? pCurs->height : 16);

	  i++)
	*phardbits++ = *pservimbits++;	/* effectively clip off last 16 bits */
}

Bool
xeroxUnrealizeCursor( pScr, pCurs)
    ScreenPtr	pScr;
    CursorPtr	pCurs;
{
    Xfree( pCurs->devPriv[ pScr->myNum]);
    return TRUE;
}


void xeroxQueryBestSize(class, pwidth, pheight)
int class;
short *pwidth;
short *pheight;
{
    unsigned width, test;

    switch(class)
    {
      case CursorShape:
	  *pwidth = 16;
	  *pheight = 16;
	  break;
      case TileShape:
      case StippleShape:
	  width = *pwidth;
	  /* Return the closes power of two not less than what they gave me */
	  test = 0x80000000;
	  /* Find the highest 1 bit in the width given */
	  while(!(test & width))
	     test >>= 1;
	  /* If their number is greater than that, bump up to the next
	   *  power of two */
	  if((test - 1) & width)
	     test <<= 1;
	  *pwidth = test;
	  /* We don't care what height they use */
	  break;
    }
}