Yajbir Singh
4644 lines
143 KiB
C++
4644 lines
143 KiB
C++
/*
|
|
* (c) Copyright Ascensio System SIA 2010-2023
|
|
*
|
|
* 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-6 Ernesta Birznieka-Upish
|
|
* 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 "../DesktopEditor/common/File.h"
|
|
#include "../DesktopEditor/common/Directory.h"
|
|
|
|
#include "PdfWriter.h"
|
|
|
|
#include "SrcWriter/Document.h"
|
|
#include "SrcWriter/Pages.h"
|
|
#include "SrcWriter/Image.h"
|
|
#include "SrcWriter/Font.h"
|
|
#include "SrcWriter/FontCidTT.h"
|
|
#include "SrcWriter/FontTT.h"
|
|
#include "SrcWriter/Font14.h"
|
|
#include "SrcWriter/Destination.h"
|
|
#include "SrcWriter/Field.h"
|
|
#include "SrcWriter/Outline.h"
|
|
#include "SrcWriter/Utils.h"
|
|
|
|
#include "Resources/BaseFonts.h"
|
|
#include "../DesktopEditor/graphics/Image.h"
|
|
#include "../DesktopEditor/graphics/structures.h"
|
|
#include "../DesktopEditor/raster/BgraFrame.h"
|
|
#include "../DesktopEditor/raster/ImageFileFormatChecker.h"
|
|
#include "../DesktopEditor/graphics/pro/Fonts.h"
|
|
#include "../DesktopEditor/graphics/pro/Image.h"
|
|
#include "../DesktopEditor/common/StringExt.h"
|
|
#include "../DesktopEditor/graphics/GraphicsPath.h"
|
|
#include "../DesktopEditor/graphics/MetafileToRenderer.h"
|
|
#include "../DesktopEditor/raster/Metafile/MetaFileCommon.h"
|
|
|
|
#include "../UnicodeConverter/UnicodeConverter.h"
|
|
#ifndef BUILDING_WASM_MODULE
|
|
#include "../Common/Network/FileTransporter/include/FileTransporter.h"
|
|
#endif
|
|
|
|
#if defined(GetTempPath)
|
|
#undef GetTempPath
|
|
#endif
|
|
|
|
#if defined(CreateFile)
|
|
#undef CreateFile
|
|
#endif
|
|
|
|
#if defined(CreateDirectory)
|
|
#undef CreateDirectory
|
|
#endif
|
|
|
|
#define MM_2_PT(X) ((X) * 72.0 / 25.4)
|
|
#define PT_2_MM(X) ((X) * 25.4 / 72.0)
|
|
|
|
#define MM_TO_PT(value) (value * 300.0 / 25.4)
|
|
|
|
#define LONG_2_BOOL(X) ((X) ? true : false)
|
|
|
|
#ifdef DrawText
|
|
#undef DrawText
|
|
#endif
|
|
|
|
#ifdef LoadImage
|
|
#undef LoadImage
|
|
#endif
|
|
|
|
#define HI_SURROGATE_START 0xD800
|
|
#define HI_SURROGATE_END 0xDBFF
|
|
#define LO_SURROGATE_START 0xDC00
|
|
#define LO_SURROGATE_END 0xDFFF
|
|
|
|
// Этих типов браша нет в рендерере, мы их используем, когда конвертим из веба
|
|
static const long c_BrushTypeLinearGradient = 8001;
|
|
static const long c_BrushTypeRadialGradient = 8002;
|
|
|
|
Aggplus::CImage* ConvertMetafile(NSFonts::IApplicationFonts* pAppFonts, const std::wstring& wsPath, const std::wstring& wsTempDirectory, double dWidth = -1, double dHeight = -1)
|
|
{
|
|
if (wsPath.find(L"data:") == 0)
|
|
{
|
|
std::wstring::size_type posZ = wsPath.find(L',');
|
|
int nBase64Size = (int)(wsPath.length() - posZ - 1);
|
|
const wchar_t* pBase64Data = wsPath.c_str() + posZ + 1;
|
|
|
|
char* pBase64Buffer = new char[nBase64Size];
|
|
for (int i = 0; i < nBase64Size; ++i)
|
|
pBase64Buffer[i] = (char)pBase64Data[i];
|
|
|
|
int nBufferLen = NSBase64::Base64DecodeGetRequiredLength(nBase64Size);
|
|
BYTE* pImageBuffer = new BYTE[nBufferLen + 64];
|
|
|
|
Aggplus::CImage* pImage = new Aggplus::CImage();
|
|
if (NSBase64::Base64Decode(pBase64Buffer, nBase64Size, pImageBuffer, &nBufferLen))
|
|
pImage->Decode(pImageBuffer, nBufferLen);
|
|
|
|
RELEASEARRAYOBJECTS(pImageBuffer);
|
|
RELEASEARRAYOBJECTS(pBase64Buffer);
|
|
return pImage;
|
|
}
|
|
|
|
CImageFileFormatChecker oImageFormat(wsPath);
|
|
if (_CXIMAGE_FORMAT_WMF == oImageFormat.eFileType ||
|
|
_CXIMAGE_FORMAT_EMF == oImageFormat.eFileType ||
|
|
_CXIMAGE_FORMAT_SVM == oImageFormat.eFileType ||
|
|
_CXIMAGE_FORMAT_SVG == oImageFormat.eFileType)
|
|
{
|
|
MetaFile::IMetaFile* pMeta = MetaFile::Create(pAppFonts);
|
|
|
|
if (NULL == pMeta || !pMeta->LoadFromFile(wsPath.c_str()))
|
|
return new Aggplus::CImage(wsPath);
|
|
|
|
bool bUseMax = false;
|
|
if (dWidth > 5000 || dHeight > 5000)
|
|
bUseMax = true;
|
|
else if (dWidth <= 0 && dHeight <= 0)
|
|
bUseMax = true;
|
|
|
|
if (!bUseMax)
|
|
pMeta->ConvertToRaster(wsTempDirectory.c_str(), _CXIMAGE_FORMAT_PNG, MM_2_PT(dWidth), MM_2_PT(dHeight));
|
|
else
|
|
MetaFile::ConvertToRasterMaxSize(pMeta, wsTempDirectory.c_str(), _CXIMAGE_FORMAT_PNG, 2000);
|
|
|
|
RELEASEOBJECT(pMeta);
|
|
|
|
return new Aggplus::CImage(wsTempDirectory);
|
|
}
|
|
|
|
return new Aggplus::CImage(wsPath);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
//
|
|
// CPdfRenderer
|
|
//
|
|
//----------------------------------------------------------------------------------------
|
|
CPdfWriter::CPdfWriter(NSFonts::IApplicationFonts* pAppFonts, bool isPDFA, IRenderer* pRenderer, bool bCreate, const std::wstring& wsTempDirectory) : m_oCommandManager(this)
|
|
{
|
|
// Создаем менеджер шрифтов с собственным кэшем
|
|
m_pFontManager = pAppFonts->GenerateFontManager();
|
|
NSFonts::IFontsCache* pMeasurerCache = NSFonts::NSFontCache::Create();
|
|
pMeasurerCache->SetStreams(pAppFonts->GetStreams());
|
|
m_pFontManager->SetOwnerCache(pMeasurerCache);
|
|
m_pRenderer = pRenderer;
|
|
m_bNeedAddHelvetica = true;
|
|
m_wsTempDirectory = wsTempDirectory;
|
|
m_pShading = NULL;
|
|
m_pShadingExtGrState = NULL;
|
|
|
|
m_pDocument = new PdfWriter::CDocument();
|
|
|
|
if (isPDFA)
|
|
m_pDocument->SetPDFAConformanceMode(true);
|
|
|
|
if (!m_pDocument || (bCreate && !m_pDocument->CreateNew()))
|
|
{
|
|
SetError();
|
|
return;
|
|
}
|
|
|
|
m_pDocument->SetCompressionMode(COMP_ALL);
|
|
|
|
m_bValid = true;
|
|
m_bSplit = false;
|
|
m_dPageHeight = 297;
|
|
m_dPageWidth = 210;
|
|
m_pPage = NULL;
|
|
m_pFont = NULL;
|
|
m_pFont14 = NULL;
|
|
m_lClipMode = 0;
|
|
|
|
m_unFieldsCounter = 0;
|
|
m_bNeedUpdateTextFont = true;
|
|
}
|
|
CPdfWriter::~CPdfWriter()
|
|
{
|
|
RELEASEOBJECT(m_pDocument);
|
|
RELEASEINTERFACE(m_pFontManager);
|
|
}
|
|
void CPdfWriter::SetPassword(const std::wstring& wsPassword)
|
|
{
|
|
if (!IsValid())
|
|
return;
|
|
|
|
m_pDocument->SetPasswords(wsPassword, wsPassword);
|
|
}
|
|
void CPdfWriter::SetDocumentID(const std::wstring& wsDocumentID)
|
|
{
|
|
if (!IsValid())
|
|
return;
|
|
|
|
m_pDocument->SetDocumentID(wsDocumentID);
|
|
}
|
|
int CPdfWriter::SaveToFile(const std::wstring& wsPath)
|
|
{
|
|
// TODO: Переделать на код ошибки
|
|
if (!IsValid())
|
|
return 1;
|
|
|
|
if (!m_pFont && !m_pFont14 && !m_pDocument->IsPDFA() && m_bNeedAddHelvetica)
|
|
{
|
|
m_bNeedUpdateTextFont = false;
|
|
m_pFont14 = m_pDocument->CreateFont14(L"Helvetica", 0, PdfWriter::EStandard14Fonts::standard14fonts_Helvetica);
|
|
CommandDrawTextCHAR(32, 0, 0, 0, 0);
|
|
}
|
|
|
|
m_oCommandManager.Flush();
|
|
|
|
if (!m_pDocument->SaveToFile(wsPath))
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
int CPdfWriter::SaveToMemory(BYTE** pData, int* pLength)
|
|
{
|
|
// TODO: Переделать на код ошибки
|
|
if (!IsValid())
|
|
return 1;
|
|
|
|
m_oCommandManager.Flush();
|
|
|
|
if (!m_pDocument->SaveToMemory(pData, pLength))
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
void CPdfWriter::SetDocumentInfo(const std::wstring& wsTitle, const std::wstring& wsCreator, const std::wstring& wsSubject, const std::wstring& wsKeywords)
|
|
{
|
|
if (!IsValid())
|
|
return;
|
|
|
|
if (!wsTitle.empty())
|
|
m_pDocument->SetTitle(U_TO_UTF8(wsTitle));
|
|
if (!wsCreator.empty())
|
|
{
|
|
std::string sAuthor = U_TO_UTF8(wsCreator);
|
|
NSStringUtils::string_replaceA(sAuthor, ";", ", ");
|
|
m_pDocument->SetAuthor(sAuthor);
|
|
}
|
|
if (!wsSubject.empty())
|
|
m_pDocument->SetSubject(U_TO_UTF8(wsSubject));
|
|
if (!wsKeywords.empty())
|
|
m_pDocument->SetKeywords(U_TO_UTF8(wsKeywords));
|
|
}
|
|
std::wstring CPdfWriter::GetTempFile(const std::wstring& wsDirectory)
|
|
{
|
|
return NSFile::CFileBinary::CreateTempFileWithUniqueName(wsDirectory, L"PDF");
|
|
}
|
|
void CPdfWriter::SetTempDirectory(const std::wstring& wsTempDirectory)
|
|
{
|
|
m_wsTempDirectory = wsTempDirectory;
|
|
}
|
|
//----------------------------------------------------------------------------------------
|
|
// Функции для работы со страницей
|
|
//----------------------------------------------------------------------------------------
|
|
HRESULT CPdfWriter::NewPage()
|
|
{
|
|
m_oCommandManager.Flush();
|
|
|
|
if (!IsValid())
|
|
return S_FALSE;
|
|
|
|
m_pPage = m_pDocument->AddPage();
|
|
|
|
if (!m_pPage)
|
|
{
|
|
SetError();
|
|
return S_FALSE;
|
|
}
|
|
|
|
m_pPage->SetWidth(MM_2_PT(m_dPageWidth));
|
|
m_pPage->SetHeight(MM_2_PT(m_dPageHeight));
|
|
|
|
Reset();
|
|
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_Height(double* dHeight)
|
|
{
|
|
*dHeight = m_dPageHeight;
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_Height(const double& dHeight, bool bMM2PT)
|
|
{
|
|
if (!IsValid() || !m_pPage)
|
|
return S_FALSE;
|
|
|
|
m_dPageHeight = bMM2PT ? dHeight : PT_2_MM(dHeight);
|
|
m_pPage->SetHeight(bMM2PT ? MM_2_PT(dHeight) : dHeight);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_Width(double* dWidth)
|
|
{
|
|
*dWidth = m_dPageWidth;
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_Width(const double& dWidth, bool bMM2PT)
|
|
{
|
|
if (!IsValid() || !m_pPage)
|
|
return S_FALSE;
|
|
|
|
m_dPageWidth = bMM2PT ? dWidth : PT_2_MM(dWidth);
|
|
m_pPage->SetWidth(bMM2PT ? MM_2_PT(dWidth) : dWidth);
|
|
return S_OK;
|
|
}
|
|
//----------------------------------------------------------------------------------------
|
|
// Функции для работы с Pen
|
|
//----------------------------------------------------------------------------------------
|
|
HRESULT CPdfWriter::get_PenColor(LONG* lColor)
|
|
{
|
|
*lColor = m_oPen.GetColor();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_PenColor(const LONG& lColor)
|
|
{
|
|
m_oPen.SetColor(lColor);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_PenAlpha(LONG* lAlpha)
|
|
{
|
|
*lAlpha = m_oPen.GetAlpha();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_PenAlpha(const LONG& lAlpha)
|
|
{
|
|
m_oPen.SetAlpha(lAlpha);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_PenSize(double* dSize)
|
|
{
|
|
*dSize = m_oPen.GetSize();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_PenSize(const double& dSize)
|
|
{
|
|
m_oPen.SetSize(dSize);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_PenDashStyle(BYTE* nDashStyle)
|
|
{
|
|
*nDashStyle = m_oPen.GetDashStyle();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_PenDashStyle(const BYTE& nDashStyle)
|
|
{
|
|
m_oPen.SetDashStyle(nDashStyle);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_PenLineStartCap(BYTE* nCapStyle)
|
|
{
|
|
*nCapStyle = m_oPen.GetStartCapStyle();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_PenLineStartCap(const BYTE& nCapStyle)
|
|
{
|
|
m_oPen.SetStartCapStyle(nCapStyle);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_PenLineEndCap(BYTE* nCapStyle)
|
|
{
|
|
*nCapStyle = m_oPen.GetEndCapStyle();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_PenLineEndCap(const BYTE& nCapStyle)
|
|
{
|
|
m_oPen.SetEndCapStyle(nCapStyle);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_PenLineJoin(BYTE* nJoinStyle)
|
|
{
|
|
*nJoinStyle = m_oPen.GetJoinStyle();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_PenLineJoin(const BYTE& nJoinStyle)
|
|
{
|
|
m_oPen.SetJoinStyle(nJoinStyle);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_PenDashOffset(double* dOffset)
|
|
{
|
|
*dOffset = m_oPen.GetDashOffset();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_PenDashOffset(const double& dOffset)
|
|
{
|
|
m_oPen.SetDashOffset(dOffset);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_PenAlign(LONG* lAlign)
|
|
{
|
|
*lAlign = m_oPen.GetAlign();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_PenAlign(const LONG& lAlign)
|
|
{
|
|
m_oPen.SetAlign(lAlign);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_PenMiterLimit(double* dMiter)
|
|
{
|
|
*dMiter = m_oPen.GetMiter();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_PenMiterLimit(const double& dMiter)
|
|
{
|
|
m_oPen.SetMiter(dMiter);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::PenDashPattern(double* pPattern, LONG lCount)
|
|
{
|
|
m_oPen.SetDashPattern(pPattern, lCount);
|
|
return S_OK;
|
|
}
|
|
//----------------------------------------------------------------------------------------
|
|
// Функции для работы с Brush
|
|
//----------------------------------------------------------------------------------------
|
|
HRESULT CPdfWriter::get_BrushType(LONG* lType)
|
|
{
|
|
*lType = m_oBrush.GetType();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_BrushType(const LONG& lType)
|
|
{
|
|
m_oBrush.SetType(lType);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_BrushColor1(LONG* lColor)
|
|
{
|
|
*lColor = m_oBrush.GetColor1();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_BrushColor1(const LONG& lColor)
|
|
{
|
|
if (lColor != m_oBrush.GetColor1())
|
|
{
|
|
m_oBrush.SetColor1(lColor);
|
|
}
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_BrushAlpha1(LONG* lAlpha)
|
|
{
|
|
*lAlpha = m_oBrush.GetAlpha1();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_BrushAlpha1(const LONG& lAlpha)
|
|
{
|
|
if (lAlpha != m_oBrush.GetAlpha1())
|
|
{
|
|
m_oBrush.SetAlpha1(lAlpha);
|
|
}
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_BrushColor2(LONG* lColor)
|
|
{
|
|
*lColor = m_oBrush.GetColor2();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_BrushColor2(const LONG& lColor)
|
|
{
|
|
m_oBrush.SetColor2(lColor);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_BrushAlpha2(LONG* lAlpha)
|
|
{
|
|
*lAlpha = m_oBrush.GetAlpha2();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_BrushAlpha2(const LONG& lAlpha)
|
|
{
|
|
m_oBrush.SetAlpha2(lAlpha);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_BrushTexturePath(std::wstring* wsPath)
|
|
{
|
|
*wsPath = m_oBrush.GetTexturePath();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_BrushTexturePath(const std::wstring& wsPath)
|
|
{
|
|
m_oBrush.SetTexturePath(wsPath);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_BrushTextureMode(LONG* lMode)
|
|
{
|
|
*lMode = m_oBrush.GetTextureMode();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_BrushTextureMode(const LONG& lMode)
|
|
{
|
|
m_oBrush.SetTextureMode(lMode);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_BrushTextureAlpha(LONG* lAlpha)
|
|
{
|
|
*lAlpha = m_oBrush.GetTextureAlpha();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_BrushTextureAlpha(const LONG& lAlpha)
|
|
{
|
|
m_oBrush.SetTextureAlpha(lAlpha);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_BrushLinearAngle(double* dAngle)
|
|
{
|
|
*dAngle = m_oBrush.GetLinearAngle();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_BrushLinearAngle(const double& dAngle)
|
|
{
|
|
m_oBrush.SetLinearAngle(dAngle);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::BrushRect(const INT& nVal, const double& dLeft, const double& dTop, const double& dWidth, const double& dHeight)
|
|
{
|
|
// Данными параметрами пользуемся, только если пришла команда EnableBrushRect, если команда не пришла, тогда
|
|
// ориентируемся на границы пата.
|
|
m_oBrush.SetBrushRect(nVal, dLeft, dTop, dWidth, dHeight);
|
|
m_oBrush.EnableBrushRect(1 == nVal ? true : false);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_BrushGradientColors(LONG* lColors, double* pPositions, LONG lCount)
|
|
{
|
|
m_oBrush.SetGradientColors(lColors, pPositions, lCount);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_BrushTextureImage(Aggplus::CImage** pImage)
|
|
{
|
|
// TODO:
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_BrushTextureImage(Aggplus::CImage* pImage)
|
|
{
|
|
// TODO:
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_BrushTransform(Aggplus::CMatrix& oMatrix)
|
|
{
|
|
// TODO:
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_BrushTransform(const Aggplus::CMatrix& oMatrix)
|
|
{
|
|
// TODO:
|
|
return S_OK;
|
|
}
|
|
//----------------------------------------------------------------------------------------
|
|
// Функции для работы со шрифтами
|
|
//----------------------------------------------------------------------------------------
|
|
HRESULT CPdfWriter::get_FontName(std::wstring* wsName)
|
|
{
|
|
*wsName = m_oFont.GetName();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_FontName(const std::wstring& wsName)
|
|
{
|
|
if (wsName != m_oFont.GetName())
|
|
{
|
|
m_oFont.SetName(wsName);
|
|
m_bNeedUpdateTextFont = true;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_FontPath(std::wstring* wsPath)
|
|
{
|
|
*wsPath = m_oFont.GetPath();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_FontPath(const std::wstring& wsPath)
|
|
{
|
|
if (wsPath != m_oFont.GetPath())
|
|
{
|
|
m_oFont.SetPath(wsPath);
|
|
m_bNeedUpdateTextFont = true;
|
|
}
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_FontSize(double* dSize)
|
|
{
|
|
*dSize = m_oFont.GetSize();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_FontSize(const double& dSize)
|
|
{
|
|
if (fabs(dSize - m_oFont.GetSize()) > 0.001)
|
|
{
|
|
m_oFont.SetSize(dSize);
|
|
}
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_FontStyle(LONG* lStyle)
|
|
{
|
|
*lStyle = m_oFont.GetStyle();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_FontStyle(const LONG& lStyle)
|
|
{
|
|
if (lStyle != m_oFont.GetStyle())
|
|
{
|
|
m_oFont.SetStyle(lStyle);
|
|
m_bNeedUpdateTextFont = true;
|
|
}
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_FontStringGID(INT* bGid)
|
|
{
|
|
*bGid = m_oFont.GetGid() ? 1 : 0;
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_FontStringGID(const INT& bGid)
|
|
{
|
|
m_oFont.SetGid(bGid ? true : false);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_FontCharSpace(double* dSpace)
|
|
{
|
|
*dSpace = m_oFont.GetCharSpace();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_FontCharSpace(const double& dSpace)
|
|
{
|
|
if (fabs(dSpace - m_oFont.GetCharSpace()) > 0.001)
|
|
{
|
|
m_oFont.SetCharSpace(dSpace);
|
|
}
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_FontFaceIndex(int* nFaceIndex)
|
|
{
|
|
*nFaceIndex = (int)m_oFont.GetFaceIndex();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_FontFaceIndex(const int& nFaceIndex)
|
|
{
|
|
if (nFaceIndex != m_oFont.GetFaceIndex())
|
|
{
|
|
m_oFont.SetFaceIndex(nFaceIndex);
|
|
m_bNeedUpdateTextFont = true;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
//----------------------------------------------------------------------------------------
|
|
// Функции для вывода текста
|
|
//----------------------------------------------------------------------------------------
|
|
bool UnicodePUA(unsigned int unUnicode)
|
|
{
|
|
return (unUnicode >= 0xE000 && unUnicode <= 0xF8FF) || (unUnicode >= 0xF0000 && unUnicode <= 0xFFFFD) || (unUnicode >= 0x100000 && unUnicode <= 0x10FFFD);
|
|
}
|
|
bool UnicodesPUA(unsigned int* pUnicodes, unsigned int unLen)
|
|
{
|
|
for (int i = 0; i < unLen; ++i)
|
|
{
|
|
if (UnicodePUA(pUnicodes[i]))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
HRESULT CPdfWriter::CommandDrawTextCHAR(const LONG& lUnicode, const double& dX, const double& dY, const double& dW, const double& dH)
|
|
{
|
|
if (!IsPageValid())
|
|
return S_FALSE;
|
|
|
|
unsigned int unUnicode = lUnicode;
|
|
unsigned char* pCodes = EncodeString(&unUnicode, 1);
|
|
if (!pCodes)
|
|
return DrawTextToRenderer(NULL, 0, dX, dY, NSStringExt::CConverter::GetUnicodeFromUTF32(&unUnicode, 1)) ? S_OK : S_FALSE;
|
|
return DrawText(pCodes, 2, dX, dY, UnicodePUA(unUnicode) ? NSStringExt::CConverter::GetUtf8FromUTF32(&unUnicode, 1) : "") ? S_OK : S_FALSE;
|
|
}
|
|
HRESULT CPdfWriter::CommandDrawText(const std::wstring& wsUnicodeText, const double& dX, const double& dY, const double& dW, const double& dH)
|
|
{
|
|
if (!IsPageValid() || !wsUnicodeText.size())
|
|
return S_FALSE;
|
|
|
|
unsigned int unLen;
|
|
unsigned int* pUnicodes = NSStringExt::CConverter::GetUtf32FromUnicode(wsUnicodeText, unLen);
|
|
if (!pUnicodes)
|
|
return S_FALSE;
|
|
|
|
unsigned char* pCodes = EncodeString(pUnicodes, unLen);
|
|
std::string sPUA;
|
|
if (UnicodesPUA(pUnicodes, unLen))
|
|
sPUA = NSStringExt::CConverter::GetUtf8FromUTF32(pUnicodes, unLen);
|
|
delete[] pUnicodes;
|
|
|
|
if (!pCodes)
|
|
return DrawTextToRenderer(NULL, 0, dX, dY, wsUnicodeText) ? S_OK : S_FALSE;
|
|
|
|
// Специальный случай для текста из Djvu, нам не нужно, чтобы он рисовался
|
|
if (L"" == m_oFont.GetPath() && L"DjvuEmptyFont" == m_oFont.GetName())
|
|
{
|
|
if (m_bNeedUpdateTextFont)
|
|
{
|
|
m_oFont.SetName(L"Arial");
|
|
UpdateFont();
|
|
m_oFont.SetName(L"DjvuEmptyFont");
|
|
if (!m_pFont)
|
|
return S_FALSE;
|
|
}
|
|
|
|
double dFontSize = MM_2_PT(dH);
|
|
double dStringWidth = 0;
|
|
for (unsigned int unIndex = 0; unIndex < unLen; unIndex++)
|
|
{
|
|
unsigned short ushCode = (pCodes[2 * unIndex] << 8) + pCodes[2 * unIndex + 1];
|
|
dStringWidth += m_pFont->GetWidth(ushCode) * dFontSize / 1000.0;
|
|
}
|
|
|
|
double dResultWidth = MM_2_PT(dW);
|
|
|
|
CTransform& t = m_oTransform;
|
|
m_oCommandManager.SetTransform(t.m11, -t.m12, -t.m21, t.m22, MM_2_PT(t.dx + t.m21 * m_dPageHeight), MM_2_PT(m_dPageHeight - m_dPageHeight * t.m22 - t.dy));
|
|
|
|
CRendererTextCommand* pText = m_oCommandManager.AddText(pCodes, unLen * 2, MM_2_PT(dX), MM_2_PT(m_dPageHeight - dY - dH));
|
|
pText->SetFont(m_pFont);
|
|
pText->SetSize(dFontSize);
|
|
pText->SetMode(PdfWriter::textrenderingmode_Invisible);
|
|
if (fabs(dStringWidth) > 0.001)
|
|
pText->SetHorScaling(dResultWidth / dStringWidth * 100);
|
|
pText->SetPUA(sPUA);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
return DrawText(pCodes, unLen * 2, dX, dY, sPUA) ? S_OK : S_FALSE;
|
|
}
|
|
HRESULT CPdfWriter::CommandDrawTextExCHAR(const LONG& lUnicode, const LONG& lGid, const double& dX, const double& dY, const double& dW, const double& dH)
|
|
{
|
|
if (!IsPageValid())
|
|
return S_FALSE;
|
|
|
|
unsigned int unUnicode = lUnicode;
|
|
unsigned int unGID = lGid;
|
|
unsigned char* pCodes = EncodeGID(unGID, &unUnicode, 1);
|
|
if (!pCodes)
|
|
return DrawTextToRenderer(&unGID, 1, dX, dY) ? S_OK : S_FALSE;
|
|
return DrawText(pCodes, 2, dX, dY, UnicodePUA(unUnicode) ? NSStringExt::CConverter::GetUtf8FromUTF32(&unUnicode, 1) : "") ? S_OK : S_FALSE;
|
|
}
|
|
HRESULT CPdfWriter::CommandDrawTextEx(const std::wstring& wsUnicodeText, const unsigned int* pGids, const unsigned int unGidsCount, const double& dX, const double& dY, const double& dW, const double& dH)
|
|
{
|
|
if (!IsPageValid() || (!wsUnicodeText.size() && (!pGids || !unGidsCount)))
|
|
return S_FALSE;
|
|
|
|
unsigned int unLen = 0;
|
|
unsigned int* pUnicodes = NULL;
|
|
if (pGids && unGidsCount)
|
|
{
|
|
unLen = unGidsCount;
|
|
if (wsUnicodeText.size())
|
|
{
|
|
unsigned int unUnicodeLen;
|
|
pUnicodes = NSStringExt::CConverter::GetUtf32FromUnicode(wsUnicodeText, unUnicodeLen);
|
|
if (!pUnicodes || unUnicodeLen != unLen)
|
|
RELEASEARRAYOBJECTS(pUnicodes);
|
|
}
|
|
|
|
if (!pUnicodes)
|
|
{
|
|
pUnicodes = new unsigned int[unLen];
|
|
if (!pUnicodes)
|
|
return S_FALSE;
|
|
|
|
for (unsigned int unIndex = 0; unIndex < unLen; unIndex++)
|
|
pUnicodes[unIndex] = pGids[unIndex];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pUnicodes = NSStringExt::CConverter::GetUtf32FromUnicode(wsUnicodeText, unLen);
|
|
if (!pUnicodes)
|
|
return S_FALSE;
|
|
}
|
|
|
|
unsigned char* pCodes = EncodeString(pUnicodes, unLen, pGids);
|
|
std::string sPUA;
|
|
if (UnicodesPUA(pUnicodes, unLen))
|
|
sPUA = NSStringExt::CConverter::GetUtf8FromUTF32(pUnicodes, unLen);
|
|
RELEASEARRAYOBJECTS(pUnicodes);
|
|
if (!pCodes)
|
|
return DrawTextToRenderer(pGids, unGidsCount, dX, dY) ? S_OK : S_FALSE;
|
|
return DrawText(pCodes, unLen * 2, dX, dY, sPUA) ? S_OK : S_FALSE;
|
|
}
|
|
HRESULT CPdfWriter::CommandDrawTextCHAR2(unsigned int* pUnicodes, const unsigned int& unUnicodeCount, const unsigned int& unGid, const double& dX, const double& dY, const double& dW, const double& dH)
|
|
{
|
|
if (!IsPageValid())
|
|
return S_FALSE;
|
|
|
|
unsigned char* pCodes = EncodeGID(unGid, pUnicodes, unUnicodeCount);
|
|
if (!pCodes)
|
|
return DrawTextToRenderer(&unGid, 1, dX, dY) ? S_OK : S_FALSE;
|
|
return DrawText(pCodes, 2, dX, dY, UnicodesPUA(pUnicodes, unUnicodeCount) ? NSStringExt::CConverter::GetUtf8FromUTF32(pUnicodes, unUnicodeCount) : "") ? S_OK : S_FALSE;
|
|
}
|
|
//----------------------------------------------------------------------------------------
|
|
// Маркеры команд
|
|
//----------------------------------------------------------------------------------------
|
|
HRESULT CPdfWriter::EndCommand(const DWORD& dwType)
|
|
{
|
|
if (!IsPageValid())
|
|
return S_FALSE;
|
|
|
|
// Здесь мы различаем лишь 2 команды: присоединить текущий пат к клипу и отменить клип
|
|
if (c_nClipType == dwType)
|
|
{
|
|
m_oCommandManager.Flush();
|
|
m_pPage->GrSave();
|
|
m_lClipDepth++;
|
|
UpdateTransform();
|
|
|
|
m_oPath.Clip(m_pPage, c_nClipRegionTypeEvenOdd & m_lClipMode);
|
|
}
|
|
else if (c_nResetClipType == dwType)
|
|
{
|
|
m_oCommandManager.Flush();
|
|
while (m_lClipDepth)
|
|
{
|
|
m_pPage->GrRestore();
|
|
m_lClipDepth--;
|
|
}
|
|
}
|
|
else if (c_nPageType == dwType)
|
|
{
|
|
for (int nIndex = 0, nCount = m_vDestinations.size(); nIndex < nCount; ++nIndex)
|
|
{
|
|
TDestinationInfo& oInfo = m_vDestinations.at(nIndex);
|
|
if (m_pDocument->GetPagesCount() > oInfo.unDestPage)
|
|
{
|
|
AddLink(oInfo.pPage, oInfo.dX, oInfo.dY, oInfo.dW, oInfo.dH, oInfo.dDestX, oInfo.dDestY, oInfo.unDestPage);
|
|
m_vDestinations.erase(m_vDestinations.begin() + nIndex);
|
|
nIndex--;
|
|
nCount--;
|
|
}
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
//----------------------------------------------------------------------------------------
|
|
// Функции для работы с патом
|
|
//----------------------------------------------------------------------------------------
|
|
HRESULT CPdfWriter::PathCommandStart()
|
|
{
|
|
m_oPath.Clear();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::PathCommandEnd()
|
|
{
|
|
m_oPath.Clear();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::DrawPath(NSFonts::IApplicationFonts* pAppFonts, const std::wstring& wsTempDirectory, const LONG& lType, bool bIgnoreRedact)
|
|
{
|
|
m_oCommandManager.Flush();
|
|
|
|
if (!IsPageValid())
|
|
return S_FALSE;
|
|
|
|
bool bStroke = LONG_2_BOOL(lType & c_nStroke);
|
|
bool bFill = LONG_2_BOOL(lType & c_nWindingFillMode);
|
|
bool bEoFill = LONG_2_BOOL(lType & c_nEvenOddFillMode);
|
|
|
|
m_pPage->GrSave();
|
|
UpdateTransform();
|
|
|
|
if (bStroke)
|
|
UpdatePen();
|
|
|
|
std::wstring sTextureOldPath = L"";
|
|
std::wstring sTextureTmpPath = L"";
|
|
|
|
if (bFill || bEoFill)
|
|
{
|
|
if (c_BrushTypeTexture == m_oBrush.GetType())
|
|
{
|
|
sTextureOldPath = m_oBrush.GetTexturePath();
|
|
sTextureTmpPath = GetDownloadFile(sTextureOldPath, wsTempDirectory);
|
|
|
|
if (!sTextureTmpPath.empty())
|
|
m_oBrush.SetTexturePath(sTextureTmpPath);
|
|
}
|
|
|
|
UpdateBrush(pAppFonts, wsTempDirectory);
|
|
}
|
|
|
|
if (!bIgnoreRedact && !m_arrRedact.empty())
|
|
{
|
|
PdfWriter::CMatrix* pMatrix = m_pPage->GetTransform();
|
|
m_oPath.Redact(pMatrix, m_arrRedact, m_pPage, bStroke, bFill, bEoFill, m_pShading, m_pShadingExtGrState);
|
|
|
|
m_pPage->GrRestore();
|
|
if (!sTextureTmpPath.empty())
|
|
m_oBrush.SetTexturePath(sTextureOldPath);
|
|
return S_OK;
|
|
}
|
|
|
|
if (!m_pShading)
|
|
{
|
|
m_oPath.Draw(m_pPage, bStroke, bFill, bEoFill);
|
|
}
|
|
else
|
|
{
|
|
if (bFill || bEoFill)
|
|
{
|
|
m_pPage->GrSave();
|
|
m_oPath.Clip(m_pPage, bEoFill);
|
|
|
|
if (NULL != m_pShadingExtGrState)
|
|
m_pPage->SetExtGrState(m_pShadingExtGrState);
|
|
|
|
m_pPage->DrawShading(m_pShading);
|
|
m_pPage->GrRestore();
|
|
}
|
|
|
|
if (bStroke)
|
|
m_oPath.Draw(m_pPage, bStroke, false, false);
|
|
}
|
|
|
|
m_pPage->GrRestore();
|
|
|
|
if (!sTextureTmpPath.empty())
|
|
{
|
|
m_oBrush.SetTexturePath(sTextureOldPath);
|
|
|
|
// We do not delete the temporary file - it will still be used.
|
|
// It must be deleted along with the temporary directory
|
|
//if (NSFile::CFileBinary::Exists(sTextureTmpPath))
|
|
// NSFile::CFileBinary::Remove(sTextureTmpPath);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::PathCommandMoveTo(const double& dX, const double& dY)
|
|
{
|
|
m_oPath.MoveTo(MM_2_PT(dX), MM_2_PT(m_dPageHeight - dY));
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::PathCommandLineTo(const double& dX, const double& dY)
|
|
{
|
|
m_oPath.LineTo(MM_2_PT(dX), MM_2_PT(m_dPageHeight - dY));
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::PathCommandLinesTo(double* pPoints, const int& nCount)
|
|
{
|
|
if (nCount < 4 || !pPoints)
|
|
return S_OK;
|
|
|
|
if (!m_oPath.IsMoveTo())
|
|
m_oPath.MoveTo(MM_2_PT(pPoints[0]), MM_2_PT(m_dPageHeight - pPoints[1]));
|
|
|
|
int nPointsCount = (nCount / 2) - 1;
|
|
for (int nIndex = 1; nIndex <= nPointsCount; ++nIndex)
|
|
{
|
|
m_oPath.LineTo(MM_2_PT(pPoints[nIndex * 2]), MM_2_PT(m_dPageHeight - pPoints[nIndex * 2 + 1]));
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::PathCommandCurveTo(const double& dX1, const double& dY1, const double& dX2, const double& dY2, const double& dXe, const double& dYe)
|
|
{
|
|
m_oPath.CurveTo(MM_2_PT(dX1), MM_2_PT(m_dPageHeight - dY1), MM_2_PT(dX2), MM_2_PT(m_dPageHeight - dY2), MM_2_PT(dXe), MM_2_PT(m_dPageHeight - dYe));
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::PathCommandCurvesTo(double* pPoints, const int& nCount)
|
|
{
|
|
if (nCount < 8 || !pPoints)
|
|
return S_OK;
|
|
|
|
if (!m_oPath.IsMoveTo())
|
|
m_oPath.MoveTo(MM_2_PT(pPoints[0]), MM_2_PT(m_dPageHeight - pPoints[1]));
|
|
|
|
int nPointsCount = (nCount - 2) / 6;
|
|
double* pCur = pPoints + 2;
|
|
for (int nIndex = 0; nIndex <= nPointsCount; ++nIndex, pCur += 6)
|
|
{
|
|
m_oPath.CurveTo(MM_2_PT(pCur[0]), MM_2_PT(m_dPageHeight - pCur[1]), MM_2_PT(pCur[2]), MM_2_PT(m_dPageHeight - pCur[3]), MM_2_PT(pCur[4]), MM_2_PT(m_dPageHeight - pCur[5]));
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::PathCommandArcTo(const double& dX, const double& dY, const double& dW, const double& dH, const double& dStartAngle, const double& dSweepAngle)
|
|
{
|
|
m_oPath.ArcTo(MM_2_PT(dX), MM_2_PT(m_dPageHeight - dY - dH), MM_2_PT(dW), MM_2_PT(dH), dStartAngle, dSweepAngle);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::PathCommandClose()
|
|
{
|
|
m_oPath.Close();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::PathCommandGetCurrentPoint(double* dX, double* dY)
|
|
{
|
|
m_oPath.GetLastPoint(*dX, *dY);
|
|
*dX = PT_2_MM(*dX);
|
|
*dY = PT_2_MM(*dY);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::PathCommandTextCHAR(const LONG& lUnicode, const double& dX, const double& dY, const double& dW, const double& dH)
|
|
{
|
|
unsigned int unUnicode = lUnicode;
|
|
bool bRes = PathCommandDrawText(&unUnicode, 1, dX, dY, NULL);
|
|
return bRes ? S_OK : S_FALSE;
|
|
}
|
|
HRESULT CPdfWriter::PathCommandText(const std::wstring& wsUnicodeText, const double& dX, const double& dY, const double& dW, const double& dH)
|
|
{
|
|
unsigned int unLen;
|
|
unsigned int* pUnicodes = NSStringExt::CConverter::GetUtf32FromUnicode(wsUnicodeText, unLen);
|
|
if (!pUnicodes)
|
|
return S_FALSE;
|
|
|
|
PathCommandDrawText(pUnicodes, unLen, dX, dY, NULL);
|
|
delete[] pUnicodes;
|
|
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::PathCommandTextExCHAR(const LONG& lUnicode, const LONG& lGid, const double& dX, const double& dY, const double& dW, const double& dH)
|
|
{
|
|
unsigned int unUnicode = lUnicode;
|
|
unsigned int unGid = lGid;
|
|
bool bRes = PathCommandDrawText(&unUnicode, 1, dX, dY, &unGid);
|
|
return bRes ? S_OK : S_FALSE;
|
|
}
|
|
HRESULT CPdfWriter::PathCommandTextEx(const std::wstring& wsUnicodeText, const unsigned int* pGids, const unsigned int unGidsCount, const double& dX, const double& dY, const double& dW, const double& dH)
|
|
{
|
|
if (!IsPageValid() || (!wsUnicodeText.size() && (!pGids || !unGidsCount)))
|
|
return S_FALSE;
|
|
|
|
unsigned int unLen = 0;
|
|
unsigned int* pUnicodes = NULL;
|
|
if (pGids && unGidsCount)
|
|
{
|
|
unLen = unGidsCount;
|
|
if (wsUnicodeText.size())
|
|
{
|
|
unsigned int unUnicodeLen;
|
|
pUnicodes = NSStringExt::CConverter::GetUtf32FromUnicode(wsUnicodeText, unUnicodeLen);
|
|
if (!pUnicodes || unUnicodeLen != unLen)
|
|
RELEASEARRAYOBJECTS(pUnicodes);
|
|
}
|
|
|
|
if (!pUnicodes)
|
|
{
|
|
pUnicodes = new unsigned int[unLen];
|
|
if (!pUnicodes)
|
|
return S_FALSE;
|
|
|
|
for (unsigned int unIndex = 0; unIndex < unLen; unIndex++)
|
|
pUnicodes[unIndex] = pGids[unIndex];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pUnicodes = NSStringExt::CConverter::GetUtf32FromUnicode(wsUnicodeText, unLen);
|
|
if (!pUnicodes)
|
|
return S_FALSE;
|
|
}
|
|
|
|
bool bRes = PathCommandDrawText(pUnicodes, unLen, dX, dY, pGids);
|
|
RELEASEARRAYOBJECTS(pUnicodes);
|
|
|
|
return bRes ? S_OK : S_FALSE;
|
|
}
|
|
//----------------------------------------------------------------------------------------
|
|
// Функции для вывода изображений
|
|
//----------------------------------------------------------------------------------------
|
|
HRESULT CPdfWriter::DrawImage(IGrObject* pImage, const double& dX, const double& dY, const double& dW, const double& dH)
|
|
{
|
|
m_oCommandManager.Flush();
|
|
|
|
if (!IsPageValid() || !pImage || SkipRedact(dX, dY, dW, dH))
|
|
return S_OK;
|
|
|
|
if (!DrawImage((Aggplus::CImage*)pImage, dX, dY, dW, dH, 255))
|
|
return S_FALSE;
|
|
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::DrawImageFromFile(NSFonts::IApplicationFonts* pAppFonts, const std::wstring& wsTempDirectory, const std::wstring& wsImagePathSrc, const double& dX, const double& dY, const double& dW, const double& dH, const BYTE& nAlpha)
|
|
{
|
|
m_oCommandManager.Flush();
|
|
|
|
if (!IsPageValid() || SkipRedact(dX, dY, dW, dH))
|
|
return S_OK;
|
|
|
|
if (m_pDocument->HasImage(wsImagePathSrc, nAlpha))
|
|
{
|
|
PdfWriter::CImageDict* pPdfImage = m_pDocument->GetImage(wsImagePathSrc, nAlpha);
|
|
m_pPage->GrSave();
|
|
UpdateTransform();
|
|
m_pPage->DrawImage(pPdfImage, MM_2_PT(dX), MM_2_PT(m_dPageHeight - dY - dH), MM_2_PT(dW), MM_2_PT(dH));
|
|
m_pPage->GrRestore();
|
|
return S_OK;
|
|
}
|
|
|
|
std::wstring sTempImagePath = GetDownloadFile(wsImagePathSrc, wsTempDirectory);
|
|
std::wstring wsImagePath = sTempImagePath.empty() ? wsImagePathSrc : sTempImagePath;
|
|
|
|
Aggplus::CImage* pAggImage = ConvertMetafile(pAppFonts, wsImagePath, GetTempFile(wsTempDirectory), MM_TO_PT(dW), MM_TO_PT(dH));
|
|
|
|
HRESULT hRes = S_OK;
|
|
PdfWriter::CImageDict* pPdfImage = NULL;
|
|
if (!pAggImage || !(pPdfImage = DrawImage(pAggImage, dX, dY, dW, dH, nAlpha)))
|
|
hRes = S_FALSE;
|
|
m_pDocument->AddImage(wsImagePathSrc, nAlpha, pPdfImage);
|
|
|
|
if (NSFile::CFileBinary::Exists(sTempImagePath))
|
|
NSFile::CFileBinary::Remove(sTempImagePath);
|
|
|
|
if (pAggImage)
|
|
delete pAggImage;
|
|
|
|
return hRes;
|
|
}
|
|
//----------------------------------------------------------------------------------------
|
|
// Функции для выставления преобразования
|
|
//----------------------------------------------------------------------------------------
|
|
HRESULT CPdfWriter::SetTransform(const double& dM11, const double& dM12, const double& dM21, const double& dM22, const double& dX, const double& dY)
|
|
{
|
|
m_oCommandManager.Flush();
|
|
m_oTransform.Set(dM11, dM12, dM21, dM22, dX, dY);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::GetTransform(double* dM11, double* dM12, double* dM21, double* dM22, double* dX, double* dY)
|
|
{
|
|
*dM11 = m_oTransform.m11;
|
|
*dM12 = m_oTransform.m12;
|
|
*dM21 = m_oTransform.m21;
|
|
*dM22 = m_oTransform.m22;
|
|
*dX = m_oTransform.dx;
|
|
*dY = m_oTransform.dy;
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::ResetTransform()
|
|
{
|
|
m_oCommandManager.Flush();
|
|
m_oTransform.Reset();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::get_ClipMode(LONG* lMode)
|
|
{
|
|
*lMode = m_lClipMode;
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::put_ClipMode(const LONG& lMode)
|
|
{
|
|
m_lClipMode = lMode;
|
|
return S_OK;
|
|
}
|
|
//----------------------------------------------------------------------------------------
|
|
// Дополнительные функции
|
|
//----------------------------------------------------------------------------------------
|
|
HRESULT CPdfWriter::AddHyperlink(const double& dX, const double& dY, const double& dW, const double& dH, const std::wstring& wsUrl, const std::wstring& wsTooltip)
|
|
{
|
|
NSUnicodeConverter::CUnicodeConverter conv;
|
|
PdfWriter::CAnnotation* pAnnot = m_pDocument->CreateUriLinkAnnot(PdfWriter::TRect(MM_2_PT(dX), m_pPage->GetHeight() - MM_2_PT(dY), MM_2_PT(dX + dW), m_pPage->GetHeight() - MM_2_PT(dY + dH)), conv.SASLprepToUtf8(wsUrl).c_str());
|
|
m_pPage->AddAnnotation(pAnnot);
|
|
pAnnot->SetBorder(0, 0, {});
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::AddLink(const double& dX, const double& dY, const double& dW, const double& dH, const double& dDestX, const double& dDestY, const int& nPage)
|
|
{
|
|
unsigned int unPagesCount = m_pDocument->GetPagesCount();
|
|
if (unPagesCount == 0)
|
|
return S_OK;
|
|
|
|
PdfWriter::CPage* pPage = m_pDocument->GetPage(nPage);
|
|
if (!pPage)
|
|
{
|
|
m_vDestinations.push_back(TDestinationInfo(m_pPage, dX, dY, dW, dH, dDestX, dDestY, nPage));
|
|
}
|
|
else
|
|
{
|
|
AddLink(m_pPage, dX, dY, dW, dH, dDestX, dDestY, nPage);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::AddFormField(NSFonts::IApplicationFonts* pAppFonts, CFormFieldInfo* pFieldInfo, const std::wstring& wsTempDirectory)
|
|
{
|
|
if (!m_pDocument || 0 == m_pDocument->GetPagesCount() || !pFieldInfo)
|
|
return S_OK;
|
|
CFormFieldInfo& oInfo = *pFieldInfo;
|
|
|
|
PdfWriter::CFontCidTrueType* pCheckedFont = NULL;
|
|
PdfWriter::CFontCidTrueType* pUncheckedFont = NULL;
|
|
if (oInfo.IsCheckBox())
|
|
{
|
|
const CFormFieldInfo::CCheckBoxFormPr* pPr = oInfo.GetCheckBoxPr();
|
|
pCheckedFont = GetFont(pPr->GetCheckedFontName(), false, false);
|
|
pUncheckedFont = GetFont(pPr->GetUncheckedFontName(), false, false);
|
|
}
|
|
if ((oInfo.IsCheckBox() && (!pCheckedFont || !pUncheckedFont)) || oInfo.IsTextField() || oInfo.IsDropDownList() || oInfo.IsDateTime())
|
|
{
|
|
if (m_bNeedUpdateTextFont)
|
|
UpdateFont();
|
|
if (!m_pFont)
|
|
return S_OK;
|
|
if (oInfo.IsCheckBox())
|
|
{
|
|
if (!pCheckedFont)
|
|
pCheckedFont = m_pFont;
|
|
if (!pUncheckedFont)
|
|
pUncheckedFont = m_pFont;
|
|
}
|
|
}
|
|
|
|
double dX, dY, dW, dH;
|
|
oInfo.GetBounds(dX, dY, dW, dH);
|
|
|
|
PdfWriter::CFieldBase* pFieldBase = NULL;
|
|
|
|
bool bRadioButton = false;
|
|
if (oInfo.IsTextField())
|
|
{
|
|
PdfWriter::CTextField* pField = m_pDocument->CreateTextField();
|
|
pFieldBase = static_cast<PdfWriter::CFieldBase*>(pField);
|
|
}
|
|
else if (oInfo.IsDropDownList())
|
|
{
|
|
PdfWriter::CChoiceField* pField = m_pDocument->CreateChoiceField();
|
|
pFieldBase = static_cast<PdfWriter::CFieldBase*>(pField);
|
|
}
|
|
else if (oInfo.IsCheckBox())
|
|
{
|
|
const CFormFieldInfo::CCheckBoxFormPr* pPr = oInfo.GetCheckBoxPr();
|
|
|
|
PdfWriter::CCheckBoxField* pField = NULL;
|
|
std::wstring wsGroupName = pPr->GetGroupKey();
|
|
if (L"" != wsGroupName)
|
|
{
|
|
bRadioButton = true;
|
|
PdfWriter::CRadioGroupField* pRadioGroup = m_pDocument->GetRadioGroupField(wsGroupName);
|
|
if (pRadioGroup)
|
|
pField = pRadioGroup->CreateKid();
|
|
}
|
|
else
|
|
{
|
|
pField = m_pDocument->CreateCheckBoxField();
|
|
}
|
|
|
|
pFieldBase = static_cast<PdfWriter::CFieldBase*>(pField);
|
|
}
|
|
else if (oInfo.IsPicture())
|
|
{
|
|
PdfWriter::CPictureField* pField = m_pDocument->CreatePictureField();
|
|
pFieldBase = static_cast<PdfWriter::CFieldBase*>(pField);
|
|
}
|
|
else if (oInfo.IsDateTime())
|
|
{
|
|
PdfWriter::CDateTimeField* pField = m_pDocument->CreateDateTimeField();
|
|
pFieldBase = static_cast<PdfWriter::CFieldBase*>(pField);
|
|
}
|
|
|
|
if (!pFieldBase)
|
|
return S_FALSE;
|
|
|
|
// 0 - Right
|
|
// 1 - Left
|
|
// 2 - Center
|
|
// 3 - Justify
|
|
// 4 - Distributed
|
|
unsigned int unAlign = oInfo.GetJc();
|
|
if (0 == unAlign)
|
|
pFieldBase->SetAlign(PdfWriter::CFieldBase::EFieldAlignType::Right);
|
|
else if (2 == unAlign)
|
|
pFieldBase->SetAlign(PdfWriter::CFieldBase::EFieldAlignType::Center);
|
|
|
|
if (oInfo.HaveBorder())
|
|
{
|
|
unsigned char unR, unG, unB, unA;
|
|
oInfo.GetBorderColor(unR, unG, unB, unA);
|
|
|
|
pFieldBase->SetFieldBorder(PdfWriter::EBorderSubtype::border_subtype_Solid, PdfWriter::TRgb(unR, unG, unB), MM_2_PT(oInfo.GetBorderSize()), 0, 0, 0);
|
|
}
|
|
|
|
if (oInfo.HaveShd())
|
|
{
|
|
unsigned char unR, unG, unB, unA;
|
|
oInfo.GetShdColor(unR, unG, unB, unA);
|
|
pFieldBase->SetShd(PdfWriter::TRgb(unR, unG, unB));
|
|
}
|
|
|
|
pFieldBase->SetRequiredFlag(oInfo.IsRequired());
|
|
pFieldBase->SetFieldHint(oInfo.GetHelpText());
|
|
|
|
bool isBold = m_oFont.IsBold();
|
|
bool isItalic = m_oFont.IsItalic();
|
|
|
|
if (oInfo.IsTextField())
|
|
{
|
|
const CFormFieldInfo::CTextFormPr* pPr = oInfo.GetTextFormPr();
|
|
std::wstring wsValue = pPr->GetTextValue();
|
|
wsValue = PdfWriter::NormalizeWhitespace(wsValue);
|
|
|
|
unsigned int unLen = 0;
|
|
unsigned int* pUnicodes = NULL;
|
|
unsigned short* pCodes = NULL;
|
|
PdfWriter::CFontCidTrueType** ppFonts = NULL;
|
|
bool bFont = GetFontData(pAppFonts, wsValue, m_pFont, isBold, isItalic, pUnicodes, unLen, pCodes, ppFonts);
|
|
if (!bFont)
|
|
{
|
|
RELEASEARRAYOBJECTS(pUnicodes);
|
|
RELEASEARRAYOBJECTS(pCodes);
|
|
RELEASEARRAYOBJECTS(ppFonts);
|
|
return S_FALSE;
|
|
}
|
|
PdfWriter::CTextField* pField = dynamic_cast<PdfWriter::CTextField*>(pFieldBase);
|
|
if (!pField)
|
|
{
|
|
RELEASEARRAYOBJECTS(pUnicodes);
|
|
RELEASEARRAYOBJECTS(pCodes);
|
|
RELEASEARRAYOBJECTS(ppFonts);
|
|
return S_FALSE;
|
|
}
|
|
|
|
double _dY = m_pPage->GetHeight() - MM_2_PT(dY);
|
|
double _dB = m_pPage->GetHeight() - MM_2_PT(dY + dH);
|
|
|
|
double dMargin = 2; // такой отступ используется в AdobeReader
|
|
double dBaseLine = MM_2_PT(dH - oInfo.GetBaseLineOffset());
|
|
double dShiftX = dMargin;
|
|
|
|
pFieldBase->AddPageRect(m_pPage, PdfWriter::TRect(MM_2_PT(dX) - dMargin, _dY, MM_2_PT(dX + dW) + dMargin, _dB));
|
|
|
|
pField->SetMaxLen(pPr->GetMaxCharacters());
|
|
pField->SetCombFlag(pPr->IsComb());
|
|
pField->SetAutoFit(pPr->IsAutoFit());
|
|
pField->SetMultilineFlag(pPr->IsMultiLine());
|
|
|
|
bool isComb = pPr->IsComb();
|
|
unsigned int unAlign = oInfo.GetJc();
|
|
double dFontSize = m_oFont.GetSize();
|
|
|
|
TColor oColor = m_oBrush.GetTColor1();
|
|
bool isPlaceHolder = oInfo.IsPlaceHolder();
|
|
|
|
PdfWriter::TRgb oNormalColor(oColor.r, oColor.g, oColor.b);
|
|
PdfWriter::TRgb oPlaceHolderColor;
|
|
oPlaceHolderColor.r = oNormalColor.r + (1.0 - oNormalColor.r) / 2.0;
|
|
oPlaceHolderColor.g = oNormalColor.g + (1.0 - oNormalColor.g) / 2.0;
|
|
oPlaceHolderColor.b = oNormalColor.b + (1.0 - oNormalColor.b) / 2.0;
|
|
|
|
if (!isPlaceHolder)
|
|
pField->SetTextValue(wsValue);
|
|
PdfWriter::CFontTrueType* pFontTT = NULL;
|
|
|
|
if (!isComb && pPr->IsMultiLine())
|
|
{
|
|
unsigned short* pCodes2 = new unsigned short[unLen];
|
|
unsigned int* pWidths = new unsigned int[unLen];
|
|
|
|
unsigned short ushSpaceCode = 0xFFFF;
|
|
unsigned short ushNewLineCode = 0xFFFE;
|
|
for (unsigned int unIndex = 0; unIndex < unLen; ++unIndex)
|
|
{
|
|
unsigned short ushCode = 0;
|
|
if (0x0020 == pUnicodes[unIndex])
|
|
ushCode = ushSpaceCode;
|
|
else if (0x000D == pUnicodes[unIndex] || 0x000A == pUnicodes[unIndex])
|
|
ushCode = ushNewLineCode;
|
|
|
|
pCodes2[unIndex] = ushCode;
|
|
pWidths[unIndex] = ppFonts[unIndex]->GetWidth(pCodes[unIndex]);
|
|
}
|
|
|
|
pFontTT = m_pDocument->CreateTrueTypeFont(m_pFont);
|
|
|
|
m_oLinesManager.Init(pCodes2, pWidths, unLen, ushSpaceCode, ushNewLineCode, pFontTT->GetLineHeight(), pFontTT->GetAscent());
|
|
|
|
// TODO: Разобраться более детально по какой именно высоте идет в Adobe расчет
|
|
// пока временно оставим (H - 3 * margin)
|
|
if (pPr->IsAutoFit())
|
|
dFontSize = m_oLinesManager.ProcessAutoFit(MM_2_PT(dW), (MM_2_PT(dH) - 3 * dMargin));
|
|
|
|
double dLineHeight = pFontTT->GetLineHeight() * dFontSize / 1000.0;
|
|
|
|
m_oLinesManager.CalculateLines(dFontSize, MM_2_PT(dW));
|
|
|
|
pField->StartTextAppearance(m_pFont, dFontSize, isPlaceHolder ? oPlaceHolderColor : oNormalColor, 1.0);
|
|
|
|
unsigned int unLinesCount = m_oLinesManager.GetLinesCount();
|
|
double dLineShiftY = MM_2_PT(dH) - pFontTT->GetLineHeight() * dFontSize / 1000.0 - dMargin;
|
|
for (unsigned int unIndex = 0; unIndex < unLinesCount; ++unIndex)
|
|
{
|
|
unsigned int unLineStart = m_oLinesManager.GetLineStartPos(unIndex);
|
|
double dLineShiftX = dShiftX;
|
|
double dLineWidth = m_oLinesManager.GetLineWidth(unIndex, dFontSize);
|
|
if (0 == unAlign)
|
|
dLineShiftX += MM_2_PT(dW) - dLineWidth;
|
|
else if (2 == unAlign)
|
|
dLineShiftX += (MM_2_PT(dW) - dLineWidth) / 2;
|
|
|
|
int nInLineCount = m_oLinesManager.GetLineEndPos(unIndex) - m_oLinesManager.GetLineStartPos(unIndex);
|
|
if (nInLineCount > 0)
|
|
pField->AddLineToTextAppearance(dLineShiftX, dLineShiftY, pCodes + unLineStart, nInLineCount, ppFonts + unLineStart, NULL);
|
|
|
|
dLineShiftY -= dLineHeight;
|
|
}
|
|
|
|
pField->EndTextAppearance();
|
|
|
|
m_oLinesManager.Clear();
|
|
|
|
delete[] pCodes2;
|
|
delete[] pWidths;
|
|
}
|
|
else
|
|
{
|
|
double* pShifts = NULL;
|
|
unsigned int unShiftsCount = 0;
|
|
|
|
if (isComb)
|
|
{
|
|
pField->SetDoNotScrollFlag(true);
|
|
pField->SetDoNotSpellCheckFlag(true);
|
|
pField->SetMultilineFlag(false);
|
|
|
|
unShiftsCount = unLen;
|
|
pShifts = new double[unShiftsCount];
|
|
if (pShifts && unShiftsCount)
|
|
{
|
|
// Сдвиг нулевой для comb форм и не забываем, что мы к ширине добавили 2 * dMargin
|
|
dShiftX = 0;
|
|
unsigned int unCellsCount = std::max(unShiftsCount, pPr->GetMaxCharacters());
|
|
double dPrevW = 0;
|
|
double dCellW = (MM_2_PT(dW) + 2 * dMargin) / unCellsCount;
|
|
|
|
if (0 == unAlign && unShiftsCount)
|
|
dPrevW = (unCellsCount - unShiftsCount) * dCellW;
|
|
|
|
for (unsigned int unIndex = 0; unIndex < unShiftsCount; ++unIndex)
|
|
{
|
|
unsigned short ushCode = pCodes[unIndex];
|
|
double dGlyphWidth = ppFonts[unIndex]->GetGlyphWidth(ushCode) / 1000.0 * dFontSize;
|
|
double dTempShift = (dCellW - dGlyphWidth) / 2;
|
|
pShifts[unIndex] = dPrevW + dTempShift;
|
|
dPrevW = dCellW - dTempShift;
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
unShiftsCount = 0;
|
|
}
|
|
}
|
|
else if (0 == unAlign || 2 == unAlign)
|
|
{
|
|
double dSumWidth = 0;
|
|
for (unsigned int unIndex = 0; unIndex < unLen; ++unIndex)
|
|
{
|
|
unsigned short ushCode = pCodes[unIndex];
|
|
double dLetterWidth = ppFonts[unIndex]->GetWidth(ushCode) / 1000.0 * dFontSize;
|
|
dSumWidth += dLetterWidth;
|
|
}
|
|
|
|
if (0 == unAlign && MM_2_PT(dW) - dSumWidth > 0)
|
|
dShiftX += MM_2_PT(dW) - dSumWidth;
|
|
else if (2 == unAlign && (MM_2_PT(dW) - dSumWidth) / 2 > 0)
|
|
dShiftX += (MM_2_PT(dW) - dSumWidth) / 2;
|
|
}
|
|
|
|
pField->SetTextAppearance(wsValue, pCodes, unLen, m_pFont, isPlaceHolder ? oPlaceHolderColor : oNormalColor, 1.0, m_oFont.GetSize(), dShiftX, dBaseLine, ppFonts, pShifts);
|
|
RELEASEARRAYOBJECTS(pShifts);
|
|
}
|
|
|
|
RELEASEARRAYOBJECTS(pUnicodes);
|
|
RELEASEARRAYOBJECTS(pCodes);
|
|
RELEASEARRAYOBJECTS(ppFonts);
|
|
|
|
if (pField->GetFont() && pField->GetFont() != m_pFont && pField->GetFont()->GetFontType() == PdfWriter::fontCIDType2)
|
|
pFontTT = m_pDocument->CreateTrueTypeFont((PdfWriter::CFontCidTrueType*)pField->GetFont());
|
|
else
|
|
pFontTT = m_pDocument->CreateTrueTypeFont(m_pFont);
|
|
pField->SetDefaultAppearance(pFontTT, m_oFont.GetSize(), PdfWriter::TRgb(oColor.r, oColor.g, oColor.b));
|
|
|
|
std::wstring wsPlaceHolder = pPr->GetPlaceHolder();
|
|
wsPlaceHolder = PdfWriter::NormalizeWhitespace(wsPlaceHolder);
|
|
if (!wsPlaceHolder.empty())
|
|
{
|
|
unsigned int unMaxLen = pPr->GetMaxCharacters();
|
|
if (unMaxLen && wsPlaceHolder.length() > unMaxLen)
|
|
wsPlaceHolder = wsPlaceHolder.substr(0, unMaxLen);
|
|
|
|
pField->SetPlaceHolderText(wsPlaceHolder, oNormalColor, oPlaceHolderColor);
|
|
}
|
|
|
|
pField->SetFormat(pPr->GetFormatPr());
|
|
}
|
|
else if (oInfo.IsDropDownList())
|
|
{
|
|
const CFormFieldInfo::CDropDownFormPr* pPr = oInfo.GetDropDownPr();
|
|
std::wstring wsValue = pPr->GetTextValue();
|
|
|
|
unsigned int unLen = 0;
|
|
unsigned int* pUnicodes = NULL;
|
|
unsigned short* pCodes = NULL;
|
|
PdfWriter::CFontCidTrueType** ppFonts = NULL;
|
|
bool bFont = GetFontData(pAppFonts, wsValue, m_pFont, isBold, isItalic, pUnicodes, unLen, pCodes, ppFonts);
|
|
if (!bFont)
|
|
{
|
|
RELEASEARRAYOBJECTS(pUnicodes);
|
|
RELEASEARRAYOBJECTS(pCodes);
|
|
RELEASEARRAYOBJECTS(ppFonts);
|
|
return S_FALSE;
|
|
}
|
|
|
|
PdfWriter::CChoiceField* pField = dynamic_cast<PdfWriter::CChoiceField*>(pFieldBase);
|
|
if (!pField)
|
|
{
|
|
RELEASEARRAYOBJECTS(pUnicodes);
|
|
RELEASEARRAYOBJECTS(pCodes);
|
|
RELEASEARRAYOBJECTS(ppFonts);
|
|
return S_FALSE;
|
|
}
|
|
|
|
pFieldBase->AddPageRect(m_pPage, PdfWriter::TRect(MM_2_PT(dX), m_pPage->GetHeight() - MM_2_PT(dY), MM_2_PT(dX + dW), m_pPage->GetHeight() - MM_2_PT(dY + dH)));
|
|
|
|
TColor oColor = m_oBrush.GetTColor1();
|
|
|
|
PdfWriter::TRgb oNormalColor(oColor.r, oColor.g, oColor.b);
|
|
PdfWriter::TRgb oPlaceHolderColor;
|
|
oPlaceHolderColor.r = oNormalColor.r + (1.0 - oNormalColor.r) / 2.0;
|
|
oPlaceHolderColor.g = oNormalColor.g + (1.0 - oNormalColor.g) / 2.0;
|
|
oPlaceHolderColor.b = oNormalColor.b + (1.0 - oNormalColor.b) / 2.0;
|
|
|
|
pField->SetTextValue(wsValue);
|
|
pField->SetTextAppearance(wsValue, pCodes, unLen, m_pFont, oInfo.IsPlaceHolder() ? oPlaceHolderColor : oNormalColor, 1, m_oFont.GetSize(), 0, MM_2_PT(dH - oInfo.GetBaseLineOffset()), ppFonts);
|
|
|
|
RELEASEARRAYOBJECTS(pUnicodes);
|
|
RELEASEARRAYOBJECTS(pCodes);
|
|
RELEASEARRAYOBJECTS(ppFonts);
|
|
|
|
unsigned int unSelectedIndex = 0xFFFF;
|
|
for (unsigned int unIndex = 0, unItemsCount = pPr->GetComboBoxItemsCount(); unIndex < unItemsCount; ++unIndex)
|
|
{
|
|
std::wstring wsItem = pPr->GetComboBoxItem(unIndex);
|
|
pField->AddOption(wsItem);
|
|
if (wsItem == wsValue)
|
|
unSelectedIndex = unIndex;
|
|
}
|
|
|
|
pField->SetComboFlag(true);
|
|
pField->SetEditFlag(pPr->IsEditComboBox());
|
|
|
|
PdfWriter::CFontTrueType* pFontTT = NULL;
|
|
if (pField->GetFont() && pField->GetFont() != m_pFont && pField->GetFont()->GetFontType() == PdfWriter::fontCIDType2)
|
|
pFontTT = m_pDocument->CreateTrueTypeFont((PdfWriter::CFontCidTrueType*)pField->GetFont());
|
|
else
|
|
pFontTT = m_pDocument->CreateTrueTypeFont(m_pFont);
|
|
pField->SetDefaultAppearance(pFontTT, m_oFont.GetSize(), oInfo.IsPlaceHolder() ? oPlaceHolderColor : oNormalColor);
|
|
|
|
std::wstring wsPlaceHolder = pPr->GetPlaceHolder();
|
|
wsPlaceHolder = PdfWriter::NormalizeWhitespace(wsPlaceHolder);
|
|
if (!wsPlaceHolder.empty())
|
|
{
|
|
pField->SetPlaceHolderText(wsPlaceHolder, oNormalColor, oPlaceHolderColor);
|
|
|
|
if (!pPr->IsEditComboBox())
|
|
{
|
|
// Для drop-down list в 0 позиции мы добавили плейсхолдер
|
|
if (oInfo.IsPlaceHolder())
|
|
unSelectedIndex = 0;
|
|
else if (0xFFFF != unSelectedIndex)
|
|
unSelectedIndex++;
|
|
}
|
|
}
|
|
|
|
if (!pPr->IsEditComboBox() && 0xFFFF != unSelectedIndex)
|
|
pField->SetSelectedIndex(unSelectedIndex);
|
|
}
|
|
else if (oInfo.IsCheckBox())
|
|
{
|
|
const CFormFieldInfo::CCheckBoxFormPr* pPr = oInfo.GetCheckBoxPr();
|
|
|
|
PdfWriter::CCheckBoxField* pField = dynamic_cast<PdfWriter::CCheckBoxField*>(pFieldBase);
|
|
if (!pField)
|
|
return S_FALSE;
|
|
|
|
pFieldBase->AddPageRect(m_pPage, PdfWriter::TRect(MM_2_PT(dX), m_pPage->GetHeight() - MM_2_PT(dY), MM_2_PT(dX + dW), m_pPage->GetHeight() - MM_2_PT(dY + dH)));
|
|
pField->SetValue(pPr->IsChecked());
|
|
|
|
unsigned int unCheckedSymbol = pPr->GetCheckedSymbol();
|
|
unsigned int unUncheckedSymbol = pPr->GetUncheckedSymbol();
|
|
|
|
unsigned short ushCheckedCode = pCheckedFont->EncodeUnicode(unCheckedSymbol);
|
|
unsigned short ushUncheckedCode = pUncheckedFont->EncodeUnicode(unUncheckedSymbol);
|
|
|
|
TColor oColor = m_oBrush.GetTColor1();
|
|
pField->SetAppearance(L"", &ushCheckedCode, 1, pCheckedFont, L"", &ushUncheckedCode, 1, pUncheckedFont, PdfWriter::TRgb(oColor.r, oColor.g, oColor.b), 1, m_oFont.GetSize(), 0, MM_2_PT(dH - oInfo.GetBaseLineOffset()));
|
|
}
|
|
else if (oInfo.IsPicture())
|
|
{
|
|
const CFormFieldInfo::CPictureFormPr* pPr = oInfo.GetPicturePr();
|
|
|
|
PdfWriter::CPictureField* pField = dynamic_cast<PdfWriter::CPictureField*>(pFieldBase);
|
|
pFieldBase->AddPageRect(m_pPage, PdfWriter::TRect(MM_2_PT(dX), m_pPage->GetHeight() - MM_2_PT(dY), MM_2_PT(dX + dW), m_pPage->GetHeight() - MM_2_PT(dY + dH)));
|
|
pField->SetConstantProportions(pPr->IsConstantProportions());
|
|
pField->SetRespectBorders(pPr->IsRespectBorders());
|
|
pField->SetScaleType(static_cast<PdfWriter::CPictureField::EScaleType>(pPr->GetScaleType()));
|
|
pField->SetShift(pPr->GetShiftX() / 1000.0, (1000 - pPr->GetShiftY()) / 1000.0);
|
|
|
|
std::wstring wsPath = pPr->GetPicturePath();
|
|
PdfWriter::CImageDict* pImage = NULL;
|
|
if (wsPath.length())
|
|
{
|
|
Aggplus::CImage* pCImage = ConvertMetafile(pAppFonts, wsPath, GetTempFile(wsTempDirectory), MM_TO_PT(dW), MM_TO_PT(dH));
|
|
pImage = LoadImage(pCImage, 255);
|
|
RELEASEOBJECT(pCImage);
|
|
}
|
|
|
|
pField->SetAppearance(pImage);
|
|
}
|
|
else if (oInfo.IsDateTime())
|
|
{
|
|
const CFormFieldInfo::CDateTimeFormPr* pPr = oInfo.GetDateTimePr();
|
|
|
|
std::wstring wsValue = pPr->GetValue();
|
|
|
|
unsigned int unLen = 0;
|
|
unsigned int* pUnicodes = NULL;
|
|
unsigned short* pCodes = NULL;
|
|
PdfWriter::CFontCidTrueType** ppFonts = NULL;
|
|
bool bFont = GetFontData(pAppFonts, wsValue, m_pFont, isBold, isItalic, pUnicodes, unLen, pCodes, ppFonts);
|
|
if (!bFont)
|
|
{
|
|
RELEASEARRAYOBJECTS(pUnicodes);
|
|
RELEASEARRAYOBJECTS(pCodes);
|
|
RELEASEARRAYOBJECTS(ppFonts);
|
|
return S_FALSE;
|
|
}
|
|
|
|
PdfWriter::CDateTimeField* pField = dynamic_cast<PdfWriter::CDateTimeField*>(pFieldBase);
|
|
if (!pField)
|
|
{
|
|
RELEASEARRAYOBJECTS(pUnicodes);
|
|
RELEASEARRAYOBJECTS(pCodes);
|
|
RELEASEARRAYOBJECTS(ppFonts);
|
|
return S_FALSE;
|
|
}
|
|
|
|
pFieldBase->AddPageRect(m_pPage, PdfWriter::TRect(MM_2_PT(dX), m_pPage->GetHeight() - MM_2_PT(dY), MM_2_PT(dX + dW), m_pPage->GetHeight() - MM_2_PT(dY + dH)));
|
|
|
|
TColor oColor = m_oBrush.GetTColor1();
|
|
|
|
PdfWriter::TRgb oNormalColor(oColor.r, oColor.g, oColor.b);
|
|
PdfWriter::TRgb oPlaceHolderColor;
|
|
oPlaceHolderColor.r = oNormalColor.r + (1.0 - oNormalColor.r) / 2.0;
|
|
oPlaceHolderColor.g = oNormalColor.g + (1.0 - oNormalColor.g) / 2.0;
|
|
oPlaceHolderColor.b = oNormalColor.b + (1.0 - oNormalColor.b) / 2.0;
|
|
|
|
pField->SetTextValue(wsValue);
|
|
pField->SetTextAppearance(wsValue, pCodes, unLen, m_pFont, oInfo.IsPlaceHolder() ? oPlaceHolderColor : oNormalColor, 1, m_oFont.GetSize(), 0, MM_2_PT(dH - oInfo.GetBaseLineOffset()), ppFonts);
|
|
|
|
RELEASEARRAYOBJECTS(pUnicodes);
|
|
RELEASEARRAYOBJECTS(pCodes);
|
|
RELEASEARRAYOBJECTS(ppFonts);
|
|
|
|
pField->SetFormat(pPr->GetFormat());
|
|
}
|
|
|
|
// Выставляем имя в конце, потому что там возможно копирование настроек поля в новое родительское поле, поэтому к текущему моменту
|
|
// все настройки должны быть выставлены
|
|
if (!bRadioButton)
|
|
{
|
|
std::wstring wsKey = oInfo.GetKey();
|
|
if (L"" != wsKey)
|
|
pFieldBase->SetFieldName(wsKey);
|
|
else
|
|
pFieldBase->SetFieldName("F" + std::to_string(++m_unFieldsCounter));
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
void GetRCSpanStyle(CAnnotFieldInfo::CMarkupAnnotPr::CFontData* pFontData, NSStringUtils::CStringBuilder& oRC)
|
|
{
|
|
oRC += L"font-size:";
|
|
oRC.AddDouble(pFontData->dFontSise, 2);
|
|
oRC += L"pt;text-align:";
|
|
switch (pFontData->nAlignment)
|
|
{
|
|
case 1: { oRC += L"center"; break; }
|
|
case 2: { oRC += L"right"; break; }
|
|
case 3: { oRC += L"justify"; break; }
|
|
case 0:
|
|
default:{ oRC += L"left"; break; }
|
|
}
|
|
|
|
oRC += L";text-decoration:";
|
|
if ((pFontData->nFontFlag >> 4) & 1)
|
|
oRC += L"word";
|
|
if ((pFontData->nFontFlag >> 3) & 1)
|
|
{
|
|
if ((pFontData->nFontFlag >> 4) & 1)
|
|
oRC += L" ";
|
|
oRC += L"line-through";
|
|
}
|
|
|
|
oRC += L";color:";
|
|
oRC.WriteHexColor3((unsigned char)(pFontData->dColor[0] * 255.0),
|
|
(unsigned char)(pFontData->dColor[1] * 255.0),
|
|
(unsigned char)(pFontData->dColor[2] * 255.0));
|
|
oRC += L";font-weight:";
|
|
oRC += (pFontData->nFontFlag >> 0) & 1 ? L"bold" : L"normal";
|
|
oRC += L";font-style:";
|
|
oRC += (pFontData->nFontFlag >> 1) & 1 ? L"italic" : L"normal";
|
|
oRC += L";font-family:";
|
|
oRC += pFontData->sActualFont.empty() ? pFontData->sFontFamily : pFontData->sActualFont;
|
|
|
|
if (pFontData->dVAlign != 0)
|
|
{
|
|
oRC += L";vertical-align:";
|
|
if (pFontData->dVAlign > 0)
|
|
oRC += L"+";
|
|
oRC.AddDouble(pFontData->dVAlign, 2);
|
|
}
|
|
}
|
|
PdfWriter::CAction* GetAction(PdfWriter::CDocument* m_pDocument, CAnnotFieldInfo::CWidgetAnnotPr::CActionWidget* pAction)
|
|
{
|
|
PdfWriter::CAction* pA = m_pDocument->CreateAction(pAction->nActionType);
|
|
if (!pA)
|
|
return NULL;
|
|
pA->SetType(pAction->wsType);
|
|
|
|
switch (pAction->nActionType)
|
|
{
|
|
case 1:
|
|
{
|
|
PdfWriter::CActionGoTo* ppA = (PdfWriter::CActionGoTo*)pA;
|
|
PdfWriter::CPage* pPageD = m_pDocument->GetPage(pAction->nInt1);
|
|
PdfWriter::CDestination* pDest = m_pDocument->CreateDestination(pPageD);
|
|
if (!pDest)
|
|
break;
|
|
ppA->SetDestination(pDest);
|
|
|
|
PdfWriter::CArrayObject* pPageBoxD = (PdfWriter::CArrayObject*)pPageD->Get("CropBox");
|
|
if (!pPageBoxD)
|
|
pPageBoxD = (PdfWriter::CArrayObject*)pPageD->Get("MediaBox");
|
|
if (!pPageBoxD)
|
|
return NULL;
|
|
PdfWriter::CObjectBase* pD = pPageBoxD->Get(3);
|
|
double dPageDH = pD->GetType() == PdfWriter::object_type_NUMBER ? ((PdfWriter::CNumberObject*)pD)->Get() : ((PdfWriter::CRealObject*)pD)->Get();
|
|
pD = pPageBoxD->Get(0);
|
|
double dPageDX = pD->GetType() == PdfWriter::object_type_NUMBER ? ((PdfWriter::CNumberObject*)pD)->Get() : ((PdfWriter::CRealObject*)pD)->Get();
|
|
|
|
switch (pAction->nKind)
|
|
{
|
|
case 0:
|
|
{
|
|
pDest->SetXYZ(pAction->dD[0] + dPageDX, dPageDH - pAction->dD[1], pAction->dD[2]);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
pDest->SetFit();
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
pDest->SetFitH(dPageDH - pAction->dD[1]);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
pDest->SetFitV(pAction->dD[0] + dPageDX);
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
pDest->SetFitR(pAction->dD[0] + dPageDX, dPageDH - pAction->dD[1], pAction->dD[2] + dPageDX, dPageDH - pAction->dD[3]);
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
pDest->SetFitB();
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
pDest->SetFitBH(dPageDH - pAction->dD[1]);
|
|
break;
|
|
}
|
|
case 7:
|
|
{
|
|
pDest->SetFitBV(pAction->dD[0] + dPageDX);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
PdfWriter::CActionURI* ppA = (PdfWriter::CActionURI*)pA;
|
|
ppA->SetURI(pAction->wsStr1);
|
|
break;
|
|
}
|
|
case 9:
|
|
{
|
|
PdfWriter::CActionHide* ppA = (PdfWriter::CActionHide*)pA;
|
|
ppA->SetH(pAction->nKind);
|
|
ppA->SetT(pAction->arrStr);
|
|
break;
|
|
}
|
|
case 10:
|
|
{
|
|
PdfWriter::CActionNamed* ppA = (PdfWriter::CActionNamed*)pA;
|
|
ppA->SetN(pAction->wsStr1);
|
|
break;
|
|
}
|
|
case 12:
|
|
{
|
|
PdfWriter::CActionResetForm* ppA = (PdfWriter::CActionResetForm*)pA;
|
|
ppA->SetFlags(pAction->nInt1);
|
|
ppA->SetFields(pAction->arrStr);
|
|
break;
|
|
}
|
|
case 14:
|
|
{
|
|
PdfWriter::CActionJavaScript* ppA = (PdfWriter::CActionJavaScript*)pA;
|
|
ppA->SetJS(pAction->wsStr1);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (pAction->pNext)
|
|
{
|
|
PdfWriter::CAction* pANext = GetAction(m_pDocument, pAction->pNext);
|
|
pA->SetNext(pANext);
|
|
}
|
|
|
|
return pA;
|
|
}
|
|
HRESULT CPdfWriter::AddAnnotField(NSFonts::IApplicationFonts* pAppFonts, CAnnotFieldInfo* pFieldInfo)
|
|
{
|
|
if (!m_pDocument || 0 == m_pDocument->GetPagesCount() || !pFieldInfo)
|
|
return S_OK;
|
|
|
|
CAnnotFieldInfo& oInfo = *pFieldInfo;
|
|
PdfWriter::CAnnotation* pAnnot = NULL;
|
|
|
|
PdfWriter::CPage* pOrigPage = m_pDocument->GetEditPage(oInfo.GetPage());
|
|
if (!pOrigPage)
|
|
pOrigPage = m_pDocument->GetPage(oInfo.GetPage());
|
|
PdfWriter::CPage* pPage = m_pPage;
|
|
|
|
int nID = oInfo.GetID();
|
|
if (nID > 0)
|
|
pAnnot = m_pDocument->GetAnnot(nID);
|
|
|
|
if (pAnnot && pOrigPage && pPage != pOrigPage)
|
|
{
|
|
pOrigPage->DeleteAnnotation(nID);
|
|
pPage->AddAnnotation(pAnnot);
|
|
}
|
|
|
|
BYTE nWidgetType = 0;
|
|
if (oInfo.IsWidget())
|
|
{
|
|
CAnnotFieldInfo::CWidgetAnnotPr* pPr = oInfo.GetWidgetAnnotPr();
|
|
nWidgetType = pPr->GetType();
|
|
}
|
|
|
|
if (!pAnnot)
|
|
{
|
|
CAnnotFieldInfo::EAnnotType oType = oInfo.GetType();
|
|
BYTE nType = (BYTE) oType;
|
|
pAnnot = m_pDocument->CreateAnnot(nType);
|
|
|
|
if (pAnnot)
|
|
{
|
|
m_pDocument->AddObject(pAnnot);
|
|
m_pDocument->AddAnnotation(nID, pAnnot);
|
|
pPage->AddAnnotation(pAnnot);
|
|
}
|
|
}
|
|
|
|
if (!pAnnot)
|
|
return S_FALSE;
|
|
double dX1, dY1, dX2, dY2;
|
|
PdfWriter::CArrayObject* pPageBox = (PdfWriter::CArrayObject*)pPage->Get("CropBox");
|
|
if (!pPageBox)
|
|
pPageBox = (PdfWriter::CArrayObject*)pPage->Get("MediaBox");
|
|
PdfWriter::CObjectBase* pD = pPageBox->Get(3);
|
|
double dPageH = pD->GetType() == PdfWriter::object_type_NUMBER ? ((PdfWriter::CNumberObject*)pD)->Get() : ((PdfWriter::CRealObject*)pD)->Get();
|
|
pD = pPageBox->Get(0);
|
|
double dPageX = pD->GetType() == PdfWriter::object_type_NUMBER ? ((PdfWriter::CNumberObject*)pD)->Get() : ((PdfWriter::CRealObject*)pD)->Get();
|
|
pPageBox = (PdfWriter::CArrayObject*)pPage->Get("MediaBox");
|
|
pD = pPageBox->Get(3);
|
|
double dPageY = pD->GetType() == PdfWriter::object_type_NUMBER ? ((PdfWriter::CNumberObject*)pD)->Get() : ((PdfWriter::CRealObject*)pD)->Get();
|
|
dPageY -= dPageH;
|
|
oInfo.GetBounds(dX1, dY1, dX2, dY2);
|
|
pAnnot->SetRect({dPageX + dX1, dPageH - dY1, dPageX + dX2, dPageH - dY2});
|
|
|
|
pAnnot->SetPage(pPage, pPage->GetWidth(), dPageH, dPageX, dPageY);
|
|
pAnnot->SetAnnotFlag(oInfo.GetAnnotFlag());
|
|
pAnnot->SetDocument(m_pDocument);
|
|
|
|
int nFlags = oInfo.GetFlag();
|
|
if (nFlags & (1 << 0))
|
|
pAnnot->SetNM(oInfo.GetNM());
|
|
if (nFlags & (1 << 1))
|
|
pAnnot->SetContents(oInfo.GetContents());
|
|
if (nFlags & (1 << 2))
|
|
{
|
|
BYTE nS;
|
|
double dI;
|
|
oInfo.GetBE(nS, dI);
|
|
pAnnot->SetBE(nS, dI);
|
|
}
|
|
if ((nFlags & (1 << 3)) && !oInfo.IsFreeText())
|
|
pAnnot->SetC(oInfo.GetC());
|
|
if (nFlags & (1 << 4))
|
|
{
|
|
BYTE nType;
|
|
double dWidth;
|
|
std::vector<double> arrDash;
|
|
oInfo.GetBorder(nType, dWidth, arrDash);
|
|
pAnnot->SetBorder(nType, dWidth, arrDash);
|
|
}
|
|
if (nFlags & (1 << 5))
|
|
pAnnot->SetLM(oInfo.GetLM());
|
|
bool bRender = (nFlags >> 6) & 1;
|
|
if (nFlags & (1 << 7))
|
|
pAnnot->SetOUserID(oInfo.GetOUserID());
|
|
if (nFlags & (1 << 9))
|
|
pAnnot->SetOMetadata(oInfo.GetOMetadata());
|
|
|
|
if (oInfo.IsMarkup())
|
|
{
|
|
CAnnotFieldInfo::CMarkupAnnotPr* pPr = oInfo.GetMarkupAnnotPr();
|
|
PdfWriter::CMarkupAnnotation* pMarkupAnnot = (PdfWriter::CMarkupAnnotation*)pAnnot;
|
|
|
|
nFlags = pPr->GetFlag();
|
|
|
|
PdfWriter::CAnnotation* pPopupAnnot = NULL;
|
|
if (nFlags & (1 << 0))
|
|
{
|
|
int nPopupID = pPr->GetPopupID();
|
|
if (nPopupID)
|
|
pPopupAnnot = m_pDocument->GetAnnot(nPopupID);
|
|
if (pOrigPage && pPage != pOrigPage)
|
|
{
|
|
pOrigPage->DeleteAnnotation(nPopupID);
|
|
if (pPopupAnnot)
|
|
{
|
|
pPage->AddAnnotation(pPopupAnnot);
|
|
pPopupAnnot->SetPage(pPage);
|
|
}
|
|
}
|
|
}
|
|
if (!pPopupAnnot && !oInfo.IsFreeText())
|
|
{
|
|
pPopupAnnot = pMarkupAnnot->CreatePopup();
|
|
pPage->AddAnnotation(pPopupAnnot);
|
|
pPopupAnnot->SetPage(pPage);
|
|
}
|
|
if (nFlags & (1 << 1))
|
|
pMarkupAnnot->SetT(pPr->GetT());
|
|
if (nFlags & (1 << 2))
|
|
pMarkupAnnot->SetCA(pPr->GetCA());
|
|
std::wstring sDefaultStyle;
|
|
if (nFlags & (1 << 3))
|
|
{
|
|
NSStringUtils::CStringBuilder oRC;
|
|
oRC += L"<?xml version=\"1.0\"?><body xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:xfa=\"http://www.xfa.org/schema/xfa-data/1.0/\" xfa:APIVersion=\"Acrobat:23.8.0\" xfa:spec=\"2.0.2\">";
|
|
std::vector<CAnnotFieldInfo::CMarkupAnnotPr::CFontData*> arrRC = pPr->GetRC();
|
|
|
|
bool bCurRTL = false;
|
|
if (!arrRC.empty())
|
|
{
|
|
NSStringUtils::CStringBuilder oDS;
|
|
oDS += L"font: Helvetica,sans-serif ";
|
|
oDS.AddDouble(arrRC[0]->dFontSise, 2);
|
|
oDS += L"pt; text-align:";
|
|
switch (arrRC[0]->nAlignment)
|
|
{
|
|
case 1: { oDS += L"center"; break; }
|
|
case 2: { oDS += L"right"; break; }
|
|
case 3: { oDS += L"justify"; break; }
|
|
case 0:
|
|
default:{ oDS += L"left"; break; }
|
|
}
|
|
oDS += L"; color:";
|
|
oDS.WriteHexColor3((unsigned char)(arrRC[0]->dColor[0] * 255.0),
|
|
(unsigned char)(arrRC[0]->dColor[1] * 255.0),
|
|
(unsigned char)(arrRC[0]->dColor[2] * 255.0));
|
|
sDefaultStyle = oDS.GetData();
|
|
|
|
bCurRTL = (arrRC[0]->nFontFlag >> 7) & 1;
|
|
}
|
|
|
|
oRC += (bCurRTL ? L"<p dir=\"rtl\">" : L"<p dir=\"ltr\">");
|
|
for (int i = 0; i < arrRC.size(); ++i)
|
|
{
|
|
bool bRTL = (arrRC[i]->nFontFlag >> 7) & 1;
|
|
if (bRTL != bCurRTL)
|
|
{
|
|
oRC += (bRTL ? L"</p><p dir=\"rtl\">" : L"</p><p dir=\"ltr\">");
|
|
bCurRTL = bRTL;
|
|
}
|
|
oRC += L"<span style=\"";
|
|
GetRCSpanStyle(arrRC[i], oRC);
|
|
oRC += L"\">";
|
|
oRC.WriteEncodeXmlString(arrRC[i]->sText);
|
|
oRC += L"</span>";
|
|
}
|
|
oRC += L"</p></body>";
|
|
pMarkupAnnot->SetRC(oRC.GetData());
|
|
// std::wcout << oRC.GetData() << std::endl;
|
|
}
|
|
if (nFlags & (1 << 4))
|
|
pMarkupAnnot->SetCD(pPr->GetCD());
|
|
if (nFlags & (1 << 5))
|
|
{
|
|
int nIRTID = pPr->GetIRTID();
|
|
PdfWriter::CAnnotation* pIRTAnnot = m_pDocument->GetAnnot(nIRTID);
|
|
if (pIRTAnnot)
|
|
pMarkupAnnot->SetIRTID(pIRTAnnot);
|
|
else
|
|
{
|
|
PdfWriter::CObjectBase* pBase = new PdfWriter::CObjectBase();
|
|
pBase->SetRef(nIRTID, 0);
|
|
pMarkupAnnot->Add("IRT", new PdfWriter::CProxyObject(pBase, true));
|
|
}
|
|
}
|
|
if (nFlags & (1 << 6))
|
|
pMarkupAnnot->SetRT(pPr->GetRT());
|
|
if (nFlags & (1 << 7))
|
|
pMarkupAnnot->SetSubj(pPr->GetSubj());
|
|
|
|
if (oInfo.IsText())
|
|
{
|
|
CAnnotFieldInfo::CTextAnnotPr* pPr = oInfo.GetTextAnnotPr();
|
|
PdfWriter::CTextAnnotation* pTextAnnot = (PdfWriter::CTextAnnotation*)pAnnot;
|
|
|
|
pTextAnnot->SetOpen(pPr->IsOpen());
|
|
if (nFlags & (1 << 16))
|
|
pTextAnnot->SetName(pPr->GetName());
|
|
if (nFlags & (1 << 17))
|
|
pTextAnnot->SetStateModel(pPr->GetStateModel());
|
|
if (nFlags & (1 << 18))
|
|
pTextAnnot->SetState(pPr->GetState());
|
|
|
|
if (!m_bSplit)
|
|
{
|
|
pMarkupAnnot->RemoveAP();
|
|
pTextAnnot->SetAP();
|
|
}
|
|
}
|
|
else if (oInfo.IsInk())
|
|
{
|
|
CAnnotFieldInfo::CInkAnnotPr* pPr = oInfo.GetInkAnnotPr();
|
|
PdfWriter::CInkAnnotation* pInkAnnot = (PdfWriter::CInkAnnotation*)pAnnot;
|
|
|
|
pInkAnnot->SetInkList(pPr->GetInkList());
|
|
if (bRender)
|
|
{
|
|
pMarkupAnnot->RemoveAP();
|
|
LONG nLen = 0;
|
|
BYTE* pRender = oInfo.GetRender(nLen);
|
|
DrawAP(pAnnot, pRender, nLen);
|
|
}
|
|
}
|
|
else if (oInfo.IsLine())
|
|
{
|
|
CAnnotFieldInfo::CLineAnnotPr* pPr = oInfo.GetLineAnnotPr();
|
|
PdfWriter::CLineAnnotation* pLineAnnot = (PdfWriter::CLineAnnotation*)pAnnot;
|
|
|
|
double dLX1, dLY1, dLX2, dLY2;
|
|
pPr->GetL(dLX1, dLY1, dLX2, dLY2);
|
|
pLineAnnot->SetL(dLX1, dLY1, dLX2, dLY2);
|
|
|
|
if (nFlags & (1 << 15))
|
|
{
|
|
BYTE nLE1, nLE2;
|
|
pPr->GetLE(nLE1, nLE2);
|
|
pLineAnnot->SetLE(nLE1, nLE2);
|
|
}
|
|
if (nFlags & (1 << 16))
|
|
pLineAnnot->SetIC(pPr->GetIC());
|
|
if (nFlags & (1 << 17))
|
|
pLineAnnot->SetLL(pPr->GetLL());
|
|
if (nFlags & (1 << 18))
|
|
pLineAnnot->SetLLE(pPr->GetLLE());
|
|
pLineAnnot->SetCap(pPr->IsCap());
|
|
if (nFlags & (1 << 20))
|
|
pLineAnnot->SetIT(pPr->GetIT());
|
|
if (nFlags & (1 << 21))
|
|
pLineAnnot->SetLLO(pPr->GetLLO());
|
|
if (nFlags & (1 << 22))
|
|
pLineAnnot->SetCP(pPr->GetCP());
|
|
if (nFlags & (1 << 23))
|
|
{
|
|
double dCO1, dCO2;
|
|
pPr->GetCO(dCO1, dCO2);
|
|
pLineAnnot->SetCO(dCO1, dCO2);
|
|
}
|
|
|
|
if (bRender)
|
|
{
|
|
pMarkupAnnot->RemoveAP();
|
|
LONG nLen = 0;
|
|
BYTE* pRender = oInfo.GetRender(nLen);
|
|
DrawAP(pAnnot, pRender, nLen);
|
|
}
|
|
}
|
|
else if (oInfo.IsTextMarkup())
|
|
{
|
|
CAnnotFieldInfo::CTextMarkupAnnotPr* pTMPr = oInfo.GetTextMarkupAnnotPr();
|
|
PdfWriter::CTextMarkupAnnotation* pTextMarkupAnnot = (PdfWriter::CTextMarkupAnnotation*)pAnnot;
|
|
|
|
pTextMarkupAnnot->SetSubtype(pTMPr->GetSubtype());
|
|
pTextMarkupAnnot->SetQuadPoints(pTMPr->GetQuadPoints());
|
|
|
|
if (!m_bSplit)
|
|
{
|
|
pMarkupAnnot->RemoveAP();
|
|
pTextMarkupAnnot->SetAP(pTMPr->GetQuadPoints(), pPr->GetCA());
|
|
}
|
|
}
|
|
else if (oInfo.IsSquareCircle())
|
|
{
|
|
CAnnotFieldInfo::CSquareCircleAnnotPr* pPr = oInfo.GetSquareCircleAnnotPr();
|
|
PdfWriter::CSquareCircleAnnotation* pSquareCircleAnnot = (PdfWriter::CSquareCircleAnnotation*)pAnnot;
|
|
|
|
pSquareCircleAnnot->SetSubtype(pPr->GetSubtype());
|
|
if (nFlags & (1 << 15))
|
|
{
|
|
double dRD1, dRD2, dRD3, dRD4;
|
|
pPr->GetRD(dRD1, dRD2, dRD3, dRD4);
|
|
pSquareCircleAnnot->SetRD(dRD1, dRD2, dRD3, dRD4);
|
|
}
|
|
if (nFlags & (1 << 16))
|
|
pSquareCircleAnnot->SetIC(pPr->GetIC());
|
|
if (bRender)
|
|
{
|
|
pMarkupAnnot->RemoveAP();
|
|
LONG nLen = 0;
|
|
BYTE* pRender = oInfo.GetRender(nLen);
|
|
DrawAP(pAnnot, pRender, nLen);
|
|
}
|
|
}
|
|
else if (oInfo.IsPolygonLine())
|
|
{
|
|
CAnnotFieldInfo::CPolygonLineAnnotPr* pPr = oInfo.GetPolygonLineAnnotPr();
|
|
PdfWriter::CPolygonLineAnnotation* pPolygonLineAnnot = (PdfWriter::CPolygonLineAnnotation*)pAnnot;
|
|
|
|
pPolygonLineAnnot->SetVertices(pPr->GetVertices());
|
|
pPolygonLineAnnot->SetSubtype(pPr->GetSubtype());
|
|
if (nFlags & (1 << 15))
|
|
{
|
|
BYTE nLE1, nLE2;
|
|
pPr->GetLE(nLE1, nLE2);
|
|
pPolygonLineAnnot->SetLE(nLE1, nLE2);
|
|
}
|
|
if (nFlags & (1 << 16))
|
|
pPolygonLineAnnot->SetIC(pPr->GetIC());
|
|
if (nFlags & (1 << 20))
|
|
pPolygonLineAnnot->SetIT(pPr->GetIT());
|
|
if (bRender)
|
|
{
|
|
pMarkupAnnot->RemoveAP();
|
|
LONG nLen = 0;
|
|
BYTE* pRender = oInfo.GetRender(nLen);
|
|
DrawAP(pAnnot, pRender, nLen);
|
|
}
|
|
}
|
|
else if (oInfo.IsFreeText())
|
|
{
|
|
CAnnotFieldInfo::CFreeTextAnnotPr* pFTPr = oInfo.GetFreeTextAnnotPr();
|
|
PdfWriter::CFreeTextAnnotation* pFreeTextAnnot = (PdfWriter::CFreeTextAnnotation*)pAnnot;
|
|
|
|
pFreeTextAnnot->SetQ(pFTPr->GetQ());
|
|
pFreeTextAnnot->SetRotate(pFTPr->GetRotate());
|
|
if (nFlags & (1 << 15))
|
|
{
|
|
double dRD1, dRD2, dRD3, dRD4;
|
|
pFTPr->GetRD(dRD1, dRD2, dRD3, dRD4);
|
|
pFreeTextAnnot->SetRD(dRD1, dRD2, dRD3, dRD4);
|
|
}
|
|
if (nFlags & (1 << 16))
|
|
pFreeTextAnnot->SetCL(pFTPr->GetCL());
|
|
|
|
std::wstring sDS = pFTPr->GetDS();
|
|
if (sDS.empty())
|
|
sDS = sDefaultStyle;
|
|
pFreeTextAnnot->SetDS(sDS);
|
|
|
|
if (nFlags & (1 << 18))
|
|
pFreeTextAnnot->SetLE(pFTPr->GetLE());
|
|
if (nFlags & (1 << 20))
|
|
pFreeTextAnnot->SetIT(pFTPr->GetIT());
|
|
if (nFlags & (1 << 21))
|
|
pFreeTextAnnot->SetIC(pFTPr->GetIC());
|
|
if (bRender)
|
|
{
|
|
pMarkupAnnot->RemoveAP();
|
|
LONG nLen = 0;
|
|
BYTE* pRender = oInfo.GetRender(nLen);
|
|
DrawAP(pAnnot, pRender, nLen);
|
|
}
|
|
|
|
PdfWriter::CFontDict* pFont = m_pFont;
|
|
if (m_pFont14)
|
|
pFont = m_pFont14;
|
|
pFreeTextAnnot->SetDA(pFont, m_oFont.GetSize(), oInfo.GetC());
|
|
}
|
|
else if (oInfo.IsCaret())
|
|
{
|
|
CAnnotFieldInfo::CCaretAnnotPr* pPr = oInfo.GetCaretAnnotPr();
|
|
PdfWriter::CCaretAnnotation* pCaretAnnot = (PdfWriter::CCaretAnnotation*)pAnnot;
|
|
|
|
if (nFlags & (1 << 15))
|
|
{
|
|
double dRD1, dRD2, dRD3, dRD4;
|
|
pPr->GetRD(dRD1, dRD2, dRD3, dRD4);
|
|
pCaretAnnot->SetRD(dRD1, dRD2, dRD3, dRD4);
|
|
}
|
|
if (nFlags & (1 << 16))
|
|
pCaretAnnot->SetSy(pPr->GetSy());
|
|
}
|
|
else if (oInfo.IsStamp())
|
|
{
|
|
CAnnotFieldInfo::CStampAnnotPr* pPr = oInfo.GetStampAnnotPr();
|
|
PdfWriter::CStampAnnotation* pStampAnnot = (PdfWriter::CStampAnnotation*)pAnnot;
|
|
|
|
pStampAnnot->SetName(L"#" + pPr->GetName());
|
|
double nRotate = pPr->GetRotate();
|
|
|
|
if (bRender)
|
|
{
|
|
LONG nLen = 0;
|
|
BYTE* pRender = oInfo.GetRender(nLen);
|
|
PdfWriter::CAnnotAppearanceObject* pAP = DrawAP(pAnnot, pRender, nLen);
|
|
|
|
double dRD1, dRD2, dRD3, dRD4;
|
|
pPr->GetInRect(dRD1, dRD2, dRD3, dRD4);
|
|
PdfWriter::CArrayObject* pArray = new PdfWriter::CArrayObject();
|
|
pAP->Add("BBox", pArray);
|
|
pArray->Add(dRD1 + dPageX);
|
|
pArray->Add(dPageH - dRD4);
|
|
pArray->Add(dRD3 + dPageX);
|
|
pArray->Add(dPageH - dRD2);
|
|
pStampAnnot->SetAPStream(pAP);
|
|
}
|
|
|
|
pStampAnnot->SetRotate(nRotate);
|
|
}
|
|
else if (oInfo.IsRedact())
|
|
{
|
|
CAnnotFieldInfo::CRedactAnnotPr* pPr = oInfo.GetRedactAnnotPr();
|
|
PdfWriter::CRedactAnnotation* pRedactAnnot = (PdfWriter::CRedactAnnotation*)pAnnot;
|
|
|
|
if (nFlags & (1 << 15))
|
|
pRedactAnnot->SetQuadPoints(pPr->GetQuadPoints());
|
|
if (nFlags & (1 << 16))
|
|
pRedactAnnot->SetIC(pPr->GetIC());
|
|
if (nFlags & (1 << 17))
|
|
pRedactAnnot->SetOverlayText(pPr->GetOverlayText());
|
|
if (nFlags & (1 << 18))
|
|
pRedactAnnot->SetRepeat(true);
|
|
if (nFlags & (1 << 19))
|
|
pRedactAnnot->SetQ(pPr->GetQ());
|
|
pRedactAnnot->SetOC(oInfo.GetC());
|
|
if (nFlags & (1 << 20))
|
|
{
|
|
std::wstring wsFontName = pPr->GetFontName();
|
|
int nStyle = pPr->GetFontStyle();
|
|
double dFontSize = pPr->GetFontSize();
|
|
PdfWriter::CFontTrueType* pFontTT = NULL;
|
|
|
|
put_FontName(wsFontName);
|
|
put_FontStyle(nStyle);
|
|
put_FontSize(dFontSize);
|
|
|
|
if (m_bNeedUpdateTextFont)
|
|
UpdateFont();
|
|
if (m_pFont)
|
|
pFontTT = m_pDocument->CreateTrueTypeFont(m_pFont);
|
|
pRedactAnnot->SetDA(pFontTT, dFontSize, pPr->GetFontColor());
|
|
}
|
|
}
|
|
}
|
|
else if (oInfo.IsPopup())
|
|
{
|
|
CAnnotFieldInfo::CPopupAnnotPr* pPr = oInfo.GetPopupAnnotPr();
|
|
PdfWriter::CPopupAnnotation* pPopupAnnot = (PdfWriter::CPopupAnnotation*)pAnnot;
|
|
|
|
nFlags = pPr->GetFlag();
|
|
pPopupAnnot->SetOpen(pPr->IsOpen());
|
|
if (nFlags & (1 << 1))
|
|
{
|
|
int nParentID = pPr->GetParentID();
|
|
PdfWriter::CAnnotation* pParentAnnot = m_pDocument->GetAnnot(nParentID);
|
|
if (pParentAnnot)
|
|
pPopupAnnot->SetParentID(pParentAnnot);
|
|
}
|
|
}
|
|
else if (oInfo.IsWidget())
|
|
{
|
|
CAnnotFieldInfo::CWidgetAnnotPr* pPr = oInfo.GetWidgetAnnotPr();
|
|
PdfWriter::CWidgetAnnotation* pWidgetAnnot = (PdfWriter::CWidgetAnnotation*)pAnnot;
|
|
|
|
std::wstring wsFontKey;
|
|
if (nFlags & (1 << 2))
|
|
wsFontKey = pPr->GetFontKey();
|
|
|
|
std::wstring wsFontName = pPr->GetFontName();
|
|
int nStyle = pPr->GetFontStyle();
|
|
double dFontSize = pPr->GetFontSizeAP();
|
|
PdfWriter::CFontTrueType* pFontTT = NULL;
|
|
|
|
BYTE nAlign = pPr->GetQ();
|
|
if (nWidgetType != 27 && nWidgetType != 28 && nWidgetType != 29)
|
|
pWidgetAnnot->SetQ(nAlign);
|
|
pWidgetAnnot->SetSubtype(nWidgetType);
|
|
pWidgetAnnot->SetFlag(pPr->GetFlag());
|
|
|
|
int nFlags = pPr->GetFlags();
|
|
int nR = 0;
|
|
if (nFlags & (1 << 0))
|
|
pWidgetAnnot->SetTU(pPr->GetTU());
|
|
if (nFlags & (1 << 1))
|
|
pWidgetAnnot->SetDS(pPr->GetDS());
|
|
if (nFlags & (1 << 3))
|
|
pWidgetAnnot->SetH(pPr->GetH());
|
|
if (nFlags & (1 << 5))
|
|
pWidgetAnnot->SetBC(pPr->GetBC());
|
|
if (nFlags & (1 << 6))
|
|
{
|
|
nR = pPr->GetR();
|
|
pWidgetAnnot->SetR(nR);
|
|
}
|
|
if (nFlags & (1 << 7))
|
|
pWidgetAnnot->SetBG(pPr->GetBG());
|
|
if (nFlags & (1 << 8))
|
|
pWidgetAnnot->SetDV(pPr->GetDV());
|
|
if (nFlags & (1 << 17))
|
|
pWidgetAnnot->SetParentID(pPr->GetParentID());
|
|
if (nFlags & (1 << 18))
|
|
pWidgetAnnot->SetT(pPr->GetT());
|
|
else
|
|
pWidgetAnnot->Remove("T");
|
|
if (nFlags & (1 << 21))
|
|
pWidgetAnnot->SetMEOptions(pPr->GetMEOptions());
|
|
else
|
|
pWidgetAnnot->Remove("MEOptions");
|
|
|
|
const std::vector<CAnnotFieldInfo::CWidgetAnnotPr::CActionWidget*> arrActions = pPr->GetActions();
|
|
for (CAnnotFieldInfo::CWidgetAnnotPr::CActionWidget* pAction : arrActions)
|
|
{
|
|
PdfWriter::CAction* pA = GetAction(m_pDocument, pAction);
|
|
pWidgetAnnot->AddAction(pA);
|
|
}
|
|
|
|
bool isBold = (nStyle & 1 ? true : false);
|
|
bool isItalic = (nStyle & 2 ? true : false);
|
|
|
|
if (oInfo.IsButtonWidget())
|
|
{
|
|
if (nWidgetType == 27)
|
|
{
|
|
CAnnotFieldInfo::CWidgetAnnotPr::CButtonWidgetPr* pPr = oInfo.GetWidgetAnnotPr()->GetButtonWidgetPr();
|
|
PdfWriter::CPushButtonWidget* pButtonWidget = (PdfWriter::CPushButtonWidget*)pAnnot;
|
|
|
|
BYTE nTP = 0;
|
|
if (nFlags & (1 << 13))
|
|
{
|
|
nTP = pPr->GetTP();
|
|
pButtonWidget->SetTP(nTP);
|
|
}
|
|
|
|
int nIFFlags = pPr->GetIFFlag();
|
|
pButtonWidget->SetIFFlag(nIFFlags);
|
|
if (nIFFlags & (1 << 0))
|
|
{
|
|
if (nIFFlags & (1 << 1))
|
|
pButtonWidget->SetSW(pPr->GetSW());
|
|
if (nIFFlags & (1 << 2))
|
|
pButtonWidget->SetS(pPr->GetS());
|
|
if (nIFFlags & (1 << 3))
|
|
{
|
|
double d1, d2;
|
|
pPr->GetA(d1, d2);
|
|
pButtonWidget->SetA(d1, d2);
|
|
}
|
|
}
|
|
|
|
if (nIFFlags & (1 << 5))
|
|
pButtonWidget->SetI(pPr->GetI());
|
|
if (nIFFlags & (1 << 6))
|
|
pButtonWidget->SetRI(pPr->GetRI());
|
|
if (nIFFlags & (1 << 7))
|
|
pButtonWidget->SetIX(pPr->GetIX());
|
|
|
|
put_FontName(wsFontName);
|
|
put_FontStyle(nStyle);
|
|
put_FontSize(dFontSize);
|
|
|
|
if (m_bNeedUpdateTextFont)
|
|
UpdateFont();
|
|
if (m_pFont)
|
|
pFontTT = m_pDocument->CreateTrueTypeFont(m_pFont);
|
|
pWidgetAnnot->SetDA(pFontTT, oInfo.GetWidgetAnnotPr()->GetFontSize(), dFontSize, oInfo.GetWidgetAnnotPr()->GetTC());
|
|
|
|
// ВНЕШНИЙ ВИД
|
|
pButtonWidget->SetFont(m_pFont, dFontSize, isBold, isItalic);
|
|
if (nFlags & (1 << 10))
|
|
{
|
|
pButtonWidget->SetCA(pPr->GetCA());
|
|
if (nTP == 0 && !m_bSplit)
|
|
DrawButtonWidget(pAppFonts, pButtonWidget, 0, NULL);
|
|
}
|
|
if (nFlags & (1 << 11))
|
|
{
|
|
pButtonWidget->SetRC(pPr->GetRC());
|
|
if (nTP == 0 && !m_bSplit)
|
|
DrawButtonWidget(pAppFonts, pButtonWidget, 1, NULL);
|
|
}
|
|
if (nFlags & (1 << 12))
|
|
{
|
|
pButtonWidget->SetAC(pPr->GetAC());
|
|
if (nTP == 0 && !m_bSplit)
|
|
DrawButtonWidget(pAppFonts, pButtonWidget, 2, NULL);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CAnnotFieldInfo::CWidgetAnnotPr::CButtonWidgetPr* pPrB = oInfo.GetWidgetAnnotPr()->GetButtonWidgetPr();
|
|
PdfWriter::CCheckBoxWidget* pButtonWidget = (PdfWriter::CCheckBoxWidget*)pAnnot;
|
|
|
|
if (nFlags & (1 << 14))
|
|
pButtonWidget->SetAP_N_Yes(pPrB->GetAP_N_Yes());
|
|
|
|
pButtonWidget->SetStyle(pPrB->GetStyle());
|
|
|
|
if (!pButtonWidget->Get("DA"))
|
|
{
|
|
PdfWriter::CFontDict* pFont = pFontTT;
|
|
dFontSize = oInfo.GetWidgetAnnotPr()->GetFontSize();
|
|
if (!wsFontName.empty())
|
|
{
|
|
put_FontName(wsFontName);
|
|
put_FontStyle(nStyle);
|
|
put_FontSize(dFontSize);
|
|
|
|
if (m_bNeedUpdateTextFont)
|
|
UpdateFont();
|
|
if (m_pFont)
|
|
pFont = m_pDocument->CreateTrueTypeFont(m_pFont);
|
|
}
|
|
else
|
|
{
|
|
put_FontName(L"Embedded: ZapfDingbats");
|
|
put_FontStyle(0);
|
|
put_FontSize(dFontSize);
|
|
|
|
if (m_bNeedUpdateTextFont)
|
|
UpdateFont();
|
|
if (m_pFont14)
|
|
pFont = m_pFont14;
|
|
}
|
|
pButtonWidget->SetDA(pFont, oInfo.GetWidgetAnnotPr()->GetFontSize(), dFontSize, oInfo.GetWidgetAnnotPr()->GetTC());
|
|
}
|
|
|
|
// ВНЕШНИЙ ВИД
|
|
if (!pButtonWidget->Get("AP"))
|
|
pButtonWidget->SetAP(nR);
|
|
|
|
if (nFlags & (1 << 9))
|
|
{
|
|
std::wstring sValue = pPrB->GetV();
|
|
if (sValue != L"Off")
|
|
pButtonWidget->Yes();
|
|
else
|
|
pButtonWidget->Off();
|
|
}
|
|
}
|
|
}
|
|
else if (oInfo.IsTextWidget())
|
|
{
|
|
CAnnotFieldInfo::CWidgetAnnotPr::CTextWidgetPr* pPr = oInfo.GetWidgetAnnotPr()->GetTextWidgetPr();
|
|
PdfWriter::CTextWidget* pTextWidget = (PdfWriter::CTextWidget*)pAnnot;
|
|
|
|
std::wstring wsValue;
|
|
bool bValue = false;
|
|
if (nFlags & (1 << 9))
|
|
{
|
|
bValue = true;
|
|
wsValue = pPr->GetV();
|
|
pTextWidget->SetV(wsValue);
|
|
}
|
|
if (nFlags & (1 << 10))
|
|
pTextWidget->SetMaxLen(pPr->GetMaxLen());
|
|
if (nFlags & (1 << 11))
|
|
pTextWidget->SetRV(pPr->GetRV());
|
|
bool bAPValue = false;
|
|
if (nFlags & (1 << 12))
|
|
{
|
|
bAPValue = true;
|
|
wsValue = pPr->GetAPV();
|
|
pTextWidget->SetAPV();
|
|
}
|
|
if (nFlags & (1 << 13))
|
|
{
|
|
pTextWidget->SetAPV();
|
|
m_pFont14 = NULL; m_pFont = NULL;
|
|
m_bNeedUpdateTextFont = true;
|
|
|
|
LONG nLen = 0;
|
|
BYTE* pRender = pPr->GetRender(nLen);
|
|
DrawWidgetAP(pAnnot, pRender, nLen, nR);
|
|
|
|
PdfWriter::CFontDict* pFont = NULL;
|
|
if (m_pFont14)
|
|
pFont = m_pFont14;
|
|
else if (m_pFont)
|
|
pFont = m_pDocument->CreateTrueTypeFont(m_pFont);
|
|
else
|
|
{
|
|
dFontSize = oInfo.GetWidgetAnnotPr()->GetFontSize();
|
|
put_FontName(wsFontName);
|
|
put_FontStyle(nStyle);
|
|
put_FontSize(dFontSize);
|
|
|
|
if (m_bNeedUpdateTextFont)
|
|
UpdateFont();
|
|
if (m_pFont14)
|
|
pFont = m_pFont14;
|
|
else if (m_pFont)
|
|
pFont = m_pDocument->CreateTrueTypeFont(m_pFont);
|
|
}
|
|
if (pFont)
|
|
pWidgetAnnot->SetDA(pFont, oInfo.GetWidgetAnnotPr()->GetFontSize(), dFontSize, oInfo.GetWidgetAnnotPr()->GetTC());
|
|
}
|
|
else if (!m_bSplit && ((bValue && pTextWidget->Get("T")) || bAPValue))
|
|
{
|
|
put_FontName(wsFontName);
|
|
put_FontStyle(nStyle);
|
|
put_FontSize(dFontSize);
|
|
|
|
if (m_bNeedUpdateTextFont)
|
|
UpdateFont();
|
|
if (m_pFont)
|
|
pFontTT = m_pDocument->CreateTrueTypeFont(m_pFont);
|
|
pWidgetAnnot->SetDA(pFontTT, oInfo.GetWidgetAnnotPr()->GetFontSize(), dFontSize, oInfo.GetWidgetAnnotPr()->GetTC());
|
|
|
|
pTextWidget->SetFont(m_pFont, dFontSize, isBold, isItalic);
|
|
DrawTextWidget(pAppFonts, pTextWidget, wsValue);
|
|
}
|
|
}
|
|
else if (oInfo.IsChoiceWidget())
|
|
{
|
|
CAnnotFieldInfo::CWidgetAnnotPr::CChoiceWidgetPr* pPr = oInfo.GetWidgetAnnotPr()->GetChoiceWidgetPr();
|
|
PdfWriter::CChoiceWidget* pChoiceWidget = (PdfWriter::CChoiceWidget*)pAnnot;
|
|
|
|
std::vector<std::wstring> arrValue;
|
|
if (nFlags & (1 << 9))
|
|
{
|
|
arrValue.push_back(pPr->GetV());
|
|
pChoiceWidget->SetV(arrValue.back());
|
|
}
|
|
if (nFlags & (1 << 10))
|
|
pChoiceWidget->SetOpt(pPr->GetOpt());
|
|
if (nFlags & (1 << 11))
|
|
pChoiceWidget->SetTI(pPr->GetTI());
|
|
if (nFlags & (1 << 12))
|
|
arrValue[arrValue.size()] = pPr->GetAPV();
|
|
if (nFlags & (1 << 13))
|
|
pChoiceWidget->SetV(pPr->GetArrV());
|
|
if (nFlags & (1 << 14))
|
|
pChoiceWidget->SetI(pPr->GetI());
|
|
else
|
|
pChoiceWidget->Remove("I");
|
|
if (nFlags & (1 << 15))
|
|
{
|
|
pChoiceWidget->SetAPV();
|
|
m_pFont14 = NULL; m_pFont = NULL;
|
|
m_bNeedUpdateTextFont = true;
|
|
|
|
LONG nLen = 0;
|
|
BYTE* pRender = pPr->GetRender(nLen);
|
|
DrawWidgetAP(pAnnot, pRender, nLen, nR, pChoiceWidget->GetWidgetType() == PdfWriter::WidgetCombobox);
|
|
|
|
PdfWriter::CFontDict* pFont = NULL;
|
|
if (m_pFont14)
|
|
pFont = m_pFont14;
|
|
else if (m_pFont)
|
|
pFont = m_pDocument->CreateTrueTypeFont(m_pFont);
|
|
else
|
|
{
|
|
dFontSize = oInfo.GetWidgetAnnotPr()->GetFontSize();
|
|
put_FontName(wsFontName);
|
|
put_FontStyle(nStyle);
|
|
put_FontSize(dFontSize);
|
|
|
|
if (m_bNeedUpdateTextFont)
|
|
UpdateFont();
|
|
if (m_pFont14)
|
|
pFont = m_pFont14;
|
|
else if (m_pFont)
|
|
pFont = m_pDocument->CreateTrueTypeFont(m_pFont);
|
|
}
|
|
if (pFont)
|
|
pWidgetAnnot->SetDA(pFont, oInfo.GetWidgetAnnotPr()->GetFontSize(), dFontSize, oInfo.GetWidgetAnnotPr()->GetTC());
|
|
}
|
|
else if (!m_bSplit && !arrValue.empty())
|
|
{
|
|
put_FontName(wsFontName);
|
|
put_FontStyle(nStyle);
|
|
put_FontSize(dFontSize);
|
|
|
|
if (m_bNeedUpdateTextFont)
|
|
UpdateFont();
|
|
if (m_pFont)
|
|
pFontTT = m_pDocument->CreateTrueTypeFont(m_pFont);
|
|
pWidgetAnnot->SetDA(pFontTT, oInfo.GetWidgetAnnotPr()->GetFontSize(), dFontSize, oInfo.GetWidgetAnnotPr()->GetTC());
|
|
|
|
pChoiceWidget->SetFont(m_pFont, dFontSize, isBold, isItalic);
|
|
DrawChoiceWidget(pAppFonts, pChoiceWidget, arrValue);
|
|
}
|
|
}
|
|
else if (oInfo.IsSignatureWidget())
|
|
{
|
|
CAnnotFieldInfo::CWidgetAnnotPr::CSignatureWidgetPr* pPr = oInfo.GetWidgetAnnotPr()->GetSignatureWidgetPr();
|
|
PdfWriter::CSignatureWidget* pSignatureWidget = (PdfWriter::CSignatureWidget*)pAnnot;
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::AddMetaData(const std::wstring& sMetaName, BYTE* pMetaData, DWORD nMetaLength)
|
|
{
|
|
return m_pDocument->AddMetaData(sMetaName, pMetaData, nMetaLength) ? S_OK : S_FALSE;
|
|
}
|
|
HRESULT CPdfWriter::AddRedact(const std::vector<double>& arrRedact)
|
|
{
|
|
m_arrRedact.clear();
|
|
if (arrRedact.empty())
|
|
return S_OK;
|
|
m_arrRedact = arrRedact;
|
|
|
|
PdfWriter::CArrayObject* pPageBox = (PdfWriter::CArrayObject*)m_pPage->Get("CropBox");
|
|
if (!pPageBox)
|
|
pPageBox = (PdfWriter::CArrayObject*)m_pPage->Get("MediaBox");
|
|
PdfWriter::CObjectBase* pD = pPageBox->Get(3);
|
|
double dPageH = pD->GetType() == PdfWriter::object_type_NUMBER ? ((PdfWriter::CNumberObject*)pD)->Get() : ((PdfWriter::CRealObject*)pD)->Get();
|
|
pD = pPageBox->Get(0);
|
|
double dPageX = pD->GetType() == PdfWriter::object_type_NUMBER ? ((PdfWriter::CNumberObject*)pD)->Get() : ((PdfWriter::CRealObject*)pD)->Get();
|
|
|
|
for (int i = 0; i < m_arrRedact.size(); i += 2)
|
|
{
|
|
m_arrRedact[i + 0] += dPageX;
|
|
m_arrRedact[i + 1] = dPageH - m_arrRedact[i + 1];
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
void CreateOutlines(PdfWriter::CDocument* m_pDocument, const std::vector<CHeadings::CHeading*>& arrHeadings, PdfWriter::COutline* pParent)
|
|
{
|
|
for (int i = 0; i < arrHeadings.size(); ++i)
|
|
{
|
|
std::string sTitle = U_TO_UTF8(arrHeadings[i]->wsTitle);
|
|
PdfWriter::COutline* pOutline = m_pDocument->CreateOutline(pParent, sTitle.c_str());
|
|
PdfWriter::CPage* pPageD = m_pDocument->GetPage(arrHeadings[i]->nPage);
|
|
PdfWriter::CDestination* pDest = m_pDocument->CreateDestination(pPageD, true);
|
|
if (pDest)
|
|
{
|
|
pOutline->SetDestination(pDest);
|
|
pDest->SetXYZ(MM_2_PT(arrHeadings[i]->dX), pPageD->GetHeight() - MM_2_PT(arrHeadings[i]->dY), 0);
|
|
}
|
|
CreateOutlines(m_pDocument, arrHeadings[i]->arrHeading, pOutline);
|
|
}
|
|
}
|
|
void CPdfWriter::SetHeadings(CHeadings* pCommand)
|
|
{
|
|
if (!m_pDocument || !pCommand)
|
|
return;
|
|
|
|
CreateOutlines(m_pDocument, pCommand->GetHeading(), NULL);
|
|
}
|
|
void CPdfWriter::SetNeedAddHelvetica(bool bNeedAddHelvetica) { m_bNeedAddHelvetica = bNeedAddHelvetica; }
|
|
//----------------------------------------------------------------------------------------
|
|
// Дополнительные функции Pdf рендерера
|
|
//----------------------------------------------------------------------------------------
|
|
HRESULT CPdfWriter::DrawImage1bpp(NSImages::CPixJbig2* pImageBuffer, const unsigned int& unWidth, const unsigned int& unHeight, const double& dX, const double& dY, const double& dW, const double& dH)
|
|
{
|
|
m_oCommandManager.Flush();
|
|
|
|
if (!IsPageValid() || !pImageBuffer || SkipRedact(dX, dY, dW, dH))
|
|
return S_OK;
|
|
|
|
m_pPage->GrSave();
|
|
UpdateTransform();
|
|
|
|
PdfWriter::CImageDict* pPdfImage = m_pDocument->CreateImage();
|
|
pPdfImage->LoadBW(pImageBuffer, unWidth, unHeight);
|
|
m_pPage->DrawImage(pPdfImage, MM_2_PT(dX), MM_2_PT(m_dPageHeight - dY - dH), MM_2_PT(dW), MM_2_PT(dH));
|
|
|
|
m_pPage->GrRestore();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::EnableBrushRect(const LONG& lEnable)
|
|
{
|
|
m_oBrush.EnableBrushRect(LONG_2_BOOL(lEnable));
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::SetLinearGradient(const double& dX0, const double& dY0, const double& dX1, const double& dY1)
|
|
{
|
|
m_oBrush.SetType(c_BrushTypeLinearGradient);
|
|
m_oBrush.SetLinearGradientPattern(dX0, dY0, dX1, dY1);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::SetRadialGradient(const double& dX0, const double& dY0, const double& dR0, const double& dX1, const double& dY1, const double& dR1)
|
|
{
|
|
m_oBrush.SetType(c_BrushTypeRadialGradient);
|
|
m_oBrush.SetRadialGradientPattern(dX0, dY0, dR0, dX1, dY1, dR1);
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::DrawImageWith1bppMask(IGrObject* pImage, NSImages::CPixJbig2* pMaskBuffer, const unsigned int& unMaskWidth, const unsigned int& unMaskHeight, const double& dX, const double& dY, const double& dW, const double& dH)
|
|
{
|
|
m_oCommandManager.Flush();
|
|
|
|
if (!IsPageValid() || !pMaskBuffer || !pImage || SkipRedact(dX, dY, dW, dH))
|
|
return S_OK;
|
|
|
|
PdfWriter::CImageDict* pPdfImage = LoadImage((Aggplus::CImage*)pImage, 255);
|
|
if (!pPdfImage)
|
|
return S_OK;
|
|
|
|
m_pPage->GrSave();
|
|
UpdateTransform();
|
|
pPdfImage->LoadMask(pMaskBuffer, unMaskWidth, unMaskHeight);
|
|
m_pPage->DrawImage(pPdfImage, MM_2_PT(dX), MM_2_PT(m_dPageHeight - dY - dH), MM_2_PT(dW), MM_2_PT(dH));
|
|
m_pPage->GrRestore();
|
|
return S_OK;
|
|
}
|
|
HRESULT CPdfWriter::EditWidgetParents(NSFonts::IApplicationFonts* pAppFonts, CWidgetsInfo* pFieldInfo, const std::wstring& wsTempDirectory)
|
|
{
|
|
if (!m_pDocument || 0 == m_pDocument->GetPagesCount() || !pFieldInfo)
|
|
return S_OK;
|
|
|
|
if (!m_pDocument->EditCO(pFieldInfo->GetCO()))
|
|
return S_FALSE;
|
|
|
|
std::vector<CWidgetsInfo::CParent*> arrParents = pFieldInfo->GetParents();
|
|
for (int j = 0; j < arrParents.size(); ++j)
|
|
{
|
|
CWidgetsInfo::CParent* pParent = arrParents[j];
|
|
PdfWriter::CDictObject* pParentObj = m_pDocument->GetParent(pParent->nID);
|
|
if (!pParentObj)
|
|
pParentObj = m_pDocument->CreateParent(pParent->nID);
|
|
|
|
std::vector<std::wstring> arrValue;
|
|
|
|
int nFlags = pParent->nFlags;
|
|
// Adobe не может смешивать юникод и utf имена полей
|
|
if (nFlags & (1 << 0))
|
|
pParentObj->Add("T", new PdfWriter::CStringObject((U_TO_UTF8(pParent->sName)).c_str(), true));
|
|
|
|
std::string sFT = m_pDocument->SetParentKids(pParent->nID);
|
|
PdfWriter::CArrayObject* pKids = dynamic_cast<PdfWriter::CArrayObject*>(pParentObj->Get("Kids"));
|
|
if (!pKids)
|
|
{
|
|
pKids = new PdfWriter::CArrayObject();
|
|
pParentObj->Add("Kids", pKids);
|
|
}
|
|
|
|
if (nFlags & (1 << 2))
|
|
{
|
|
std::string sDV = U_TO_UTF8(pParent->sDV);
|
|
if (sFT == "Btn")
|
|
pParentObj->Add("DV", sDV.c_str());
|
|
else
|
|
pParentObj->Add("DV", new PdfWriter::CStringObject(sDV.c_str(), true));
|
|
}
|
|
if (nFlags & (1 << 3))
|
|
{
|
|
PdfWriter::CArrayObject* pArray = new PdfWriter::CArrayObject();
|
|
pParentObj->Add("I", pArray);
|
|
for (int i = 0; i < pParent->arrI.size(); ++i)
|
|
pArray->Add(pParent->arrI[i]);
|
|
}
|
|
else
|
|
pParentObj->Remove("I");
|
|
if (nFlags & (1 << 4))
|
|
{
|
|
PdfWriter::CDictObject* pParentObj2 = m_pDocument->GetParent(pParent->nParentID);
|
|
if (!pParentObj2)
|
|
pParentObj2 = m_pDocument->CreateParent(pParent->nParentID);
|
|
if (pParentObj2)
|
|
pParentObj->Add("Parent", pParentObj2);
|
|
}
|
|
if (nFlags & (1 << 5))
|
|
{
|
|
PdfWriter::CArrayObject* pArray = new PdfWriter::CArrayObject();
|
|
pParentObj->Add("V", pArray);
|
|
for (int i = 0; i < pParent->arrV.size(); ++i)
|
|
pArray->Add(new PdfWriter::CStringObject(U_TO_UTF8(pParent->arrV[i]).c_str(), true));
|
|
|
|
for (int i = 0; i < pKids->GetCount(); ++i)
|
|
{
|
|
PdfWriter::CObjectBase* pObj = pKids->Get(i);
|
|
if (pObj->GetType() != PdfWriter::object_type_DICT ||
|
|
((PdfWriter::CDictObject*)pObj)->GetDictType() != PdfWriter::dict_type_ANNOTATION ||
|
|
((PdfWriter::CAnnotation*)pObj)->GetAnnotationType() != PdfWriter::AnnotWidget)
|
|
continue;
|
|
PdfWriter::EWidgetType nType = ((PdfWriter::CWidgetAnnotation*)pObj)->GetWidgetType();
|
|
if (nType == PdfWriter::WidgetCombobox || nType == PdfWriter::WidgetListbox)
|
|
{
|
|
PdfWriter::CChoiceWidget* pKid = dynamic_cast<PdfWriter::CChoiceWidget*>(pObj);
|
|
if (!pKid->HaveAPV() && !m_bSplit)
|
|
DrawChoiceWidget(pAppFonts, pKid, pParent->arrV);
|
|
}
|
|
}
|
|
}
|
|
std::map<std::wstring, std::wstring> mNameAP_N_Yes;
|
|
if (nFlags & (1 << 6))
|
|
{
|
|
PdfWriter::CArrayObject* pArray = new PdfWriter::CArrayObject();
|
|
pParentObj->Add("Opt", pArray);
|
|
|
|
for (int i = 0; i < pParent->arrOpt.size(); ++i)
|
|
{
|
|
std::pair<std::wstring, std::wstring> PV = pParent->arrOpt[i];
|
|
std::string sValue;
|
|
if (PV.first.empty())
|
|
{
|
|
sValue = U_TO_UTF8(PV.second);
|
|
pArray->Add(new PdfWriter::CStringObject(sValue.c_str(), true));
|
|
|
|
if (mNameAP_N_Yes.find(PV.second) == mNameAP_N_Yes.end())
|
|
mNameAP_N_Yes[PV.second] = std::to_wstring(i);
|
|
}
|
|
else
|
|
{
|
|
PdfWriter::CArrayObject* pArray2 = new PdfWriter::CArrayObject();
|
|
pArray->Add(pArray2);
|
|
|
|
sValue = U_TO_UTF8(PV.first);
|
|
pArray2->Add(new PdfWriter::CStringObject(sValue.c_str(), true));
|
|
|
|
if (mNameAP_N_Yes.find(PV.first) == mNameAP_N_Yes.end())
|
|
mNameAP_N_Yes[PV.first] = std::to_wstring(i);
|
|
|
|
sValue = U_TO_UTF8(PV.second);
|
|
pArray2->Add(new PdfWriter::CStringObject(sValue.c_str(), true));
|
|
}
|
|
}
|
|
}
|
|
if (nFlags & (1 << 1))
|
|
{
|
|
std::string sV = U_TO_UTF8(pParent->sV);
|
|
if (sFT == "Btn")
|
|
{
|
|
int nFf = 0;
|
|
if (nFlags & (1 << 7))
|
|
nFf = pParent->nFieldFlag;
|
|
bool bRadiosInUnison = (bool)(nFf & (1 << 25));
|
|
int nOptIndex = -1;
|
|
if (isdigit(sV[0]))
|
|
nOptIndex = std::stoi(sV);
|
|
|
|
if (!pParent->arrOpt.empty() && nOptIndex >= 0 && nOptIndex < pParent->arrOpt.size())
|
|
{
|
|
std::pair<std::wstring, std::wstring> PV = pParent->arrOpt[nOptIndex];
|
|
std::wstring sOpt = PV.first.empty() ? PV.second : PV.first;
|
|
|
|
for (int i = 0; i < pParent->arrOpt.size(); ++i)
|
|
{
|
|
if (i >= pKids->GetCount())
|
|
break;
|
|
PdfWriter::CObjectBase* pObj = pKids->Get(i);
|
|
if (pObj->GetType() != PdfWriter::object_type_DICT ||
|
|
((PdfWriter::CDictObject*)pObj)->GetDictType() != PdfWriter::dict_type_ANNOTATION ||
|
|
((PdfWriter::CAnnotation*)pObj)->GetAnnotationType() != PdfWriter::AnnotWidget)
|
|
continue;
|
|
PdfWriter::EWidgetType nType = ((PdfWriter::CWidgetAnnotation*)pObj)->GetWidgetType();
|
|
if (nType != PdfWriter::WidgetCheckbox && nType != PdfWriter::WidgetRadiobutton)
|
|
continue;
|
|
PdfWriter::CCheckBoxWidget* pKid = dynamic_cast<PdfWriter::CCheckBoxWidget*>(pObj);
|
|
if (!pKid)
|
|
continue;
|
|
|
|
PV = pParent->arrOpt[i];
|
|
std::wstring sOptI = PV.first.empty() ? PV.second : PV.first;
|
|
if (pKid->NeedAP_N_Yes())
|
|
pKid->SetAP_N_Yes((bRadiosInUnison || nType == PdfWriter::WidgetCheckbox) ? mNameAP_N_Yes[sOptI] : std::to_wstring(i));
|
|
|
|
pKid->Remove("V");
|
|
if (((bRadiosInUnison || nType == PdfWriter::WidgetCheckbox) && sOptI == sOpt) || (!bRadiosInUnison && i == nOptIndex))
|
|
{
|
|
if (i == nOptIndex)
|
|
pKid->RenameAP_N_Yes(pParent->sV);
|
|
sV = pKid->Yes();
|
|
}
|
|
else
|
|
pKid->Off();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < pKids->GetCount(); ++i)
|
|
{
|
|
PdfWriter::CObjectBase* pObj = pKids->Get(i);
|
|
if (pObj->GetType() != PdfWriter::object_type_DICT ||
|
|
((PdfWriter::CDictObject*)pObj)->GetDictType() != PdfWriter::dict_type_ANNOTATION ||
|
|
((PdfWriter::CAnnotation*)pObj)->GetAnnotationType() != PdfWriter::AnnotWidget)
|
|
continue;
|
|
PdfWriter::EWidgetType nType = ((PdfWriter::CWidgetAnnotation*)pObj)->GetWidgetType();
|
|
if (nType != PdfWriter::WidgetCheckbox && nType != PdfWriter::WidgetRadiobutton)
|
|
continue;
|
|
PdfWriter::CCheckBoxWidget* pKid = dynamic_cast<PdfWriter::CCheckBoxWidget*>(pObj);
|
|
if (!pKid)
|
|
continue;
|
|
if (pKid->NeedAP_N_Yes())
|
|
{
|
|
std::pair<std::wstring, std::wstring> PV = pParent->arrOpt[i];
|
|
std::wstring sOpt = PV.first.empty() ? PV.second : PV.first;
|
|
pKid->SetAP_N_Yes(mNameAP_N_Yes[sOpt]);
|
|
}
|
|
|
|
pKid->Remove("V");
|
|
if (pKid->GetAP_N_Yes() == sV)
|
|
sV = pKid->Yes();
|
|
else
|
|
pKid->Off();
|
|
}
|
|
}
|
|
|
|
pParentObj->Add("V", sV.c_str());
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < pKids->GetCount(); ++i)
|
|
{
|
|
PdfWriter::CObjectBase* pObj = pKids->Get(i);
|
|
if (pObj->GetType() != PdfWriter::object_type_DICT ||
|
|
((PdfWriter::CDictObject*)pObj)->GetDictType() != PdfWriter::dict_type_ANNOTATION ||
|
|
((PdfWriter::CAnnotation*)pObj)->GetAnnotationType() != PdfWriter::AnnotWidget)
|
|
continue;
|
|
PdfWriter::EWidgetType nType = ((PdfWriter::CWidgetAnnotation*)pObj)->GetWidgetType();
|
|
if (nType == PdfWriter::WidgetCombobox || nType == PdfWriter::WidgetListbox)
|
|
{
|
|
PdfWriter::CChoiceWidget* pKid = dynamic_cast<PdfWriter::CChoiceWidget*>(pObj);
|
|
if (!pKid->HaveAPV() && !m_bSplit)
|
|
DrawChoiceWidget(pAppFonts, pKid, {pParent->sV});
|
|
}
|
|
else if (nType == PdfWriter::WidgetText)
|
|
{
|
|
PdfWriter::CTextWidget* pKid = dynamic_cast<PdfWriter::CTextWidget*>(pObj);
|
|
if (!pKid->HaveAPV() && !m_bSplit)
|
|
DrawTextWidget(pAppFonts, pKid, pParent->sV);
|
|
}
|
|
}
|
|
pParentObj->Add("V", new PdfWriter::CStringObject(sV.c_str(), true));
|
|
}
|
|
}
|
|
if (nFlags & (1 << 7))
|
|
pParentObj->Add("Ff", pParent->nFieldFlag);
|
|
if (nFlags & (1 << 8))
|
|
{
|
|
const std::vector<CAnnotFieldInfo::CWidgetAnnotPr::CActionWidget*> arrActions = pParent->arrAction;
|
|
for (CAnnotFieldInfo::CWidgetAnnotPr::CActionWidget* pAction : arrActions)
|
|
{
|
|
PdfWriter::CAction* pA = GetAction(m_pDocument, pAction);
|
|
if (!pA)
|
|
continue;
|
|
|
|
if (pA->m_sType == "A")
|
|
pParentObj->Add(pA->m_sType.c_str(), pA);
|
|
else
|
|
{
|
|
PdfWriter::CDictObject* pAA = (PdfWriter::CDictObject*)pParentObj->Get("AA");
|
|
if (!pAA)
|
|
{
|
|
pAA = new PdfWriter::CDictObject();
|
|
pParentObj->Add("AA", pAA);
|
|
}
|
|
pAA->Add(pA->m_sType.c_str(), pA);
|
|
}
|
|
}
|
|
}
|
|
if (nFlags & (1 << 9))
|
|
pParentObj->Add("MaxLen", pParent->nMaxLen);
|
|
if (nFlags & (1 << 10))
|
|
pParentObj->Add("TU", new PdfWriter::CStringObject((U_TO_UTF8(pParent->sTU)).c_str(), true));
|
|
if (nFlags & (1 << 11))
|
|
pParentObj->Add("MEOptions", pParent->nMEOptions);
|
|
else
|
|
pParentObj->Remove("MEOptions");
|
|
}
|
|
|
|
std::vector<std::wstring> arrBI = pFieldInfo->GetButtonImg();
|
|
std::vector<PdfWriter::CXObject*> arrForm;
|
|
for (int i = 0; i < arrBI.size(); ++i)
|
|
{
|
|
std::wstring wsPath = arrBI[i];
|
|
if (wsPath.empty())
|
|
{
|
|
arrForm.push_back(NULL);
|
|
continue;
|
|
}
|
|
std::wstring sTempImagePath = GetDownloadFile(wsPath, wsTempDirectory);
|
|
std::wstring wsImagePath = sTempImagePath.empty() ? wsPath : sTempImagePath;
|
|
|
|
Aggplus::CImage* pCImage = ConvertMetafile(pAppFonts, wsImagePath, m_bSplit ? L"" : GetTempFile(wsTempDirectory));
|
|
PdfWriter::CImageDict* pImage = LoadImage(pCImage, 255);
|
|
RELEASEOBJECT(pCImage);
|
|
|
|
arrForm.push_back(m_pDocument->CreateForm(pImage, std::to_string(i)));
|
|
}
|
|
|
|
std::map<int, PdfWriter::CAnnotation*> mAnnots = m_pDocument->GetAnnots();
|
|
for (auto it = mAnnots.begin(); it != mAnnots.end(); it++)
|
|
{
|
|
PdfWriter::CAnnotation* pAnnot = it->second;
|
|
if (pAnnot->GetAnnotationType() != PdfWriter::AnnotWidget)
|
|
continue;
|
|
|
|
PdfWriter::CWidgetAnnotation* pWidget = (PdfWriter::CWidgetAnnotation*)pAnnot;
|
|
if (pWidget->GetWidgetType() != PdfWriter::WidgetPushbutton)
|
|
continue;
|
|
|
|
PdfWriter::CPushButtonWidget* pPBWidget = (PdfWriter::CPushButtonWidget*)pAnnot;
|
|
if (pPBWidget->m_nI >= 0)
|
|
DrawButtonWidget(pAppFonts, pPBWidget, 0, arrForm[pPBWidget->m_nI]);
|
|
if (pPBWidget->m_nRI >= 0)
|
|
DrawButtonWidget(pAppFonts, pPBWidget, 1, arrForm[pPBWidget->m_nRI]);
|
|
else if (pPBWidget->m_nI >= 0)
|
|
{
|
|
PdfWriter::CDictObject* pObj = dynamic_cast<PdfWriter::CDictObject*>(pPBWidget->Get("AP"));
|
|
if (pObj && pObj->Get("R"))
|
|
{
|
|
pObj = dynamic_cast<PdfWriter::CDictObject*>(pPBWidget->Get("MK"));
|
|
if (pObj && !pObj->Get("RI"))
|
|
DrawButtonWidget(pAppFonts, pPBWidget, 1, arrForm[pPBWidget->m_nI]);
|
|
}
|
|
}
|
|
if (pPBWidget->m_nIX >= 0)
|
|
DrawButtonWidget(pAppFonts, pPBWidget, 2, arrForm[pPBWidget->m_nIX]);
|
|
else if (pPBWidget->m_nI >= 0)
|
|
{
|
|
PdfWriter::CDictObject* pObj = dynamic_cast<PdfWriter::CDictObject*>(pPBWidget->Get("AP"));
|
|
if (pObj && pObj->Get("D"))
|
|
{
|
|
pObj = dynamic_cast<PdfWriter::CDictObject*>(pPBWidget->Get("MK"));
|
|
if (pObj && !pObj->Get("IX"))
|
|
DrawButtonWidget(pAppFonts, pPBWidget, 2, arrForm[pPBWidget->m_nI]);
|
|
}
|
|
}
|
|
|
|
if (!pPBWidget->Get("AP") && !m_bSplit)
|
|
DrawButtonWidget(pAppFonts, pPBWidget, 0, NULL);
|
|
}
|
|
|
|
std::map<int, PdfWriter::CDictObject*> mParents = m_pDocument->GetParents();
|
|
for (auto it = mParents.begin(); it != mParents.end(); it++)
|
|
{
|
|
PdfWriter::CDictObject* pP = it->second;
|
|
PdfWriter::CObjectBase* pParentOfParent = pP->Get("Parent");
|
|
if (!pParentOfParent || pParentOfParent->GetType() != PdfWriter::object_type_DICT)
|
|
continue;
|
|
|
|
PdfWriter::CDictObject* pParent = (PdfWriter::CDictObject*)pParentOfParent;
|
|
PdfWriter::CArrayObject* pKids = dynamic_cast<PdfWriter::CArrayObject*>(pParent->Get("Kids"));
|
|
if (!pKids)
|
|
{
|
|
pKids = new PdfWriter::CArrayObject();
|
|
pParent->Add("Kids", pKids);
|
|
}
|
|
|
|
bool bReplase = false;
|
|
int nID = pP->GetObjId();
|
|
if (nID > 0)
|
|
{
|
|
for (int i = 0; i < pKids->GetCount(); ++i)
|
|
{
|
|
PdfWriter::CObjectBase* pKid = pKids->Get(i);
|
|
if (pKid->GetObjId() == nID)
|
|
{
|
|
pKids->Insert(pKid, pP, true);
|
|
bReplase = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!bReplase)
|
|
pKids->Add(pP);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
PdfWriter::CDocument* CPdfWriter::GetDocument() { return m_pDocument; }
|
|
PdfWriter::CPage* CPdfWriter::GetPage() { return m_pPage; }
|
|
IRenderer* CPdfWriter::GetRenderer() { return m_pRenderer; }
|
|
void CPdfWriter::SetPage(PdfWriter::CPage* pPage)
|
|
{
|
|
if (!IsValid())
|
|
return;
|
|
m_oCommandManager.Flush();
|
|
|
|
m_pPage = pPage;
|
|
}
|
|
bool CPdfWriter::EditPage(PdfWriter::CPage* pNewPage)
|
|
{
|
|
if (!IsValid())
|
|
return false;
|
|
m_oCommandManager.Flush();
|
|
|
|
m_pPage = pNewPage;
|
|
if (m_pPage)
|
|
{
|
|
m_dPageWidth = PT_2_MM(m_pPage->GetWidth());
|
|
m_dPageHeight = PT_2_MM(m_pPage->GetHeight());
|
|
Reset();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
bool CPdfWriter::AddPage(int nPageIndex)
|
|
{
|
|
if (!IsValid())
|
|
return false;
|
|
m_oCommandManager.Flush();
|
|
|
|
m_pPage = m_pDocument->AddPage(nPageIndex);
|
|
if (m_pPage)
|
|
{
|
|
m_pPage->SetWidth(MM_2_PT(m_dPageWidth));
|
|
m_pPage->SetHeight(MM_2_PT(m_dPageHeight));
|
|
Reset();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
bool CPdfWriter::EditClose()
|
|
{
|
|
if (!IsValid())
|
|
return false;
|
|
m_oCommandManager.Flush();
|
|
|
|
unsigned int nPagesCount = m_pDocument->GetPagesCount();
|
|
for (int nIndex = 0, nCount = m_vDestinations.size(); nIndex < nCount; ++nIndex)
|
|
{
|
|
TDestinationInfo& oInfo = m_vDestinations.at(nIndex);
|
|
if (nPagesCount > oInfo.unDestPage)
|
|
{
|
|
AddLink(oInfo.pPage, oInfo.dX, oInfo.dY, oInfo.dW, oInfo.dH, oInfo.dDestX, oInfo.dDestY, oInfo.unDestPage);
|
|
m_vDestinations.erase(m_vDestinations.begin() + nIndex);
|
|
nIndex--;
|
|
nCount--;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
void CPdfWriter::PageRotate(int nRotate)
|
|
{
|
|
if (m_pPage)
|
|
m_pPage->SetRotate(nRotate);
|
|
}
|
|
void CPdfWriter::Sign(const double& dX, const double& dY, const double& dW, const double& dH, const std::wstring& wsPicturePath, ICertificate* pCertificate)
|
|
{
|
|
PdfWriter::CImageDict* pImage = NULL;
|
|
if (!wsPicturePath.empty())
|
|
{
|
|
Aggplus::CImage oImage(wsPicturePath);
|
|
pImage = LoadImage(&oImage, 255);
|
|
}
|
|
|
|
m_pDocument->Sign(PdfWriter::TRect(MM_2_PT(dX), m_pPage->GetHeight() - MM_2_PT(dY), MM_2_PT(dX + dW), m_pPage->GetHeight() - MM_2_PT(dY + dH)),
|
|
pImage, pCertificate);
|
|
}
|
|
//----------------------------------------------------------------------------------------
|
|
// Внутренние функции
|
|
//----------------------------------------------------------------------------------------
|
|
bool CPdfWriter::SkipRedact(const double& dX, const double& dY, const double& dW, const double& dH)
|
|
{
|
|
if (m_arrRedact.empty())
|
|
return false;
|
|
double dXmin = MM_2_PT(dX), dYmin = MM_2_PT(m_dPageHeight - dY - dH), dXmax = MM_2_PT(dX + dW), dYmax = MM_2_PT(m_dPageHeight - dY);
|
|
CTransform& t = m_oTransform;
|
|
CTransform oT;
|
|
oT.Set(t.m11, -t.m12, -t.m21, t.m22, MM_2_PT(t.dx + t.m21 * m_dPageHeight), MM_2_PT(m_dPageHeight - m_dPageHeight * t.m22 - t.dy));
|
|
|
|
double dX1, dY1, dX2, dY2, dX3, dY3, dX4, dY4;
|
|
dX1 = dXmin, dY1 = dYmin;
|
|
dX2 = dXmin, dY2 = dYmax;
|
|
dX3 = dXmax, dY3 = dYmax;
|
|
dX4 = dXmax, dY4 = dYmin;
|
|
|
|
oT.Transform(dX1, dY1, &dX1, &dY1);
|
|
oT.Transform(dX2, dY2, &dX2, &dY2);
|
|
oT.Transform(dX3, dY3, &dX3, &dY3);
|
|
oT.Transform(dX4, dY4, &dX4, &dY4);
|
|
|
|
std::vector<PdfWriter::CPoint> poly2 =
|
|
{
|
|
PdfWriter::CPoint(dX1, dY1),
|
|
PdfWriter::CPoint(dX2, dY2),
|
|
PdfWriter::CPoint(dX3, dY3),
|
|
PdfWriter::CPoint(dX4, dY4)
|
|
};
|
|
for (int i = 0; i < m_arrRedact.size(); i += 8)
|
|
{
|
|
std::vector<PdfWriter::CPoint> poly1 =
|
|
{
|
|
PdfWriter::CPoint(m_arrRedact[i + 0], m_arrRedact[i + 1]),
|
|
PdfWriter::CPoint(m_arrRedact[i + 2], m_arrRedact[i + 3]),
|
|
PdfWriter::CPoint(m_arrRedact[i + 4], m_arrRedact[i + 5]),
|
|
PdfWriter::CPoint(m_arrRedact[i + 6], m_arrRedact[i + 7])
|
|
};
|
|
|
|
if (PdfWriter::SAT(poly1, poly2))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
bool CPdfWriter::SkipRedact(const double& dX, const double& dY)
|
|
{
|
|
if (m_arrRedact.empty())
|
|
return false;
|
|
double dXc = MM_2_PT(dX), dYc = MM_2_PT(m_dPageHeight - dY);
|
|
CTransform& t = m_oTransform;
|
|
CTransform oT;
|
|
oT.Set(t.m11, -t.m12, -t.m21, t.m22, MM_2_PT(t.dx + t.m21 * m_dPageHeight), MM_2_PT(m_dPageHeight - m_dPageHeight * t.m22 - t.dy));
|
|
oT.Transform(dXc, dYc, &dXc, &dYc);
|
|
for (int i = 0; i < m_arrRedact.size(); i += 8)
|
|
{
|
|
double x1 = m_arrRedact[i + 0];
|
|
double y1 = m_arrRedact[i + 1];
|
|
double x2 = m_arrRedact[i + 2];
|
|
double y2 = m_arrRedact[i + 3];
|
|
double x3 = m_arrRedact[i + 4];
|
|
double y3 = m_arrRedact[i + 5];
|
|
double x4 = m_arrRedact[i + 6];
|
|
double y4 = m_arrRedact[i + 7];
|
|
|
|
if (PdfWriter::isPointInQuad(dXc, dYc, x1, y1, x2, y2, x3, y3, x4, y4))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
PdfWriter::CImageDict* CPdfWriter::LoadImage(Aggplus::CImage* pImage, BYTE nAlpha)
|
|
{
|
|
TColor oColor;
|
|
int nImageW = abs((int)pImage->GetWidth());
|
|
int nImageH = abs((int)pImage->GetHeight());
|
|
BYTE* pData = pImage->GetData();
|
|
int nStride = 4 * nImageW;
|
|
|
|
// Картинки совсем маленьких размеров нельзя делать Jpeg2000
|
|
bool bJpeg = false;
|
|
if (nImageH < 100 || nImageW < 100 || m_pDocument->IsPDFA())
|
|
bJpeg = true;
|
|
|
|
if (nImageH <= 0 || nImageW <= 0)
|
|
return NULL;
|
|
|
|
// TODO: Пока не разберемся как в CxImage управлять параметрами кодирования нельзя писать в Jpeg2000,
|
|
// т.к. файлы получаются гораздо больше и конвертация идет намного дольше.
|
|
bJpeg = true;
|
|
|
|
// Пробегаемся по картинке и определяем есть ли у нас альфа-канал
|
|
bool bAlpha = false;
|
|
|
|
CBgraFrame oFrame;
|
|
/*
|
|
if (m_pDocument->IsPDFA())
|
|
{
|
|
BYTE* pCopyImage = new BYTE[4 * nImageW * nImageH];
|
|
if (!pCopyImage)
|
|
return NULL;
|
|
|
|
::memcpy(pCopyImage, pData, 4 * nImageW * nImageH);
|
|
|
|
BYTE* pDataMem = pCopyImage;
|
|
for (int nIndex = 0, nSize = nImageW * nImageH; nIndex < nSize; nIndex++)
|
|
{
|
|
if (pDataMem[3] < 32)
|
|
{
|
|
pDataMem[0] = 255;
|
|
pDataMem[1] = 255;
|
|
pDataMem[2] = 255;
|
|
}
|
|
pDataMem += 4;
|
|
}
|
|
|
|
oFrame.put_Width(nImageW);
|
|
oFrame.put_Height(nImageH);
|
|
oFrame.put_Data(pCopyImage);// +4 * (nImageH - 1) * nImageW);
|
|
oFrame.put_Stride(-4* nImageW);
|
|
}
|
|
else
|
|
*/
|
|
{
|
|
BYTE* pDataMem = pData;
|
|
for (int nIndex = 0, nSize = nImageW * nImageH; nIndex < nSize; nIndex++)
|
|
{
|
|
// making full-transparent pixels white
|
|
if (pDataMem[3] == 0)
|
|
{
|
|
pDataMem[0] = 255;
|
|
pDataMem[1] = 255;
|
|
pDataMem[2] = 255;
|
|
}
|
|
|
|
if (!bAlpha && (pDataMem[3] < 255))
|
|
{
|
|
bAlpha = true;
|
|
}
|
|
|
|
pDataMem += 4;
|
|
}
|
|
oFrame.FromImage(pImage);
|
|
}
|
|
|
|
oFrame.SetJpegQuality(85.0);
|
|
|
|
BYTE* pBuffer = NULL;
|
|
int nBufferSize = 0;
|
|
if (!oFrame.Encode(pBuffer, nBufferSize, bJpeg ? _CXIMAGE_FORMAT_JPG : _CXIMAGE_FORMAT_JP2))
|
|
return NULL;
|
|
|
|
if (!pBuffer || !nBufferSize)
|
|
return NULL;
|
|
|
|
PdfWriter::CImageDict* pPdfImage = m_pDocument->CreateImage();
|
|
if (bAlpha || nAlpha < 255)
|
|
pPdfImage->LoadSMask(pData, nImageW, nImageH, nAlpha, (pImage->GetStride() >= 0) ? false : true);
|
|
|
|
if (bJpeg)
|
|
pPdfImage->LoadJpeg(pBuffer, nBufferSize, nImageW, nImageH);
|
|
else
|
|
pPdfImage->LoadJpx(pBuffer, nBufferSize, nImageW, nImageH);
|
|
|
|
free(pBuffer);
|
|
|
|
return pPdfImage;
|
|
}
|
|
PdfWriter::CImageDict* CPdfWriter::DrawImage(Aggplus::CImage* pImage, const double& dX, const double& dY, const double& dW, const double& dH, const BYTE& nAlpha)
|
|
{
|
|
PdfWriter::CImageDict* pPdfImage = LoadImage(pImage, nAlpha);
|
|
if (!pPdfImage)
|
|
return NULL;
|
|
|
|
m_pPage->GrSave();
|
|
UpdateTransform();
|
|
m_pPage->DrawImage(pPdfImage, MM_2_PT(dX), MM_2_PT(m_dPageHeight - dY - dH), MM_2_PT(dW), MM_2_PT(dH));
|
|
m_pPage->GrRestore();
|
|
|
|
return pPdfImage;
|
|
}
|
|
bool CPdfWriter::DrawText(unsigned char* pCodes, const unsigned int& unLen, const double& dX, const double& dY, const std::string& sPUA)
|
|
{
|
|
if (!pCodes || !unLen)
|
|
return false;
|
|
|
|
// TODO должна быть проверка центрального положения, а не точки начала
|
|
// TODO Сюда приходит много символов за раз, и нужно отрисовать только те, что вне областей редакта
|
|
if (SkipRedact(dX, dY))
|
|
return true;
|
|
|
|
CTransform& t = m_oTransform;
|
|
m_oCommandManager.SetTransform(t.m11, -t.m12, -t.m21, t.m22, MM_2_PT(t.dx + t.m21 * m_dPageHeight), MM_2_PT(m_dPageHeight - m_dPageHeight * t.m22 - t.dy));
|
|
|
|
CRendererTextCommand* pText = m_oCommandManager.AddText(pCodes, unLen, MM_2_PT(dX), MM_2_PT(m_dPageHeight - dY));
|
|
PdfWriter::CFontDict* pFont = m_pFont;
|
|
if (m_pFont14)
|
|
pFont = m_pFont14;
|
|
pText->SetFont(pFont);
|
|
pText->SetSize(m_oFont.GetSize());
|
|
pText->SetColor(m_oBrush.GetColor1());
|
|
pText->SetAlpha((BYTE)m_oBrush.GetAlpha1());
|
|
pText->SetCharSpace(MM_2_PT(m_oFont.GetCharSpace()));
|
|
pText->SetNeedDoBold(m_oFont.IsNeedDoBold());
|
|
pText->SetNeedDoItalic(m_oFont.IsNeedDoItalic());
|
|
pText->SetPUA(sPUA);
|
|
|
|
return true;
|
|
}
|
|
bool CPdfWriter::DrawTextToRenderer(const unsigned int* unGid, const unsigned int& unLen, const double& dX, const double& dY, const std::wstring& wsUnicodeText)
|
|
{
|
|
if (m_bSplit)
|
|
return false;
|
|
// TODO должна быть проверка центрального положения, а не точки начала
|
|
// TODO Сюда приходит много символов за раз, и нужно отрисовать только те, что вне областей редакта
|
|
if (SkipRedact(dX, dY))
|
|
return true;
|
|
// TODO pdf позволяет создание своего шрифта, но не следует это использовать для воссоздания шрифта запрещенного для редактирования или встраивания
|
|
Aggplus::CGraphicsPathSimpleConverter simplifier;
|
|
simplifier.SetRenderer(m_pRenderer);
|
|
m_pFontManager->LoadFontByName(m_oFont.GetName(), m_oFont.GetSize(), (int)m_oFont.GetStyle(), 72.0, 72.0);
|
|
PathCommandEnd();
|
|
if (simplifier.PathCommandText2(wsUnicodeText, (const int*)unGid, unLen, m_pFontManager, dX, dY, 0, 0))
|
|
{
|
|
DrawPath(NULL, L"", c_nWindingFillMode, true);
|
|
PathCommandEnd();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
bool CPdfWriter::PathCommandDrawText(unsigned int* pUnicodes, unsigned int unLen, const double& dX, const double& dY, const unsigned int* pGids)
|
|
{
|
|
// TODO должна быть проверка центрального положения, а не точки начала
|
|
// TODO Сюда приходит много символов за раз, и нужно отрисовать только те, что вне областей редакта
|
|
if (SkipRedact(dX, dY))
|
|
return true;
|
|
|
|
unsigned char* pCodes = EncodeString(pUnicodes, unLen, pGids);
|
|
if (!pCodes)
|
|
return false;
|
|
|
|
m_oPath.AddText(m_pFont, pCodes, unLen * 2, MM_2_PT(dX), MM_2_PT(m_dPageHeight - dY), m_oFont.GetSize(), MM_2_PT(m_oFont.GetCharSpace()));
|
|
return true;
|
|
}
|
|
int CPdfWriter::IsEmbeddedBase14(const std::wstring& wsName)
|
|
{
|
|
if (wsName.find(L"Embedded: ") != 0)
|
|
return -1;
|
|
std::wstring sSub = wsName.substr(10);
|
|
if (sSub == L"Helvetica")
|
|
return 0;
|
|
if (sSub == L"Helvetica-Bold")
|
|
return 1;
|
|
if (sSub == L"Helvetica-Oblique")
|
|
return 2;
|
|
if (sSub == L"Helvetice-BoldOblique")
|
|
return 3;
|
|
if (sSub == L"Courier")
|
|
return 4;
|
|
if (sSub == L"Courier-Bold")
|
|
return 5;
|
|
if (sSub == L"Courier-Oblique")
|
|
return 6;
|
|
if (sSub == L"Courier-BoldOblique")
|
|
return 7;
|
|
if (sSub == L"Times" || sSub == L"Times-Roman")
|
|
return 8;
|
|
if (sSub == L"Times-Bold")
|
|
return 9;
|
|
if (sSub == L"Times-Oblique")
|
|
return 10;
|
|
if (sSub == L"Times-BoldOblique")
|
|
return 11;
|
|
if (sSub == L"Symbol")
|
|
return 12;
|
|
if (sSub == L"ZapfDingbats")
|
|
return 13;
|
|
return -1;
|
|
}
|
|
bool CPdfWriter::GetBaseFont14(const std::wstring& wsFontName, int nBase14)
|
|
{
|
|
std::wstring wsFontPath = m_oFont.GetPath();
|
|
LONG lFaceIndex = m_oFont.GetFaceIndex();
|
|
if (!FindFontPath(wsFontName, m_oFont.IsBold(), m_oFont.IsItalic(), wsFontPath, lFaceIndex))
|
|
{
|
|
std::wstring sSub = wsFontName.substr(10);
|
|
const BYTE* pData14 = NULL;
|
|
unsigned int nSize14 = 0;
|
|
PdfReader::GetBaseFont(sSub, pData14, nSize14);
|
|
NSFonts::IFontsMemoryStorage* pMemoryStorage = NSFonts::NSApplicationFontStream::GetGlobalMemoryStorage();
|
|
if (pMemoryStorage)
|
|
{
|
|
if (!pMemoryStorage->Get(sSub))
|
|
pMemoryStorage->Add(sSub, (BYTE*)pData14, nSize14);
|
|
AddFont(wsFontName, false, false, sSub, 0);
|
|
}
|
|
else
|
|
{
|
|
std::wstring wsTempFileName = m_wsTempDirectory + L"/" + sSub + L".base";
|
|
if (NSFile::CFileBinary::Exists(wsTempFileName))
|
|
wsFontPath = wsTempFileName;
|
|
else
|
|
{
|
|
NSFile::CFileBinary oFile;
|
|
if (oFile.CreateFileW(wsTempFileName))
|
|
{
|
|
oFile.WriteFile((BYTE*)pData14, nSize14);
|
|
wsFontPath = wsTempFileName;
|
|
}
|
|
oFile.CloseFile();
|
|
}
|
|
AddFont(wsFontName, false, false, wsFontPath, 0);
|
|
}
|
|
if (!FindFontPath(wsFontName, m_oFont.IsBold(), m_oFont.IsItalic(), wsFontPath, lFaceIndex))
|
|
return false;
|
|
}
|
|
if (m_bSplit)
|
|
return false;
|
|
if (!m_pFontManager->LoadFontFromFile(wsFontPath, lFaceIndex, m_oFont.GetSize(), 72, 72))
|
|
return false;
|
|
PdfWriter::EStandard14Fonts nType = (PdfWriter::EStandard14Fonts)nBase14;
|
|
m_pFont14 = m_pDocument->CreateFont14(wsFontPath, lFaceIndex, nType);
|
|
return !!m_pFont14;
|
|
}
|
|
bool CPdfWriter::UpdateFont()
|
|
{
|
|
m_bNeedUpdateTextFont = false;
|
|
m_pFont14 = NULL;
|
|
|
|
std::wstring wsFontPath = m_oFont.GetPath();
|
|
LONG lFaceIndex = m_oFont.GetFaceIndex();
|
|
if (L"" == wsFontPath)
|
|
{
|
|
std::wstring wsFontName = m_oFont.GetName();
|
|
int nBase14 = IsEmbeddedBase14(wsFontName);
|
|
if (nBase14 >= 0 && GetBaseFont14(wsFontName, nBase14))
|
|
{
|
|
m_pFont = NULL;
|
|
return true;
|
|
}
|
|
if (!GetFontPath(wsFontName, m_oFont.IsBold(), m_oFont.IsItalic(), wsFontPath, lFaceIndex))
|
|
{
|
|
m_pFont = NULL;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
m_pFont = NULL;
|
|
m_oFont.SetNeedDoBold(false);
|
|
m_oFont.SetNeedDoItalic(false);
|
|
|
|
if (L"" != wsFontPath)
|
|
{
|
|
m_pFont = GetFont(wsFontPath, lFaceIndex);
|
|
if (m_pFont)
|
|
{
|
|
if (m_oFont.IsItalic() && !m_pFont->IsItalic())
|
|
m_oFont.SetNeedDoItalic(true);
|
|
|
|
if (m_oFont.IsBold() && !m_pFont->IsBold())
|
|
m_oFont.SetNeedDoBold(true);
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
void CPdfWriter::AddFont(const std::wstring& wsFontName, const bool& bBold, const bool& bItalic, const std::wstring& wsFontPath, const LONG& lFaceIndex)
|
|
{
|
|
std::wstring _wsFontPath;
|
|
LONG _lFaceIndex;
|
|
if (FindFontPath(wsFontName, bBold, bItalic, _wsFontPath, _lFaceIndex))
|
|
return;
|
|
m_vFonts.push_back(TFontInfo(wsFontName, bBold, bItalic, wsFontPath, lFaceIndex));
|
|
}
|
|
bool CPdfWriter::FindFontPath(const std::wstring& wsFontName, const bool& bBold, const bool& bItalic, std::wstring& wsFontPath, LONG& lFaceIndex)
|
|
{
|
|
for (int nIndex = 0, nCount = m_vFonts.size(); nIndex < nCount; nIndex++)
|
|
{
|
|
TFontInfo& oInfo = m_vFonts.at(nIndex);
|
|
if (oInfo.wsFontName == wsFontName && oInfo.bBold == bBold && oInfo.bItalic == bItalic)
|
|
{
|
|
wsFontPath = oInfo.wsFontPath;
|
|
lFaceIndex = oInfo.lFaceIndex;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
bool CPdfWriter::GetFontPath(const std::wstring &wsFontName, const bool &bBold, const bool &bItalic, std::wstring& wsFontPath, LONG& lFaceIndex)
|
|
{
|
|
bool bFind = FindFontPath(wsFontName, bBold, bItalic, wsFontPath, lFaceIndex);
|
|
|
|
if (!bFind)
|
|
{
|
|
if (m_bSplit)
|
|
return false;
|
|
|
|
NSFonts::CFontSelectFormat oFontSelect;
|
|
oFontSelect.wsName = new std::wstring(wsFontName);
|
|
oFontSelect.bItalic = new INT(bItalic ? 1 : 0);
|
|
oFontSelect.bBold = new INT(bBold ? 1 : 0);
|
|
NSFonts::CFontInfo* pFontInfo = m_pFontManager->GetFontInfoByParams(oFontSelect, false);
|
|
if (!NSFonts::CFontInfo::CanEmbedForPreviewAndPrint(pFontInfo->m_usType))
|
|
{
|
|
return false;
|
|
|
|
oFontSelect.Fill(pFontInfo);
|
|
if (NULL != oFontSelect.usType)
|
|
*oFontSelect.usType = NSFONTS_EMBEDDING_RIGHTS_PRINT_AND_PREVIEW;
|
|
else
|
|
oFontSelect.usType = new USHORT(NSFONTS_EMBEDDING_RIGHTS_PRINT_AND_PREVIEW);
|
|
|
|
pFontInfo = m_pFontManager->GetFontInfoByParams(oFontSelect, false);
|
|
}
|
|
|
|
wsFontPath = pFontInfo->m_wsFontPath;
|
|
lFaceIndex = pFontInfo->m_lIndex;
|
|
|
|
m_vFonts.push_back(TFontInfo(wsFontName, bBold, bItalic, wsFontPath, lFaceIndex));
|
|
}
|
|
return true;
|
|
}
|
|
PdfWriter::CFontCidTrueType* CPdfWriter::GetFont(const std::wstring& wsFontPath, const LONG& lFaceIndex)
|
|
{
|
|
PdfWriter::CFontCidTrueType* pFont = NULL;
|
|
if (L"" != wsFontPath)
|
|
{
|
|
pFont = m_pDocument->FindCidTrueTypeFont(wsFontPath, lFaceIndex);
|
|
if (pFont)
|
|
return pFont;
|
|
|
|
if (m_bSplit)
|
|
return pFont;
|
|
|
|
// TODO: Пока мы здесь предполагаем, что шрифты только либо TrueType, либо OpenType
|
|
if (!m_pFontManager->LoadFontFromFile(wsFontPath, lFaceIndex, 10, 72, 72))
|
|
{
|
|
std::wcout << L"PDF Writer: Can't load fontfile " << wsFontPath.c_str() << "\n";
|
|
return NULL;
|
|
}
|
|
|
|
std::wstring wsFontType = m_pFontManager->GetFontType();
|
|
if (L"TrueType" == wsFontType || L"OpenType" == wsFontType || L"CFF" == wsFontType)
|
|
pFont = m_pDocument->CreateCidTrueTypeFont(wsFontPath, lFaceIndex);
|
|
}
|
|
|
|
return pFont;
|
|
}
|
|
PdfWriter::CFontCidTrueType* CPdfWriter::GetFont(const std::wstring& wsFontName, const bool& bBold, const bool& bItalic)
|
|
{
|
|
std::wstring wsFontPath;
|
|
LONG lFaceIndex;
|
|
|
|
GetFontPath(wsFontName, bBold, bItalic, wsFontPath, lFaceIndex);
|
|
return GetFont(wsFontPath, lFaceIndex);
|
|
}
|
|
bool CPdfWriter::GetFontData(NSFonts::IApplicationFonts* pAppFonts, const std::wstring& wsValue, PdfWriter::CFontCidTrueType* pFont, bool bBold, bool bItalic,
|
|
unsigned int*& pUnicodes, unsigned int& unLen, unsigned short*& pCodes, PdfWriter::CFontCidTrueType**& ppFonts)
|
|
{
|
|
pUnicodes = NSStringExt::CConverter::GetUtf32FromUnicode(wsValue, unLen);
|
|
if (!pUnicodes)
|
|
return false;
|
|
|
|
pCodes = new unsigned short[unLen];
|
|
if (!pCodes)
|
|
{
|
|
RELEASEARRAYOBJECTS(pUnicodes);
|
|
return false;
|
|
}
|
|
|
|
ppFonts = new PdfWriter::CFontCidTrueType*[unLen];
|
|
if (!ppFonts)
|
|
{
|
|
RELEASEARRAYOBJECTS(pUnicodes);
|
|
RELEASEARRAYOBJECTS(pCodes);
|
|
return false;
|
|
}
|
|
|
|
for (unsigned int unIndex = 0; unIndex < unLen; ++unIndex)
|
|
{
|
|
unsigned int unUnicode = pUnicodes[unIndex];
|
|
|
|
if (!pFont->HaveChar(unUnicode))
|
|
{
|
|
std::wstring wsFontFamily = pAppFonts->GetFontBySymbol(unUnicode);
|
|
PdfWriter::CFontCidTrueType* pTempFont = GetFont(wsFontFamily, bBold, bItalic);
|
|
if (pTempFont)
|
|
{
|
|
pCodes[unIndex] = pTempFont->EncodeUnicode(unUnicode);
|
|
ppFonts[unIndex] = pTempFont;
|
|
continue;
|
|
}
|
|
}
|
|
pCodes[unIndex] = pFont->EncodeUnicode(unUnicode);
|
|
ppFonts[unIndex] = pFont;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
void CPdfWriter::UpdateTransform()
|
|
{
|
|
CTransform& t = m_oTransform;
|
|
m_pPage->SetTransform(t.m11, -t.m12, -t.m21, t.m22, MM_2_PT(t.dx + t.m21 * m_dPageHeight), MM_2_PT(m_dPageHeight - m_dPageHeight * t.m22 - t.dy));
|
|
}
|
|
void CPdfWriter::UpdatePen()
|
|
{
|
|
TColor oColor = m_oPen.GetTColor();
|
|
m_pPage->SetStrokeColor(oColor.r, oColor.g, oColor.b);
|
|
m_pPage->SetStrokeAlpha((unsigned char)m_oPen.GetAlpha());
|
|
m_pPage->SetLineWidth(MM_2_PT(m_oPen.GetSize()));
|
|
|
|
LONG lDashCount = 0;
|
|
double* pDashPattern = NULL;
|
|
|
|
LONG lDashStyle = m_oPen.GetDashStyle();
|
|
if (Aggplus::DashStyleSolid == lDashStyle)
|
|
{
|
|
// Ничего не делаем
|
|
}
|
|
else if (Aggplus::DashStyleCustom == lDashStyle)
|
|
{
|
|
double *pDashPatternMM = m_oPen.GetDashPattern(lDashCount);
|
|
if (pDashPatternMM && lDashCount)
|
|
{
|
|
pDashPattern = new double[lDashCount];
|
|
if (pDashPattern)
|
|
{
|
|
for (LONG lIndex = 0; lIndex < lDashCount; lIndex++)
|
|
{
|
|
pDashPattern[lIndex] = MM_2_PT(pDashPatternMM[lIndex]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// TODO: Реализовать другие типы пунктирных линий
|
|
}
|
|
|
|
if (pDashPattern && lDashCount)
|
|
{
|
|
m_pPage->SetDash(pDashPattern, lDashCount, MM_2_PT(m_oPen.GetDashOffset()));
|
|
delete[] pDashPattern;
|
|
}
|
|
|
|
LONG lCapStyle = m_oPen.GetStartCapStyle();
|
|
if (Aggplus::LineCapRound == lCapStyle)
|
|
m_pPage->SetLineCap(PdfWriter::linecap_Round);
|
|
else if (Aggplus::LineCapSquare == lCapStyle)
|
|
m_pPage->SetLineCap(PdfWriter::linecap_ProjectingSquare);
|
|
else
|
|
m_pPage->SetLineCap(PdfWriter::linecap_Butt);
|
|
|
|
LONG lJoinStyle = m_oPen.GetJoinStyle();
|
|
if (Aggplus::LineJoinBevel == lJoinStyle)
|
|
m_pPage->SetLineJoin(PdfWriter::linejoin_Bevel);
|
|
else if (Aggplus::LineJoinMiter == lJoinStyle)
|
|
{
|
|
m_pPage->SetLineJoin(PdfWriter::linejoin_Miter);
|
|
m_pPage->SetMiterLimit(MM_2_PT(m_oPen.GetMiter()));
|
|
}
|
|
else
|
|
m_pPage->SetLineJoin(PdfWriter::linejoin_Round);
|
|
}
|
|
void CPdfWriter::UpdateBrush(NSFonts::IApplicationFonts* pAppFonts, const std::wstring& wsTempDirectory)
|
|
{
|
|
m_pShading = NULL;
|
|
m_pShadingExtGrState = NULL;
|
|
|
|
LONG lBrushType = m_oBrush.GetType();
|
|
if (c_BrushTypeTexture == lBrushType)
|
|
{
|
|
std::wstring wsTexturePath = m_oBrush.GetTexturePath();
|
|
BYTE nAlpha = m_oBrush.GetTextureAlpha();
|
|
CImageFileFormatChecker oImageFormat(wsTexturePath);
|
|
|
|
PdfWriter::CImageDict* pImage = NULL;
|
|
int nImageW = 0;
|
|
int nImageH = 0;
|
|
bool bHasImage = false;
|
|
if (m_pDocument->HasImage(wsTexturePath, nAlpha))
|
|
{
|
|
pImage = m_pDocument->GetImage(wsTexturePath, nAlpha);
|
|
nImageH = pImage->GetHeight();
|
|
nImageW = pImage->GetWidth();
|
|
bHasImage = true;
|
|
}
|
|
else if (_CXIMAGE_FORMAT_JPG == oImageFormat.eFileType || _CXIMAGE_FORMAT_JP2 == oImageFormat.eFileType)
|
|
{
|
|
pImage = m_pDocument->CreateImage();
|
|
CBgraFrame oFrame;
|
|
oFrame.OpenFile(wsTexturePath);
|
|
nImageH = oFrame.get_Height();
|
|
nImageW = oFrame.get_Width();
|
|
|
|
if (pImage)
|
|
{
|
|
if (_CXIMAGE_FORMAT_JPG == oImageFormat.eFileType)
|
|
pImage->LoadJpeg(wsTexturePath.c_str(), nImageW, nImageH, oFrame.IsGrayScale());
|
|
else
|
|
pImage->LoadJpx(wsTexturePath.c_str(), nImageW, nImageH);
|
|
|
|
m_pDocument->AddImage(wsTexturePath, nAlpha, pImage);
|
|
}
|
|
}
|
|
else if (_CXIMAGE_FORMAT_WMF == oImageFormat.eFileType ||
|
|
_CXIMAGE_FORMAT_EMF == oImageFormat.eFileType ||
|
|
_CXIMAGE_FORMAT_SVM == oImageFormat.eFileType ||
|
|
_CXIMAGE_FORMAT_SVG == oImageFormat.eFileType)
|
|
{
|
|
// TODO: Реализовать отрисовку метафайлов по-нормальному
|
|
MetaFile::IMetaFile* pMeta = MetaFile::Create(pAppFonts);
|
|
pMeta->LoadFromFile(wsTexturePath.c_str());
|
|
|
|
double dL, dR, dT, dB;
|
|
m_oPath.GetBounds(dL, dT, dR, dB);
|
|
|
|
double dW = 300.0 * (dR - dL) / 72;
|
|
if (dW < 0) dW = -dW;
|
|
double dH = 300.0 * (dB - dT) / 72;
|
|
if (dH < 0) dH = -dH;
|
|
|
|
if (dW < 1) dW = 1;
|
|
if (dH < 1) dH = 1;
|
|
|
|
double dMax = 2000;
|
|
double dMin = 10;
|
|
if (dW > dMax || dH > dMax)
|
|
{
|
|
double dMaxSrc = (dW > dH) ? dW : dH;
|
|
dW *= (dMax / dMaxSrc);
|
|
dH *= (dMax / dMaxSrc);
|
|
}
|
|
|
|
if (dW < dMin) dW = dMin;
|
|
if (dH < dMin) dH = dMin;
|
|
|
|
std::wstring wsTempFile = GetTempFile(wsTempDirectory);
|
|
pMeta->ConvertToRaster(wsTempFile.c_str(), _CXIMAGE_FORMAT_PNG, (int)dW, (int)dH);
|
|
|
|
RELEASEOBJECT(pMeta);
|
|
|
|
Aggplus::CImage oImage(wsTempFile);
|
|
nImageW = abs((int)oImage.GetWidth());
|
|
nImageH = abs((int)oImage.GetHeight());
|
|
pImage = LoadImage(&oImage, 255);
|
|
m_pDocument->AddImage(wsTexturePath, nAlpha, pImage);
|
|
}
|
|
else
|
|
{
|
|
Aggplus::CImage oImage(wsTexturePath);
|
|
nImageW = abs((int)oImage.GetWidth());
|
|
nImageH = abs((int)oImage.GetHeight());
|
|
pImage = LoadImage(&oImage, 255);
|
|
m_pDocument->AddImage(wsTexturePath, nAlpha, pImage);
|
|
}
|
|
|
|
if (pImage)
|
|
{
|
|
if (0xFF != nAlpha && !bHasImage)
|
|
pImage->AddTransparency(nAlpha);
|
|
|
|
LONG lTextureMode = m_oBrush.GetTextureMode();
|
|
|
|
double dW = 10;
|
|
double dH = 10;
|
|
|
|
double dL, dR, dT, dB;
|
|
CBrushState::TBrushRect& oRect = m_oBrush.GetBrushRect();
|
|
if (!oRect.bUse)
|
|
{
|
|
m_oPath.GetBounds(dL, dT, dR, dB);
|
|
}
|
|
else
|
|
{
|
|
dL = MM_2_PT(oRect.dLeft);
|
|
dB = MM_2_PT(m_dPageHeight - oRect.dTop);
|
|
dR = MM_2_PT(oRect.dLeft + oRect.dWidth);
|
|
dT = MM_2_PT(m_dPageHeight - oRect.dTop - oRect.dHeight);
|
|
}
|
|
|
|
double dXStepSpacing = 0, dYStepSpacing = 0;
|
|
if (c_BrushTextureModeStretch == lTextureMode)
|
|
{
|
|
// Растягиваем картинку по размерам пата
|
|
dW = std::max(10.0, dR - dL);
|
|
dH = std::max(10.0, dB - dT);
|
|
|
|
// Чтобы избавиться от погрешностей из-за которых могут возникать полоски или обрезание картинки,
|
|
// удвоим расстрояние между соседними тайлами. Плохого тут нет, т.к. нам нужен всего 1 тайл
|
|
dXStepSpacing = dW;
|
|
dYStepSpacing = dH;
|
|
}
|
|
else
|
|
{
|
|
// Размеры картинки заданы в пикселях. Размеры тайла - это размеры картинки в пунктах.
|
|
dW = (double)nImageW * 72.0 / 96.0;
|
|
dH = (double)nImageH * 72.0 / 96.0;
|
|
|
|
dT = dB;
|
|
}
|
|
|
|
// Нам нужно, чтобы левый нижний угол границ нашего пата являлся точкой переноса для матрицы преобразования.
|
|
PdfWriter::CMatrix* pMatrix = m_pPage->GetTransform();
|
|
pMatrix->Apply(dL, dT);
|
|
PdfWriter::CMatrix oPatternMatrix = *pMatrix;
|
|
oPatternMatrix.x = dL;
|
|
oPatternMatrix.y = dT;
|
|
m_pPage->SetPatternColorSpace(m_pDocument->CreateImageTilePattern(dW, dH, pImage, &oPatternMatrix, PdfWriter::imagetilepatterntype_Default, dXStepSpacing, dYStepSpacing));
|
|
}
|
|
}
|
|
else if (c_BrushTypeHatch1 == lBrushType)
|
|
{
|
|
std::wstring wsHatchType = m_oBrush.GetTexturePath();
|
|
|
|
double dW = 8 * 72 / 96;
|
|
double dH = 8 * 72 / 96;
|
|
|
|
TColor oColor1 = m_oBrush.GetTColor1();
|
|
TColor oColor2 = m_oBrush.GetTColor2();
|
|
BYTE nAlpha1 = (BYTE)m_oBrush.GetAlpha1();
|
|
BYTE nAlpha2 = (BYTE)m_oBrush.GetAlpha2();
|
|
|
|
m_pPage->SetPatternColorSpace(m_pDocument->CreateHatchPattern(dW, dH, oColor1.r, oColor1.g, oColor1.b, nAlpha1, oColor2.r, oColor2.g, oColor2.b, nAlpha2, wsHatchType));
|
|
}
|
|
else if (c_BrushTypeRadialGradient == lBrushType || c_BrushTypeLinearGradient == lBrushType)
|
|
{
|
|
TColor* pGradientColors;
|
|
double* pPoints;
|
|
LONG lCount;
|
|
|
|
m_oBrush.GetGradientColors(pGradientColors, pPoints, lCount);
|
|
|
|
if (lCount > 0)
|
|
{
|
|
unsigned char* pColors = new unsigned char[3 * lCount];
|
|
unsigned char* pAlphas = new unsigned char[lCount];
|
|
if (pColors)
|
|
{
|
|
for (LONG lIndex = 0; lIndex < lCount; lIndex++)
|
|
{
|
|
pColors[3 * lIndex + 0] = pGradientColors[lIndex].r;
|
|
pColors[3 * lIndex + 1] = pGradientColors[lIndex].g;
|
|
pColors[3 * lIndex + 2] = pGradientColors[lIndex].b;
|
|
pAlphas[lIndex] = pGradientColors[lIndex].a;
|
|
}
|
|
|
|
if (c_BrushTypeLinearGradient == lBrushType)
|
|
{
|
|
double dX0, dY0, dX1, dY1;
|
|
m_oBrush.GetLinearGradientPattern(dX0, dY0, dX1, dY1);
|
|
m_pShading = m_pDocument->CreateAxialShading(m_pPage, MM_2_PT(dX0), MM_2_PT(m_dPageHeight - dY0), MM_2_PT(dX1), MM_2_PT(m_dPageHeight - dY1), pColors, pAlphas, pPoints, lCount, m_pShadingExtGrState);
|
|
}
|
|
else //if (c_BrushTypeRadialGradient == lBrushType)
|
|
{
|
|
double dX0, dY0, dR0, dX1, dY1, dR1;
|
|
m_oBrush.GetRadialGradientPattern(dX0, dY0, dR0, dX1, dY1, dR1);
|
|
m_pShading = m_pDocument->CreateRadialShading(m_pPage, MM_2_PT(dX0), MM_2_PT(m_dPageHeight - dY0), MM_2_PT(dR0), MM_2_PT(dX1), MM_2_PT(m_dPageHeight - dY1), MM_2_PT(dR1), pColors, pAlphas, pPoints, lCount, m_pShadingExtGrState);
|
|
}
|
|
delete[] pColors;
|
|
delete[] pAlphas;
|
|
}
|
|
}
|
|
}
|
|
else// if (c_BrushTypeSolid == lBrushType)
|
|
{
|
|
TColor oColor1 = m_oBrush.GetTColor1();
|
|
m_pPage->SetFillColor(oColor1.r, oColor1.g, oColor1.b);
|
|
m_pPage->SetFillAlpha((unsigned char)m_oBrush.GetAlpha1());
|
|
}
|
|
}
|
|
void CPdfWriter::Reset()
|
|
{
|
|
m_oPen.Reset();
|
|
m_oBrush.Reset();
|
|
m_oFont.Reset();
|
|
m_oPath.Clear();
|
|
|
|
// clear font!!!
|
|
m_oFont.SetName(L"");
|
|
m_oFont.SetSize(-1);
|
|
m_oFont.SetStyle(1 << 5);
|
|
|
|
m_lClipDepth = 0;
|
|
}
|
|
|
|
void CPdfWriter::AddLink(PdfWriter::CPage* pPage, const double& dX, const double& dY, const double& dW, const double& dH, const double& dDestX, const double& dDestY, const unsigned int& unDestPage)
|
|
{
|
|
PdfWriter::CPage* pDestPage = m_pDocument->GetPage(unDestPage);
|
|
if (!pPage || !pDestPage)
|
|
return;
|
|
|
|
PdfWriter::CDestination* pDestination = m_pDocument->CreateDestination(pDestPage);
|
|
if (!pDestination)
|
|
return;
|
|
|
|
pDestination->SetXYZ(MM_2_PT(dDestX), pDestPage->GetHeight() - MM_2_PT(dDestY), 0);
|
|
PdfWriter::CAnnotation* pAnnot = m_pDocument->CreateLinkAnnot(PdfWriter::TRect(MM_2_PT(dX), pPage->GetHeight() - MM_2_PT(dY), MM_2_PT(dX + dW), pPage->GetHeight() - MM_2_PT(dY + dH)), pDestination);
|
|
if (pAnnot && pPage)
|
|
pPage->AddAnnotation(pAnnot);
|
|
pAnnot->SetBorder(0, 0, {});
|
|
}
|
|
bool CPdfWriter::IsValid()
|
|
{
|
|
return m_bValid;
|
|
}
|
|
bool CPdfWriter::IsPageValid()
|
|
{
|
|
if (!IsValid() || !m_pPage)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
void CPdfWriter::SetError()
|
|
{
|
|
m_bValid = false;
|
|
}
|
|
unsigned char* CPdfWriter::EncodeString(const unsigned int *pUnicodes, const unsigned int& unCount, const unsigned int *pGIDs)
|
|
{
|
|
if (m_bNeedUpdateTextFont)
|
|
{
|
|
if (!UpdateFont())
|
|
return NULL;
|
|
}
|
|
|
|
if (m_pFont14)
|
|
{
|
|
unsigned char* pCodes = new unsigned char[unCount * 2];
|
|
if (!pCodes)
|
|
return NULL;
|
|
|
|
for (unsigned int unIndex = 0; unIndex < unCount; unIndex++)
|
|
{
|
|
bool bNew = false;
|
|
if (pGIDs)
|
|
m_pFont14->EncodeUnicode(pGIDs[unIndex], pUnicodes[unIndex], bNew);
|
|
if (bNew)
|
|
{
|
|
TBBoxAdvance oBox = m_pFontManager->MeasureChar2(*pUnicodes);
|
|
double dWidth = oBox.fAdvanceX / m_oFont.GetSize() * 1000.0;
|
|
m_pFont14->AddWidth(dWidth);
|
|
}
|
|
|
|
pCodes[2 * unIndex + 0] = (pUnicodes[unIndex] >> 8) & 0xFF;
|
|
pCodes[2 * unIndex + 1] = pUnicodes[unIndex] & 0xFF;
|
|
}
|
|
return pCodes;
|
|
}
|
|
|
|
if (!m_pFont)
|
|
return NULL;
|
|
|
|
unsigned char* pCodes = new unsigned char[unCount * 2];
|
|
if (!pCodes)
|
|
return NULL;
|
|
|
|
for (unsigned int unIndex = 0; unIndex < unCount; unIndex++)
|
|
{
|
|
unsigned short ushCode;
|
|
if (pGIDs)
|
|
ushCode = m_pFont->EncodeGID(pGIDs[unIndex], &pUnicodes[unIndex], 1);
|
|
else
|
|
ushCode = m_pFont->EncodeUnicode(pUnicodes[unIndex]);
|
|
if (ushCode == 0)
|
|
{
|
|
RELEASEARRAYOBJECTS(pCodes);
|
|
return NULL;
|
|
}
|
|
|
|
pCodes[2 * unIndex + 0] = (ushCode >> 8) & 0xFF;
|
|
pCodes[2 * unIndex + 1] = ushCode & 0xFF;
|
|
}
|
|
|
|
return pCodes;
|
|
}
|
|
unsigned char* CPdfWriter::EncodeGID(const unsigned int& unGID, const unsigned int* pUnicodes, const unsigned int& unUnicodesCount)
|
|
{
|
|
if (m_bNeedUpdateTextFont)
|
|
{
|
|
if (!UpdateFont())
|
|
return NULL;
|
|
}
|
|
|
|
if (m_pFont14)
|
|
{
|
|
bool bNew = false;
|
|
m_pFont14->EncodeUnicode(unGID, *pUnicodes, bNew);
|
|
if (bNew)
|
|
{
|
|
TBBoxAdvance oBox = m_pFontManager->MeasureChar2(*pUnicodes);
|
|
double dWidth = oBox.fAdvanceX / m_oFont.GetSize() * 1000.0;
|
|
m_pFont14->AddWidth(dWidth);
|
|
}
|
|
unsigned char* pCodes = new unsigned char[2];
|
|
pCodes[0] = (*pUnicodes >> 8) & 0xFF;
|
|
pCodes[1] = *pUnicodes & 0xFF;
|
|
return pCodes;
|
|
}
|
|
|
|
if (!m_pFont)
|
|
return NULL;
|
|
|
|
unsigned char* pCodes = new unsigned char[2];
|
|
if (!pCodes)
|
|
return NULL;
|
|
|
|
unsigned short ushCode = m_pFont->EncodeGID(unGID, pUnicodes, unUnicodesCount);
|
|
if (ushCode == 0)
|
|
{
|
|
RELEASEARRAYOBJECTS(pCodes);
|
|
return NULL;
|
|
}
|
|
|
|
pCodes[0] = (ushCode >> 8) & 0xFF;
|
|
pCodes[1] = ushCode & 0xFF;
|
|
return pCodes;
|
|
}
|
|
std::wstring CPdfWriter::GetDownloadFile(const std::wstring& sUrl, const std::wstring& wsTempDirectory)
|
|
{
|
|
std::wstring::size_type n1 = sUrl.find(L"www.");
|
|
std::wstring::size_type n2 = sUrl.find(L"http://");
|
|
std::wstring::size_type n3 = sUrl.find(L"ftp://");
|
|
std::wstring::size_type n4 = sUrl.find(L"https://");
|
|
std::wstring::size_type n5 = sUrl.find(L"file://");
|
|
std::wstring::size_type nMax = 3;
|
|
|
|
bool bIsNeedDownload = false;
|
|
if (n1 != std::wstring::npos && n1 < nMax)
|
|
bIsNeedDownload = true;
|
|
else if (n2 != std::wstring::npos && n2 < nMax)
|
|
bIsNeedDownload = true;
|
|
else if (n3 != std::wstring::npos && n3 < nMax)
|
|
bIsNeedDownload = true;
|
|
else if (n4 != std::wstring::npos && n4 < nMax)
|
|
bIsNeedDownload = true;
|
|
else if (n5 != std::wstring::npos && n5 < nMax)
|
|
bIsNeedDownload = true;
|
|
|
|
if (!bIsNeedDownload)
|
|
return L"";
|
|
#ifndef BUILDING_WASM_MODULE
|
|
std::wstring sTempFile = GetTempFile(wsTempDirectory);
|
|
NSNetwork::NSFileTransport::CFileDownloader oDownloader(sUrl, false);
|
|
oDownloader.SetFilePath(sTempFile);
|
|
|
|
if (oDownloader.DownloadSync())
|
|
return sTempFile;
|
|
|
|
if (NSFile::CFileBinary::Exists(sTempFile))
|
|
NSFile::CFileBinary::Remove(sTempFile);
|
|
#endif
|
|
return L"";
|
|
}
|
|
PdfWriter::CAnnotAppearanceObject* CPdfWriter::DrawAP(PdfWriter::CAnnotation* pAnnot, BYTE* pRender, LONG nLenRender)
|
|
{
|
|
if (!pAnnot || !pRender)
|
|
return NULL;
|
|
|
|
PdfWriter::CPage* pCurPage = m_pPage;
|
|
PdfWriter::CPage* pFakePage = new PdfWriter::CPage(m_pDocument);
|
|
m_pPage = pFakePage;
|
|
m_pDocument->SetCurPage(pFakePage);
|
|
m_pPage->StartTransform(1, 0, 0, 1, -pAnnot->GetPageX(), pAnnot->GetPageY());
|
|
|
|
PdfWriter::CAnnotAppearanceObject* pAP = pAnnot->StartAP(0);
|
|
|
|
pFakePage->SetStream(pAP->GetStream());
|
|
pFakePage->Add("Resources", pAP->Get("Resources"));
|
|
|
|
IMetafileToRenderter* pCorrector = new IMetafileToRenderter(m_pRenderer);
|
|
NSOnlineOfficeBinToPdf::ConvertBufferToRenderer(pRender, nLenRender, pCorrector);
|
|
RELEASEOBJECT(pCorrector);
|
|
|
|
pAnnot->APFromFakePage();
|
|
|
|
m_pPage = pCurPage;
|
|
m_pDocument->SetCurPage(pCurPage);
|
|
RELEASEOBJECT(pFakePage);
|
|
|
|
return pAP;
|
|
}
|
|
void CPdfWriter::DrawWidgetAP(PdfWriter::CAnnotation* pA, BYTE* pRender, LONG nLenRender, int nRotate, bool bDiff)
|
|
{
|
|
if (!pA || !pRender)
|
|
return;
|
|
|
|
PdfWriter::CWidgetAnnotation* pAnnot = (PdfWriter::CWidgetAnnotation*)pA;
|
|
|
|
PdfWriter::CPage* pCurPage = m_pPage;
|
|
PdfWriter::CPage* pFakePage = new PdfWriter::CPage(m_pDocument);
|
|
m_pPage = pFakePage;
|
|
m_pDocument->SetCurPage(pFakePage);
|
|
double dY = pAnnot->GetRect().fBottom;
|
|
if (nRotate == 90 || nRotate == 270)
|
|
{
|
|
double dW = pAnnot->GetWidth();
|
|
double dH = pAnnot->GetHeight();
|
|
double dDiff = dW / 2.0 - dH / 2.0;
|
|
if (!bDiff)
|
|
dDiff *= 2.0;
|
|
dY -= dDiff;
|
|
}
|
|
m_oTransform.Set(1, 0, 0, 1, PT_2_MM(-pAnnot->GetPageX() - pAnnot->GetRect().fLeft), PT_2_MM(dY));
|
|
|
|
PdfWriter::CAnnotAppearanceObject* pAP = pAnnot->StartAP(nRotate);
|
|
|
|
pFakePage->SetStream(pAP->GetStream());
|
|
pFakePage->Add("Resources", pAP->Get("Resources"));
|
|
|
|
pFakePage->SetStrokeColor(0, 0, 0);
|
|
pFakePage->SetFillColor(0, 0, 0);
|
|
|
|
IMetafileToRenderter* pCorrector = new IMetafileToRenderter(m_pRenderer);
|
|
NSOnlineOfficeBinToPdf::ConvertBufferToRenderer(pRender, nLenRender, pCorrector);
|
|
RELEASEOBJECT(pCorrector);
|
|
|
|
m_oCommandManager.Flush();
|
|
pAP->EndDraw();
|
|
pFakePage->EndMarkedContent();
|
|
|
|
m_pPage = pCurPage;
|
|
m_pDocument->SetCurPage(pCurPage);
|
|
RELEASEOBJECT(pFakePage);
|
|
}
|
|
void CPdfWriter::DrawTextWidget(NSFonts::IApplicationFonts* pAppFonts, PdfWriter::CTextWidget* pTextWidget, const std::wstring& wsValue)
|
|
{
|
|
if (!pAppFonts || !pTextWidget)
|
|
return;
|
|
PdfWriter::CFontCidTrueType* pFont = pTextWidget->GetFont();
|
|
if (!pFont)
|
|
return;
|
|
PdfWriter::CFontTrueType* pFontTT = m_pDocument->CreateTrueTypeFont(pFont);
|
|
double dFontSize = pTextWidget->GetFontSize();
|
|
bool isBold = pTextWidget->GetFontIsBold();
|
|
bool isItalic = pTextWidget->GetFontIsItalic();
|
|
bool isComb = pTextWidget->IsCombFlag();
|
|
double dWidth = pTextWidget->GetWidth();
|
|
double dHeight = pTextWidget->GetHeight();
|
|
BYTE nAlign = pTextWidget->GetQ();
|
|
|
|
if (!pTextWidget->HaveBorder() && pTextWidget->HaveBC())
|
|
pTextWidget->SetBorder(0, 1, {});
|
|
double dShiftBorder = pTextWidget->GetBorderWidth();
|
|
PdfWriter::EBorderType nType = pTextWidget->GetBorderType();
|
|
if (nType == PdfWriter::EBorderType::Beveled || nType == PdfWriter::EBorderType::Inset)
|
|
dShiftBorder *= 2;
|
|
|
|
// Коды, шрифты, количество
|
|
unsigned int unLen = 0;
|
|
unsigned int* pUnicodes = NULL;
|
|
unsigned short* pCodes = NULL;
|
|
PdfWriter::CFontCidTrueType** ppFonts = NULL;
|
|
bool bFont = GetFontData(pAppFonts, wsValue, pFont, isBold, isItalic, pUnicodes, unLen, pCodes, ppFonts);
|
|
if (!bFont)
|
|
{
|
|
pTextWidget->SetEmptyAP();
|
|
RELEASEARRAYOBJECTS(pUnicodes);
|
|
RELEASEARRAYOBJECTS(pCodes);
|
|
RELEASEARRAYOBJECTS(ppFonts);
|
|
return;
|
|
}
|
|
|
|
if (!isComb && pTextWidget->IsMultiLine() && pFontTT)
|
|
{
|
|
unsigned short* pCodes2 = new unsigned short[unLen];
|
|
unsigned int* pWidths = new unsigned int[unLen];
|
|
|
|
unsigned short ushSpaceCode = 0xFFFF;
|
|
unsigned short ushNewLineCode = 0xFFFE;
|
|
for (unsigned int unIndex = 0; unIndex < unLen; ++unIndex)
|
|
{
|
|
unsigned short ushCode = 0;
|
|
if (0x0020 == pUnicodes[unIndex])
|
|
ushCode = ushSpaceCode;
|
|
else if (0x000D == pUnicodes[unIndex] || 0x000A == pUnicodes[unIndex])
|
|
ushCode = ushNewLineCode;
|
|
|
|
pCodes2[unIndex] = ushCode;
|
|
pWidths[unIndex] = ppFonts[unIndex]->GetWidth(pCodes[unIndex]);
|
|
}
|
|
|
|
m_oLinesManager.Init(pCodes2, pWidths, unLen, ushSpaceCode, ushNewLineCode, pFontTT->GetLineHeight(), pFontTT->GetAscent());
|
|
|
|
double dKoef = dFontSize / pFontTT->m_dUnitsPerEm;
|
|
double dLineHeight = (pFontTT->m_dAscent + std::abs(pFontTT->m_dDescent)) * dKoef;
|
|
|
|
m_oLinesManager.CalculateLines(dFontSize, dWidth - dShiftBorder * 4);
|
|
|
|
pTextWidget->StartAP(0);
|
|
|
|
unsigned int unLinesCount = m_oLinesManager.GetLinesCount();
|
|
double dLineShiftY = dHeight - dShiftBorder * 2 - dLineHeight;
|
|
for (unsigned int unIndex = 0; unIndex < unLinesCount; ++unIndex)
|
|
{
|
|
unsigned int unLineStart = m_oLinesManager.GetLineStartPos(unIndex);
|
|
double dLineShiftX = dShiftBorder * 2;
|
|
double dLineWidth = m_oLinesManager.GetLineWidth(unIndex, dFontSize);
|
|
if (2 == nAlign)
|
|
dLineShiftX = dWidth - dLineWidth - dShiftBorder * 2;
|
|
else if (1 == nAlign)
|
|
dLineShiftX = (dWidth - dLineWidth) / 2;
|
|
|
|
int nInLineCount = m_oLinesManager.GetLineEndPos(unIndex) - m_oLinesManager.GetLineStartPos(unIndex);
|
|
if (nInLineCount > 0)
|
|
pTextWidget->AddLineToAP(dLineShiftX, dLineShiftY, pCodes + unLineStart, nInLineCount, ppFonts + unLineStart, NULL);
|
|
|
|
dLineShiftY -= dLineHeight;
|
|
}
|
|
|
|
pTextWidget->EndAP();
|
|
|
|
m_oLinesManager.Clear();
|
|
|
|
RELEASEARRAYOBJECTS(pCodes2);
|
|
RELEASEARRAYOBJECTS(pWidths);
|
|
}
|
|
else
|
|
{
|
|
double* pShifts = NULL;
|
|
unsigned int unShiftsCount = 0;
|
|
double dShiftX = dShiftBorder * 2;
|
|
if (dShiftX == 0)
|
|
dShiftX = 2;
|
|
|
|
if (isComb)
|
|
{
|
|
unShiftsCount = unLen;
|
|
pShifts = new double[unShiftsCount];
|
|
if (pShifts && unShiftsCount)
|
|
{
|
|
dShiftX = 0;
|
|
unsigned int unCellsCount = std::max(unShiftsCount, pTextWidget->GetMaxLen());
|
|
double dPrevW = 0;
|
|
double dCellW = dWidth / unCellsCount;
|
|
|
|
if (1 == nAlign)
|
|
{
|
|
unsigned int unCells = (unCellsCount - unShiftsCount) / 2;
|
|
dPrevW = unCells * dCellW;
|
|
}
|
|
if (2 == nAlign)
|
|
dPrevW = (unCellsCount - unShiftsCount) * dCellW;
|
|
|
|
for (unsigned int unIndex = 0; unIndex < unShiftsCount; ++unIndex)
|
|
{
|
|
unsigned short ushCode = pCodes[unIndex];
|
|
double dGlyphWidth = ppFonts[unIndex]->GetGlyphWidth(ushCode) / 1000.0 * dFontSize;
|
|
double dTempShift = (dCellW - dGlyphWidth) / 2;
|
|
pShifts[unIndex] = dPrevW + dTempShift;
|
|
dPrevW = dCellW - dTempShift;
|
|
}
|
|
}
|
|
}
|
|
else if (1 == nAlign || 2 == nAlign)
|
|
{
|
|
double dLineWidth = 0;
|
|
for (unsigned int unIndex = 0; unIndex < unLen; ++unIndex)
|
|
{
|
|
unsigned short ushCode = pCodes[unIndex];
|
|
double dLetterWidth = ppFonts[unIndex]->GetWidth(ushCode) / 1000.0 * dFontSize;
|
|
dLineWidth += dLetterWidth;
|
|
}
|
|
|
|
if (2 == nAlign)
|
|
dShiftX = dWidth - dLineWidth - dShiftBorder * 2;
|
|
else if (1 == nAlign)
|
|
dShiftX = (dWidth - dLineWidth) / 2;
|
|
}
|
|
|
|
double dBaseLine = (dHeight - dFontSize) / 2.0 - dShiftBorder;
|
|
if (pFontTT)
|
|
{
|
|
double dKoef = dFontSize / pFontTT->m_dUnitsPerEm;
|
|
double dLineHeight = (pFontTT->m_dAscent + std::abs(pFontTT->m_dDescent)) * dKoef;;
|
|
dBaseLine = (dHeight - dLineHeight) / 2.0 + std::abs(pFontTT->m_dDescent * dKoef);
|
|
}
|
|
|
|
pTextWidget->SetAP(wsValue, pCodes, unLen, dShiftX, dBaseLine, ppFonts, pShifts);
|
|
RELEASEARRAYOBJECTS(pShifts);
|
|
}
|
|
|
|
RELEASEARRAYOBJECTS(pUnicodes);
|
|
RELEASEARRAYOBJECTS(pCodes);
|
|
RELEASEARRAYOBJECTS(ppFonts);
|
|
}
|
|
void CPdfWriter::DrawChoiceWidget(NSFonts::IApplicationFonts* pAppFonts, PdfWriter::CChoiceWidget* pChoiceWidget, const std::vector<std::wstring>& arrValue)
|
|
{
|
|
if (!pAppFonts || !pChoiceWidget)
|
|
return;
|
|
PdfWriter::CFontCidTrueType* pFont = pChoiceWidget->GetFont();
|
|
if (!pFont)
|
|
return;
|
|
PdfWriter::CFontTrueType* pFontTT = m_pDocument->CreateTrueTypeFont(pFont);
|
|
if (!pFontTT)
|
|
return;
|
|
double dFontSize = pChoiceWidget->GetFontSize();
|
|
bool isBold = pChoiceWidget->GetFontIsBold();
|
|
bool isItalic = pChoiceWidget->GetFontIsItalic();
|
|
double dWidth = pChoiceWidget->GetWidth();
|
|
double dHeight = pChoiceWidget->GetHeight();
|
|
BYTE nAlign = pChoiceWidget->GetQ();
|
|
|
|
if (!pChoiceWidget->HaveBorder() && pChoiceWidget->HaveBC())
|
|
pChoiceWidget->SetBorder(0, 1, {});
|
|
double dShiftBorder = pChoiceWidget->GetBorderWidth();
|
|
PdfWriter::EBorderType nType = pChoiceWidget->GetBorderType();
|
|
if (nType == PdfWriter::EBorderType::Beveled || nType == PdfWriter::EBorderType::Inset)
|
|
dShiftBorder *= 2;
|
|
|
|
if (arrValue.empty())
|
|
{
|
|
pChoiceWidget->SetEmptyAP();
|
|
return;
|
|
}
|
|
|
|
if (pChoiceWidget->GetWidgetType() == PdfWriter::WidgetCombobox)
|
|
{
|
|
std::wstring wsValue = pChoiceWidget->GetValue(arrValue.back());
|
|
unsigned int unLen = 0;
|
|
unsigned int* pUnicodes = NULL;
|
|
unsigned short* pCodes = NULL;
|
|
PdfWriter::CFontCidTrueType** ppFonts = NULL;
|
|
bool bFont = GetFontData(pAppFonts, wsValue, pFont, isBold, isItalic, pUnicodes, unLen, pCodes, ppFonts);
|
|
if (!bFont)
|
|
{
|
|
RELEASEARRAYOBJECTS(pUnicodes);
|
|
RELEASEARRAYOBJECTS(pCodes);
|
|
RELEASEARRAYOBJECTS(ppFonts);
|
|
return;
|
|
}
|
|
|
|
double dShiftX = dShiftBorder * 2;
|
|
if (dShiftX == 0)
|
|
dShiftX = 2;
|
|
if (1 == nAlign || 2 == nAlign)
|
|
{
|
|
double dSumWidth = 0;
|
|
for (unsigned int unIndex = 0; unIndex < unLen; ++unIndex)
|
|
{
|
|
unsigned short ushCode = pCodes[unIndex];
|
|
double dLetterWidth = ppFonts[unIndex]->GetWidth(ushCode) / 1000.0 * dFontSize;
|
|
dSumWidth += dLetterWidth;
|
|
}
|
|
|
|
if (2 == nAlign)
|
|
dShiftX = dWidth - dSumWidth - dShiftBorder * 2;
|
|
else if (1 == nAlign)
|
|
dShiftX = (dWidth - dSumWidth) / 2;
|
|
}
|
|
|
|
double dBaseLine = (dHeight - dFontSize) / 2.0 - dShiftBorder;
|
|
if (pFontTT)
|
|
dBaseLine = (dHeight - pFontTT->m_dHeight * dFontSize / pFontTT->m_dUnitsPerEm) / 2.0 + std::abs(pFontTT->m_dDescent * dFontSize / pFontTT->m_dUnitsPerEm);
|
|
|
|
pChoiceWidget->SetAP(wsValue, pCodes, unLen, dShiftX, dBaseLine, ppFonts, NULL);
|
|
|
|
RELEASEARRAYOBJECTS(pUnicodes);
|
|
RELEASEARRAYOBJECTS(pCodes);
|
|
RELEASEARRAYOBJECTS(ppFonts);
|
|
}
|
|
else // ListBox
|
|
{
|
|
std::wstring wsValue = pChoiceWidget->SetListBoxIndex(arrValue);
|
|
unsigned int unLen = 0;
|
|
unsigned int* pUnicodes = NULL;
|
|
unsigned short* pCodes = NULL;
|
|
PdfWriter::CFontCidTrueType** ppFonts = NULL;
|
|
bool bFont = GetFontData(pAppFonts, wsValue, pFont, isBold, isItalic, pUnicodes, unLen, pCodes, ppFonts);
|
|
if (!bFont)
|
|
{
|
|
RELEASEARRAYOBJECTS(pUnicodes);
|
|
RELEASEARRAYOBJECTS(pCodes);
|
|
RELEASEARRAYOBJECTS(ppFonts);
|
|
return;
|
|
}
|
|
|
|
unsigned short* pCodes2 = new unsigned short[unLen];
|
|
unsigned int* pWidths = new unsigned int[unLen];
|
|
|
|
unsigned short ushSpaceCode = 0xFFFF;
|
|
unsigned short ushNewLineCode = 0xFFFE;
|
|
for (unsigned int unIndex = 0; unIndex < unLen; ++unIndex)
|
|
{
|
|
unsigned short ushCode = 0;
|
|
if (0x0020 == pUnicodes[unIndex])
|
|
ushCode = ushSpaceCode;
|
|
else if (0x000D == pUnicodes[unIndex] || 0x000A == pUnicodes[unIndex])
|
|
ushCode = ushNewLineCode;
|
|
|
|
pCodes2[unIndex] = ushCode;
|
|
pWidths[unIndex] = ppFonts[unIndex]->GetWidth(pCodes[unIndex]);
|
|
}
|
|
|
|
m_oLinesManager.Init(pCodes2, pWidths, unLen, ushSpaceCode, ushNewLineCode, pFontTT->GetLineHeight(), pFontTT->GetAscent());
|
|
|
|
m_oLinesManager.CalculateLines(dFontSize, dWidth - dShiftBorder * 4);
|
|
|
|
double dKoef = dFontSize / pFontTT->m_dUnitsPerEm;
|
|
double dLineHeight = pFontTT->m_dHeight * dKoef;
|
|
pChoiceWidget->SetListBoxHeight(dLineHeight);
|
|
pChoiceWidget->StartAP(0);
|
|
|
|
// double dKoef = dFontSize / pFontTT->m_dUnitsPerEm;
|
|
// double dDescent = std::abs(pFontTT->m_dDescent * dFontSize / pFontTT->m_dUnitsPerEm);
|
|
// double dAscent = dLineHeight - dDescent;
|
|
// double dMidPoint = dAscent - pFontTT->m_dMinY * dKoef + dAscent - pFontTT->m_dMaxY * dKoef;
|
|
// double dDiff = dLineHeight - dMidPoint;
|
|
double dLineShiftY = dHeight - dShiftBorder - dLineHeight + std::abs(pFontTT->m_dDescent * dKoef);
|
|
|
|
unsigned int unLinesCount = m_oLinesManager.GetLinesCount();
|
|
for (unsigned int unIndex = 0; unIndex < unLinesCount; ++unIndex)
|
|
{
|
|
unsigned int unLineStart = m_oLinesManager.GetLineStartPos(unIndex);
|
|
double dLineShiftX = dShiftBorder * 2;
|
|
if (dLineShiftX == 0)
|
|
dLineShiftX = 2;
|
|
double dLineWidth = m_oLinesManager.GetLineWidth(unIndex, dFontSize);
|
|
if (2 == nAlign)
|
|
dLineShiftX = dWidth - dLineWidth - dShiftBorder * 2;
|
|
else if (1 == nAlign)
|
|
dLineShiftX = (dWidth - dLineWidth) / 2;
|
|
|
|
int nInLineCount = m_oLinesManager.GetLineEndPos(unIndex) - m_oLinesManager.GetLineStartPos(unIndex);
|
|
if (nInLineCount > 0)
|
|
pChoiceWidget->AddLineToAP(dLineShiftX, dLineShiftY, pCodes + unLineStart, nInLineCount, ppFonts + unLineStart, NULL);
|
|
|
|
dLineShiftY -= dLineHeight;
|
|
if (dLineShiftY < 0)
|
|
break;
|
|
}
|
|
|
|
pChoiceWidget->EndAP();
|
|
|
|
m_oLinesManager.Clear();
|
|
|
|
RELEASEARRAYOBJECTS(pCodes2);
|
|
RELEASEARRAYOBJECTS(pWidths);
|
|
|
|
RELEASEARRAYOBJECTS(pUnicodes);
|
|
RELEASEARRAYOBJECTS(pCodes);
|
|
RELEASEARRAYOBJECTS(ppFonts);
|
|
}
|
|
}
|
|
void CPdfWriter::DrawButtonWidget(NSFonts::IApplicationFonts* pAppFonts, PdfWriter::CPushButtonWidget* pButtonWidget, BYTE nAP, PdfWriter::CXObject* pForm)
|
|
{
|
|
if (!pAppFonts || !pButtonWidget)
|
|
return;
|
|
|
|
double dShiftX = 0;
|
|
double dShiftY = 0;
|
|
double dLineW = 0;
|
|
double dLineH = 0;
|
|
unsigned int unLen = 0;
|
|
unsigned int* pUnicodes = NULL;
|
|
unsigned short* pCodes = NULL;
|
|
PdfWriter::CFontCidTrueType** ppFonts = NULL;
|
|
BYTE nTP = pButtonWidget->GetTP();
|
|
std::wstring wsValue;
|
|
if (nAP == 0)
|
|
wsValue = pButtonWidget->GetCA();
|
|
else if (nAP == 1)
|
|
wsValue = pButtonWidget->GetRC();
|
|
else
|
|
wsValue = pButtonWidget->GetAC();
|
|
|
|
if (!pButtonWidget->HaveBorder() && pButtonWidget->HaveBC())
|
|
pButtonWidget->SetBorder(0, 1, {});
|
|
if (nTP != 1 && !pForm)
|
|
nTP = 0;
|
|
|
|
if (nTP != 1 && !m_bSplit)
|
|
{
|
|
PdfWriter::CFontCidTrueType* pFont = pButtonWidget->GetFont();
|
|
if (!pFont)
|
|
return;
|
|
PdfWriter::CFontTrueType* pFontTT = m_pDocument->CreateTrueTypeFont(pFont);
|
|
double dFontSize = pButtonWidget->GetFontSize();
|
|
bool isBold = pButtonWidget->GetFontIsBold();
|
|
bool isItalic = pButtonWidget->GetFontIsItalic();
|
|
double dWidth = pButtonWidget->GetWidth();
|
|
double dHeight = pButtonWidget->GetHeight();
|
|
int nRotate = pButtonWidget->GetR();
|
|
if (nRotate == 90 || nRotate == 270)
|
|
std::swap(dWidth, dHeight);
|
|
|
|
double dShiftBorder = pButtonWidget->GetBorderWidth();
|
|
PdfWriter::EBorderType nType = pButtonWidget->GetBorderType();
|
|
if (nType == PdfWriter::EBorderType::Beveled || nType == PdfWriter::EBorderType::Inset)
|
|
dShiftBorder *= 2;
|
|
if (dShiftBorder == 0)
|
|
dShiftBorder = 1;
|
|
double dShiftRespectBorder = dShiftBorder / 2;
|
|
bool bRespectBorder = pButtonWidget->GetRespectBorder();
|
|
if (!bRespectBorder)
|
|
dShiftBorder = 0;
|
|
|
|
bool bFont = GetFontData(pAppFonts, wsValue, pFont, isBold, isItalic, pUnicodes, unLen, pCodes, ppFonts);
|
|
if (!wsValue.empty() && !bFont)
|
|
{
|
|
RELEASEARRAYOBJECTS(pUnicodes);
|
|
RELEASEARRAYOBJECTS(pCodes);
|
|
RELEASEARRAYOBJECTS(ppFonts);
|
|
return;
|
|
}
|
|
|
|
for (unsigned int unIndex = 0; unIndex < unLen; ++unIndex)
|
|
{
|
|
unsigned short ushCode = pCodes[unIndex];
|
|
double dLetterWidth = ppFonts[unIndex]->GetWidth(ushCode) / 1000.0 * dFontSize;
|
|
dLineW += dLetterWidth;
|
|
}
|
|
|
|
if (pFontTT)
|
|
{
|
|
double dKoef = dFontSize / pFontTT->m_dUnitsPerEm;
|
|
// TODO что-то между m_dMaxY-m_dMinY и m_dHeight, но не просто среднее
|
|
dLineH = (pFontTT->m_dMaxY + std::abs(pFontTT->m_dMinY) + pFontTT->m_dHeight) / 2.0 * dKoef;
|
|
// dLineH = (pFontTT->m_dMaxY + std::abs(pFontTT->m_dMinY)) * dKoef;
|
|
// dLineH = pFontTT->m_dHeight * dKoef;
|
|
// double dLineHeight = pFontTT->m_dHeight * dKoef;
|
|
// double dDescent = std::abs(pFontTT->m_dDescent * dKoef);
|
|
// double dAscent1 = pFontTT->m_dAscent * dKoef;
|
|
// double dAscent = dLineHeight - dDescent;
|
|
// double dMidPoint = dAscent - pFontTT->m_dMinY * dKoef + dAscent - pFontTT->m_dMaxY * dKoef;
|
|
// double dDiff = dLineHeight - dMidPoint;
|
|
|
|
if (nTP == 0 || nTP == 2 || nTP == 3 || nTP == 6)
|
|
dShiftX = (dWidth - dLineW) / 2;
|
|
else if (nTP == 4)
|
|
dShiftX = dWidth - dLineW - dShiftBorder * 2 + dShiftRespectBorder;
|
|
else if (nTP == 5)
|
|
dShiftX = dShiftBorder * 2 + dShiftRespectBorder;
|
|
|
|
if (nTP == 0 || nTP == 6 || nTP == 4 || nTP == 5)
|
|
dShiftY = (dHeight - dLineH) / 2 + std::abs(pFontTT->m_dMinY * dKoef);
|
|
else if (nTP == 3)
|
|
dShiftY = dHeight - dShiftBorder * 2 - dShiftRespectBorder - dLineH + std::abs(pFontTT->m_dMinY * dKoef);
|
|
else if (nTP == 2)
|
|
dShiftY = dShiftBorder * 2 + std::abs(pFontTT->m_dMinY * dKoef);
|
|
}
|
|
}
|
|
|
|
pButtonWidget->SetAP(pForm, nAP, pCodes, unLen, dShiftX, dShiftY, dLineW, dLineH, ppFonts, m_bSplit);
|
|
|
|
RELEASEARRAYOBJECTS(pUnicodes);
|
|
RELEASEARRAYOBJECTS(pCodes);
|
|
RELEASEARRAYOBJECTS(ppFonts);
|
|
}
|