2264 lines
68 KiB
C++
2264 lines
68 KiB
C++
/**************************************************************************\
|
|
*
|
|
* Copyright (c) 1998 Microsoft Corporation
|
|
*
|
|
* Abstract:
|
|
*
|
|
* Engine text out routines.
|
|
*
|
|
* Revision History:
|
|
*
|
|
* 3/25/1999 cameronb
|
|
* Created it.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
#include "precomp.hpp"
|
|
|
|
struct GlyphScanBuf
|
|
{
|
|
INT left;
|
|
INT top;
|
|
INT bottom;
|
|
INT widthInBytes;
|
|
DpRegion::Visibility visibility;
|
|
};
|
|
|
|
const BYTE GRAYSCALE_LEVEL = 16;
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* Draws text at a position.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [IN] context - the context (matrix and clipping)
|
|
* [IN] surface - the surface to fill
|
|
* [IN] drawBounds - the surface bounds
|
|
* [IN] text - the typeset text to be drawn
|
|
* [IN] font - the font to use
|
|
* [IN] fgBrush - the brush to use for the text
|
|
* [IN] bgBrush - the brush to use for the background (default = NULL)
|
|
*
|
|
* Return Value:
|
|
*
|
|
* GpStatus - Ok or failure status
|
|
*
|
|
* Created:
|
|
*
|
|
* 3/25/1999 cameronb
|
|
*
|
|
\**************************************************************************/
|
|
|
|
GpStatus
|
|
DpDriver::DrawGlyphs
|
|
(
|
|
DrawGlyphData *drawGlyphData
|
|
)
|
|
{
|
|
GpStatus status = GenericError;
|
|
HDC hdc = NULL;
|
|
|
|
ASSERT(!drawGlyphData->glyphPathPos);
|
|
|
|
// Choose appropriate brush behaviour
|
|
|
|
switch(drawGlyphData->brush->Type)
|
|
{
|
|
case BrushTypeSolidColor:
|
|
|
|
INT angle; // Passed from GetTextOutputHdc to GdiText
|
|
|
|
if (!(drawGlyphData->flags & DG_NOGDI))
|
|
{
|
|
hdc = drawGlyphData->context->GetTextOutputHdc(
|
|
drawGlyphData->faceRealization,
|
|
drawGlyphData->brush->SolidColor,
|
|
drawGlyphData->surface,
|
|
&angle
|
|
);
|
|
}
|
|
if (hdc)
|
|
{
|
|
BOOL isClip;
|
|
BOOL usePathClipping = FALSE;
|
|
SetupClipping(hdc, drawGlyphData->context,
|
|
drawGlyphData->drawBounds, isClip,
|
|
usePathClipping, FALSE);
|
|
|
|
status = GdiText(
|
|
hdc,
|
|
angle,
|
|
drawGlyphData->glyphs,
|
|
drawGlyphData->glyphOrigins,
|
|
drawGlyphData->glyphCount,
|
|
drawGlyphData->rightToLeft
|
|
);
|
|
RestoreClipping(hdc, isClip, usePathClipping);
|
|
drawGlyphData->context->ReleaseTextOutputHdc(hdc);
|
|
}
|
|
else
|
|
{
|
|
|
|
status = SolidText(
|
|
drawGlyphData->context,
|
|
drawGlyphData->surface,
|
|
drawGlyphData->drawBounds,
|
|
drawGlyphData->brush->SolidColor,
|
|
drawGlyphData->glyphPos,
|
|
drawGlyphData->count,
|
|
drawGlyphData->faceRealization->RealizationMethod(),
|
|
drawGlyphData->rightToLeft
|
|
);
|
|
}
|
|
break;
|
|
|
|
// case BrushRectGrad:
|
|
// case BrushRadialGrad:
|
|
case BrushTypeTextureFill:
|
|
case BrushTypeHatchFill:
|
|
// case BrushTriangleGrad:
|
|
case BrushTypePathGradient:
|
|
case BrushTypeLinearGradient:
|
|
|
|
status = BrushText(
|
|
drawGlyphData->context,
|
|
drawGlyphData->surface,
|
|
drawGlyphData->drawBounds,
|
|
drawGlyphData->brush,
|
|
drawGlyphData->glyphPos,
|
|
drawGlyphData->count,
|
|
drawGlyphData->faceRealization->RealizationMethod()
|
|
);
|
|
break;
|
|
|
|
default:
|
|
status = GenericError;
|
|
break;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
static GpStatus
|
|
OutputSolidNormalText (
|
|
DpContext* context,
|
|
DpDriver *driver,
|
|
DpBitmap* surface,
|
|
const GpRect* drawBounds,
|
|
GpColor color,
|
|
const GpGlyphPos *glyphPos,
|
|
INT count
|
|
)
|
|
{
|
|
DpScanBuffer scan(
|
|
surface->Scan,
|
|
driver,
|
|
context,
|
|
surface,
|
|
(color.IsOpaque() &&
|
|
(!context->AntiAliasMode)));
|
|
|
|
if (!scan.IsValid())
|
|
{
|
|
return(GenericError);
|
|
}
|
|
|
|
FPUStateSaver fpuState;
|
|
|
|
ARGB argb = color.GetPremultipliedValue();
|
|
|
|
DpOutputSolidColorSpan outputSolid(argb, &scan);
|
|
DpClipRegion * clipRegion = NULL;
|
|
|
|
if (context->VisibleClip.GetRectVisibility(
|
|
drawBounds->X, drawBounds->Y,
|
|
drawBounds->GetRight(), drawBounds->GetBottom()) !=
|
|
DpRegion::TotallyVisible)
|
|
{
|
|
clipRegion = &(context->VisibleClip);
|
|
clipRegion->InitClipping(&outputSolid, drawBounds->Y);
|
|
}
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
INT left = glyphPos[i].GetLeft();
|
|
INT top = glyphPos[i].GetTop();
|
|
#if 0
|
|
printf("Drawing glyph at [%d,%d]\n", left, top);
|
|
#endif
|
|
INT widthInPixels = glyphPos[i].GetWidth();
|
|
INT right = left + widthInPixels;
|
|
INT height = glyphPos[i].GetHeight();
|
|
INT bottom = top + height;
|
|
|
|
INT widthInBytes = (widthInPixels + 7) / 8;
|
|
|
|
const BYTE* mask = glyphPos[i].GetBits();
|
|
|
|
if (widthInPixels == 0 || height == 0)
|
|
continue;
|
|
|
|
ASSERT(mask != NULL);
|
|
|
|
if (clipRegion != NULL)
|
|
{
|
|
// Clipping
|
|
GpRect clippedRect;
|
|
DpRegion::Visibility visibility =
|
|
clipRegion->GetRectVisibility(
|
|
left, top, right, bottom, &clippedRect
|
|
);
|
|
|
|
if (visibility == DpRegion::Invisible)
|
|
continue;
|
|
|
|
for (INT y = top, my = 0; y < bottom && my < height; y++, my++)
|
|
{
|
|
const BYTE* maskPtr = mask + my * widthInBytes;
|
|
|
|
BYTE bit = 0x80;
|
|
BYTE nextPixel = (*(maskPtr) & bit) ? 255 : 0;
|
|
|
|
INT runStart = 0;
|
|
|
|
for (INT mx = 0; mx < widthInPixels; mx++)
|
|
{
|
|
BYTE pixel = nextPixel;
|
|
|
|
bit = (bit == 0x01) ? 0x80 : bit >> 1;
|
|
nextPixel = (mx == widthInPixels - 1)
|
|
? 0
|
|
: ( (*(maskPtr + (mx + 1) / 8) & bit) ? 255 : 0);
|
|
|
|
if (pixel != nextPixel)
|
|
{
|
|
if (pixel)
|
|
{
|
|
|
|
// Draw this run
|
|
|
|
INT runLength = mx - runStart + 1;
|
|
INT from = left + runStart;
|
|
|
|
if (visibility == DpRegion::TotallyVisible)
|
|
{
|
|
|
|
// Draw the entire run
|
|
|
|
FillMemoryInt32( scan.NextBuffer(from, y, runLength),
|
|
runLength, argb);
|
|
}
|
|
else
|
|
{
|
|
|
|
// Clip the run
|
|
|
|
INT to = from + runLength; // reference needed
|
|
clipRegion->OutputSpan(y, from, to);
|
|
}
|
|
|
|
};
|
|
|
|
if (nextPixel)
|
|
{
|
|
// Start a new run
|
|
runStart = mx + 1;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// No clipping
|
|
for (INT y = top, my = 0; y < bottom && my < height; y++, my++)
|
|
{
|
|
const BYTE* maskPtr = mask + my * widthInBytes;
|
|
BYTE bit = 0x80;
|
|
|
|
INT runLength = 0;
|
|
INT runStart;
|
|
|
|
for (INT mx = 0; mx < widthInPixels; mx++)
|
|
{
|
|
BOOL pixelOn = *(maskPtr + mx / 8) & bit;
|
|
|
|
if (pixelOn)
|
|
{
|
|
if (runLength == 0)
|
|
{
|
|
// Start a new run
|
|
runStart = mx;
|
|
}
|
|
runLength++;
|
|
}
|
|
|
|
if
|
|
(
|
|
runLength > 0 && !pixelOn
|
|
||
|
|
runLength > 0 && mx == widthInPixels - 1
|
|
)
|
|
{
|
|
// Finish this run and draw it
|
|
FillMemoryInt32(
|
|
scan.NextBuffer(left + runStart, y, runLength),
|
|
runLength, argb
|
|
);
|
|
runLength = 0;
|
|
};
|
|
bit = (bit == 0x01) ? 0x80 : bit >> 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (clipRegion != NULL)
|
|
{
|
|
clipRegion->EndClipping();
|
|
}
|
|
|
|
return(Ok);
|
|
|
|
}
|
|
|
|
static inline
|
|
VOID GetGlyphDimensions(
|
|
const GpGlyphPos & glyphPos,
|
|
INT * left,
|
|
INT * top,
|
|
INT * widthInPixels,
|
|
INT * right,
|
|
INT * height,
|
|
INT * bottom
|
|
)
|
|
{
|
|
*left = glyphPos.GetLeft();
|
|
*top = glyphPos.GetTop();
|
|
*widthInPixels = glyphPos.GetWidth();
|
|
*right = *left + *widthInPixels;
|
|
*height = glyphPos.GetHeight();
|
|
*bottom = *top + *height;
|
|
} // GetGlyphDimensions
|
|
|
|
template <typename MASKTYPE>
|
|
class DpOutputOptimizedSpan : public DpOutputSpan
|
|
{
|
|
public:
|
|
typedef MASKTYPE SCANMASKTYPE;
|
|
|
|
DpOutputOptimizedSpan(DpScanBuffer * scan)
|
|
: Scan(scan)
|
|
{}
|
|
|
|
virtual BOOL IsValid() const
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
void SetMaskAndLeft(const MASKTYPE * maskPtr, INT left)
|
|
{
|
|
ASSERT(maskPtr != 0);
|
|
MaskPtr = maskPtr;
|
|
Left = left;
|
|
}
|
|
|
|
protected:
|
|
DpScanBuffer * Scan;
|
|
INT Left;
|
|
const MASKTYPE *MaskPtr;
|
|
};
|
|
|
|
template <class OUTPUT_SPAN>
|
|
static GpStatus
|
|
OutputTextOptimized(
|
|
DpContext* context,
|
|
const GpRect* drawBounds,
|
|
const GpGlyphPos *glyphPos,
|
|
INT count,
|
|
OUTPUT_SPAN & outputSpan
|
|
)
|
|
{
|
|
ASSERT(context->CompositingMode == CompositingModeSourceOver);
|
|
|
|
DpClipRegion * clipRegion = &(context->VisibleClip);
|
|
clipRegion->InitClipping(&outputSpan, drawBounds->Y);
|
|
|
|
// measure bounding box for all glyphs
|
|
INT minX = INT_MAX, maxX = INT_MIN, minY = INT_MAX, maxY = INT_MIN;
|
|
for (INT i = 0; i < count; ++i)
|
|
{
|
|
INT left, top, widthInPixels, right, height, bottom;
|
|
GetGlyphDimensions(glyphPos[i], &left, &top, &widthInPixels, &right, &height, &bottom);
|
|
|
|
if (widthInPixels == 0 ||
|
|
height == 0 ||
|
|
clipRegion->GetRectVisibility(left, top, right, bottom) ==
|
|
DpRegion::Invisible)
|
|
continue;
|
|
|
|
if (left < minX) minX = left;
|
|
if (top < minY) minY = top;
|
|
if (right > maxX) maxX = right;
|
|
if (bottom > maxY) maxY = bottom;
|
|
}
|
|
|
|
ASSERT(drawBounds->GetLeft() <= minX);
|
|
ASSERT(drawBounds->GetTop() <= minY);
|
|
ASSERT(drawBounds->GetRight() >= maxX);
|
|
ASSERT(drawBounds->GetBottom() >= maxY);
|
|
|
|
if (minX >= maxX || minY >= maxY)
|
|
return Ok;
|
|
|
|
AutoArray<OUTPUT_SPAN::SCANMASKTYPE> scanLine(new OUTPUT_SPAN::SCANMASKTYPE[maxX - minX]);
|
|
if (!scanLine)
|
|
return OutOfMemory;
|
|
|
|
outputSpan.SetMaskAndLeft(scanLine.Get(), minX);
|
|
|
|
for (INT line = minY; line < maxY; ++line)
|
|
{
|
|
GpMemset(scanLine.Get(), 0, (maxX - minX) * sizeof(OUTPUT_SPAN::SCANMASKTYPE));
|
|
|
|
for (INT i = 0; i < count; ++i)
|
|
{
|
|
INT left, top, widthInPixels, right, height, bottom;
|
|
GetGlyphDimensions(glyphPos[i], &left, &top, &widthInPixels, &right, &height, &bottom);
|
|
|
|
if (widthInPixels == 0 ||
|
|
height == 0 ||
|
|
top > line ||
|
|
line >= bottom ||
|
|
clipRegion->GetRectVisibility(left, top, right, bottom) ==
|
|
DpRegion::Invisible)
|
|
continue; // is the last check necessary? [mleonov]
|
|
|
|
// now, render glyph into the horizontal merge buffer
|
|
|
|
outputSpan.RenderGlyph(
|
|
glyphPos[i].GetBits(),
|
|
&scanLine[left-minX],
|
|
widthInPixels,
|
|
line - top
|
|
);
|
|
}
|
|
|
|
// now, clip and render scan line
|
|
clipRegion->OutputSpan(line, minX, maxX);
|
|
}
|
|
|
|
clipRegion->EndClipping();
|
|
|
|
return Ok;
|
|
} // OutputTextOptimized
|
|
|
|
class DpOutputSolidColorOptimizedSpan : public DpOutputOptimizedSpan<ARGB>
|
|
{
|
|
typedef DpOutputOptimizedSpan<ARGB> super;
|
|
|
|
public:
|
|
DpOutputSolidColorOptimizedSpan(DpScanBuffer * scan, ARGB argb)
|
|
: super(scan), Argb(argb)
|
|
{}
|
|
|
|
virtual GpStatus OutputSpan(INT y, INT xMin, INT xMax)
|
|
{
|
|
INT width = xMax - xMin;
|
|
const ARGB * maskPtr = MaskPtr + xMin - Left;
|
|
ARGB * buf = Scan->NextBuffer(xMin, y, width);
|
|
GpMemcpy(buf, maskPtr, width * sizeof(ARGB));
|
|
return Ok;
|
|
}
|
|
|
|
void RenderGlyph(const BYTE * glyphBits,
|
|
SCANMASKTYPE * dst,
|
|
INT widthInPixels,
|
|
INT y)
|
|
{
|
|
const INT widthInBytes = (widthInPixels + 7) / 8;
|
|
const BYTE * mask = glyphBits + widthInBytes * y;
|
|
|
|
for (INT pos = 0; pos < widthInPixels; ++dst, ++pos)
|
|
{
|
|
if (!*dst && (mask[pos>>3] & (0x80 >> (pos & 7))))
|
|
*dst = Argb;
|
|
}
|
|
} // RenderGlyph
|
|
|
|
protected:
|
|
const ARGB Argb;
|
|
}; // class DpOutputSolidColorOptimizedSpan
|
|
|
|
static GpStatus
|
|
OutputSolidNormalTextOptimized(
|
|
DpContext* context,
|
|
DpDriver *driver,
|
|
DpBitmap* surface,
|
|
const GpRect* drawBounds,
|
|
const GpColor & color,
|
|
const GpGlyphPos *glyphPos,
|
|
INT count
|
|
)
|
|
{
|
|
DpScanBuffer scan(surface->Scan, driver, context, surface);
|
|
|
|
if (!scan.IsValid())
|
|
return GenericError;
|
|
|
|
DpOutputSolidColorOptimizedSpan outputSolid(&scan, color.GetPremultipliedValue());
|
|
|
|
return OutputTextOptimized(context, drawBounds, glyphPos, count, outputSolid);
|
|
} // OutputSolidNormalTextOptimized
|
|
|
|
class DpOutputClearTypeOptimizedSpan : public DpOutputOptimizedSpan<BYTE>
|
|
{
|
|
typedef DpOutputOptimizedSpan<BYTE> super;
|
|
|
|
public:
|
|
DpOutputClearTypeOptimizedSpan(DpScanBuffer * scan)
|
|
: super(scan)
|
|
{}
|
|
|
|
void RenderGlyph(const BYTE * glyphBits,
|
|
SCANMASKTYPE * dst,
|
|
INT widthInPixels,
|
|
INT y)
|
|
{
|
|
const BYTE * mask = glyphBits + widthInPixels * y;
|
|
|
|
for (INT pos = 0; pos < widthInPixels; ++pos, ++dst)
|
|
{
|
|
const BYTE src = mask[pos];
|
|
ASSERT(0 <= *dst && *dst <= CT_LOOKUP - 1);
|
|
ASSERT(0 <= src && src <= CT_LOOKUP - 1);
|
|
|
|
if (*dst == 0)
|
|
{
|
|
*dst = src;
|
|
}
|
|
else if (src != 0)
|
|
{
|
|
// merge ClearType data
|
|
ULONG kR = (ULONG)Globals::gaOutTable[*dst].kR + (ULONG)Globals::gaOutTable[src].kR;
|
|
ULONG kG = (ULONG)Globals::gaOutTable[*dst].kG + (ULONG)Globals::gaOutTable[src].kG;
|
|
ULONG kB = (ULONG)Globals::gaOutTable[*dst].kB + (ULONG)Globals::gaOutTable[src].kB;
|
|
|
|
if (kR > CT_SAMPLE_F) {kR = CT_SAMPLE_F;}
|
|
if (kG > CT_SAMPLE_F) {kG = CT_SAMPLE_F;}
|
|
if (kB > CT_SAMPLE_F) {kB = CT_SAMPLE_F;}
|
|
|
|
*dst = Globals::FilteredCTLut[kB + 7 * kG + 49 * kR];
|
|
}
|
|
}
|
|
} // RenderGlyph
|
|
}; // class DpOutputClearTypeOptimizedSpan
|
|
|
|
class DpOutputClearTypeSolidOptimizedSpan : public DpOutputClearTypeOptimizedSpan
|
|
{
|
|
typedef DpOutputClearTypeOptimizedSpan super;
|
|
|
|
public:
|
|
DpOutputClearTypeSolidOptimizedSpan(DpScanBuffer * scan)
|
|
: super(scan)
|
|
{}
|
|
|
|
virtual GpStatus OutputSpan(INT y, INT xMin, INT xMax)
|
|
{
|
|
const INT width = xMax - xMin;
|
|
const BYTE * maskPtr = MaskPtr + xMin - Left;
|
|
Scan->NextBuffer(xMin, y, width);
|
|
BYTE * buf = reinterpret_cast<BYTE *>(Scan->GetCurrentCTBuffer());
|
|
for (INT i = 0; i < width; ++i)
|
|
{
|
|
ASSERT(0 <= *maskPtr && *maskPtr <= CT_LOOKUP - 1);
|
|
*buf = *maskPtr;
|
|
++buf;
|
|
++maskPtr;
|
|
}
|
|
return Ok;
|
|
}
|
|
}; // class DpOutputClearTypeSolidOptimizedSpan
|
|
|
|
class DpOutputClearTypeBrushOptimizedSpan : public DpOutputClearTypeOptimizedSpan
|
|
{
|
|
typedef DpOutputClearTypeOptimizedSpan super;
|
|
|
|
public:
|
|
DpOutputClearTypeBrushOptimizedSpan(DpScanBuffer * scan, DpOutputSpan * output)
|
|
: super(scan), Output(output)
|
|
{}
|
|
|
|
virtual GpStatus OutputSpan(INT y, INT xMin, INT xMax)
|
|
{
|
|
GpStatus status = Output->OutputSpan(y, xMin, xMax);
|
|
if (status != Ok)
|
|
return status;
|
|
|
|
const INT width = xMax - xMin;
|
|
const BYTE * maskPtr = MaskPtr + xMin - Left;
|
|
BYTE * buf = reinterpret_cast<BYTE *>(Scan->GetCurrentCTBuffer());
|
|
for (INT i = 0; i < width; ++i)
|
|
{
|
|
ASSERT(0 <= *maskPtr && *maskPtr <= CT_LOOKUP - 1);
|
|
*buf = *maskPtr;
|
|
++buf;
|
|
++maskPtr;
|
|
}
|
|
return Ok;
|
|
}
|
|
|
|
protected:
|
|
DpOutputSpan * Output;
|
|
}; // class DpOutputClearTypeBrushOptimizedSpan
|
|
|
|
static GpStatus
|
|
OutputBrushClearTypeText(
|
|
DpContext* context,
|
|
DpDriver *driver,
|
|
DpBitmap* surface,
|
|
const GpRect* drawBounds,
|
|
const DpBrush * brush,
|
|
const GpGlyphPos *glyphPos,
|
|
INT count
|
|
)
|
|
{
|
|
DpScanBuffer scan(
|
|
surface->Scan,
|
|
driver,
|
|
context,
|
|
surface,
|
|
FALSE,
|
|
EpScanTypeCT);
|
|
|
|
if (!scan.IsValid())
|
|
{
|
|
return GenericError;
|
|
}
|
|
|
|
AutoPointer<DpOutputSpan> output(DpOutputSpan::Create(brush, &scan, context));
|
|
if (!output)
|
|
return OutOfMemory;
|
|
|
|
DpOutputClearTypeBrushOptimizedSpan outputCTSpan(&scan, output.Get());
|
|
|
|
return OutputTextOptimized(context, drawBounds, glyphPos, count, outputCTSpan);
|
|
} // OutputBrushClearTypeText
|
|
|
|
static GpStatus
|
|
OutputSolidClearTypeText(
|
|
DpContext* context,
|
|
DpDriver *driver,
|
|
DpBitmap* surface,
|
|
const GpRect* drawBounds,
|
|
GpColor color,
|
|
const GpGlyphPos *glyphPos,
|
|
INT count
|
|
)
|
|
{
|
|
DpScanBuffer scan(
|
|
surface->Scan,
|
|
driver,
|
|
context,
|
|
surface,
|
|
FALSE,
|
|
EpScanTypeCTSolidFill,
|
|
PixelFormat32bppPARGB,
|
|
PixelFormat32bppPARGB,
|
|
color.GetValue());
|
|
|
|
if (!scan.IsValid())
|
|
{
|
|
return GenericError;
|
|
}
|
|
|
|
DpOutputClearTypeSolidOptimizedSpan outputCTSpan(&scan);
|
|
|
|
return OutputTextOptimized(context, drawBounds, glyphPos, count, outputCTSpan);
|
|
} // OutputSolidClearTypeText
|
|
|
|
|
|
class DpOutputAntiAliasSolidColorOptimizedSpan : public DpOutputOptimizedSpan<BYTE>
|
|
{
|
|
typedef DpOutputOptimizedSpan<BYTE> super;
|
|
|
|
public:
|
|
DpOutputAntiAliasSolidColorOptimizedSpan(DpScanBuffer * scan, const GpColor & color, ULONG gammaValue)
|
|
: super(scan)
|
|
{
|
|
TextGammaTable.CreateTextColorGammaTable(&color, gammaValue, GRAYSCALE_LEVEL);
|
|
}
|
|
|
|
virtual GpStatus OutputSpan(INT y, INT xMin, INT xMax)
|
|
{
|
|
INT width = xMax - xMin;
|
|
const BYTE * maskPtr = MaskPtr + xMin - Left;
|
|
ARGB * buf = Scan->NextBuffer(xMin, y, width);
|
|
|
|
for (ARGB * cur = buf; cur < buf + width; ++cur, ++maskPtr)
|
|
{
|
|
if (*maskPtr)
|
|
*cur = TextGammaTable.argb[*maskPtr];
|
|
else
|
|
*cur = 0;
|
|
}
|
|
return Ok;
|
|
}
|
|
protected:
|
|
TextColorGammaTable TextGammaTable;
|
|
|
|
BYTE MergeGrayscale(BYTE src, BYTE dst)
|
|
{
|
|
return max(src, dst);
|
|
|
|
/* how do we correctly merge overlapping antialiased glyphs?
|
|
we need to know if subpixels come from the same glyph
|
|
UINT res = src + dst;
|
|
if (res >= GsLevel)
|
|
return GsLevel - 1;
|
|
return (BYTE)res;
|
|
*/
|
|
} // MergeGrayscale
|
|
|
|
}; // class DpOutputAntiAliasSolidColorOptimizedSpan
|
|
|
|
class DpOutputAntiAliasSolid8BPPOptimizedSpan : public DpOutputAntiAliasSolidColorOptimizedSpan
|
|
{
|
|
typedef DpOutputAntiAliasSolidColorOptimizedSpan super;
|
|
public:
|
|
DpOutputAntiAliasSolid8BPPOptimizedSpan(DpScanBuffer * scan, const GpColor & color, ULONG gammaValue)
|
|
: super(scan, color, gammaValue)
|
|
{}
|
|
|
|
void RenderGlyph(const BYTE * glyphBits,
|
|
SCANMASKTYPE * dst,
|
|
INT widthInPixels,
|
|
INT y)
|
|
{
|
|
const BYTE * mask = glyphBits + widthInPixels * y;
|
|
|
|
for (INT pos = 0; pos < widthInPixels; ++pos, ++dst)
|
|
{
|
|
*dst = MergeGrayscale(*dst, mask[pos]);
|
|
}
|
|
} // RenderGlyph
|
|
}; // class DpOutputAntiAliasSolid8BPPOptimizedSpan
|
|
|
|
class DpOutputAntiAliasSolid4BPPOptimizedSpan : public DpOutputAntiAliasSolidColorOptimizedSpan
|
|
{
|
|
typedef DpOutputAntiAliasSolidColorOptimizedSpan super;
|
|
public:
|
|
DpOutputAntiAliasSolid4BPPOptimizedSpan(DpScanBuffer * scan, const GpColor & color, ULONG gammaValue)
|
|
: super(scan, color, gammaValue)
|
|
{}
|
|
|
|
void RenderGlyph(const BYTE * glyphBits,
|
|
SCANMASKTYPE * dst,
|
|
INT widthInPixels,
|
|
INT y)
|
|
{
|
|
const INT widthInBytes = (widthInPixels + 1) / 2;
|
|
const BYTE * mask = glyphBits + widthInBytes * y;
|
|
for (INT pos = 0; pos < widthInPixels; ++dst, ++pos)
|
|
{
|
|
BYTE value = mask[pos / 2];
|
|
value >>= 4 * ((pos + 1) & 1);
|
|
value &= 0x0F;
|
|
*dst = MergeGrayscale(*dst, value);
|
|
}
|
|
} // RenderGlyph
|
|
}; // class DpOutputAntiAliasSolid4BPPOptimizedSpan
|
|
|
|
static GpStatus
|
|
OutputSolidAntiAliasText8BPPOptimized(
|
|
DpContext* context,
|
|
DpDriver * driver,
|
|
DpBitmap* surface,
|
|
const GpRect* drawBounds,
|
|
GpColor color,
|
|
const GpGlyphPos *glyphPos,
|
|
INT count
|
|
)
|
|
{
|
|
DpScanBuffer scan(surface->Scan, driver, context, surface);
|
|
|
|
if (!scan.IsValid())
|
|
return GenericError;
|
|
|
|
DpOutputAntiAliasSolid8BPPOptimizedSpan outputAASolid(&scan, color, context->TextContrast);
|
|
|
|
return OutputTextOptimized(context, drawBounds, glyphPos, count, outputAASolid);
|
|
} // OutputSolidAntiAliasText8BPPOptimized
|
|
|
|
static GpStatus
|
|
OutputSolidAntiAliasText4BPPOptimized(
|
|
DpContext* context,
|
|
DpDriver * driver,
|
|
DpBitmap* surface,
|
|
const GpRect* drawBounds,
|
|
GpColor color,
|
|
const GpGlyphPos *glyphPos,
|
|
INT count
|
|
)
|
|
{
|
|
DpScanBuffer scan(surface->Scan, driver, context, surface);
|
|
|
|
if (!scan.IsValid())
|
|
return GenericError;
|
|
|
|
DpOutputAntiAliasSolid4BPPOptimizedSpan outputAASolid(&scan, color, context->TextContrast);
|
|
return OutputTextOptimized(context, drawBounds, glyphPos, count, outputAASolid);
|
|
} // OutputSolidAntiAliasText4BPPOptimized
|
|
|
|
static GpStatus
|
|
OutputSolidAntiAliasText8BPP (
|
|
DpContext* context,
|
|
DpDriver * driver,
|
|
DpBitmap* surface,
|
|
const GpRect* drawBounds,
|
|
GpColor color,
|
|
const GpGlyphPos *glyphPos,
|
|
INT count
|
|
)
|
|
{
|
|
INT i;
|
|
|
|
DpScanBuffer scan(
|
|
surface->Scan,
|
|
driver,
|
|
context,
|
|
surface,
|
|
FALSE);
|
|
|
|
if (!scan.IsValid())
|
|
{
|
|
return(GenericError);
|
|
}
|
|
|
|
FPUStateSaver fpuState;
|
|
|
|
DpOutputAntiAliasSolidColorSpan outputAASolid(color, &scan, context->TextContrast, GRAYSCALE_LEVEL);
|
|
DpClipRegion * clipRegion = NULL;
|
|
|
|
if (context->VisibleClip.GetRectVisibility(
|
|
drawBounds->X, drawBounds->Y,
|
|
drawBounds->GetRight(), drawBounds->GetBottom()) !=
|
|
DpRegion::TotallyVisible)
|
|
{
|
|
clipRegion = &(context->VisibleClip);
|
|
clipRegion->InitClipping(&outputAASolid, drawBounds->Y);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
INT left = glyphPos[i].GetLeft();
|
|
INT top = glyphPos[i].GetTop();
|
|
INT widthInPixels = glyphPos[i].GetWidth();
|
|
INT right = left + widthInPixels;
|
|
INT height = glyphPos[i].GetHeight();
|
|
INT bottom = top + height;
|
|
|
|
if (widthInPixels == 0 || height == 0)
|
|
continue;
|
|
|
|
INT widthInBytes = widthInPixels;
|
|
|
|
const BYTE* mask = glyphPos[i].GetBits();
|
|
|
|
ASSERT(mask != NULL);
|
|
|
|
if (clipRegion != NULL)
|
|
{
|
|
// Clipping
|
|
GpRect clippedRect;
|
|
DpRegion::Visibility visibility =
|
|
clipRegion->GetRectVisibility(
|
|
left, top, right, bottom, &clippedRect
|
|
);
|
|
|
|
if (visibility == DpRegion::Invisible)
|
|
continue;
|
|
|
|
for (INT y = top, my = 0; y < bottom && my < height; y++, my++)
|
|
{
|
|
const BYTE* maskPtr = mask + my * widthInBytes;
|
|
|
|
BYTE grayscaleValue = *maskPtr;
|
|
|
|
INT runStart = 0;
|
|
|
|
for (INT mx = 0; mx <= widthInPixels; mx++)
|
|
{
|
|
BYTE nextgrayscaleValue;
|
|
|
|
if (mx == widthInPixels)
|
|
{
|
|
nextgrayscaleValue = 0;
|
|
}
|
|
else
|
|
{
|
|
nextgrayscaleValue = *maskPtr;
|
|
maskPtr++;
|
|
}
|
|
|
|
if (grayscaleValue != nextgrayscaleValue)
|
|
{
|
|
|
|
if (grayscaleValue != 0)
|
|
{
|
|
|
|
// Draw this run
|
|
|
|
INT runLength = mx - runStart;
|
|
INT from = left + runStart;
|
|
|
|
if (visibility == DpRegion::TotallyVisible)
|
|
{
|
|
|
|
// Draw the entire run
|
|
FillMemoryInt32( scan.NextBuffer(from, y, runLength), runLength,
|
|
outputAASolid.GetAASolidColor((ULONG) grayscaleValue));
|
|
}
|
|
else
|
|
{
|
|
|
|
// Clip the run
|
|
|
|
INT to = from + runLength; // reference needed
|
|
outputAASolid.GetAASolidColor((ULONG) grayscaleValue);
|
|
|
|
clipRegion->OutputSpan(y, from, to);
|
|
}
|
|
|
|
// Start a new run
|
|
runStart = mx;
|
|
grayscaleValue = nextgrayscaleValue;
|
|
}
|
|
else
|
|
{
|
|
// Start a new run
|
|
runStart = mx;
|
|
grayscaleValue = nextgrayscaleValue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ARGB * buf;
|
|
// No clipping
|
|
for (INT y = top, my = 0; y < bottom && my < height; y++, my++)
|
|
{
|
|
// Get the first byte in the scan line
|
|
const BYTE* maskPtr = mask + my * widthInBytes;
|
|
|
|
buf = scan.NextBuffer(left, y, widthInPixels);
|
|
|
|
for (INT mx = 0; mx < widthInPixels; mx++)
|
|
{
|
|
*buf++ = outputAASolid.GetAASolidColor((ULONG) *maskPtr);
|
|
maskPtr++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (clipRegion != NULL)
|
|
{
|
|
clipRegion->EndClipping();
|
|
}
|
|
|
|
return(Ok);
|
|
|
|
}
|
|
|
|
static GpStatus
|
|
OutputSolidAntiAliasText4BPP (
|
|
DpContext* context,
|
|
DpDriver * driver,
|
|
DpBitmap* surface,
|
|
const GpRect* drawBounds,
|
|
GpColor color,
|
|
const GpGlyphPos *glyphPos,
|
|
INT count
|
|
)
|
|
{
|
|
INT i;
|
|
|
|
DpScanBuffer scan(
|
|
surface->Scan,
|
|
driver,
|
|
context,
|
|
surface,
|
|
FALSE);
|
|
|
|
if (!scan.IsValid())
|
|
{
|
|
return(GenericError);
|
|
}
|
|
|
|
FPUStateSaver fpuState;
|
|
|
|
DpOutputAntiAliasSolidColorSpan outputAASolid(color, &scan, context->TextContrast, GRAYSCALE_LEVEL);
|
|
DpClipRegion * clipRegion = NULL;
|
|
|
|
if (context->VisibleClip.GetRectVisibility(
|
|
drawBounds->X, drawBounds->Y,
|
|
drawBounds->GetRight(), drawBounds->GetBottom()) !=
|
|
DpRegion::TotallyVisible)
|
|
{
|
|
clipRegion = &(context->VisibleClip);
|
|
clipRegion->InitClipping(&outputAASolid, drawBounds->Y);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
INT left = glyphPos[i].GetLeft();
|
|
INT top = glyphPos[i].GetTop();
|
|
INT widthInPixels = glyphPos[i].GetWidth();
|
|
INT right = left + widthInPixels;
|
|
INT height = glyphPos[i].GetHeight();
|
|
INT bottom = top + height;
|
|
|
|
if (widthInPixels == 0 || height == 0)
|
|
continue;
|
|
|
|
INT widthInBytes = ((widthInPixels + 1) / 2);
|
|
|
|
const BYTE* mask = glyphPos[i].GetBits();
|
|
|
|
ASSERT(mask != NULL);
|
|
|
|
if (clipRegion != NULL)
|
|
{
|
|
// Clipping
|
|
GpRect clippedRect;
|
|
DpRegion::Visibility visibility =
|
|
clipRegion->GetRectVisibility(
|
|
left, top, right, bottom, &clippedRect
|
|
);
|
|
|
|
if (visibility == DpRegion::Invisible)
|
|
continue;
|
|
|
|
for (INT y = top, my = 0; y < bottom && my < height; y++, my++)
|
|
{
|
|
const BYTE* maskPtr = mask + my * widthInBytes;
|
|
|
|
BYTE grayscaleValue = *maskPtr >> 4;
|
|
|
|
INT runStart = 0;
|
|
|
|
for (INT mx = 0; mx <= widthInPixels; mx++)
|
|
{
|
|
BYTE nextgrayscaleValue;
|
|
|
|
if (mx == widthInPixels)
|
|
{
|
|
nextgrayscaleValue = 0;
|
|
}
|
|
else
|
|
{
|
|
if (mx % 2)
|
|
{
|
|
nextgrayscaleValue = *maskPtr & 0x0F;
|
|
maskPtr++;
|
|
}
|
|
else
|
|
{
|
|
nextgrayscaleValue = *maskPtr >> 4;
|
|
}
|
|
}
|
|
|
|
if (grayscaleValue != nextgrayscaleValue)
|
|
{
|
|
|
|
if (grayscaleValue != 0)
|
|
{
|
|
|
|
// Draw this run
|
|
|
|
INT runLength = mx - runStart;
|
|
INT from = left + runStart;
|
|
|
|
if (visibility == DpRegion::TotallyVisible)
|
|
{
|
|
|
|
// Draw the entire run
|
|
FillMemoryInt32( scan.NextBuffer(from, y, runLength), runLength,
|
|
outputAASolid.GetAASolidColor((ULONG) grayscaleValue));
|
|
}
|
|
else
|
|
{
|
|
|
|
// Clip the run
|
|
|
|
INT to = from + runLength; // reference needed
|
|
outputAASolid.GetAASolidColor((ULONG) grayscaleValue);
|
|
|
|
clipRegion->OutputSpan(y, from, to);
|
|
}
|
|
|
|
// Start a new run
|
|
runStart = mx;
|
|
grayscaleValue = nextgrayscaleValue;
|
|
}
|
|
else
|
|
{
|
|
// Start a new run
|
|
runStart = mx;
|
|
grayscaleValue = nextgrayscaleValue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ARGB * buf;
|
|
// No clipping
|
|
for (INT y = top, my = 0; y < bottom && my < height; y++, my++)
|
|
{
|
|
// Get the first byte in the scan line
|
|
const BYTE* maskPtr = mask + my * widthInBytes;
|
|
|
|
buf = scan.NextBuffer(left, y, widthInPixels);
|
|
|
|
for (INT mx = 0; mx < widthInPixels; mx++)
|
|
{
|
|
if (!(mx % 2))
|
|
*buf++ = outputAASolid.GetAASolidColor((ULONG) (*maskPtr >> 4));
|
|
else
|
|
{
|
|
*buf++ = outputAASolid.GetAASolidColor((ULONG) (*maskPtr & 0x0F));
|
|
maskPtr++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (clipRegion != NULL)
|
|
{
|
|
clipRegion->EndClipping();
|
|
}
|
|
|
|
return(Ok);
|
|
|
|
}
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* Engine version of routine to draw solid text.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [IN] - DDI parameters.
|
|
*
|
|
* Return Value:
|
|
*
|
|
* TRUE if successful.
|
|
*
|
|
* History:
|
|
*
|
|
* 4/4/1999 cameronb
|
|
* Created it.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
GpStatus
|
|
DpDriver::SolidText(
|
|
DpContext* context,
|
|
DpBitmap* surface,
|
|
const GpRect* drawBounds,
|
|
GpColor color,
|
|
const GpGlyphPos *glyphPos,
|
|
INT count,
|
|
TextRenderingHint textMode,
|
|
BOOL rightToLeft
|
|
)
|
|
{
|
|
ASSERT (textMode != TextRenderingHintSystemDefault);
|
|
switch(textMode)
|
|
{
|
|
case TextRenderingHintSingleBitPerPixelGridFit:
|
|
case TextRenderingHintSingleBitPerPixel:
|
|
if (context->CompositingMode == CompositingModeSourceCopy)
|
|
return OutputSolidNormalText(context, this, surface, drawBounds, color, glyphPos, count);
|
|
// we are allowed to output transparent pixels
|
|
// version with minimized number of scan records
|
|
return OutputSolidNormalTextOptimized(context, this, surface, drawBounds, color, glyphPos, count);
|
|
|
|
case TextRenderingHintAntiAlias:
|
|
if (context->CompositingMode == CompositingModeSourceCopy)
|
|
return OutputSolidAntiAliasText8BPP(context, this, surface, drawBounds, color, glyphPos, count);
|
|
return OutputSolidAntiAliasText8BPPOptimized(context, this, surface, drawBounds, color, glyphPos, count);
|
|
case TextRenderingHintAntiAliasGridFit:
|
|
if (context->CompositingMode == CompositingModeSourceCopy)
|
|
return OutputSolidAntiAliasText4BPP(context, this, surface, drawBounds, color, glyphPos, count);
|
|
|
|
return OutputSolidAntiAliasText4BPPOptimized(context, this, surface, drawBounds, color, glyphPos, count);
|
|
|
|
case TextRenderingHintClearTypeGridFit:
|
|
return OutputSolidClearTypeText(context, this, surface, drawBounds, color, glyphPos, count);
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return Ok;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* Engine version of routine to draw text based on a brush.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [IN] - DDI parameters.
|
|
*
|
|
* Return Value:
|
|
*
|
|
* TRUE if successful.
|
|
*
|
|
* History:
|
|
* 5-1-2000 YungT rewrite it.
|
|
* 2/7/2000 YungT modify it.
|
|
* 4/14/1999 cameronb
|
|
* Created it.
|
|
*
|
|
\**************************************************************************/
|
|
static GpStatus
|
|
OutputBrushNormalText(
|
|
DpContext* context,
|
|
DpDriver * driver,
|
|
DpBitmap* surface,
|
|
const GpRect* drawBounds,
|
|
const DpBrush* brush,
|
|
const GpGlyphPos* glyphPos,
|
|
INT count
|
|
)
|
|
{
|
|
DpScanBuffer scan(
|
|
surface->Scan,
|
|
driver,
|
|
context,
|
|
surface,
|
|
FALSE); // (color64.IsOpaque() &&
|
|
// (!context->AntiAliasMode)));
|
|
// !!! If you fix this, you'll get a perf improvement for
|
|
// text that has no transparency.
|
|
|
|
if (!scan.IsValid())
|
|
{
|
|
return(GenericError);
|
|
}
|
|
|
|
FPUStateSaver fpuState;
|
|
|
|
DpOutputSpan* output = DpOutputSpan::Create(brush, &scan, context);
|
|
|
|
if (output != NULL)
|
|
{
|
|
|
|
INT i;
|
|
INT my;
|
|
GlyphScanBuf glyphScanBuf[256], *pglyphScanBuf;
|
|
DpClipRegion* clipRegion = NULL;
|
|
|
|
INT topY = drawBounds->Y;
|
|
INT bottomY = drawBounds->GetBottom();
|
|
|
|
// Allocate enough space for glyph scan buffer
|
|
if (count < 256)
|
|
{
|
|
pglyphScanBuf = &glyphScanBuf[0];
|
|
}
|
|
else
|
|
{
|
|
pglyphScanBuf = (GlyphScanBuf *) GpMalloc(count * sizeof(GlyphScanBuf));
|
|
|
|
if (!pglyphScanBuf)
|
|
return (OutOfMemory);
|
|
}
|
|
|
|
if (context->VisibleClip.GetRectVisibility(drawBounds->X, topY, drawBounds->GetRight(),
|
|
bottomY) != DpRegion::TotallyVisible)
|
|
{
|
|
clipRegion = &(context->VisibleClip);
|
|
clipRegion->InitClipping(output, drawBounds->Y);
|
|
}
|
|
|
|
|
|
// Scan evrey Glyph and get the Visibility
|
|
// Also we cache some data we will need to for later computation
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
GpRect clippedRect;
|
|
pglyphScanBuf[i].left = glyphPos[i].GetLeft();
|
|
pglyphScanBuf[i].top = glyphPos[i].GetTop();
|
|
pglyphScanBuf[i].widthInBytes = (glyphPos[i].GetWidth() + 7) / 8;
|
|
pglyphScanBuf[i].bottom = pglyphScanBuf[i].top + glyphPos[i].GetHeight();
|
|
|
|
// Set the glyph as invisible if it is empty.
|
|
if (glyphPos[i].GetWidth() == 0 || glyphPos[i].GetHeight() == 0)
|
|
pglyphScanBuf[i].visibility = DpRegion::Invisible;
|
|
else if (clipRegion != NULL)
|
|
pglyphScanBuf[i].visibility = clipRegion->GetRectVisibility(pglyphScanBuf[i].left,
|
|
pglyphScanBuf[i].top,
|
|
pglyphScanBuf[i].left + glyphPos[i].GetWidth(),
|
|
pglyphScanBuf[i].bottom, &clippedRect);
|
|
else
|
|
pglyphScanBuf[i].visibility = DpRegion::TotallyVisible;
|
|
|
|
}
|
|
|
|
// Start to scan from top of bounding box to bottom
|
|
for (int y = topY; y < bottomY; y++)
|
|
{
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
const BYTE* maskPtr;
|
|
|
|
INT runLength, runStart;
|
|
INT from, to;
|
|
|
|
BYTE thisBit;
|
|
BYTE nextPixel;
|
|
BYTE pixel;
|
|
|
|
// Invisible glyph
|
|
if (pglyphScanBuf[i].visibility == DpRegion::Invisible)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// check the scan line with y.top and y.bottom
|
|
if (y < pglyphScanBuf[i].top || y >= pglyphScanBuf[i].bottom)
|
|
continue;
|
|
|
|
if (pglyphScanBuf[i].visibility != DpRegion::TotallyVisible)
|
|
{
|
|
// Get the relateive y-scan line for each glyph
|
|
my = y - pglyphScanBuf[i].top;
|
|
|
|
// Get the address of glyph bits
|
|
maskPtr = glyphPos[i].GetBits();
|
|
|
|
ASSERT(maskPtr != NULL);
|
|
|
|
maskPtr += my * pglyphScanBuf[i].widthInBytes;
|
|
|
|
thisBit = 0x80;
|
|
nextPixel = (*(maskPtr) & thisBit) ? 255 : 0;
|
|
|
|
runStart = 0;
|
|
|
|
for (INT mx = 0; mx < glyphPos[i].GetWidth(); mx++)
|
|
{
|
|
pixel = nextPixel;
|
|
thisBit = (thisBit == 0x01) ? 0x80 : thisBit >> 1;
|
|
nextPixel = (mx == glyphPos[i].GetWidth() - 1) ? 0 : ( (*(maskPtr + (mx + 1) / 8) & thisBit) ? 255 : 0);
|
|
|
|
if (pixel != nextPixel)
|
|
{
|
|
if (pixel)
|
|
{
|
|
// Draw this run
|
|
runLength = mx - runStart + 1;
|
|
|
|
// Clip the run
|
|
from = pglyphScanBuf[i].left + runStart;
|
|
to = from + runLength;
|
|
|
|
clipRegion->OutputSpan(y, from, to);
|
|
}
|
|
|
|
if (nextPixel)
|
|
{
|
|
// Start a new run
|
|
runStart = mx + 1;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
my = y - pglyphScanBuf[i].top;
|
|
|
|
maskPtr = glyphPos[i].GetBits();
|
|
|
|
ASSERT(maskPtr != NULL);
|
|
|
|
maskPtr += my * pglyphScanBuf[i].widthInBytes;
|
|
|
|
thisBit = 0x80;
|
|
|
|
runLength = 0;
|
|
|
|
for (INT mx = 0; mx < glyphPos[i].GetWidth(); mx++)
|
|
{
|
|
BOOL pixelOn = *(maskPtr + mx / 8) & thisBit;
|
|
|
|
if (pixelOn)
|
|
{
|
|
if (runLength == 0)
|
|
{
|
|
// Start a new run
|
|
runStart = mx;
|
|
}
|
|
|
|
runLength++;
|
|
}
|
|
|
|
if (runLength > 0 && !pixelOn || runLength > 0 && mx == glyphPos[i].GetWidth() - 1)
|
|
{
|
|
// Finish this run and draw it
|
|
from = pglyphScanBuf[i].left + runStart;
|
|
to = from + runLength;
|
|
output->OutputSpan(y, from, to);
|
|
runLength = 0;
|
|
};
|
|
|
|
thisBit = (thisBit == 0x01) ? 0x80 : thisBit >> 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
} // next scan line
|
|
|
|
if (clipRegion != NULL)
|
|
{
|
|
clipRegion->EndClipping();
|
|
}
|
|
|
|
delete output;
|
|
|
|
if (pglyphScanBuf != &glyphScanBuf[0])
|
|
GpFree(pglyphScanBuf);
|
|
|
|
}
|
|
|
|
return(Ok);
|
|
}
|
|
|
|
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* Antialias version of routine to draw text based on a brush.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [IN] - same as DDI parameters.
|
|
*
|
|
* Return Value:
|
|
*
|
|
* Ok if successful.
|
|
*
|
|
* History:
|
|
*
|
|
* 2/20/00 YungT
|
|
* Created it.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
static GpStatus
|
|
OutputBrushAntiAliasText8BPP(
|
|
DpContext* context,
|
|
DpDriver * driver,
|
|
DpBitmap* surface,
|
|
const GpRect* drawBounds,
|
|
const DpBrush* brush,
|
|
const GpGlyphPos* glyphPos,
|
|
INT count
|
|
)
|
|
{
|
|
DpScanBuffer scan(
|
|
surface->Scan,
|
|
driver,
|
|
context,
|
|
surface,
|
|
FALSE); // (color64.IsOpaque() &&
|
|
// (!context->AntiAliasMode)));
|
|
// !!! If you fix this, you'll get a perf improvement for
|
|
// text that has no transparency.
|
|
|
|
if (!scan.IsValid())
|
|
{
|
|
return(GenericError);
|
|
}
|
|
|
|
DpOutputSpan* output = DpOutputSpan::Create(brush, &scan, context);
|
|
|
|
DpOutputAntiAliasBrushOutputSpan aaBrushSpan;
|
|
|
|
if (output != NULL)
|
|
{
|
|
INT i;
|
|
|
|
TextColorGammaTable textContrastTable;
|
|
textContrastTable.CreateTextColorGammaTable((GpColor *) NULL, context->TextContrast, GRAYSCALE_LEVEL);
|
|
|
|
DpClipRegion* clipRegion = NULL;
|
|
|
|
if (context->VisibleClip.GetRectVisibility( drawBounds->X, drawBounds->Y,
|
|
drawBounds->GetRight(), drawBounds->GetBottom()) !=
|
|
DpRegion::TotallyVisible)
|
|
{
|
|
aaBrushSpan.Init(output);
|
|
|
|
clipRegion = &(context->VisibleClip);
|
|
clipRegion->InitClipping(&aaBrushSpan, drawBounds->Y);
|
|
}
|
|
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
INT left = glyphPos[i].GetLeft();
|
|
INT top = glyphPos[i].GetTop();
|
|
INT widthInPixels = glyphPos[i].GetWidth();
|
|
INT right = left + widthInPixels;
|
|
INT height = glyphPos[i].GetHeight();
|
|
INT bottom = top + height;
|
|
|
|
if (widthInPixels == 0 || height == 0)
|
|
continue;
|
|
|
|
INT widthInBytes = widthInPixels;
|
|
|
|
const BYTE* mask = glyphPos[i].GetBits();
|
|
|
|
ASSERT(mask != NULL);
|
|
|
|
if (clipRegion != NULL)
|
|
{
|
|
GpRect clippedRect;
|
|
DpRegion::Visibility visibility =
|
|
clipRegion->GetRectVisibility(left, top, right, bottom, &clippedRect);
|
|
|
|
if (visibility == DpRegion::Invisible)
|
|
continue;
|
|
|
|
for (INT y = top, my = 0; y < bottom && my < height; y++, my++)
|
|
{
|
|
const BYTE* maskPtr = mask + my * widthInBytes;
|
|
|
|
BYTE grayscaleValue = *maskPtr;
|
|
|
|
INT runStart = 0;
|
|
|
|
for (INT mx = 0; mx <= widthInPixels; mx++)
|
|
{
|
|
BYTE nextgrayscaleValue;
|
|
|
|
if (mx == widthInPixels)
|
|
{
|
|
nextgrayscaleValue = 0;
|
|
}
|
|
else
|
|
{
|
|
nextgrayscaleValue = *maskPtr;
|
|
maskPtr++;
|
|
}
|
|
|
|
if (grayscaleValue != nextgrayscaleValue)
|
|
{
|
|
|
|
if (grayscaleValue != 0)
|
|
{
|
|
|
|
// Draw this run
|
|
|
|
INT runLength = mx - runStart;
|
|
INT from = left + runStart;
|
|
|
|
if (visibility == DpRegion::TotallyVisible)
|
|
{
|
|
|
|
// Clip the run
|
|
INT to = from + runLength; // reference needed
|
|
output->OutputSpan(y, from, to);
|
|
|
|
ARGB *buffer;
|
|
buffer = output->GetScanBuffer()->GetCurrentBuffer();
|
|
|
|
for (INT j = from; j < to; j++)
|
|
{
|
|
*buffer++ = GpColor::MultiplyCoverage(*buffer,
|
|
textContrastTable.GetGammaTableIndexValue(grayscaleValue, GRAYSCALE_LEVEL));
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
// Clip the run
|
|
|
|
INT to = from + runLength; // reference needed
|
|
aaBrushSpan.SetCoverage(textContrastTable.GetGammaTableIndexValue(grayscaleValue, GRAYSCALE_LEVEL));
|
|
|
|
clipRegion->OutputSpan(y, from, to);
|
|
}
|
|
|
|
// Start a new run
|
|
runStart = mx;
|
|
grayscaleValue = nextgrayscaleValue;
|
|
}
|
|
else
|
|
{
|
|
// Start a new run
|
|
runStart = mx;
|
|
grayscaleValue = nextgrayscaleValue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
|
|
for (INT y = top, my = 0; y < bottom && my < height; y++, my++)
|
|
{
|
|
const BYTE* maskPtr = mask + my * widthInBytes;
|
|
|
|
BYTE grayscaleValue = *maskPtr;
|
|
|
|
INT runStart = 0;
|
|
|
|
for (INT mx = 0; mx <= widthInPixels; mx++)
|
|
{
|
|
BYTE nextgrayscaleValue;
|
|
|
|
if (mx == widthInPixels)
|
|
{
|
|
nextgrayscaleValue = 0;
|
|
}
|
|
else
|
|
{
|
|
nextgrayscaleValue = *maskPtr;
|
|
maskPtr++;
|
|
}
|
|
|
|
if (grayscaleValue != nextgrayscaleValue)
|
|
{
|
|
|
|
if (grayscaleValue != 0)
|
|
{
|
|
// Draw this run
|
|
|
|
INT runLength = mx - runStart;
|
|
INT from = left + runStart;
|
|
|
|
|
|
// Clip the run
|
|
INT to = from + runLength; // reference needed
|
|
|
|
output->OutputSpan(y, from, to);
|
|
ARGB *buffer;
|
|
buffer = output->GetScanBuffer()->GetCurrentBuffer();
|
|
for (INT j = from; j < to; j++)
|
|
{
|
|
*buffer++ = GpColor::MultiplyCoverage(*buffer,
|
|
textContrastTable.GetGammaTableIndexValue(grayscaleValue, GRAYSCALE_LEVEL));
|
|
}
|
|
|
|
// Start a new run
|
|
runStart = mx;
|
|
grayscaleValue = nextgrayscaleValue;
|
|
}
|
|
else
|
|
{
|
|
// Start a new run
|
|
runStart = mx;
|
|
grayscaleValue = nextgrayscaleValue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (clipRegion != NULL)
|
|
{
|
|
clipRegion->EndClipping();
|
|
}
|
|
|
|
delete output;
|
|
}
|
|
|
|
return(Ok);
|
|
}
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* Antialias version of routine to draw text based on a brush.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [IN] - same as DDI parameters.
|
|
*
|
|
* Return Value:
|
|
*
|
|
* Ok if successful.
|
|
*
|
|
* History:
|
|
*
|
|
* 1/28/00 YungT
|
|
* Created it.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
static GpStatus
|
|
OutputBrushAntiAliasText4BPP(
|
|
DpContext* context,
|
|
DpDriver * driver,
|
|
DpBitmap* surface,
|
|
const GpRect* drawBounds,
|
|
const DpBrush* brush,
|
|
const GpGlyphPos* glyphPos,
|
|
INT count
|
|
)
|
|
{
|
|
DpScanBuffer scan(
|
|
surface->Scan,
|
|
driver,
|
|
context,
|
|
surface,
|
|
FALSE); // (color64.IsOpaque() &&
|
|
// (!context->AntiAliasMode)));
|
|
// !!! If you fix this, you'll get a perf improvement for
|
|
// text that has no transparency.
|
|
|
|
if (!scan.IsValid())
|
|
{
|
|
return(GenericError);
|
|
}
|
|
|
|
DpOutputSpan* output = DpOutputSpan::Create(brush, &scan, context);
|
|
|
|
DpOutputAntiAliasBrushOutputSpan aaBrushSpan;
|
|
|
|
if (output != NULL)
|
|
{
|
|
INT i;
|
|
|
|
TextColorGammaTable textContrastTable;
|
|
textContrastTable.CreateTextColorGammaTable((GpColor *) NULL, context->TextContrast, GRAYSCALE_LEVEL);
|
|
|
|
DpClipRegion* clipRegion = NULL;
|
|
|
|
if (context->VisibleClip.GetRectVisibility( drawBounds->X, drawBounds->Y,
|
|
drawBounds->GetRight(), drawBounds->GetBottom()) !=
|
|
DpRegion::TotallyVisible)
|
|
{
|
|
aaBrushSpan.Init(output);
|
|
|
|
clipRegion = &(context->VisibleClip);
|
|
clipRegion->InitClipping(&aaBrushSpan, drawBounds->Y);
|
|
}
|
|
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
INT left = glyphPos[i].GetLeft();
|
|
INT top = glyphPos[i].GetTop();
|
|
INT widthInPixels = glyphPos[i].GetWidth();
|
|
INT right = left + widthInPixels;
|
|
INT height = glyphPos[i].GetHeight();
|
|
INT bottom = top + height;
|
|
|
|
if (widthInPixels == 0 || height == 0)
|
|
continue;
|
|
|
|
INT widthInBytes = ((widthInPixels + 1) / 2);
|
|
|
|
const BYTE* mask = glyphPos[i].GetBits();
|
|
|
|
ASSERT(mask != NULL);
|
|
|
|
if (clipRegion != NULL)
|
|
{
|
|
GpRect clippedRect;
|
|
DpRegion::Visibility visibility =
|
|
clipRegion->GetRectVisibility(left, top, right, bottom, &clippedRect);
|
|
|
|
if (visibility == DpRegion::Invisible)
|
|
continue;
|
|
|
|
for (INT y = top, my = 0; y < bottom && my < height; y++, my++)
|
|
{
|
|
const BYTE* maskPtr = mask + my * widthInBytes;
|
|
|
|
BYTE grayscaleValue = *maskPtr >> 4;
|
|
|
|
INT runStart = 0;
|
|
|
|
for (INT mx = 0; mx <= widthInPixels; mx++)
|
|
{
|
|
BYTE nextgrayscaleValue;
|
|
|
|
if (mx == widthInPixels)
|
|
{
|
|
nextgrayscaleValue = 0;
|
|
}
|
|
else
|
|
{
|
|
if (mx % 2)
|
|
{
|
|
nextgrayscaleValue = *maskPtr & 0x0F;
|
|
maskPtr++;
|
|
}
|
|
else
|
|
{
|
|
nextgrayscaleValue = *maskPtr >> 4;
|
|
}
|
|
}
|
|
|
|
if (grayscaleValue != nextgrayscaleValue)
|
|
{
|
|
|
|
if (grayscaleValue != 0)
|
|
{
|
|
|
|
// Draw this run
|
|
|
|
INT runLength = mx - runStart;
|
|
INT from = left + runStart;
|
|
|
|
if (visibility == DpRegion::TotallyVisible)
|
|
{
|
|
|
|
// Clip the run
|
|
INT to = from + runLength; // reference needed
|
|
output->OutputSpan(y, from, to);
|
|
|
|
ARGB *buffer;
|
|
buffer = output->GetScanBuffer()->GetCurrentBuffer();
|
|
|
|
for (INT j = from; j < to; j++)
|
|
{
|
|
*buffer++ = GpColor::MultiplyCoverage(*buffer,
|
|
textContrastTable.GetGammaTableIndexValue(grayscaleValue, GRAYSCALE_LEVEL));
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
// Clip the run
|
|
|
|
INT to = from + runLength; // reference needed
|
|
aaBrushSpan.SetCoverage(textContrastTable.GetGammaTableIndexValue(grayscaleValue, GRAYSCALE_LEVEL));
|
|
|
|
clipRegion->OutputSpan(y, from, to);
|
|
}
|
|
|
|
// Start a new run
|
|
runStart = mx;
|
|
grayscaleValue = nextgrayscaleValue;
|
|
}
|
|
else
|
|
{
|
|
// Start a new run
|
|
runStart = mx;
|
|
grayscaleValue = nextgrayscaleValue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
|
|
for (INT y = top, my = 0; y < bottom && my < height; y++, my++)
|
|
{
|
|
const BYTE* maskPtr = mask + my * widthInBytes;
|
|
|
|
BYTE grayscaleValue = *maskPtr >> 4;
|
|
|
|
INT runStart = 0;
|
|
|
|
for (INT mx = 0; mx <= widthInPixels; mx++)
|
|
{
|
|
BYTE nextgrayscaleValue;
|
|
|
|
if (mx == widthInPixels)
|
|
{
|
|
nextgrayscaleValue = 0;
|
|
}
|
|
else
|
|
{
|
|
if (mx % 2)
|
|
{
|
|
nextgrayscaleValue = *maskPtr & 0x0F;
|
|
maskPtr++;
|
|
}
|
|
else
|
|
{
|
|
nextgrayscaleValue = *maskPtr >> 4;
|
|
}
|
|
}
|
|
|
|
if (grayscaleValue != nextgrayscaleValue)
|
|
{
|
|
|
|
if (grayscaleValue != 0)
|
|
{
|
|
// Draw this run
|
|
|
|
INT runLength = mx - runStart;
|
|
INT from = left + runStart;
|
|
|
|
|
|
// Clip the run
|
|
INT to = from + runLength; // reference needed
|
|
|
|
output->OutputSpan(y, from, to);
|
|
ARGB *buffer;
|
|
buffer = output->GetScanBuffer()->GetCurrentBuffer();
|
|
for (INT j = from; j < to; j++)
|
|
{
|
|
*buffer++ = GpColor::MultiplyCoverage(*buffer,
|
|
textContrastTable.GetGammaTableIndexValue(grayscaleValue, GRAYSCALE_LEVEL));
|
|
}
|
|
|
|
// Start a new run
|
|
runStart = mx;
|
|
grayscaleValue = nextgrayscaleValue;
|
|
}
|
|
else
|
|
{
|
|
// Start a new run
|
|
runStart = mx;
|
|
grayscaleValue = nextgrayscaleValue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (clipRegion != NULL)
|
|
{
|
|
clipRegion->EndClipping();
|
|
}
|
|
|
|
delete output;
|
|
}
|
|
|
|
return(Ok);
|
|
}
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* Engine version of routine to draw solid text.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [IN] - DDI parameters.
|
|
*
|
|
* Return Value:
|
|
*
|
|
* TRUE if successful.
|
|
*
|
|
* History:
|
|
* 1/24/2000 YungT modified it
|
|
* 4/4/1999 cameronb
|
|
* Created it.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
GpStatus
|
|
DpDriver::BrushText(
|
|
DpContext* context,
|
|
DpBitmap* surface,
|
|
const GpRect* drawBounds,
|
|
const DpBrush* brush,
|
|
const GpGlyphPos *glyphPos,
|
|
INT count,
|
|
TextRenderingHint textMode
|
|
)
|
|
{
|
|
ASSERT (textMode != TextRenderingHintSystemDefault);
|
|
switch(textMode)
|
|
{
|
|
case TextRenderingHintSingleBitPerPixelGridFit:
|
|
case TextRenderingHintSingleBitPerPixel:
|
|
return OutputBrushNormalText(context, this, surface, drawBounds, brush, glyphPos, count);
|
|
case TextRenderingHintAntiAlias:
|
|
return OutputBrushAntiAliasText8BPP(context, this, surface, drawBounds, brush, glyphPos, count);
|
|
case TextRenderingHintAntiAliasGridFit:
|
|
return OutputBrushAntiAliasText4BPP(context, this, surface, drawBounds, brush, glyphPos, count);
|
|
// version 2 :
|
|
// case TextRenderingHintClearType:
|
|
case TextRenderingHintClearTypeGridFit:
|
|
return OutputBrushClearTypeText(context, this, surface, drawBounds, brush, glyphPos, count);
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return Ok;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
///// GdiText - Draw glyph on downlevel DC
|
|
//
|
|
// !!! Optimize to use lpdx
|
|
// NOTE:
|
|
// Here we explicitly call ExtTextOutW because we calling it with
|
|
// ETO_GLYPH_INDEX. It will be fine even if we are running on Windows 9x
|
|
// because internally it calls ExtTextOutA.
|
|
// We didn't use Global::ExtTextOutFunction because we don't want to call
|
|
// ExtTextOutA with ETO_GLYPH_INDEX while recording to a Meta file under
|
|
// Windows 9x. And in that case Windows 9x fails to record it.
|
|
// The code in Windows 9x is recording glyph indexes only if we are spooling
|
|
// only otherwise it will not record.
|
|
|
|
GpStatus
|
|
DpDriver::GdiText(
|
|
HDC hdc,
|
|
INT angle, // Tenths of a degree
|
|
const UINT16 *glyphs,
|
|
const PointF *glyphOrigins,
|
|
INT glyphCount,
|
|
BOOL rightToLeft,
|
|
UINT16 blankGlyph
|
|
)
|
|
{
|
|
UINT16 lastTwoGlyphs[2];
|
|
|
|
if ( glyphCount > 1
|
|
&& angle == 0)
|
|
{
|
|
// Try to optimise for horizintal text. (We don't try for vertical
|
|
// text since GDI and GDI+ rotation semantics are not compatible)
|
|
|
|
INT i=1;
|
|
while ( i < glyphCount
|
|
&& abs(GpRound(glyphOrigins[i].Y - glyphOrigins[i-1].Y)) == 0)
|
|
{
|
|
i++;
|
|
}
|
|
|
|
if (i == glyphCount)
|
|
{
|
|
// All text is at the same dy
|
|
|
|
AutoArray<INT> advances(new INT[glyphCount]);
|
|
|
|
if (!advances)
|
|
{
|
|
return OutOfMemory;
|
|
}
|
|
|
|
if (rightToLeft && !Globals::IsNt && glyphCount>1)
|
|
{
|
|
// Windows 9x doesn't work with the negative advanced widths
|
|
|
|
AutoArray<UINT16> bidiGlyphs(new UINT16[glyphCount]);
|
|
if (!bidiGlyphs)
|
|
{
|
|
return OutOfMemory;
|
|
}
|
|
|
|
for (i=0; i<glyphCount-1; i++)
|
|
{
|
|
bidiGlyphs[i] = glyphs[glyphCount - i - 1];
|
|
advances[i] = GpRound(glyphOrigins[glyphCount- i - 2].X - glyphOrigins[glyphCount- i - 1].X);
|
|
}
|
|
|
|
bidiGlyphs[glyphCount-1] = glyphs[0];
|
|
advances[glyphCount-1] = 0;
|
|
|
|
if (blankGlyph > 0 && (glyphCount & 1))
|
|
{
|
|
if (!ExtTextOutW(
|
|
hdc,
|
|
GpRound(glyphOrigins[glyphCount - 1].X),
|
|
GpRound(glyphOrigins[glyphCount - 1].Y),
|
|
ETO_GLYPH_INDEX,
|
|
NULL,
|
|
(PWSTR)bidiGlyphs.Get(),
|
|
glyphCount-1,
|
|
advances.Get()
|
|
)) {
|
|
return Win32Error;
|
|
}
|
|
|
|
lastTwoGlyphs[0] = bidiGlyphs[glyphCount-1];
|
|
lastTwoGlyphs[1] = blankGlyph;
|
|
|
|
if (!ExtTextOutW(
|
|
hdc,
|
|
GpRound(glyphOrigins[0].X),
|
|
GpRound(glyphOrigins[0].Y),
|
|
ETO_GLYPH_INDEX,
|
|
NULL,
|
|
(PWSTR)lastTwoGlyphs,
|
|
2,
|
|
NULL
|
|
)) {
|
|
return Win32Error;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!ExtTextOutW(
|
|
hdc,
|
|
GpRound(glyphOrigins[glyphCount - 1].X),
|
|
GpRound(glyphOrigins[glyphCount - 1].Y),
|
|
ETO_GLYPH_INDEX,
|
|
NULL,
|
|
(PWSTR)bidiGlyphs.Get(),
|
|
glyphCount,
|
|
advances.Get()
|
|
)) {
|
|
return Win32Error;
|
|
}
|
|
}
|
|
return Ok;
|
|
}
|
|
|
|
|
|
INT offset = GpRound(glyphOrigins[0].X);
|
|
|
|
for (i=0; i<glyphCount-1; i++)
|
|
{
|
|
advances[i] = GpRound(glyphOrigins[i+1].X) - offset;
|
|
offset += advances[i];
|
|
}
|
|
advances[glyphCount-1] = 0;
|
|
|
|
|
|
if (blankGlyph > 0 && (glyphCount & 1))
|
|
{
|
|
if (!ExtTextOutW(
|
|
hdc,
|
|
GpRound(glyphOrigins[0].X),
|
|
GpRound(glyphOrigins[0].Y),
|
|
ETO_GLYPH_INDEX,
|
|
NULL,
|
|
(PWSTR)glyphs,
|
|
glyphCount-1,
|
|
advances.Get()
|
|
)) {
|
|
return Win32Error;
|
|
}
|
|
|
|
lastTwoGlyphs[0] = glyphs[glyphCount-1];
|
|
lastTwoGlyphs[1] = blankGlyph;
|
|
|
|
if (!ExtTextOutW(
|
|
hdc,
|
|
GpRound(glyphOrigins[glyphCount-1].X),
|
|
GpRound(glyphOrigins[glyphCount-1].Y),
|
|
ETO_GLYPH_INDEX,
|
|
NULL,
|
|
(PWSTR)lastTwoGlyphs,
|
|
2,
|
|
NULL
|
|
)) {
|
|
return Win32Error;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!ExtTextOutW(
|
|
hdc,
|
|
GpRound(glyphOrigins[0].X),
|
|
GpRound(glyphOrigins[0].Y),
|
|
ETO_GLYPH_INDEX,
|
|
NULL,
|
|
(PWSTR)glyphs,
|
|
glyphCount,
|
|
advances.Get()
|
|
)) {
|
|
return Win32Error;
|
|
}
|
|
}
|
|
|
|
|
|
return Ok;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
if (blankGlyph > 0)
|
|
{
|
|
lastTwoGlyphs[1] = blankGlyph;
|
|
|
|
for (INT i=0; i<glyphCount; i++)
|
|
{
|
|
if (glyphs[i] != 0xffff) // 0xffff is never displayed
|
|
{
|
|
lastTwoGlyphs[0] = glyphs[i];
|
|
|
|
if (!ExtTextOutW(
|
|
hdc,
|
|
GpRound(glyphOrigins[i].X),
|
|
GpRound(glyphOrigins[i].Y),
|
|
ETO_GLYPH_INDEX,
|
|
NULL,
|
|
(PWSTR)lastTwoGlyphs,
|
|
2,
|
|
NULL
|
|
)) {
|
|
return Win32Error;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Failed to optimise ...
|
|
for (INT i=0; i<glyphCount; i++)
|
|
{
|
|
if (glyphs[i] != 0xffff) // 0xffff is never displayed
|
|
{
|
|
if (!ExtTextOutW(
|
|
hdc,
|
|
GpRound(glyphOrigins[i].X),
|
|
GpRound(glyphOrigins[i].Y),
|
|
ETO_GLYPH_INDEX,
|
|
NULL,
|
|
(PWSTR)glyphs+i,
|
|
1,
|
|
NULL
|
|
)) {
|
|
return Win32Error;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return Ok;
|
|
}
|
|
|
|
|