lcd_dvc.c

与Nucleus Plus配套的图形库

	return(rtnCode);
}


/* Function SetBitmap modifies the passed bitmap in the following ways:
	if argPAGE = PGALL: replaces the bitmaps rowtable with one to
		address all pages
	else: modifies the bitmaps existing rowtable to address the graphics
		page enumerated by the lower 8 bits of argPAGE.

NOTE!! These routines assume that the planes are all folded to one rowtable. 
    This is the case for all hardware that this function looks up in its
    supported table. */

void SetBitmap(int argPAGE, grafMap *argGMAP)
{
#define PGALL		255
#define pageCur		mapTable[4]
#define pageMax		mapTable[5]
#define pageScans	mapTable[6]
#define numDev2Pg	1

	word dev2Pg[numDev2Pg][3];	/* Device IDs and offsets to second page bitmap */
	word pg1Offset;
	short maxPages;
	long pageSize;
	long baseAdr;
	long **rowAdr;
	long **oldAdr;
	long pageOffset;
	short devCode;
	int i;
	int j;
	short grafErrValue;

	devCode = (short) argGMAP->devMode;
	for (i = 0; i < numDev2Pg; i++)
	{	/* look up device code in second page table */
		if (devCode == dev2Pg[i][0]) goto FoundIt;
	}

	grafErrValue = c_SetGrafM + c_InvDevFunc;
	nuGrafErr(grafErrValue);	/* post error */
	return;

FoundIt:
 	pg1Offset = dev2Pg[i][1];	/* offset to next page */
 	maxPages = dev2Pg[i][2];	/* max number of pages */

	/* what function are we doing? */
	if (argPAGE == PGALL)
	{	/* replace current rowtable with one large enough to access
		all pages of the display */
		pageSize = ((maxPages * argGMAP->pixHeight) + 1) << 2;
		rowAdr = (long **) GrafAlloc(pageSize);
		if (rowAdr == 0)	/* check for null returned */
		{
			grafErrValue = c_SetGrafM + c_OutofMem;
			nuGrafErr(grafErrValue);	/* post error */
			return;
		}

		oldAdr = argGMAP->mapTable[0];
		#ifdef FIXUP386
		/* unfixup the old dll relative maptable pointer to be ds relative */
		oldAdr -= dllFixup;
		#endif

        /* replace all 4 maptable entries with with new table */
        argGMAP->mapTable[0] = rowAdr;
        argGMAP->mapTable[1] = rowAdr;
        argGMAP->mapTable[2] = rowAdr;
        argGMAP->mapTable[3] = rowAdr;

		baseAdr = (long) *oldAdr;	/* get original base address */
        GrafFree(oldAdr);	/* chuck old rowtable */

		/* init rowtable sections for each page */
		for (j = 0; j < maxPages; j++)
		{
			for (i = 0; i < argGMAP->pixHeight; i++)
			{
				*rowAdr = (long *) (baseAdr + i * argGMAP->pixBytes);
				rowAdr++;
			}
			baseAdr += pg1Offset;	/* add offset for next time */
		}

		argGMAP->pixHeight *= maxPages;	/* update pixHeight */

		#ifdef FIXUP386
		/* fixup the ds relative maptable pointers to be dll relative */
		argGMAP->mapTable[0] += dllFixup;
		argGMAP->mapTable[1] += dllFixup;
		argGMAP->mapTable[2] += dllFixup;
		argGMAP->mapTable[3] += dllFixup;
		#endif
	}
	else
	{	/* adjust current rowtable to point to requested page */
		rowAdr = argGMAP->mapTable[0];	/* get the grafMaps rowtable 0 pointer */

		#ifdef FIXUP386
		/* unfixup the dll relative maptable pointer to be ds relative */
		rowAdr -= dllFixup;
		#endif

		argPAGE &= 0xFF;	/* mask all but low 8 bits */
 		if (argPAGE >= maxPages)	/* check for valid page request */
		{
			nuGrafErr(c_InvDevFunc);	/* post error */
			return;
		}

		/* compute signed offset from current page to requested page
		'fifth' planes maptable pointer holds current page */
		pageOffset = (argPAGE - (long) argGMAP->pageCur) * pg1Offset;
		if (pageOffset != 0)
		{	/* offset the (one and only) rowtable to new page */
			for (i = 0; i < argGMAP->pixHeight; i++)
			{
				*rowAdr += pageOffset;
				rowAdr++;
			}
			argGMAP->pageCur = (long **) argPAGE;	/* update current 'page' */
		}
	}
	return;
}

  
/* Function InitGrafDriver initializes the passed grafMap primitive pointers
using internal data associated with the passed grafMaps devTech field.  It
also inits bank manager and device manager using internal data associated
with the passed grafMaps devMode field.

Returns:  0 = OK, -1 = can't resolve driver. */
int InitGrafDriver(grafMap *argGRAFMAP)
{
	void InitBankMgr(grafMap *argGRAFMAP);
	void InitDevMgr(grafMap *argGRAFMAP);
	short grafErrValue;
	int retCode = 0;

	/* Device primitives function prototypes */
	void PrimErr(void);
	int iPrimErr(void);
	long lPrimErr(void);
	void mwFLLCD(blitRcd *fillRec);
	void mwPBSSLCD(blitRcd *blitRec);
	void mwPBSMLCD(blitRcd *blitRec);
	void mwPBMSLCD(blitRcd *blitRec);
	void mwPB1SLCD(blitRcd *blitRec);
	void mwRDIMLCD(grafMap * rdiBmap, image *dstImage, int gblYmax, int gblXmax,
			       int gblYmin, int gblXmin);
	void mwWRIMLCD(blitRcd *blitRec);
	void mwLILCD(blitRcd *lineRec);
	void mwSPLCD(blitRcd *setPRec);
	long mwGPLCD(int gblX, int gblY, grafMap *getpBmap);
	void mwFLA0(blitRcd *fillRec);
	void mwPBAAA(blitRcd *blitRec);
	void mwPBMAB(blitRcd *blitRec);
	void mwRDIMA(grafMap * rdiBmap, image *dstImage, int gblYmax, int gblXmax,
			     int gblYmin, int gblXmin);
	void mwWRIMA(blitRcd *blitRec);
	void mwLIA(blitRcd *lineRec);
	void mwSPA(blitRcd *setpRec);
	long mwGPA(int gblX, int gblY, grafMap *getpBmap);

	/* check that the devTech is in range */
	if (argGRAFMAP->devTech > 8)
	{	/* error */
		grafErrValue = c_InitBitm + c_BadDevTech;
		nuGrafErr(grafErrValue);
		retCode = -1;
	}

	switch (argGRAFMAP->devTech)
	{
	case 0:	/* LCD */
		argGRAFMAP->mapBankMgr = iPrimErr;	/* Ptr to bank manager function  */
		argGRAFMAP->mapPlaneMgr = PrimErr;	/* Ptr to plane manager function */
		argGRAFMAP->mapAltMgr = PrimErr;	/* Ptr to alt manager function   */
		argGRAFMAP->mapDevMgr = iPrimErr;	/* Ptr to device manager list    */       
		argGRAFMAP->prFill = mwFLLCD;		/* primitive vector for fills    */
		argGRAFMAP->prBlitSS = mwPBSSLCD;	/* primitive vector for self-self blits */
		argGRAFMAP->prBlit1S = mwPB1SLCD;	/* primitive vector for mono-self blits */
		argGRAFMAP->prBlitMS = mwPBMSLCD;	/* primitive vector for mem-self  blits */
		argGRAFMAP->prBlitSM = mwPBSMLCD;	/* primitive vector for self-mem  blits */
		argGRAFMAP->prRdImg = mwRDIMLCD;	/* primitive vector for read image */
		argGRAFMAP->prWrImg = mwWRIMLCD;	/* primitive vector for write image */
		argGRAFMAP->prLine = mwLILCD;		/* primitive vector for thin lines */
		argGRAFMAP->prSetPx = mwSPLCD;		/* primitive vector for set pixel */
		argGRAFMAP->prGetPx = mwGPLCD;		/* primitive vector for get pixel */
		break;
	case 8:	/* 8-Bit */
		argGRAFMAP->mapBankMgr = iPrimErr;	/* Ptr to bank manager function  */
		argGRAFMAP->mapPlaneMgr = PrimErr;	/* Ptr to plane manager function */
		argGRAFMAP->mapAltMgr = PrimErr;	/* Ptr to alt manager function   */
		argGRAFMAP->mapDevMgr = iPrimErr;	/* Ptr to device manager list    */       
		argGRAFMAP->prFill = mwFLA0;		/* primitive vector for fills    */
		argGRAFMAP->prBlitSS = mwPBAAA;		/* primitive vector for self-self blits */
		argGRAFMAP->prBlit1S = mwPBMAB;		/* primitive vector for mono-self blits */
		argGRAFMAP->prBlitMS = mwPBAAA;		/* primitive vector for mem-self  blits */
		argGRAFMAP->prBlitSM = mwPBAAA;		/* primitive vector for self-mem  blits */
		argGRAFMAP->prRdImg = mwRDIMA;		/* primitive vector for read image */
		argGRAFMAP->prWrImg = mwWRIMA;		/* primitive vector for write image */
		argGRAFMAP->prLine = mwLIA;			/* primitive vector for thin lines */
		argGRAFMAP->prSetPx = mwSPA;		/* primitive vector for set pixel */
		argGRAFMAP->prGetPx = mwGPA;		/* primitive vector for get pixel */
		break;
	default:/* Null */
		argGRAFMAP->mapBankMgr = iPrimErr;	/* Ptr to bank manager function  */
		argGRAFMAP->mapPlaneMgr = PrimErr;	/* Ptr to plane manager function */
		argGRAFMAP->mapAltMgr = PrimErr;	/* Ptr to alt manager function   */
		argGRAFMAP->mapDevMgr = iPrimErr;	/* Ptr to device manager list    */       
		argGRAFMAP->prFill = PrimErr;		/* primitive vector for fills    */
		argGRAFMAP->prBlitSS = PrimErr;		/* primitive vector for self-self blits */
		argGRAFMAP->prBlit1S = PrimErr;		/* primitive vector for mono-self blits */
		argGRAFMAP->prBlitMS = PrimErr;		/* primitive vector for mem-self  blits */
		argGRAFMAP->prBlitSM = PrimErr;		/* primitive vector for self-mem  blits */
		argGRAFMAP->prRdImg = PrimErr;		/* primitive vector for read image */
		argGRAFMAP->prWrImg = PrimErr;		/* primitive vector for write image */
		argGRAFMAP->prLine = PrimErr;		/* primitive vector for thin lines */
		argGRAFMAP->prSetPx = PrimErr;		/* primitive vector for set pixel */
		argGRAFMAP->prGetPx = lPrimErr;		/* primitive vector for get pixel */
	}

	/* init the bank and device managers from internal tables */
	InitBankMgr(argGRAFMAP);
	InitDevMgr(argGRAFMAP);

	return(retCode);
}


/* A stub CloseGrafDriver function */
int CloseGrafDriver(grafMap *argGRAFMAP)
{
	return(0);
}

/* Function InitBankMgr initializes the passed grafMaps bank/plane
managers and map fields using internal data associated with the grafMaps
devMode code.  If a device has no entry, BankStub and PlaneStub are used.
BankStub posts an error, as it should never be called.  PlaneStub is a
null routine, it justs updates mapWinPlane. */
void InitBankMgr(grafMap *argGRAFMAP)
{
	DBPstruc *bnkTblPtr;
	int i;

	/* look up device code in Graphics Device Table */
	for (i = 0; i < numDisplays; i++)
	{
		if(displayTable[i].devcName == -1)	/* not found */
		{
			argGRAFMAP->mapPlaneMgr = PlaneStub;
			return;
		}

		if((argGRAFMAP->devMode == displayTable[i].devcName) &&
			(displayTable[i].bnkTblPtr != NULL)) break;
	}

	/* Initialize the passed GrafMap for bank management */
	bnkTblPtr = displayTable[i].bnkTblPtr;
	argGRAFMAP->mapBankMgr = bnkTblPtr->bnkMgr;
	argGRAFMAP->mapPlaneMgr = bnkTblPtr->plnMgr;
	if (bnkTblPtr->wnType >= 0x80)
	{	/* has altMgr */
		argGRAFMAP->mapFlags |= mfAltMgr;
		argGRAFMAP->mapAltMgr = bnkTblPtr->altMgr;
	}

	argGRAFMAP->mapWinType = bnkTblPtr->wnType & 0x0f;
	argGRAFMAP->mapWinScans = bnkTblPtr->wnSize;
	argGRAFMAP->mapWinOffset = bnkTblPtr->wnOff;

	return;
}


/* Function InitDevMgr initializes the passed grafMaps device manager
and map handle fields using internal data associated with the grafMaps
devMode code. */
void InitDevMgr(grafMap *argGRAFMAP)
{
	int i;

	/* look up device code in Graphics Device Table */
	for (i = 0; i < numDisplays; i++)
	{
		if(displayTable[i].devcName == -1)
		{	/* not found */
			argGRAFMAP->mapDevMgr = DevStub;
			return;
		}

		if(argGRAFMAP->devMode == displayTable[i].devcName) break;
	}

	/* install  device manager */
	argGRAFMAP->mapDevMgr = displayTable[i].devTblPtr;

	return;
}


/* Function QueryGraphics determines if the requested device is
available.  The return values are:

  0 = present    (normal device manager ok return )
 -1 = can't tell (normal device manager bad return )
  1	= device detected as not present
  2	= Unknown device, not in table */
int QueryGraphics(int argDEV)
{
#define QRYDEVUNKN	2	/* Unknown device, not in table */
	grafMap testGM;
	int i;

	NU_InitGrafVars();	/* Initialize certain graphics variables */

	/* look up device code in Graphics Device Table */
	for (i = 0; i < numDisplays; i++)
	{
		if(displayTable[i].devcName == -1)  return(QRYDEVUNKN);

		if(argDEV == displayTable[i].devcName) break;
	}

	/* okay, we got a device in our table */
	testGM.mapDevMgr = displayTable[i].devTblPtr;

	/* issue devMgr call to query device there? */
	return(testGM.mapDevMgr(&testGM, DMQRY, argDEV));
}


/* Function LCDDevMgr initializes the passed grafMaps device manager
and map handle fields using internal data associated with the grafMaps
devMode code. */
int LCDDevMgr(grafMap *argGRAFMAP, int dmFunc, int dmParam)
{
	int LCD_Init(void);

/* BobB 5/5/98 - added following two lines to get rid of warnings */
	unsigned char LCD_ReadReg(int reg);
/*	void LCD_WriteReg(int reg, unsigned char n);*/
	byte b;

	if(dmFunc == DMWAKEUP) return(LCD_Init());

/* BobB 5/20/98 - removed the palette functions
	if(dmFunc == DMRPAL)
	if(dmFunc == DMWPAL) */

	if(dmFunc == DMQRY)
	{	/* check if the LCD is working */
		b = LCD_ReadReg(0x02);	/* read panel type */
		if (b != 0x1c) return(1);	/* not working if return */
	}

	return(0);
}


/* Function PrimErr supplied as primitives if error loading primitives */
void PrimErr(void)
{
	short grafErrValue;

	grafErrValue = c_InitBitm + c_InvDevFunc;
	nuGrafErr(grafErrValue);
	return;
}
int iPrimErr(void)
{
	short grafErrValue;

	grafErrValue = c_InitBitm + c_InvDevFunc;
	nuGrafErr(grafErrValue);
	return(0);
}
long lPrimErr(void)
{
	short grafErrValue;

	grafErrValue = c_InitBitm + c_InvDevFunc;
	nuGrafErr(grafErrValue);
	return(0);
}