/******************************Module*Header*******************************\
*
* Module Name: TEXTOUT.c
* Author: Martin Barber
* Date: Jun. 19, 1995
* Purpose: Handle calls to DrvTxtOut
*
* Copyright (c) 1995,1996 Cirrus Logic, Inc.
*
* $Log: X:/log/laguna/nt35/displays/cl546x/TEXTOUT.C $
*
* Rev 1.34 Mar 27 1998 14:47:14 frido
* PDR#11280. In the monospaced font loop there was a problem loading
* the pointer to the next glyph bits. It always got the pointer to the
* previous glyph.
*
* Rev 1.33 Mar 04 1998 15:38:46 frido
* Added new shadow macros.
*
* Rev 1.32 Dec 17 1997 16:42:14 frido
* PDR#10875: There was a GPF inside vMmClipGlyphExpansion and NT
* 3.51 does not handle this very well. It caused the hardware to wait for
* another DWORD which was never send.
*
* Rev 1.31 Dec 10 1997 13:32:20 frido
* Merged from 1.62 branch.
*
* Rev 1.30.1.1 Dec 03 1997 18:12:20 frido
* PDR#11039. Fixed allocation of font cache. In certain cases it would
* allocate too few cells and still use the unallocated cells causing
* corruption.
*
* Rev 1.30.1.0 Nov 18 1997 15:40:16 frido
* Changed a spelling error: RWQUIRE into REQUIRE.
*
* Rev 1.30 Nov 03 1997 10:17:36 frido
* Added REQUIRE and WRITE_STRING macros.
* Removed CHECK_QFREE macros.
*
* Rev 1.29 25 Aug 1997 16:07:24 FRIDO
*
* Fixed lockup in 8-bpp vMmClipGlyphExpansion SWAT7 code.
*
* Rev 1.28 08 Aug 1997 17:24:30 FRIDO
* Added support for new memory manager.
* Added SWAT7 switches for 8-bpp hardware bug.
*
* Rev 1.27 29 Apr 1997 16:28:50 noelv
*
* Merged in new SWAT code.
* SWAT:
* SWAT: Rev 1.7 24 Apr 1997 12:05:38 frido
* SWAT: Fixed a missing "}".
* SWAT:
* SWAT: Rev 1.6 24 Apr 1997 11:22:18 frido
* SWAT: NT140b09 merge.
* SWAT: Changed pfm into pCell for SWAT3 changes.
* SWAT:
* SWAT: Rev 1.5 19 Apr 1997 17:11:02 frido
* SWAT: Added SWAT.h include file.
* SWAT: Fixed a bug in DrvDestroyFont causing hangups in 2nd WB97 pass.
* SWAT:
* SWAT: Rev 1.4 18 Apr 1997 00:34:28 frido
* SWAT: Fixed a merge bug.
* SWAT:
* SWAT: Rev 1.3 18 Apr 1997 00:15:28 frido
* SWAT: NT140b07 merge.
* SWAT:
* SWAT: Rev 1.2 10 Apr 1997 16:02:06 frido
* SWAT: Oops, I allocated the font cache in the wrong size.
* SWAT:
* SWAT: Rev 1.1 09 Apr 1997 17:37:30 frido
* SWAT: New font cache allocation scheme. Allocate from a 'pool' of cells
* SWAT: instead of putting the font cache all over the place.
*
* Rev 1.26 08 Apr 1997 12:32:50 einkauf
*
* add SYNC_W_3D to coordinate MCD/2D hw access
*
* Rev 1.25 21 Mar 1997 13:37:06 noelv
* Added checkes for QFREE.
*
* Rev 1.24 06 Feb 1997 10:38:04 noelv
* Removed WAIT_FOR_IDLE
*
* Rev 1.23 04 Feb 1997 11:11:00 SueS
* Added support for hardware clipping for the 5465.
*
* Rev 1.22 17 Dec 1996 16:59:00 SueS
* Added test for writing to log file based on cursor at (0,0).
*
* Rev 1.21 26 Nov 1996 10:46:36 SueS
* Changed WriteLogFile parameters for buffering.
*
* Rev 1.20 13 Nov 1996 17:01:28 SueS
* Changed WriteFile calls to WriteLogFile.
*
* Rev 1.19 07 Nov 1996 16:10:16 bennyn
*
* Added no offscn mem allocation if DD enabled
*
* Rev 1.18 06 Sep 1996 15:16:44 noelv
* Updated NULL driver for 4.0
*
* Rev 1.17 20 Aug 1996 11:04:36 noelv
* Bugfix release from Frido 8-19-96
*
* Rev 1.3 16 Aug 1996 14:48:20 frido
* Fixed a small wanring error.
*
* Rev 1.2 15 Aug 1996 11:54:32 frido
* Fixed precompiled headers.
*
* Rev 1.1 15 Aug 1996 11:38:32 frido
* Added precompiled header.
*
* Rev 1.0 14 Aug 1996 17:16:32 frido
* Initial revision.
*
* Rev 1.16 25 Jul 1996 15:56:28 bennyn
*
* Modified to support DirectDraw
*
* Rev 1.15 28 May 1996 15:11:36 noelv
* Updated data logging.
*
* Rev 1.14 16 May 1996 15:06:18 bennyn
*
* Added PIXEL_ALIGN to allocoffscnmem()
*
* Rev 1.13 16 May 1996 14:54:32 noelv
* Added logging code.
*
* Rev 1.12 03 May 1996 15:09:42 noelv
*
* Added flag to turn caching on and off.
*
* Rev 1.11 01 May 1996 11:01:48 bennyn
*
* Modified for NT4.0
*
* Rev 1.10 12 Apr 1996 18:13:06 andys
* Fixed bug in combining 3 bytes into DWORD (<< | bug)
*
* Rev 1.9 11 Apr 1996 18:00:56 andys
* Added Code to the > 16 PEL case to guard against walking off the end of a b
*
* Rev 1.8 04 Apr 1996 13:20:32 noelv
* Frido release 26
*
* Rev 1.16 01 Apr 1996 15:29:22 frido
* Fixed bug in font cache when glyph cannot be cached.
*
* Rev 1.15 28 Mar 1996 23:37:34 frido
* Fixed drawing of partially left-clipped glyphs.
*
* Rev 1.14 27 Mar 1996 14:12:18 frido
* Commented changes.
*
* Rev 1.13 25 Mar 1996 11:58:38 frido
* Removed warning message.
*
* Rev 1.12 25 Mar 1996 11:50:42 frido
* Bellevue 102B03.
*
* Rev 1.5 18 Mar 1996 12:34:10 noelv
*
* Added data logging stuff
*
* Rev 1.4 07 Mar 1996 18:24:14 bennyn
*
* Removed read/modify/write on CONTROL reg
*
* Rev 1.3 05 Mar 1996 11:59:20 noelv
* Frido version 19
*
* Rev 1.11 04 Mar 1996 20:23:28 frido
* Cached grCONTROL register.
*
* Rev 1.10 29 Feb 1996 20:23:08 frido
* Changed some comments.
*
* Rev 1.9 28 Feb 1996 22:39:46 frido
* Added Optimize.h.
*
* Rev 1.8 27 Feb 1996 16:38:12 frido
* Added device bitmap store/restore.
*
* Rev 1.7 24 Feb 1996 01:23:16 frido
* Added device bitmaps.
*
* Rev 1.6 03 Feb 1996 13:57:24 frido
* Use the compile switch "-Dfrido=0" to disable my extensions.
*
* Rev 1.5 03 Feb 1996 12:17:58 frido
* Added text clipping.
*
* Rev 1.4 25 Jan 1996 12:45:56 frido
* Added reinitialization of font cache after mode switch.
*
* Rev 1.3 24 Jan 1996 23:10:16 frido
* Moved font cache and entry point to assembly for i386.
*
* Rev 1.2 23 Jan 1996 15:37:20 frido
* Added font cache.
*
\**************************************************************************/
#include "precomp.h"
#include "font.h"
#include "SWAT.h" // SWAT optimizations
#define TEXT_DBG_LEVEL 1
#define TEXT_DBG_LEVEL1 1
#define RECORD_ON FALSE
#define BUFFER_EXPAND FALSE
/*
-------------------------------------------------------------------------------
Module Entry Points:
--------------------
DrvTextOut()
General Plan:
--------------------
*
* On every TextOut, GDI provides an array of 'GLYPHPOS' structures
* for every glyph to be drawn. Each GLYPHPOS structure contains a
* the glyph. (Note that unlike Windows 3.1, which provides a column-
* major glyph bitmap, Windows NT always provides a row-major glyph
* bitmap.) As such, there are three basic methods for drawing text
* with hardware acceleration:
*
* 1) Glyph caching -- Glyph bitmaps are cached by the accelerator
* (probably in off-screen memory), and text is drawn by
* referring the hardware to the cached glyph locations.
*
* 2) Glyph expansion -- Each individual glyph is colour-expanded
* directly to the screen from the monochrome glyph bitmap
* supplied by GDI.
*
* 3) Buffer expansion -- The CPU is used to draw all the glyphs into
* a 1bpp monochrome bitmap, and the hardware is then used
* to colour-expand the result.
*
* The fastest method depends on a number of variables, such as the
* colour expansion speed, bus speed, CPU speed, average glyph size,
* and average string length.
*
* Copyright (c) 1992-1994 Microsoft Corporation
*
\**************************************************************************/
//
// Data logging stuff.
// Gets compiled out in a free bulid.
//
#if LOG_CALLS
char BUF[256];
#if ENABLE_LOG_SWITCH
#define LogFile(x) \
do { \
if (pointer_switch == 1) \
{ \
int i = sprintf x ; \
WriteLogFile(ppdev->pmfile, BUF, i, ppdev->TxtBuff, &ppdev->TxtBuffIndex); \
} \
} while(0); \
#else
#define LogFile(x) \
do { \
int i = sprintf x ; \
WriteLogFile(ppdev->pmfile, BUF, i, ppdev->TxtBuff, &ppdev->TxtBuffIndex); \
} while(0); \
#endif
#else
#define BUF 0
#define LogFile(x)
#endif
POINTL gptlZero = { 0, 0 }; // Specifies that the origin of the
// temporary buffer given to the 1bpp
// transfer routine for fasttext is
// at (0, 0)
/******************************Public*Routine******************************\
* void AddToFontCacheChain
*
* Add the FONTCACHE to the Font cache chain
*
\**************************************************************************/
void AddToFontCacheChain(PDEV* ppdev,
FONTOBJ* pfo,
PFONTCACHE pfc)
{
DISPDBG((TEXT_DBG_LEVEL1," AddToFontCacheChain.\n"));
pfc->pfo = pfo;
#if !SWAT3 // We don't need this anymore. The cell grid has all the pointers.
// Hook the font cache into the chain.
if (ppdev->pfcChain != NULL)
{
ppdev->pfcChain->pfcPrev = pfc;
}
pfc->pfcPrev = NULL;
pfc->pfcNext = ppdev->pfcChain;
ppdev->pfcChain = pfc;
#endif
}
/******************************Public*Routine******************************\
* BOOL bIntersect
*
* If 'prcl1' and 'prcl2' intersect, has a return value of TRUE and returns
* the intersection in 'prclResult'. If they don't intersect, has a return
* value of FALSE, and 'prclResult' is undefined.
*
\**************************************************************************/
BOOL bIntersect(
RECTL* prcl1,
RECTL* prcl2,
RECTL* prclResult)
{
DISPDBG((TEXT_DBG_LEVEL1," bIntersect.\n"));
prclResult->left = max(prcl1->left, prcl2->left);
prclResult->right = min(prcl1->right, prcl2->right);
if (prclResult->left < prclResult->right)
{
prclResult->top = max(prcl1->top, prcl2->top);
prclResult->bottom = min(prcl1->bottom, prcl2->bottom);
if (prclResult->top < prclResult->bottom)
{
return(TRUE);
}
}
return(FALSE);
}
/******************************Public*Routine******************************\
* LONG cIntersect
*
* This routine takes a list of rectangles from 'prclIn' and clips them
* in-place to the rectangle 'prclClip'. The input rectangles don't
* have to intersect 'prclClip'; the return value will reflect the
* number of input rectangles that did intersect, and the intersecting
* rectangles will be densely packed.
*
\**************************************************************************/
LONG cIntersect(
RECTL* prclClip,
RECTL* prclIn, // List of rectangles
LONG c) // Can be zero
{
LONG cIntersections;
RECTL* prclOut;
DISPDBG((TEXT_DBG_LEVEL1," cIntersect.\n"));
cIntersections = 0;
prclOut = prclIn;
for ( ; c != 0; prclIn++, c--)
{
prclOut->left = max(prclIn->left, prclClip->left);
prclOut->right = min(prclIn->right, prclClip->right);
if (prclOut->left < prclOut->right)
{
prclOut->top = max(prclIn->top, prclClip->top);
prclOut->bottom = min(prclIn->bottom, prclClip->bottom);
if (prclOut->top < prclOut->bottom)
{
prclOut++;
cIntersections++;
}
}
}
return(cIntersections);
}
/******************************Public*Routine******************************\
* VOID vClipSolid
*
* Fills the specified rectangles with the specified colour, honouring
* the requested clipping. No more than four rectangles should be passed in.
* Intended for drawing the areas of the opaquing rectangle that extend
* beyond the text box. The rectangles must be in left to right, top to
* bottom order. Assumes there is at least one rectangle in the list.
*
\**************************************************************************/
VOID vClipSolid(
PDEV* ppdev,
LONG crcl,
RECTL* prcl,
ULONG iColor,
CLIPOBJ* pco)
{
BOOL bMore; // Flag for clip enumeration
ENUMRECTS8 ce; // Clip enumeration object
ULONG i;
ULONG j;
#if !(DRIVER_5465 && HW_CLIPPING)
RECTL arclTmp[4];
ULONG crclTmp;
RECTL* prclTmp;
RECTL* prclClipTmp;
LONG iLastBottom;
#endif
RECTL* prclClip;
DISPDBG((TEXT_DBG_LEVEL1,"vClipSolid: Entry.\n"));
ASSERTMSG( (crcl > 0) && (crcl <= 4), "Expected 1 to 4 rectangles");
ASSERTMSG( (pco != NULL) && (pco->iDComplexity != DC_TRIVIAL),
"Expected a non-null clip object");
// Do the loop invariant setup here
REQUIRE(2);
LL_DRAWBLTDEF(SOLID_COLOR_FILL, 2);
if (pco->iDComplexity == DC_RECT)
{
crcl = cIntersect(&pco->rclBounds, prcl, crcl);
while (crcl--)
{
REQUIRE(5);
LL_OP0(prcl->left + ppdev->ptlOffset.x,
prcl->top + ppdev->ptlOffset.y);
LL_BLTEXT((prcl->right - prcl->left), (prcl->bottom - prcl->top));
prcl++;
}
}
else // iDComplexity == DC_COMPLEX
{
// Initialize the clip rectangle enumeration to right-down so we can
// take advantage of the rectangle list being right-down:
CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_RIGHTDOWN, 0);
#if DRIVER_5465 && HW_CLIPPING
// Set up the hardware clipping
REQUIRE(6);
LL_DRAWBLTDEF(SOLID_COLOR_FILL | DD_CLIPEN, 0);
i = max(0, prcl->left);
j = max(0, prcl->top);
LL_OP0(i + ppdev->ptlOffset.x, j + ppdev->ptlOffset.y);
LL_BLTEXT_EXT(prcl->right - i, prcl->bottom - j);
do
{
// Get a batch of region rectangles:
bMore = CLIPOBJ_bEnum(pco, sizeof(ce), (VOID*)&ce);
// Clip the rect list to each region rect:
for (j = ce.c, prclClip = ce.arcl; j-- > 0; prclClip++)
{
// Draw the clipped rects
REQUIRE(5);
LL_CLIPULE(prclClip->left + ppdev->ptlOffset.x,
prclClip->top + ppdev->ptlOffset.y);
LL_CLIPLOR_EX(prclClip->right + ppdev->ptlOffset.x,
prclClip->bottom + ppdev->ptlOffset.y);
} // End for each rectangle in the list.
} while (bMore); // End loop for each batch
#else
// Bottom of last rectangle to fill
iLastBottom = prcl[crcl - 1].bottom;
// Scan through all the clip rectangles, looking for intersects
// of fill areas with region rectangles:
do
{
// Get a batch of region rectangles:
bMore = CLIPOBJ_bEnum(pco, sizeof(ce), (VOID*)&ce);
// Clip the rect list to each region rect:
for (j = ce.c, prclClip = ce.arcl; j-- > 0; prclClip++)
{
// Since the rectangles and the region enumeration are both
// right-down, we can zip through the region until we reach
// the first fill rect, and are done when we've passed the
// last fill rect.
if (prclClip->top >= iLastBottom)
{
// Past last fill rectangle; nothing left to do:
return;
}
// Do intersection tests only if we've reached the top of
// the first rectangle to fill:
if (prclClip->bottom > prcl->top)
{
// We've reached the top Y scan of the first rect, so
// it's worth bothering checking for intersection.
// Generate a list of the rects clipped to this region
// rect:
prclTmp = prcl;
prclClipTmp = arclTmp;
for (i = crcl, crclTmp = 0; i-- != 0; prclTmp++)
{
// Intersect fill and clip rectangles
if (bIntersect(prclTmp, prclClip, prclClipTmp))
{
// Draw the clipped rects
REQUIRE(5);
LL_OP0(prclClipTmp->left + ppdev->ptlOffset.x,
prclClipTmp->top + ppdev->ptlOffset.y);
LL_BLTEXT ( (prclClipTmp->right - prclClipTmp->left) ,
(prclClipTmp->bottom - prclClipTmp->top) );
}
} // End for each rectangle in the batch.
} // End intersect test.
} // End for each rectangle in the list.
} while (bMore); // End loop for each batch
#endif // if !(DRIVER_5465 && HW_CLIPPING)
} // End DC_COMPLEX
}
#if SWAT7
/******************************Public*Routine******************************\
* VOID Xfer64Pixels
*
* Copy 64 pixels of font data to the Laguna memory.
*
\**************************************************************************/
VOID Xfer64Pixels(
PDEV* ppdev,
UINT x,
UINT y,
UINT bitOffset,
UINT height,
BYTE* pjGlyph,
UINT delta
)
{
delta = (delta + 7) >> 3;
REQUIRE(5);
LL_OP0(x + ppdev->ptlOffset.x, y + ppdev->ptlOffset.y);
LL_BLTEXT(64, height);
while (height--)
{
REQUIRE(3);
LL32(grHOSTDATA[0], *(ULONG*) &pjGlyph[0]);
LL32(grHOSTDATA[1], *(ULONG*) &pjGlyph[4]);
if (bitOffset > 0)
{
LL32(grHOSTDATA[2], pjGlyph[8]);
}
pjGlyph += delta;
}
}
#endif
/******************************Public*Routine******************************\
* VOID vMmClipGlyphExpansion
*
* Handles any strings that need to be clipped, using the 'glyph
* expansion' method.
*
\**************************************************************************/
VOID vMmClipGlyphExpansion(
PDEV* ppdev,
STROBJ* pstro,
CLIPOBJ* pco)
{
BOOL bMoreGlyphs;
ULONG cGlyphOriginal;
ULONG cGlyph;
GLYPHPOS* pgpOriginal;
GLYPHPOS* pgp;
GLYPHBITS* pgb;
POINTL ptlOrigin;
BOOL bMore;
ENUMRECTS8 ce;
RECTL* prclClip;
ULONG ulCharInc;
LONG cxGlyph;
LONG cyGlyph;
BYTE* pjGlyph;
BYTE* pTmp;
LONG cj;
LONG cw;
LONG xLeft;
LONG yTop;
LONG xRight;
LONG yBottom;
LONG xBias;
LONG lDelta;
LONG cx;
LONG cy;
#if SWAT7
UINT xOrigin;
#endif
DISPDBG((TEXT_DBG_LEVEL1,"vMmClipGlyphExpansion: Entry.\n"));
ASSERTMSG(pco != NULL, "Don't expect NULL clip objects here");
do // Loop for each batch of glyphs to be done.
{
//
// Get a batch of glyphs.
//
if (pstro->pgp != NULL)
{
// There's only the one batch of glyphs, so save ourselves
// a call:
pgpOriginal = pstro->pgp;
cGlyphOriginal = pstro->cGlyphs;
bMoreGlyphs = FALSE;
}
else
{
bMoreGlyphs = STROBJ_bEnum(pstro, &cGlyphOriginal, &pgpOriginal);
}
//
// cGlyphOrigional is the number of glyphs in the batch before they
// are clipped.
// bMoreGlyphs is TRUE if there are more batches to be done after
// this one.
//
if (cGlyphOriginal > 0) // Were there any glyphs in the batch?
{
ulCharInc = pstro->ulCharInc;
if (pco->iDComplexity == DC_RECT)
{
//
// We could call 'cEnumStart' and 'bEnum' when the clipping is
// DC_RECT, but the last time I checked, those two calls took
// more than 150 instructions to go through GDI. Since
// 'rclBounds' already contains the DC_RECT clip rectangle,
// and since it's such a common case, we'll special case it:
//
bMore = FALSE; // No more clip lists to do.
prclClip = &pco->rclBounds;
ce.c = 1; // Only one rectangle in this list.
goto SingleRectangle;
}
CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_ANY, 0);
do // For each list of rectangles.
{
bMore = CLIPOBJ_bEnum(pco, sizeof(ce), (ULONG*) &ce);
// For each rectangle in the list.
for (prclClip = &ce.arcl[0]; ce.c != 0; ce.c--, prclClip++)
{
SingleRectangle:
pgp = pgpOriginal;
cGlyph = cGlyphOriginal;
pgb = pgp->pgdf->pgb;
ptlOrigin.x = pgb->ptlOrigin.x + pgp->ptl.x;
ptlOrigin.y = pgb->ptlOrigin.y + pgp->ptl.y;
// Loop through all the glyphs for this rectangle:
while (TRUE)
{
LogFile((BUF, "GC:M\r\n"));
cxGlyph = pgb->sizlBitmap.cx;
cyGlyph = pgb->sizlBitmap.cy;
pjGlyph = pgb->aj;
#if SWAT7
lDelta = (cxGlyph + 7) >> 3;
#endif
if ((prclClip->left <= ptlOrigin.x) &&
(prclClip->top <= ptlOrigin.y) &&
(prclClip->right >= ptlOrigin.x + cxGlyph) &&
(prclClip->bottom >= ptlOrigin.y + cyGlyph))
{
//-----------------------------------------------------
// Unclipped glyph
#if SWAT7
xOrigin = ptlOrigin.x;
#endif
#if SWAT7
//
// Test for 5465AD hardware bug in 8-bpp.
//
if ( (cxGlyph > 64) && (cxGlyph < 128)
&& (ppdev->iBytesPerPixel == 1)
)
{
Xfer64Pixels(ppdev, xOrigin, ptlOrigin.y, 0,
cyGlyph, pjGlyph, cxGlyph);
pjGlyph += 64 / 8;
xOrigin += 64;
cxGlyph -= 64;
}
REQUIRE(5);
LL_OP0(xOrigin + ppdev->ptlOffset.x,
ptlOrigin.y + ppdev->ptlOffset.y);
#else
REQUIRE(5);
LL_OP0(ptlOrigin.x + ppdev->ptlOffset.x,
ptlOrigin.y + ppdev->ptlOffset.y);
#endif
LL_BLTEXT(cxGlyph, cyGlyph);
if (cxGlyph <= 8)
{
//-----------------------------------------------------
// 1 to 8 pels in width
while ( cyGlyph-- )
{
REQUIRE(1);
#if SWAT7
LL32 (grHOSTDATA[0], *pjGlyph);
pjGlyph += lDelta;
#else
LL32 (grHOSTDATA[0], *pjGlyph++);
#endif
}
}
else if (cxGlyph <= 16)
{
//-----------------------------------------------------
// 9 to 16 pels in width
while ( cyGlyph-- )
{
REQUIRE(1);
#if SWAT7
LL32 (grHOSTDATA[0], *(USHORT*)pjGlyph);
pjGlyph += lDelta;
#else
LL32 (grHOSTDATA[0], *((USHORT*)pjGlyph)++);
#endif
}
}
else
{
//-----------------------------------------------------
// More than 16 pels in width
#if SWAT7
cw = (cxGlyph + 31) >> 5;
#else
lDelta = (pgb->sizlBitmap.cx + 7) >> 3;
cw = (lDelta + 3) >> 2;
#endif
pTmp = pjGlyph + lDelta * pgb->sizlBitmap.cy;
for (;cyGlyph!=1; cyGlyph--)
{
WRITE_STRING(pjGlyph, cw);
pjGlyph += lDelta;
}
{
ULONG *pSrc = (ULONG*) pjGlyph + cw - 1;
WRITE_STRING(pjGlyph, cw - 1);
if ((BYTE *)pSrc+4<=pTmp)
{
REQUIRE(1);
LL32 (grHOSTDATA[0], *pSrc++ );
}
else
{
int Extra = (ULONG) pTmp - (ULONG) pSrc;
BYTE * pByte = (BYTE *)pSrc;
ULONG ulData;
DISPDBG((TEXT_DBG_LEVEL1,
"Caught it %s %d %d %x %x\n", __FILE__, __LINE__, Extra, pTmp, pSrc));
if (Extra == 1)
ulData = (ULONG)(*pByte);
else if (Extra == 2)
ulData = (ULONG)(*(USHORT*)pByte);
else
ulData = (((ULONG)*(pByte+2) << 8) | (ULONG)*(pByte+1)) << 8 | *pByte;
REQUIRE(1);
LL32 (grHOSTDATA[0], ulData );
}
}
} // End 16 pels or wider.
} // End unclipped glyph.
else
{
//-----------------------------------------------------
// Clipped glyph
// Find the intersection of the glyph rectangle
// and the clip rectangle:
xLeft = max(prclClip->left, ptlOrigin.x);
yTop = max(prclClip->top, ptlOrigin.y);
xRight = min(prclClip->right, ptlOrigin.x + cxGlyph);
yBottom = min(prclClip->bottom, ptlOrigin.y + cyGlyph);
// Check for trivial rejection:
if (((cx = xRight - xLeft) > 0) &&
((cy = yBottom - yTop) > 0))
{
xBias = (xLeft - ptlOrigin.x) & 7;
// 'xBias' is the bit position in the monochrome glyph
// bitmap of the first pixel to be lit, relative to
// the start of the byte. That is, if 'xBias' is 2,
// then the first unclipped pixel is represented by bit
// 2 of the corresponding bitmap byte.
//
// Normally, the accelerator expects bit 0 to be the
// first lit byte. We set the host phase to discard the
// first 'xBias' bits.
//
if ( xBias )
{
REQUIRE(2);
LL_OP2_MONO (xBias,0);
}
#if !SWAT7
REQUIRE(5);
LL_OP0(xLeft + ppdev->ptlOffset.x,
yTop + ppdev->ptlOffset.y);
LL_BLTEXT (cx, cy);
#endif
lDelta = (cxGlyph + 7) >> 3;
// compute the end-of-glyph marker before
// clipping the glyph.
pTmp = pjGlyph + lDelta * cy;
pjGlyph += (yTop - ptlOrigin.y) * lDelta
+ ((xLeft - ptlOrigin.x) >> 3);
#if SWAT7
//
// Test for 5465AD hardware bug in 8-bpp.
//
if ( (cx > 64) && (cx < 128)
&& (ppdev->iBytesPerPixel == 1)
)
{
Xfer64Pixels(ppdev, xLeft, yTop, xBias, cy,
pjGlyph, cxGlyph);
pjGlyph += 64 / 8;
xLeft += 64;
cx -= 64;
}
REQUIRE(5);
LL_OP0(xLeft + ppdev->ptlOffset.x,
yTop + ppdev->ptlOffset.y);
LL_BLTEXT (cx, cy);
#endif
cj = (cx + xBias + 31) >> 5;
for (;cy!=1; cy--)
{
WRITE_STRING(pjGlyph, cj);
pjGlyph += lDelta;
}
{
ULONG *pSrc = (ULONG*) pjGlyph + cj - 1;
int Extra = (ULONG) pTmp - (ULONG) pSrc;
BYTE * pByte = (BYTE *)pSrc;
ULONG ulData;
WRITE_STRING(pjGlyph, cj - 1);
if (Extra == 1)
ulData = (ULONG)(*pByte);
else if (Extra == 2)
ulData = (ULONG)(*(USHORT*)pByte);
else if (Extra == 3)
ulData = (((ULONG)*(pByte+2) << 8) | (ULONG)*(pByte+1)) << 8 | *pByte;
else
ulData = *pSrc;
REQUIRE(1);
LL32 (grHOSTDATA[0], ulData );
}
if (xBias != 0)
{
REQUIRE(2);
LL_OP2_MONO(0,0);
}
} // if not trivially rejected.
} // End clipped glyph.
//
// If we're out of glyphs the get next batch.
if (--cGlyph == 0)
break;
// Get ready for next glyph:
pgp++;
pgb = pgp->pgdf->pgb;
//
// Calculate where to place the next glyph.
// If this is mono spaced text, we may need to
// skip over some pixels to make our characters
// line up.
//
if (ulCharInc == 0)
{
ptlOrigin.x = pgp->ptl.x + pgb->ptlOrigin.x;
ptlOrigin.y = pgp->ptl.y + pgb->ptlOrigin.y;
}
else
{
ptlOrigin.x += ulCharInc;
}
} // End loop for each glyph in the batch.
} // End for each rectangle in the list.
} while (bMore); // Loop for each batch of clipping rectangles.
} // If there were any glyphs in this batch.
} while (bMoreGlyphs); // Loop for each batch of glyphs.
} // End clipped glyph expansion.
/******************************Public*Routine******************************\
* BOOL DrvTextOut
*
* If it's the fastest method, outputs text using the 'glyph expansion'
* method. Each individual glyph is colour-expanded directly to the
* screen from the monochrome glyph bitmap supplied by GDI.
*
* If it's not the fastest method, calls the routine that implements the
* 'buffer expansion' method.
*
\**************************************************************************/
#if (USE_ASM && defined(i386))
BOOL i386DrvTextOut(
#else
BOOL APIENTRY DrvTextOut(
#endif
SURFOBJ* pso,
STROBJ* pstro,
FONTOBJ* pfo,
CLIPOBJ* pco,
RECTL* prclExtra, // If we had set GCAPS_HORIZSTRIKE, we would have
// to fill these extra rectangles (it is used
// largely for underlines). It's not a big
// performance win (GDI will call our DrvBitBlt
// to draw the extra rectangles).
RECTL* prclOpaque,
BRUSHOBJ* pboFore,
BRUSHOBJ* pboOpaque,
POINTL* pptlBrush,
MIX mix)
{
PDEV* ppdev;
BOOL bTextPerfectFit;
ULONG cGlyph;
BOOL bMoreGlyphs;
GLYPHPOS* pgp;
GLYPHBITS* pgb;
BYTE* pjGlyph;
BYTE* pTmp;
#if SWAT7
LONG cxGlyph;
#endif
LONG cyGlyph;
POINTL ptlOrigin;
LONG ulCharInc;
BYTE iDComplexity;
LONG lDelta;
LONG cw;
ULONG iFGColor;
ULONG iBGColor;
ULONG bitCount;
#if SWAT7
UINT xOrigin;
#endif
#if NULL_TEXTOUT
{
if (pointer_switch) return TRUE;
}
#endif
DISPDBG((TEXT_DBG_LEVEL,"DrvTextOut: Entry.\n"));
// The DDI spec says we'll only ever get foreground and background
// mixes of R2_COPYPEN:
ASSERTMSG(mix == 0x0d0d, "GDI should only give us a copy mix");
ppdev = (PDEV*) pso->dhpdev;
SYNC_W_3D(ppdev); // if 3D context(s) active, make sure 3D engine idle before continuing...
if (pso->iType == STYPE_DEVBITMAP)
{
PDSURF pdsurf = (PDSURF)pso->dhsurf;
LogFile((BUF, "DTO Id=%p ", pdsurf));
if (pdsurf->pso)
{
if ( !bCreateScreenFromDib(ppdev, pdsurf) )
{
LogFile((BUF, "DTO: D=DH (punted)\r\n"));
return(EngTextOut(pdsurf->pso, pstro, pfo, pco, prclExtra,
prclOpaque, pboFore, pboOpaque, pptlBrush, mix));
}
else
{
LogFile((BUF, "DTO: D=DF "));
}
}
else
{
LogFile((BUF, "DTO: D=D "));
}
ppdev->ptlOffset.x = pdsurf->ptl.x;
ppdev->ptlOffset.y = pdsurf->ptl.y;
}
else
{
LogFile((BUF, "DTO: D=S "));
ppdev->ptlOffset.x = ppdev->ptlOffset.y = 0;
}
//
// Dump information about the call to the log file.
//
LogFile((BUF, "FG=%X BG=%X ",
pboFore->iSolidColor, pboOpaque->iSolidColor));
LogFile((BUF, "C=%s ",
(pco == NULL) ? "N " :
((pco->iDComplexity == DC_TRIVIAL) ? "T" :
((pco->iDComplexity == DC_RECT) ? "R" : "C" ))
));
LogFile((BUF, "%s ", (prclOpaque != NULL) ? "O" : "T"));
LogFile((BUF, "%s ", (pstro->ulCharInc == 0) ? "P" : "M"));
#if !(USE_ASM && defined(i386))
// If we have a font that is cached but the screen has been reinitialized,
// we delete the font from memory and try again.
if (ppdev->UseFontCache == 0)
pfo->pvConsumer = (VOID*) -1;
if (pfo->pvConsumer != NULL && pfo->pvConsumer != (PVOID) -1)
{
if (((PFONTCACHE) pfo->pvConsumer)->ulFontCount != ppdev->ulFontCount)
{
LogFile((BUF, "FCD "));
DrvDestroyFont(pfo);
}
else
LogFile((BUF, "GC=2 "));
}
if (pfo->pvConsumer == (PVOID) -1)
{
LogFile((BUF, "GC=3"));
}
// If we have a font that has not yet been cached, try caching it.
if (pfo->pvConsumer == NULL)
{
// New font, check it out.
int height = pstro->rclBkGround.bottom - pstro->rclBkGround.top;
LogFile((BUF, "GC="));
#if SWAT3
if (height > FONTCELL_Y * 3 / 2)
#else
if (height > LINES_PER_TILE * 3 / 2)
#endif
{
// Font too big, mark is as uncacheable.
LogFile((BUF, "0size "));
pfo->pvConsumer = (PVOID) -1;
}
else
{
// Allocate memory for the font cache.
#ifdef WINNT_VER40
pfo->pvConsumer = MEM_ALLOC(FL_ZERO_MEMORY, sizeof(FONTCACHE), ALLOC_TAG);
#else
pfo->pvConsumer = MEM_ALLOC(LMEM_FIXED | LMEM_ZEROINIT, sizeof(FONTCACHE));
#endif
if (pfo->pvConsumer == NULL)
{
// Not enough memory, mark it as uncacheable.
LogFile((BUF, "0mem "));
pfo->pvConsumer = (PVOID) -1;
}
else
{
LogFile((BUF, "1 "));
AddToFontCacheChain(ppdev, pfo, pfo->pvConsumer);
// Store device this font belongs to.
((PFONTCACHE) pfo->pvConsumer)->ppdev = ppdev;
}
}
}
#endif
// Set FG / BG colors at this level
iFGColor = pboFore->iSolidColor;
iBGColor = pboOpaque->iSolidColor;
switch (ppdev->iBitmapFormat)
{
case BMF_8BPP:
iFGColor |= iFGColor << 8;
iBGColor |= iBGColor << 8;
case BMF_16BPP:
iFGColor |= iFGColor << 16;
iBGColor |= iBGColor << 16;
break;
}
iDComplexity = (pco == NULL) ? DC_TRIVIAL : pco->iDComplexity;
#if !(USE_ASM && defined(i386))
// Can we use the font cache?
if ( (pfo->pvConsumer != (PVOID) -1) && (iDComplexity != DC_COMPLEX)
&& (((PFONTCACHE) pfo->pvConsumer)->ppdev == ppdev))
{
// Set color registers.
REQUIRE(4);
LL_BGCOLOR(iBGColor, 2);
LL_FGCOLOR(iFGColor, 2);
if (prclOpaque != NULL)
{
#if LOG_CALLS
#define FIT_FLAGS (SO_ZERO_BEARINGS | \
SO_FLAG_DEFAULT_PLACEMENT | \
SO_MAXEXT_EQUAL_BM_SIDE | \
SO_CHAR_INC_EQUAL_BM_BASE)
bTextPerfectFit =
(pstro->flAccel & FIT_FLAGS) == FIT_FLAGS;
if (!(bTextPerfectFit) ||
(pstro->rclBkGround.top > prclOpaque->top) ||
(pstro->rclBkGround.left > prclOpaque->left) ||
(pstro->rclBkGround.right < prclOpaque->right) ||
(pstro->rclBkGround.bottom < prclOpaque->bottom))
{
LogFile((BUF, "FIT=N "));
}
else
{
LogFile((BUF, "FIT=Y "));
}
#endif
// Draw opaqueing rectangle.
if (iDComplexity == DC_TRIVIAL)
{
REQUIRE(7);
LL_DRAWBLTDEF(SOLID_COLOR_FILL, 0);
LL_OP0(prclOpaque->left + ppdev->ptlOffset.x,
prclOpaque->top + ppdev->ptlOffset.y);
LL_BLTEXT(prclOpaque->right - prclOpaque->left,
prclOpaque->bottom - prclOpaque->top);
}
else
{
LONG x, y, cx, cy;
x = max(prclOpaque->left, pco->rclBounds.left);
y = max(prclOpaque->top, pco->rclBounds.top);
cx = min(prclOpaque->right, pco->rclBounds.right) - x;
cy = min(prclOpaque->bottom, pco->rclBounds.bottom) - y;
if ( (cx > 0) && (cy > 0) )
{
REQUIRE(7);
LL_DRAWBLTDEF(SOLID_COLOR_FILL, 0);
LL_OP0(x + ppdev->ptlOffset.x, y + ppdev->ptlOffset.y);
LL_BLTEXT(cx, cy);
}
}
}
// Enable bit swizzling and set DRAWBLTDEF.
ppdev->grCONTROL |= SWIZ_CNTL;
LL16(grCONTROL, ppdev->grCONTROL);
REQUIRE(2);
LL_DRAWBLTDEF(CACHE_EXPAND_XPAR, 2);
LogFile((BUF, "UC"));
LogFile((BUF, "\r\n"));
// Call the font cache handler.
if (iDComplexity == DC_TRIVIAL)
{
FontCache((PFONTCACHE) pfo->pvConsumer, pstro);
}
else
{
ClipCache((PFONTCACHE) pfo->pvConsumer, pstro, pco->rclBounds);
}
// Disable bit swizzling.
ppdev->grCONTROL = ppdev->grCONTROL & ~SWIZ_CNTL;
LL16(grCONTROL, ppdev->grCONTROL);
return(TRUE);
}
#endif
DISPDBG((TEXT_DBG_LEVEL1,"DrvTextOut: Setting FG/BG Color.\n"));
REQUIRE(4);
LL_BGCOLOR(iBGColor, 2);
LL_FGCOLOR(iFGColor, 2);
ppdev->grCONTROL |= SWIZ_CNTL;
LL16(grCONTROL, ppdev->grCONTROL);
if (prclOpaque != NULL)
{
DISPDBG((TEXT_DBG_LEVEL1,"DrvTextOut: Setting Opaque.\n"));
////////////////////////////////////////////////////////////
// Opaque Initialization
////////////////////////////////////////////////////////////
//
// If we paint the glyphs in 'opaque' mode, we may not actually
// have to draw the opaquing rectangle up-front -- the process
// of laying down all the glyphs will automatically cover all
// of the pixels in the opaquing rectangle.
//
// The condition that must be satisfied is that the text must
// fit 'perfectly' such that the entire background rectangle is
// covered, and none of the glyphs overlap (if the glyphs
// overlap, such as for italics, they have to be drawn in
// transparent mode after the opaquing rectangle is cleared).
//
#define PERFECT_FIT_FLAGS (SO_ZERO_BEARINGS | \
SO_FLAG_DEFAULT_PLACEMENT | \
SO_MAXEXT_EQUAL_BM_SIDE | \
SO_CHAR_INC_EQUAL_BM_BASE)
bTextPerfectFit =
(pstro->flAccel & PERFECT_FIT_FLAGS) == PERFECT_FIT_FLAGS;
if (!(bTextPerfectFit) ||
(pstro->rclBkGround.top > prclOpaque->top) ||
(pstro->rclBkGround.left > prclOpaque->left) ||
(pstro->rclBkGround.right < prclOpaque->right)||
(pstro->rclBkGround.bottom < prclOpaque->bottom))
{
//
// Draw opaquing rectangle.
//
if (iDComplexity == DC_TRIVIAL)
{
DISPDBG((TEXT_DBG_LEVEL1,"DrvTextOut: Opaque DC_TRIVIAL.\n"));
REQUIRE(7);
LL_DRAWBLTDEF(SOLID_COLOR_FILL, 0);
LL_OP0(prclOpaque->left + ppdev->ptlOffset.x,
prclOpaque->top + ppdev->ptlOffset.y);
LL_BLTEXT ((prclOpaque->right - prclOpaque->left) ,
(prclOpaque->bottom - prclOpaque->top) );
}
else
{
vClipSolid(ppdev, 1, prclOpaque, pboOpaque->iSolidColor, pco);
}
LogFile((BUF, "FIT=N "));
// Opaquing rectangle has been drawn, now
// we do transparent text.
}
else
{
LogFile((BUF, "FIT=Y "));
// We don't have to draw the opaquing rectangle because
// the text is an exact fit.
goto TextInitOpaque;
}
} // End (prclOpaque != NULL)
LogFile((BUF, "\r\n"));
////////////////////////////////////////////////////////////
// Transparent Initialization
////////////////////////////////////////////////////////////
// Initialize the hardware for transparent text:
//
// Set the chip up to do transparent text.
//
DISPDBG((TEXT_DBG_LEVEL1,"DrvTextOut: Setting XPAR Text.\n"));
LL_DRAWBLTDEF(TEXT_EXPAND_XPAR, 2);
goto TextInitDone;
TextInitOpaque:
//
// Set the chip up to do opaque text.
// Any opaquing rectangle needed has been drawn by now.
//
DISPDBG((TEXT_DBG_LEVEL1,"DrvTextOut: Setting Opaque Text.\n"));
LL_DRAWBLTDEF(TEXT_EXPAND_OPAQUE, 2);
TextInitDone:
//
// We're all set up to do either opaque or transparent text.
// If necessary, any opaquing has been done by now.
// So let's draw some glyphs on the screen.
//
REQUIRE(2);
LL_OP2_MONO (0,0); // Set Zero phase for transfers
if (iDComplexity == DC_TRIVIAL)
{
do // Loop while there are glyphs to draw.
{
//
// Get a batch of glyphs to draw.
//
if (pstro->pgp != NULL)
{
DISPDBG((TEXT_DBG_LEVEL1,"DrvTextOut: One batch of Glyphs.\n"));
// There's only the one batch of glyphs, so save ourselves
// a call:
pgp = pstro->pgp;
cGlyph = pstro->cGlyphs;
bMoreGlyphs = FALSE;
}
else
{
DISPDBG((TEXT_DBG_LEVEL1,
"DrvTextOut: Calling STROBJ_bEnum for Glyphs.\n"));
bMoreGlyphs = STROBJ_bEnum(pstro, &cGlyph, &pgp);
}
//
// cGlyph is the count of glyphs in this batch.
// bMorGlyphs is TRUE if there is another batch waiting for
// us after this one.
//
if (cGlyph > 0)
{
//
// Check the type of spacing.
//
if (pstro->ulCharInc == 0)
{
///////////////////////////////////////////////////////////
// Proportional Spacing
DISPDBG((TEXT_DBG_LEVEL1,
"DrvTextOut: Proportional Spacing.\n"));
while (TRUE) // Loop once for each Glyph.
{
pgb = pgp->pgdf->pgb;
LogFile((BUF, "GC:M\r\n"));
#if !SWAT7
REQUIRE(5);
LL_OP0(pgp->ptl.x + pgb->ptlOrigin.x + ppdev->ptlOffset.x,
pgp->ptl.y + pgb->ptlOrigin.y + ppdev->ptlOffset.y);
LL_BLTEXT (pgb->sizlBitmap.cx, pgb->sizlBitmap.cy);
#endif
#if SWAT7
xOrigin = pgp->ptl.x + pgb->ptlOrigin.x;
cxGlyph = pgb->sizlBitmap.cx;
lDelta = (cxGlyph + 7) >> 3;
#endif
pjGlyph = pgb->aj;
cyGlyph = pgb->sizlBitmap.cy;
#if SWAT7
//
// Test for 5465AD hardware bug in 8-bpp.
//
if ( (cxGlyph > 64) && (cxGlyph < 128)
&& (ppdev->iBytesPerPixel == 1)
)
{
Xfer64Pixels(ppdev, xOrigin, pgp->ptl.y +
pgb->ptlOrigin.y, 0, cyGlyph, pjGlyph,
cxGlyph);
pjGlyph += 64 / 8;
xOrigin += 64;
cxGlyph -= 64;
}
REQUIRE(5);
LL_OP0(xOrigin + ppdev->ptlOffset.x, pgp->ptl.y +
pgb->ptlOrigin.y + ppdev->ptlOffset.y);
LL_BLTEXT (cxGlyph, cyGlyph);
#endif
// The monochrome bitmap describing the glyph is
// byte-aligned. This means that if the glyph is
// 1 to 8 pels in width, each row of the glyph is
// defined in consecutive bytes; if the glyph is 9
// to 16 pels in width, each row of the glyph is
// defined in consecutive words, etc.
//
#if SWAT7
if (cxGlyph <= 8)
#else
if (pgb->sizlBitmap.cx <= 8)
#endif
{
//--------------------------------------------------
// 1 to 8 pels in width
// 91% of all glyphs will go through this path.
while (cyGlyph--)
#if SWAT7
{
REQUIRE(1);
LL32(grHOSTDATA[0], *pjGlyph);
pjGlyph += lDelta;
}
#else
REQUIRE(1);
LL32 (grHOSTDATA[0], *pjGlyph++);
// We're a bit tricky here in order to avoid letting
// the compiler tail-merge this code (which would
// add an extra jump):
pgp++;
if (--cGlyph != 0)
continue; // Go do the next glyph.
break; // Done with all glyphs in this batch.
// breakout of Glyph Loop.
#endif
}
#if SWAT7
else if (cxGlyph <= 16)
#else
else if (pgb->sizlBitmap.cx <= 16)
#endif
{
//--------------------------------------------------
// 9 to 16 pels in width
// 5% of all glyphs will go through this path.
while ( cyGlyph-- )
#if SWAT7
{
REQUIRE(1);
LL32(grHOSTDATA[0], *(USHORT*)pjGlyph);
pjGlyph += lDelta;
}
#else
REQUIRE(1);
LL32 (grHOSTDATA[0], *((USHORT*)pjGlyph)++);
#endif
}
else
{
//--------------------------------------------------
// More than 16 pels in width
#if SWAT7
cw = (cxGlyph + 31) >> 5;
#else
lDelta = (pgb->sizlBitmap.cx + 7) >> 3;
cw = (lDelta + 3) >> 2;
#endif
pTmp = pjGlyph + lDelta * pgb->sizlBitmap.cy;
for (;cyGlyph!=1; cyGlyph--)
{
WRITE_STRING(pjGlyph, cw);
pjGlyph += lDelta;
}
{
ULONG *pSrc = (ULONG*) pjGlyph + cw - 1;
WRITE_STRING(pjGlyph, cw - 1);
if ((BYTE *)pSrc+4<=pTmp)
{
REQUIRE(1);
LL32 (grHOSTDATA[0], *pSrc++ );
}
else
{
int Extra = (ULONG) pTmp - (ULONG) pSrc;
BYTE * pByte = (BYTE *)pSrc;
ULONG ulData;
DISPDBG((TEXT_DBG_LEVEL1,
"Caught it %s %d %d %x %x\n", __FILE__, __LINE__, Extra, pTmp, pSrc));
if (Extra == 1)
ulData = (ULONG)(*pByte);
else if (Extra == 2)
ulData = (ULONG)(*(USHORT*)pByte);
else
ulData = (((ULONG)*(pByte+2) << 8) | (ULONG)*(pByte+1)) << 8 | *pByte;
REQUIRE(1);
LL32 (grHOSTDATA[0], ulData );
}
}
} // END pel width test.
pgp++; // Next glyph
if (--cGlyph == 0)
break; // Done with this batch.
// Break out of the Glyph Loop.
} // End Glyph Loop.
} // End porportional characters.
else
{
////////////////////////////////////////////////////////////
// Mono Spacing
DISPDBG((TEXT_DBG_LEVEL1,"DrvTextOut: Mono Spacing.\n"));
ulCharInc = pstro->ulCharInc;
pgb = pgp->pgdf->pgb;
ptlOrigin.x = pgb->ptlOrigin.x + pgp->ptl.x;
ptlOrigin.y = pgb->ptlOrigin.y + pgp->ptl.y;
while (TRUE) // Loop once for each Glyph in the batch.
{
LogFile((BUF, "GC:M\r\n"));
pgb = pgp->pgdf->pgb;
#if !SWAT7
REQUIRE(5);
LL_OP0(ptlOrigin.x + ppdev->ptlOffset.x,
ptlOrigin.y + ppdev->ptlOffset.y);
ptlOrigin.x += ulCharInc;
LL_BLTEXT (pgb->sizlBitmap.cx, pgb->sizlBitmap.cy);
#endif
pjGlyph = pgb->aj;
cyGlyph = pgb->sizlBitmap.cy;
#if SWAT7
xOrigin = ptlOrigin.x;
cxGlyph = pgb->sizlBitmap.cx;
lDelta = (cxGlyph + 7) >> 3;
//
// Test for 5465AD hardware bug in 8-bpp.
//
if ( (cxGlyph > 64) && (cxGlyph < 128)
&& (ppdev->iBytesPerPixel == 1)
)
{
Xfer64Pixels(ppdev, xOrigin, ptlOrigin.y, 0,
cyGlyph, pjGlyph, cxGlyph);
pjGlyph += 64 / 8;
xOrigin += 64;
cxGlyph -= 64;
}
REQUIRE(5);
LL_OP0(xOrigin + ppdev->ptlOffset.x,
ptlOrigin.y + ppdev->ptlOffset.y);
ptlOrigin.x += ulCharInc;
LL_BLTEXT (cxGlyph, cyGlyph);
#endif
//
// Note: Mono spacing does not guarantee that all the
// glyphs are the same size -- that is, we cannot
// move the size check out of this inner loop,
// unless we key off some more of the STROBJ
// accelerator flags.
// We are not guarenteed the Glyphs are the same size,
// only that they are the same distance apart.
//
#if SWAT7
if (cxGlyph <= 8)
#else
if (pgb->sizlBitmap.cx <= 8)
#endif
{
//-----------------------------------------------------
// 1 to 8 pels in width
while ( cyGlyph-- )
#if SWAT7
{
REQUIRE(1);
LL32(grHOSTDATA[0], *pjGlyph);
pjGlyph += lDelta;
}
#else
REQUIRE(1);
LL32 (grHOSTDATA[0], *pjGlyph++);
#endif
}
#if SWAT7
else if (cxGlyph <= 16)
#else
else if (pgb->sizlBitmap.cx <= 16)
#endif
{
//-----------------------------------------------------
// 9 to 16 pels in width
while ( cyGlyph-- )
#if SWAT7
{
REQUIRE(1);
LL32(grHOSTDATA[0], *(USHORT*)pjGlyph);
pjGlyph += lDelta;
}
#else
REQUIRE(1);
LL32 (grHOSTDATA[0], *((USHORT*)pjGlyph)++);
#endif
}
else
{
//-----------------------------------------------------
// More than 16 pels in width
#if SWAT7
cw = (cxGlyph + 31) >> 5;
#else
lDelta = (pgb->sizlBitmap.cx + 7) >> 3;
cw = (lDelta + 3) >> 2;
#endif
pTmp = pjGlyph + lDelta * pgb->sizlBitmap.cy;
for (;cyGlyph!=1; cyGlyph--)
{
WRITE_STRING(pjGlyph, cw);
pjGlyph += lDelta;
}
{
ULONG *pSrc = (ULONG*) pjGlyph + cw - 1;
WRITE_STRING(pjGlyph, cw - 1);
if ((BYTE *)pSrc+4<=pTmp)
{
REQUIRE(1);
LL32 (grHOSTDATA[0], *pSrc++ );
}
else
{
int Extra = (ULONG) pTmp - (ULONG) pSrc;
BYTE * pByte = (BYTE *)pSrc;
ULONG ulData;
DISPDBG((TEXT_DBG_LEVEL1,
"Caught it %s %d %d %x %x\n",
__FILE__, __LINE__, Extra, pTmp, pSrc));
if (Extra == 1)
ulData = (ULONG)(*pByte);
else if (Extra == 2)
ulData = (ULONG)(*(USHORT*)pByte);
else
ulData = (((ULONG)*(pByte+2) << 8) | (ULONG)*(pByte+1)) << 8 | *pByte;
REQUIRE(1);
LL32 (grHOSTDATA[0], ulData );
}
}
} // End more than 16 pels wide.
pgp++;
if (--cGlyph == 0) // We are done with this batch
break; // of glyphs. Break out of the glyph loop.
} // End Glyph Loop.
} // End Mono Spacing.
} // End if (cGlyph > 0)
//
// Done with this batch of Glyphs.
// Go get the next one.
//
} while (bMoreGlyphs);
} // End DC_TRIVIAL
else
{
// If there's clipping, call off to a function:
vMmClipGlyphExpansion(ppdev, pstro, pco);
}
ppdev->grCONTROL = ppdev->grCONTROL & ~SWIZ_CNTL;
LL16(grCONTROL, ppdev->grCONTROL);
return(TRUE);
} // End DrvTextOut.
/******************************Public*Routine******************************\
* BOOL bEnableText
*
* Performs the necessary setup for the text drawing subcomponent.
*
\**************************************************************************/
BOOL bEnableText(
PDEV* ppdev)
{
// Our text algorithms require no initialization. If we were to
// do glyph caching, we would probably want to allocate off-screen
// memory and do a bunch of other stuff here.
DISPDBG((TEXT_DBG_LEVEL,"bEnableText: Entry.\n"));
#if RECORD_ON
LL( RECORD, 1); // Switch on
LL( RECORD, 2); // Pause
DISPDBG((TEXT_DBG_LEVEL1,"xbEnableText: Recording Paused.\n"));
#endif
return(TRUE);
}
/******************************Public*Routine******************************\
* VOID vDisableText
*
* Performs the necessary clean-up for the text drawing subcomponent.
*
\**************************************************************************/
VOID vDisableText(PDEV* ppdev)
{
// Here we free any stuff allocated in 'bEnableText'.
DISPDBG((TEXT_DBG_LEVEL,"vDisableText: Entry.\n"));
}
#if !SWAT3
#pragma optimize("", off) // Microsoft doesn't know how to do compile...
#endif
/******************************Public*Routine******************************\
* VOID vAssertModeText
*
* Disables or re-enables the text drawing subcomponent in preparation for
* full-screen entry/exit.
*
\**************************************************************************/
VOID vAssertModeText(
PDEV* ppdev,
BOOL bEnable)
{
#if SWAT3
SIZEL sizl;
POINTL pos;
int i;
if (bEnable)
{
// We are enabling the screen again, so allocate the font cache if it
// is not yet allocated.
if (ppdev->pofmFontCache == NULL)
{
#if MEMMGR
sizl.cx = ppdev->lDeltaScreen / FONTCELL_X;
#else
//sizl.cx = ppdev->cxMemory;
sizl.cx = ppdev->lDeltaScreen / ppdev->iBytesPerPixel / FONTCELL_X;
#endif
sizl.cy = (FONTCELL_COUNT + sizl.cx - 1) / sizl.cx;
sizl.cx *= FONTCELL_X;
sizl.cy *= FONTCELL_Y;
ppdev->pofmFontCache = AllocOffScnMem(ppdev, &sizl, 0, NULL);
//ppdev->pofmFontCache = AllocOffScnMem(ppdev, &sizl,
// PIXEL_AlIGN, NULL);
}
if (ppdev->pofmFontCache != NULL)
{
// Clear the entire font cell array.
pos.x = pos.y = 0;
for (i = 0; i < FONTCELL_COUNT; i++)
{
if (pos.y >= sizl.cy)
{
ppdev->fcGrid[i].x = 0;
ppdev->fcGrid[i].y = 0;
ppdev->fcGrid[i].pfc = (PFONTCACHE) -1;
}
else
{
ppdev->fcGrid[i].x = ppdev->pofmFontCache->x + pos.x;
ppdev->fcGrid[i].y = ppdev->pofmFontCache->y + pos.y;
ppdev->fcGrid[i].pfc = NULL;
ppdev->fcGrid[i].ulLastX = 0;
ppdev->fcGrid[i].pNext = NULL;
pos.x += FONTCELL_X;
if (pos.x >= (LONG) ppdev->cxMemory)
{
pos.x = 0;
pos.y += FONTCELL_Y;
}
}
}
}
}
else
{
// We are disabling the screen so destroy all cached fonts.
if (ppdev->pofmFontCache != NULL)
{
for (i = 0; i < FONTCELL_COUNT; i++)
{
if ( (ppdev->fcGrid[i].pfc != NULL)
&& (ppdev->fcGrid[i].pfc != (PFONTCACHE) -1)
)
{
DrvDestroyFont(ppdev->fcGrid[i].pfc->pfo);
}
}
// Free the font cache cells.
FreeOffScnMem(ppdev, ppdev->pofmFontCache);
ppdev->pofmFontCache = NULL;
}
}
#elif !SWAT3
if (!bEnable)
{
// Remove all chained fonts.
PFONTCACHE p = ppdev->pfcChain;
while (p != NULL)
{
DrvDestroyFont(p->pfo);
p = ppdev->pfcChain;
}
}
#endif // SWAT3
}
#if !SWAT3
#pragma optimize("", on)
#endif
#if SWAT3
/******************************************************************************\
* PFONTCELL fcAllocCell(PFONTCACGE pfc)
*
* Allocate a font cell for the given font cache. Returns NULL if there are no
* more empty font cells.
\******************************************************************************/
PFONTCELL fcAllocCell(PFONTCACHE pfc)
{
int i;
PPDEV ppdev = pfc->ppdev;
PFONTCELL p = ppdev->fcGrid;
if (ppdev->pofmFontCache == NULL)
{
// Font cache is disabled, return NULL.
return NULL;
}
for (i = 0; i < FONTCELL_COUNT; i++, p++)
{
if (p->pfc == NULL)
{
p->pfc = pfc;
return p;
}
}
return NULL;
}
/******************************************************************************\
* void fcFreeCell(PFONTCELL pCell)
*
* Mark the given font cell as free.
\******************************************************************************/
void fcFreeCell(PFONTCELL pCell)
{
pCell->pfc = NULL;
pCell->ulLastX = 0;
pCell->pNext = NULL;
}
#endif // SWAT3
/******************************Public*Routine******************************\
* VOID DrvDestroyFont
*
* We're being notified that the given font is being deallocated; clean up
* anything we've stashed in the 'pvConsumer' field of the 'pfo'.
*
\**************************************************************************/
VOID DrvDestroyFont(FONTOBJ *pfo)
{
DISPDBG((TEXT_DBG_LEVEL, "DrvDestroyFont Entry\n"));
if (pfo->pvConsumer != NULL && pfo->pvConsumer != (PVOID) -1)
{
PFONTCACHE pfc = (PFONTCACHE) pfo->pvConsumer;
#if SWAT3
PFONTCELL pCell, pCellNext;
#else
PFONTMEMORY pfm, pfmNext;
#endif
PPDEV ppdev;
ppdev = pfc->ppdev;
LogFile((BUF, "DrvDestroyFont: "));
#if SWAT3
for (pCell = pfc->pFontCell; pCell != NULL; pCell = pCellNext)
{
pCellNext = pCell->pNext;
fcFreeCell(pCell);
}
LogFile((BUF, "\r\n"));
#else
for (pfm = pfc->pFontMemory; pfm != NULL; pfm = pfmNext)
{
pfmNext = pfm->pNext;
if (pfm->pTile != NULL)
{
FreeOffScnMem(pfc->ppdev, pfm->pTile);
}
MEMORY_FREE(pfm);
}
// Unhook the font cache from the chain.
if (pfc->pfcPrev != NULL)
{
pfc->pfcPrev->pfcNext = pfc->pfcNext;
}
else
{
ppdev->pfcChain = pfc->pfcNext;
}
if (pfc->pfcNext != NULL)
{
pfc->pfcNext->pfcPrev = pfc->pfcPrev;
}
#endif
LogFile((BUF, "\r\n"));
MEMORY_FREE(pfc);
}
pfo->pvConsumer = NULL;
DISPDBG((TEXT_DBG_LEVEL, "DrvDestroyFont Exit\n"));
}
/*
* GetGlyphSize
*
* Get the size (in pixels) of the requested glyph. Return the width of the
* glyph in bytes or 0 if the glyph is too big to cache.
*
*/
long GetGlyphSize(
GLYPHBITS* pgb, // Pointer to glyph.
POINTL* pptlOrigin, // Pointer to return origin in.
DWORD* pcSize // Pointer to return size in.
)
{
long x, y, height = 0;
BYTE* pByte = pgb->aj;
int i;
x = (pgb->sizlBitmap.cx + 7) >> 3; // get width in bytes
if (x > 0)
{
// find first line in glyph that contains data
for (y = 0; y < pgb->sizlBitmap.cy; y++, pByte += x)
{
// walk trough every byte on a line
for (i = 0; i < x; i++)
{
if (pByte[i]) // we have data, so we are at the first line
{
// find the last line in te glyph that contains data
height = pgb->sizlBitmap.cy - y;
for (pByte += (height - 1) * x; height > 0; height--)
{
// walk trough every byte on a line
for (i = 0; i < x; i++)
{
if (pByte[i])
{
// test height of glyph
#if SWAT3
if (height > FONTCELL_Y)
#else
if (height > LINES_PER_TILE)
#endif
{
// glyph too big, mark it as uncacheable
*pcSize = (DWORD) -1;
return(0);
}
// fill return parameters
pptlOrigin->y = y;
*pcSize = PACK_XY(pgb->sizlBitmap.cx, height);
return(x);
}
}
pByte -= x;
}
}
}
}
}
// glyph is empty
*pcSize = 0;
return(0);
}
/*
* AllocFontCache
*
* Allocate the requsted memory in off-screen memory. Return TRUE and the x,y
* coordinates of the upper left corner of this region, or FALSE if there is
* not enough memory.
*
*/
BOOL AllocFontCache(
PFONTCACHE pfc, // Pointer to font cache.
long cWidth, // Width (in bytes) to allocate.
long cHeight, // Height to allocate.
POINTL* ppnt // Point to return cooridinate in.
)
{
#if SWAT3
PFONTCELL pCell;
#else
SIZEL sizl;
PFONTMEMORY pfm;
#endif
long x;
PPDEV ppdev = pfc->ppdev;
#if !SWAT3
if (ppdev->iBytesPerPixel == 3)
{
sizl.cx = (128 + 2) / 3;
}
else
{
sizl.cx = 128 / ppdev->iBytesPerPixel;
}
sizl.cy = 16;
#endif
#if SWAT3
if (pfc->pFontCell == NULL)
{
pfc->pFontCell = fcAllocCell(pfc);
}
#else
if (pfc->pFontMemory == NULL)
{
pfc->pFontMemory = (PFONTMEMORY)
#ifdef WINNT_VER40
MEM_ALLOC(FL_ZERO_MEMORY, sizeof(FONTMEMORY), ALLOC_TAG);
#else
MEM_ALLOC(LMEM_FIXED | LMEM_ZEROINIT, sizeof(FONTMEMORY));
#endif
}
#endif
#if SWAT3
for (pCell = pfc->pFontCell; pCell != NULL; pCell = pCell->pNext)
{
x = pCell->ulLastX;
if (x + cWidth <= FONTCELL_X)
{
pCell->ulLastX += cWidth;
ppnt->x = pCell->x + x;
ppnt->y = pCell->y;
return TRUE;
}
if (pCell->pNext == NULL)
{
pCell->pNext = fcAllocCell(pfc);
}
}
#else
for (pfm = pfc->pFontMemory; pfm; pfm = pfm->pNext)
{
if (pfm->pTile == NULL)
{
#ifdef ALLOC_IN_CREATESURFACE
if (!ppdev->bDirectDrawInUse)
#endif
pfm->pTile = AllocOffScnMem(ppdev, &sizl, PIXEL_AlIGN, NULL);
if (pfm->pTile == NULL)
{
return FALSE;
}
ppnt->x = pfm->pTile->x;
ppnt->y = pfm->pTile->y;
pfm->ulLastX = cWidth;
return TRUE;
}
x = pfm->ulLastX;
if (x + cWidth <= BYTES_PER_TILE)
{
pfm->ulLastX += cWidth;
ppnt->x = pfm->pTile->x + x;
ppnt->y = pfm->pTile->y;
return TRUE;
}
if (pfm->pNext == NULL)
{
pfm->pNext = (PFONTMEMORY)
#ifdef WINNT_VER40
MEM_ALLOC(FL_ZERO_MEMORY, sizeof(FONTMEMORY), ALLOC_TAG);
#else
MEM_ALLOC(LMEM_FIXED | LMEM_ZEROINIT, sizeof(FONTMEMORY));
#endif
}
}
#endif
return FALSE;
}
/*
* AllocGlyph
*
* Allocate memory for the requested glyph and copy the glyph into off-screen
* memory. If there is not enough off-screen memory left, or the glyph is too
* large to glyph, return FALSE, otherwise return TRUE.
*
*/
VOID AllocGlyph(
PFONTCACHE pfc, // pointer to font cache
GLYPHBITS* pgb, // pointer to glyph to cache
GLYPHCACHE* pgc // pointer to glyph cache structure
)
{
long cBytes;
BYTE *pOffScreen, *pSrc;
long y;
PDEV *ppdev;
POINTL pointl;
ppdev = pfc->ppdev;
cBytes = GetGlyphSize(pgb, &pgc->ptlOrigin, &pgc->cSize);
if (cBytes == 0)
{
pgc->xyPos = (DWORD) -1;
LogFile((BUF, "GC:F\r\n"));
return;
}
if (AllocFontCache(pfc, cBytes, pgc->cSize >> 16, &pointl) == FALSE)
{
pgc->cSize = (DWORD) -1;
LogFile((BUF, "GC:F\r\n"));
return;
}
pOffScreen = ppdev->pjScreen + pointl.x + pointl.y * ppdev->lDeltaScreen;
pSrc = &pgb->aj[pgc->ptlOrigin.y * cBytes];
y = (long) (pgc->cSize >> 16);
if (cBytes == sizeof(BYTE))
{
while (y-- > 0)
{
*pOffScreen = Swiz[*pSrc];
pOffScreen += ppdev->lDeltaScreen;
pSrc += sizeof(BYTE);
}
}
else
{
while (y-- > 0)
{
long lDelta = ppdev->lDeltaScreen - cBytes;
long i;
for (i = cBytes; i > 0; i--)
{
*pOffScreen++ = Swiz[*pSrc++];
}
pOffScreen += lDelta;
}
}
pgc->xyPos = PACK_XY(pointl.x * 8, pointl.y);
pgc->ptlOrigin.x = pgb->ptlOrigin.x;
pgc->ptlOrigin.y += pgb->ptlOrigin.y;
LogFile((BUF, "GC:S\r\n"));
}
#if !(USE_ASM && defined(i386))
/*
* FontCache
*
* Draw glyphs using the off-screen font cache.
*
*/
VOID FontCache(
PFONTCACHE pfc, // Pointer to font cache.
STROBJ* pstro // Pointer to glyphs.
)
{
PDEV* ppdev;
BOOL bMoreGlyphs = TRUE;
ULONG cGlyph;
GLYPHPOS* pgp;
POINTL ptlOrigin;
PGLYPHCACHE pgc;
ULONG ulCharInc;
// set pointer to physical device
ppdev = pfc->ppdev;
// loop until there are no more glyphs to process
while (bMoreGlyphs)
{
if (pstro->pgp != NULL)
{
// we have just one set of glyphs
pgp = pstro->pgp;
cGlyph = pstro->cGlyphs;
bMoreGlyphs = FALSE;
}
else
{
// enumerate a set of glyphs
bMoreGlyphs = STROBJ_bEnum(pstro, &cGlyph, &pgp);
}
if (pstro->ulCharInc)
{
// fixed fonts... get x and y coordinates of first glyph
ptlOrigin.x = pgp->ptl.x;
ptlOrigin.y = pgp->ptl.y;
// get glyph increment
ulCharInc = pstro->ulCharInc;
// walk through all glyphs
while (cGlyph-- > 0)
{
if (pgp->hg < MAX_GLYPHS)
{
// this glyph index is cacheable
pgc = &pfc->aGlyphs[pgp->hg];
if (pgc->xyPos == 0)
{
// cache the glyph
AllocGlyph(pfc, pgp->pgdf->pgb, pgc);
}
if ((long) pgc->cSize > 0)
{
LogFile((BUF, "GC:H\r\n"));
// the glyph is cached, blit it on the screen
REQUIRE(7);
LL_OP0(ptlOrigin.x + pgc->ptlOrigin.x + ppdev->ptlOffset.x,
ptlOrigin.y + pgc->ptlOrigin.y + ppdev->ptlOffset.y);
LL32 (grOP2_opMRDRAM, pgc->xyPos);
LL32 (grBLTEXT_EX.dw, pgc->cSize);
}
else if ((long) pgc->cSize == -1)
{
// the glyph is uncacheable, draw it directly
DrawGlyph(ppdev, pgp->pgdf->pgb, ptlOrigin);
}
}
else
{
// the glyph index is out of range, draw it directly
DrawGlyph(ppdev, pgp->pgdf->pgb, ptlOrigin);
}
// increment glyph x coordinate
ptlOrigin.x += ulCharInc;
// next glyph
pgp++;
}
}
else
{
// variable width fonts, walk trough all glyphs
while (cGlyph-- > 0)
{
if (pgp->hg < MAX_GLYPHS)
{
// this glyph index is cacheable
pgc = &pfc->aGlyphs[pgp->hg];
if (pgc->xyPos == 0)
{
// cache the glyph
AllocGlyph(pfc, pgp->pgdf->pgb, pgc);
}
if ((long) pgc->cSize > 0)
{
LogFile((BUF, "GC:H\r\n"));
// the glyph is cached, blit it on the screen
REQUIRE(7);
LL_OP0(pgp->ptl.x + pgc->ptlOrigin.x + ppdev->ptlOffset.x,
pgp->ptl.y + pgc->ptlOrigin.y + ppdev->ptlOffset.y);
LL32 (grOP2_opMRDRAM, pgc->xyPos);
LL32 (grBLTEXT_EX.dw, pgc->cSize);
}
else if ((long) pgc->cSize == -1)
{
// the glyph is uncacheable, draw it directly
DrawGlyph(ppdev, pgp->pgdf->pgb, pgp->ptl);
}
}
else
{
// the glyph index is out of range, draw it directly
DrawGlyph(ppdev, pgp->pgdf->pgb, pgp->ptl);
}
// next glyph
pgp++;
}
}
}
}
/*
* DrawGlyph
*
* Draw glyphs directly on the screen.
*
*/
VOID DrawGlyph(
PDEV* ppdev, // Pointer to physical device.
GLYPHBITS* pgb, // Pointer to glyph to draw.
POINTL ptl // Location of glyph.
)
{
BYTE* pjGlyph;
ULONG cyGlyph;
#if SWAT7
ULONG cxGlyph;
ULONG xOrigin;
LONG lDelta;
#endif
LogFile((BUF, "GC:M\r\n"));
#if SWAT7
xOrigin = ptl.x + pgb->ptlOrigin.x;
cxGlyph = pgb->sizlBitmap.cx;
cyGlyph = pgb->sizlBitmap.cy;
pjGlyph = pgb->aj;
lDelta = (cxGlyph + 7) >> 3;
#endif
// start the blit
REQUIRE(4);
LL_DRAWBLTDEF(TEXT_EXPAND_XPAR, 0);
LL_OP2_MONO(0, 0);
#if !SWAT7
REQUIRE(5);
LL_OP0(ptl.x + pgb->ptlOrigin.x + ppdev->ptlOffset.x,
ptl.y + pgb->ptlOrigin.y + ppdev->ptlOffset.y);
LL_BLTEXT(pgb->sizlBitmap.cx, pgb->sizlBitmap.cy);
pjGlyph = pgb->aj;
cyGlyph = pgb->sizlBitmap.cy;
#endif
#if SWAT7
//
// Test for 5465AD hardware bug in 8-bpp.
//
if ( (cxGlyph > 64) && (cxGlyph < 128)
&& (ppdev->iBytesPerPixel == 1)
)
{
Xfer64Pixels(ppdev, xOrigin, ptl.y + pgb->ptlOrigin.y, 0, cyGlyph,
pjGlyph, cxGlyph);
pjGlyph += 64 / 8;
xOrigin += 64;
cxGlyph -= 64;
}
REQUIRE(5);
LL_OP0(xOrigin + ppdev->ptlOffset.x,
ptl.y + pgb->ptlOrigin.y + ppdev->ptlOffset.y);
LL_BLTEXT(cxGlyph, cyGlyph);
#endif
#if SWAT7
if (cxGlyph <= 8)
#else
if (pgb->sizlBitmap.cx <= 8)
#endif
{
// just one byte per line
while (cyGlyph--)
{
REQUIRE(1);
LL32 (grHOSTDATA[0], *pjGlyph);
#if SWAT7
pjGlyph += lDelta;
#else
pjGlyph++;
#endif
}
}
#if SWAT7
else if (cxGlyph <= 16)
#else
else if (pgb->sizlBitmap.cx <= 16)
#endif
{
// just two bytes per line
while (cyGlyph--)
{
REQUIRE(1);
LL32 (grHOSTDATA[0], *(WORD *) pjGlyph);
#if SWAT7
pjGlyph += lDelta;
#else
pjGlyph += 2;
#endif
}
}
#if SWAT7
else if (cxGlyph <= 24)
#else
else if (pgb->sizlBitmap.cx <= 24)
#endif
{
// just three bytes per line
while (cyGlyph--)
{
REQUIRE(1);
LL32 (grHOSTDATA[0], *(DWORD *) pjGlyph);
#if SWAT7
pjGlyph += lDelta;
#else
pjGlyph += 3;
#endif
}
}
#if SWAT7
else if (cxGlyph <= 32)
#else
else if (pgb->sizlBitmap.cx <= 32)
#endif
{
// just four bytes per line
while (cyGlyph--)
{
REQUIRE(1);
LL32 (grHOSTDATA[0], *(DWORD *) pjGlyph);
#if SWAT7
pjGlyph += lDelta;
#else
pjGlyph += 4;
#endif
}
}
else
{
// any number of bytes per line
#if SWAT7
int cw = (cxGlyph + 31) >> 5;
#else
long lDelta = (pgb->sizlBitmap.cx + 7) >> 3;
int cw = (lDelta + 3) >> 2;
#endif
BYTE * pTmp = pjGlyph + lDelta * pgb->sizlBitmap.cy;
for (;cyGlyph!=1; cyGlyph--)
{
WRITE_STRING(pjGlyph, cw);
pjGlyph += lDelta;
}
{
ULONG *pSrc = (ULONG*) pjGlyph + cw - 1;
WRITE_STRING(pjGlyph, cw - 1);
if ((BYTE *)pSrc+4<=pTmp)
{
REQUIRE(1);
LL32 (grHOSTDATA[0], *pSrc++ );
}
else
{
int Extra = (ULONG) pTmp - (ULONG) pSrc;
BYTE * pByte = (BYTE *)pSrc;
ULONG ulData;
DISPDBG((TEXT_DBG_LEVEL1,
"Caught it %s %d %d %x %x\n",
__FILE__, __LINE__, Extra, pTmp, pSrc));
if (Extra == 1)
ulData = (ULONG)(*pByte);
else if (Extra == 2)
ulData = (ULONG)(*(USHORT*)pByte);
else
ulData = (((ULONG)*(pByte+2) << 8) | (ULONG)*(pByte+1)) << 8 | *pByte;
REQUIRE(1);
LL32 (grHOSTDATA[0], ulData );
}
}
}
// reset to transparent cache expansion
LL_DRAWBLTDEF(CACHE_EXPAND_XPAR, 2);
}
VOID ClipCache(
PFONTCACHE pfc, // Pointer to font cache.
STROBJ* pstro, // Pointer to glyphs.
RECTL rclBounds // Clipping rectangle.
)
{
PDEV* ppdev;
BOOL bMoreGlyphs = TRUE;
ULONG cGlyph;
GLYPHPOS* pgp;
POINTL ptlOrigin;
PGLYPHCACHE pgc;
ULONG ulCharInc;
// set pointer to physical device
ppdev = pfc->ppdev;
// loop until there are no more glyphs to process
while (bMoreGlyphs)
{
if (pstro->pgp != NULL)
{
// we have just one set of glyphs
pgp = pstro->pgp;
cGlyph = pstro->cGlyphs;
bMoreGlyphs = FALSE;
}
else
{
// enumerate a set of glyphs
bMoreGlyphs = STROBJ_bEnum(pstro, &cGlyph, &pgp);
}
// get x and y coordinates of first glyph
ptlOrigin.x = pgp->ptl.x;
ptlOrigin.y = pgp->ptl.y;
// get glyph increment
ulCharInc = pstro->ulCharInc;
// walk through all glyphs
while (cGlyph-- > 0)
{
if (pgp->hg < MAX_GLYPHS)
{
// this glyph index is cacheable
pgc = &pfc->aGlyphs[pgp->hg];
if (pgc->xyPos == 0)
{
// cache the glyph
AllocGlyph(pfc, pgp->pgdf->pgb, pgc);
}
if ((long) pgc->cSize > 0)
{
RECTL rcl;
LONG i, cx, cy;
ULONG xyPos;
// the glyph is cached, ckeck clipping
rcl.left = ptlOrigin.x + pgc->ptlOrigin.x;
rcl.top = ptlOrigin.y + pgc->ptlOrigin.y;
rcl.right = rcl.left + (pgc->cSize & 0x0000FFFF);
rcl.bottom = rcl.top + (pgc->cSize >> 16);
xyPos = pgc->xyPos;
i = rclBounds.left - rcl.left;
if (i > 0)
{
// the glyph is partially clipped on the left, draw it
// directly
ClipGlyph(ppdev, pgp->pgdf->pgb, ptlOrigin, rclBounds);
}
else
{
LogFile((BUF, "GC:H\r\n"));
cx = min(rcl.right, rclBounds.right) - rcl.left;
if (cx > 0)
{
i = rclBounds.top - rcl.top;
if (i > 0)
{
rcl.top += i;
xyPos += i << 16;
}
cy = min(rcl.bottom, rclBounds.bottom) - rcl.top;
if (cy > 0)
{
REQUIRE(7);
LL_OP0(rcl.left + ppdev->ptlOffset.x,
rcl.top + ppdev->ptlOffset.y);
LL32(grOP2_opMRDRAM, xyPos);
LL_BLTEXT(cx, cy);
}
}
}
}
else if ((long) pgc->cSize == -1)
{
// the glyph is uncacheable, draw it directly
ClipGlyph(ppdev, pgp->pgdf->pgb, ptlOrigin, rclBounds);
}
}
else
{
// the glyph index is out of range, draw it directly
ClipGlyph(ppdev, pgp->pgdf->pgb, ptlOrigin, rclBounds);
}
// next glyph
pgp++;
if (ulCharInc == 0)
{
ptlOrigin.x = pgp->ptl.x;
ptlOrigin.y = pgp->ptl.y;
}
else
{
// increment glyph x coordinate
ptlOrigin.x += ulCharInc;
}
}
}
}
VOID ClipGlyph(
PDEV* ppdev, // Pointer to physical device.
GLYPHBITS* pgb, // Pointer to glyph to draw.
POINTL ptl, // Location of glyph.
RECTL rclBounds // Clipping rectangle.
)
{
BYTE* pjGlyph;
LONG cx, cy, lDelta, i;
RECTL rcl;
ULONG xBit;
LogFile((BUF, "GC:M\r\n"));
rcl.left = ptl.x + pgb->ptlOrigin.x;
rcl.top = ptl.y + pgb->ptlOrigin.y;
rcl.right = rcl.left + pgb->sizlBitmap.cx;
rcl.bottom = rcl.top + pgb->sizlBitmap.cy;
xBit = 0;
pjGlyph = pgb->aj;
lDelta = (pgb->sizlBitmap.cx + 7) >> 3;
i = rclBounds.left - rcl.left;
if (i > 0)
{
pjGlyph += i >> 3;
xBit = i & 7;
rcl.left += i;
}
cx = min(rcl.right, rclBounds.right) - rcl.left;
if (cx > 0)
{
i = rclBounds.top - rcl.top;
if (i > 0)
{
pjGlyph += i * lDelta;
rcl.top += i;
}
cy = min(rcl.bottom, rclBounds.bottom) - rcl.top;
if (cy > 0)
{
// start the blit
REQUIRE(4);
LL_DRAWBLTDEF(TEXT_EXPAND_XPAR, 0);
LL_OP2(xBit, 0);
#if SWAT7
//
// Test for 5465AD hardware bug in 8-bpp.
//
if ((cx > 64) && (cx < 128) && (ppdev->iBytesPerPixel == 1))
{
Xfer64Pixels(ppdev, rcl.left, rcl.top, xBit, cy, pjGlyph,
pgb->sizlBitmap.cx);
pjGlyph += 64 / 8;
rcl.left += 64;
cx -= 64;
}
#endif
REQUIRE(5);
LL_OP0(rcl.left + ppdev->ptlOffset.x,
rcl.top + ppdev->ptlOffset.y);
LL_BLTEXT(cx, cy);
cx = (xBit + cx + 7) >> 3;
switch (cx)
{
case 1:
while (cy--)
{
REQUIRE(1);
LL32(grHOSTDATA[0], *(BYTE *) pjGlyph);
pjGlyph += lDelta;
}
break;
case 2:
while (cy--)
{
REQUIRE(1);
LL32(grHOSTDATA[0], *(WORD *) pjGlyph);
pjGlyph += lDelta;
}
break;
case 3:
case 4:
while (cy--)
{
REQUIRE(1);
LL32(grHOSTDATA[0], *(DWORD *) pjGlyph);
pjGlyph += lDelta;
}
break;
default:
while (cy--)
{
WRITE_STRING(pjGlyph, (cx + 3) / 4);
pjGlyph += lDelta;
}
break;
}
// reset to transparent cache expansion
REQUIRE(2);
LL_DRAWBLTDEF(CACHE_EXPAND_XPAR, 2);
}
}
}
#endif // !(USE_ASM && defined(i386))