mirror of
https://github.com/ONLYOFFICE/core.git
synced 2026-04-07 13:55:33 +08:00
970 lines
26 KiB
C++
970 lines
26 KiB
C++
/*
|
||
* (c) Copyright Ascensio System SIA 2010-2018
|
||
*
|
||
* This program is a free software product. You can redistribute it and/or
|
||
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
||
* version 3 as published by the Free Software Foundation. In accordance with
|
||
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
|
||
* that Ascensio System SIA expressly excludes the warranty of non-infringement
|
||
* of any third-party rights.
|
||
*
|
||
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
||
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
||
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
||
*
|
||
* You can contact Ascensio System SIA at Lubanas st. 125a-25, Riga, Latvia,
|
||
* EU, LV-1021.
|
||
*
|
||
* The interactive user interfaces in modified source and object code versions
|
||
* of the Program must display Appropriate Legal Notices, as required under
|
||
* Section 5 of the GNU AGPL version 3.
|
||
*
|
||
* Pursuant to Section 7(b) of the License you must retain the original Product
|
||
* logo when distributing the program. Pursuant to Section 7(e) we decline to
|
||
* grant you any rights under trademark law for use of our trademarks.
|
||
*
|
||
* All the Product's GUI elements, including illustrations and icon sets, as
|
||
* well as technical writing content are licensed under the terms of the
|
||
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
|
||
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
||
*
|
||
*/
|
||
#pragma once
|
||
|
||
#include "./MetafileToRendererCheck.h"
|
||
#include "agg_math.h"
|
||
|
||
#if !defined(_WIN32) && !defined(_WIN64)
|
||
#include "../common/String.h"
|
||
#endif
|
||
|
||
IMetafileToRenderter::IMetafileToRenderter(IRenderer* pRenderer)
|
||
{
|
||
m_pRenderer = pRenderer;
|
||
}
|
||
void IMetafileToRenderter::EnableBrushRect(bool bValue)
|
||
{
|
||
}
|
||
void IMetafileToRenderter::SetLinearGradiant(const double& x0, const double& y0, const double& x1, const double& y1)
|
||
{
|
||
double dAngle = 0;
|
||
if (fabs(x1 - x0) >= FLT_EPSILON || fabs(y1 - y0) >= FLT_EPSILON)
|
||
dAngle = 180 * atan2(y1 - y0, x1 - x0) / agg::pi;
|
||
|
||
m_pRenderer->put_BrushType(/*c_BrushTypePathGradient1*/2006);
|
||
m_pRenderer->put_BrushLinearAngle(dAngle);
|
||
}
|
||
|
||
void IMetafileToRenderter::SetRadialGradiant(const double& dX0, const double& dY0, const double& dR0, const double& dX1, const double& dY1, const double& dR1)
|
||
{
|
||
// TODO:
|
||
m_pRenderer->put_BrushType(/*c_BrushTypePathGradient2*/2007);
|
||
}
|
||
|
||
namespace NSOnlineOfficeBinToPdf
|
||
{
|
||
inline INT32 ReadInt(BYTE*& pData, int& nOffset)
|
||
{
|
||
#ifdef _ARM_ALIGN_
|
||
INT32 ret = 0;
|
||
memcpy(&ret, pData, sizeof(INT32));
|
||
pData += 4;
|
||
nOffset += 4;
|
||
return ret;
|
||
#else
|
||
INT32 ret = *((INT32*)pData);
|
||
pData += 4;
|
||
nOffset += 4;
|
||
return ret;
|
||
#endif
|
||
}
|
||
inline void SkipInt(BYTE*& pData, int& nOffset, int nCount = 1)
|
||
{
|
||
pData += (nCount << 2);
|
||
nOffset += (nCount << 2);
|
||
}
|
||
|
||
inline USHORT ReadUSHORT(BYTE*& pData, int& nOffset)
|
||
{
|
||
#ifdef _ARM_ALIGN_
|
||
USHORT ret = 0;
|
||
memcpy(&ret, pData, sizeof(USHORT));
|
||
pData += 2;
|
||
nOffset += 2;
|
||
return ret;
|
||
#else
|
||
USHORT ret = *((USHORT*)pData);
|
||
pData += 2;
|
||
nOffset += 2;
|
||
return ret;
|
||
#endif
|
||
}
|
||
inline void SkipUSHORT(BYTE*& pData, int& nOffset)
|
||
{
|
||
pData += 2;
|
||
nOffset += 2;
|
||
}
|
||
|
||
inline std::wstring ReadString16(BYTE*& pData, int& nOffset, int nLen)
|
||
{
|
||
std::wstring wsTempString;
|
||
#ifdef _ARM_ALIGN_
|
||
|
||
if (sizeof(wchar_t) == 4)
|
||
{
|
||
#if !defined(_WIN32) && !defined(_WIN64)
|
||
int len = nLen / 2;
|
||
unsigned short* buf = new unsigned short[len];
|
||
memcpy(buf, pData, nLen);
|
||
wsTempString = NSStringExt::CConverter::GetUnicodeFromUTF16((unsigned short*)buf, len);
|
||
RELEASEARRAYOBJECTS(buf);
|
||
#endif
|
||
}
|
||
else
|
||
{
|
||
int len = nLen / 2;
|
||
wchar_t* buf = new wchar_t[len];
|
||
memcpy(buf, pData, nLen);
|
||
wsTempString = std::wstring(buf, len);
|
||
RELEASEARRAYOBJECTS(buf);
|
||
}
|
||
|
||
#else
|
||
|
||
if (sizeof(wchar_t) == 4)
|
||
{
|
||
#if !defined(_WIN32) && !defined(_WIN64)
|
||
wsTempString = NSStringExt::CConverter::GetUnicodeFromUTF16((unsigned short*)pData, nLen / 2);
|
||
#endif
|
||
}
|
||
else
|
||
{
|
||
wsTempString = std::wstring((wchar_t*)pData, nLen / 2);
|
||
}
|
||
|
||
#endif
|
||
pData += nLen;
|
||
nOffset += nLen;
|
||
return wsTempString;
|
||
}
|
||
inline void SkipString16(BYTE*& pData, int& nOffset, int nLen)
|
||
{
|
||
pData += nLen;
|
||
nOffset += nLen;
|
||
}
|
||
|
||
bool ConvertBufferToRenderer(BYTE* pBuffer, LONG lBufferLen, IMetafileToRenderter* pCorrector)
|
||
{
|
||
IRenderer* pRenderer = pCorrector->m_pRenderer;
|
||
|
||
LONG lRendererType = 0;
|
||
pRenderer->get_Type(&lRendererType);
|
||
|
||
CommandType eCommand = ctError;
|
||
|
||
bool bIsPathOpened = false;
|
||
int curindex = 0;
|
||
|
||
BYTE* current = pBuffer;
|
||
while (curindex < lBufferLen)
|
||
{
|
||
eCommand = (CommandType)(*current);
|
||
current++;
|
||
curindex++;
|
||
switch (eCommand)
|
||
{
|
||
case ctPageWidth:
|
||
{
|
||
pRenderer->put_Width(ReadInt(current, curindex) / 100000.0);
|
||
break;
|
||
}
|
||
case ctPageHeight:
|
||
{
|
||
pRenderer->put_Height(ReadInt(current, curindex) / 100000.0);
|
||
break;
|
||
}
|
||
case ctPageStart:
|
||
{
|
||
pRenderer->NewPage();
|
||
pRenderer->BeginCommand(c_nPageType);
|
||
|
||
// TODO:
|
||
pRenderer->put_PenLineStartCap(Aggplus::LineCapFlat);
|
||
pRenderer->put_PenLineEndCap(Aggplus::LineCapFlat);
|
||
break;
|
||
}
|
||
case ctPageEnd:
|
||
{
|
||
if (bIsPathOpened)
|
||
{
|
||
pRenderer->PathCommandEnd();
|
||
pRenderer->EndCommand(c_nPathType);
|
||
}
|
||
bIsPathOpened = false;
|
||
|
||
pRenderer->EndCommand(c_nPageType);
|
||
|
||
if (lRendererType == c_nGrRenderer)
|
||
return true;
|
||
|
||
break;
|
||
}
|
||
case ctPenColor:
|
||
{
|
||
pRenderer->put_PenColor(ReadInt(current, curindex));
|
||
break;
|
||
}
|
||
case ctPenAlpha:
|
||
{
|
||
pRenderer->put_PenAlpha(*current);
|
||
current++;
|
||
curindex++;
|
||
break;
|
||
}
|
||
case ctPenSize:
|
||
{
|
||
pRenderer->put_PenSize(ReadInt(current, curindex) / 100000.0);
|
||
break;
|
||
}
|
||
case ctPenDashStyle:
|
||
{
|
||
BYTE nDashType = *current++;
|
||
curindex++;
|
||
switch (nDashType)
|
||
{
|
||
case Aggplus::DashStyleCustom:
|
||
{
|
||
int nCountDash = ReadInt(current, curindex);
|
||
if (0 < nCountDash)
|
||
{
|
||
double* pDash = new double[nCountDash];
|
||
for (int nDash = 0; nDash < nCountDash; ++nDash)
|
||
{
|
||
pDash[nDash] = ReadInt(current, curindex) / 100000.0;
|
||
}
|
||
|
||
if (c_nGrRenderer == lRendererType)
|
||
{
|
||
for (int nDash = 0; nDash < nCountDash; ++nDash)
|
||
{
|
||
// в отрисовщике - баг. зачем-то умножается на коеф 25.4/dpi
|
||
// чтобы не менять там (перед выпуском) - умножаю здесь на обратку
|
||
double dDpiX = 0;
|
||
pRenderer->get_DpiX(&dDpiX);
|
||
pDash[nDash] *= (dDpiX / 25.4);
|
||
}
|
||
}
|
||
|
||
pRenderer->PenDashPattern(pDash, nCountDash);
|
||
delete[] pDash;
|
||
}
|
||
}
|
||
default:
|
||
pRenderer->put_PenDashStyle(nDashType);
|
||
break;
|
||
}
|
||
|
||
break;
|
||
}
|
||
case ctPenLineJoin:
|
||
{
|
||
pRenderer->put_PenLineJoin(*current);
|
||
current++;
|
||
curindex++;
|
||
break;
|
||
}
|
||
case ctBrushType:
|
||
{
|
||
pRenderer->put_BrushType(ReadInt(current, curindex));
|
||
break;
|
||
}
|
||
case ctBrushColor1:
|
||
{
|
||
pRenderer->put_BrushColor1(ReadInt(current, curindex));
|
||
break;
|
||
}
|
||
case ctBrushAlpha1:
|
||
{
|
||
pRenderer->put_BrushAlpha1(*current);
|
||
current++;
|
||
curindex++;
|
||
break;
|
||
}
|
||
case ctBrushColor2:
|
||
{
|
||
pRenderer->put_BrushColor1(ReadInt(current, curindex));
|
||
break;
|
||
}
|
||
case ctBrushAlpha2:
|
||
{
|
||
pRenderer->put_BrushAlpha2(*current);
|
||
current++;
|
||
curindex++;
|
||
break;
|
||
}
|
||
case ctBrushRectable:
|
||
{
|
||
double m1 = ReadInt(current, curindex) / 100000.0;
|
||
double m2 = ReadInt(current, curindex) / 100000.0;
|
||
double m3 = ReadInt(current, curindex) / 100000.0;
|
||
double m4 = ReadInt(current, curindex) / 100000.0;
|
||
pRenderer->BrushRect(0, m1, m2, m3, m4);
|
||
break;
|
||
}
|
||
case ctBrushRectableEnabled:
|
||
{
|
||
bool bEnable = (1 == *current) ? true : false;
|
||
pCorrector->EnableBrushRect(bEnable);
|
||
|
||
current += 1;
|
||
curindex += 1;
|
||
break;
|
||
}
|
||
case ctBrushTexturePath:
|
||
{
|
||
int nLen = 2 * ReadUSHORT(current, curindex);
|
||
std::wstring sTempPath = ReadString16(current, curindex, nLen);
|
||
|
||
std::wstring sImagePath = pCorrector->GetImagePath(sTempPath);
|
||
pRenderer->put_BrushTexturePath(sImagePath);
|
||
break;
|
||
}
|
||
case ctBrushGradient:
|
||
{
|
||
current++;
|
||
curindex++;
|
||
|
||
while (true)
|
||
{
|
||
BYTE _command = *current;
|
||
current++;
|
||
curindex++;
|
||
|
||
if (251 == _command)
|
||
break;
|
||
|
||
switch (_command)
|
||
{
|
||
case 0:
|
||
{
|
||
current += 5;
|
||
curindex += 5;
|
||
double x0 = ReadInt(current, curindex) / 100000.0;
|
||
double y0 = ReadInt(current, curindex) / 100000.0;
|
||
double x1 = ReadInt(current, curindex) / 100000.0;
|
||
double y1 = ReadInt(current, curindex) / 100000.0;
|
||
|
||
pCorrector->SetLinearGradiant(x0, y0, x1, y1);
|
||
break;
|
||
}
|
||
case 1:
|
||
{
|
||
current++;
|
||
curindex++;
|
||
double x0 = ReadInt(current, curindex) / 100000.0;
|
||
double y0 = ReadInt(current, curindex) / 100000.0;
|
||
double x1 = ReadInt(current, curindex) / 100000.0;
|
||
double y1 = ReadInt(current, curindex) / 100000.0;
|
||
double r0 = ReadInt(current, curindex) / 100000.0;
|
||
double r1 = ReadInt(current, curindex) / 100000.0;
|
||
pCorrector->SetRadialGradiant(x0, y0, r0, x1, y1, r1);
|
||
break;
|
||
}
|
||
case 2:
|
||
{
|
||
LONG lColorsCount = (LONG)ReadInt(current, curindex);
|
||
if (0 >= lColorsCount)
|
||
{
|
||
pRenderer->put_BrushGradientColors(NULL, NULL, 0);
|
||
}
|
||
else
|
||
{
|
||
LONG* pColors = new LONG[lColorsCount];
|
||
double* pPositions = new double[lColorsCount];
|
||
|
||
if (!pColors)
|
||
break;
|
||
|
||
if (!pPositions)
|
||
{
|
||
delete[] pColors;
|
||
break;
|
||
}
|
||
|
||
for (LONG lIndex = 0; lIndex < lColorsCount; lIndex++)
|
||
{
|
||
pPositions[lIndex] = ReadInt(current, curindex) / 100000.0;
|
||
pColors[lIndex] = ReadInt(current, curindex);
|
||
}
|
||
|
||
pRenderer->put_BrushGradientColors(pColors, pPositions, lColorsCount);
|
||
|
||
delete[] pColors;
|
||
delete[] pPositions;
|
||
}
|
||
|
||
break;
|
||
}
|
||
default:
|
||
{
|
||
break;
|
||
}
|
||
};
|
||
}
|
||
|
||
break;
|
||
}
|
||
case ctBrushTextureMode:
|
||
{
|
||
LONG lMode = (LONG)(*current);
|
||
pRenderer->put_BrushTextureMode(lMode);
|
||
|
||
current += 1;
|
||
curindex += 1;
|
||
break;
|
||
}
|
||
case ctBrushTextureAlpha:
|
||
{
|
||
LONG lAlpha = (LONG)(*current);
|
||
pRenderer->put_BrushTextureAlpha(lAlpha);
|
||
|
||
current += 1;
|
||
curindex += 1;
|
||
break;
|
||
}
|
||
case ctSetTransform:
|
||
{
|
||
double m1 = ReadInt(current, curindex) / 100000.0;
|
||
double m2 = ReadInt(current, curindex) / 100000.0;
|
||
double m3 = ReadInt(current, curindex) / 100000.0;
|
||
double m4 = ReadInt(current, curindex) / 100000.0;
|
||
double m5 = ReadInt(current, curindex) / 100000.0;
|
||
double m6 = ReadInt(current, curindex) / 100000.0;
|
||
pRenderer->SetTransform(m1, m2, m3, m4, m5, m6);
|
||
break;
|
||
}
|
||
case ctPathCommandStart:
|
||
{
|
||
if (bIsPathOpened)
|
||
{
|
||
pRenderer->PathCommandEnd();
|
||
pRenderer->EndCommand(c_nPathType);
|
||
}
|
||
|
||
pRenderer->BeginCommand(c_nPathType);
|
||
pRenderer->PathCommandStart();
|
||
|
||
bIsPathOpened = true;
|
||
break;
|
||
}
|
||
case ctPathCommandMoveTo:
|
||
{
|
||
double m1 = ReadInt(current, curindex) / 100000.0;
|
||
double m2 = ReadInt(current, curindex) / 100000.0;
|
||
pRenderer->PathCommandMoveTo(m1, m2);
|
||
break;
|
||
}
|
||
case ctPathCommandLineTo:
|
||
{
|
||
double m1 = ReadInt(current, curindex) / 100000.0;
|
||
double m2 = ReadInt(current, curindex) / 100000.0;
|
||
pRenderer->PathCommandLineTo(m1, m2);
|
||
break;
|
||
}
|
||
case ctPathCommandCurveTo:
|
||
{
|
||
double m1 = ReadInt(current, curindex) / 100000.0;
|
||
double m2 = ReadInt(current, curindex) / 100000.0;
|
||
double m3 = ReadInt(current, curindex) / 100000.0;
|
||
double m4 = ReadInt(current, curindex) / 100000.0;
|
||
double m5 = ReadInt(current, curindex) / 100000.0;
|
||
double m6 = ReadInt(current, curindex) / 100000.0;
|
||
pRenderer->PathCommandCurveTo(m1, m2, m3, m4, m5, m6);
|
||
break;
|
||
}
|
||
case ctPathCommandClose:
|
||
{
|
||
pRenderer->PathCommandClose();
|
||
break;
|
||
}
|
||
case ctPathCommandEnd:
|
||
{
|
||
if (bIsPathOpened)
|
||
{
|
||
pRenderer->PathCommandEnd();
|
||
pRenderer->EndCommand(c_nPathType);
|
||
bIsPathOpened = false;
|
||
}
|
||
break;
|
||
}
|
||
case ctDrawPath:
|
||
{
|
||
pRenderer->DrawPath(ReadInt(current, curindex));
|
||
break;
|
||
}
|
||
case ctDrawImageFromFile:
|
||
{
|
||
int nLen = ReadInt(current, curindex);
|
||
std::wstring sTempPath = ReadString16(current, curindex, nLen);
|
||
std::wstring sImagePath = pCorrector->GetImagePath(sTempPath);
|
||
|
||
double m1 = ReadInt(current, curindex) / 100000.0;
|
||
double m2 = ReadInt(current, curindex) / 100000.0;
|
||
double m3 = ReadInt(current, curindex) / 100000.0;
|
||
double m4 = ReadInt(current, curindex) / 100000.0;
|
||
|
||
try
|
||
{
|
||
pRenderer->DrawImageFromFile(sImagePath, m1, m2, m3, m4);
|
||
}
|
||
catch (...)
|
||
{
|
||
}
|
||
|
||
break;
|
||
}
|
||
case ctFontName:
|
||
{
|
||
int _sLen = 2 * (int)ReadUSHORT(current, curindex);
|
||
std::wstring wsTempString = ReadString16(current, curindex, _sLen);
|
||
pRenderer->put_FontName(wsTempString);
|
||
break;
|
||
}
|
||
case ctFontSize:
|
||
{
|
||
double m1 = ReadInt(current, curindex) / 100000.0;
|
||
pRenderer->put_FontSize(m1);
|
||
break;
|
||
}
|
||
case ctFontStyle:
|
||
{
|
||
pRenderer->put_FontStyle(ReadInt(current, curindex));
|
||
break;
|
||
}
|
||
case ctDrawText:
|
||
{
|
||
int _sLen = 2 * (int)ReadUSHORT(current, curindex);
|
||
std::wstring wsTempString = ReadString16(current, curindex, _sLen);
|
||
|
||
double m1 = ReadInt(current, curindex) / 100000.0;
|
||
double m2 = ReadInt(current, curindex) / 100000.0;
|
||
|
||
pRenderer->CommandDrawText(wsTempString, m1, m2, 0, 0);
|
||
break;
|
||
}
|
||
case ctBeginCommand:
|
||
{
|
||
if (bIsPathOpened)
|
||
{
|
||
pRenderer->PathCommandEnd();
|
||
pRenderer->EndCommand(4);
|
||
bIsPathOpened = false;
|
||
}
|
||
pRenderer->BeginCommand((DWORD)(ReadInt(current, curindex)));
|
||
break;
|
||
}
|
||
case ctEndCommand:
|
||
{
|
||
if (bIsPathOpened)
|
||
{
|
||
pRenderer->EndCommand(4);
|
||
bIsPathOpened = false;
|
||
}
|
||
pRenderer->EndCommand((DWORD)(ReadInt(current, curindex)));
|
||
pRenderer->PathCommandEnd();
|
||
break;
|
||
}
|
||
case ctGradientFill:
|
||
{
|
||
// TODO: Эта команда не должна приходить
|
||
INT32 gradientType = ReadInt(current, curindex);
|
||
|
||
std::wstring sXml, sXmlStop;
|
||
if (0 == gradientType) // linearGradient
|
||
{
|
||
double x1 = ReadInt(current, curindex) / 100000.0;
|
||
double x2 = ReadInt(current, curindex) / 100000.0;
|
||
double y1 = ReadInt(current, curindex) / 100000.0;
|
||
double y2 = ReadInt(current, curindex) / 100000.0;
|
||
|
||
int stops = ReadInt(current, curindex);
|
||
|
||
for (int i = 0; i < stops; ++i)
|
||
{
|
||
INT32 color = static_cast<INT32>(*current);
|
||
double opacity = static_cast<double>(static_cast<INT32>(*(current + 1))) / 255.0;
|
||
double offset = static_cast<double>(static_cast<INT32>(*(current + 2))) / 255.0;
|
||
|
||
current += 6 * 4; // 4 + 1 + 1
|
||
curindex += 6 * 4;
|
||
}
|
||
}
|
||
else if (1 == gradientType)
|
||
{
|
||
double cx = ReadInt(current, curindex) / 100000.0;
|
||
double cy = ReadInt(current, curindex) / 100000.0;
|
||
double r = ReadInt(current, curindex) / 100000.0;
|
||
double fx = ReadInt(current, curindex) / 100000.0;
|
||
double fy = ReadInt(current, curindex) / 100000.0;
|
||
|
||
int stops = ReadInt(current, curindex);
|
||
|
||
for (int i = 0; i < stops; ++i)
|
||
{
|
||
INT32 color = static_cast<INT32>(*current);
|
||
double opacity = static_cast<double>(static_cast<INT32>(*(current + 1))) / 255.0;
|
||
double offset = static_cast<double>(static_cast<INT32>(*(current + 2))) / 255.0;
|
||
|
||
current += 6 * 4; // 4 + 1 + 1
|
||
curindex += 6 * 4;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case ctGradientFillXML:
|
||
{
|
||
// TODO: Эта команда не должна приходить
|
||
INT32 gradientType = ReadInt(current, curindex);
|
||
int _sLen = ReadInt(current, curindex);
|
||
std::wstring wsTempString = ReadString16(current, curindex, _sLen);
|
||
break;
|
||
}
|
||
case ctGradientStroke:
|
||
{
|
||
// TODO: Эта команда не должна приходить
|
||
INT32 gradientType = ReadInt(current, curindex);
|
||
if (0 == gradientType) // linearGradient
|
||
{
|
||
double x1 = ReadInt(current, curindex) / 100000.0;
|
||
double x2 = ReadInt(current, curindex) / 100000.0;
|
||
double y1 = ReadInt(current, curindex) / 100000.0;
|
||
double y2 = ReadInt(current, curindex) / 100000.0;
|
||
int stops = ReadInt(current, curindex);
|
||
|
||
for (int i = 0; i < stops; ++i)
|
||
{
|
||
INT32 color = static_cast<INT32>(*current);
|
||
double opacity = static_cast<double>(static_cast<INT32>(*(current + 1))) / 255.0;
|
||
double offset = static_cast<double>(static_cast<INT32>(*(current + 2))) / 255.0;
|
||
|
||
current += 6 * 4; // 4 + 1 + 1
|
||
curindex += 6 * 4;
|
||
}
|
||
}
|
||
else if (1 == gradientType)
|
||
{
|
||
double cx = ReadInt(current, curindex) / 100000.0;
|
||
double cy = ReadInt(current, curindex) / 100000.0;
|
||
double r = ReadInt(current, curindex) / 100000.0;
|
||
double fx = ReadInt(current, curindex) / 100000.0;
|
||
double fy = ReadInt(current, curindex) / 100000.0;
|
||
int stops = ReadInt(current, curindex);
|
||
|
||
for (int i = 0; i < stops; ++i)
|
||
{
|
||
INT32 color = static_cast<INT32>(*current);
|
||
double opacity = static_cast<double>(static_cast<INT32>(*(current + 1))) / 255.0;
|
||
double offset = static_cast<double>(static_cast<INT32>(*(current + 2))) / 255.0;
|
||
|
||
current += 6 * 4; // 4 + 1 + 1
|
||
curindex += 6 * 4;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case ctGradientStrokeXML:
|
||
{
|
||
// TODO: Эта команда не должна приходить
|
||
INT32 gradientType = ReadInt(current, curindex);
|
||
int _sLen = (int)ReadInt(current, curindex);
|
||
std::wstring wsTempString = ReadString16(current, curindex, _sLen);
|
||
break;
|
||
}
|
||
default:
|
||
{
|
||
break;
|
||
}
|
||
}; // switch (eCommand)
|
||
} // while (curindex < len)
|
||
|
||
return true;
|
||
}
|
||
|
||
void CMetafilePagesInfo::CheckBuffer(BYTE* pBuffer, LONG lBufferLen)
|
||
{
|
||
CommandType eCommand = ctError;
|
||
|
||
bool bIsPathOpened = false;
|
||
int curindex = 0;
|
||
|
||
BYTE* current = pBuffer;
|
||
while (curindex < lBufferLen)
|
||
{
|
||
eCommand = (CommandType)(*current);
|
||
current++;
|
||
curindex++;
|
||
switch (eCommand)
|
||
{
|
||
case ctPageWidth:
|
||
{
|
||
arSizes[PagesCount - 1].width = (ReadInt(current, curindex) / 100000.0);
|
||
break;
|
||
}
|
||
case ctPageHeight:
|
||
{
|
||
arSizes[PagesCount - 1].height = (ReadInt(current, curindex) / 100000.0);
|
||
break;
|
||
}
|
||
case ctPageStart:
|
||
{
|
||
AddPage();
|
||
arSizes[PagesCount - 1].data = current;
|
||
break;
|
||
}
|
||
case ctPageEnd:
|
||
{
|
||
break;
|
||
}
|
||
case ctPenColor:
|
||
{
|
||
SkipInt(current, curindex);
|
||
break;
|
||
}
|
||
case ctPenAlpha:
|
||
{
|
||
current++;
|
||
curindex++;
|
||
break;
|
||
}
|
||
case ctPenSize:
|
||
{
|
||
SkipInt(current, curindex);
|
||
break;
|
||
}
|
||
case ctPenDashStyle:
|
||
{
|
||
BYTE nDashType = *current++;
|
||
curindex++;
|
||
switch (nDashType)
|
||
{
|
||
case Aggplus::DashStyleCustom:
|
||
{
|
||
int nCountDash = ReadInt(current, curindex);
|
||
if (0 < nCountDash)
|
||
{
|
||
SkipInt(current, curindex, nCountDash);
|
||
}
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
|
||
break;
|
||
}
|
||
case ctPenLineJoin:
|
||
{
|
||
current++;
|
||
curindex++;
|
||
break;
|
||
}
|
||
case ctBrushType:
|
||
{
|
||
SkipInt(current, curindex);
|
||
break;
|
||
}
|
||
case ctBrushColor1:
|
||
{
|
||
SkipInt(current, curindex);
|
||
break;
|
||
}
|
||
case ctBrushAlpha1:
|
||
{
|
||
current++;
|
||
curindex++;
|
||
break;
|
||
}
|
||
case ctBrushColor2:
|
||
{
|
||
SkipInt(current, curindex);
|
||
break;
|
||
}
|
||
case ctBrushAlpha2:
|
||
{
|
||
current++;
|
||
curindex++;
|
||
break;
|
||
}
|
||
case ctBrushRectable:
|
||
{
|
||
SkipInt(current, curindex, 4);
|
||
break;
|
||
}
|
||
case ctBrushRectableEnabled:
|
||
{
|
||
current += 1;
|
||
curindex += 1;
|
||
break;
|
||
}
|
||
case ctBrushTexturePath:
|
||
{
|
||
int nLen = 2 * ReadUSHORT(current, curindex);
|
||
SkipString16(current, curindex, nLen);
|
||
break;
|
||
}
|
||
case ctBrushGradient:
|
||
{
|
||
current++;
|
||
curindex++;
|
||
|
||
while (true)
|
||
{
|
||
BYTE _command = *current;
|
||
current++;
|
||
curindex++;
|
||
|
||
if (251 == _command)
|
||
break;
|
||
|
||
switch (_command)
|
||
{
|
||
case 0:
|
||
{
|
||
current += 5;
|
||
curindex += 5;
|
||
SkipInt(current, curindex, 4);
|
||
break;
|
||
}
|
||
case 1:
|
||
{
|
||
current++;
|
||
curindex++;
|
||
SkipInt(current, curindex, 6);
|
||
break;
|
||
}
|
||
case 2:
|
||
{
|
||
LONG lColorsCount = (LONG)ReadInt(current, curindex);
|
||
if (0 <= lColorsCount)
|
||
{
|
||
SkipInt(current, curindex, 2 * lColorsCount);
|
||
}
|
||
|
||
break;
|
||
}
|
||
default:
|
||
{
|
||
break;
|
||
}
|
||
};
|
||
}
|
||
|
||
break;
|
||
}
|
||
case ctBrushTextureMode:
|
||
{
|
||
current += 1;
|
||
curindex += 1;
|
||
break;
|
||
}
|
||
case ctBrushTextureAlpha:
|
||
{
|
||
current += 1;
|
||
curindex += 1;
|
||
break;
|
||
}
|
||
case ctSetTransform:
|
||
{
|
||
SkipInt(current, curindex, 6);
|
||
break;
|
||
}
|
||
case ctPathCommandStart:
|
||
{
|
||
break;
|
||
}
|
||
case ctPathCommandMoveTo:
|
||
{
|
||
SkipInt(current, curindex, 2);
|
||
break;
|
||
}
|
||
case ctPathCommandLineTo:
|
||
{
|
||
SkipInt(current, curindex, 2);
|
||
break;
|
||
}
|
||
case ctPathCommandCurveTo:
|
||
{
|
||
SkipInt(current, curindex, 6);
|
||
break;
|
||
}
|
||
case ctPathCommandClose:
|
||
{
|
||
break;
|
||
}
|
||
case ctPathCommandEnd:
|
||
{
|
||
break;
|
||
}
|
||
case ctDrawPath:
|
||
{
|
||
SkipInt(current, curindex);
|
||
break;
|
||
}
|
||
case ctDrawImageFromFile:
|
||
{
|
||
int nLen = ReadInt(current, curindex);
|
||
SkipString16(current, curindex, nLen);
|
||
|
||
SkipInt(current, curindex, 4);
|
||
break;
|
||
}
|
||
case ctFontName:
|
||
{
|
||
int nLen = 2 * (int)ReadUSHORT(current, curindex);
|
||
SkipString16(current, curindex, nLen);
|
||
break;
|
||
}
|
||
case ctFontSize:
|
||
{
|
||
SkipInt(current, curindex);
|
||
break;
|
||
}
|
||
case ctFontStyle:
|
||
{
|
||
SkipInt(current, curindex);
|
||
break;
|
||
}
|
||
case ctDrawText:
|
||
{
|
||
int nLen = 2 * (int)ReadUSHORT(current, curindex);
|
||
SkipString16(current, curindex, nLen);
|
||
|
||
SkipInt(current, curindex, 2);
|
||
break;
|
||
}
|
||
case ctBeginCommand:
|
||
{
|
||
SkipInt(current, curindex);
|
||
break;
|
||
}
|
||
case ctEndCommand:
|
||
{
|
||
SkipInt(current, curindex);
|
||
break;
|
||
}
|
||
case ctGradientFill:
|
||
case ctGradientFillXML:
|
||
case ctGradientStroke:
|
||
case ctGradientStrokeXML:
|
||
{
|
||
// TODO: Эта команда не должна приходить
|
||
return;
|
||
}
|
||
default:
|
||
{
|
||
break;
|
||
}
|
||
}; // switch (eCommand)
|
||
} // while (curindex < len)
|
||
}
|
||
}
|