2790 lines
90 KiB
C
2790 lines
90 KiB
C
/******************************************************************************\
|
||
*
|
||
* $Workfile: textout.c $
|
||
*
|
||
* On every TextOut, GDI provides an array of 'GLYPHPOS' structures for every
|
||
* glyph to be drawn. Each GLYPHPOS structure contains a glyph handle and a
|
||
* pointer to a monochrome bitmap that describes 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 color-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 color-expand the
|
||
* result.
|
||
*
|
||
* The fastest method depends on a number of variables, such as the color
|
||
* expansion speed, bus speed, CPU speed, average glyph size, and average string
|
||
* length.
|
||
*
|
||
* Glyph expansion is typically faster than buffer expansion for very large
|
||
* glyphs, even on the ISA bus, because less copying by the CPU needs to be
|
||
* done. Unfortunately, large glyphs are pretty rare.
|
||
*
|
||
* An advantange of the buffer expansion method is that opaque text will never
|
||
* flash -- the other two methods typically need to draw the opaquing rectangle
|
||
* before laying down the glyphs, which may cause a flash if the raster is
|
||
* caught at the wrong time.
|
||
*
|
||
* Copyright (c) 1992-1995 Microsoft Corporation
|
||
*
|
||
********************************************************************************
|
||
*
|
||
* On the CL-GD5436/46 chips we use glyph caching which is a major performance
|
||
* gain.
|
||
*
|
||
* Copyright (c) 1996 Cirrus Logic, Inc.
|
||
*
|
||
* $Log: S:/projects/drivers/ntsrc/display/textout.c_v $
|
||
*
|
||
* Rev 1.5 Jan 15 1997 09:43:28 unknown
|
||
* Enable font cache for english.
|
||
*
|
||
* Rev 1.4 Jan 14 1997 15:16:58 unknown
|
||
* take out GR33 clearing after 80 blt.
|
||
*
|
||
* Rev 1.2 Nov 07 1996 16:48:08 unknown
|
||
*
|
||
*
|
||
* Rev 1.1 Oct 10 1996 15:39:28 unknown
|
||
*
|
||
*
|
||
* Rev 1.9 12 Aug 1996 17:12:50 frido
|
||
* Changed some comments.
|
||
*
|
||
* Rev 1.8 12 Aug 1996 16:55:08 frido
|
||
* Removed unaccessed local variables.
|
||
*
|
||
* Rev 1.7 02 Aug 1996 14:50:42 frido
|
||
* Fixed reported GPF during mode switching.
|
||
* Used another way to bypass the hardware bug.
|
||
*
|
||
* Rev 1.6 31 Jul 1996 17:56:08 frido
|
||
* Fixed clipping.
|
||
*
|
||
* Rev 1.5 26 Jul 1996 12:56:48 frido
|
||
* Removed clipping for now.
|
||
*
|
||
* Rev 1.4 24 Jul 1996 20:19:26 frido
|
||
* Added a chain of FONTCACHE structures.
|
||
* Fixed bugs in vDrawGlyph and vClipGlyph.
|
||
* Changed vAssertModeText to remove all cached fonts.
|
||
*
|
||
* Rev 1.3 23 Jul 1996 17:41:52 frido
|
||
* Fixed a compile problem after commenting.
|
||
*
|
||
* Rev 1.2 23 Jul 1996 08:53:00 frido
|
||
* Documentation done.
|
||
*
|
||
* Rev 1.1 22 Jul 1996 20:45:38 frido
|
||
* Added font cache.
|
||
*
|
||
* jl01 10-08-96 Do Transparent BLT w/o Solid Fill. Refer to PDRs#5511/6817.
|
||
\******************************************************************************/
|
||
|
||
#include "precomp.h"
|
||
|
||
// Handy macros.
|
||
#define BUSY_BLT(ppdev, pjBase) (CP_MM_ACL_STAT(ppdev, pjBase) & 0x10)
|
||
|
||
#define FIFTEEN_BITS ((1 << 15) - 1)
|
||
|
||
/******************************Public*Routine******************************\
|
||
* VOID vClipSolid
|
||
*
|
||
* Fills the specified rectangles with the specified color, honoring
|
||
* 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.
|
||
*
|
||
* Also used as a simple way to do a rectangular solid fill while honoring
|
||
* clipping (as in extra rectangles).
|
||
*
|
||
\**************************************************************************/
|
||
|
||
VOID vClipSolid(
|
||
PDEV* ppdev,
|
||
LONG crcl,
|
||
RECTL* prcl,
|
||
ULONG iColor,
|
||
CLIPOBJ* pco)
|
||
{
|
||
BOOL bMore; // Flag for clip enumeration
|
||
CLIPENUM ce; // Clip enumeration object
|
||
ULONG i;
|
||
ULONG j;
|
||
RECTL arclTmp[4];
|
||
ULONG crclTmp;
|
||
RECTL* prclTmp;
|
||
RECTL* prclClipTmp;
|
||
LONG iLastBottom;
|
||
RECTL* prclClip;
|
||
RBRUSH_COLOR rbc;
|
||
|
||
ASSERTDD((crcl > 0) && (crcl <= 4), "Expected 1 to 4 rectangles");
|
||
|
||
rbc.iSolidColor = iColor;
|
||
if ((!pco) || (pco->iDComplexity == DC_TRIVIAL))
|
||
{
|
||
(ppdev->pfnFillSolid)(ppdev, 1, prcl, R4_PATCOPY, rbc, NULL);
|
||
}
|
||
else if (pco->iDComplexity == DC_RECT)
|
||
{
|
||
crcl = cIntersect(&pco->rclBounds, prcl, crcl);
|
||
if (crcl != 0)
|
||
{
|
||
(ppdev->pfnFillSolid)(ppdev, crcl, prcl, R4_PATCOPY,
|
||
rbc, NULL);
|
||
}
|
||
}
|
||
else // iDComplexity == DC_COMPLEX
|
||
{
|
||
// Bottom of last rectangle to fill
|
||
|
||
iLastBottom = prcl[crcl - 1].bottom;
|
||
|
||
// 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);
|
||
|
||
// 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))
|
||
{
|
||
// Add to list if anything's left to draw:
|
||
|
||
crclTmp++;
|
||
prclClipTmp++;
|
||
}
|
||
}
|
||
|
||
// Draw the clipped rects
|
||
|
||
if (crclTmp != 0)
|
||
{
|
||
(ppdev->pfnFillSolid)(ppdev, crclTmp, &arclTmp[0],
|
||
R4_PATCOPY, rbc, NULL);
|
||
}
|
||
}
|
||
}
|
||
} while (bMore);
|
||
}
|
||
}
|
||
|
||
#if 0 //removed
|
||
BOOL bVerifyStrObj(STROBJ* pstro)
|
||
{
|
||
BOOL bMoreGlyphs;
|
||
LONG cGlyph;
|
||
GLYPHPOS * pgp;
|
||
LONG iGlyph = 0;
|
||
RECTL * prclDraw;
|
||
GLYPHPOS * pgpTmp;
|
||
POINTL ptlPlace;
|
||
|
||
do
|
||
{
|
||
// Get the next batch of glyphs:
|
||
|
||
if (pstro->pgp != NULL)
|
||
{
|
||
// There's only the one batch of glyphs, so save ourselves
|
||
// a call:
|
||
|
||
pgp = pstro->pgp;
|
||
cGlyph = pstro->cGlyphs;
|
||
bMoreGlyphs = FALSE;
|
||
}
|
||
else
|
||
{
|
||
bMoreGlyphs = STROBJ_bEnum(pstro, &cGlyph, &pgp);
|
||
}
|
||
|
||
prclDraw = &pstro->rclBkGround;
|
||
pgpTmp = pgp;
|
||
|
||
ptlPlace = pgpTmp->ptl;
|
||
|
||
while (cGlyph)
|
||
{
|
||
if (((ptlPlace.x + pgpTmp->pgdf->pgb->ptlOrigin.x + pgpTmp->pgdf->pgb->sizlBitmap.cx) > (prclDraw->right)) ||
|
||
((ptlPlace.x + pgpTmp->pgdf->pgb->ptlOrigin.x) < (prclDraw->left)) ||
|
||
((ptlPlace.y + pgpTmp->pgdf->pgb->ptlOrigin.y + pgpTmp->pgdf->pgb->sizlBitmap.cy) > (prclDraw->bottom)) ||
|
||
((ptlPlace.y + pgpTmp->pgdf->pgb->ptlOrigin.y) < (prclDraw->top))
|
||
)
|
||
{
|
||
DISPDBG((0,"------------------------------------------------------------"));
|
||
DISPDBG((0,"Glyph %d extends beyond pstro->rclBkGround", iGlyph));
|
||
DISPDBG((0,"\tpstro->rclBkGround (%d,%d,%d,%d)",
|
||
pstro->rclBkGround.left,
|
||
pstro->rclBkGround.top,
|
||
pstro->rclBkGround.right,
|
||
pstro->rclBkGround.bottom));
|
||
DISPDBG((0,"\teffective glyph rect (%d,%d,%d,%d)",
|
||
(ptlPlace.x + pgpTmp->pgdf->pgb->ptlOrigin.x),
|
||
(ptlPlace.y + pgpTmp->pgdf->pgb->ptlOrigin.y),
|
||
(ptlPlace.x + pgpTmp->pgdf->pgb->ptlOrigin.x + pgpTmp->pgdf->pgb->sizlBitmap.cx),
|
||
(ptlPlace.y + pgpTmp->pgdf->pgb->ptlOrigin.y + pgpTmp->pgdf->pgb->sizlBitmap.cy)));
|
||
DISPDBG((0,"\tglyph pos (%d,%d)",ptlPlace.x,ptlPlace.y));
|
||
DISPDBG((0,"\tglyph origin (%d,%d)",
|
||
pgpTmp->pgdf->pgb->ptlOrigin.x,
|
||
pgpTmp->pgdf->pgb->ptlOrigin.y));
|
||
DISPDBG((0,"\tglyph sizl (%d,%d)",
|
||
pgpTmp->pgdf->pgb->sizlBitmap.cx,
|
||
pgpTmp->pgdf->pgb->sizlBitmap.cy));
|
||
DISPDBG((0,"------------------------------------------------------------"));
|
||
RIP("time to call the font guys...");
|
||
return(FALSE);
|
||
}
|
||
|
||
cGlyph--;
|
||
iGlyph++;
|
||
pgpTmp++;
|
||
|
||
if (pstro->ulCharInc == 0)
|
||
{
|
||
ptlPlace = pgpTmp->ptl;
|
||
}
|
||
else
|
||
{
|
||
ptlPlace.x += pstro->ulCharInc;
|
||
}
|
||
}
|
||
} while (bMoreGlyphs);
|
||
|
||
return(TRUE);
|
||
}
|
||
|
||
VOID vIoTextOutUnclipped(
|
||
PPDEV ppdev,
|
||
STROBJ* pstro,
|
||
FONTOBJ* pfo,
|
||
CLIPOBJ* pco,
|
||
RECTL* prclOpaque,
|
||
BRUSHOBJ* pboFore,
|
||
BRUSHOBJ* pboOpaque)
|
||
{
|
||
BYTE* pjPorts = ppdev->pjPorts;
|
||
LONG lDelta = ppdev->lDelta;
|
||
LONG cBpp = ppdev->cBpp;
|
||
|
||
ULONG *pulXfer;
|
||
ULONG ulDstAddr;
|
||
|
||
ULONG ulFgColor;
|
||
ULONG ulBgColor;
|
||
ULONG ulSolidColor;
|
||
|
||
BYTE jMode = 0;
|
||
BYTE jModeColor = 0;
|
||
|
||
BOOL bTextPerfectFit;
|
||
ULONG cGlyph;
|
||
BOOL bMoreGlyphs;
|
||
GLYPHPOS* pgp;
|
||
GLYPHBITS* pgb;
|
||
LONG cxGlyph;
|
||
LONG cyGlyph;
|
||
ULONG* pdSrc;
|
||
ULONG* pdDst;
|
||
LONG cj;
|
||
LONG cd;
|
||
POINTL ptlOrigin;
|
||
LONG ulCharInc;
|
||
|
||
ulFgColor = pboFore->iSolidColor;
|
||
|
||
if (pboOpaque)
|
||
{
|
||
ulBgColor = pboOpaque->iSolidColor;
|
||
}
|
||
|
||
if (cBpp == 1)
|
||
{
|
||
ulFgColor |= ulFgColor << 8;
|
||
ulFgColor |= ulFgColor << 16;
|
||
ulBgColor |= ulBgColor << 8;
|
||
ulBgColor |= ulBgColor << 16;
|
||
}
|
||
else if (cBpp == 2)
|
||
{
|
||
ulFgColor |= ulFgColor << 16;
|
||
ulBgColor |= ulBgColor << 16;
|
||
}
|
||
|
||
pulXfer = ppdev->pulXfer;
|
||
ppdev->pfnBankMap(ppdev, ppdev->lXferBank);
|
||
|
||
CP_IO_WAIT_FOR_BLT_COMPLETE(ppdev, pjPorts);
|
||
CP_IO_DST_Y_OFFSET(ppdev, pjPorts, lDelta);
|
||
|
||
if (prclOpaque != NULL)
|
||
{
|
||
////////////////////////////////////////////////////////////
|
||
// 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).
|
||
|
||
bTextPerfectFit = (pstro->flAccel & (SO_ZERO_BEARINGS |
|
||
SO_FLAG_DEFAULT_PLACEMENT | SO_MAXEXT_EQUAL_BM_SIDE |
|
||
SO_CHAR_INC_EQUAL_BM_BASE)) ==
|
||
(SO_ZERO_BEARINGS | SO_FLAG_DEFAULT_PLACEMENT |
|
||
SO_MAXEXT_EQUAL_BM_SIDE | SO_CHAR_INC_EQUAL_BM_BASE);
|
||
|
||
if (!(bTextPerfectFit) ||
|
||
(pstro->rclBkGround.top > prclOpaque->top) ||
|
||
(pstro->rclBkGround.left > prclOpaque->left) ||
|
||
(pstro->rclBkGround.right < prclOpaque->right) ||
|
||
(pstro->rclBkGround.bottom < prclOpaque->bottom))
|
||
{
|
||
vClipSolid(ppdev, 1, prclOpaque, pboOpaque->iSolidColor, pco);
|
||
}
|
||
|
||
if (bTextPerfectFit)
|
||
{
|
||
// If we have already drawn the opaquing rectangle (because
|
||
// is was larger than the text rectangle), we could lay down
|
||
// the glyphs in 'transparent' mode. But I've found the QVision
|
||
// to be a bit faster drawing in opaque mode, so we'll stick
|
||
// with that:
|
||
|
||
jMode = jModeColor |
|
||
ENABLE_COLOR_EXPAND |
|
||
SRC_CPU_DATA;
|
||
|
||
CP_IO_WAIT_FOR_BLT_COMPLETE(ppdev, pjPorts);
|
||
|
||
CP_IO_FG_COLOR(ppdev, pjPorts, ulFgColor);
|
||
CP_IO_BG_COLOR(ppdev, pjPorts, ulBgColor);
|
||
CP_IO_ROP(ppdev, pjPorts, CL_SRC_COPY);
|
||
CP_IO_BLT_MODE(ppdev, pjPorts, jMode);
|
||
|
||
goto SkipTransparentInitialization;
|
||
}
|
||
}
|
||
|
||
////////////////////////////////////////////////////////////
|
||
// Transparent Initialization
|
||
////////////////////////////////////////////////////////////
|
||
|
||
// Initialize the hardware for transparent text:
|
||
|
||
jMode = jModeColor |
|
||
ENABLE_COLOR_EXPAND |
|
||
ENABLE_TRANSPARENCY_COMPARE |
|
||
SRC_CPU_DATA;
|
||
|
||
CP_IO_WAIT_FOR_BLT_COMPLETE(ppdev, pjPorts);
|
||
|
||
CP_IO_FG_COLOR(ppdev, pjPorts, ulFgColor);
|
||
CP_IO_BG_COLOR(ppdev, pjPorts, ~ulFgColor);
|
||
CP_IO_XPAR_COLOR(ppdev, pjPorts, ~ulFgColor);
|
||
CP_IO_ROP(ppdev, pjPorts, CL_SRC_COPY);
|
||
CP_IO_BLT_MODE(ppdev, pjPorts, jMode);
|
||
CP_IO_BLT_EXT_MODE(ppdev, pjPorts, 0); // jl01
|
||
|
||
|
||
SkipTransparentInitialization:
|
||
|
||
do {
|
||
if (pstro->pgp != NULL)
|
||
{
|
||
// There's only the one batch of glyphs, so save ourselves
|
||
// a call:
|
||
|
||
pgp = pstro->pgp;
|
||
cGlyph = pstro->cGlyphs;
|
||
bMoreGlyphs = FALSE;
|
||
}
|
||
else
|
||
{
|
||
bMoreGlyphs = STROBJ_bEnum(pstro, &cGlyph, &pgp);
|
||
}
|
||
|
||
if (cGlyph > 0)
|
||
{
|
||
if (pstro->ulCharInc == 0)
|
||
{
|
||
////////////////////////////////////////////////////////////
|
||
// Proportional Spacing
|
||
|
||
pdDst = pulXfer;
|
||
|
||
CP_IO_WAIT_FOR_BLT_COMPLETE(ppdev, pjPorts);
|
||
|
||
do {
|
||
pgb = pgp->pgdf->pgb;
|
||
|
||
ulDstAddr = ((pgp->ptl.y + pgb->ptlOrigin.y) * lDelta) +
|
||
PELS_TO_BYTES(pgp->ptl.x + pgb->ptlOrigin.x);
|
||
|
||
cxGlyph = pgb->sizlBitmap.cx;
|
||
cyGlyph = pgb->sizlBitmap.cy;
|
||
|
||
CP_IO_WAIT_FOR_BLT_COMPLETE(ppdev, pjPorts);
|
||
|
||
CP_IO_XCNT(ppdev, pjPorts, (PELS_TO_BYTES(cxGlyph) - 1));
|
||
CP_IO_YCNT(ppdev, pjPorts, cyGlyph - 1);
|
||
|
||
//
|
||
// The 542x chips require a write to the Src Address Register when
|
||
// doing a host transfer with color expansion. The value is
|
||
// irrelevant, but the write is crucial. This is documented in
|
||
// the manual, not the errata. Go figure.
|
||
//
|
||
|
||
CP_IO_SRC_ADDR(ppdev, pjPorts, 0);
|
||
CP_IO_DST_ADDR(ppdev, pjPorts, ulDstAddr);
|
||
|
||
CP_IO_START_BLT(ppdev, pjPorts);
|
||
|
||
pdSrc = (ULONG*) pgb->aj;
|
||
|
||
cj = cyGlyph * ((cxGlyph + 7) >> 3);
|
||
|
||
cd = (cj + 3) >> 2;
|
||
|
||
{
|
||
do {
|
||
WRITE_REGISTER_ULONG(pdDst, *pdSrc);
|
||
// *pdDst = *pdSrc;
|
||
CP_MEMORY_BARRIER();
|
||
pdSrc++;
|
||
} while (--cd != 0);
|
||
}
|
||
} while (pgp++, --cGlyph != 0);
|
||
}
|
||
else
|
||
{
|
||
////////////////////////////////////////////////////////////
|
||
// Mono Spacing
|
||
|
||
ulCharInc = pstro->ulCharInc;
|
||
pgb = pgp->pgdf->pgb;
|
||
|
||
ptlOrigin.x = pgb->ptlOrigin.x + pgp->ptl.x;
|
||
ptlOrigin.y = pgb->ptlOrigin.y + pgp->ptl.y;
|
||
|
||
pdDst = pulXfer;
|
||
|
||
do {
|
||
pgb = pgp->pgdf->pgb;
|
||
|
||
ulDstAddr = (ptlOrigin.y * lDelta) +
|
||
PELS_TO_BYTES(ptlOrigin.x);
|
||
|
||
cxGlyph = pgb->sizlBitmap.cx;
|
||
cyGlyph = pgb->sizlBitmap.cy;
|
||
|
||
CP_IO_WAIT_FOR_BLT_COMPLETE(ppdev, pjPorts);
|
||
|
||
CP_IO_XCNT(ppdev, pjPorts, (PELS_TO_BYTES(cxGlyph) - 1));
|
||
CP_IO_YCNT(ppdev, pjPorts, cyGlyph - 1);
|
||
|
||
//
|
||
// The 542x chips require a write to the Src Address Register when
|
||
// doing a host transfer with color expansion. The value is
|
||
// irrelevant, but the write is crucial. This is documented in
|
||
// the manual, not the errata. Go figure.
|
||
//
|
||
|
||
CP_IO_SRC_ADDR(ppdev, pjPorts, 0);
|
||
CP_IO_DST_ADDR(ppdev, pjPorts, ulDstAddr);
|
||
|
||
ptlOrigin.x += ulCharInc;
|
||
|
||
CP_IO_START_BLT(ppdev, pjPorts);
|
||
|
||
pdSrc = (ULONG*) pgb->aj;
|
||
|
||
cj = cyGlyph * ((cxGlyph + 7) >> 3);
|
||
|
||
cd = (cj + 3) >> 2;
|
||
|
||
{
|
||
do {
|
||
WRITE_REGISTER_ULONG(pdDst, *pdSrc);
|
||
// *pdDst = *pdSrc;
|
||
MEMORY_BARRIER();
|
||
pdSrc++;
|
||
} while (--cd != 0);
|
||
}
|
||
} while (pgp++, --cGlyph != 0);
|
||
}
|
||
}
|
||
} while (bMoreGlyphs);
|
||
|
||
}
|
||
#endif
|
||
|
||
/******************************Public*Routine******************************\
|
||
* BOOL DrvTextOut
|
||
*
|
||
* If it's the fastest method, outputs text using the 'glyph expansion'
|
||
* method. Each individual glyph is color-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.
|
||
*
|
||
\**************************************************************************/
|
||
|
||
BOOL DrvTextOut(
|
||
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;
|
||
DSURF* pdsurf;
|
||
OH* poh;
|
||
BOOL bTextPerfectFit;
|
||
LONG lDelta;
|
||
|
||
BOOL bTmpAlloc;
|
||
VOID* pvTmp;
|
||
SURFOBJ* psoTmpMono;
|
||
BOOL bOpaque;
|
||
BRUSHOBJ boFore;
|
||
BRUSHOBJ boOpaque;
|
||
BOOL bRet;
|
||
XLATECOLORS xlc; // Temporary for keeping colours
|
||
XLATEOBJ xlo; // Temporary for passing colours
|
||
|
||
ULONG ulBufferBytes;
|
||
ULONG ulBufferHeight;
|
||
|
||
// The DDI spec says we'll only ever get foreground and background
|
||
// mixes of R2_COPYPEN:
|
||
|
||
ASSERTDD(mix == 0x0d0d, "GDI should only give us a copy mix");
|
||
|
||
// Pass the surface off to GDI if it's a device bitmap that we've
|
||
// converted to a DIB:
|
||
|
||
pdsurf = (DSURF*) pso->dhsurf;
|
||
|
||
if (pdsurf->dt != DT_DIB)
|
||
{
|
||
// We'll be drawing to the screen or an off-screen DFB; copy the
|
||
// surface's offset now so that we won't need to refer to the DSURF
|
||
// again:
|
||
|
||
poh = pdsurf->poh;
|
||
ppdev = (PDEV*) pso->dhpdev;
|
||
|
||
ppdev->xOffset = poh->x;
|
||
ppdev->yOffset = poh->y;
|
||
ppdev->xyOffset = poh->xy;
|
||
|
||
if (HOST_XFERS_DISABLED(ppdev) && DIRECT_ACCESS(ppdev))
|
||
{
|
||
//
|
||
// if HOST_XFERS_DISABLED(ppdev) is TRUE then the BitBlt used by
|
||
// our text code will be VERY slow. We should just let the engine
|
||
// draw the text if it can.
|
||
//
|
||
|
||
if (ppdev->bLinearMode)
|
||
{
|
||
SURFOBJ *psoPunt = ppdev->psoPunt;
|
||
|
||
psoPunt->pvScan0 = poh->pvScan0;
|
||
ppdev->pfnBankSelectMode(ppdev, BANK_ON);
|
||
|
||
return(EngTextOut(psoPunt, pstro, pfo, pco, prclExtra,
|
||
prclOpaque, pboFore, pboOpaque,
|
||
pptlBrush, mix));
|
||
}
|
||
else
|
||
{
|
||
BANK bnk;
|
||
BOOL b;
|
||
RECTL rclDraw;
|
||
RECTL *prclDst = &pco->rclBounds;
|
||
|
||
// The bank manager requires that the 'draw' rectangle be
|
||
// well-ordered:
|
||
|
||
rclDraw = *prclDst;
|
||
if (rclDraw.left > rclDraw.right)
|
||
{
|
||
rclDraw.left = prclDst->right;
|
||
rclDraw.right = prclDst->left;
|
||
}
|
||
if (rclDraw.top > rclDraw.bottom)
|
||
{
|
||
rclDraw.top = prclDst->bottom;
|
||
rclDraw.bottom = prclDst->top;
|
||
}
|
||
|
||
vBankStart(ppdev, &rclDraw, pco, &bnk);
|
||
|
||
b = TRUE;
|
||
do {
|
||
b &= EngTextOut(bnk.pso,
|
||
pstro,
|
||
pfo,
|
||
bnk.pco,
|
||
prclExtra,
|
||
prclOpaque,
|
||
pboFore,
|
||
pboOpaque,
|
||
pptlBrush,
|
||
mix);
|
||
} while (bBankEnum(&bnk));
|
||
|
||
return(b);
|
||
}
|
||
}
|
||
|
||
if ((pco != NULL) && (pco->iDComplexity != DC_TRIVIAL))
|
||
{
|
||
// I'm not entirely sure why, but GDI will occasionally send
|
||
// us TextOut's where the opaquing rectangle does not intersect
|
||
// with the clip object bounds -- meaning that the text out
|
||
// should have already been trivially rejected. We will do so
|
||
// here because the blt code usually assumes that all trivial
|
||
// rejections will have already been performed, and we will be
|
||
// passing this call on to the blt code:
|
||
|
||
if ((pco->rclBounds.top >= pstro->rclBkGround.bottom) ||
|
||
(pco->rclBounds.left >= pstro->rclBkGround.right) ||
|
||
(pco->rclBounds.right <= pstro->rclBkGround.left) ||
|
||
(pco->rclBounds.bottom <= pstro->rclBkGround.top))
|
||
{
|
||
// The entire operation was trivially rejected:
|
||
|
||
if (prclOpaque)
|
||
{
|
||
vClipSolid(ppdev, 1, prclOpaque, pboOpaque->iSolidColor, pco);
|
||
}
|
||
return(TRUE);
|
||
}
|
||
}
|
||
|
||
// Font cache.
|
||
if ((ppdev->flStatus & STAT_FONT_CACHE) &&
|
||
bFontCache(ppdev, pstro, pfo, pco, prclOpaque, pboFore, pboOpaque))
|
||
{
|
||
return(TRUE);
|
||
}
|
||
|
||
// See if the temporary buffer is big enough for the text; if
|
||
// not, try to allocate enough memory. We round up to the
|
||
// nearest dword multiple:
|
||
|
||
lDelta = ((((pstro->rclBkGround.right + 31) & ~31) -
|
||
(pstro->rclBkGround.left & ~31)) >> 3);
|
||
|
||
ulBufferHeight = pstro->rclBkGround.bottom - pstro->rclBkGround.top;
|
||
ulBufferBytes = lDelta * ulBufferHeight;
|
||
|
||
if (((ULONG) lDelta > FIFTEEN_BITS) ||
|
||
(ulBufferHeight > FIFTEEN_BITS))
|
||
{
|
||
// Fail if the math will have overflowed:
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
// Use our temporary buffer if it's big enough, otherwise
|
||
// allocate a buffer on the fly:
|
||
|
||
if (ulBufferBytes >= TMP_BUFFER_SIZE)
|
||
{
|
||
// The textout is so big that I doubt this allocation will
|
||
// cost a significant amount in performance:
|
||
|
||
bTmpAlloc = TRUE;
|
||
pvTmp = ALLOC(ulBufferBytes);
|
||
if (pvTmp == NULL)
|
||
return(FALSE);
|
||
}
|
||
else
|
||
{
|
||
bTmpAlloc = FALSE;
|
||
pvTmp = ppdev->pvTmpBuffer;
|
||
}
|
||
|
||
psoTmpMono = ppdev->psoTmpMono;
|
||
|
||
// Adjust 'lDelta' and 'pvScan0' of our temporary 1bpp surface object
|
||
// so that when GDI starts drawing the text, it will begin in the
|
||
// first dword
|
||
|
||
psoTmpMono->pvScan0 = (BYTE*) pvTmp - (pstro->rclBkGround.top * lDelta)
|
||
- ((pstro->rclBkGround.left & ~31) >> 3);
|
||
psoTmpMono->lDelta = lDelta;
|
||
|
||
ASSERTDD(((ULONG_PTR) psoTmpMono->pvScan0 & 3) == 0,
|
||
"pvScan0 must be dword aligned");
|
||
ASSERTDD((lDelta & 3) == 0, "lDelta must be dword aligned");
|
||
|
||
// We always want GDI to draw in opaque mode to temporary 1bpp
|
||
// buffer:
|
||
// We only want GDI to opaque within the rclBkGround.
|
||
// We'll handle the rest ourselves.
|
||
|
||
bOpaque = (prclOpaque != NULL);
|
||
|
||
// Get GDI to draw the text for us:
|
||
|
||
boFore.iSolidColor = 1;
|
||
boOpaque.iSolidColor = 0;
|
||
|
||
bRet = EngTextOut(psoTmpMono,
|
||
pstro,
|
||
pfo,
|
||
pco,
|
||
prclExtra,
|
||
&pstro->rclBkGround, //prclOpaque,
|
||
&boFore,
|
||
&boOpaque,
|
||
pptlBrush,
|
||
mix);
|
||
|
||
if (bRet)
|
||
{
|
||
if (bOpaque)
|
||
{
|
||
bTextPerfectFit = (pstro->flAccel & (SO_ZERO_BEARINGS |
|
||
SO_FLAG_DEFAULT_PLACEMENT | SO_MAXEXT_EQUAL_BM_SIDE |
|
||
SO_CHAR_INC_EQUAL_BM_BASE)) ==
|
||
(SO_ZERO_BEARINGS | SO_FLAG_DEFAULT_PLACEMENT |
|
||
SO_MAXEXT_EQUAL_BM_SIDE | SO_CHAR_INC_EQUAL_BM_BASE);
|
||
|
||
if (!(bTextPerfectFit) ||
|
||
(pstro->rclBkGround.top > prclOpaque->top) ||
|
||
(pstro->rclBkGround.left > prclOpaque->left) ||
|
||
(pstro->rclBkGround.right < prclOpaque->right) ||
|
||
(pstro->rclBkGround.bottom < prclOpaque->bottom))
|
||
{
|
||
//
|
||
// Drawing the Opaque test will not completely cover the
|
||
// opaque rectangle, so we must do it. Go to transparent
|
||
// blt so we don't do the work twice (since opaque text is
|
||
// done in two passes).
|
||
//
|
||
|
||
vClipSolid(ppdev, 1, prclOpaque, pboOpaque->iSolidColor, pco);
|
||
goto Transparent_Text;
|
||
}
|
||
|
||
xlc.iForeColor = pboFore->iSolidColor;
|
||
xlc.iBackColor = pboOpaque->iSolidColor;
|
||
xlo.pulXlate = (ULONG*) &xlc;
|
||
|
||
bRet = DrvBitBlt(pso,
|
||
psoTmpMono,
|
||
NULL,
|
||
pco,
|
||
&xlo,
|
||
&pstro->rclBkGround,
|
||
(POINTL*)&pstro->rclBkGround,
|
||
NULL,
|
||
NULL, //&boFore
|
||
NULL,
|
||
R4_SRCCOPY);
|
||
}
|
||
else
|
||
{
|
||
Transparent_Text:
|
||
// Foreground colour must be 0xff for 8bpp and 0xffff for 16bpp:
|
||
|
||
xlc.iForeColor = (ULONG)((1<<PELS_TO_BYTES(8)) - 1);
|
||
xlc.iBackColor = 0;
|
||
xlo.pulXlate = (ULONG*) &xlc;
|
||
|
||
boFore.iSolidColor = pboFore->iSolidColor;
|
||
|
||
//
|
||
// Transparently blt the text bitmap
|
||
//
|
||
|
||
bRet = DrvBitBlt(pso,
|
||
psoTmpMono,
|
||
NULL,
|
||
pco,
|
||
&xlo,
|
||
&pstro->rclBkGround,
|
||
(POINTL*)&pstro->rclBkGround,
|
||
NULL,
|
||
&boFore,
|
||
NULL,
|
||
0xe2e2);
|
||
}
|
||
}
|
||
|
||
// Free up any memory we allocated for the temp buffer:
|
||
|
||
if (bTmpAlloc)
|
||
{
|
||
FREE(pvTmp);
|
||
}
|
||
|
||
return(bRet);
|
||
}
|
||
else
|
||
{
|
||
// We're drawing to a DFB we've converted to a DIB, so just call GDI
|
||
// to handle it:
|
||
|
||
return(EngTextOut(pdsurf->pso, pstro, pfo, pco, prclExtra, prclOpaque,
|
||
pboFore, pboOpaque, pptlBrush, mix));
|
||
}
|
||
|
||
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'.
|
||
}
|
||
|
||
////////////////////////////////////////////////////////////////////////////////
|
||
// //
|
||
// F O N T C A C H E S T U F F //
|
||
// //
|
||
////////////////////////////////////////////////////////////////////////////////
|
||
|
||
/*
|
||
The font cache has quite an impact on the speed. First a little note on the
|
||
necessaty of an off-screen font cache (it is an off-screen font cache). The
|
||
original code calls the GDI to perform the character drawing on a temporary
|
||
monochrome surface and then blits that surface to the screen. The problem
|
||
is that GDI is realy too slow. So we need some sort of acceleration here.
|
||
The best acceleration possible is to cache all glyphs off-screen so we can
|
||
let the bitblt engine do its work while we calculate the stuff required for
|
||
the next glyph to draw. Call it co-operate cacheing if you like.
|
||
|
||
Okay, so now we know why we need a font cache, how do we do it? Calling
|
||
the heap manager for every glyph we are going to cache is quite disasterous
|
||
since the off-screen heap gets fragmented with a lot (and I mean a lot) of
|
||
small chunks of data. We can do it better. We will implement our own very
|
||
sneaky (simple and fast) memory manager. We just call the off-screen heap
|
||
manager to allocate a big chunk (4Kb or so) rectengular memory and perform
|
||
our own allocation in that chunk.
|
||
|
||
We will use a simple linear allocation technique. Whenever we are required
|
||
to allocate a number of bytes we will test if we have enough room in the
|
||
last line accessed in the chunk. If we have, we decrease the size left on
|
||
that line and return a pointer to it. If we don't have enough memory in the
|
||
last line we simply move to the next line which will be free. If there is
|
||
not enough memory there either, the requested glyph is too big and so we
|
||
return NULL. The only problem here is when we run out of lines in the
|
||
chunk. In this case we link in another chunk we allocate in off-screen
|
||
memory and mark the current chunk 'full'. Okay, this may not be the best
|
||
memory manager since it might leave lines in the chunk very empty if a
|
||
large glyph needs to be allocated. But it is small and fast. And that's our
|
||
main goal.
|
||
|
||
We could copy the entire glyph into off-screen memory, but this would use
|
||
up valueable memory since most glyphs will have a lot of white space in
|
||
them. So we calculate the actual visible part of the glyph and only copy
|
||
that data to the off-screen memory. This requires some extra overhead when
|
||
a glyph is being cached, but that will happen only once. And we can detect
|
||
empty glyphs (like the space) to speed up drawing in the process. This does
|
||
however add the necessaty of first drawing an opaque rectangle if required.
|
||
This does not matter that much, since the bitblt engine will draw it while
|
||
we setup some loop variables.
|
||
|
||
Okay, now we know about the memory manager. But how do we attach this glyph
|
||
cache to a font? And how do we free its recourses? Windows NT has this nice
|
||
feature called OEM extension. In the FONT object there is a field
|
||
(vConsumer) which is for the display driver only. We can use this field to
|
||
hook up a pointer to our FONTCACHE structure. And when the font is no
|
||
longer required, Windows NT calls DrvDestroyFont so we can remove any
|
||
resources attached to the font. There is only one glitch to this scheme.
|
||
Windows NT does not free up the fonts when the screen goes to full-screen
|
||
DOS mode. This does not matter but when the screen is reset to graphics
|
||
mode all off-screen fonts are smashed and invalid. So I have added a
|
||
counter that gets incremented when the screen is reset to graphics mode.
|
||
When this counter does not match the copy in the FONTCACHE structure we
|
||
must destroy the font first before caching it again.
|
||
|
||
There might be some TrueType fonts out there that have many glyphs in them
|
||
(the Unicode fonts for example). This would cause an extremely large font
|
||
cache indeed. So we set a maximum (defaults to 256) of glyphs to cache.
|
||
Whenever we are asked to draw a glyph outside the range we do it by
|
||
bypassing the font cache for that particular glyph.
|
||
|
||
Some glyphs might be too large to cache even though the font is small
|
||
enough to be validated for cacheing. In this case we mark the specific
|
||
glyph as uncacheable and draw it directly to screen, bypassing the font
|
||
cache. Other glyphs might have no visble pixels at all (spaces) and we mark
|
||
them as empty so they never get drawn.
|
||
|
||
This covers most of the basics for the font cache. See the comments in the
|
||
source for more details.
|
||
|
||
EXTRA: Today (24-Jul-96) I have added a chain of FONTCACHE structures that
|
||
keeps track of which FONTOBJs are loaded and cached. This chain will we
|
||
walked to throw all cached fonts out of memory when a mode change to full-
|
||
screen occurs or when DirectDraw is being initialized to give more memory
|
||
to DirectDraw.
|
||
*/
|
||
|
||
/******************************************************************************\
|
||
*
|
||
* Function: bEnableText
|
||
*
|
||
* This routine is called from DrvEnableSurface and should perform any actions
|
||
* required to set up the font cache.
|
||
*
|
||
* Parameters: ppdev Pointer to physical device.
|
||
*
|
||
* Returns: TRUE.
|
||
*
|
||
\******************************************************************************/
|
||
BOOL bEnableText(
|
||
PDEV* ppdev)
|
||
{
|
||
// The font cache is only available on the CL-GD5436 like chips, direct
|
||
// access to the frame buffer is enabled and we can do host transfers.
|
||
if ((ppdev->flCaps & CAPS_AUTOSTART) &&
|
||
DIRECT_ACCESS(ppdev) &&
|
||
!(ppdev->flCaps & CAPS_NO_HOST_XFER))
|
||
{
|
||
// Don't enable the font cache in low memory situations.
|
||
LONG cWidth = BYTES_TO_PELS(FONT_ALLOC_X);
|
||
if ((cWidth <= ppdev->heap.cxMax) &&
|
||
(FONT_ALLOC_Y <= ppdev->heap.cyMax) && FALSE)
|
||
{
|
||
// The font cache will be used.
|
||
ppdev->flStatus |= STAT_FONT_CACHE;
|
||
ppdev->pfcChain = NULL;
|
||
}
|
||
}
|
||
return(TRUE);
|
||
}
|
||
|
||
/******************************************************************************\
|
||
*
|
||
* Function: vAssertModeText
|
||
*
|
||
* This routine is called from DrvAssertMode. When we switch to full screen we
|
||
* destroy all cached fonts.
|
||
*
|
||
* Parameters: ppdev Pointer to physical device.
|
||
* bEnable TRUE if switching to graphics mode, FALSE if
|
||
* switching to full-screen MS-DOS mode.
|
||
*
|
||
* Returns: Nothing.
|
||
*
|
||
\******************************************************************************/
|
||
VOID vAssertModeText(
|
||
PDEV* ppdev,
|
||
BOOL bEnable)
|
||
{
|
||
if (bEnable)
|
||
{
|
||
ppdev->ulFontCacheID++;
|
||
}
|
||
else
|
||
{
|
||
// Destroy all fonts in the chain.
|
||
while (ppdev->pfcChain != NULL)
|
||
{
|
||
DrvDestroyFont(ppdev->pfcChain->pfo);
|
||
}
|
||
}
|
||
}
|
||
|
||
/******************************************************************************\
|
||
*
|
||
* Function: DrvDestroyFont
|
||
*
|
||
* This functin is called by NT when a font is being removed from memory. We
|
||
* must free any resources we have attached to this font.
|
||
*
|
||
* Parameters: pfo Pointer to the font object being destroyed.
|
||
*
|
||
* Returns: Nothing.
|
||
*
|
||
\******************************************************************************/
|
||
VOID DrvDestroyFont(
|
||
FONTOBJ *pfo)
|
||
{
|
||
// Do we have any recourses allocated?
|
||
if ((pfo->pvConsumer != NULL) && (pfo->pvConsumer != (VOID*) -1))
|
||
{
|
||
FONTCACHE* pfc = pfo->pvConsumer;
|
||
FONTMEMORY* pfm;
|
||
PDEV* ppdev;
|
||
|
||
ppdev = pfc->ppdev;
|
||
|
||
// Free all allocated memory blocks.
|
||
pfm = pfc->pfm;
|
||
while (pfm != NULL)
|
||
{
|
||
FONTMEMORY* pfmNext = pfm->pfmNext;
|
||
|
||
if (pfm->poh != NULL)
|
||
{
|
||
pohFree(ppdev, pfm->poh);
|
||
}
|
||
|
||
FREE(pfm);
|
||
pfm = pfmNext;
|
||
}
|
||
|
||
// 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;
|
||
}
|
||
|
||
// Free the font cache.
|
||
FREE(pfc);
|
||
}
|
||
|
||
// We don't have anything allocated anymore!
|
||
pfo->pvConsumer = NULL;
|
||
}
|
||
|
||
/******************************************************************************\
|
||
*
|
||
* Function: cGetGlyphSize
|
||
*
|
||
* Get the width and height of a glyph. The height is its visble height, without
|
||
* leading and trailing blank lines.
|
||
*
|
||
* Parameters: pgb Pointer to the glyph.
|
||
* pptlOrigin Pointer to a POINTL which receives the origin of
|
||
* the glyph.
|
||
* psizlPixels Pointer to a SIZEL which receives the size of the
|
||
* glyph in pixels.
|
||
*
|
||
* Returns: The width of the glyph in bytes or 0 if the glyph is empty.
|
||
*
|
||
\******************************************************************************/
|
||
LONG cGetGlyphSize(
|
||
GLYPHBITS* pgb,
|
||
POINTL* pptlOrigin,
|
||
SIZEL* psizlPixels)
|
||
{
|
||
LONG x, y;
|
||
BYTE* pByte = pgb->aj;
|
||
INT i;
|
||
|
||
// Get width in bytes.
|
||
x = (pgb->sizlBitmap.cx + 7) >> 3;
|
||
if (x > 0)
|
||
{
|
||
// Find the first line in glyph that conatins data.
|
||
for (y = 0; y < pgb->sizlBitmap.cy; y++, pByte += x)
|
||
{
|
||
// Walk through every byte on a line.
|
||
for (i = 0; i < x; i++)
|
||
{
|
||
// If we have data here, we have found the first line.
|
||
if (pByte[i])
|
||
{
|
||
// Find the last line in the glyph that contains data.
|
||
LONG lHeight = pgb->sizlBitmap.cy - y;
|
||
for (pByte += (lHeight - 1) * x; lHeight > 0; lHeight--)
|
||
{
|
||
// Walk through every byte on a line.
|
||
for (i = 0; i < x; i++)
|
||
{
|
||
if (pByte[i])
|
||
{
|
||
// Fill return parameters.
|
||
pptlOrigin->y = y;
|
||
psizlPixels->cx = pgb->sizlBitmap.cx;
|
||
psizlPixels->cy = lHeight;
|
||
return(x);
|
||
}
|
||
}
|
||
pByte -= x;
|
||
}
|
||
|
||
// Glyph is empty.
|
||
return(0);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Glyph is empty.
|
||
return(0);
|
||
}
|
||
|
||
/******************************************************************************\
|
||
*
|
||
* Function: pjAllocateFontCache
|
||
*
|
||
* Allocate a number of bytes in the off-screen font cache.
|
||
*
|
||
* Parameters: pfc Pointer to the font cache.
|
||
* cBytes Number of bytes to allocate.
|
||
*
|
||
* Returns: Linear address of allocation or NULL if there was an error
|
||
* allocating memory.
|
||
*
|
||
\******************************************************************************/
|
||
BYTE* pjAllocateFontCache(
|
||
FONTCACHE* pfc,
|
||
LONG cBytes)
|
||
{
|
||
FONTMEMORY* pfm;
|
||
BYTE* pjLinear;
|
||
PDEV* ppdev = pfc->ppdev;
|
||
|
||
// Allocate first FONTMEMORY structure if not yet done.
|
||
if (pfc->pfm == NULL)
|
||
{
|
||
pfc->pfm = ALLOC(sizeof(FONTMEMORY));
|
||
if (pfc->pfm == NULL)
|
||
{
|
||
return(NULL);
|
||
}
|
||
}
|
||
|
||
// Walk through all FONTMEMORY structures to find enough space.
|
||
for (pfm = pfc->pfm; pfm != NULL; pfm = pfm->pfmNext)
|
||
{
|
||
// Allocate the off-screen node if not yet done so.
|
||
if (pfm->poh == NULL)
|
||
{
|
||
OH* poh = pohAllocate(ppdev, pfc->cWidth, pfc->cHeight,
|
||
FLOH_ONLY_IF_ROOM);
|
||
if (poh == NULL)
|
||
{
|
||
DISPDBG((4, "Not enough room for font cache"));
|
||
return(NULL);
|
||
}
|
||
|
||
// Make off-screen node PERMANENT.
|
||
poh->ofl = OFL_PERMANENT;
|
||
vCalculateMaximum(ppdev);
|
||
|
||
// Initialize memory manager.
|
||
pfm->poh = poh;
|
||
pfm->cx = PELS_TO_BYTES(poh->cx);
|
||
pfm->cy = poh->cy;
|
||
pfm->xy = poh->xy;
|
||
}
|
||
|
||
// Test if the font is too big to fit in any memory block.
|
||
if (cBytes > pfm->cx)
|
||
{
|
||
return(NULL);
|
||
}
|
||
|
||
// If the block is not yet full...
|
||
if (pfm->cy > 0)
|
||
{
|
||
// If the glyph fots on the current line...
|
||
if ((pfm->x + cBytes) <= pfm->cx)
|
||
{
|
||
pjLinear = (BYTE*)(ULONG_PTR)(pfm->xy + pfm->x);
|
||
pfm->x += cBytes;
|
||
return(pjLinear);
|
||
}
|
||
|
||
// Next line.
|
||
pfm->cy--;
|
||
|
||
// If this memory block is not yet full...
|
||
if (pfm->cy > 0)
|
||
{
|
||
pfm->xy += ppdev->lDelta;
|
||
pfm->x = cBytes;
|
||
return((BYTE*)(ULONG_PTR)pfm->xy);
|
||
}
|
||
}
|
||
|
||
// Allocate the next FONTMEMORY structure if not yet done.
|
||
if (pfm->pfmNext == NULL)
|
||
{
|
||
pfm->pfmNext = ALLOC(sizeof(FONTMEMORY));
|
||
}
|
||
}
|
||
|
||
return(NULL);
|
||
}
|
||
|
||
/******************************************************************************\
|
||
*
|
||
* Function: vAllocateGlyph
|
||
*
|
||
* Cache a glyph to the off-screen font cache.
|
||
*
|
||
* Parameters: pfc Pointer to the font cache.
|
||
* pgb Pointer to the glyph structure.
|
||
* pgc Pointer to the glyph cache.
|
||
*
|
||
* Returns: pgc->sizlBytes.cy.
|
||
*
|
||
\******************************************************************************/
|
||
LONG lAllocateGlyph(
|
||
FONTCACHE* pfc,
|
||
GLYPHBITS* pgb,
|
||
GLYPHCACHE* pgc)
|
||
{
|
||
PDEV* ppdev = pfc->ppdev;
|
||
LONG lDelta;
|
||
BYTE* pjSrc;
|
||
BYTE* pjDst;
|
||
LONG c;
|
||
|
||
// Get the size of the glyph.
|
||
lDelta = cGetGlyphSize(pgb, &pgc->ptlOrigin, &pgc->sizlPixels);
|
||
if (lDelta == 0)
|
||
{
|
||
// Glyph is empty.
|
||
pgc->pjGlyph = (BYTE*) -1;
|
||
pgc->sizlBytes.cy = GLYPH_EMPTY;
|
||
return(GLYPH_EMPTY);
|
||
}
|
||
|
||
// Allocate the glyph in the off-screen font cache.
|
||
pgc->lDelta = lDelta;
|
||
c = lDelta * pgc->sizlPixels.cy;
|
||
pgc->pjGlyph = pjAllocateFontCache(pfc, c);
|
||
if (pgc->pjGlyph == NULL)
|
||
{
|
||
// Glyph is uncacheable.
|
||
pgc->pjGlyph = (BYTE*) -1;
|
||
pgc->sizlBytes.cy = GLYPH_UNCACHEABLE;
|
||
return(GLYPH_UNCACHEABLE);
|
||
}
|
||
|
||
// Calculate the glyph and off-screen pointers.
|
||
pjSrc = &pgb->aj[pgc->ptlOrigin.y * lDelta];
|
||
pjDst = ppdev->pjScreen + (ULONG_PTR) pgc->pjGlyph;
|
||
|
||
// First, align the source to a DWORD boundary.
|
||
while (((ULONG_PTR)pjSrc & 3) && (c > 0))
|
||
{
|
||
*pjDst++ = *pjSrc++;
|
||
c--;
|
||
}
|
||
|
||
// Copy the data in DWORDs.
|
||
while (c >= 4)
|
||
{
|
||
*((UNALIGNED DWORD*) pjDst)++ = *((DWORD*) pjSrc)++;
|
||
c -= 4;
|
||
}
|
||
|
||
// Copy the remaining data.
|
||
while (c >= 0)
|
||
{
|
||
*pjDst++ = *pjSrc++;
|
||
c--;
|
||
}
|
||
|
||
// Calculate the glyph origin and size.
|
||
pgc->ptlOrigin.x = pgb->ptlOrigin.x;
|
||
pgc->ptlOrigin.y += pgb->ptlOrigin.y;
|
||
pgc->sizlBytes.cx = PELS_TO_BYTES(pgc->sizlPixels.cx) - 1;
|
||
pgc->sizlBytes.cy = pgc->sizlPixels.cy - 1;
|
||
|
||
return(pgc->sizlBytes.cy);
|
||
}
|
||
|
||
/******************************************************************************\
|
||
*
|
||
* Function: bFontCache
|
||
*
|
||
* This is the font cache routine which is called from DrvTextOut if the font
|
||
* cache is turned on.
|
||
*
|
||
* Parameters: ppdev Pointer to physical device.
|
||
* pstro Pointer to array of glyphs to draw.
|
||
* pfo Pointer to the font.
|
||
* pco Pointer to a CLIPOBJ structure.
|
||
* prclOpaque Pointer to the opaque rectangle.
|
||
* pboFore Pointer to the foreground brush.
|
||
* pboOpaque Pointer to the opaque brush.
|
||
*
|
||
* Returns: TRUE if the font has been drawn, FALSE if DrvTextOut should
|
||
* handle it.
|
||
*
|
||
\******************************************************************************/
|
||
BOOL bFontCache(
|
||
PDEV* ppdev,
|
||
STROBJ* pstro,
|
||
FONTOBJ* pfo,
|
||
CLIPOBJ* pco,
|
||
RECTL* prclOpaque,
|
||
BRUSHOBJ* pboFore,
|
||
BRUSHOBJ* pboOpaque)
|
||
{
|
||
BYTE iDComplexity;
|
||
BOOL bMoreGlyphs;
|
||
LONG cGlyphs;
|
||
GLYPHPOS* pgp;
|
||
BOOL bFirstTime;
|
||
POINTL ptlOrigin;
|
||
ULONG ulCharInc;
|
||
RECTL rclBounds;
|
||
ULONG ulDstOffset;
|
||
POINTL ptlDst;
|
||
SIZEL sizlDst;
|
||
|
||
FONTCACHE* pfc = pfo->pvConsumer;
|
||
BYTE* pjBase = ppdev->pjBase;
|
||
LONG lDelta = ppdev->lDelta;
|
||
BYTE jBltMode = ppdev->jModeColor;
|
||
|
||
// If the font is uncacheable, return FALSE.
|
||
if (pfc == (VOID*) -1)
|
||
{
|
||
DISPDBG((5, "bFontCache: pfo=0x%08X uncachable", pfo));
|
||
return(FALSE);
|
||
}
|
||
|
||
// We don't support complex clipping.
|
||
iDComplexity = (pco == NULL) ? DC_TRIVIAL : pco->iDComplexity;
|
||
if (iDComplexity == DC_COMPLEX)
|
||
{
|
||
return(FALSE);
|
||
}
|
||
|
||
// If the font was invalidated by a mode switch (or DirectDraw), destroy it
|
||
// first.
|
||
if ((pfc != NULL) && (pfc->ulFontCacheID != ppdev->ulFontCacheID))
|
||
{
|
||
DISPDBG((5, "bFontCache: pfo=0x%08X invalidated (%d)", pfo,
|
||
pfc->ulFontCacheID));
|
||
DrvDestroyFont(pfo);
|
||
pfc = NULL;
|
||
}
|
||
|
||
// If the font has not been cached, allocate a cache structure now.
|
||
if (pfc == NULL)
|
||
{
|
||
// Mark the font uncacheable if it is too high. We could opt to cache
|
||
// even the largest of fonts, but that will only reject them later on
|
||
// if there is not enough font cache memory (remember we allocate off-
|
||
// screen fonts in rectangular areas) so it will be rejected anyway.
|
||
// This gives quite a bit of extra overhead we can better do without.
|
||
if ((pstro->rclBkGround.bottom - pstro->rclBkGround.top) > FONT_ALLOC_Y)
|
||
{
|
||
DISPDBG((5, "bFontCache: pfo(0x%08X) too large (%d > %d)", pfo,
|
||
pstro->rclBkGround.bottom - pstro->rclBkGround.top,
|
||
FONT_ALLOC_Y));
|
||
pfo->pvConsumer = (VOID*) -1;
|
||
return(FALSE);
|
||
}
|
||
|
||
// Allocate the font cache structure.
|
||
pfc = ALLOC(sizeof(FONTCACHE));
|
||
if (pfc == NULL)
|
||
{
|
||
// Not enough memory.
|
||
return(FALSE);
|
||
}
|
||
pfo->pvConsumer = pfc;
|
||
|
||
// Initialize the font cache structure.
|
||
pfc->ppdev = ppdev;
|
||
pfc->ulFontCacheID = ppdev->ulFontCacheID;
|
||
pfc->cWidth = BYTES_TO_PELS(FONT_ALLOC_X);
|
||
pfc->cHeight = FONT_ALLOC_Y;
|
||
pfc->pfo = pfo;
|
||
|
||
// Allocate the first block of off-screen memory.
|
||
if (pjAllocateFontCache(pfc, 0) == NULL)
|
||
{
|
||
// Not enough off-screen memory.
|
||
DISPDBG((5, "bFontCache: pfo(0x%08X) not enough memory", pfo));
|
||
|
||
if (pfc->pfm != NULL)
|
||
{
|
||
FREE(pfc->pfm);
|
||
}
|
||
FREE(pfc);
|
||
pfo->pvConsumer = NULL;
|
||
return(FALSE);
|
||
}
|
||
|
||
// Hook the font cache into the chain.
|
||
pfc->pfcPrev = NULL;
|
||
pfc->pfcNext = ppdev->pfcChain;
|
||
ppdev->pfcChain = pfc;
|
||
if (pfc->pfcNext != NULL)
|
||
{
|
||
pfc->pfcNext->pfcPrev = pfc;
|
||
}
|
||
}
|
||
|
||
// If we need to draw an opaque rectangle...
|
||
if (prclOpaque != NULL)
|
||
{
|
||
// Get opaque rectangle.
|
||
if (iDComplexity == DC_TRIVIAL)
|
||
{
|
||
ptlDst.x = prclOpaque->left;
|
||
ptlDst.y = prclOpaque->top;
|
||
sizlDst.cx = prclOpaque->right - ptlDst.x;
|
||
sizlDst.cy = prclOpaque->bottom - ptlDst.y;
|
||
}
|
||
else
|
||
{
|
||
ptlDst.x = max(prclOpaque->left, pco->rclBounds.left);
|
||
ptlDst.y = max(prclOpaque->top, pco->rclBounds.top);
|
||
sizlDst.cx = min(prclOpaque->right, pco->rclBounds.right)
|
||
- ptlDst.x;
|
||
sizlDst.cy = min(prclOpaque->bottom, pco->rclBounds.bottom)
|
||
- ptlDst.y;
|
||
}
|
||
|
||
// If the clipped opaque rectangle is valid...
|
||
if ((sizlDst.cx > 0) && (sizlDst.cy > 0))
|
||
{
|
||
ulDstOffset = (ptlDst.y * lDelta) + PELS_TO_BYTES(ptlDst.x);
|
||
sizlDst.cx = PELS_TO_BYTES(sizlDst.cx) - 1;
|
||
sizlDst.cy = sizlDst.cy - 1;
|
||
|
||
// Wait for bitblt engine.
|
||
while (BUSY_BLT(ppdev, pjBase));
|
||
|
||
// Program bitblt engine.
|
||
CP_MM_FG_COLOR(ppdev, pjBase, pboOpaque->iSolidColor);
|
||
CP_MM_XCNT(ppdev, pjBase, sizlDst.cx);
|
||
CP_MM_YCNT(ppdev, pjBase, sizlDst.cy);
|
||
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
|
||
CP_MM_SRC_ADDR(ppdev, pjBase, 0);
|
||
CP_MM_BLT_MODE(ppdev, pjBase, jBltMode |
|
||
ENABLE_COLOR_EXPAND |
|
||
ENABLE_8x8_PATTERN_COPY);
|
||
CP_MM_ROP(ppdev, pjBase, HW_P);
|
||
CP_MM_BLT_EXT_MODE(ppdev, pjBase, ENABLE_SOLID_FILL);
|
||
CP_MM_DST_ADDR(ppdev, pjBase, ulDstOffset);
|
||
}
|
||
}
|
||
|
||
// Setup loop variables.
|
||
bFirstTime = TRUE;
|
||
ulCharInc = pstro->ulCharInc;
|
||
jBltMode |= ENABLE_COLOR_EXPAND | ENABLE_TRANSPARENCY_COMPARE;
|
||
|
||
// No clipping...
|
||
if (iDComplexity == DC_TRIVIAL)
|
||
{
|
||
#if 1 // D5480
|
||
ppdev->pfnGlyphOut(ppdev, pfc, pstro, pboFore->iSolidColor);
|
||
#else
|
||
do
|
||
{
|
||
// Get pointer to array of glyphs.
|
||
if (pstro->pgp != NULL)
|
||
{
|
||
pgp = pstro->pgp;
|
||
cGlyphs = pstro->cGlyphs;
|
||
bMoreGlyphs = FALSE;
|
||
}
|
||
else
|
||
{
|
||
bMoreGlyphs = STROBJ_bEnum(pstro, &cGlyphs, &pgp);
|
||
}
|
||
|
||
// Setup the blitter if this is the first loop through.
|
||
if (bFirstTime)
|
||
{
|
||
// Wait for the bitblt engine.
|
||
while (BUSY_BLT(ppdev, pjBase));
|
||
|
||
// Setup the common bitblt registers.
|
||
CP_MM_FG_COLOR(ppdev, pjBase, pboFore->iSolidColor);
|
||
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
|
||
CP_MM_ROP(ppdev, pjBase, CL_SRC_COPY);
|
||
CP_MM_BLT_EXT_MODE(ppdev, pjBase, 0);
|
||
|
||
// Mark registers as setup.
|
||
bFirstTime = FALSE;
|
||
}
|
||
|
||
// Get coordinates of first glyph.
|
||
ptlOrigin.x = pgp->ptl.x;
|
||
ptlOrigin.y = pgp->ptl.y;
|
||
|
||
// Loop through all glyphs.
|
||
while (cGlyphs-- > 0)
|
||
{
|
||
LONG cy;
|
||
GLYPHCACHE* pgc;
|
||
|
||
if (pgp->hg < MAX_GLYPHS)
|
||
{
|
||
// This is a cacheable glyph index.
|
||
pgc = &pfc->aGlyphs[pgp->hg];
|
||
cy = (pgc->pjGlyph == NULL)
|
||
? lAllocateGlyph(pfc, pgp->pgdf->pgb, pgc)
|
||
: pgc->sizlBytes.cy;
|
||
}
|
||
else
|
||
{
|
||
// The glyph index is out of range.
|
||
cy = GLYPH_UNCACHEABLE;
|
||
}
|
||
|
||
if (cy >= 0) // The glyph is cached, expand it to the screen.
|
||
{
|
||
// Setup the destination variables.
|
||
ptlDst.x = ptlOrigin.x + pgc->ptlOrigin.x;
|
||
ptlDst.y = ptlOrigin.y + pgc->ptlOrigin.y;
|
||
ulDstOffset = (ptlDst.y * lDelta) + PELS_TO_BYTES(ptlDst.x);
|
||
|
||
// Wait for the bitblt engine.
|
||
while (BUSY_BLT(ppdev, pjBase));
|
||
|
||
// Perform the blit expansion.
|
||
CP_MM_XCNT(ppdev, pjBase, pgc->sizlBytes.cx);
|
||
CP_MM_YCNT(ppdev, pjBase, cy);
|
||
CP_MM_SRC_Y_OFFSET(ppdev, pjBase, pgc->lDelta);
|
||
CP_MM_SRC_ADDR(ppdev, pjBase, pgc->pjGlyph);
|
||
CP_MM_BLT_MODE(ppdev, pjBase, jBltMode);
|
||
CP_MM_DST_ADDR(ppdev, pjBase, ulDstOffset);
|
||
}
|
||
else if (cy == GLYPH_UNCACHEABLE)
|
||
{
|
||
// The glyph is uncacheable, draw it directly.
|
||
vDrawGlyph(ppdev, pgp->pgdf->pgb, ptlOrigin);
|
||
}
|
||
|
||
// Next glyph.
|
||
pgp++;
|
||
if (ulCharInc)
|
||
{
|
||
ptlOrigin.x += ulCharInc;
|
||
}
|
||
else
|
||
{
|
||
ptlOrigin.x = pgp->ptl.x;
|
||
ptlOrigin.y = pgp->ptl.y;
|
||
}
|
||
}
|
||
} while (bMoreGlyphs);
|
||
#endif // endif D5480
|
||
return(TRUE);
|
||
}
|
||
|
||
// Clipping...
|
||
rclBounds = pco->rclBounds;
|
||
|
||
#if 1 // D5480
|
||
ppdev->pfnGlyphOutClip(ppdev, pfc, pstro, &rclBounds, pboFore->iSolidColor);
|
||
#else
|
||
do
|
||
{
|
||
// Get pointer to array of glyphs.
|
||
if (pstro->pgp != NULL)
|
||
{
|
||
pgp = pstro->pgp;
|
||
cGlyphs = pstro->cGlyphs;
|
||
bMoreGlyphs = FALSE;
|
||
}
|
||
else
|
||
{
|
||
bMoreGlyphs = STROBJ_bEnum(pstro, &cGlyphs, &pgp);
|
||
}
|
||
|
||
// Setup the blitter if this is the first loop through.
|
||
if (bFirstTime)
|
||
{
|
||
// Wait for the bitblt engine.
|
||
while (BUSY_BLT(ppdev, pjBase));
|
||
|
||
// Setup the common bitblt registers.
|
||
CP_MM_FG_COLOR(ppdev, pjBase, pboFore->iSolidColor);
|
||
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
|
||
CP_MM_ROP(ppdev, pjBase, CL_SRC_COPY);
|
||
CP_MM_BLT_EXT_MODE(ppdev, pjBase, 0);
|
||
|
||
// Mark registers as setup.
|
||
bFirstTime = FALSE;
|
||
}
|
||
|
||
// Get coordinates of first glyph.
|
||
ptlOrigin.x = pgp->ptl.x;
|
||
ptlOrigin.y = pgp->ptl.y;
|
||
|
||
// Loop through all glyphs.
|
||
while (cGlyphs-- > 0)
|
||
{
|
||
LONG c, cy;
|
||
GLYPHCACHE* pgc;
|
||
|
||
if (pgp->hg < MAX_GLYPHS)
|
||
{
|
||
// This is a cacheable glyph index.
|
||
pgc = &pfc->aGlyphs[pgp->hg];
|
||
cy = (pgc->pjGlyph == NULL)
|
||
? lAllocateGlyph(pfc, pgp->pgdf->pgb, pgc)
|
||
: pgc->sizlBytes.cy;
|
||
}
|
||
else
|
||
{
|
||
// The glyph index is out of range.
|
||
goto SoftwareClipping;
|
||
}
|
||
|
||
if (cy >= 0)
|
||
{
|
||
// The glyph is cached, expand it to the screen.
|
||
ULONG ulSrcOffset;
|
||
RECTL rcl;
|
||
LONG lSrcDelta;
|
||
LONG cSkipBits;
|
||
|
||
// Calculate the glyph bounding box.
|
||
rcl.left = ptlOrigin.x + pgc->ptlOrigin.x;
|
||
rcl.right = rcl.left + pgc->sizlPixels.cx;
|
||
if ((rcl.left >= rclBounds.right) ||
|
||
(rcl.right <= rclBounds.left))
|
||
{
|
||
goto NextGlyph;
|
||
}
|
||
rcl.top = ptlOrigin.y + pgc->ptlOrigin.y;
|
||
rcl.bottom = rcl.top + pgc->sizlPixels.cy;
|
||
if ((rcl.top >= rclBounds.bottom) ||
|
||
(rcl.bottom <= rclBounds.top))
|
||
{
|
||
goto NextGlyph;
|
||
}
|
||
|
||
// Setup source parameters.
|
||
ulSrcOffset = (ULONG) pgc->pjGlyph;
|
||
lSrcDelta = pgc->lDelta;
|
||
|
||
// Do the left side clipping.
|
||
c = rclBounds.left - rcl.left;
|
||
if (c > 0)
|
||
{
|
||
ulSrcOffset += c >> 3;
|
||
cSkipBits = c & 7;
|
||
rcl.left += c & ~7;
|
||
|
||
if (ppdev->cBpp == 3)
|
||
{
|
||
cSkipBits *= 3;
|
||
}
|
||
|
||
ulSrcOffset |= cSkipBits << 24;
|
||
}
|
||
|
||
// Do the top side clipping.
|
||
c = rclBounds.top - rcl.top;
|
||
if (c > 0)
|
||
{
|
||
rcl.top += c;
|
||
ulSrcOffset += c * lSrcDelta;
|
||
}
|
||
|
||
// Calculate size of the blit.
|
||
sizlDst.cx = min(rcl.right, rclBounds.right) - rcl.left;
|
||
sizlDst.cy = min(rcl.bottom, rclBounds.bottom) - rcl.top;
|
||
if ((sizlDst.cx <= 0) || (sizlDst.cy <= 0))
|
||
{
|
||
goto NextGlyph;
|
||
}
|
||
|
||
// Setup destination variables.
|
||
ulDstOffset = (rcl.top * lDelta) + PELS_TO_BYTES(rcl.left);
|
||
|
||
// HARDWARE BUG:
|
||
// ============
|
||
// A monochrome screen-to-screen expansion with a source pitch
|
||
// not equaling the width of the expansion (i.e. left- and/or
|
||
// right-side clipping) is not done correctly by the hardware.
|
||
// So we have to do the line increment by software.
|
||
if (((sizlDst.cx + 7) >> 3) != lSrcDelta)
|
||
{
|
||
// Wait for the bitblt engine.
|
||
while (BUSY_BLT(ppdev, pjBase));
|
||
|
||
// Setup the common bitblt registers.
|
||
CP_MM_XCNT(ppdev, pjBase, PELS_TO_BYTES(sizlDst.cx) - 1);
|
||
CP_MM_YCNT(ppdev, pjBase, 0);
|
||
CP_MM_BLT_MODE(ppdev, pjBase, jBltMode);
|
||
|
||
while (TRUE)
|
||
{
|
||
// Perform the expansion.
|
||
CP_MM_SRC_ADDR(ppdev, pjBase, ulSrcOffset);
|
||
CP_MM_DST_ADDR(ppdev, pjBase, ulDstOffset);
|
||
|
||
// Next line.
|
||
if (--sizlDst.cy == 0)
|
||
{
|
||
goto NextGlyph;
|
||
}
|
||
ulSrcOffset += lSrcDelta;
|
||
ulDstOffset += lDelta;
|
||
|
||
// Wait for the bitblt engine.
|
||
while (BUSY_BLT(ppdev, pjBase));
|
||
}
|
||
}
|
||
|
||
// Wait for the bitblt engine.
|
||
while (BUSY_BLT(ppdev, pjBase));
|
||
|
||
// Perform the expansion.
|
||
CP_MM_XCNT(ppdev, pjBase, PELS_TO_BYTES(sizlDst.cx) - 1);
|
||
CP_MM_YCNT(ppdev, pjBase, sizlDst.cy - 1);
|
||
CP_MM_SRC_Y_OFFSET(ppdev, pjBase, lSrcDelta);
|
||
CP_MM_SRC_ADDR(ppdev, pjBase, ulSrcOffset);
|
||
CP_MM_BLT_MODE(ppdev, pjBase, jBltMode);
|
||
CP_MM_DST_ADDR(ppdev, pjBase, ulDstOffset);
|
||
}
|
||
else if (cy == GLYPH_UNCACHEABLE)
|
||
{
|
||
SoftwareClipping:
|
||
{
|
||
// The glyph is uncacheable, draw it directly.
|
||
vClipGlyph(ppdev, pgp->pgdf->pgb, ptlOrigin, rclBounds,
|
||
pboFore->iSolidColor);
|
||
}
|
||
}
|
||
|
||
// Next glyph.
|
||
NextGlyph:
|
||
{
|
||
pgp++;
|
||
if (ulCharInc)
|
||
{
|
||
ptlOrigin.x += ulCharInc;
|
||
}
|
||
else
|
||
{
|
||
ptlOrigin.x = pgp->ptl.x;
|
||
ptlOrigin.y = pgp->ptl.y;
|
||
}
|
||
}
|
||
}
|
||
} while (bMoreGlyphs);
|
||
#endif // D5480
|
||
return(TRUE);
|
||
}
|
||
|
||
/******************************************************************************\
|
||
*
|
||
* Function: vDrawGlyph
|
||
*
|
||
* Draw an uncacheable glyph directly to screen.
|
||
*
|
||
* Parameters: ppdev Pointer to physical device.
|
||
* pgb Pointer to glyph to draw.
|
||
* ptl Coordinates of the glyph.
|
||
*
|
||
* Returns: Nothing.
|
||
*
|
||
\******************************************************************************/
|
||
VOID vDrawGlyph(
|
||
PDEV* ppdev,
|
||
GLYPHBITS* pgb,
|
||
POINTL ptl)
|
||
{
|
||
BYTE* pjBase = ppdev->pjBase;
|
||
BYTE jBltMode;
|
||
ULONG dstOffset;
|
||
DWORD* pulSrc;
|
||
DWORD* pulDst;
|
||
LONG c, cx, cy;
|
||
LONG x, y;
|
||
|
||
// BLT Mode Register value.
|
||
jBltMode = ENABLE_COLOR_EXPAND
|
||
| ENABLE_TRANSPARENCY_COMPARE
|
||
| SRC_CPU_DATA
|
||
| ppdev->jModeColor;
|
||
|
||
// Calculate the destination offset.
|
||
x = ptl.x + pgb->ptlOrigin.x;
|
||
y = ptl.y + pgb->ptlOrigin.y;
|
||
dstOffset = (y * ppdev->lDelta) + PELS_TO_BYTES(x);
|
||
|
||
// Calculate the glyph variables.
|
||
pulSrc = (DWORD*) pgb->aj;
|
||
pulDst = (DWORD*) ppdev->pulXfer;
|
||
cx = pgb->sizlBitmap.cx;
|
||
cy = pgb->sizlBitmap.cy;
|
||
c = (((cx + 7) >> 3) * cy + 3) >> 2; // Number of DWORDs to transfer.
|
||
cx *= ppdev->cBpp;
|
||
|
||
// Wait for the blitter.
|
||
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
|
||
|
||
// Setup the blitter registers.
|
||
CP_MM_XCNT(ppdev, pjBase, cx - 1);
|
||
CP_MM_YCNT(ppdev, pjBase, cy - 1);
|
||
CP_MM_BLT_MODE(ppdev, pjBase, jBltMode);
|
||
CP_MM_BLT_EXT_MODE(ppdev, pjBase, 0);
|
||
CP_MM_DST_ADDR(ppdev, pjBase, dstOffset);
|
||
|
||
// Copy the data from the glyph to the screen. Note that the glyph is
|
||
// always DWORD aligned, so we don't have to do anything weird here.
|
||
while (c-- > 0)
|
||
{
|
||
*pulDst = *pulSrc++;
|
||
}
|
||
}
|
||
|
||
/******************************************************************************\
|
||
*
|
||
* Function: vClipGlyph
|
||
*
|
||
* Draw an uncacheable glyph directly to screen using a clipping rectangle.
|
||
*
|
||
* Parameters: ppdev Pointer to physical device.
|
||
* pgb Pointer to glyph to draw.
|
||
* ptl Coordinates of the glyph.
|
||
* rclBounds Clipping rectangle.
|
||
* ulColor Foreground Color.
|
||
*
|
||
* Returns: Nothing.
|
||
*
|
||
\******************************************************************************/
|
||
VOID vClipGlyph(
|
||
PDEV* ppdev,
|
||
GLYPHBITS* pgb,
|
||
POINTL ptl,
|
||
RECTL* rclBounds,
|
||
ULONG ulColor)
|
||
{
|
||
BYTE jBltMode;
|
||
ULONG ulDstOffset;
|
||
BYTE* pjSrc;
|
||
LONG cx, cy;
|
||
RECTL rcl;
|
||
LONG lSrcDelta;
|
||
LONG i, cBytes;
|
||
|
||
BYTE* pjBase = ppdev->pjBase;
|
||
LONG lDelta = ppdev->lDelta;
|
||
ULONG* pulDst = (ULONG*) ppdev->pulXfer;
|
||
LONG cSkipBits = 0;
|
||
|
||
// Calculate glyph bounding box.
|
||
rcl.left = ptl.x + pgb->ptlOrigin.x;
|
||
rcl.top = ptl.y + pgb->ptlOrigin.y;
|
||
rcl.right = min(rcl.left + pgb->sizlBitmap.cx, rclBounds->right);
|
||
rcl.bottom = min(rcl.top + pgb->sizlBitmap.cy, rclBounds->bottom);
|
||
|
||
// Setup source variables.
|
||
pjSrc = pgb->aj;
|
||
lSrcDelta = (pgb->sizlBitmap.cx + 7) >> 3;
|
||
|
||
// Setup BLT Mode Register value.
|
||
jBltMode = ENABLE_COLOR_EXPAND
|
||
| ENABLE_TRANSPARENCY_COMPARE
|
||
| SRC_CPU_DATA
|
||
| ppdev->jModeColor;
|
||
|
||
// Do left side clipping.
|
||
cx = rclBounds->left - rcl.left;
|
||
if (cx > 0)
|
||
{
|
||
pjSrc += cx >> 3;
|
||
cSkipBits = cx & 7;
|
||
rcl.left += cx & ~7;
|
||
|
||
if (ppdev->cBpp == 3)
|
||
{
|
||
cSkipBits *= 3;
|
||
}
|
||
}
|
||
|
||
// Calculate width in pixels.
|
||
cx = rcl.right - rcl.left;
|
||
if (cx <= 0)
|
||
{
|
||
// Glyph is completely clipped.
|
||
return;
|
||
}
|
||
|
||
// Do top side clipping.
|
||
cy = rclBounds->top - rcl.top;
|
||
if (cy > 0)
|
||
{
|
||
pjSrc += cy * lSrcDelta;
|
||
rcl.top += cy;
|
||
}
|
||
|
||
// Calculate height in pixels.
|
||
cy = rcl.bottom - rcl.top;
|
||
if (cy <= 0)
|
||
{
|
||
// Glyph is completely clipped.
|
||
return;
|
||
}
|
||
|
||
// Setup destination variables.
|
||
ulDstOffset = (rcl.top * ppdev->lDelta) + PELS_TO_BYTES(rcl.left);
|
||
cBytes = (cx + 7) >> 3;
|
||
|
||
// Wait for the bitblt engine.
|
||
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
|
||
|
||
// Setup the bitblt registers.
|
||
CP_MM_XCNT(ppdev, pjBase, PELS_TO_BYTES(cx) - 1);
|
||
CP_MM_YCNT(ppdev, pjBase, cy - 1);
|
||
CP_MM_DST_WRITE_MASK(ppdev, pjBase, cSkipBits);
|
||
CP_MM_BLT_MODE(ppdev, pjBase, jBltMode);
|
||
CP_MM_BLT_EXT_MODE(ppdev, pjBase, SOURCE_GRANULARITY);
|
||
CP_MM_DST_ADDR(ppdev, pjBase, ulDstOffset);
|
||
|
||
while (cy--)
|
||
{
|
||
BYTE* pjSrcTmp = pjSrc;
|
||
|
||
// Copy one line of glyph data to the screen.
|
||
for (i = cBytes; i >= sizeof(ULONG); i -= sizeof(ULONG))
|
||
{
|
||
*pulDst = *((ULONG*)pjSrcTmp)++;
|
||
}
|
||
|
||
if (i == 1)
|
||
{
|
||
*pulDst = *(BYTE*)pjSrcTmp;
|
||
}
|
||
else if (i == 2)
|
||
{
|
||
*pulDst = *(USHORT*)pjSrcTmp;
|
||
}
|
||
else if (i == 3)
|
||
{
|
||
*pulDst = pjSrcTmp[0] | (pjSrcTmp[1] << 8) | (pjSrcTmp[2] << 16);
|
||
}
|
||
|
||
pjSrc += lSrcDelta;
|
||
}
|
||
while (BUSY_BLT(ppdev, pjBase));
|
||
CP_MM_BLT_EXT_MODE(ppdev, pjBase, 0);
|
||
}
|
||
|
||
|
||
#if 1 // D5480
|
||
/******************************************************************************\
|
||
*
|
||
* Function: vGlyphOut
|
||
*
|
||
* Draw an uncacheable glyph directly to screen.
|
||
*
|
||
* Parameters: ppdev Pointer to physical device.
|
||
* pfc Pointer to FONTCACHE.
|
||
* pstro Pointer to array of glyphs to draw.
|
||
* ulSolidColor Foreground Color.
|
||
*
|
||
* Returns: Nothing.
|
||
*
|
||
\******************************************************************************/
|
||
VOID vMmGlyphOut(
|
||
PDEV* ppdev,
|
||
FONTCACHE* pfc,
|
||
STROBJ* pstro,
|
||
ULONG ulSolidColor )
|
||
{
|
||
BOOL bMoreGlyphs;
|
||
LONG cGlyphs;
|
||
GLYPHPOS* pgp;
|
||
BOOL bFirstTime;
|
||
POINTL ptlOrigin;
|
||
ULONG ulCharInc;
|
||
ULONG ulDstOffset;
|
||
POINTL ptlDst;
|
||
BYTE* pjBase = ppdev->pjBase;
|
||
BYTE jBltMode = ppdev->jModeColor;
|
||
LONG lDelta = ppdev->lDelta;
|
||
|
||
bFirstTime = TRUE;
|
||
ulCharInc = pstro->ulCharInc;
|
||
jBltMode |= ENABLE_COLOR_EXPAND | ENABLE_TRANSPARENCY_COMPARE;
|
||
|
||
do
|
||
{
|
||
// Get pointer to array of glyphs.
|
||
if (pstro->pgp != NULL)
|
||
{
|
||
pgp = pstro->pgp;
|
||
cGlyphs = pstro->cGlyphs;
|
||
bMoreGlyphs = FALSE;
|
||
}
|
||
else
|
||
{
|
||
bMoreGlyphs = STROBJ_bEnum(pstro, &cGlyphs, &pgp);
|
||
}
|
||
|
||
// Setup the blitter if this is the first loop through.
|
||
if (bFirstTime)
|
||
{
|
||
// Wait for the bitblt engine.
|
||
while (BUSY_BLT(ppdev, pjBase));
|
||
|
||
// Setup the common bitblt registers.
|
||
CP_MM_FG_COLOR(ppdev, pjBase, ulSolidColor);
|
||
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
|
||
CP_MM_ROP(ppdev, pjBase, CL_SRC_COPY);
|
||
CP_MM_BLT_EXT_MODE(ppdev, pjBase, 0);
|
||
|
||
// Mark registers as setup.
|
||
bFirstTime = FALSE;
|
||
}
|
||
|
||
// Get coordinates of first glyph.
|
||
ptlOrigin.x = pgp->ptl.x;
|
||
ptlOrigin.y = pgp->ptl.y;
|
||
|
||
|
||
// Loop through all glyphs.
|
||
while (cGlyphs-- > 0)
|
||
{
|
||
LONG cy;
|
||
GLYPHCACHE* pgc;
|
||
|
||
if (pgp->hg < MAX_GLYPHS)
|
||
{
|
||
// This is a cacheable glyph index.
|
||
pgc = &pfc->aGlyphs[pgp->hg];
|
||
cy = (pgc->pjGlyph == NULL)
|
||
? lAllocateGlyph(pfc, pgp->pgdf->pgb, pgc)
|
||
: pgc->sizlBytes.cy;
|
||
}
|
||
else
|
||
{
|
||
// The glyph index is out of range.
|
||
cy = GLYPH_UNCACHEABLE;
|
||
}
|
||
|
||
if (cy >= 0) // The glyph is cached, expand it to the screen.
|
||
{
|
||
// Setup the destination variables.
|
||
ptlDst.x = ptlOrigin.x + pgc->ptlOrigin.x;
|
||
ptlDst.y = ptlOrigin.y + pgc->ptlOrigin.y;
|
||
ulDstOffset = (ptlDst.y * lDelta) + PELS_TO_BYTES(ptlDst.x);
|
||
|
||
// Wait for the bitblt engine.
|
||
while (BUSY_BLT(ppdev, pjBase));
|
||
|
||
// Perform the blit expansion.
|
||
CP_MM_XCNT(ppdev, pjBase, pgc->sizlBytes.cx);
|
||
CP_MM_YCNT(ppdev, pjBase, cy);
|
||
CP_MM_SRC_Y_OFFSET(ppdev, pjBase, pgc->lDelta);
|
||
CP_MM_SRC_ADDR(ppdev, pjBase, (ULONG_PTR)pgc->pjGlyph);
|
||
CP_MM_BLT_MODE(ppdev, pjBase, jBltMode);
|
||
CP_MM_DST_ADDR(ppdev, pjBase, ulDstOffset);
|
||
}
|
||
else if (cy == GLYPH_UNCACHEABLE)
|
||
{
|
||
// The glyph is uncacheable, draw it directly.
|
||
vDrawGlyph(ppdev, pgp->pgdf->pgb, ptlOrigin);
|
||
}
|
||
|
||
// Next glyph.
|
||
pgp++;
|
||
if (ulCharInc)
|
||
{
|
||
ptlOrigin.x += ulCharInc;
|
||
}
|
||
else
|
||
{
|
||
ptlOrigin.x = pgp->ptl.x;
|
||
ptlOrigin.y = pgp->ptl.y;
|
||
}
|
||
}
|
||
} while (bMoreGlyphs);
|
||
}
|
||
|
||
/******************************************************************************\
|
||
*
|
||
* Function: vGlyphOutClip
|
||
*
|
||
* Draw an uncacheable glyph directly to screen.
|
||
*
|
||
* Parameters: ppdev Pointer to physical device.
|
||
* pfc Pointer to FONTCACHE.
|
||
* pstro Pointer to array of glyphs to draw.
|
||
* rclBounds Clipping rectangle.
|
||
* ulSolidColor Foreground Color.
|
||
*
|
||
* Returns: Nothing.
|
||
*
|
||
\******************************************************************************/
|
||
VOID vMmGlyphOutClip(
|
||
PDEV* ppdev,
|
||
FONTCACHE* pfc,
|
||
STROBJ* pstro,
|
||
RECTL* rclBounds,
|
||
ULONG ulSolidColor )
|
||
{
|
||
BOOL bMoreGlyphs;
|
||
LONG cGlyphs;
|
||
GLYPHPOS* pgp;
|
||
BOOL bFirstTime;
|
||
POINTL ptlOrigin;
|
||
ULONG ulCharInc;
|
||
ULONG ulDstOffset;
|
||
POINTL ptlDst;
|
||
BYTE* pjBase = ppdev->pjBase;
|
||
BYTE jBltMode = ppdev->jModeColor;
|
||
LONG lDelta = ppdev->lDelta;
|
||
|
||
bFirstTime = TRUE;
|
||
ulCharInc = pstro->ulCharInc;
|
||
jBltMode |= ENABLE_COLOR_EXPAND | ENABLE_TRANSPARENCY_COMPARE;
|
||
|
||
do
|
||
{
|
||
// Get pointer to array of glyphs.
|
||
if (pstro->pgp != NULL)
|
||
{
|
||
pgp = pstro->pgp;
|
||
cGlyphs = pstro->cGlyphs;
|
||
bMoreGlyphs = FALSE;
|
||
}
|
||
else
|
||
{
|
||
bMoreGlyphs = STROBJ_bEnum(pstro, &cGlyphs, &pgp);
|
||
}
|
||
|
||
// Setup the blitter if this is the first loop through.
|
||
if (bFirstTime)
|
||
{
|
||
// Wait for the bitblt engine.
|
||
while (BUSY_BLT(ppdev, pjBase));
|
||
|
||
// Setup the common bitblt registers.
|
||
CP_MM_FG_COLOR(ppdev, pjBase, ulSolidColor);
|
||
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
|
||
CP_MM_ROP(ppdev, pjBase, CL_SRC_COPY);
|
||
CP_MM_BLT_EXT_MODE(ppdev, pjBase, 0);
|
||
|
||
// Mark registers as setup.
|
||
bFirstTime = FALSE;
|
||
}
|
||
|
||
// Get coordinates of first glyph.
|
||
ptlOrigin.x = pgp->ptl.x;
|
||
ptlOrigin.y = pgp->ptl.y;
|
||
|
||
// Loop through all glyphs.
|
||
while (cGlyphs-- > 0)
|
||
{
|
||
LONG c, cy;
|
||
GLYPHCACHE* pgc;
|
||
|
||
if (pgp->hg < MAX_GLYPHS)
|
||
{
|
||
// This is a cacheable glyph index.
|
||
pgc = &pfc->aGlyphs[pgp->hg];
|
||
cy = (pgc->pjGlyph == NULL)
|
||
? lAllocateGlyph(pfc, pgp->pgdf->pgb, pgc)
|
||
: pgc->sizlBytes.cy;
|
||
}
|
||
else
|
||
{
|
||
// The glyph index is out of range.
|
||
goto SoftwareClipping;
|
||
}
|
||
|
||
if (cy >= 0)
|
||
{
|
||
// The glyph is cached, expand it to the screen.
|
||
ULONG ulSrcOffset;
|
||
RECTL rcl;
|
||
LONG lSrcDelta;
|
||
LONG cSkipBits;
|
||
SIZEL sizlDst;
|
||
|
||
// Calculate the glyph bounding box.
|
||
rcl.left = ptlOrigin.x + pgc->ptlOrigin.x;
|
||
rcl.right = rcl.left + pgc->sizlPixels.cx;
|
||
if ((rcl.left >= rclBounds->right) ||
|
||
(rcl.right <= rclBounds->left))
|
||
{
|
||
goto NextGlyph;
|
||
}
|
||
rcl.top = ptlOrigin.y + pgc->ptlOrigin.y;
|
||
rcl.bottom = rcl.top + pgc->sizlPixels.cy;
|
||
if ((rcl.top >= rclBounds->bottom) ||
|
||
(rcl.bottom <= rclBounds->top))
|
||
{
|
||
goto NextGlyph;
|
||
}
|
||
|
||
// Setup source parameters.
|
||
ulSrcOffset = (ULONG)((ULONG_PTR)pgc->pjGlyph);
|
||
lSrcDelta = pgc->lDelta;
|
||
|
||
// Do the left side clipping.
|
||
c = rclBounds->left - rcl.left;
|
||
if (c > 0)
|
||
{
|
||
ulSrcOffset += c >> 3;
|
||
cSkipBits = c & 7;
|
||
rcl.left += c & ~7;
|
||
|
||
if (ppdev->cBpp == 3)
|
||
{
|
||
cSkipBits *= 3;
|
||
}
|
||
|
||
ulSrcOffset |= cSkipBits << 24;
|
||
}
|
||
|
||
// Do the top side clipping.
|
||
c = rclBounds->top - rcl.top;
|
||
if (c > 0)
|
||
{
|
||
rcl.top += c;
|
||
ulSrcOffset += c * lSrcDelta;
|
||
}
|
||
|
||
// Calculate size of the blit.
|
||
sizlDst.cx = min(rcl.right, rclBounds->right) - rcl.left;
|
||
sizlDst.cy = min(rcl.bottom, rclBounds->bottom) - rcl.top;
|
||
if ((sizlDst.cx <= 0) || (sizlDst.cy <= 0))
|
||
{
|
||
goto NextGlyph;
|
||
}
|
||
|
||
// Setup destination variables.
|
||
ulDstOffset = (rcl.top * lDelta) + PELS_TO_BYTES(rcl.left);
|
||
|
||
// HARDWARE BUG:
|
||
// ============
|
||
// A monochrome screen-to-screen expansion with a source pitch
|
||
// not equaling the width of the expansion (i.e. left- and/or
|
||
// right-side clipping) is not done correctly by the hardware.
|
||
// So we have to do the line increment by software.
|
||
if (((sizlDst.cx + 7) >> 3) != lSrcDelta)
|
||
{
|
||
// Wait for the bitblt engine.
|
||
while (BUSY_BLT(ppdev, pjBase));
|
||
|
||
// Setup the common bitblt registers.
|
||
CP_MM_XCNT(ppdev, pjBase, PELS_TO_BYTES(sizlDst.cx) - 1);
|
||
CP_MM_YCNT(ppdev, pjBase, 0);
|
||
CP_MM_BLT_MODE(ppdev, pjBase, jBltMode);
|
||
|
||
while (TRUE)
|
||
{
|
||
// Perform the expansion.
|
||
CP_MM_SRC_ADDR(ppdev, pjBase, ulSrcOffset);
|
||
CP_MM_DST_ADDR(ppdev, pjBase, ulDstOffset);
|
||
|
||
// Next line.
|
||
if (--sizlDst.cy == 0)
|
||
{
|
||
goto NextGlyph;
|
||
}
|
||
ulSrcOffset += lSrcDelta;
|
||
ulDstOffset += lDelta;
|
||
|
||
// Wait for the bitblt engine.
|
||
while (BUSY_BLT(ppdev, pjBase));
|
||
}
|
||
}
|
||
|
||
// Wait for the bitblt engine.
|
||
while (BUSY_BLT(ppdev, pjBase));
|
||
|
||
// Perform the expansion.
|
||
CP_MM_XCNT(ppdev, pjBase, PELS_TO_BYTES(sizlDst.cx) - 1);
|
||
CP_MM_YCNT(ppdev, pjBase, sizlDst.cy - 1);
|
||
CP_MM_SRC_Y_OFFSET(ppdev, pjBase, lSrcDelta);
|
||
CP_MM_SRC_ADDR(ppdev, pjBase, ulSrcOffset);
|
||
CP_MM_BLT_MODE(ppdev, pjBase, jBltMode);
|
||
CP_MM_DST_ADDR(ppdev, pjBase, ulDstOffset);
|
||
}
|
||
else if (cy == GLYPH_UNCACHEABLE)
|
||
{
|
||
SoftwareClipping:
|
||
{
|
||
// The glyph is uncacheable, draw it directly.
|
||
vClipGlyph(ppdev, pgp->pgdf->pgb, ptlOrigin, rclBounds,
|
||
ulSolidColor);
|
||
}
|
||
}
|
||
|
||
// Next glyph.
|
||
NextGlyph:
|
||
{
|
||
pgp++;
|
||
if (ulCharInc)
|
||
{
|
||
ptlOrigin.x += ulCharInc;
|
||
}
|
||
else
|
||
{
|
||
ptlOrigin.x = pgp->ptl.x;
|
||
ptlOrigin.y = pgp->ptl.y;
|
||
}
|
||
}
|
||
}
|
||
} while (bMoreGlyphs);
|
||
}
|
||
|
||
/******************************************************************************\
|
||
*
|
||
* Function: vGlyphOut80
|
||
*
|
||
* Draw an uncacheable glyph directly to screen.
|
||
*
|
||
* Parameters: ppdev Pointer to physical device.
|
||
* pfc Pointer to FONTCACHE.
|
||
* pstro Pointer to array of glyphs to draw.
|
||
* ulSolidColor Foreground Color.
|
||
*
|
||
* Returns: Nothing.
|
||
*
|
||
\******************************************************************************/
|
||
VOID vMmGlyphOut80(
|
||
PDEV* ppdev,
|
||
FONTCACHE* pfc,
|
||
STROBJ* pstro,
|
||
ULONG ulSolidColor )
|
||
{
|
||
ULONG_PTR* ulCLStart;
|
||
ULONG ulWidthHeight;
|
||
ULONG xCLOffset;
|
||
BOOL bMoreGlyphs;
|
||
LONG cGlyphs;
|
||
GLYPHPOS* pgp;
|
||
POINTL ptlOrigin;
|
||
ULONG ulCharInc;
|
||
POINTL ptlDst;
|
||
LONG cy;
|
||
GLYPHCACHE* pgc;
|
||
DWORD jSaveMode;
|
||
ULONG cCommandPacket = 0;
|
||
ULONG ulDstOffset = 0;
|
||
BOOL bCommandListOpen = FALSE;
|
||
BYTE* pjBase = ppdev->pjBase;
|
||
LONG lDelta = ppdev->lDelta;
|
||
DWORD jExtMode = ENABLE_XY_POSITION_PACKED
|
||
| CL_PACKED_SRC_COPY
|
||
| ppdev->jModeColor
|
||
| ENABLE_COLOR_EXPAND
|
||
| ENABLE_TRANSPARENCY_COMPARE;
|
||
|
||
ulCharInc = pstro->ulCharInc;
|
||
jSaveMode = jExtMode;
|
||
|
||
//
|
||
// Make sure we can write to the video registers.
|
||
//
|
||
// We need to change to wait for buffer ready
|
||
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
|
||
|
||
// Setup the common bitblt registers.
|
||
CP_MM_FG_COLOR(ppdev, pjBase, ulSolidColor);
|
||
// Do we really need to set it every time?
|
||
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
|
||
CP_MM_SRC_XY_PACKED(ppdev, pjBase, 0);
|
||
|
||
do
|
||
{
|
||
// Get pointer to array of glyphs.
|
||
if (pstro->pgp != NULL)
|
||
{
|
||
pgp = pstro->pgp;
|
||
cGlyphs = pstro->cGlyphs;
|
||
bMoreGlyphs = FALSE;
|
||
}
|
||
else
|
||
{
|
||
bMoreGlyphs = STROBJ_bEnum(pstro, &cGlyphs, &pgp);
|
||
}
|
||
|
||
// Get coordinates of first glyph.
|
||
ptlOrigin.x = pgp->ptl.x;
|
||
ptlOrigin.y = pgp->ptl.y;
|
||
|
||
|
||
// Loop through all glyphs.
|
||
while (cGlyphs-- > 0)
|
||
{
|
||
if (pgp->hg < MAX_GLYPHS)
|
||
{
|
||
// This is a cacheable glyph index.
|
||
pgc = &pfc->aGlyphs[pgp->hg];
|
||
cy = (pgc->pjGlyph == NULL)
|
||
? lAllocateGlyph(pfc, pgp->pgdf->pgb, pgc)
|
||
: pgc->sizlBytes.cy;
|
||
}
|
||
else
|
||
{
|
||
// The glyph index is out of range.
|
||
cy = GLYPH_UNCACHEABLE;
|
||
}
|
||
|
||
if (cy >= 0) // The glyph is cached, expand it to the screen.
|
||
{
|
||
if ( bCommandListOpen )
|
||
{
|
||
// Command List
|
||
if( cCommandPacket == 0 )
|
||
{
|
||
jExtMode |= ENABLE_COMMAND_LIST_PACKED;
|
||
ulCLStart = ppdev->pCommandList;
|
||
ulDstOffset |= (ULONG)(((ULONG_PTR)ulCLStart
|
||
- (ULONG_PTR)ppdev->pjScreen) << 14);
|
||
CP_MM_CL_SWITCH(ppdev);
|
||
}
|
||
|
||
// Calculate the destination address and size.
|
||
*ulCLStart = PACKXY_FAST(pgc->sizlPixels.cx - 1, cy);
|
||
// XY
|
||
*(ulCLStart + 1) = PACKXY_FAST(ptlOrigin.x + pgc->ptlOrigin.x,
|
||
ptlOrigin.y + pgc->ptlOrigin.y);
|
||
// Source Start address
|
||
*(ulCLStart + 2) = (ULONG)((ULONG_PTR)pgc->pjGlyph);
|
||
|
||
// Dst/SRC pitch
|
||
*(ulCLStart + 3) = PACKXY_FAST(lDelta, pgc->lDelta);
|
||
|
||
ulCLStart += 4;
|
||
|
||
if( ++cCommandPacket > COMMAND_TOTAL_PACKETS )
|
||
{
|
||
// Indicate last Packet
|
||
*(ulCLStart - 4) |= COMMAND_LAST_PACKET;
|
||
CP_MM_BLT_MODE_PACKED(ppdev, pjBase, jExtMode);
|
||
CP_MM_DST_ADDR(ppdev, pjBase, ulDstOffset);
|
||
CP_MM_DST_X(ppdev, pjBase, xCLOffset);
|
||
bCommandListOpen = FALSE;
|
||
cCommandPacket = 0;
|
||
jExtMode = jSaveMode;
|
||
ulDstOffset = 0;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
bCommandListOpen = TRUE;
|
||
//
|
||
// Make sure we can write to the video registers.
|
||
//
|
||
// We need to change to wait for buffer ready
|
||
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
|
||
// Setup the first set.
|
||
xCLOffset = ptlOrigin.x + pgc->ptlOrigin.x;
|
||
CP_MM_DST_Y(ppdev, pjBase, ptlOrigin.y + pgc->ptlOrigin.y);
|
||
CP_MM_SRC_Y_OFFSET(ppdev, pjBase, pgc->lDelta);
|
||
CP_MM_SRC_ADDR(ppdev,pjBase,(ULONG_PTR)pgc->pjGlyph);
|
||
|
||
// Perform the blit expansion.
|
||
CP_MM_XCNT(ppdev, pjBase, pgc->sizlPixels.cx - 1 );
|
||
CP_MM_YCNT(ppdev, pjBase, cy);
|
||
}
|
||
}
|
||
else if (cy == GLYPH_UNCACHEABLE)
|
||
{
|
||
if ( bCommandListOpen )
|
||
{
|
||
// Indicate last Packet
|
||
if ( cCommandPacket )
|
||
*(ulCLStart - 4) |= COMMAND_LAST_PACKET;
|
||
CP_MM_BLT_MODE_PACKED(ppdev, pjBase, jExtMode);
|
||
CP_MM_DST_ADDR(ppdev, pjBase, ulDstOffset);
|
||
CP_MM_DST_X(ppdev, pjBase, xCLOffset);
|
||
bCommandListOpen = FALSE;
|
||
jExtMode = jSaveMode;
|
||
cCommandPacket = 0;
|
||
ulDstOffset = 0;
|
||
}
|
||
// The glyph is uncacheable, draw it directly.
|
||
vDrawGlyph(ppdev, pgp->pgdf->pgb, ptlOrigin);
|
||
}
|
||
|
||
// Next glyph.
|
||
pgp++;
|
||
if (ulCharInc)
|
||
{
|
||
ptlOrigin.x += ulCharInc;
|
||
}
|
||
else
|
||
{
|
||
ptlOrigin.x = pgp->ptl.x;
|
||
ptlOrigin.y = pgp->ptl.y;
|
||
}
|
||
}
|
||
} while (bMoreGlyphs);
|
||
|
||
if ( bCommandListOpen )
|
||
{
|
||
// Indicate last Packet
|
||
if ( cCommandPacket )
|
||
*(ulCLStart - 4) |= COMMAND_LAST_PACKET;
|
||
CP_MM_BLT_MODE_PACKED(ppdev, pjBase, jExtMode);
|
||
CP_MM_DST_ADDR(ppdev, pjBase, ulDstOffset);
|
||
CP_MM_DST_X(ppdev, pjBase, xCLOffset);
|
||
}
|
||
|
||
}
|
||
|
||
/******************************************************************************\
|
||
*
|
||
* Function: vGlyphOutClip80
|
||
*
|
||
* Draw an uncacheable glyph directly to screen.
|
||
*
|
||
* Parameters: ppdev Pointer to physical device.
|
||
* pfc Pointer to FONTCACHE.
|
||
* pstro Pointer to array of glyphs to draw.
|
||
* rclBounds Clipping rectangle.
|
||
* ulSolidColor Foreground Color.
|
||
*
|
||
* Returns: Nothing.
|
||
*
|
||
\******************************************************************************/
|
||
VOID vMmGlyphOutClip80(
|
||
PDEV* ppdev,
|
||
FONTCACHE* pfc,
|
||
STROBJ* pstro,
|
||
RECTL* rclBounds,
|
||
ULONG ulSolidColor )
|
||
{
|
||
BOOL bMoreGlyphs;
|
||
LONG cGlyphs;
|
||
GLYPHPOS* pgp;
|
||
POINTL ptlOrigin;
|
||
ULONG ulCharInc;
|
||
POINTL ptlDst;
|
||
LONG cy;
|
||
GLYPHCACHE* pgc;
|
||
RECTL rclDst;
|
||
RECTL rclClip;
|
||
ULONG ulDstOffset;
|
||
BYTE* pjBase = ppdev->pjBase;
|
||
LONG lDelta = ppdev->lDelta;
|
||
DWORD jExtMode = ENABLE_XY_POSITION_PACKED
|
||
| ENABLE_CLIP_RECT_PACKED
|
||
| CL_PACKED_SRC_COPY
|
||
| ppdev->jModeColor
|
||
| ENABLE_COLOR_EXPAND
|
||
| ENABLE_TRANSPARENCY_COMPARE;
|
||
|
||
ulCharInc = pstro->ulCharInc;
|
||
|
||
//
|
||
// Make sure we can write to the video registers.
|
||
//
|
||
// We need to change to wait for buffer ready
|
||
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
|
||
|
||
// Setup the common bitblt registers.
|
||
CP_MM_FG_COLOR(ppdev, pjBase, ulSolidColor);
|
||
// Do we really need to set it every time?
|
||
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
|
||
CP_MM_SRC_XY_PACKED(ppdev, pjBase, 0);
|
||
|
||
CP_MM_BLT_MODE_PACKED(ppdev, pjBase, jExtMode);
|
||
|
||
do
|
||
{
|
||
// Get pointer to array of glyphs.
|
||
if (pstro->pgp != NULL)
|
||
{
|
||
pgp = pstro->pgp;
|
||
cGlyphs = pstro->cGlyphs;
|
||
bMoreGlyphs = FALSE;
|
||
}
|
||
else
|
||
{
|
||
bMoreGlyphs = STROBJ_bEnum(pstro, &cGlyphs, &pgp);
|
||
}
|
||
|
||
// Get coordinates of first glyph.
|
||
ptlOrigin.x = pgp->ptl.x;
|
||
ptlOrigin.y = pgp->ptl.y;
|
||
|
||
// Loop through all glyphs.
|
||
while (cGlyphs-- > 0)
|
||
{
|
||
LONG c, cy;
|
||
GLYPHCACHE* pgc;
|
||
|
||
if (pgp->hg < MAX_GLYPHS)
|
||
{
|
||
// This is a cacheable glyph index.
|
||
pgc = &pfc->aGlyphs[pgp->hg];
|
||
cy = (pgc->pjGlyph == NULL)
|
||
? lAllocateGlyph(pfc, pgp->pgdf->pgb, pgc)
|
||
: pgc->sizlBytes.cy;
|
||
}
|
||
else
|
||
{
|
||
// The glyph index is out of range.
|
||
cy = GLYPH_UNCACHEABLE;
|
||
}
|
||
|
||
if (cy >= 0)
|
||
{
|
||
// Calculate the glyph bounding box.
|
||
rclDst.left = ptlOrigin.x + pgc->ptlOrigin.x;
|
||
rclDst.right = rclDst.left + pgc->sizlPixels.cx;
|
||
if ((rclDst.left >= rclBounds->right) ||
|
||
(rclDst.right <= rclBounds->left))
|
||
{
|
||
goto NextGlyph;
|
||
}
|
||
rclDst.top = ptlOrigin.y + pgc->ptlOrigin.y;
|
||
rclDst.bottom = rclDst.top + pgc->sizlPixels.cy;
|
||
if ((rclDst.top >= rclBounds->bottom) ||
|
||
(rclDst.bottom <= rclBounds->top))
|
||
{
|
||
goto NextGlyph;
|
||
}
|
||
|
||
rclClip = *rclBounds;
|
||
ulDstOffset = 0;
|
||
//
|
||
// Handle X negtive
|
||
//
|
||
if (rclDst.left < 0)
|
||
{
|
||
rclClip.left -= rclDst.left;
|
||
rclClip.right -= rclDst.left;
|
||
ulDstOffset += PELS_TO_BYTES(rclDst.left);
|
||
rclDst.left = 0;
|
||
}
|
||
//
|
||
// Handle Y negtive
|
||
//
|
||
if (rclDst.top < 0)
|
||
{
|
||
rclClip.top -= rclDst.top;
|
||
rclClip.bottom -= rclDst.top;
|
||
ulDstOffset += (rclDst.top * lDelta);
|
||
rclDst.top = 0;
|
||
}
|
||
|
||
CP_MM_CLIP_ULXY(ppdev, pjBase, rclClip.left, rclClip.top);
|
||
CP_MM_CLIP_LRXY(ppdev, pjBase, rclClip.right - 1, rclClip.bottom - 1);
|
||
|
||
//
|
||
// Make sure we can write to the video registers.
|
||
//
|
||
// We need to change to wait for buffer ready
|
||
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
|
||
CP_MM_DST_Y(ppdev, pjBase, rclDst.top);
|
||
CP_MM_SRC_Y_OFFSET(ppdev, pjBase, pgc->lDelta);
|
||
CP_MM_SRC_ADDR(ppdev, pjBase, (ULONG_PTR)pgc->pjGlyph);
|
||
|
||
// Perform the blit expansion.
|
||
CP_MM_XCNT(ppdev, pjBase, pgc->sizlPixels.cx - 1 );
|
||
CP_MM_YCNT(ppdev, pjBase, cy);
|
||
CP_MM_DST_ADDR(ppdev, pjBase, ulDstOffset);
|
||
CP_MM_DST_X(ppdev, pjBase, rclDst.left);
|
||
}
|
||
else if (cy == GLYPH_UNCACHEABLE)
|
||
{
|
||
// The glyph is uncacheable, draw it directly.
|
||
vClipGlyph(ppdev, pgp->pgdf->pgb, ptlOrigin, rclBounds,
|
||
ulSolidColor);
|
||
}
|
||
|
||
// Next glyph.
|
||
NextGlyph:
|
||
{
|
||
pgp++;
|
||
if (ulCharInc)
|
||
{
|
||
ptlOrigin.x += ulCharInc;
|
||
}
|
||
else
|
||
{
|
||
ptlOrigin.x = pgp->ptl.x;
|
||
ptlOrigin.y = pgp->ptl.y;
|
||
}
|
||
}
|
||
}
|
||
} while (bMoreGlyphs);
|
||
|
||
}
|
||
#endif // endif D5480
|