mirror of
https://github.com/ONLYOFFICE/core.git
synced 2026-07-11 14:00:32 +08:00
1354 lines
48 KiB
C++
1354 lines
48 KiB
C++
/*
|
||
* (c) Copyright Ascensio System SIA 2010-2019
|
||
*
|
||
* 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 20A-12 Ernesta Birznieka-Upisha
|
||
* street, Riga, Latvia, EU, LV-1050.
|
||
*
|
||
* 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
|
||
*
|
||
*/
|
||
#include "../include/HTMLRenderer3.h"
|
||
#include "./Common.h"
|
||
#include "./Document.h"
|
||
#include "./Writer.h"
|
||
|
||
namespace NSHtmlRenderer
|
||
{
|
||
class CASCHTMLRenderer3_Private : public NSHtmlRenderer::IBaseMatrixUpdater
|
||
{
|
||
public:
|
||
NSHtmlRenderer::CDocument m_oDocument; // вся информация о документе (только страницы и их размеры)
|
||
NSHtmlRenderer::CWriter m_oWriter; // сам вьюер. основной класс
|
||
|
||
NSHtmlRenderer::CGraphicsDumper m_oDumper;
|
||
bool m_bIsGraphicsDumperMode;
|
||
|
||
std::wstring m_strDstFile;
|
||
int m_lLastSavedPage;
|
||
|
||
Aggplus::CGraphicsPathSimpleConverter m_oSimpleGraphicsConverter; // конвертер сложных гафических путей в простые
|
||
|
||
NSFonts::IApplicationFonts* m_pApplicationFonts;
|
||
NSFonts::IFontManager* m_pFontManager; // менеджер шрифтов
|
||
|
||
Aggplus::CMatrix m_oTransform; // текущая матрица преобразований рендерера
|
||
double m_dTransformAngle;
|
||
|
||
int m_lCurrentCommandType; // текущая команда
|
||
int m_lCurrentPage; // текущая страница
|
||
bool m_bIsMetafileDrawing;
|
||
bool m_bIsTextGraphicType;
|
||
|
||
int m_lClipMode;
|
||
|
||
NSStructures::CPen m_oPen; // настройки всей графики (скопирован ашник из AVSGraphics)
|
||
NSStructures::CBrush m_oBrush;
|
||
NSStructures::CFont m_oFont;
|
||
|
||
NSStructures::CFont m_oInstalledFont;
|
||
|
||
bool m_bPageClosed;
|
||
bool m_bPageOpened;
|
||
|
||
bool m_bIsChangedFontParamBetweenDrawText;
|
||
|
||
public:
|
||
int* m_pTempUnicodes;
|
||
int m_nTempUnicodesAlloc;
|
||
int m_nTempUnicodesLen;
|
||
|
||
bool m_bIsOnlyTextMode;
|
||
bool m_bDisablePageEnd;
|
||
|
||
public:
|
||
CASCHTMLRenderer3_Private()
|
||
{
|
||
// initialize move to CreateOfficeFile (custom directory support)
|
||
//m_oApplicationFonts.Initialize();
|
||
m_pApplicationFonts = NSFonts::NSApplication::Create();
|
||
m_pApplicationFonts->GetCache()->SetCacheSize(16);
|
||
|
||
m_lLastSavedPage = 0;
|
||
m_oDocument.SetUpdater(this);
|
||
|
||
m_oWriter.m_pPen = &m_oPen;
|
||
m_oWriter.m_pBrush = &m_oBrush;
|
||
m_oWriter.m_pFont = &m_oFont;
|
||
|
||
m_bPageClosed = true;
|
||
|
||
m_dTransformAngle = 0.0;
|
||
|
||
m_pFontManager = NULL;
|
||
|
||
m_oWriter.SetSimpleConverter(&m_oSimpleGraphicsConverter, &m_oTransform);
|
||
m_oWriter.SetApplicationFonts(m_pApplicationFonts);
|
||
|
||
m_bIsMetafileDrawing = false;
|
||
m_bIsTextGraphicType = false;
|
||
|
||
m_bIsChangedFontParamBetweenDrawText = true;
|
||
m_bIsGraphicsDumperMode = false;
|
||
|
||
m_nTempUnicodesAlloc = 100;
|
||
m_pTempUnicodes = new int[m_nTempUnicodesAlloc];
|
||
m_nTempUnicodesLen = 0;
|
||
|
||
m_bIsOnlyTextMode = false;
|
||
m_bPageOpened = false;
|
||
|
||
m_bDisablePageEnd = false;
|
||
}
|
||
~CASCHTMLRenderer3_Private()
|
||
{
|
||
RELEASEOBJECT(m_pApplicationFonts);
|
||
RELEASEARRAYOBJECTS(m_pTempUnicodes);
|
||
}
|
||
|
||
public:
|
||
void GetUnicodes(const std::wstring& sText)
|
||
{
|
||
int nLen = (int)sText.length();
|
||
if (nLen > m_nTempUnicodesAlloc)
|
||
{
|
||
RELEASEARRAYOBJECTS(m_pTempUnicodes);
|
||
m_nTempUnicodesAlloc = nLen;
|
||
m_pTempUnicodes = new int[m_nTempUnicodesAlloc];
|
||
}
|
||
|
||
m_nTempUnicodesLen = 0;
|
||
const wchar_t* pWchars = sText.c_str();
|
||
|
||
if (sizeof(wchar_t) == 2)
|
||
{
|
||
for (int nIndex = 0, nGlyphIndex = 0; nIndex < nLen; ++nIndex, ++nGlyphIndex)
|
||
{
|
||
int code = (int)pWchars[nIndex];
|
||
if (code >= 0xD800 && code <= 0xDFFF && (nIndex + 1) < nLen)
|
||
{
|
||
++nIndex;
|
||
code = 0x10000 + (((code & 0x3FF) << 10) | (0x03FF & pWchars[nIndex]));
|
||
}
|
||
|
||
m_pTempUnicodes[m_nTempUnicodesLen++] = code;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for ( int nIndex = 0; nIndex < nLen; ++nIndex )
|
||
{
|
||
m_pTempUnicodes[m_nTempUnicodesLen++] = (int)pWchars[nIndex];
|
||
}
|
||
}
|
||
}
|
||
|
||
public:
|
||
virtual void OnBaseMatrixUpdate(const double& dWidth, const double& dHeight)
|
||
{
|
||
if (m_bPageClosed)
|
||
{
|
||
// значит размеры пришли не в первый раз для текущей страницы
|
||
return;
|
||
}
|
||
m_bPageClosed = true;
|
||
StartPage(dWidth, dHeight);
|
||
}
|
||
|
||
void CalculateFullTransform()
|
||
{
|
||
m_dTransformAngle = m_oTransform.z_Rotation();
|
||
}
|
||
|
||
inline void MoveTo(const double& dX, const double& dY)
|
||
{
|
||
m_oWriter.WritePathMoveTo(dX, dY);
|
||
}
|
||
inline void LineTo(const double& dX, const double& dY)
|
||
{
|
||
m_oWriter.WritePathLineTo(dX, dY);
|
||
}
|
||
inline void CurveTo(const double& x1, const double& y1, const double& x2, const double& y2, const double& x3, const double& y3)
|
||
{
|
||
m_oWriter.WritePathCurveTo(x1, y1, x2, y2, x3, y3);
|
||
}
|
||
void Start()
|
||
{
|
||
m_oWriter.WriteBeginPath();
|
||
}
|
||
void End()
|
||
{
|
||
m_oWriter.WriteEndPath();
|
||
}
|
||
void Close()
|
||
{
|
||
m_oWriter.WritePathClose();
|
||
}
|
||
|
||
void StartPage(const double& dWidth, const double& dHeight)
|
||
{
|
||
++m_lCurrentPage;
|
||
m_oWriter.NewPage(dWidth, dHeight);
|
||
}
|
||
void EndPage()
|
||
{
|
||
m_oWriter.EndPage();
|
||
m_bPageOpened = false;
|
||
}
|
||
|
||
void _SetFont()
|
||
{
|
||
if (NULL == m_pFontManager)
|
||
{
|
||
m_pFontManager = m_pApplicationFonts->GenerateFontManager();
|
||
}
|
||
|
||
double dPix = m_oFont.CharSpace * 96 / 25.4;
|
||
|
||
if (m_oInstalledFont.IsEqual(&m_oFont))
|
||
{
|
||
if (1 < m_oWriter.m_dWidth)
|
||
{
|
||
m_pFontManager->SetCharSpacing(dPix);
|
||
}
|
||
return;
|
||
}
|
||
|
||
m_pFontManager->SetStringGID(m_oFont.StringGID);
|
||
if (1 < m_oWriter.m_dWidth)
|
||
{
|
||
m_pFontManager->SetCharSpacing(dPix);
|
||
}
|
||
|
||
if (m_oFont.Path.empty())
|
||
{
|
||
m_pFontManager->LoadFontByName(m_oFont.Name, m_oFont.Size, m_oFont.GetStyle(), 96, 96);
|
||
}
|
||
else
|
||
{
|
||
m_pFontManager->LoadFontFromFile(m_oFont.Path, m_oFont.FaceIndex, m_oFont.Size, 96, 96);
|
||
}
|
||
|
||
m_oInstalledFont = m_oFont;
|
||
}
|
||
};
|
||
|
||
CASCHTMLRenderer3::CASCHTMLRenderer3()
|
||
{
|
||
m_pInternal = new CASCHTMLRenderer3_Private();
|
||
}
|
||
CASCHTMLRenderer3::~CASCHTMLRenderer3()
|
||
{
|
||
RELEASEOBJECT(m_pInternal);
|
||
}
|
||
|
||
HRESULT CASCHTMLRenderer3::get_Type(LONG* lType)
|
||
{
|
||
*lType = c_nHtmlRendrerer2;
|
||
return S_OK;
|
||
}
|
||
|
||
//-------- Функции для работы со страницей --------------------------------------------------
|
||
HRESULT CASCHTMLRenderer3::NewPage()
|
||
{
|
||
if (m_pInternal->m_bPageOpened)
|
||
{
|
||
m_pInternal->EndPage();
|
||
}
|
||
|
||
m_pInternal->m_oPen.SetDefaultParams();
|
||
m_pInternal->m_oBrush.SetDefaultParams();
|
||
m_pInternal->m_oFont.SetDefaultParams();
|
||
|
||
m_pInternal->m_oDocument.NewPage();
|
||
m_pInternal->m_bPageClosed = false;
|
||
m_pInternal->m_bPageOpened = true;
|
||
|
||
m_pInternal->m_bIsMetafileDrawing = false;
|
||
m_pInternal->m_bIsTextGraphicType = false;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_Height(double* dHeight)
|
||
{
|
||
size_t nCount = m_pInternal->m_oDocument.m_arrPages.size();
|
||
if ((nCount > 0) && (NULL != dHeight))
|
||
*dHeight = m_pInternal->m_oDocument.m_arrPages[nCount - 1].GetHeight();
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_Height(const double& dHeight)
|
||
{
|
||
size_t nCount = m_pInternal->m_oDocument.m_arrPages.size();
|
||
if (nCount > 0)
|
||
m_pInternal->m_oDocument.m_arrPages[nCount - 1].SetHeight(dHeight);
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_Width(double* dWidth)
|
||
{
|
||
size_t nCount = m_pInternal->m_oDocument.m_arrPages.size();
|
||
if ((nCount > 0) && (NULL != dWidth))
|
||
*dWidth = m_pInternal->m_oDocument.m_arrPages[nCount - 1].GetWidth();
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_Width(const double& dWidth)
|
||
{
|
||
size_t nCount = m_pInternal->m_oDocument.m_arrPages.size();
|
||
if (nCount > 0)
|
||
m_pInternal->m_oDocument.m_arrPages[nCount - 1].SetWidth(dWidth);
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_DpiX(double* dDpiX)
|
||
{
|
||
*dDpiX = 96;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_DpiY(double* dDpiY)
|
||
{
|
||
*dDpiY = 96;
|
||
return S_OK;
|
||
}
|
||
|
||
// pen --------------------------------------------------------------------------------------
|
||
HRESULT CASCHTMLRenderer3::get_PenColor(LONG* lColor)
|
||
{
|
||
*lColor = m_pInternal->m_oPen.Color;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_PenColor(const LONG& lColor)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_PenColor(lColor);
|
||
|
||
m_pInternal->m_oPen.Color = lColor;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_PenAlpha(LONG* lAlpha)
|
||
{
|
||
*lAlpha = m_pInternal->m_oPen.Alpha;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_PenAlpha(const LONG& lAlpha)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_PenAlpha(lAlpha);
|
||
|
||
m_pInternal->m_oPen.Alpha = lAlpha;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_PenSize(double* dSize)
|
||
{
|
||
*dSize = m_pInternal->m_oPen.Size;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_PenSize(const double& dSize)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_PenSize(dSize);
|
||
|
||
m_pInternal->m_oPen.Size = dSize;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_PenDashStyle(BYTE* val)
|
||
{
|
||
*val = m_pInternal->m_oPen.DashStyle;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_PenDashStyle(const BYTE& val)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_PenDashStyle(val);
|
||
|
||
m_pInternal->m_oPen.DashStyle = val;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_PenLineStartCap(BYTE* val)
|
||
{
|
||
*val = m_pInternal->m_oPen.LineStartCap;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_PenLineStartCap(const BYTE& val)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_PenLineStartCap(val);
|
||
|
||
m_pInternal->m_oPen.LineStartCap = val;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_PenLineEndCap(BYTE* val)
|
||
{
|
||
*val = m_pInternal->m_oPen.LineEndCap;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_PenLineEndCap(const BYTE& val)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_PenLineEndCap(val);
|
||
|
||
m_pInternal->m_oPen.LineEndCap = val;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_PenLineJoin(BYTE* val)
|
||
{
|
||
*val = m_pInternal->m_oPen.LineJoin;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_PenLineJoin(const BYTE& val)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_PenLineJoin(val);
|
||
|
||
m_pInternal->m_oPen.LineJoin = val;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_PenDashOffset(double* dOffset)
|
||
{
|
||
*dOffset = m_pInternal->m_oPen.DashOffset;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_PenDashOffset(const double& dOffset)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_PenDashOffset(dOffset);
|
||
|
||
m_pInternal->m_oPen.DashOffset = dOffset;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_PenAlign(LONG* lAlign)
|
||
{
|
||
*lAlign = m_pInternal->m_oPen.Align;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_PenAlign(const LONG& lAlign)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_PenAlign(lAlign);
|
||
|
||
m_pInternal->m_oPen.Align = lAlign;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_PenMiterLimit(double* dOffset)
|
||
{
|
||
*dOffset = m_pInternal->m_oPen.MiterLimit;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_PenMiterLimit(const double& dOffset)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_PenMiterLimit(dOffset);
|
||
|
||
m_pInternal->m_oPen.MiterLimit = dOffset;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::PenDashPattern(double* pPattern, LONG lCount)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.PenDashPattern(pPattern, lCount);
|
||
|
||
m_pInternal->m_oPen.SetDashPattern(pPattern, lCount);
|
||
return S_OK;
|
||
}
|
||
|
||
// brush ------------------------------------------------------------------------------------
|
||
HRESULT CASCHTMLRenderer3::get_BrushType(LONG* lType)
|
||
{
|
||
*lType = m_pInternal->m_oBrush.Type;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_BrushType(const LONG& lType)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_BrushType(lType);
|
||
|
||
m_pInternal->m_oBrush.Type = lType;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_BrushColor1(LONG* lColor)
|
||
{
|
||
*lColor = m_pInternal->m_oBrush.Color1;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_BrushColor1(const LONG& lColor)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_BrushColor1(lColor);
|
||
|
||
m_pInternal->m_oBrush.Color1 = lColor;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_BrushAlpha1(LONG* lAlpha)
|
||
{
|
||
*lAlpha = m_pInternal->m_oBrush.Alpha1;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_BrushAlpha1(const LONG& lAlpha)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_BrushAlpha1(lAlpha);
|
||
|
||
m_pInternal->m_oBrush.Alpha1 = lAlpha;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_BrushColor2(LONG* lColor)
|
||
{
|
||
*lColor = m_pInternal->m_oBrush.Color2;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_BrushColor2(const LONG& lColor)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_BrushColor2(lColor);
|
||
|
||
m_pInternal->m_oBrush.Color2 = lColor;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_BrushAlpha2(LONG* lAlpha)
|
||
{
|
||
*lAlpha = m_pInternal->m_oBrush.Alpha2;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_BrushAlpha2(const LONG& lAlpha)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_BrushAlpha2(lAlpha);
|
||
|
||
m_pInternal->m_oBrush.Alpha2 = lAlpha;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_BrushTexturePath(std::wstring* bsPath)
|
||
{
|
||
*bsPath = m_pInternal->m_oBrush.TexturePath;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_BrushTexturePath(const std::wstring& bsPath)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_BrushTexturePath(bsPath);
|
||
|
||
m_pInternal->m_oBrush.TexturePath = bsPath;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_BrushTextureMode(LONG* lMode)
|
||
{
|
||
*lMode = m_pInternal->m_oBrush.TextureMode;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_BrushTextureMode(const LONG& lMode)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_BrushTextureMode(lMode);
|
||
|
||
m_pInternal->m_oBrush.TextureMode = lMode;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_BrushTextureAlpha(LONG* lTxAlpha)
|
||
{
|
||
*lTxAlpha = m_pInternal->m_oBrush.TextureAlpha;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_BrushTextureAlpha(const LONG& lTxAlpha)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_BrushTextureAlpha(lTxAlpha);
|
||
|
||
m_pInternal->m_oBrush.TextureAlpha = lTxAlpha;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_BrushLinearAngle(double* dAngle)
|
||
{
|
||
*dAngle = m_pInternal->m_oBrush.LinearAngle;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_BrushLinearAngle(const double& dAngle)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_BrushLinearAngle(dAngle);
|
||
|
||
m_pInternal->m_oBrush.LinearAngle = dAngle;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::BrushRect(const INT& val, const double& left, const double& top, const double& width, const double& height)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.BrushRect(val, left, top, width, height);
|
||
|
||
m_pInternal->m_oBrush.Rectable = val;
|
||
m_pInternal->m_oBrush.Rect.X = (float)left;
|
||
m_pInternal->m_oBrush.Rect.Y = (float)top;
|
||
m_pInternal->m_oBrush.Rect.Width = (float)width;
|
||
m_pInternal->m_oBrush.Rect.Height = (float)height;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::BrushBounds(const double& left, const double& top, const double& width, const double& height)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.BrushBounds(left, top, width, height);
|
||
|
||
m_pInternal->m_oBrush.Bounds.left = left;
|
||
m_pInternal->m_oBrush.Bounds.top = top;
|
||
m_pInternal->m_oBrush.Bounds.right = left + width;
|
||
m_pInternal->m_oBrush.Bounds.bottom = top + height;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_BrushGradientColors(LONG* lColors, double* pPositions, LONG nCount)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_BrushGradientColors(lColors, pPositions, nCount);
|
||
|
||
m_pInternal->m_oBrush.m_arrSubColors.RemoveAll();
|
||
for (LONG i = 0; i < nCount; ++i)
|
||
{
|
||
NSStructures::CBrush::TSubColor color;
|
||
color.color = lColors[i];
|
||
color.position = (long)(pPositions[i] * 65536);
|
||
m_pInternal->m_oBrush.m_arrSubColors.Add(color);
|
||
}
|
||
return S_OK;
|
||
}
|
||
|
||
// font -------------------------------------------------------------------------------------
|
||
HRESULT CASCHTMLRenderer3::get_FontName(std::wstring* bsName)
|
||
{
|
||
*bsName = m_pInternal->m_oFont.Name;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_FontName(const std::wstring& bsName)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_FontName(bsName);
|
||
|
||
m_pInternal->m_oFont.Name = bsName;
|
||
m_pInternal->m_bIsChangedFontParamBetweenDrawText = true;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_FontPath(std::wstring* bsName)
|
||
{
|
||
*bsName = m_pInternal->m_oFont.Path;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_FontPath(const std::wstring& bsName)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_FontPath(bsName);
|
||
|
||
m_pInternal->m_oFont.Path = bsName;
|
||
m_pInternal->m_bIsChangedFontParamBetweenDrawText = true;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_FontSize(double* dSize)
|
||
{
|
||
*dSize = m_pInternal->m_oFont.Size;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_FontSize(const double& dSize)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_FontSize(dSize);
|
||
|
||
if (m_pInternal->m_oFont.Size != dSize)
|
||
{
|
||
m_pInternal->m_oFont.Size = dSize;
|
||
m_pInternal->m_bIsChangedFontParamBetweenDrawText = true;
|
||
}
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_FontStyle(LONG* lStyle)
|
||
{
|
||
*lStyle = m_pInternal->m_oFont.GetStyle();
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_FontStyle(const LONG& lStyle)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_FontStyle(lStyle);
|
||
|
||
LONG lOld = m_pInternal->m_oFont.GetStyle();
|
||
if (lOld != lStyle)
|
||
{
|
||
m_pInternal->m_oFont.SetStyle(lStyle);
|
||
m_pInternal->m_bIsChangedFontParamBetweenDrawText = true;
|
||
}
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_FontStringGID(INT* bGID)
|
||
{
|
||
*bGID = m_pInternal->m_oFont.StringGID;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_FontStringGID(const INT& bGID)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_FontStringGID(bGID);
|
||
|
||
m_pInternal->m_oFont.StringGID = bGID;
|
||
m_pInternal->m_pFontManager->SetStringGID(bGID);
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_FontCharSpace(double* dSpace)
|
||
{
|
||
*dSpace = m_pInternal->m_oFont.CharSpace;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_FontCharSpace(const double& dSpace)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_FontCharSpace(dSpace);
|
||
|
||
m_pInternal->m_oFont.CharSpace = dSpace;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::get_FontFaceIndex(int* lFaceIndex)
|
||
{
|
||
*lFaceIndex = m_pInternal->m_oFont.FaceIndex;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_FontFaceIndex(const int& lFaceIndex)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_FontFaceIndex(lFaceIndex);
|
||
|
||
m_pInternal->m_oFont.FaceIndex = lFaceIndex;
|
||
return S_OK;
|
||
}
|
||
|
||
//-------- Функции для вывода текста --------------------------------------------------------
|
||
HRESULT CASCHTMLRenderer3::CommandDrawTextCHAR(const LONG& c, const double& x, const double& y, const double& w, const double& h)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.CommandDrawTextCHAR(c, x, y, w, h);
|
||
|
||
if (c_nHyperlinkType == m_pInternal->m_lCurrentCommandType)
|
||
return S_OK;
|
||
|
||
int _c = (int)c;
|
||
m_pInternal->m_oWriter.WriteText(&_c, NULL, 1, x, y, w, h, m_pInternal->m_bIsChangedFontParamBetweenDrawText);
|
||
m_pInternal->m_bIsChangedFontParamBetweenDrawText = false;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::CommandDrawText(const std::wstring& bsText, const double& x, const double& y, const double& w, const double& h)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.CommandDrawText(bsText, x, y, w, h);
|
||
|
||
if (c_nHyperlinkType == m_pInternal->m_lCurrentCommandType)
|
||
return S_OK;
|
||
|
||
m_pInternal->GetUnicodes(bsText);
|
||
m_pInternal->m_oWriter.WriteText(m_pInternal->m_pTempUnicodes, NULL, m_pInternal->m_nTempUnicodesLen,
|
||
x, y, w, h, m_pInternal->m_bIsChangedFontParamBetweenDrawText);
|
||
m_pInternal->m_bIsChangedFontParamBetweenDrawText = false;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::CommandDrawTextExCHAR(const LONG& c, const LONG& gid, const double& x, const double& y, const double& w, const double& h)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.CommandDrawTextExCHAR(c, gid, x, y, w, h);
|
||
|
||
if (c_nHyperlinkType == m_pInternal->m_lCurrentCommandType)
|
||
return S_OK;
|
||
|
||
int _c = (int)c;
|
||
int _g = (int)gid;
|
||
|
||
m_pInternal->m_oWriter.WriteText(&_c, &_g, 1,
|
||
x, y, w, h, m_pInternal->m_bIsChangedFontParamBetweenDrawText);
|
||
m_pInternal->m_bIsChangedFontParamBetweenDrawText = false;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::CommandDrawTextEx(const std::wstring& bsUnicodeText, const unsigned int* pGids, const unsigned int nGidsCount, const double& x, const double& y, const double& w, const double& h)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.CommandDrawText(bsUnicodeText, x, y, w, h);
|
||
|
||
if (c_nHyperlinkType == m_pInternal->m_lCurrentCommandType)
|
||
return S_OK;
|
||
|
||
m_pInternal->GetUnicodes(bsUnicodeText);
|
||
m_pInternal->m_oWriter.WriteText(m_pInternal->m_pTempUnicodes, (const int*)pGids, m_pInternal->m_nTempUnicodesLen,
|
||
x, y, w, h, m_pInternal->m_bIsChangedFontParamBetweenDrawText);
|
||
m_pInternal->m_bIsChangedFontParamBetweenDrawText = false;
|
||
return S_OK;
|
||
}
|
||
|
||
//-------- Маркеры для команд ---------------------------------------------------------------
|
||
HRESULT CASCHTMLRenderer3::BeginCommand(const DWORD& lType)
|
||
{
|
||
if (m_pInternal->m_bIsOnlyTextMode)
|
||
{
|
||
m_pInternal->m_lCurrentCommandType = lType;
|
||
return S_OK;
|
||
}
|
||
|
||
if (m_pInternal->m_bIsGraphicsDumperMode && lType != c_nPDFTilingFill)
|
||
return m_pInternal->m_oDumper.BeginCommand(lType);
|
||
|
||
if (c_nClipType == lType)
|
||
{
|
||
m_pInternal->m_oWriter.WritePathClip();
|
||
}
|
||
else if (c_nPathType == lType)
|
||
{
|
||
m_pInternal->m_oWriter.WriteBeginPath();
|
||
m_pInternal->m_oSimpleGraphicsConverter.PathCommandEnd();
|
||
}
|
||
else if (c_nImageType == lType)
|
||
{
|
||
m_pInternal->m_bIsMetafileDrawing = true;
|
||
}
|
||
else if (c_nTextGraphicType == lType)
|
||
{
|
||
m_pInternal->m_bIsTextGraphicType = true;
|
||
}
|
||
else if (c_nPDFTilingFill == lType)
|
||
{
|
||
m_pInternal->m_oWriter.m_lTilingCounter++;
|
||
}
|
||
m_pInternal->m_lCurrentCommandType = lType;
|
||
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::EndCommand(const DWORD& lType)
|
||
{
|
||
if (m_pInternal->m_bIsOnlyTextMode)
|
||
{
|
||
if (c_nPageType == lType && !m_pInternal->m_bDisablePageEnd)
|
||
{
|
||
m_pInternal->EndPage();
|
||
}
|
||
m_pInternal->m_lCurrentCommandType = -1;
|
||
return S_OK;
|
||
}
|
||
|
||
if (m_pInternal->m_bIsGraphicsDumperMode && lType != c_nPDFTilingFill)
|
||
return m_pInternal->m_oDumper.EndCommand(lType);
|
||
|
||
if (c_nPageType == lType && !m_pInternal->m_bDisablePageEnd)
|
||
{
|
||
m_pInternal->EndPage();
|
||
}
|
||
else if (c_nClipType == lType)
|
||
{
|
||
m_pInternal->m_oWriter.WritePathClipEnd();
|
||
}
|
||
else if (c_nResetClipType == lType)
|
||
{
|
||
m_pInternal->m_oWriter.WritePathResetClip();
|
||
}
|
||
//else if (c_nPathType == lType)
|
||
//{
|
||
// PathCommandEnd();
|
||
//}
|
||
else if (c_nImageType == lType)
|
||
{
|
||
m_pInternal->m_bIsMetafileDrawing = false;
|
||
}
|
||
else if (c_nTextGraphicType == lType)
|
||
{
|
||
m_pInternal->m_bIsTextGraphicType = false;
|
||
}
|
||
else if (c_nPDFTilingFill == lType)
|
||
{
|
||
m_pInternal->m_oWriter.m_lTilingCounter--;
|
||
|
||
if (0 == m_pInternal->m_oWriter.m_lTilingCounter)
|
||
{
|
||
m_pInternal->m_bIsGraphicsDumperMode = false;
|
||
|
||
// dump Graphics
|
||
CBgraFrame* pFrame = m_pInternal->m_oDumper.ConvertVectorGraphics();
|
||
m_pInternal->m_oWriter.WritePattern(pFrame, m_pInternal->m_oDumper.m_oTile);
|
||
RELEASEOBJECT(pFrame);
|
||
}
|
||
}
|
||
//else if (c_nParagraphType == lType)
|
||
//{
|
||
// m_oWriter.m_oPage.m_oText.EndParagraph();
|
||
//}
|
||
m_pInternal->m_lCurrentCommandType = -1;
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
//-------- Функции для работы с Graphics Path -----------------------------------------------
|
||
HRESULT CASCHTMLRenderer3::PathCommandMoveTo(const double& x, const double& y)
|
||
{
|
||
if (m_pInternal->m_bIsOnlyTextMode)
|
||
return S_OK;
|
||
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.PathCommandMoveTo(x, y);
|
||
|
||
if (c_nSimpleGraphicType == m_pInternal->m_lCurrentCommandType)
|
||
{
|
||
m_pInternal->MoveTo(x, y);
|
||
}
|
||
else
|
||
{
|
||
m_pInternal->m_oSimpleGraphicsConverter.PathCommandMoveTo(x, y);
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::PathCommandLineTo(const double& x, const double& y)
|
||
{
|
||
if (m_pInternal->m_bIsOnlyTextMode)
|
||
return S_OK;
|
||
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.PathCommandLineTo(x, y);
|
||
|
||
if (c_nSimpleGraphicType == m_pInternal->m_lCurrentCommandType)
|
||
{
|
||
m_pInternal->LineTo(x, y);
|
||
}
|
||
else
|
||
{
|
||
m_pInternal->m_oSimpleGraphicsConverter.PathCommandLineTo(x, y);
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::PathCommandLinesTo(double* points, const int& count)
|
||
{
|
||
if (m_pInternal->m_bIsOnlyTextMode)
|
||
return S_OK;
|
||
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.PathCommandLinesTo(points, count);
|
||
|
||
m_pInternal->m_oSimpleGraphicsConverter.PathCommandLinesTo(points, count);
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::PathCommandCurveTo(const double& x1, const double& y1, const double& x2, const double& y2, const double& x3, const double& y3)
|
||
{
|
||
if (m_pInternal->m_bIsOnlyTextMode)
|
||
return S_OK;
|
||
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.PathCommandCurveTo(x1, y1, x2, y2, x3, y3);
|
||
|
||
if (c_nSimpleGraphicType == m_pInternal->m_lCurrentCommandType)
|
||
{
|
||
m_pInternal->CurveTo(x1, y1, x2, y2, x3, y3);
|
||
}
|
||
else
|
||
{
|
||
m_pInternal->m_oSimpleGraphicsConverter.PathCommandCurveTo(x1, y1, x2, y2, x3, y3);
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::PathCommandCurvesTo(double* points, const int& count)
|
||
{
|
||
if (m_pInternal->m_bIsOnlyTextMode)
|
||
return S_OK;
|
||
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.PathCommandCurvesTo(points, count);
|
||
|
||
m_pInternal->m_oSimpleGraphicsConverter.PathCommandCurvesTo(points, count);
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::PathCommandArcTo(const double& x, const double& y, const double& w, const double& h, const double& startAngle, const double& sweepAngle)
|
||
{
|
||
if (m_pInternal->m_bIsOnlyTextMode)
|
||
return S_OK;
|
||
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.PathCommandArcTo(x, y, w, h, startAngle, sweepAngle);
|
||
|
||
m_pInternal->m_oSimpleGraphicsConverter.PathCommandArcTo(x, y, w, h, startAngle, sweepAngle);
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::PathCommandClose()
|
||
{
|
||
if (m_pInternal->m_bIsOnlyTextMode)
|
||
return S_OK;
|
||
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.PathCommandClose();
|
||
|
||
if (c_nSimpleGraphicType == m_pInternal->m_lCurrentCommandType)
|
||
{
|
||
m_pInternal->Close();
|
||
}
|
||
else
|
||
{
|
||
m_pInternal->m_oSimpleGraphicsConverter.PathCommandClose();
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::PathCommandEnd()
|
||
{
|
||
if (m_pInternal->m_bIsOnlyTextMode)
|
||
return S_OK;
|
||
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.PathCommandEnd();
|
||
|
||
if (c_nSimpleGraphicType == m_pInternal->m_lCurrentCommandType)
|
||
{
|
||
m_pInternal->End();
|
||
}
|
||
else
|
||
{
|
||
m_pInternal->m_oSimpleGraphicsConverter.PathCommandEnd();
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::DrawPath(const LONG& nType)
|
||
{
|
||
if (m_pInternal->m_bIsOnlyTextMode)
|
||
return S_OK;
|
||
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.DrawPath(nType);
|
||
|
||
m_pInternal->m_oWriter.WriteDrawPath(nType);
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::PathCommandStart()
|
||
{
|
||
if (m_pInternal->m_bIsOnlyTextMode)
|
||
return S_OK;
|
||
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.PathCommandStart();
|
||
|
||
if (c_nSimpleGraphicType == m_pInternal->m_lCurrentCommandType)
|
||
{
|
||
m_pInternal->Start();
|
||
}
|
||
else
|
||
{
|
||
m_pInternal->m_oSimpleGraphicsConverter.PathCommandEnd();
|
||
m_pInternal->m_oSimpleGraphicsConverter.PathCommandStart();
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::PathCommandGetCurrentPoint(double* x, double* y)
|
||
{
|
||
if (m_pInternal->m_bIsOnlyTextMode)
|
||
return S_OK;
|
||
|
||
m_pInternal->m_oSimpleGraphicsConverter.PathCommandGetCurrentPoint(x, y);
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::PathCommandTextCHAR(const LONG& c, const double& x, const double& y, const double& w, const double& h)
|
||
{
|
||
if (m_pInternal->m_bIsOnlyTextMode)
|
||
return S_OK;
|
||
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.PathCommandTextCHAR(c, x, y, w, h);
|
||
|
||
int _c = (int)c;
|
||
|
||
m_pInternal->_SetFont();
|
||
m_pInternal->m_oSimpleGraphicsConverter.PathCommandText2(&_c, NULL, 1, m_pInternal->m_pFontManager, x, y, w, h);
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::PathCommandText(const std::wstring& bsText, const double& x, const double& y, const double& w, const double& h)
|
||
{
|
||
if (m_pInternal->m_bIsOnlyTextMode)
|
||
return S_OK;
|
||
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.PathCommandText(bsText, x, y, w, h);
|
||
|
||
m_pInternal->GetUnicodes(bsText);
|
||
|
||
m_pInternal->_SetFont();
|
||
m_pInternal->m_oSimpleGraphicsConverter.PathCommandText2(m_pInternal->m_pTempUnicodes, NULL, m_pInternal->m_nTempUnicodesLen,
|
||
m_pInternal->m_pFontManager, x, y, w, h);
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::PathCommandTextExCHAR(const LONG& c, const LONG& gid, const double& x, const double& y, const double& w, const double& h)
|
||
{
|
||
if (m_pInternal->m_bIsOnlyTextMode)
|
||
return S_OK;
|
||
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.PathCommandTextExCHAR(c, gid, x, y, w, h);
|
||
|
||
int _c = (int)c;
|
||
int _g = (int)gid;
|
||
|
||
m_pInternal->_SetFont();
|
||
m_pInternal->m_oSimpleGraphicsConverter.PathCommandText2(&_c, &_g, 1,
|
||
m_pInternal->m_pFontManager, x, y, w, h);
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::PathCommandTextEx(const std::wstring& bsUnicodeText, const unsigned int* pGids, const unsigned int nGidsCount, const double& x, const double& y, const double& w, const double& h)
|
||
{
|
||
if (m_pInternal->m_bIsOnlyTextMode)
|
||
return S_OK;
|
||
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.PathCommandTextEx(bsUnicodeText, pGids, nGidsCount, x, y, w, h);
|
||
|
||
m_pInternal->_SetFont();
|
||
m_pInternal->m_oSimpleGraphicsConverter.PathCommandText2(NULL, (const int*)pGids, nGidsCount,
|
||
m_pInternal->m_pFontManager, x, y, w, h);
|
||
return S_OK;
|
||
}
|
||
|
||
//-------- Функции для вывода изображений ---------------------------------------------------
|
||
HRESULT CASCHTMLRenderer3::DrawImage(IGrObject* pImage, const double& x, const double& y, const double& w, const double& h)
|
||
{
|
||
if (m_pInternal->m_bIsOnlyTextMode)
|
||
return S_OK;
|
||
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.DrawImage(pImage, x, y, w, h);
|
||
|
||
if (NULL == pImage)
|
||
return S_OK;
|
||
|
||
m_pInternal->m_oWriter.WriteImage(pImage, x, y, w, h);
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT CASCHTMLRenderer3::DrawImageFromFile(const std::wstring& sPath, const double& x, const double& y, const double& w, const double& h, const BYTE& lAlpha)
|
||
{
|
||
if (m_pInternal->m_bIsOnlyTextMode)
|
||
return S_OK;
|
||
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.DrawImageFromFile(sPath, x, y, w, h, lAlpha);
|
||
|
||
m_pInternal->m_oWriter.WriteImage(sPath, x, y, w, h);
|
||
return S_OK;
|
||
}
|
||
|
||
// transform --------------------------------------------------------------------------------
|
||
HRESULT CASCHTMLRenderer3::SetTransform(const double& m1, const double& m2, const double& m3, const double& m4, const double& m5, const double& m6)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.SetTransform(m1, m2, m3, m4, m5, m6);
|
||
|
||
m_pInternal->m_oTransform.SetElements(m1, m2, m3, m4, m5, m6);
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::GetTransform(double *pdA, double *pdB, double *pdC, double *pdD, double *pdE, double *pdF)
|
||
{
|
||
*pdA = m_pInternal->m_oTransform.sx();
|
||
*pdB = m_pInternal->m_oTransform.shy();
|
||
*pdC = m_pInternal->m_oTransform.shx();
|
||
*pdD = m_pInternal->m_oTransform.sy();
|
||
*pdE = m_pInternal->m_oTransform.tx();
|
||
*pdF = m_pInternal->m_oTransform.ty();
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::ResetTransform()
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.ResetTransform();
|
||
|
||
m_pInternal->m_oTransform.Reset();
|
||
return S_OK;
|
||
}
|
||
|
||
// -----------------------------------------------------------------------------------------
|
||
HRESULT CASCHTMLRenderer3::get_ClipMode(LONG* plMode)
|
||
{
|
||
*plMode = m_pInternal->m_lClipMode;
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_ClipMode(const LONG& lMode)
|
||
{
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.put_ClipMode(lMode);
|
||
|
||
m_pInternal->m_lClipMode = lMode;
|
||
m_pInternal->m_oWriter.m_oSVGWriter.m_lClipMode = lMode;
|
||
return S_OK;
|
||
}
|
||
|
||
// additiaonal params ----------------------------------------------------------------------
|
||
HRESULT CASCHTMLRenderer3::CommandLong(const LONG& lType, const LONG& lCommand)
|
||
{
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::CommandDouble(const LONG& lType, const double& dCommand)
|
||
{
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::CommandString(const LONG& lType, const std::wstring& sCommand)
|
||
{
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT CASCHTMLRenderer3::StartConvertCoordsToIdentity()
|
||
{
|
||
m_bUseTransformCoordsToIdentity = true;
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.StartConvertCoordsToIdentity();
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::EndConvertCoordsToIdentity()
|
||
{
|
||
m_bUseTransformCoordsToIdentity = false;
|
||
if (m_pInternal->m_bIsGraphicsDumperMode)
|
||
return m_pInternal->m_oDumper.EndConvertCoordsToIdentity();
|
||
return S_OK;
|
||
}
|
||
|
||
// owner params ----------------------------------------------------------------------
|
||
HRESULT CASCHTMLRenderer3::get_Mode(LONG *plMode)
|
||
{
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::put_Mode(LONG lMode)
|
||
{
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT CASCHTMLRenderer3::CreateOfficeFile(std::wstring bsFileName, const std::wstring& fontsDir)
|
||
{
|
||
if (fontsDir.empty())
|
||
m_pInternal->m_pApplicationFonts->Initialize();
|
||
else
|
||
m_pInternal->m_pApplicationFonts->InitializeFromFolder(fontsDir);
|
||
|
||
m_pInternal->m_strDstFile = bsFileName;
|
||
|
||
size_t pos1 = m_pInternal->m_strDstFile.find_last_of(wchar_t('/'));
|
||
size_t pos2 = m_pInternal->m_strDstFile.find_last_of(wchar_t('\\'));
|
||
|
||
size_t pos = std::wstring::npos;
|
||
if (pos1 != std::wstring::npos)
|
||
pos = pos1;
|
||
|
||
if (pos2 != std::wstring::npos)
|
||
{
|
||
if (pos == std::wstring::npos)
|
||
pos = pos2;
|
||
else if (pos2 > pos)
|
||
pos = pos2;
|
||
}
|
||
|
||
if (pos == std::wstring::npos)
|
||
return S_FALSE;
|
||
|
||
std::wstring strDir = m_pInternal->m_strDstFile.substr(0, pos);
|
||
|
||
size_t nIndexExt = m_pInternal->m_strDstFile.find_last_of(wchar_t('.'));
|
||
if (nIndexExt == std::wstring::npos || nIndexExt <= pos)
|
||
nIndexExt = pos;
|
||
|
||
std::wstring strName = m_pInternal->m_strDstFile.substr(pos + 1, nIndexExt - pos - 1);
|
||
|
||
m_pInternal->m_oWriter.m_pTransform = &m_pInternal->m_oTransform;
|
||
m_pInternal->m_oWriter.CreateFile(strDir, strName);
|
||
m_pInternal->m_oWriter.WriteStartDocument();
|
||
|
||
m_pInternal->m_oWriter.m_oSmartText.m_oFontManager.Init(m_pInternal->m_pApplicationFonts);
|
||
|
||
m_pInternal->m_lCurrentPage = -1;
|
||
m_pInternal->m_bPageOpened = false;
|
||
|
||
m_pInternal->m_pFontManager = m_pInternal->m_pApplicationFonts->GenerateFontManager();
|
||
NSFonts::IFontsCache* pGraphicsFontCache = NSFonts::NSFontCache::Create();
|
||
pGraphicsFontCache->SetStreams(m_pInternal->m_pApplicationFonts->GetStreams());
|
||
pGraphicsFontCache->SetCacheSize(16);
|
||
m_pInternal->m_pFontManager->SetOwnerCache(pGraphicsFontCache);
|
||
|
||
m_pInternal->m_oFont.SetDefaultParams();
|
||
m_pInternal->m_oInstalledFont.SetDefaultParams();
|
||
|
||
m_pInternal->m_oSimpleGraphicsConverter.SetRenderer(this);
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::CloseFile(bool bIsNoBase64)
|
||
{
|
||
if (m_pInternal->m_bPageOpened)
|
||
{
|
||
m_pInternal->EndPage();
|
||
}
|
||
|
||
m_pInternal->m_oWriter.WriteEndDocument(m_pInternal->m_oDocument, bIsNoBase64);
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT CASCHTMLRenderer3::SetAdditionalParam(std::string sParamName, int nValue)
|
||
{
|
||
if ("SourceType" == sParamName)
|
||
{
|
||
m_pInternal->m_oWriter.m_lSrcFileType = nValue;
|
||
return S_OK;
|
||
}
|
||
return S_OK;
|
||
}
|
||
HRESULT CASCHTMLRenderer3::SetAdditionalParam(std::string sParamName, const std::wstring& sParam)
|
||
{
|
||
if ("DisablePageEnd" == sParamName)
|
||
{
|
||
m_pInternal->m_bDisablePageEnd = L"yes" == sParam;
|
||
}
|
||
|
||
if (m_pInternal->m_bIsOnlyTextMode)
|
||
return S_OK;
|
||
|
||
if ("TilingHtmlPattern" == sParamName)
|
||
{
|
||
if (1 == m_pInternal->m_oWriter.m_lTilingCounter)
|
||
{
|
||
m_pInternal->m_bIsGraphicsDumperMode = true;
|
||
m_pInternal->m_oDumper.m_oTile.LoadFromXml(sParam);
|
||
|
||
m_pInternal->m_oDumper.NewPage(m_pInternal->m_oWriter.m_dWidth, m_pInternal->m_oWriter.m_dHeight);
|
||
|
||
m_pInternal->m_oDumper.m_oTile.bbox_x = 0;
|
||
m_pInternal->m_oDumper.m_oTile.bbox_y = 0;
|
||
m_pInternal->m_oDumper.m_oTile.bbox_r = m_pInternal->m_oDumper.m_lWidthPix - 1;
|
||
m_pInternal->m_oDumper.m_oTile.bbox_b = m_pInternal->m_oDumper.m_lHeightPix - 1;
|
||
|
||
m_pInternal->m_oDumper.m_oBounds.left = 0;
|
||
m_pInternal->m_oDumper.m_oBounds.top = 0;
|
||
m_pInternal->m_oDumper.m_oBounds.right = m_pInternal->m_oDumper.m_lWidthPix - 1;
|
||
m_pInternal->m_oDumper.m_oBounds.bottom = m_pInternal->m_oDumper.m_lHeightPix - 1;
|
||
}
|
||
}
|
||
return S_OK;
|
||
}
|
||
|
||
bool CASCHTMLRenderer3::GetOnlyTextMode()
|
||
{
|
||
return m_pInternal->m_bIsOnlyTextMode;
|
||
}
|
||
|
||
void CASCHTMLRenderer3::SetOnlyTextMode(const bool& enabled)
|
||
{
|
||
m_pInternal->m_oWriter.m_bIsOnlyTextMode = enabled;
|
||
m_pInternal->m_bIsOnlyTextMode = enabled;
|
||
}
|
||
|
||
void CASCHTMLRenderer3::GetLastPageInfo(int& paragraphs, int& words, int& symbols, int& spaces, std::string& sBase64Data)
|
||
{
|
||
m_pInternal->m_oWriter.GetLastPageInfo(paragraphs, words, symbols, spaces, sBase64Data);
|
||
}
|
||
}
|