{

LOGFONT lf;

ZeroMemory(&lf, sizeof(lf));

lf <<= style;

lf.lfHeight = (LONG)(style.fontSize + 0.5);

lf.lfOutPrecision = OUT_TT_PRECIS;

lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;

lf.lfQuality = ANTIALIASED_QUALITY;

lf.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;

if (!CreateFontIndirect(&lf)) {

_tcscpy_s(lf.lfFaceName, _T("Arial"));

VERIFY(CreateFontIndirect(&lf));

}

HFONT hOldFont = SelectFont(g_hDC, *this);

TEXTMETRIC tm;

GetTextMetrics(g_hDC, &tm);

m_ascent = ((tm.tmAscent + 4) >> 3);

m_descent = ((tm.tmDescent + 4) >> 3);

SelectFont(g_hDC, hOldFont);

RenderingCaches& renderingCaches)

: m_fDrawn(false)

, m_p(INT_MAX, INT_MAX)

, m_renderingCaches(renderingCaches)

, m_scalex(scalex)

, m_scaley(scaley)

, m_str(str)

, m_fWhiteSpaceChar(false)

, m_fLineBreak(false)

, m_style(style)

, m_pOpaqueBox(nullptr)

, m_ktype(ktype)

, m_kstart(kstart)

, m_kend(kend)

, m_width(0)

, m_ascent(0)

, m_descent(0)

{

if (str.IsEmpty()) {

m_fWhiteSpaceChar = m_fLineBreak = true;

}

{

if (m_style != w->m_style

|| m_fLineBreak || w->m_fLineBreak

|| w->m_kstart != w->m_kend || m_ktype != w->m_ktype) {

return false;

}

m_fWhiteSpaceChar = m_fWhiteSpaceChar && w->m_fWhiteSpaceChar;

m_str += w->m_str;

m_width += w->m_width;

m_fDrawn = false;

m_p = CPoint(INT_MAX, INT_MAX);

return true;

{

if (!m_str) {

return;

}

COverlayKey overlayKey(this, p, org);

if (m_renderingCaches.overlayCache.Lookup(overlayKey, m_pOverlayData)) {

m_fDrawn = m_renderingCaches.outlineCache.Lookup(overlayKey, m_pOutlineData);

if (m_style.borderStyle == 1) {

VERIFY(CreateOpaqueBox());

}

} else {

if (!m_fDrawn) {

if (m_renderingCaches.outlineCache.Lookup(overlayKey, m_pOutlineData)) {

if (m_style.borderStyle == 1) {

VERIFY(CreateOpaqueBox());

}

} else {

if (!CreatePath()) {

return;

}

Transform(CPoint((org.x - p.x) * 8, (org.y - p.y) * 8));

if (!ScanConvert()) {

return;

}

if (m_style.borderStyle == 0 && (m_style.outlineWidthX + m_style.outlineWidthY > 0)) {

int rx = std::max<int>(0, std::lround(m_style.outlineWidthX));

int ry = std::max<int>(0, std::lround(m_style.outlineWidthY));

if (!m_pEllipse || m_pEllipse->GetXRadius() != rx || m_pEllipse->GetYRadius() != ry) {

CEllipseKey ellipseKey(rx, ry);

if (!m_renderingCaches.ellipseCache.Lookup(ellipseKey, m_pEllipse)) {

m_pEllipse = std::make_shared<CEllipse>(rx, ry);

m_renderingCaches.ellipseCache.SetAt(ellipseKey, m_pEllipse);

}

}

if (!CreateWidenedRegion(rx, ry)) {

return;

}

} else if (m_style.borderStyle == 1) {

VERIFY(CreateOpaqueBox());

}

m_renderingCaches.outlineCache.SetAt(overlayKey, m_pOutlineData);

}

m_fDrawn = true;

if (!Rasterize(p.x & 7, p.y & 7, m_style.fBlur, m_style.fGaussianBlur)) {

return;

}

m_renderingCaches.overlayCache.SetAt(overlayKey, m_pOverlayData);

} else if ((m_p.x & 7) != (p.x & 7) || (m_p.y & 7) != (p.y & 7)) {

Rasterize(p.x & 7, p.y & 7, m_style.fBlur, m_style.fGaussianBlur);

m_renderingCaches.overlayCache.SetAt(overlayKey, m_pOverlayData);

}

}

m_p = p;

if (m_pOpaqueBox) {

m_pOpaqueBox->Paint(p, org);

}

{

#if defined(_M_IX86_FP) && _M_IX86_FP < 2

if (!m_bUseSSE2) {

Transform_C(org);

} else

#endif

{

Transform_SSE2(org);

}

{

if (m_pOpaqueBox) {

return true;

}

STSStyle style = m_style;

style.borderStyle = 0;

// We don't want to apply the outline and the scaling twice

style.outlineWidthX = style.outlineWidthY = 0.0;

style.fontScaleX = style.fontScaleY = 100.0;

style.colors[0] = m_style.colors[2];

style.alpha[0] = m_style.alpha[2];

int w = std::lround(m_style.outlineWidthX);

int h = std::lround(m_style.outlineWidthY);

// Convert to pixels rounding to nearest

CStringW str;

str.Format(L"m %d %d l %d %d %d %d %d %d",

-(w + 4) / 8, -(h + 4) / 8,

(m_width + w + 4) / 8, -(h + 4) / 8,

(m_width + w + 4) / 8, (m_ascent + m_descent + h + 4) / 8,

-(w + 4) / 8, (m_ascent + m_descent + h + 4) / 8);

try {

m_pOpaqueBox = DEBUG_NEW CPolygon(style, str, 0, 0, 0, 1.0, 1.0, 0, m_renderingCaches);

} catch (CMemoryException* e) {

e->Delete();

m_pOpaqueBox = nullptr;

}

return !!m_pOpaqueBox;

{

const double scalex = m_style.fontScaleX / 100.0;

const double scaley = m_style.fontScaleY / 100.0;

const double xzoomf = m_scalex * 20000.0;

const double yzoomf = m_scaley * 20000.0;

const double caz = cos((M_PI / 180.0) * m_style.fontAngleZ);

const double saz = sin((M_PI / 180.0) * m_style.fontAngleZ);

const double cax = cos((M_PI / 180.0) * m_style.fontAngleX);

const double sax = sin((M_PI / 180.0) * m_style.fontAngleX);

const double cay = cos((M_PI / 180.0) * m_style.fontAngleY);

const double say = sin((M_PI / 180.0) * m_style.fontAngleY);

double dOrgX = static_cast<double>(org.x), dOrgY = static_cast<double>(org.y);

for (ptrdiff_t i = 0; i < mPathPoints; i++) {

double x, y, z, xx, yy, zz;

x = mpPathPoints[i].x;

y = mpPathPoints[i].y;

z = 0;

const double dPPx = m_style.fontShiftX * y + x;

y = scaley * (m_style.fontShiftY * x + y) - dOrgY;

x = scalex * dPPx - dOrgX;

xx = x * caz + y * saz;

yy = -(x * saz - y * caz);

zz = z;

x = xx;

y = yy * cax + zz * sax;

z = yy * sax - zz * cax;

xx = x * cay + z * say;

yy = y;

zz = x * say - z * cay;

x = xx * xzoomf / std::max((zz + xzoomf), 1000.0);

y = yy * yzoomf / std::max((zz + yzoomf), 1000.0);

// round to integer

mpPathPoints[i].x = std::lround(x) + org.x;

mpPathPoints[i].y = std::lround(y) + org.y;

}

{

// SSE code

// speed up ~1.5-1.7x

const __m128 __xshift = _mm_set_ps1((float)m_style.fontShiftX);

const __m128 __yshift = _mm_set_ps1((float)m_style.fontShiftY);

const __m128 __xorg = _mm_set_ps1((float)org.x);

const __m128 __yorg = _mm_set_ps1((float)org.y);

const __m128 __xscale = _mm_set_ps1((float)(m_style.fontScaleX / 100.0));

const __m128 __yscale = _mm_set_ps1((float)(m_style.fontScaleY / 100.0));

const __m128 __xzoomf = _mm_set_ps1((float)(m_scalex * 20000.0));

const __m128 __yzoomf = _mm_set_ps1((float)(m_scaley * 20000.0));

const __m128 __caz = _mm_set_ps1((float)cos((M_PI / 180.0) * m_style.fontAngleZ));

const __m128 __saz = _mm_set_ps1((float)sin((M_PI / 180.0) * m_style.fontAngleZ));

const __m128 __cax = _mm_set_ps1((float)cos((M_PI / 180.0) * m_style.fontAngleX));

const __m128 __sax = _mm_set_ps1((float)sin((M_PI / 180.0) * m_style.fontAngleX));

const __m128 __cay = _mm_set_ps1((float)cos((M_PI / 180.0) * m_style.fontAngleY));

const __m128 __say = _mm_set_ps1((float)sin((M_PI / 180.0) * m_style.fontAngleY));

const __m128 __1000 = _mm_set_ps1(1000.0f);

int mPathPointsD4 = mPathPoints / 4;

int mPathPointsM4 = mPathPoints % 4;

for (ptrdiff_t i = 0; i < mPathPointsD4 + 1; i++) {

__m128 __pointx, __pointy, __tmpx, __tmpy;

// we can't use load .-.

if (i != mPathPointsD4) {

__pointx = _mm_set_ps((float)mpPathPoints[4 * i + 0].x, (float)mpPathPoints[4 * i + 1].x, (float)mpPathPoints[4 * i + 2].x, (float)mpPathPoints[4 * i + 3].x);

__pointy = _mm_set_ps((float)mpPathPoints[4 * i + 0].y, (float)mpPathPoints[4 * i + 1].y, (float)mpPathPoints[4 * i + 2].y, (float)mpPathPoints[4 * i + 3].y);

} else { // last cycle

switch (mPathPointsM4) {

default:

case 0:

continue;

case 1:

__pointx = _mm_set_ps((float)mpPathPoints[4 * i + 0].x, 0, 0, 0);

__pointy = _mm_set_ps((float)mpPathPoints[4 * i + 0].y, 0, 0, 0);

break;

case 2:

__pointx = _mm_set_ps((float)mpPathPoints[4 * i + 0].x, (float)mpPathPoints[4 * i + 1].x, 0, 0);

__pointy = _mm_set_ps((float)mpPathPoints[4 * i + 0].y, (float)mpPathPoints[4 * i + 1].y, 0, 0);

break;

case 3:

__pointx = _mm_set_ps((float)mpPathPoints[4 * i + 0].x, (float)mpPathPoints[4 * i + 1].x, (float)mpPathPoints[4 * i + 2].x, 0);

__pointy = _mm_set_ps((float)mpPathPoints[4 * i + 0].y, (float)mpPathPoints[4 * i + 1].y, (float)mpPathPoints[4 * i + 2].y, 0);

break;

}

}

// scale and shift

__tmpy = __pointx; // save a copy for calculating __pointy later

if (m_style.fontShiftX != 0) {

__tmpx = _mm_mul_ps(__xshift, __pointy);

__pointx = _mm_add_ps(__pointx, __tmpx);

}

__pointx = _mm_mul_ps(__pointx, __xscale);

__pointx = _mm_sub_ps(__pointx, __xorg);

if (m_style.fontShiftY != 0) {

__tmpy = _mm_mul_ps(__yshift, __tmpy); // __tmpy is a copy of __pointx here, because it may otherwise be modified

__pointy = _mm_add_ps(__pointy, __tmpy);

}

__pointy = _mm_mul_ps(__pointy, __yscale);

__pointy = _mm_sub_ps(__pointy, __yorg);

// rotate

__m128 __xx, __yy;

__m128 __zz = _mm_setzero_ps();

// xx = x * caz + y * saz

__tmpx = _mm_mul_ps(__pointx, __caz); // x * caz

__tmpy = _mm_mul_ps(__pointy, __saz); // y * saz

__xx = _mm_add_ps(__tmpx, __tmpy); // xx = x * caz + y * saz;

// yy = -(x * saz - y * caz)

__tmpx = _mm_mul_ps(__pointx, __saz); // x * saz

__tmpy = _mm_mul_ps(__pointy, __caz); // y * caz

__yy = _mm_sub_ps(__tmpy, __tmpx); // yy = -(x * saz - y * caz) = y * caz - x * saz

__pointx = __xx; // x = xx

// y = yy * cax + zz * sax

__tmpx = _mm_mul_ps(__zz, __sax); // zz * sax

__tmpy = _mm_mul_ps(__yy, __cax); // yy * cax

__pointy = _mm_add_ps(__tmpy, __tmpx); // y = yy * cax + zz * sax

// z = yy * sax - zz * cax

__tmpx = _mm_mul_ps(__zz, __cax); // zz * cax

__tmpy = _mm_mul_ps(__yy, __sax); // yy * sax

__zz = _mm_sub_ps(__tmpy, __tmpx); // z = yy * sax - zz * cax

// xx = x * cay + z * say

__tmpx = _mm_mul_ps(__pointx, __cay); // x * cay

__tmpy = _mm_mul_ps(__zz, __say); // z * say

__xx = _mm_add_ps(__tmpx, __tmpy); // xx = x * cay + z * say

__yy = __pointy; // yy = y

// zz = x * say - z * cay

__tmpx = _mm_mul_ps(__pointx, __say); // x * say

__zz = _mm_mul_ps(__zz, __cay); // z * cay

__zz = _mm_sub_ps(__tmpx, __zz); // zz = x * say - z * cay

// x = xx * xzoomf / std::max((zz + xzoomf), 1000.0);

// y = yy * yzoomf / std::max((zz + yzoomf), 1000.0);

__m128 __tmpzz = _mm_add_ps(__zz, __xzoomf); // zz + xzoomf

__xx = _mm_mul_ps(__xx, __xzoomf); // xx * xzoomf

__pointx = _mm_div_ps(__xx, _mm_max_ps(__tmpzz, __1000)); // x = (xx * xzoomf) / std::max((zz + xzoomf), 1000.0)

__tmpzz = _mm_add_ps(__zz, __yzoomf); // zz + yzoomf

__yy = _mm_mul_ps(__yy, __yzoomf); // yy * yzoomf

__pointy = _mm_div_ps(__yy, _mm_max_ps(__tmpzz, __1000)); // y = yy * yzoomf / std::max((zz + yzoomf), 1000.0);

__pointx = _mm_add_ps(__pointx, __xorg); // x = x + org.x

__pointy = _mm_add_ps(__pointy, __yorg); // y = y + org.y

// round to integer

__m128i __pointxRounded = _mm_cvtps_epi32(__pointx);

__m128i __pointyRounded = _mm_cvtps_epi32(__pointy);

if (i == mPathPointsD4) { // last cycle

for (int k = 0; k < mPathPointsM4; k++) {

mpPathPoints[i * 4 + k].x = __pointxRounded.m128i_i32[3 - k];

mpPathPoints[i * 4 + k].y = __pointyRounded.m128i_i32[3 - k];

}

} else {

for (int k = 0; k < 4; k++) {

mpPathPoints[i * 4 + k].x = __pointxRounded.m128i_i32[3 - k];

mpPathPoints[i * 4 + k].y = __pointyRounded.m128i_i32[3 - k];

}

}

}

RenderingCaches& renderingCaches)

: CWord(style, str, ktype, kstart, kend, scalex, scaley, renderingCaches)

{

if (m_str == L" ") {

m_fWhiteSpaceChar = true;

}

CTextDimsKey textDimsKey(m_str, m_style);

CTextDims textDims;

if (!renderingCaches.textDimsCache.Lookup(textDimsKey, textDims)) {

CMyFont font(m_style);

m_ascent = font.m_ascent;

m_descent = font.m_descent;

HFONT hOldFont = SelectFont(g_hDC, font);

if (m_style.fontSpacing) {

for (LPCWSTR s = m_str; *s; s++) {

CSize extent;

if (!GetTextExtentPoint32W(g_hDC, s, 1, &extent)) {

SelectFont(g_hDC, hOldFont);

ASSERT(0);

return;

}

m_width += extent.cx + (int)m_style.fontSpacing;

}

// m_width -= (int)m_style.fontSpacing; // TODO: subtract only at the end of the line

} else {

CSize extent;

if (!GetTextExtentPoint32W(g_hDC, m_str, str.GetLength(), &extent)) {

SelectFont(g_hDC, hOldFont);

ASSERT(0);

return;

}

m_width += extent.cx;

}

SelectFont(g_hDC, hOldFont);

textDims.ascent = m_ascent;

textDims.descent = m_descent;

textDims.width = m_width;

renderingCaches.textDimsCache.SetAt(textDimsKey, textDims);

} else {

m_ascent = textDims.ascent;

m_descent = textDims.descent;

m_width = textDims.width;

}

m_ascent = (int)(m_style.fontScaleY / 100 * m_ascent);

m_descent = (int)(m_style.fontScaleY / 100 * m_descent);

m_width = (int)(m_style.fontScaleX / 100 * m_width + 4) >> 3;

{

CMyFont font(m_style);

HFONT hOldFont = SelectFont(g_hDC, font);

if (m_style.fontSpacing) {

int width = 0;

bool bFirstPath = true;

for (LPCWSTR s = m_str; *s; s++) {

CSize extent;

if (!GetTextExtentPoint32W(g_hDC, s, 1, &extent)) {

SelectFont(g_hDC, hOldFont);

ASSERT(0);

return false;

}

PartialBeginPath(g_hDC, bFirstPath);

bFirstPath = false;

TextOutW(g_hDC, 0, 0, s, 1);

PartialEndPath(g_hDC, width, 0);

width += extent.cx + (int)m_style.fontSpacing;

}

} else {

CSize extent;

if (!GetTextExtentPoint32W(g_hDC, m_str, m_str.GetLength(), &extent)) {

SelectFont(g_hDC, hOldFont);

ASSERT(0);

return false;

}

BeginPath(g_hDC);

TextOutW(g_hDC, 0, 0, m_str, m_str.GetLength());

EndPath(g_hDC);

}

SelectFont(g_hDC, hOldFont);

return true;

RenderingCaches& renderingCaches)

: CWord(style, str, ktype, kstart, kend, scalex, scaley, renderingCaches)

, m_baseline(baseline)

{

ParseStr();

: CWord(src.m_style, src.m_str, src.m_ktype, src.m_kstart, src.m_kend, src.m_scalex, src.m_scaley, src.m_renderingCaches)

, m_baseline(src.m_baseline)

, m_pPolygonPath(src.m_pPolygonPath)

{

m_width = src.m_width;

m_ascent = src.m_ascent;

m_descent = src.m_descent;

{

CPolygon* p = dynamic_cast<CPolygon*>(w);

if (!p) {

return false;

}

// TODO

return false;

//return true;

{

LPWSTR xEnd = nullptr;

LPWSTR yEnd = nullptr;

point.x = std::lround(wcstod(str, &xEnd) * m_scalex) * 64;

if (xEnd <= str) {

return false;

}

point.y = std::lround(wcstod(xEnd, &yEnd) * m_scaley) * 64;

bool ret = yEnd > xEnd;

str = yEnd;

return ret;

{

if (m_pPolygonPath && !m_pPolygonPath->typesOrg.IsEmpty()) {

return true;

}

CPolygonPathKey polygonPathKey(m_str, m_scalex, m_scaley);

if (!m_renderingCaches.polygonCache.Lookup(polygonPathKey, m_pPolygonPath)) {

m_pPolygonPath = std::make_shared<CPolygonPath>();

CPoint p;

bool bFoundMove = false;

size_t i, j, lastSplineStart = SIZE_T_ERROR;

auto isValidAction = [](const WCHAR c) {

return c == L'm' || c == L'n' || c == L'l' || c == L'b'

|| c == L's' || c == L'p' || c == L'c';

};

for (LPCWSTR str = m_str; *str;) {

// Trim any leading invalid characters and whitespace

while (*str && !isValidAction(*str)) {

str++;

}

const WCHAR c = *str;

if (*str) {

do {

str++;

} while (isValidAction(*str));

}

switch (c) {

case L'm':

if (!bFoundMove) {

if (m_pPolygonPath->typesOrg.GetCount() > 0) {

// move command not first so we abort

m_pPolygonPath = nullptr;

return false;

}

bFoundMove = true;

}

while (GetPOINT(str, p)) {

m_pPolygonPath->typesOrg.Add(PT_MOVETO);

m_pPolygonPath->pointsOrg.Add(p);

}

break;

case L'n':

while (GetPOINT(str, p)) {

m_pPolygonPath->typesOrg.Add(PT_MOVETONC);

m_pPolygonPath->pointsOrg.Add(p);

}

break;

case L'l':

if (m_pPolygonPath->pointsOrg.GetCount() < 1) {

break;

}

while (GetPOINT(str, p)) {

m_pPolygonPath->typesOrg.Add(PT_LINETO);

m_pPolygonPath->pointsOrg.Add(p);

}

break;

case L'b':

j = m_pPolygonPath->typesOrg.GetCount();

if (j < 1) {

break;

}

while (GetPOINT(str, p)) {

m_pPolygonPath->typesOrg.Add(PT_BEZIERTO);

m_pPolygonPath->pointsOrg.Add(p);

++j;

}

j = m_pPolygonPath->typesOrg.GetCount() - ((m_pPolygonPath->typesOrg.GetCount() - j) % 3);

m_pPolygonPath->typesOrg.SetCount(j);

m_pPolygonPath->pointsOrg.SetCount(j);

break;

case L's':

if (m_pPolygonPath->pointsOrg.GetCount() < 1) {

break;

}

j = lastSplineStart = m_pPolygonPath->typesOrg.GetCount();

i = 3;

while (i-- && GetPOINT(str, p)) {

m_pPolygonPath->typesOrg.Add(PT_BSPLINETO);

m_pPolygonPath->pointsOrg.Add(p);

++j;

}

if (m_pPolygonPath->typesOrg.GetCount() - lastSplineStart < 3) {

m_pPolygonPath->typesOrg.SetCount(lastSplineStart);

m_pPolygonPath->pointsOrg.SetCount(lastSplineStart);

lastSplineStart = SIZE_T_ERROR;

}

// no break

case L'p':

if (m_pPolygonPath->pointsOrg.GetCount() < 3) {

break;

}

while (GetPOINT(str, p)) {

m_pPolygonPath->typesOrg.Add(PT_BSPLINEPATCHTO);

m_pPolygonPath->pointsOrg.Add(p);

}

break;

case L'c':

if (lastSplineStart != SIZE_T_ERROR && lastSplineStart > 0) {

m_pPolygonPath->typesOrg.Add(PT_BSPLINEPATCHTO);

m_pPolygonPath->typesOrg.Add(PT_BSPLINEPATCHTO);

m_pPolygonPath->typesOrg.Add(PT_BSPLINEPATCHTO);

p = m_pPolygonPath->pointsOrg[lastSplineStart - 1]; // we need p for temp storage, because operator [] will return a reference to CPoint and Add() may reallocate its internal buffer (this is true for MFC 7.0 but not for 6.0, hehe)

m_pPolygonPath->pointsOrg.Add(p);

p = m_pPolygonPath->pointsOrg[lastSplineStart];

m_pPolygonPath->pointsOrg.Add(p);

p = m_pPolygonPath->pointsOrg[lastSplineStart + 1];

m_pPolygonPath->pointsOrg.Add(p);

lastSplineStart = SIZE_T_ERROR;

}

break;

default:

break;

}

}

if (!bFoundMove) {

// move command not found so we abort

m_pPolygonPath = nullptr;

return false;

}

int minx = INT_MAX, miny = INT_MAX, maxx = INT_MIN, maxy = INT_MIN;

for (size_t m = 0; m < m_pPolygonPath->typesOrg.GetCount(); m++) {

if (minx > m_pPolygonPath->pointsOrg[m].x) {

minx = m_pPolygonPath->pointsOrg[m].x;

}

if (miny > m_pPolygonPath->pointsOrg[m].y) {

miny = m_pPolygonPath->pointsOrg[m].y;

}

if (maxx < m_pPolygonPath->pointsOrg[m].x) {

maxx = m_pPolygonPath->pointsOrg[m].x;

}

if (maxy < m_pPolygonPath->pointsOrg[m].y) {

maxy = m_pPolygonPath->pointsOrg[m].y;

}

}

m_pPolygonPath->size.SetSize(std::max(maxx - minx, 0), std::max(maxy - miny, 0));

m_renderingCaches.polygonCache.SetAt(polygonPathKey, m_pPolygonPath);

}

m_width = m_pPolygonPath->size.cx;

m_ascent = m_pPolygonPath->size.cy;

int baseline = std::lround(m_scaley * m_baseline) * 64;

m_descent = baseline;

m_ascent -= baseline;

m_width = ((int)(m_style.fontScaleX / 100.0 * m_width) + 4) >> 3;

m_ascent = ((int)(m_style.fontScaleY / 100.0 * m_ascent) + 4) >> 3;

m_descent = ((int)(m_style.fontScaleY / 100.0 * m_descent) + 4) >> 3;

return true;

{

int len = m_pPolygonPath ? (int)m_pPolygonPath->typesOrg.GetCount() : 0;

if (len == 0) {

return false;

}

if (mPathPoints != len) {

BYTE* pNewPathTypes = (BYTE*)realloc(mpPathTypes, len * sizeof(BYTE));

if (!pNewPathTypes) {

return false;

}

mpPathTypes = pNewPathTypes;

POINT* pNewPathPoints = (POINT*)realloc(mpPathPoints, len * sizeof(POINT));

if (!pNewPathPoints) {

return false;

}

mpPathPoints = pNewPathPoints;

mPathPoints = len;

}

memcpy(mpPathTypes, m_pPolygonPath->typesOrg.GetData(), len * sizeof(BYTE));

memcpy(mpPathPoints, m_pPolygonPath->pointsOrg.GetData(), len * sizeof(POINT));

return true;

RenderingCaches& renderingCaches)

: CPolygon(STSStyle(), str, 0, 0, 0, scalex, scaley, 0, renderingCaches)

, m_size(size)

, m_inverse(inverse)

, m_cpOffset(cpOffset)

, m_pAlphaMask(nullptr)

, m_effectType(-1)

{

{

if (m_pAlphaMask) {

return m_pAlphaMask;

}

ASSERT(this == clipper.get());

if (m_size.cx <= 0 || m_size.cy <= 0) {

return nullptr;

}

CClipperKey key(clipper);

if (m_renderingCaches.alphaMaskCache.Lookup(key, m_pAlphaMask)) {

return m_pAlphaMask;

}

Paint(CPoint(0, 0), CPoint(0, 0));

if (!m_pOverlayData) {

return nullptr;

}

int w = m_pOverlayData->mOverlayWidth, h = m_pOverlayData->mOverlayHeight;

int x = (m_pOverlayData->mOffsetX + m_cpOffset.x + 4) >> 3, y = (m_pOverlayData->mOffsetY + m_cpOffset.y + 4) >> 3;

int xo = 0, yo = 0;

if (x < 0) {

xo = -x;

w -= -x;

x = 0;

}

if (y < 0) {

yo = -y;

h -= -y;

y = 0;

}

if (x + w > m_size.cx) {

w = m_size.cx - x;

}

if (y + h > m_size.cy) {

h = m_size.cy - y;

}

if (w <= 0 || h <= 0) {

return nullptr;

}

const size_t alphaMaskSize = size_t(m_size.cx) * m_size.cy;

try {

m_pAlphaMask = CAlphaMask::Alloc(m_renderingCaches.alphaMaskPool, alphaMaskSize);

} catch (CMemoryException* e) {

e->Delete();

m_pAlphaMask = nullptr;

return nullptr;

}

BYTE* pAlphaMask = m_pAlphaMask->get();

memset(pAlphaMask, (m_inverse ? 0x40 : 0), alphaMaskSize);

const BYTE* src = m_pOverlayData->mpOverlayBufferBody + m_pOverlayData->mOverlayPitch * yo + xo;

BYTE* dst = pAlphaMask + m_size.cx * y + x;

if (m_inverse) {

for (ptrdiff_t i = 0; i < h; ++i) {

for (ptrdiff_t wt = 0; wt < w; ++wt) {

dst[wt] = 0x40 - src[wt];

}

src += m_pOverlayData->mOverlayPitch;

dst += m_size.cx;

}

} else {

for (ptrdiff_t i = 0; i < h; ++i) {

memcpy(dst, src, w * sizeof(BYTE));

src += m_pOverlayData->mOverlayPitch;

dst += m_size.cx;

}

}

if (m_effectType == EF_SCROLL) {

int height = m_effect.param[4];

int spd_w = m_size.cx, spd_h = m_size.cy;

int da = (64 << 8) / height;

int a = 0;

int k = m_effect.param[0] >> 3;

int l = k + height;

if (k < 0) {

a += -k * da;

k = 0;

}

if (l > spd_h) {

l = spd_h;

}

if (k < spd_h) {

BYTE* am = &pAlphaMask[k * spd_w];

ZeroMemory(pAlphaMask, am - pAlphaMask);

for (ptrdiff_t j = k; j < l; j++, a += da) {

for (ptrdiff_t i = 0; i < spd_w; i++, am++) {

*am = BYTE(((*am) * a) >> 14);

}

}

}

da = -(64 << 8) / height;

a = 0x40 << 8;

l = m_effect.param[1] >> 3;

k = l - height;

if (k < 0) {

a += -k * da;

k = 0;

}

if (l > spd_h) {

l = spd_h;

}

if (k < spd_h) {

BYTE* am = &pAlphaMask[k * spd_w];

int j = k;

for (; j < l; j++, a += da) {

for (ptrdiff_t i = 0; i < spd_w; i++, am++) {

*am = BYTE(((*am) * a) >> 14);

}

}

ZeroMemory(am, (spd_h - j)*spd_w);

}

} else if (m_effectType == EF_BANNER) {

int width = m_effect.param[2];

int spd_w = m_size.cx, spd_h = m_size.cy;

int da = (64 << 8) / width;

BYTE* am = pAlphaMask;

for (ptrdiff_t j = 0; j < spd_h; j++, am += spd_w) {

int a = 0;

int k = std::min(width, spd_w);

for (ptrdiff_t i = 0; i < k; i++, a += da) {

am[i] = BYTE((am[i] * a) >> 14);

}

a = 0x40 << 8;

k = spd_w - width;

if (k < 0) {

a -= -k * da;

k = 0;

}

for (ptrdiff_t i = k; i < spd_w; i++, a -= da) {

am[i] = BYTE((am[i] * a) >> 14);

}

}

}

m_renderingCaches.alphaMaskCache.SetAt(key, m_pAlphaMask);

return m_pAlphaMask;

{

POSITION pos = GetHeadPosition();

while (pos) {

CWord* w = GetNext(pos);

if (!w->m_fWhiteSpaceChar) {

break;

}

m_width -= w->m_width;

delete w;

RemoveHead();

}

pos = GetTailPosition();

while (pos) {