mirror of
https://github.com/ONLYOFFICE/core.git
synced 2026-07-11 10:59:17 +08:00
2276da418e
git-svn-id: svn://fileserver/activex/AVS/Sources/TeamlabOffice/trunk/ServerComponents@62078 954022d7-b5bf-4e40-9824-e11837661b57
930 lines
24 KiB
C++
930 lines
24 KiB
C++
#include "ASCSVGWriter.h"
|
||
|
||
#include "../DesktopEditor/graphics/GraphicsPath.h"
|
||
#include "Writer/VectorGraphicsWriter2.h"
|
||
|
||
namespace NSHtmlRenderer
|
||
{
|
||
CASCSVGWriter::CASCSVGWriter()
|
||
{
|
||
m_dDpiX = 96.0;
|
||
m_dDpiY = 96.0;
|
||
|
||
m_dWidth = 100;
|
||
m_dHeight = 100;
|
||
m_bIsRaster = false;
|
||
|
||
m_lClipMode = c_nClipRegionTypeWinding;
|
||
|
||
m_pSimpleGraphicsConverter = new Aggplus::CGraphicsPathSimpleConverter();
|
||
m_pSimpleGraphicsConverter->SetRenderer(this);
|
||
|
||
m_dTransformAngle = 0.0;
|
||
|
||
m_pFontManager = NULL;
|
||
m_bDeleteFontManager = true;
|
||
m_pPen = new NSStructures::CPen();
|
||
m_pBrush = new NSStructures::CBrush();
|
||
m_pFont = new NSStructures::CFont();
|
||
m_pInstalledFont = new NSStructures::CFont();
|
||
|
||
m_pBaseTransform = new Aggplus::CMatrix();
|
||
m_pTransform = new Aggplus::CMatrix();
|
||
m_pFullTransform = new Aggplus::CMatrix();
|
||
|
||
//todo вроде как подбора нет, но может нужно передавать?
|
||
m_pFontManager = new CFontManager();
|
||
m_pFontManager->Initialize();
|
||
|
||
m_pVectorWriter = new NSHtmlRenderer::CSVGGraphicsWriter();
|
||
m_pVectorWriter->m_pSimpleConverter = m_pSimpleGraphicsConverter;
|
||
m_pVectorWriter->m_pFullTransform = m_pFullTransform;
|
||
m_pVectorWriter->SetSettings(m_pPen, m_pBrush, m_pSimpleGraphicsConverter);
|
||
}
|
||
CASCSVGWriter::~CASCSVGWriter()
|
||
{
|
||
RELEASEOBJECT(m_pSimpleGraphicsConverter);
|
||
if(m_bDeleteFontManager)
|
||
RELEASEOBJECT(m_pFontManager);
|
||
RELEASEOBJECT(m_pPen);
|
||
RELEASEOBJECT(m_pBrush);
|
||
RELEASEOBJECT(m_pFont);
|
||
RELEASEOBJECT(m_pInstalledFont);
|
||
RELEASEOBJECT(m_pBaseTransform);
|
||
RELEASEOBJECT(m_pTransform);
|
||
RELEASEOBJECT(m_pFullTransform);
|
||
RELEASEOBJECT(m_pVectorWriter);
|
||
}
|
||
|
||
HRESULT CASCSVGWriter::get_Type(LONG* lType)
|
||
{
|
||
if (NULL == lType)
|
||
return S_FALSE;
|
||
|
||
*lType = c_nSVGRendrerer;
|
||
return S_OK;
|
||
}
|
||
//-------- Функции для работы со страницей --------------------------------------------------
|
||
HRESULT CASCSVGWriter::NewPage()
|
||
{
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_Height(double* dHeight)
|
||
{
|
||
*dHeight = m_dHeight;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_Height(const double& dHeight)
|
||
{
|
||
m_dHeight = dHeight;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_Width(double* dWidth)
|
||
{
|
||
*dWidth = m_dWidth;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_Width(const double& dWidth)
|
||
{
|
||
m_dWidth = dWidth;
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT CASCSVGWriter::get_DpiX(double* dDpiX)
|
||
{
|
||
if (NULL != dDpiX)
|
||
*dDpiX = m_dDpiX;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_DpiY(double* dDpiY)
|
||
{
|
||
if (NULL != dDpiY)
|
||
*dDpiY = m_dDpiY;
|
||
return S_OK;
|
||
}
|
||
// pen --------------------------------------------------------------------------------------
|
||
HRESULT CASCSVGWriter::get_PenColor(LONG* lColor)
|
||
{
|
||
*lColor = m_pPen->Color;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_PenColor(const LONG& lColor)
|
||
{
|
||
m_pPen->Color = lColor;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_PenAlpha(LONG* lAlpha)
|
||
{
|
||
*lAlpha = m_pPen->Alpha;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_PenAlpha(const LONG& lAlpha)
|
||
{
|
||
m_pPen->Alpha = lAlpha;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_PenSize(double* dSize)
|
||
{
|
||
*dSize = m_pPen->Size;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_PenSize(const double& dSize)
|
||
{
|
||
m_pPen->Size = dSize;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_PenDashStyle(BYTE* val)
|
||
{
|
||
*val = m_pPen->DashStyle;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_PenDashStyle(const BYTE& val)
|
||
{
|
||
m_pPen->DashStyle = val;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_PenLineStartCap(BYTE* val)
|
||
{
|
||
*val = m_pPen->LineStartCap;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_PenLineStartCap(const BYTE& val)
|
||
{
|
||
m_pPen->LineStartCap = val;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_PenLineEndCap(BYTE* val)
|
||
{
|
||
*val = m_pPen->LineEndCap;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_PenLineEndCap(const BYTE& val)
|
||
{
|
||
m_pPen->LineEndCap = val;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_PenLineJoin(BYTE* val)
|
||
{
|
||
*val = m_pPen->LineJoin;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_PenLineJoin(const BYTE& val)
|
||
{
|
||
m_pPen->LineJoin = val;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_PenDashOffset(double* val)
|
||
{
|
||
*val = m_pPen->DashOffset;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_PenDashOffset(const double& val)
|
||
{
|
||
m_pPen->DashOffset = val;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_PenAlign(LONG* val)
|
||
{
|
||
*val = m_pPen->Align;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_PenAlign(const LONG& val)
|
||
{
|
||
m_pPen->Align = val;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_PenMiterLimit(double* val)
|
||
{
|
||
*val = m_pPen->MiterLimit;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_PenMiterLimit(const double& val)
|
||
{
|
||
m_pPen->MiterLimit = val;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::PenDashPattern(double* pPattern, LONG lCount)
|
||
{
|
||
if (NULL != pPattern)
|
||
{
|
||
m_pPen->SetDashPattern(pPattern, lCount);
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
// brush ------------------------------------------------------------------------------------
|
||
HRESULT CASCSVGWriter::get_BrushType(LONG* lType)
|
||
{
|
||
*lType = m_pBrush->Type;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_BrushType(const LONG& lType)
|
||
{
|
||
m_pBrush->Type = lType;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_BrushColor1(LONG* lColor)
|
||
{
|
||
*lColor = m_pBrush->Color1;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_BrushColor1(const LONG& lColor)
|
||
{
|
||
m_pBrush->Color1 = lColor;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_BrushAlpha1(LONG* lAlpha)
|
||
{
|
||
*lAlpha = m_pBrush->Alpha1;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_BrushAlpha1(const LONG& lAlpha)
|
||
{
|
||
m_pBrush->Alpha1 = lAlpha;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_BrushColor2(LONG* lColor)
|
||
{
|
||
*lColor = m_pBrush->Color2;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_BrushColor2(const LONG& lColor)
|
||
{
|
||
m_pBrush->Color2 = lColor;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_BrushAlpha2(LONG* lAlpha)
|
||
{
|
||
*lAlpha = m_pBrush->Alpha2;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_BrushAlpha2(const LONG& lAlpha)
|
||
{
|
||
m_pBrush->Alpha2 = lAlpha;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_BrushTexturePath(std::wstring* bsPath)
|
||
{
|
||
*bsPath = m_pBrush->TexturePath;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_BrushTexturePath(const std::wstring& bsPath)
|
||
{
|
||
m_pBrush->TexturePath = bsPath;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_BrushTextureMode(LONG* lMode)
|
||
{
|
||
*lMode = m_pBrush->TextureMode;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_BrushTextureMode(const LONG& lMode)
|
||
{
|
||
m_pBrush->TextureMode = lMode;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_BrushTextureAlpha(LONG* lTxAlpha)
|
||
{
|
||
*lTxAlpha = m_pBrush->TextureAlpha;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_BrushTextureAlpha(const LONG& lTxAlpha)
|
||
{
|
||
m_pBrush->TextureAlpha = lTxAlpha;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_BrushLinearAngle(double* dAngle)
|
||
{
|
||
*dAngle = m_pBrush->LinearAngle;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_BrushLinearAngle(const double& dAngle)
|
||
{
|
||
m_pBrush->LinearAngle = dAngle;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::BrushRect(const INT& val, const double& left, const double& top, const double& width, const double& height)
|
||
{
|
||
m_pBrush->Rectable = val;
|
||
m_pBrush->Rect.X = (float)left;
|
||
m_pBrush->Rect.Y = (float)top;
|
||
m_pBrush->Rect.Width = (float)width;
|
||
m_pBrush->Rect.Height = (float)height;
|
||
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::BrushBounds(const double& left, const double& top, const double& width, const double& height)
|
||
{
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT CASCSVGWriter::put_BrushGradientColors(LONG* lColors, double* pPositions, LONG nCount)
|
||
{
|
||
return S_OK;
|
||
}
|
||
|
||
// font -------------------------------------------------------------------------------------
|
||
HRESULT CASCSVGWriter::get_FontName(std::wstring* bsName)
|
||
{
|
||
*bsName = m_pFont->Name;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_FontName(const std::wstring& bsName)
|
||
{
|
||
m_pFont->Name = bsName;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_FontPath(std::wstring* bsName)
|
||
{
|
||
*bsName = m_pFont->Path;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_FontPath(const std::wstring& bsName)
|
||
{
|
||
m_pFont->Path = bsName;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_FontSize(double* dSize)
|
||
{
|
||
*dSize = m_pFont->Size;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_FontSize(const double& dSize)
|
||
{
|
||
m_pFont->Size = dSize;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_FontStyle(LONG* lStyle)
|
||
{
|
||
*lStyle = m_pFont->GetStyle();
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_FontStyle(const LONG& lStyle)
|
||
{
|
||
m_pFont->SetStyle(lStyle);
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_FontStringGID(INT* bGID)
|
||
{
|
||
*bGID = m_pFont->StringGID;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_FontStringGID(const INT& bGID)
|
||
{
|
||
m_pFont->StringGID = bGID;
|
||
m_pFontManager->SetStringGID(bGID);
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_FontCharSpace(double* dSpace)
|
||
{
|
||
*dSpace = m_pFont->CharSpace;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_FontCharSpace(const double& dSpace)
|
||
{
|
||
m_pFont->CharSpace = dSpace;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::get_FontFaceIndex(int* lFaceIndex)
|
||
{
|
||
*lFaceIndex = m_pFont->FaceIndex;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_FontFaceIndex(const int& lFaceIndex)
|
||
{
|
||
m_pFont->FaceIndex = lFaceIndex;
|
||
return S_OK;
|
||
}
|
||
//-------- Функции для вывода текста --------------------------------------------------------
|
||
HRESULT CASCSVGWriter::CommandDrawTextCHAR(const LONG& c, const double& x, const double& y, const double& w, const double& h, const double& baselineOffset)
|
||
{
|
||
//todo new command
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::CommandDrawText(const std::wstring& bsText, const double& x, const double& y, const double& w, const double& h, const double& baselineOffset)
|
||
{
|
||
if (c_nHyperlinkType == m_lCurrentCommandType)
|
||
return S_OK;
|
||
|
||
if (m_bIsRaster)
|
||
return S_OK;
|
||
|
||
PathCommandEnd();
|
||
BeginCommand(c_nPathType);
|
||
PathCommandText(bsText, x, y, w, h, baselineOffset);
|
||
DrawPath(c_nWindingFillMode);
|
||
EndCommand(c_nPathType);
|
||
PathCommandEnd();
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::CommandDrawTextExCHAR(const LONG& c, const LONG& gid, const double& x, const double& y, const double& w, const double& h, const double& baselineOffset, const DWORD& lFlags)
|
||
{
|
||
//todo new command
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::CommandDrawTextEx(const std::wstring& bsUnicodeText, const std::wstring& bsGidText, const double& x, const double& y, const double& w, const double& h, const double& baselineOffset, const DWORD& lFlags)
|
||
{
|
||
if (m_bIsRaster)
|
||
return S_OK;
|
||
|
||
PathCommandEnd();
|
||
BeginCommand(c_nPathType);
|
||
PathCommandTextEx(bsUnicodeText, bsGidText, x, y, w, h, baselineOffset, lFlags);
|
||
DrawPath(c_nWindingFillMode);
|
||
EndCommand(c_nPathType);
|
||
PathCommandEnd();
|
||
return S_OK;
|
||
}
|
||
//-------- Маркеры для команд ---------------------------------------------------------------
|
||
HRESULT CASCSVGWriter::BeginCommand(const DWORD& lType)
|
||
{
|
||
if (m_bIsRaster)
|
||
return S_OK;
|
||
|
||
if (c_nClipType == lType)
|
||
{
|
||
m_pVectorWriter->WritePathClip();
|
||
}
|
||
else if (c_nPathType == lType)
|
||
{
|
||
m_pVectorWriter->WritePathStart();
|
||
m_pSimpleGraphicsConverter->PathCommandEnd();
|
||
}
|
||
m_lCurrentCommandType = lType;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::EndCommand(const DWORD& lType)
|
||
{
|
||
if (m_bIsRaster)
|
||
return S_OK;
|
||
|
||
if (c_nClipType == lType)
|
||
{
|
||
m_pVectorWriter->WritePathClipEnd();
|
||
}
|
||
else if (c_nResetClipType == lType)
|
||
{
|
||
m_pVectorWriter->WritePathResetClip();
|
||
}
|
||
m_lCurrentCommandType = -1;
|
||
return S_OK;
|
||
}
|
||
//-------- Функции для работы с Graphics Path -----------------------------------------------
|
||
HRESULT CASCSVGWriter::PathCommandMoveTo(const double& fX, const double& fY)
|
||
{
|
||
if (m_bIsRaster)
|
||
return S_OK;
|
||
|
||
if (c_nSimpleGraphicType == m_lCurrentCommandType)
|
||
{
|
||
MoveTo(fX, fY);
|
||
}
|
||
else
|
||
{
|
||
m_pSimpleGraphicsConverter->PathCommandMoveTo(fX, fY);
|
||
}
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::PathCommandLineTo(const double& fX, const double& fY)
|
||
{
|
||
if (m_bIsRaster)
|
||
return S_OK;
|
||
|
||
if (c_nSimpleGraphicType == m_lCurrentCommandType)
|
||
{
|
||
LineTo(fX, fY);
|
||
}
|
||
else
|
||
{
|
||
m_pSimpleGraphicsConverter->PathCommandLineTo(fX, fY);
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::PathCommandLinesTo(double* points, const int& count)
|
||
{
|
||
if (m_bIsRaster)
|
||
return S_OK;
|
||
|
||
m_pSimpleGraphicsConverter->PathCommandLinesTo(points, count);
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::PathCommandCurveTo(const double& fX1, const double& fY1, const double& fX2, const double& fY2, const double& fX3, const double& fY3)
|
||
{
|
||
if (m_bIsRaster)
|
||
return S_OK;
|
||
|
||
if (c_nSimpleGraphicType == m_lCurrentCommandType)
|
||
{
|
||
CurveTo(fX1, fY1, fX2, fY2, fX3, fY3);
|
||
}
|
||
else
|
||
{
|
||
m_pSimpleGraphicsConverter->PathCommandCurveTo(fX1, fY1, fX2, fY2, fX3, fY3);
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::PathCommandCurvesTo(double* points, const int& count)
|
||
{
|
||
if (m_bIsRaster)
|
||
return S_OK;
|
||
|
||
m_pSimpleGraphicsConverter->PathCommandCurvesTo(points, count);
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::PathCommandArcTo(const double& fX, const double& fY, const double& fWidth, const double& fHeight, const double& fStartAngle, const double& fSweepAngle)
|
||
{
|
||
if (m_bIsRaster)
|
||
return S_OK;
|
||
|
||
m_pSimpleGraphicsConverter->PathCommandArcTo(fX, fY, fWidth, fHeight, fStartAngle, fSweepAngle);
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::PathCommandClose()
|
||
{
|
||
if (m_bIsRaster)
|
||
return S_OK;
|
||
|
||
if (c_nSimpleGraphicType == m_lCurrentCommandType)
|
||
{
|
||
Close();
|
||
}
|
||
else
|
||
{
|
||
m_pSimpleGraphicsConverter->PathCommandClose();
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::PathCommandEnd()
|
||
{
|
||
if (m_bIsRaster)
|
||
return S_OK;
|
||
|
||
if (c_nSimpleGraphicType == m_lCurrentCommandType)
|
||
{
|
||
End();
|
||
}
|
||
else
|
||
{
|
||
m_pSimpleGraphicsConverter->PathCommandEnd();
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::DrawPath(const long& nType)
|
||
{
|
||
if (m_pBrush->Type == c_BrushTypeTexture)
|
||
m_bIsRaster = true;
|
||
|
||
if (m_bIsRaster)
|
||
return S_OK;
|
||
|
||
m_pVectorWriter->WriteDrawPath(nType);
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::PathCommandStart()
|
||
{
|
||
if (m_bIsRaster)
|
||
return S_OK;
|
||
|
||
if (c_nSimpleGraphicType == m_lCurrentCommandType)
|
||
{
|
||
Start();
|
||
}
|
||
else
|
||
{
|
||
m_pSimpleGraphicsConverter->PathCommandEnd();
|
||
m_pSimpleGraphicsConverter->PathCommandStart();
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::PathCommandGetCurrentPoint(double* fX, double* fY)
|
||
{
|
||
m_pSimpleGraphicsConverter->PathCommandGetCurrentPoint(fX, fY);
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::PathCommandTextCHAR(const LONG& c, const double& x, const double& y, const double& w, const double& h, const double& baselineOffset)
|
||
{
|
||
//todo new command
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::PathCommandText(const std::wstring& bsText, const double& fX, const double& fY, const double& fWidth, const double& fHeight, const double& fBaseLineOffset)
|
||
{
|
||
if (m_bIsRaster)
|
||
return S_OK;
|
||
|
||
_SetFont();
|
||
m_pSimpleGraphicsConverter->PathCommandText(bsText, m_pFontManager, fX, fY, fWidth, fHeight, fBaseLineOffset);
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::PathCommandTextExCHAR(const LONG& c, const LONG& gid, const double& x, const double& y, const double& w, const double& h, const double& baselineOffset, const DWORD& lFlags)
|
||
{
|
||
//todo new command
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::PathCommandTextEx(const std::wstring& bsUnicodeText, const std::wstring& bsGidText, const double& x, const double& y, const double& w, const double& h, const double& baselineOffset, const DWORD& lFlags)
|
||
{
|
||
if (m_bIsRaster)
|
||
return S_OK;
|
||
|
||
bool bGid = m_pFont->StringGID != 0 ? true : false;
|
||
if (bsGidText.empty())
|
||
{
|
||
m_pFont->StringGID = 1;
|
||
PathCommandText(bsGidText, x, y, w, h, baselineOffset);
|
||
}
|
||
|
||
m_pFont->StringGID = 0;
|
||
PathCommandText(bsUnicodeText, x, y, w, h, baselineOffset);
|
||
|
||
m_pFont->StringGID = bGid ? 1 : 0;
|
||
return S_OK;
|
||
}
|
||
//-------- Функции для вывода изображений ---------------------------------------------------
|
||
HRESULT CASCSVGWriter::DrawImage(IGrObject* pImage, const double& fX, const double& fY, const double& fWidth, const double& fHeight)
|
||
{
|
||
m_bIsRaster = true;
|
||
/*
|
||
double x = fX;
|
||
double y = fY;
|
||
|
||
double r = fX + fWidth;
|
||
double b = fY + fHeight;
|
||
|
||
if (0 == m_dTransformAngle)
|
||
{
|
||
m_pFullTransform->TransformPoint(x, y);
|
||
m_pFullTransform->TransformPoint(r, b);
|
||
}
|
||
else
|
||
{
|
||
NSHtmlRenderer::CMatrix oTemp = *m_pFullTransform;
|
||
|
||
double dCx = (x + r) / 2;
|
||
double dCy = (y + b) / 2;
|
||
m_pFullTransform->TransformPoint(dCx, dCy);
|
||
oTemp.RotateAt(-m_dTransformAngle, dCx, dCy, Aggplus::MatrixOrderAppend);
|
||
|
||
oTemp.TransformPoint(x, y);
|
||
oTemp.TransformPoint(r, b);
|
||
}
|
||
|
||
m_oWriter.WriteImage(pInterface, x, y, r - x, b - y, m_dTransformAngle);
|
||
*/
|
||
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::DrawImageFromFile(const std::wstring& sVal, const double& x, const double& y, const double& w, const double& h, const BYTE& lAlpha = 255)
|
||
{
|
||
m_bIsRaster = true;
|
||
/*
|
||
double x = fX;
|
||
double y = fY;
|
||
|
||
double r = fX + fWidth;
|
||
double b = fY + fHeight;
|
||
|
||
if (0 == m_dTransformAngle)
|
||
{
|
||
m_pFullTransform->TransformPoint(x, y);
|
||
m_pFullTransform->TransformPoint(r, b);
|
||
}
|
||
else
|
||
{
|
||
NSHtmlRenderer::CMatrix oTemp = *m_pFullTransform;
|
||
|
||
double dCx = (x + r) / 2;
|
||
double dCy = (y + b) / 2;
|
||
m_pFullTransform->TransformPoint(dCx, dCy);
|
||
oTemp.RotateAt(-m_dTransformAngle, dCx, dCy, Aggplus::MatrixOrderAppend);
|
||
|
||
oTemp.TransformPoint(x, y);
|
||
oTemp.TransformPoint(r, b);
|
||
}
|
||
|
||
m_oWriter.WriteImage((CString)bstrVal, x, y, r - x, b - y, m_pTransform->z_Rotation());
|
||
*/
|
||
|
||
return S_OK;
|
||
}
|
||
// transform --------------------------------------------------------------------------------
|
||
HRESULT CASCSVGWriter::SetTransform(const double& dA, const double& dB, const double& dC, const double& dD, const double& dE, const double& dF)
|
||
{
|
||
Aggplus::CMatrix oTrans(dA, dB, dC, dD, dE, dF);
|
||
*m_pTransform = oTrans;
|
||
|
||
CalculateFullTransform();
|
||
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::GetTransform(double *pdA, double *pdB, double *pdC, double *pdD, double *pdE, double *pdF)
|
||
{
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::ResetTransform(void)
|
||
{
|
||
m_pTransform->Reset();
|
||
CalculateFullTransform();
|
||
return S_OK;
|
||
}
|
||
// -----------------------------------------------------------------------------------------
|
||
HRESULT CASCSVGWriter::get_ClipMode(LONG* plMode)
|
||
{
|
||
*plMode = m_lClipMode;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::put_ClipMode(const LONG& lMode)
|
||
{
|
||
m_lClipMode = lMode;
|
||
m_pVectorWriter->SetClipMode(m_lClipMode);
|
||
return S_OK;
|
||
}
|
||
// additiaonal params ----------------------------------------------------------------------
|
||
HRESULT CASCSVGWriter::SaveFile(const std::wstring& strFileSave)
|
||
{
|
||
NSFile::CFileBinary oFile;
|
||
if(oFile.CreateFileW(strFileSave))
|
||
{
|
||
LONG lW = (LONG)m_dWidth;
|
||
LONG lH = (LONG)m_dHeight;
|
||
CString strStart = _T("");
|
||
strStart.Format(NSHtmlRenderer::g_svg_string_svgOpen, (LONG)(m_dWidth / 100), (LONG)(m_dHeight / 100), lW, lH);
|
||
|
||
oFile.WriteStringUTF8(std::wstring(strStart.GetString()));
|
||
|
||
CString s = m_pVectorWriter->m_oSVG.m_oDocument.GetCString();
|
||
oFile.WriteStringUTF8(std::wstring(s.GetString()));
|
||
|
||
CString strEnd = _T("</svg>");
|
||
oFile.WriteStringUTF8(std::wstring(strEnd.GetString()));
|
||
}
|
||
oFile.CloseFile();
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::ReInit()
|
||
{
|
||
m_dDpiX = 96.0;
|
||
m_dDpiY = 96.0;
|
||
|
||
m_dWidth = 100;
|
||
m_dHeight = 100;
|
||
m_bIsRaster = false;
|
||
|
||
m_lClipMode = c_nClipRegionTypeWinding;
|
||
|
||
RELEASEOBJECT(m_pSimpleGraphicsConverter);
|
||
m_pSimpleGraphicsConverter = new Aggplus::CGraphicsPathSimpleConverter();
|
||
m_pSimpleGraphicsConverter->SetRenderer(this);
|
||
|
||
m_dTransformAngle = 0.0;
|
||
|
||
|
||
m_pVectorWriter->m_pSimpleConverter = m_pSimpleGraphicsConverter;
|
||
m_pVectorWriter->m_pFullTransform = m_pFullTransform;
|
||
m_pVectorWriter->SetSettings(m_pPen, m_pBrush, m_pSimpleGraphicsConverter);
|
||
|
||
m_pPen->SetDefaultParams();
|
||
m_pBrush->SetDefaultParams();
|
||
m_pFont->SetDefaultParams();
|
||
|
||
m_pBaseTransform->Reset();
|
||
m_pTransform->Reset();
|
||
m_pFullTransform->Reset();
|
||
|
||
m_pVectorWriter->m_oSVG.ReInit();
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::IsRaster(bool* bVal)
|
||
{
|
||
*bVal = m_bIsRaster;
|
||
return S_OK;
|
||
}
|
||
// additiaonal params ----------------------------------------------------------------------
|
||
HRESULT CASCSVGWriter::CommandLong(const LONG& lType, const LONG& lCommand)
|
||
{
|
||
//todo new command
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::CommandDouble(const LONG& lType, const double& dCommand)
|
||
{
|
||
//todo new command
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCSVGWriter::CommandString(const LONG& lType, const std::wstring& sCommand)
|
||
{
|
||
//todo new command
|
||
return S_OK;
|
||
}
|
||
// --------------------------------------------------------------------------------------------
|
||
void CASCSVGWriter::OnBaseMatrixUpdate(const double& dWidth, const double& dHeight)
|
||
{
|
||
m_pBaseTransform->Reset();
|
||
|
||
double dScaleX = m_dDpiX / NSHtmlRenderer::c_ag_Inch_to_MM;
|
||
double dScaleY = m_dDpiY / NSHtmlRenderer::c_ag_Inch_to_MM;
|
||
|
||
m_pBaseTransform->Scale(dScaleX, dScaleY, Aggplus::MatrixOrderAppend);
|
||
|
||
CalculateFullTransform();
|
||
|
||
double dWidthPix = dScaleX * dWidth;
|
||
double dHeightPix = dScaleY * dHeight;
|
||
}
|
||
void CASCSVGWriter::SetFontManager(CFontManager* pFontManager)
|
||
{
|
||
if(NULL != pFontManager)
|
||
{
|
||
if(m_bDeleteFontManager)
|
||
RELEASEOBJECT(m_pFontManager);
|
||
m_pFontManager = pFontManager;
|
||
m_bDeleteFontManager = false;
|
||
}
|
||
}
|
||
void CASCSVGWriter::CalculateFullTransform()
|
||
{
|
||
*m_pFullTransform = *m_pBaseTransform;
|
||
m_pFullTransform->Multiply(m_pTransform, Aggplus::MatrixOrderPrepend);
|
||
|
||
m_dTransformAngle = m_pTransform->z_Rotation();
|
||
}
|
||
|
||
inline void CASCSVGWriter::MoveTo(const double& dX, const double& dY)
|
||
{
|
||
double x = dX;
|
||
double y = dY;
|
||
m_pFullTransform->TransformPoint(x, y);
|
||
|
||
m_pVectorWriter->WritePathMoveTo(x, y);
|
||
}
|
||
inline void CASCSVGWriter::LineTo(const double& dX, const double& dY)
|
||
{
|
||
double x = dX;
|
||
double y = dY;
|
||
m_pFullTransform->TransformPoint(x, y);
|
||
|
||
m_pVectorWriter->WritePathLineTo(x, y);
|
||
}
|
||
inline void CASCSVGWriter::CurveTo(const double& x1, const double& y1, const double& x2, const double& y2, const double& x3, const double& y3)
|
||
{
|
||
double _x1 = x1;
|
||
double _y1 = y1;
|
||
m_pFullTransform->TransformPoint(_x1, _y1);
|
||
|
||
double _x2 = x2;
|
||
double _y2 = y2;
|
||
m_pFullTransform->TransformPoint(_x2, _y2);
|
||
|
||
double _x3 = x3;
|
||
double _y3 = y3;
|
||
m_pFullTransform->TransformPoint(_x3, _y3);
|
||
|
||
m_pVectorWriter->WritePathCurveTo(_x1, _y1, _x2, _y2, _x3, _y3);
|
||
}
|
||
void CASCSVGWriter::Start()
|
||
{
|
||
m_pVectorWriter->WritePathStart();
|
||
}
|
||
void CASCSVGWriter::End()
|
||
{
|
||
m_pVectorWriter->WriteEndPath();
|
||
}
|
||
void CASCSVGWriter::Close()
|
||
{
|
||
m_pVectorWriter->WritePathClose();
|
||
}
|
||
|
||
void CASCSVGWriter::_SetFont()
|
||
{
|
||
double dPix = m_pFont->CharSpace * m_dDpiX / 25.4;
|
||
|
||
if (m_pInstalledFont->IsEqual(m_pFont))
|
||
{
|
||
if (1 < m_dWidth)
|
||
{
|
||
m_pFontManager->SetCharSpacing(dPix);
|
||
}
|
||
return;
|
||
}
|
||
|
||
m_pFontManager->SetStringGID(m_pFont->StringGID);
|
||
if (1 < m_dWidth)
|
||
{
|
||
m_pFontManager->SetCharSpacing(dPix);
|
||
}
|
||
|
||
if (_T("") == m_pFont->Path)
|
||
{
|
||
m_pFontManager->LoadFontByName(m_pFont->Name, (float)m_pFont->Size, m_pFont->GetStyle(), m_dDpiX, m_dDpiY);
|
||
}
|
||
else
|
||
{
|
||
m_pFontManager->LoadFontFromFile(m_pFont->Path, (float)m_pFont->Size, m_dDpiX, m_dDpiY, 0);
|
||
}
|
||
|
||
*m_pInstalledFont = *m_pFont;
|
||
}
|
||
}
|