able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/drivers/video/ms/weitek/disp/textout.c

1381 lines
41 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/******************************Module*Header*******************************\
* Module Name: textout.c
*
* Copyright (c) 1992-1995 Microsoft Corporation
*
\**************************************************************************/
#include "precomp.h"
//////////////////////////////////////////////////////////////////////////
RECTL grclMax = { 0, 0, 0x10000, 0x10000 };
// Maximal clip rectangle for trivial clipping
#define GLYPH_CACHE_CX 32 // Maximal width of glyphs that we'll consider
// caching
#define GLYPH_CACHE_CY 32 // Maximum height of glyphs that we'll consider
// caching
#define GLYPH_ALLOC_SIZE 4000
// Do all cached glyph memory allocations
// in 4k chunks
#define HGLYPH_SENTINEL ((ULONG) -1)
// GDI will never give us a glyph with a
// handle value of 0xffffffff, so we can
// use this as a sentinel for the end of
// our linked lists
#define GLYPH_HASH_SIZE 256
#define GLYPH_HASH_FUNC(x) ((x) & (GLYPH_HASH_SIZE - 1))
typedef struct _CACHEDGLYPH CACHEDGLYPH;
typedef struct _CACHEDGLYPH
{
CACHEDGLYPH* pcgNext; // Points to next glyph that was assigned
// to the same hash table bucket
HGLYPH hg; // Handles in the bucket-list are kept in
// increasing order
POINTL ptlOrigin; // Origin of glyph bits
LONG xyWidth; // Width of the glyph in the high word
ULONG* pdPixel1Rem;// Points to accelerator register used for
// writing last partial dword of the glyph
LONG cd; // Number of whole dwords in glyph
ULONG ad[1]; // Start of glyph bits
} CACHEDGLYPH; /* cg, pcg */
typedef struct _GLYPHALLOC GLYPHALLOC;
typedef struct _GLYPHALLOC
{
GLYPHALLOC* pgaNext; // Points to next glyph structure that
// was allocated for this font
CACHEDGLYPH acg[1]; // This array is a bit misleading, because
// the CACHEDGLYPH structures are actually
// variable sized
} GLYPHAALLOC; /* ga, pga */
typedef struct _CACHEDFONT
{
GLYPHALLOC* pgaChain; // Points to start of allocated memory list
CACHEDGLYPH* pcgNew; // Points to where in the current glyph
// allocation structure a new glyph should
// be placed
LONG cjAlloc; // Bytes remaining in current glyph allocation
// structure
CACHEDGLYPH cgSentinel; // Sentinel entry of the end of our bucket
// lists, with a handle of HGLYPH_SENTINEL
CACHEDGLYPH* apcg[GLYPH_HASH_SIZE];
// Hash table for glyphs
} CACHEDFONT; /* cf, pcf */
/******************************Public*Routine******************************\
* CACHEDFONT* pcfAllocateCachedFont()
*
* Initializes our font data structure.
*
\**************************************************************************/
CACHEDFONT* pcfAllocateCachedFont(
PDEV* ppdev)
{
CACHEDFONT* pcf;
CACHEDGLYPH** ppcg;
LONG i;
pcf = EngAllocMem(FL_ZERO_MEMORY, sizeof(CACHEDFONT), ALLOC_TAG);
if (pcf != NULL)
{
// Note that we rely on FL_ZERO_MEMORY to zero 'pgaChain' and
// 'cjAlloc':
pcf->cgSentinel.hg = HGLYPH_SENTINEL;
// Initialize the hash table entries to all point to our sentinel:
for (ppcg = &pcf->apcg[0], i = GLYPH_HASH_SIZE; i != 0; i--, ppcg++)
{
*ppcg = &pcf->cgSentinel;
}
}
return(pcf);
}
/******************************Public*Routine******************************\
* VOID vFreeCachedFont()
*
* Frees all memory associated with the cache we kept for this font.
*
\**************************************************************************/
VOID vFreeCachedFont(
CACHEDFONT* pcf)
{
GLYPHALLOC* pga;
GLYPHALLOC* pgaNext;
pga = pcf->pgaChain;
while (pga != NULL)
{
pgaNext = pga->pgaNext;
EngFreeMem(pga);
pga = pgaNext;
}
EngFreeMem(pcf);
}
/******************************Public*Routine******************************\
* CACHEDGLYPH* pcgNew()
*
* Caches a new glyph.
*
\**************************************************************************/
CACHEDGLYPH* pcgNew(
PDEV* ppdev,
CACHEDFONT* pcf,
GLYPHPOS* pgp)
{
GLYPHBITS* pgb;
GLYPHALLOC* pga;
CACHEDGLYPH* pcg;
LONG cjCachedGlyph;
HGLYPH hg;
LONG cyGlyph;
LONG cxGlyph;
POINTL ptlOrigin;
LONG cjSrcWidth;
BYTE jSrc;
BYTE* pjSrc;
BYTE* pjDst;
LONG cAlign;
LONG i;
LONG j;
LONG cTotal;
LONG cRem;
LONG cd;
LONG iHash;
CACHEDGLYPH* pcgFind;
// First, calculate the amount of storage we'll need for this glyph:
pgb = pgp->pgdf->pgb;
cjCachedGlyph = sizeof(CACHEDGLYPH)
+ ((pgb->sizlBitmap.cx * pgb->sizlBitmap.cy + 7) >> 3);
// Reserve an extra byte at the end for temporary usage by our pack
// routine:
cjCachedGlyph++;
// We need to dword align it too:
cjCachedGlyph = (cjCachedGlyph + 3) & ~3L;
if (cjCachedGlyph > pcf->cjAlloc)
{
// Have to allocate a new glyph allocation structure:
pga = EngAllocMem(FL_ZERO_MEMORY, GLYPH_ALLOC_SIZE, ALLOC_TAG);
if (pga == NULL)
{
// It's safe to return at this time because we haven't
// fatally altered any of our data structures:
return(NULL);
}
// Add this allocation to the front of the allocation linked list,
// so that we can free it later:
pga->pgaNext = pcf->pgaChain;
pcf->pgaChain = pga;
// Now we've got a chunk of memory where we can store our cached
// glyphs:
pcf->pcgNew = &pga->acg[0];
pcf->cjAlloc = GLYPH_ALLOC_SIZE - (sizeof(*pga) - sizeof(pga->acg[0]));
// It would be bad if we let in any glyphs that would be bigger
// than our basic allocation size:
ASSERTDD(cjCachedGlyph <= GLYPH_ALLOC_SIZE, "Woah, this is one big glyph!");
}
pcg = pcf->pcgNew;
// We only need to ensure 'dword' alignment of the next structure:
pcf->pcgNew = (CACHEDGLYPH*) ((BYTE*) pcg + cjCachedGlyph);
pcf->cjAlloc -= cjCachedGlyph;
ASSERTDD((((ULONG_PTR) pcf->pcgNew) & 3) == 0, "pcgNew not aligned");
ASSERTDD((BYTE*) pcf->pcgNew <= (BYTE*) pcf->pgaChain + GLYPH_ALLOC_SIZE,
"Overrunning end of buffer");
///////////////////////////////////////////////////////////////
// Pack the glyph:
cyGlyph = pgb->sizlBitmap.cy;
cxGlyph = pgb->sizlBitmap.cx;
ptlOrigin = pgb->ptlOrigin;
cjSrcWidth = (cxGlyph + 7) >> 3;
cRem = ((cxGlyph - 1) & 7) + 1; // 0 -> 8
cAlign = 0;
pjSrc = pgb->aj;
pjDst = (BYTE*) pcg->ad;
*pjDst = 0; // Have to zero very first byte
i = cyGlyph;
do {
j = cjSrcWidth;
do {
jSrc = *pjSrc;
*(pjDst) |= (jSrc >> (cAlign));
// Note that we may modify a byte past the end of our
// destination buffer, which is why we reserved an
// extra byte:
*(pjDst + 1) = (jSrc << (8 - cAlign));
pjSrc++;
pjDst++;
} while (--j != 0);
pjDst--;
cAlign += cRem;
if (cAlign >= 8)
{
cAlign -= 8;
pjDst++;
}
} while (--i != 0);
ASSERTDD(pjDst <= (BYTE*) pcf->pcgNew, "Overran end of glyph");
///////////////////////////////////////////////////////////////
// Initialize the glyph fields:
hg = pgp->hg;
pcg->hg = hg;
pcg->ptlOrigin = ptlOrigin;
pcg->xyWidth = cxGlyph << 16;
cTotal = cxGlyph * cyGlyph;
cd = (cTotal >> 5);
cRem = (cTotal & 31) - 1;
if (cRem < 0)
{
cd--;
cRem = 31;
ASSERTDD(cd >= 0, "Must leave at least one pixel left in glyph");
}
pcg->cd = cd;
pcg->pdPixel1Rem
= (ULONG*) CP_PIXEL1_REM_REGISTER(ppdev, ppdev->pjBase, cRem);
///////////////////////////////////////////////////////////////
// Insert the glyph, in-order, into the list hanging off our hash
// bucket:
iHash = GLYPH_HASH_FUNC(hg);
pcgFind = pcf->apcg[iHash];
if (pcgFind->hg > hg)
{
pcf->apcg[iHash] = pcg;
pcg->pcgNext = pcgFind;
}
else
{
// The sentinel will ensure that we never fall off the end of
// this list:
while (pcgFind->pcgNext->hg < hg)
pcgFind = pcgFind->pcgNext;
// 'pcgFind' now points to the entry to the entry after which
// we want to insert our new node:
pcg->pcgNext = pcgFind->pcgNext;
pcgFind->pcgNext = pcg;
}
return(pcg);
}
/******************************Public*Routine******************************\
* BOOL bCachedProportionalText
*
* Draws proportionally spaced glyphs via glyph caching.
*
\**************************************************************************/
BOOL bCachedProportionalText(
PDEV* ppdev,
CACHEDFONT* pcf,
GLYPHPOS* pgp,
LONG cGlyph)
{
BYTE* pjBase;
HGLYPH hg;
CACHEDGLYPH* pcg;
LONG xy;
ULONG* pdPixel1Rem;
LONG i;
pjBase = ppdev->pjBase;
CP_WOFFSET(ppdev, pjBase, ppdev->xOffset, ppdev->yOffset);
// Wait for the opaquing rectangle to be finished drawing, so that
// we don't hold the bus for a long time on our first write to
// pixel1...
CP_WAIT(ppdev, pjBase);
do {
hg = pgp->hg;
pcg = pcf->apcg[GLYPH_HASH_FUNC(hg)];
while (pcg->hg < hg)
pcg = pcg->pcgNext;
if (pcg->hg > hg)
{
// This will hopefully not be the common case (that is,
// we will have a high cache hit rate), so if I were
// writing this in Asm I would have this out-of-line
// to avoid the jump around for the common case.
// But the Pentium has branch prediction, so what the
// heck.
pcg = pcgNew(ppdev, pcf, pgp);
if (pcg == NULL)
{
CP_WOFFSET(ppdev, pjBase, 0, 0);
return(FALSE);
}
}
// The glyph's origin y-coordinate may often be negative, so we
// can't compute this as follows:
//
// xy = (pgp->ptl.x << 16) | pgp->ptl.y;
// xy += pcg->xyOrigin;
xy = ((pgp->ptl.x + pcg->ptlOrigin.x) << 16) |
(pgp->ptl.y + pcg->ptlOrigin.y);
ASSERTDD((pgp->ptl.y + pcg->ptlOrigin.y) >= 0,
"Can't have negative 'y' coordinates here");
CP_WOFF_PACKED_XY0(ppdev, pjBase, xy);
CP_WOFF_PACKED_XY1(ppdev, pjBase, xy);
CP_WOFF_PACKED_XY2(ppdev, pjBase, xy + pcg->xyWidth);
CP_START_PIXEL1(ppdev, pjBase);
pdPixel1Rem = pcg->pdPixel1Rem;
for (i = pcg->cd; i != 0; i--)
{
CP_PIXEL1(ppdev, pjBase, pcg->ad[0]);
// Note that we didn't set 'pdSrc = &pcg->ad[0]' and
// use that instead because by using and incrementing
// 'pcg' directly, we avoid an extra 'lea' instruction:
pcg = (CACHEDGLYPH*) ((ULONG*) pcg + 1);
}
CP_PIXEL1_VIA_REGISTER(ppdev, pdPixel1Rem, pcg->ad[0]);
CP_END_PIXEL1(ppdev, pjBase);
} while (pgp++, --cGlyph != 0);
// I'm not sure why we have to reset the window offset when we're
// done using it, but if we don't we get clipping problems on the
// P9100. I suspect that the manual lies when it says that the
// window offset register has no effect on clipping:
CP_WOFFSET(ppdev, pjBase, 0, 0);
return(TRUE);
}
/******************************Public*Routine******************************\
* BOOL bCachedFixedText
*
* Draws fixed spaced glyphs via glyph caching.
*
\**************************************************************************/
BOOL bCachedFixedText(
PDEV* ppdev,
CACHEDFONT* pcf,
GLYPHPOS* pgp,
LONG cGlyph,
ULONG ulCharInc)
{
BYTE* pjBase;
LONG xGlyph;
LONG yGlyph;
LONG xyGlyph;
HGLYPH hg;
CACHEDGLYPH* pcg;
ULONG* pdPixel1Rem;
LONG i;
pjBase = ppdev->pjBase;
// Convert to absolute coordinates:
xGlyph = pgp->ptl.x + ppdev->xOffset;
yGlyph = pgp->ptl.y + ppdev->yOffset;
// Wait for the opaquing rectangle to be finished drawing, so that
// we don't hold the bus for a long time on our first write to
// pixel1...
CP_WAIT(ppdev, pjBase);
do {
hg = pgp->hg;
pcg = pcf->apcg[GLYPH_HASH_FUNC(hg)];
while (pcg->hg < hg)
pcg = pcg->pcgNext;
if (pcg->hg > hg)
{
// This will hopefully not be the common case (that is,
// we will have a high cache hit rate), so if I were
// writing this in Asm I would have this out-of-line
// to avoid the jump around for the common case.
// But the Pentium has branch prediction, so what the
// heck.
pcg = pcgNew(ppdev, pcf, pgp);
if (pcg == NULL)
return(FALSE);
}
xyGlyph = PACKXY(xGlyph + pcg->ptlOrigin.x,
yGlyph + pcg->ptlOrigin.y);
xGlyph += ulCharInc;
CP_ABS_PACKED_XY0(ppdev, pjBase, xyGlyph);
CP_ABS_PACKED_XY1(ppdev, pjBase, xyGlyph);
CP_ABS_PACKED_XY2(ppdev, pjBase, xyGlyph + pcg->xyWidth);
CP_START_PIXEL1(ppdev, pjBase);
pdPixel1Rem = pcg->pdPixel1Rem;
for (i = pcg->cd; i != 0; i--)
{
CP_PIXEL1(ppdev, pjBase, pcg->ad[0]);
// Note that we didn't set 'pdSrc = &pcg->ad[0]' and
// use that instead because by using and incrementing
// 'pcg' directly, we avoid an extra 'lea' instruction:
pcg = (CACHEDGLYPH*) ((ULONG*) pcg + 1);
}
CP_PIXEL1_VIA_REGISTER(ppdev, pdPixel1Rem, pcg->ad[0]);
CP_END_PIXEL1(ppdev, pjBase);
} while (pgp++, --cGlyph != 0);
return(TRUE);
}
/******************************Public*Routine******************************\
* BOOL bCachedClippedText
*
* Draws clipped text via glyph caching.
*
\**************************************************************************/
BOOL bCachedClippedText(
PDEV* ppdev,
CACHEDFONT* pcf,
STROBJ* pstro,
CLIPOBJ* pco)
{
BYTE* pjBase;
BOOL bRet;
BOOL bMoreGlyphs;
ULONG cGlyphOriginal;
ULONG cGlyph;
BOOL bClippingSet;
GLYPHPOS* pgpOriginal;
GLYPHPOS* pgp;
GLYPHBITS* pgb;
POINTL ptlOrigin;
BOOL bMore;
CLIPENUM ce;
RECTL* prclClip;
ULONG ulCharInc;
LONG cxGlyph;
LONG cyGlyph;
ULONG* pulGlyph;
LONG i;
HGLYPH hg;
CACHEDGLYPH* pcg;
ULONG* pdPixel1Rem;
LONG xyOrigin;
ASSERTDD((pco != NULL) && (pco->iDComplexity != DC_TRIVIAL),
"Don't expect trivial clipping in this function");
bRet = TRUE;
pjBase = ppdev->pjBase;
ulCharInc = pstro->ulCharInc;
CP_WOFFSET(ppdev, pjBase, ppdev->xOffset, ppdev->yOffset);
do {
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);
}
if (cGlyphOriginal > 0)
{
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;
ce.c = 1;
prclClip = &pco->rclBounds;
goto SingleRectangle;
}
CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_ANY, 0);
do {
bMore = CLIPOBJ_bEnum(pco, sizeof(ce), (ULONG*) &ce);
for (prclClip = &ce.arcl[0]; ce.c != 0; ce.c--, prclClip++)
{
SingleRectangle:
// We don't always simply set the clipping rectangle here
// because it may actually end up that no text intersects
// this clip rectangle, so it would be for naught. This
// actually happens a lot when using NT's analog clock set
// to always-on-top, with a round shape:
bClippingSet = FALSE;
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)
{
cxGlyph = pgb->sizlBitmap.cx;
cyGlyph = pgb->sizlBitmap.cy;
pulGlyph = (ULONG*) pgb->aj;
// Do trivial rejection:
if ((prclClip->right > ptlOrigin.x) &&
(prclClip->bottom > ptlOrigin.y) &&
(prclClip->left < ptlOrigin.x + cxGlyph) &&
(prclClip->top < ptlOrigin.y + cyGlyph))
{
// Lazily set the hardware clipping:
if (!bClippingSet)
{
bClippingSet = TRUE;
CP_WAIT(ppdev, pjBase);
CP_WMIN(ppdev, pjBase, prclClip->left, prclClip->top);
CP_WMAX(ppdev, pjBase, prclClip->right - 1, prclClip->bottom - 1);
}
hg = pgp->hg;
pcg = pcf->apcg[GLYPH_HASH_FUNC(hg)];
while (pcg->hg < hg)
pcg = pcg->pcgNext;
if (pcg->hg > hg)
{
// This will hopefully not be the common case (that is,
// we will have a high cache hit rate), so if I were
// writing this in Asm I would have this out-of-line
// to avoid the jump around for the common case.
// But the Pentium has branch prediction, so what the
// heck.
pcg = pcgNew(ppdev, pcf, pgp);
if (pcg == NULL)
{
bRet = FALSE;
goto AllDone;
}
}
// Note that 'ptlOrigin.y' may be negative:
xyOrigin = PACKXY(ptlOrigin.x, ptlOrigin.y);
CP_WOFF_PACKED_XY0(ppdev, pjBase, xyOrigin);
CP_WOFF_PACKED_XY1(ppdev, pjBase, xyOrigin);
CP_WOFF_PACKED_XY2(ppdev, pjBase, xyOrigin + pcg->xyWidth);
CP_START_PIXEL1(ppdev, pjBase);
pdPixel1Rem = pcg->pdPixel1Rem;
for (i = pcg->cd; i != 0; i--)
{
CP_PIXEL1(ppdev, pjBase, pcg->ad[0]);
// Note that we didn't set 'pdSrc = &pcg->ad[0]' and
// use that instead because by using and incrementing
// 'pcg' directly, we avoid an extra 'lea' instruction:
pcg = (CACHEDGLYPH*) ((ULONG*) pcg + 1);
}
CP_PIXEL1_VIA_REGISTER(ppdev, pdPixel1Rem, pcg->ad[0]);
CP_END_PIXEL1(ppdev, pjBase);
}
if (--cGlyph == 0)
break;
// Get ready for next glyph:
pgp++;
if (ulCharInc == 0)
{
pgb = pgp->pgdf->pgb;
ptlOrigin.x = pgp->ptl.x + pgb->ptlOrigin.x;
ptlOrigin.y = pgp->ptl.y + pgb->ptlOrigin.y;
}
else
{
ptlOrigin.x += ulCharInc;
}
}
}
} while (bMore);
}
} while (bMoreGlyphs);
AllDone:
CP_WOFFSET(ppdev, pjBase, 0, 0);
CP_WAIT(ppdev, pjBase);
CP_ABS_WMIN(ppdev, pjBase, 0, 0);
CP_ABS_WMAX(ppdev, pjBase, MAX_COORD, MAX_COORD);
return(bRet);
}
/******************************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
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");
ASSERTDD((pco != NULL) && (pco->iDComplexity != DC_TRIVIAL),
"Expected a non-null clip object");
rbc.iSolidColor = iColor;
if (pco->iDComplexity == DC_RECT)
{
crcl = cIntersect(&pco->rclBounds, prcl, crcl);
if (crcl != 0)
{
(ppdev->pfnFillSolid)(ppdev, crcl, prcl, 0xf0f0, 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],
0xf0f0, rbc, NULL);
}
}
}
} while (bMore);
}
}
/******************************Public*Routine******************************\
* VOID vGeneralText
*
\**************************************************************************/
VOID vGeneralText(
PDEV* ppdev,
STROBJ* pstro,
CLIPOBJ* pco)
{
BYTE* pjBase;
BYTE iDComplexity;
BOOL bMoreGlyphs;
ULONG cGlyphOriginal;
ULONG cGlyph;
GLYPHPOS* pgpOriginal;
GLYPHPOS* pgp;
GLYPHBITS* pgb;
POINTL ptlOrigin;
BOOL bMore;
CLIPENUM ce;
RECTL* prclClip;
ULONG ulCharInc;
LONG cxGlyph;
LONG cyGlyph;
LONG xBias;
LONG cx;
LONG cy;
ULONG* pulGlyph;
LONG cxXfer;
LONG cBits;
LONG xLeft;
LONG yTop;
LONG xRight;
LONG yBottom;
LONG lDelta;
LONG cj;
LONG i;
BYTE* pjGlyph;
pjBase = ppdev->pjBase;
iDComplexity = (pco == NULL) ? DC_TRIVIAL : pco->iDComplexity;
do {
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);
}
if (cGlyphOriginal > 0)
{
ulCharInc = pstro->ulCharInc;
if (iDComplexity != DC_COMPLEX)
{
// 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;
ce.c = 1;
if (iDComplexity == DC_TRIVIAL)
prclClip = &grclMax;
else
prclClip = &pco->rclBounds;
goto SingleRectangle;
}
CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_ANY, 0);
do {
bMore = CLIPOBJ_bEnum(pco, sizeof(ce), (ULONG*) &ce);
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)
{
cxGlyph = pgb->sizlBitmap.cx;
cyGlyph = pgb->sizlBitmap.cy;
pulGlyph = (ULONG*) pgb->aj;
if ((prclClip->left <= ptlOrigin.x) &&
(prclClip->top <= ptlOrigin.y) &&
(prclClip->right >= ptlOrigin.x + cxGlyph) &&
(prclClip->bottom >= ptlOrigin.y + cyGlyph))
{
//-----------------------------------------------------
// Unclipped glyph
cxXfer = (cxGlyph + 7) & ~7;
cBits = (cyGlyph * cxXfer);
CP_X0(ppdev, pjBase, ptlOrigin.x);
CP_XY1(ppdev, pjBase, ptlOrigin.x, ptlOrigin.y);
CP_X2(ppdev, pjBase, ptlOrigin.x + cxXfer);
CP_WAIT(ppdev, pjBase);
CP_WRIGHT(ppdev, pjBase, ptlOrigin.x + cxGlyph - 1);
CP_START_PIXEL1(ppdev, pjBase);
while (TRUE)
{
cBits -= 32;
if (cBits <= 0)
break;
CP_PIXEL1(ppdev, pjBase, *pulGlyph);
pulGlyph++;
}
// The 'count' for CP_PIXEL1_REM must be pre-decremented by
// 1, which explains why this is '+31':
cBits += 31;
CP_PIXEL1_REM(ppdev, pjBase, cBits, *pulGlyph);
CP_END_PIXEL1(ppdev, pjBase);
}
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))
{
CP_WAIT(ppdev, pjBase);
CP_WRIGHT(ppdev, pjBase, xRight - 1);
// Make the left edge byte-aligned in the source:
xBias = (xLeft - ptlOrigin.x) & 7;
if (xBias != 0)
{
// '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 use the scissors so that the
// first 'xBias' bits of the byte will not be displayed.
//
// (What we're doing is simply aligning the monochrome
// blt using the hardware clipping.)
CP_WLEFT(ppdev, pjBase, xLeft);
xLeft -= xBias;
cx += xBias;
}
// Make the right edge byte-aligned too:
cx = (cx + 7) & ~7L;
CP_X0(ppdev, pjBase, xLeft);
CP_XY1(ppdev, pjBase, xLeft, yTop);
CP_X2(ppdev, pjBase, xLeft + cx);
CP_START_PIXEL1(ppdev, pjBase);
lDelta = (cxGlyph + 7) >> 3;
pjGlyph = (BYTE*) pulGlyph + (yTop - ptlOrigin.y) * lDelta
+ ((xLeft - ptlOrigin.x) >> 3);
cj = cx >> 3;
lDelta -= cj; // Make it into a true delta
do {
i = cj;
do {
CP_PIXEL1_REM(ppdev, pjBase, 7, *pjGlyph);
pjGlyph++;
} while (--i != 0);
pjGlyph += lDelta;
} while (--cy);
CP_END_PIXEL1(ppdev, pjBase);
if (xBias != 0)
{
CP_WAIT(ppdev, pjBase);
CP_ABS_WMIN(ppdev, pjBase, 0, 0);
}
}
}
if (--cGlyph == 0)
break;
// Get ready for next glyph:
pgp++;
pgb = pgp->pgdf->pgb;
if (ulCharInc == 0)
{
ptlOrigin.x = pgp->ptl.x + pgb->ptlOrigin.x;
ptlOrigin.y = pgp->ptl.y + pgb->ptlOrigin.y;
}
else
{
ptlOrigin.x += ulCharInc;
}
}
}
} while (bMore);
}
} while (bMoreGlyphs);
CP_WAIT(ppdev, pjBase);
CP_ABS_WMAX(ppdev, pjBase, MAX_COORD, MAX_COORD);
}
/******************************Public*Routine******************************\
* BOOL DrvTextOut
*
\**************************************************************************/
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;
BYTE* pjBase;
ULONG cGlyph;
BOOL bMoreGlyphs;
GLYPHPOS* pgp;
BYTE iDComplexity;
CACHEDFONT* pcf;
BOOL bTextPerfectFit;
pdsurf = (DSURF*) pso->dhsurf;
if (pdsurf->dt != DT_DIB)
{
poh = pdsurf->poh;
ppdev = (PDEV*) pso->dhpdev;
ppdev->xOffset = poh->x;
ppdev->yOffset = poh->y;
// 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");
pjBase = ppdev->pjBase;
iDComplexity = (pco == NULL) ? DC_TRIVIAL : pco->iDComplexity;
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))
{
if (iDComplexity == DC_TRIVIAL)
{
CP_METARECT(ppdev, pjBase, prclOpaque->left, prclOpaque->top);
CP_METARECT(ppdev, pjBase, prclOpaque->right, prclOpaque->bottom);
CP_WAIT(ppdev, pjBase);
if (P9000(ppdev))
{
CP_BACKGROUND(ppdev, pjBase, pboOpaque->iSolidColor);
CP_RASTER(ppdev, pjBase, P9000_B);
}
else
{
CP_COLOR0(ppdev, pjBase, pboOpaque->iSolidColor);
CP_RASTER(ppdev, pjBase, P9100_P);
}
CP_START_QUAD(ppdev, pjBase);
}
else
{
vClipSolid(ppdev, 1, prclOpaque, pboOpaque->iSolidColor, pco);
}
}
if (bTextPerfectFit)
{
// If we have already drawn the opaquing rectangle (because
// it was larger than the text rectangle), we could lay down
// the glyphs in 'transparent' mode. But I've found the Weitek
// to be a bit faster drawing in opaque mode, so we'll stick
// with that:
CP_WAIT(ppdev, pjBase);
if (P9000(ppdev))
{
CP_BACKGROUND(ppdev, pjBase, pboOpaque->iSolidColor);
CP_FOREGROUND(ppdev, pjBase, pboFore->iSolidColor);
CP_RASTER(ppdev, pjBase, P9000_OPAQUE_EXPAND);
}
else
{
CP_COLOR0(ppdev, pjBase, pboOpaque->iSolidColor);
CP_COLOR1(ppdev, pjBase, pboFore->iSolidColor);
CP_RASTER(ppdev, pjBase, P9100_OPAQUE_EXPAND);
}
CP_ABS_Y3(ppdev, pjBase, 1);
goto SkipTransparentInitialization;
}
}
////////////////////////////////////////////////////////////
// Transparent Initialization
////////////////////////////////////////////////////////////
// Initialize the hardware for transparent text:
CP_WAIT(ppdev, pjBase);
if (P9000(ppdev))
{
CP_FOREGROUND(ppdev, pjBase, pboFore->iSolidColor);
CP_RASTER(ppdev, pjBase, P9000_TRANSPARENT_EXPAND);
}
else
{
CP_COLOR1(ppdev, pjBase, pboFore->iSolidColor);
CP_RASTER(ppdev, pjBase, P9100_TRANSPARENT_EXPAND);
}
CP_ABS_Y3(ppdev, pjBase, 1);
SkipTransparentInitialization:
if ((pfo->cxMax <= GLYPH_CACHE_CX) &&
((pstro->rclBkGround.bottom - pstro->rclBkGround.top) <= GLYPH_CACHE_CY))
{
pcf = (CACHEDFONT*) pfo->pvConsumer;
if (pcf == NULL)
{
pcf = pcfAllocateCachedFont(ppdev);
if (pcf == NULL)
return(FALSE);
pfo->pvConsumer = pcf;
}
// Use our glyph cache:
if (iDComplexity == DC_TRIVIAL)
{
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)
{
if (!bCachedProportionalText(ppdev, pcf, pgp, cGlyph))
return(FALSE);
}
else
{
if (!bCachedFixedText(ppdev, pcf, pgp, cGlyph, pstro->ulCharInc))
return(FALSE);
}
}
} while (bMoreGlyphs);
}
else
{
if (!bCachedClippedText(ppdev, pcf, pstro, pco))
return(FALSE);
}
}
else
{
DISPDBG((5, "Text too big to cache: %li x %li",
pfo->cxMax, pstro->rclBkGround.bottom - pstro->rclBkGround.top));
vGeneralText(ppdev, pstro, pco);
}
}
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 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)
{
CACHEDFONT* pcf;
pcf = pfo->pvConsumer;
if (pcf != NULL)
{
vFreeCachedFont(pcf);
pfo->pvConsumer = NULL;
}
}
/******************************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.
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'.
}
/******************************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 we were to do off-screen glyph caching, we would probably want
// to invalidate our cache here, because it will get destroyed when
// we switch to full-screen.
}
Reference in a new issue Copy permalink