/*
 * (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 "Document.h"
#include "Info.h"
#include "Catalog.h"
#include "Streams.h"
#include "EncryptDictionary.h"
#include "Encrypt.h"
#include "Pages.h"
#include "Outline.h"
#include "Destination.h"
#include "GState.h"
#include "Annotation.h"
#include "Image.h"
#include "Font14.h"
#include "FontCidTT.h"
#include "FontTT.h"
#include "FontTTWriter.h"
#include "Shading.h"
#include "Pattern.h"
#include "AcroForm.h"
#include "Field.h"
#include "ResourcesDictionary.h"
#include "Metadata.h"

#include "../../DesktopEditor/agg-2.4/include/agg_span_hatch.h"
#include "../../DesktopEditor/common/SystemUtils.h"

#ifdef CreateFont
#undef CreateFont
#endif

#ifndef VALUE2STR
#define VALUE_TO_STRING(x) #x
#define VALUE2STR(x) VALUE_TO_STRING(x)
#endif

namespace PdfWriter
{
	const char* c_sPdfHeader = "%PDF-1.7\015%\315\312\322\251\015";
	const char* c_sPdfAHeader = "%PDF-1.4\015%\315\312\322\251\015";
	//----------------------------------------------------------------------------------------
	// CDocument
	//----------------------------------------------------------------------------------------
	CDocument::CDocument()
	{
		m_pCatalog          = NULL;
		m_pOutlines         = NULL;
		m_pXref             = NULL;
		m_pLastXref         = NULL;
		m_pPageTree         = NULL;
		m_pCurPage          = NULL;
		m_nCurPageNum       = -1;
		m_pCurImage         = NULL;
		m_pInfo             = NULL;
		m_pTrailer          = NULL;
		m_pResources        = NULL;
		m_pMetaData         = NULL;
		m_bEncrypt          = false;
		m_pEncryptDict      = NULL;
		m_unFormFields      = 0;
		m_unCompressMode    = COMP_NONE;
		memset((void*)m_sTTFontTag, 0x00, 8);
		m_pJbig2            = NULL;
		m_pDefaultCheckBoxFont = NULL;
		m_pTransparencyGroup = NULL;
		m_pFreeTypeLibrary  = NULL;
		m_bPDFAConformance	= false;
		m_pAcroForm         = NULL;
		m_pFieldsResources  = NULL;
	}
	CDocument::~CDocument()
	{
		Close();
	}
	bool CDocument::CreateNew()
	{
		Close();

		m_pXref = new CXref(this, 0);
		if (!m_pXref)
			return false;

		m_pTrailer = m_pXref->GetTrailer();
		if (!m_pTrailer)
			return false;

		m_pMetaData = new CStreamData(m_pXref);
		if (!m_pMetaData)
			return false;

		m_pCatalog = new CCatalog(m_pXref);
		if (!m_pCatalog)
			return false;

		m_pCatalog->SetPageMode(pagemode_UseNone);
		m_pCatalog->SetPageLayout(pagelayout_OneColumn);

		m_pPageTree = m_pCatalog->GetRoot();
		if (!m_pPageTree)
			return false;

		m_pInfo = new CInfoDict(m_pXref);
		if (!m_pInfo)
			return false;

		m_pInfo->SetTime(InfoCreationDate);
		m_pInfo->SetTime(InfoModaDate);

		std::wstring sCreator = NSSystemUtils::GetEnvVariable(NSSystemUtils::gc_EnvApplicationName);
		if (sCreator.empty())
			sCreator = NSSystemUtils::gc_EnvApplicationNameDefault;
		std::string sCreatorA = NSFile::CUtf8Converter::GetUtf8StringFromUnicode(sCreator);

#if defined(INTVER)
		std::string sVersion = VALUE2STR(INTVER);
		sCreatorA += ("/" + sVersion);
#endif

		m_pInfo->SetInfo(InfoProducer, sCreatorA.c_str());
		m_pInfo->SetInfo(InfoCreator, sCreatorA.c_str());

		if (IsPDFA())
		{
			CArrayObject* pID = (CArrayObject*)m_pTrailer->Get("ID");
			if (!pID)
			{
				BYTE arrId[16];
				CEncryptDict::CreateId(m_pInfo, m_pXref, (BYTE*)arrId);

				pID = new CArrayObject();
				m_pTrailer->Add("ID", pID);

				pID->Add(new CBinaryObject(arrId, 16));
				pID->Add(new CBinaryObject(arrId, 16));
			}
		}

		m_nCurPageNum = -1;

		m_vExtGrStates.clear();
		m_vFillAlpha.clear();
		m_vStrokeAlpha.clear();
		m_vRadioGroups.clear();
		m_vMetaOForms.clear();
		m_vImages.clear();

		m_pTransparencyGroup = NULL;

		return true;
	}
    void CDocument::Close()
	{
		// Все объекты удаляются внутри CXref
		RELEASEOBJECT(m_pXref);

		m_pLastXref         = NULL;
		m_pTrailer          = NULL;
		m_pResources        = NULL;
		m_pCatalog          = NULL;
		m_pOutlines         = NULL;
		m_pPageTree         = NULL;
		m_pCurPage          = NULL;
		m_nCurPageNum       = 0;
		m_pCurImage         = NULL;
		m_unFormFields      = 0;
		m_bEncrypt          = false;
		m_pEncryptDict      = NULL;
		m_pInfo             = NULL;
		m_unCompressMode    = COMP_NONE;
		m_pJbig2            = NULL;
		m_pTransparencyGroup= NULL;
		m_pAcroForm         = NULL;
		m_pFieldsResources  = NULL;
		memset((void*)m_sTTFontTag, 0x00, 8);
		m_pDefaultCheckBoxFont = NULL;

		m_vExtGrStates.clear();
		m_vStrokeAlpha.clear();
		m_vFillAlpha.clear();
		m_vShadings.clear();
		m_vCidTTFonts.clear();
		m_vTTFonts.clear();
		m_vFreeTypeFonts.clear();
		m_vSignatures.clear();
		m_vMetaOForms.clear();
		m_vImages.clear();
		if (m_pFreeTypeLibrary)
		{
			FT_Done_FreeType(m_pFreeTypeLibrary);
			m_pFreeTypeLibrary = NULL;
		}
	}
	bool CDocument::SaveToFile(const std::wstring& wsPath)
	{
		CFileStream* pStream = new CFileStream();
		if (!pStream || !pStream->OpenFile(wsPath, true))
			return false;

		if (m_pJbig2)
			m_pJbig2->FlushStreams();

		SaveToStream((CStream*)pStream);
		delete pStream;

		Sign(wsPath, m_pXref->GetSizeXRef());

		return true;
	}
	bool CDocument::SaveToMemory(BYTE** pData, int* pLength)
	{
		CMemoryStream* pStream = new CMemoryStream();
		if (!pStream)
			return false;

		if (m_pJbig2)
			m_pJbig2->FlushStreams();

		SaveToStream(pStream);

		*pData = pStream->GetBuffer();
		*pLength = pStream->Size();

		pStream->ClearWithoutAttack();
		return true;
	}
    void CDocument::SaveToStream(CStream* pStream)
	{
		m_pCatalog->AddMetadata(m_pXref, m_pInfo);

		// Пишем заголовок
		if (IsPDFA())
			pStream->WriteStr(c_sPdfAHeader);
		else
			pStream->WriteStr(c_sPdfHeader);
		
		if (false == m_wsDocumentID.empty())
		{
			std::string sDocumentID = "%DocumentID " + NSFile::CUtf8Converter::GetUtf8StringFromUnicode(m_wsDocumentID);
			pStream->WriteStr(sDocumentID.c_str());
		}

		// Добавляем в Trailer необходимые элементы 
		m_pTrailer->Add("Root", m_pCatalog);
		m_pTrailer->Add("Info", m_pInfo);

		// Шифруем документ, если это необходимо
		CEncrypt* pEncrypt = NULL;
		if (m_bEncrypt)
		{
			pEncrypt = m_pEncryptDict->GetEncrypt();
			PrepareEncryption();
		}

		m_pXref->WriteToStream(pStream, pEncrypt, true);
	}
	bool CDocument::SaveNewWithPassword(CXref* pXref, CXref* _pXref, const std::wstring& wsPath, const std::wstring& wsOwnerPassword, const std::wstring& wsUserPassword, CDictObject* pTrailer)
	{
		if (!pXref || !pTrailer || !_pXref)
			return false;
		m_pTrailer = pTrailer;

		CEncrypt* pEncrypt = NULL;
		if (!wsOwnerPassword.empty())
		{
			m_pEncryptDict = new CEncryptDict(_pXref);
			m_pEncryptDict->SetPasswords(wsOwnerPassword, wsUserPassword);
			m_pTrailer->Add("Encrypt", m_pEncryptDict);

			pEncrypt = m_pEncryptDict->GetEncrypt();
			PrepareEncryption();
		}

		CFileStream* pStream = new CFileStream();
		if (!pStream || !pStream->OpenFile(wsPath, true))
			return false;
		pStream->WriteStr(c_sPdfHeader);

		pXref->WriteToStream(pStream, pEncrypt);

		delete pStream;
		return true;
	}
    void CDocument::PrepareEncryption()
	{
		CEncrypt* pEncrypt = m_pEncryptDict->GetEncrypt();
		if (!pEncrypt)
			return;

		m_pEncryptDict->Prepare(m_pInfo, m_pXref);

		CArrayObject* pID = (CArrayObject*)m_pTrailer->Get("ID");
		if (!pID)
		{
			pID = new CArrayObject();
			m_pTrailer->Add("ID", pID);
		}
		else
			pID->Clear();

		pID->Add(new CBinaryObject(pEncrypt->m_anEncryptID, 16));
		pID->Add(new CBinaryObject(pEncrypt->m_anEncryptID, 16));

		if (m_pMetaData)
			m_pMetaData->SetID(new CBinaryObject(pEncrypt->m_anEncryptID, 16));

		for (int i = 0; i < m_vMetaOForms.size(); ++i)
			m_vMetaOForms[i]->Add("ID", new CBinaryObject(pEncrypt->m_anEncryptID, 16));
	}
    void CDocument::SetPasswords(const std::wstring & wsOwnerPassword, const std::wstring & wsUserPassword)
	{
		if (IsPDFA())
			return;

		if (!m_pEncryptDict)
			m_pEncryptDict = new CEncryptDict(m_pXref);

		if (!m_pEncryptDict)
			return;

		m_pEncryptDict->SetPasswords(wsOwnerPassword, wsUserPassword);

		m_pTrailer->Add("Encrypt", m_pEncryptDict);
		m_bEncrypt = true;
	}
    CPage* CDocument::AddPage()
	{
		CPage* pPage = new CPage(m_pXref, m_pPageTree, this);
		m_pPageTree->AddPage(pPage);
		m_pCurPage = pPage;

#ifndef FILTER_FLATE_DECODE_DISABLED
		if (m_unCompressMode & COMP_TEXT)
			pPage->SetFilter(STREAM_FILTER_FLATE_DECODE);
#endif

		m_nCurPageNum++;
		return pPage;
	}
	CPage* CDocument::GetPage(const unsigned int &unPage)
	{
		if (unPage >= m_pPageTree->GetCount())
			return NULL;

		return m_pPageTree->GetPage(unPage);
	}
	CPage* CDocument::GetEditPage(const unsigned int& unPage)
	{
		CPage* pRes = NULL;
		std::map<int, CPage*>::iterator p = m_mEditPages.find(unPage);
		if (p != m_mEditPages.end())
			pRes = p->second;
		return pRes;
	}
	int CDocument::FindPage(CPage* pPage)
	{
		int nI = 0;
		return m_pPageTree->Find(pPage, nI) ? nI : -1;
	}
	unsigned int CDocument::GetPagesCount() const
	{
		return m_pPageTree->GetCount();
	}
    void CDocument::SetDocumentID(const std::wstring& documentID)
	{
		m_wsDocumentID = documentID;		
	}
    void CDocument::SetTitle(const std::string& sTitle)
    {
        if (!m_pInfo)
            return;
        m_pInfo->SetInfo(InfoTitle, sTitle.c_str());
    }
    void CDocument::SetAuthor(const std::string& sAuthor)
    {
        if (!m_pInfo)
            return;
        m_pInfo->SetInfo(InfoAuthor, sAuthor.c_str());
    }
    void CDocument::SetSubject(const std::string& sSubject)
    {
        if (!m_pInfo)
            return;
        m_pInfo->SetInfo(InfoSubject, sSubject.c_str());
    }
    void CDocument::SetKeywords(const std::string& sKeywords)
    {
        if (!m_pInfo)
            return;
        m_pInfo->SetInfo(InfoKeyWords, sKeywords.c_str());
    }

    void CDocument::SetPermission(unsigned int unPermission)
	{
		if (!m_bEncrypt)
			return;

		CEncrypt* pEncrypt = m_pEncryptDict->GetEncrypt();
		pEncrypt->SetPermission(unPermission);
	}
    void CDocument::SetCompressionMode(unsigned int unMode)
	{
		m_unCompressMode = unMode;
	}
	unsigned int CDocument::GetCompressionMode() const
	{
		return m_unCompressMode;
	}
	void CDocument::SetPDFAConformanceMode(bool isPDFA)
	{
		m_bPDFAConformance = isPDFA;		
	}
	bool CDocument::IsPDFA() const
	{
		return m_bPDFAConformance;
	}
    void CDocument::AddPageLabel(EPageNumStyle eStyle, unsigned int unFirstPage, const char* sPrefix)
	{
		CDictObject* pPageLabel = CreatePageLabel(eStyle, unFirstPage, sPrefix);
		if (!pPageLabel)
			return;

		m_pCatalog->AddPageLabel(m_nCurPageNum, pPageLabel);
	}
    void CDocument::AddPageLabel(unsigned int unPageNum, EPageNumStyle eStyle, unsigned int unFirstPage, const char* sPrefix)
	{
		CDictObject* pPageLabel = CreatePageLabel(eStyle, unFirstPage, sPrefix);
		if (!pPageLabel)
			return;

		m_pCatalog->AddPageLabel(unPageNum, pPageLabel);
	}
	bool CDocument::AddMetaData(const std::wstring& sMetaName, BYTE* pMetaData, DWORD nMetaLength)
	{
		if (!m_pMetaData)
			return false;

		CBinaryObject* sID = NULL;
		CArrayObject* pID = (CArrayObject*)m_pTrailer->Get("ID");
		if (!pID)
		{
			BYTE arrId[16];
			CEncryptDict::CreateId(m_pInfo, m_pXref, (BYTE*)arrId);

			pID = new CArrayObject();
			m_pTrailer->Add("ID", pID);

			pID->Add(new CBinaryObject(arrId, 16));
			pID->Add(new CBinaryObject(arrId, 16));

			sID = new CBinaryObject(arrId, 16);
		}
		else
			sID = (CBinaryObject*)pID->Get(1)->Copy();

		m_pMetaData->SetID(sID);

		return m_pMetaData->AddMetaData(sMetaName, pMetaData, nMetaLength);
	}
	CDictObject* CDocument::CreatePageLabel(EPageNumStyle eStyle, unsigned int unFirstPage, const char* sPrefix)
	{
		CDictObject* pLabel = new CDictObject();
		if (!pLabel)
			return NULL;

        eStyle = std::min(std::max(eStyle, pagenumstyle_Min), pagenumstyle_Max);
		switch (eStyle)
		{
		case pagenumstyle_UpperRoman: pLabel->Add("S", "R"); break;
		case pagenumstyle_LowerRoman: pLabel->Add("S", "r"); break;
		case pagenumstyle_UpperLetters: pLabel->Add("S", "A"); break;
		case pagenumstyle_LowerLetters: pLabel->Add("S", "a"); break;
		case pagenumstyle_Decimal: pLabel->Add("S", "D"); break;
		}

		if (sPrefix && 0 != sPrefix[0])
			pLabel->Add("P", new CStringObject(sPrefix));

		if (0 != unFirstPage)
			pLabel->Add("St", unFirstPage);

		return pLabel;
	}
    COutline* CDocument::CreateOutline(COutline* pParent, const char* sTitle)
	{
		if (!pParent)
		{
			if (!m_pOutlines)
			{
				m_pOutlines = new COutline(m_pXref);
				if (m_pOutlines)
					m_pCatalog->Add("Outlines", m_pOutlines);
				else
					return NULL;
			}

			pParent = m_pOutlines;
		}

		return new COutline(pParent, sTitle, m_pXref);
	}
	CDestination* CDocument::CreateDestination(CObjectBase* pPage, bool bInline)
	{
		if (pPage)
			return new CDestination(pPage, m_pXref, bInline);
		return NULL;
	}
    CExtGrState* CDocument::FindExtGrState(double dAlphaStroke, double dAlphaFill, EBlendMode eMode, int nStrokeAdjustment)
	{
		CExtGrState* pExtGrState = NULL;
		for (unsigned int unIndex = 0, unCount = m_vExtGrStates.size(); unIndex < unCount; unIndex++)
		{
			pExtGrState = m_vExtGrStates.at(unIndex);

			if (dAlphaStroke != pExtGrState->GetAlphaStroke())
				continue;

			if (dAlphaFill != pExtGrState->GetAlphaFill())
				continue;

			if (eMode != pExtGrState->GetBlendMode())
				continue;

			if ((0 == nStrokeAdjustment ? false : true) != pExtGrState->GetStrokeAdjustment())
				continue;

			return pExtGrState;
		}

		return NULL;
	}
	void CDocument::AddExtGState(CExtGrState* pState)
	{
		m_vExtGrStates.push_back(pState);
	}
    CExtGrState* CDocument::GetExtGState(double dAlphaStroke, double dAlphaFill, EBlendMode eMode, int nStrokeAdjustment)
	{
		CExtGrState* pExtGrState = FindExtGrState(dAlphaStroke, dAlphaFill, eMode, nStrokeAdjustment);

		if (!pExtGrState)
		{
			pExtGrState = new CExtGrState(m_pXref);
			if (!pExtGrState)
				return NULL;

			if (-1 != dAlphaStroke)
				pExtGrState->SetAlphaStroke(dAlphaStroke);

			if (-1 != dAlphaFill)
				pExtGrState->SetAlphaFill(dAlphaFill);

			if (blendmode_Unknown != eMode)
				pExtGrState->SetBlendMode(eMode);

			if (-1 != nStrokeAdjustment)
				pExtGrState->SetStrokeAdjustment(0 == nStrokeAdjustment ? false : true);

			m_vExtGrStates.push_back(pExtGrState);
		}

		return pExtGrState;
	}
    CExtGrState* CDocument::GetStrokeAlpha(double dAlpha)
	{
		CExtGrState* pExtGrState = NULL;
		for (unsigned int unIndex = 0, unCount = m_vStrokeAlpha.size(); unIndex < unCount; unIndex++)
		{
			pExtGrState = m_vStrokeAlpha.at(unIndex);

			if (fabs(dAlpha - pExtGrState->GetAlphaStroke()) < 0.001)
				return pExtGrState;
		}

		pExtGrState = new CExtGrState(m_pXref);
		if (!pExtGrState)
			return NULL;

		pExtGrState->SetAlphaStroke(dAlpha);

		m_vStrokeAlpha.push_back(pExtGrState);
		return pExtGrState;
	}
    CExtGrState* CDocument::GetFillAlpha(double dAlpha)
	{
		CExtGrState* pExtGrState = NULL;
		for (unsigned int unIndex = 0, unCount = m_vFillAlpha.size(); unIndex < unCount; unIndex++)
		{
			pExtGrState = m_vFillAlpha.at(unIndex);

			if (fabs(dAlpha - pExtGrState->GetAlphaFill()) < 0.001)
				return pExtGrState;
		}

		pExtGrState = new CExtGrState(m_pXref);
		if (!pExtGrState)
			return NULL;

		pExtGrState->SetAlphaFill(dAlpha);

		m_vFillAlpha.push_back(pExtGrState);
		return pExtGrState;
	}
	CAnnotation* CDocument::CreateAnnot(BYTE m_nType)
	{
		CAnnotation* pAnnot = NULL;
		if (m_nType == 0)
		{
			pAnnot = new CTextAnnotation(m_pXref);
			pAnnot->SetC({ 1.0, 0.8, 0.0 });
		}
		else if (m_nType == 14)
			pAnnot = new CInkAnnotation(m_pXref);
		else if (m_nType == 3)
			pAnnot = new CLineAnnotation(m_pXref);
		else if (m_nType >= 8 && m_nType <= 11)
			pAnnot = new CTextMarkupAnnotation(m_pXref);
		else if (m_nType == 4 || m_nType == 5)
			pAnnot = new CSquareCircleAnnotation(m_pXref);
		else if (m_nType == 6 || m_nType == 7)
			pAnnot = new CPolygonLineAnnotation(m_pXref);
		else if (m_nType == 15)
			pAnnot = new CPopupAnnotation(m_pXref);
		else if (m_nType == 2)
			pAnnot = new CFreeTextAnnotation(m_pXref);
		else if (m_nType == 13)
			pAnnot = new CCaretAnnotation(m_pXref);
		else if (m_nType == 12)
			pAnnot = new CStampAnnotation(m_pXref);
		else if (m_nType == 25)
			pAnnot = new CRedactAnnotation(m_pXref);

		if (pAnnot)
			m_pXref->Add(pAnnot);

		if (m_nType >= 26)
		{
			if (!CheckAcroForm())
				return NULL;

			switch (m_nType)
			{
			case 26:
			{
				pAnnot = new CWidgetAnnotation(m_pXref, EAnnotType::AnnotWidget);
				break;
			}
			case 27:
			{
				pAnnot = new CPushButtonWidget(m_pXref);
				pAnnot->Add("FT", "Btn");
				break;
			}
			case 28:
			case 29:
			{
				pAnnot = new CCheckBoxWidget(m_pXref);
				pAnnot->Add("FT", "Btn");
				break;
			}
			case 30:
			{
				pAnnot = new CTextWidget(m_pXref);
				pAnnot->Add("FT", "Tx");
				break;
			}
			case 31:
			case 32:
			{
				pAnnot = new CChoiceWidget(m_pXref);
				pAnnot->Add("FT", "Ch");
				break;
			}
			case 33:
			{
				pAnnot = new CSignatureWidget(m_pXref);
				pAnnot->Add("FT", "Sig");
				break;
			}
			default: break;
			}

			if (pAnnot)
			{
				m_pXref->Add(pAnnot);
				CArrayObject* ppFields = (CArrayObject*)m_pAcroForm->Get("Fields");
				ppFields->Add(pAnnot);
			}
		}
		return pAnnot;
	}
	CAnnotation* CDocument::CreateLinkAnnot(const TRect& oRect, CDestination* pDest)
	{
		CAnnotation* pAnnot = new CLinkAnnotation(m_pXref, pDest);
		pAnnot->SetRect(oRect);
		m_pXref->Add(pAnnot);
		return pAnnot;
	}
	CAnnotation* CDocument::CreateUriLinkAnnot(const TRect& oRect, const char* sUrl)
	{
		CAnnotation* pAnnot = new CUriLinkAnnotation(m_pXref, sUrl);
		pAnnot->SetRect(oRect);
		m_pXref->Add(pAnnot);
		return pAnnot;
	}
	CAction* CDocument::CreateAction(BYTE nType)
	{
		switch (nType)
		{
		case 1:  return new CActionGoTo(m_pXref);
		case 6:  return new CActionURI(m_pXref);
		case 9:  return new CActionHide(m_pXref);
		case 10: return new CActionNamed(m_pXref);
		case 12: return new CActionResetForm(m_pXref);
		case 14: return new CActionJavaScript(m_pXref);
		}

		return NULL;
	}
	void CDocument::AddAnnotation(const int& nID, CAnnotation* pAnnot)
	{
		pAnnot->SetXref(m_pXref);
		m_mAnnotations[nID] = pAnnot;
	}
    CImageDict* CDocument::CreateImage()
	{
		return new CImageDict(m_pXref, this);
	}
	CXObject* CDocument::CreateForm(CImageDict* pImage, const std::string& sName)
	{
		if (!pImage)
			return NULL;

		std::string sFrmName = "FRM" + sName;
		std::string sImgName = "Img" + sName;

		CXObject* pForm = new CXObject();
		CStream* pStream = new CMemoryStream();
		pForm->SetStream(m_pXref, pStream);

#ifndef FILTER_FLATE_DECODE_DISABLED
		if (m_unCompressMode & COMP_TEXT)
			pForm->SetFilter(STREAM_FILTER_FLATE_DECODE);
#endif
		double dOriginW = pImage->GetWidth();
		double dOriginH = pImage->GetHeight();
		pForm->SetWidth(dOriginW);
		pForm->SetHeight(dOriginH);

		CArrayObject* pBBox = new CArrayObject();
		pForm->Add("BBox", pBBox);
		pBBox->Add(0);
		pBBox->Add(0);
		pBBox->Add(dOriginW);
		pBBox->Add(dOriginH);
		pForm->Add("FormType", 1);
		CArrayObject* pFormMatrix = new CArrayObject();
		pForm->Add("Matrix", pFormMatrix);
		pFormMatrix->Add(1);
		pFormMatrix->Add(0);
		pFormMatrix->Add(0);
		pFormMatrix->Add(1);
		pFormMatrix->Add(0);
		pFormMatrix->Add(0);
		pForm->Add("Name", sFrmName.c_str());
		pForm->SetName(sFrmName);

		CDictObject* pFormRes = new CDictObject();
		CArrayObject* pFormResProcset = new CArrayObject();
		pFormRes->Add("ProcSet", pFormResProcset);
		pFormResProcset->Add(new CNameObject("PDF"));
		pFormResProcset->Add(new CNameObject("ImageC"));
		CDictObject* pFormResXObject = new CDictObject();
		pFormRes->Add("XObject", pFormResXObject);

		pFormResXObject->Add(sImgName, pImage);
		pForm->Add("Resources", pFormRes);

		pForm->Add("Subtype", "Form");
		pForm->Add("Type", "XObject");

		pStream->WriteStr("q\012");
		pStream->WriteReal(dOriginW);
		pStream->WriteStr(" 0 0 ");
		pStream->WriteReal(dOriginH);
		pStream->WriteStr(" 0 0 cm\012/");
		pStream->WriteStr(sImgName.c_str());
		pStream->WriteStr(" Do\012Q");

		return pForm;
	}
	CFont14* CDocument::CreateFont14(const std::wstring& wsFontPath, unsigned int unIndex, EStandard14Fonts eType)
	{
		CFont14* pFont = FindFont14(wsFontPath, unIndex);
		if (pFont)
			return pFont;
		pFont = new CFont14(m_pXref, this, eType);
		m_vFonts14.push_back(TFontInfo(wsFontPath, unIndex, pFont));
		return pFont;
	}
	CFont14* CDocument::FindFont14(const std::wstring& wsFontPath, unsigned int unIndex)
	{
		for (int nIndex = 0, nCount = m_vFonts14.size(); nIndex < nCount; nIndex++)
		{
			TFontInfo& oInfo = m_vFonts14.at(nIndex);
			if (wsFontPath == oInfo.wsPath && unIndex == oInfo.unIndex)
				return (CFont14*)oInfo.pFont;
		}
		return NULL;
	}
	CFontCidTrueType* CDocument::CreateCidTrueTypeFont(const std::wstring& wsFontPath, unsigned int unIndex)
	{
		CFontCidTrueType* pFont = FindCidTrueTypeFont(wsFontPath, unIndex);
		if (pFont)
			return pFont;

		CFontFileTrueType* pFontTT = CFontFileTrueType::LoadFromFile(wsFontPath, unIndex);
		if (!pFontTT)
			return NULL;

		pFont = new CFontCidTrueType(m_pXref, this, wsFontPath, unIndex, pFontTT);
		if (!pFont)
			return NULL;

		// 0 GID всегда используется для .notdef символа, не используем данный код для настоящих символов
		unsigned int unUnicode = 0;
		pFont->EncodeGID(0, &unUnicode, 1);

		m_vCidTTFonts.push_back(TFontInfo(wsFontPath, unIndex, pFont));
		return pFont;
	}
	CFontCidTrueType* CDocument::FindCidTrueTypeFont(const std::wstring &wsFontPath, unsigned int unIndex)
	{
		for (int nIndex = 0, nCount = m_vCidTTFonts.size(); nIndex < nCount; nIndex++)
		{
			TFontInfo& oInfo = m_vCidTTFonts.at(nIndex);
			if (wsFontPath == oInfo.wsPath && unIndex == oInfo.unIndex)
				return (CFontCidTrueType*)oInfo.pFont;
		}

		return NULL;
	}
	CFontTrueType* CDocument::CreateTrueTypeFont(const std::wstring& wsFontPath, unsigned int unIndex)
	{
		for (int nIndex = 0, nCount = m_vTTFonts.size(); nIndex < nCount; nIndex++)
		{
			TFontInfo& oInfo = m_vTTFonts.at(nIndex);
			if (wsFontPath == oInfo.wsPath && unIndex == oInfo.unIndex)
				return (CFontTrueType*)oInfo.pFont;
		}

		CFontTrueType* pFont = new CFontTrueType(m_pXref, this, wsFontPath, unIndex);
		if (!pFont)
			return NULL;

		m_vTTFonts.push_back(TFontInfo(wsFontPath, unIndex, pFont));
		return pFont;
	}
	CFontTrueType* CDocument::CreateTrueTypeFont(CFontCidTrueType* pCidFont)
	{
		for (int nIndex = 0, nCount = m_vCidTTFonts.size(); nIndex < nCount; nIndex++)
		{
			TFontInfo& oInfo = m_vCidTTFonts.at(nIndex);
			if (pCidFont == (CFontCidTrueType*)oInfo.pFont)
			{
				return CreateTrueTypeFont(oInfo.wsPath, oInfo.unIndex);
			}
		}

		return NULL;
	}
	CFont14* CDocument::GetDefaultCheckboxFont()
	{
		if (!m_pDefaultCheckBoxFont)
			m_pDefaultCheckBoxFont = new CFont14(m_pXref, this, EStandard14Fonts::standard14fonts_ZapfDingbats);

		return m_pDefaultCheckBoxFont;
	}
	char* CDocument::GetTTFontTag()
	{
		if (0 == m_sTTFontTag[0])
		{
			MemCpy((BYTE*)m_sTTFontTag, (BYTE*)"BAAAAA+", 7);
		}
		else
		{
			for (unsigned int nIndex = 0; nIndex <= 5; nIndex++)
			{
				m_sTTFontTag[nIndex] += 1;
				if (m_sTTFontTag[nIndex] > 'Z')
					m_sTTFontTag[nIndex] = 'A';
				else
					break;
			}
		}

		return m_sTTFontTag;
	}
    void CDocument::AddFreeTypeFont(CFontCidTrueType* pFont)
	{
		for (int nIndex = 0, nCount = m_vFreeTypeFonts.size(); nIndex < nCount; nIndex++)
		{
			if (pFont == m_vFreeTypeFonts.at(nIndex))
			{
				if (nIndex >= 10)
				{
					m_vFreeTypeFonts.erase(m_vFreeTypeFonts.begin() + nIndex);
					m_vFreeTypeFonts.insert(m_vFreeTypeFonts.begin(), pFont);
				}
				return;
			}
		}

		m_vFreeTypeFonts.insert(m_vFreeTypeFonts.begin(), pFont);

		int nFontsCount = m_vFreeTypeFonts.size();
		if (nFontsCount > MAX_OPENED_FT_FACES)
		{
			for (int nFontIndex = MAX_OPENED_FT_FACES; nFontIndex < nFontsCount; nFontIndex++)
			{
				CFontCidTrueType* pFont = m_vFreeTypeFonts.at(nFontIndex);
				pFont->CloseFontFace();
			}
			m_vFreeTypeFonts.erase(m_vFreeTypeFonts.begin() + MAX_OPENED_FT_FACES, m_vFreeTypeFonts.end());
		}
	}
    FT_Library CDocument::GetFreeTypeLibrary()
	{
		if (!m_pFreeTypeLibrary)
			FT_Init_FreeType(&m_pFreeTypeLibrary);

		return m_pFreeTypeLibrary;
	}
    CJbig2Global* CDocument::GetJbig2Global()
	{
		if (m_pJbig2 && m_pJbig2->GetImagesCount() > 4)
		{
			// Удалять не надо, т.к. объект удалится в CXref
			m_pJbig2->FlushStreams();
			m_pJbig2 = NULL;
		}

		if (!m_pJbig2)
			m_pJbig2 = new CJbig2Global(m_pXref);

		return m_pJbig2;
	}
    CShading* CDocument::CreateShading(CPage* pPage, double *pPattern, bool bAxial, unsigned char* pColors, unsigned char* pAlphas, double* pPoints, int nCount, CExtGrState*& pExtGrState)
	{
		pExtGrState = NULL;

		bool bNeedAlpha = false;
		unsigned char* pA = new unsigned char[3 * nCount];
		if (!pA)
			return NULL;

		for (int nIndex = 0; nIndex < nCount; nIndex++)
		{
			pA[3 * nIndex + 0] = pAlphas[nIndex];
			pA[3 * nIndex + 1] = pAlphas[nIndex];
			pA[3 * nIndex + 2] = pAlphas[nIndex];

			if (255 != pAlphas[nIndex])
				bNeedAlpha = true;
		}

		if (!bNeedAlpha)
		{
			delete[] pA;
			if (bAxial)
				return CreateAxialShading(pPattern[0], pPattern[1], pPattern[2], pPattern[3], pColors, pPoints, nCount);
			else
				return CreateRadialShading(pPattern[0], pPattern[1], pPattern[2], pPattern[3], pPattern[4], pPattern[5], pColors, pPoints, nCount);
		}

		// Создаем 2 shading-объекта, один цветной RGB, второй серый со значениями альфа-канала
		CShading* pColorShading = NULL;
		CShading* pAlphaShading = NULL;

		if (bAxial)
		{
			pColorShading = CreateAxialShading(pPattern[0], pPattern[1], pPattern[2], pPattern[3], pColors, pPoints, nCount);
			pAlphaShading = CreateAxialShading(pPattern[0], pPattern[1], pPattern[2], pPattern[3], pA, pPoints, nCount);
		}
		else
		{
			pColorShading = CreateRadialShading(pPattern[0], pPattern[1], pPattern[2], pPattern[3], pPattern[4], pPattern[5], pColors, pPoints, nCount);
			pAlphaShading = CreateRadialShading(pPattern[0], pPattern[1], pPattern[2], pPattern[3], pPattern[4], pPattern[5], pA, pPoints, nCount);
		}
		delete[] pA;

        if (!IsPDFA())
        {
            if (!m_pTransparencyGroup)
            {
                m_pTransparencyGroup = new CDictObject();
                m_pTransparencyGroup->Add("Type", "Group");
                m_pTransparencyGroup->Add("S", "Transparency");
                m_pTransparencyGroup->Add("CS", "DeviceRGB");
            }

            pPage->Add("Group", m_pTransparencyGroup);
        }
		double dWidth  = pPage->GetWidth();
		double dHeight = pPage->GetHeight();

		// Создаем графический объект, который будет альфа-маской
		CDictObject* pXObject = new CDictObject(m_pXref);
		pXObject->Add("Type", "XObject");
		pXObject->Add("Subtype", "Form");
		pXObject->Add("BBox", CArrayObject::CreateBox(0, 0, dWidth, dHeight));
        if (m_pTransparencyGroup)
            pXObject->Add("Group", m_pTransparencyGroup);
		CDictObject* pResources = new CDictObject();
		pXObject->Add("Resources", pResources);
		CDictObject* pResShadings = new CDictObject();
		pResources->Add("Shading", pResShadings);
		pResShadings->Add("S1", pAlphaShading);
		CStream* pStream = pXObject->GetStream();

		pStream->WriteStr("0 0 ");
		pStream->WriteReal(dWidth);
		pStream->WriteChar(' ');
		pStream->WriteReal(dHeight);
		pStream->WriteStr(" re\012W\012\n\012/S1 sh\012");

		// Создаем обект-маску для графического состояние
		CDictObject* pMask = new CDictObject();
		m_pXref->Add(pMask);
		pMask->Add("Type", "Mask");
		pMask->Add("S", "Luminosity");
		pMask->Add("G", pXObject);

		if (!IsPDFA())
		{
			// Создаем ExtGState объект, в который мы запишем альфа-маску
			pExtGrState = new CExtGrState(m_pXref);
			pExtGrState->Add("BM", "Normal");
			pExtGrState->Add("ca", 1);
			pExtGrState->Add("SMask", pMask);
		}

		return pColorShading;
	}
    CShading* CDocument::CreateAxialShading(double dX0, double dY0, double dX1, double dY1, unsigned char* pColors, double* pPoints, int nCount)
	{
		for (int nIndex = 0, nShadingsCount = m_vShadings.size(); nIndex < nShadingsCount; nIndex++)
		{
			CShading* pShading = m_vShadings.at(nIndex);
			if (shadingtype_Axial == pShading->GetShadingType()
				&& ((CAxialShading*)pShading)->Compare(dX0, dY0, dX1, dY1)
				&& pShading->CompareColors(pColors, pPoints, nCount, true)
				&& pShading->CompareExtend(true, true))
				return pShading;
		}

		CAxialShading* pShading = new CAxialShading(m_pXref, dX0, dY0, dX1, dY1);
		if (!pShading)
			return NULL;

		pShading->SetRgbColors(pColors, pPoints, nCount);
		pShading->SetExtend(true, true);

		m_vShadings.push_back(pShading);

		return pShading;
	}
    CShading* CDocument::CreateRadialShading(double dX0, double dY0, double dR0, double dX1, double dY1, double dR1, unsigned char* pColors, double* pPoints, int nCount)
	{
		for (int nIndex = 0, nShadingsCount = m_vShadings.size(); nIndex < nShadingsCount; nIndex++)
		{
			CShading* pShading = m_vShadings.at(nIndex);
			if (shadingtype_Radial == pShading->GetShadingType()
				&& ((CRadialShading*)pShading)->Compare(dX0, dY0, dR0, dX1, dY1, dR1)
				&& pShading->CompareColors(pColors, pPoints, nCount, true)
				&& pShading->CompareExtend(true, true))
				return pShading;
		}

		CRadialShading* pShading = new CRadialShading(m_pXref, dX0, dY0, dR0, dX1, dY1, dR1);
		if (!pShading)
			return NULL;

		pShading->SetRgbColors(pColors, pPoints, nCount);
		pShading->SetExtend(true, true);

		m_vShadings.push_back(pShading);

		return pShading;
	}
	CImageTilePattern*CDocument::CreateImageTilePattern(double dW, double dH, CImageDict* pImageDict, CMatrix* pMatrix, EImageTilePatternType eType, double dXStepSpacing, double dYStepSpacing)
	{
		return new CImageTilePattern(m_pXref, dW, dH, pImageDict, pMatrix, eType, dXStepSpacing, dYStepSpacing);
	}
	CImageTilePattern*CDocument::CreateHatchPattern(double dW, double dH, const BYTE& nR1, const BYTE& nG1, const BYTE& nB1, const BYTE& nAlpha1, const BYTE& nR2, const BYTE& nG2, const BYTE& nB2, const BYTE& nAlpha2, const std::wstring& wsHatch)
	{
		// TODO: Надо бы сделать мап, чтобы не создавать одинаковых паттернов

		CImageDict* pImage = CreateImage();
		BYTE* pBuffer = new BYTE[3 * HATCH_TX_SIZE * HATCH_TX_SIZE];
		if (!pBuffer)
			return NULL;

		TColor oColor1(nR1, nG1, nB1);
		TColor oColor2(nR2, nG2, nB2);
		agg::GetHatchPattern<TColor>(wsHatch, (TColor*)pBuffer, oColor1, oColor2);
		pImage->LoadRaw(pBuffer, 3 * HATCH_TX_SIZE * HATCH_TX_SIZE, HATCH_TX_SIZE, HATCH_TX_SIZE);
		delete[] pBuffer;

		if (255 != nAlpha1 || 255 != nAlpha2)
		{
			BYTE* pSMask = new BYTE[HATCH_TX_SIZE * HATCH_TX_SIZE];
			if (pSMask)
			{
				agg::GetHatchPattern<BYTE>(wsHatch, pSMask, nAlpha1, nAlpha2);
				pImage->LoadSMask(pSMask, (unsigned int)HATCH_TX_SIZE * HATCH_TX_SIZE, (unsigned int)HATCH_TX_SIZE, (unsigned int)HATCH_TX_SIZE);
				delete[] pSMask;
			}
		}

		return CreateImageTilePattern(dW, dH, pImage, NULL, imagetilepatterntype_Default);
	}
    CShading* CDocument::CreateAxialShading(CPage* pPage, double dX0, double dY0, double dX1, double dY1, unsigned char* pColors, unsigned char* pAlphas, double* pPoints, int nCount, CExtGrState*& pExtGrState)
	{
		double pPattern[] ={ dX0, dY0, dX1, dY1 };
		return CreateShading(pPage, pPattern, true, pColors, pAlphas, pPoints, nCount, pExtGrState);
	}
    CShading* CDocument::CreateRadialShading(CPage* pPage, double dX0, double dY0, double dR0, double dX1, double dY1, double dR1, unsigned char* pColors, unsigned char* pAlphas, double* pPoints, int nCount, CExtGrState*& pExtGrState)
	{
		double pPattern[] ={ dX0, dY0, dR0, dX1, dY1, dR1 };
		return CreateShading(pPage, pPattern, false, pColors, pAlphas, pPoints, nCount, pExtGrState);
	}
	CResourcesDict* CDocument::GetFieldsResources()
	{
		if (!m_pFieldsResources)
		{
			if (!CheckAcroForm())
				return NULL;
			
			m_pFieldsResources = new CResourcesDict(m_pXref, false, true);
			m_pAcroForm->Add("DR", m_pFieldsResources);
		}

		return m_pFieldsResources;
	}
	CTextField* CDocument::CreateTextField()
	{
		if (!CheckAcroForm())
			return NULL;

		CTextField* pField = new CTextField(m_pXref, this);
		if (!pField)
			return NULL;

		CArrayObject* ppFields = (CArrayObject*)m_pAcroForm->Get("Fields");
		ppFields->Add(pField);

		return pField;
	}
	CChoiceField* CDocument::CreateChoiceField()
	{
		if (!CheckAcroForm())
			return NULL;

		CChoiceField* pField = new CChoiceField(m_pXref, this);
		if (!pField)
			return NULL;

		CArrayObject* ppFields = (CArrayObject*)m_pAcroForm->Get("Fields");
		ppFields->Add(pField);

		return pField;
	}
	CSignatureField* CDocument::CreateSignatureField()
	{
		if (!CheckAcroForm())
			return NULL;

		CSignatureField* pField = new CSignatureField(m_pXref, this);
		if (!pField)
			return NULL;

		CArrayObject* ppFields = (CArrayObject*)m_pAcroForm->Get("Fields");
		ppFields->Add(pField);

		return pField;
	}
	CDateTimeField* CDocument::CreateDateTimeField()
	{
		if (!CheckAcroForm())
			return NULL;
		
		CDateTimeField* pField = new CDateTimeField(m_pXref, this);
		if (!pField)
			return NULL;
		
		CArrayObject* ppFields = (CArrayObject*)m_pAcroForm->Get("Fields");
		ppFields->Add(pField);
		
		return pField;
	}
	CCheckBoxField* CDocument::CreateCheckBoxField()
	{
		if (!CheckAcroForm())
			return NULL;

		CCheckBoxField* pField = new CCheckBoxField(m_pXref, this);
		if (!pField)
			return NULL;

		CArrayObject* ppFields = (CArrayObject*)m_pAcroForm->Get("Fields");
		ppFields->Add(pField);

		return pField;
	}
	CRadioGroupField* CDocument::GetRadioGroupField(const std::wstring& wsGroupName)
	{
		CRadioGroupField* pField = FindRadioGroupField(wsGroupName);
		if (!pField)
		{
			if (!CheckAcroForm())
				return NULL;

			pField = new CRadioGroupField(m_pXref, this);
			if (!pField)
				return NULL;

			m_vRadioGroups.push_back(pField);

			pField->SetFieldName(wsGroupName);
			CArrayObject* ppFields = (CArrayObject*)m_pAcroForm->Get("Fields");
			ppFields->Add(pField);
		}

		return pField;
	}
	CRadioGroupField* CDocument::FindRadioGroupField(const std::wstring& wsGroupName)
	{
		CRadioGroupField* pField = NULL;
		for (unsigned int unIndex = 0, unCount = m_vRadioGroups.size(); unIndex < unCount; ++unIndex)
		{
			pField = m_vRadioGroups.at(unIndex);

			if (pField->GetFieldName() == wsGroupName)
				return pField;
		}

		return NULL;
	}
	CPictureField* CDocument::CreatePictureField()
	{
		if (!CheckAcroForm())
			return NULL;

		CPictureField* pField = new CPictureField(m_pXref, this);
		if (!pField)
			return NULL;

		CArrayObject* ppFields = (CArrayObject*)m_pAcroForm->Get("Fields");
		ppFields->Add(pField);

		return pField;
	}
	bool CDocument::HasImage(const std::wstring& wsImagePath, BYTE nAlpha)
	{
		for (size_t i = 0, nSize = m_vImages.size(); i < nSize; ++i)
		{
			if (m_vImages[i].wsImagePath == wsImagePath && m_vImages[i].nAlpha == nAlpha)
				return true;
		}
		return false;
	}
	CImageDict* CDocument::GetImage(const std::wstring& wsImagePath, BYTE nAlpha)
	{
		for (size_t i = 0, nSize = m_vImages.size(); i < nSize; ++i)
		{
			if (m_vImages[i].wsImagePath == wsImagePath && m_vImages[i].nAlpha == nAlpha)
			{
				m_pCurImage = m_vImages[i].pImage;
				return m_vImages[i].pImage;
			}
		}
		return NULL;
	}
	void CDocument::AddImage(const std::wstring& wsImagePath, BYTE nAlpha, CImageDict* pImage)
	{
		if (!pImage)
			return;
		m_pCurImage = pImage;
		m_vImages.push_back({wsImagePath, nAlpha, pImage});
	}
	void CDocument::AddObject(CObjectBase* pObj)
	{
		m_pXref->Add(pObj);
	}
	void CDocument::RemoveObj(CObjectBase* pObj)
	{
		std::map<int, CAnnotation*>::iterator it1 = std::find_if(m_mAnnotations.begin(), m_mAnnotations.end(), [pObj](const std::pair<int, CAnnotation*>& t){ return t.second == pObj; });
		if (it1 != m_mAnnotations.end())
			m_mAnnotations.erase(it1);
		std::map<int, CPage*>::iterator it2 = std::find_if(m_mEditPages.begin(), m_mEditPages.end(), [pObj](const std::pair<int, CPage*>& t){ return t.second == pObj; });
		if (it2 != m_mEditPages.end())
			m_mEditPages.erase(it2);
		if (m_pCurPage == pObj)
			m_pCurPage = NULL;
		m_pXref->Remove(pObj);
	}
	bool CDocument::CheckFieldName(CFieldBase* pField, const std::string& sName)
	{
		CFieldBase* pBase = m_mFields[sName];
		if (pBase)
		{
			if (!pBase->GetKidsCount())
			{
				CFieldBase* pParent = new CFieldBase(m_pXref, this);
				pParent->SetFieldName(sName, true);
				pParent->Add("Ff", pBase->GetFieldFlag());
				pParent->Add("FT", pBase->GetFieldType());

				CObjectBase* pT = pBase->Get("T");
				if (pT && pT->GetType() == object_type_STRING)
					pParent->Add("T", pT->Copy());

				CObjectBase* pV = pBase->Get("V");
				if (pV && pV->GetType() == object_type_STRING)
					pParent->Add("V", pV->Copy());

				CObjectBase* pAA = pBase->Get("AA");
				if (pAA)
					pParent->Add("AA", pAA->Copy());

				CTextField* pTextField = dynamic_cast<CTextField*>(pBase);
				int nMaxLen = 0;
				if (pTextField && 0 != (nMaxLen = pTextField->GetMaxLen()))
				{
					pBase->Remove("MaxLen");
					pParent->Add("MaxLen", nMaxLen);
				}

				pBase->SetParent(pParent);
				pBase->ClearKidRecords();
				pParent->AddKid(pBase);

				m_mFields[sName] = pParent;
				pField->ClearKidRecords();
				pField->SetParent(pParent);
				pParent->AddKid(pField);

				CChoiceField* pChoice = dynamic_cast<CChoiceField*>(pBase);
				if (pChoice)
					pChoice->UpdateSelectedIndexToParent();

				pParent->UpdateKidsPlaceHolder();
			}
			else
			{
				pField->ClearKidRecords();
				pField->SetParent(pBase);
				pBase->AddKid(pField);

				CChoiceField* pChoice = dynamic_cast<CChoiceField*>(pBase);
				if (pChoice)
					pChoice->UpdateSelectedIndexToParent();

				pBase->UpdateKidsPlaceHolder();
			}

			return true;
		}
		else
		{
			m_mFields[sName] = pField;
			return false;
		}
	}
	bool CDocument::CheckAcroForm()
	{
		if (!m_pXref || !m_pCatalog)
			return false;

		if (!m_pAcroForm)
		{
			m_pAcroForm = new CDictObject();
			if (!m_pAcroForm)
				return false;

			m_pCatalog->Add("AcroForm", m_pAcroForm);
			m_pAcroForm->Add("Fields", new CArrayObject());
		}

		return (!!m_pAcroForm);
	}
	void CDocument::SetAcroForm(CDictObject* pObj)
	{
		if (!m_pXref || !m_pCatalog)
			return;
		m_pCatalog->Add("AcroForm", pObj);
		m_pAcroForm = pObj;
	}
	CResourcesDict* CDocument::CreateResourcesDict(bool bInline, bool bProcSet)
	{
		return new CResourcesDict(m_pXref, bInline, bProcSet);
	}
	bool CDocument::CreatePageTree(CXref* pXref, CPageTree* pPageTree)
	{
		if (!pPageTree || !EditXref(pXref))
			return false;

		if (!m_pPageTree)
			m_pPageTree = pPageTree;
		else
			m_pPageTree->Join(pPageTree);

		return true;
	}
	bool CDocument::EditPdf(int nPosLastXRef, int nSizeXRef, CXref* pXref, CCatalog* pCatalog, CEncryptDict* pEncrypt, int nFormField)
	{
		if (!pXref || !pCatalog)
			return false;
		Close();

		m_pXref = new CXref(this, nSizeXRef);
		if (!m_pXref)
			return false;
		m_pXref->SetPrevAddr(nPosLastXRef);
		m_pLastXref = m_pXref;

		m_pTrailer = m_pXref->GetTrailer();
		if (!m_pTrailer)
			return false;

		SetCompressionMode(COMP_ALL);

		m_pCatalog = pCatalog;
		pXref->SetPrev(m_pLastXref);
		m_pLastXref = pXref;

		CObjectBase* pAcroForm = m_pCatalog->Get("AcroForm");
		if (pAcroForm && pAcroForm->GetType() == object_type_DICT)
			m_pAcroForm = (CDictObject*)pAcroForm;

		if (pEncrypt)
		{
			m_pEncryptDict = pEncrypt;
			m_bEncrypt = true;
		}

		m_unFormFields = nFormField;
		return true;
	}
	bool CDocument::EditResources(CXref* pXref, CResourcesDict* pResources)
	{
		if (!pResources || !EditXref(pXref))
			return false;

		CheckAcroForm();
		m_pAcroForm->Add("DR", pResources);
		m_pFieldsResources = pResources;
		return true;
	}
	std::pair<int, int> CDocument::GetPageRef(int nPageIndex)
	{
		std::pair<int, int> pRes = std::make_pair(0, 0);
		if (!m_pPageTree)
			return pRes;

		CObjectBase* pObj = m_pPageTree->GetObj(nPageIndex);
		if (pObj)
		{
			pRes.first  = pObj->GetObjId();
			pRes.second = pObj->GetGenNo();
		}

		return pRes;
	}
	bool CDocument::EditPage(CXref* pXref, CPage* pPage, int nPageIndex)
	{
		if (!pPage || !EditXref(pXref))
			return false;

		pPage->AddContents(m_pXref);
#ifndef FILTER_FLATE_DECODE_DISABLED
		if (m_unCompressMode & COMP_TEXT)
			pPage->SetFilter(STREAM_FILTER_FLATE_DECODE);
#endif

		m_pCurPage = pPage;
		m_mEditPages[nPageIndex] = pPage;

		if (m_pPageTree)
			m_pPageTree->ReplacePage(nPageIndex, pPage);

		return true;
	}
	void CDocument::FixEditPage(CPage* _pPage, int nPageIndex)
	{
		CPage* pPage = _pPage ? _pPage : m_mEditPages[nPageIndex];
		if (!pPage)
			return;

		pPage->AddContents(m_pXref);
#ifndef FILTER_FLATE_DECODE_DISABLED
		if (m_unCompressMode & COMP_TEXT)
			pPage->SetFilter(STREAM_FILTER_FLATE_DECODE);
#endif
	}
	void CDocument::AddEditPage(CPage* pPage, int nPageIndex)
	{
		m_mEditPages[nPageIndex] = pPage;
	}
	bool CDocument::EditAnnot(CXref* pXref, CAnnotation* pAnnot, int nID)
	{
		if (!pAnnot || !EditXref(pXref))
			return false;

		pAnnot->SetXref(m_pXref);
		m_mAnnotations[nID] = pAnnot;

		return true;
	}
	void CDocument::AddParent(int nID, CDictObject* pParent)
	{
		m_mParents[nID] = pParent;
	}
	CDictObject* CDocument::CreateParent(int nID)
	{
		CDictObject* pParent = new CDictObject();
		m_pXref->Add(pParent);
		m_mParents[nID] = pParent;
		return pParent;
	}
	bool CDocument::EditParent(CXref* pXref, CDictObject* pParent, int nID)
	{
		if (!pParent || !EditXref(pXref))
			return false;
		m_mParents[nID] = pParent;
		return true;
	}
	bool CDocument::EditXref(CXref* pXref)
	{
		if (!pXref)
			return true;

		pXref->SetPrev(m_pLastXref);
		m_pLastXref = pXref;

		return true;
	}
	bool CDocument::DeleteAnnot(int nObjNum, int nObjGen)
	{
		if (m_pCurPage && m_pCurPage->DeleteAnnotation(nObjNum))
		{
			if (m_pAcroForm)
			{
				CArrayObject* ppFields = (CArrayObject*)m_pAcroForm->Get("Fields");
				for (int i = 0; i < ppFields->GetCount(); ++i)
				{
					CObjectBase* pObj = ppFields->Get(i);
					if (pObj->GetObjId() == nObjNum)
					{
						CObjectBase* pDelete = ppFields->Remove(i);
						RELEASEOBJECT(pDelete);
						break;
					}
				}
			}

			CXref* pXref = new CXref(this, nObjNum, nObjGen);
			if (!pXref)
				return false;

			pXref->SetPrev(m_pLastXref);
			m_pLastXref = pXref;
			return true;
		}
		return false;
	}
	CAnnotation* CDocument::GetAnnot(int nID)
	{
		std::map<int, CAnnotation*>::iterator p = m_mAnnotations.find(nID);
		if (p != m_mAnnotations.end())
			return p->second;
		return NULL;
	}
	CDictObject* CDocument::GetParent(int nID)
	{
		std::map<int, CDictObject*>::iterator p = m_mParents.find(nID);
		if (p != m_mParents.end())
			return p->second;
		return NULL;
	}
	std::string CDocument::SetParentKids(int nParentID)
	{
		CDictObject* pParent = GetParent(nParentID);
		if (!pParent)
			return "";

		for (auto it = m_mAnnotations.begin(); it != m_mAnnotations.end(); it++)
		{
			CAnnotation* pAnnot = it->second;
			if (pAnnot->GetAnnotationType() != AnnotWidget)
				continue;

			CWidgetAnnotation* pWidget = (CWidgetAnnotation*)pAnnot;
			int nWidgetParentID = pWidget->GetParentID();
			if (nWidgetParentID != nParentID)
				continue;

			pWidget->SetParent(pParent);

			CObjectBase* pFT = pParent->Get("FT");
			CObjectBase* pWidgetFT = pWidget->Get("FT");
			if (!pFT && pParent->Get("T") && pWidgetFT)
				pParent->Add("FT", pWidgetFT->Copy());

			CArrayObject* pKids = dynamic_cast<CArrayObject*>(pParent->Get("Kids"));
			if (!pKids)
			{
				pKids = new CArrayObject();
				pParent->Add("Kids", pKids);
			}
			bool bReplase = false;
			int nID = pWidget->GetObjId();
			if (nID > 0)
			{
				for (int i = 0; i < pKids->GetCount(); ++i)
				{
					CObjectBase* pKid = pKids->Get(i);
					if (pKid->GetObjId() == nID)
					{
						pKids->Insert(pKid, pWidget, true);
						bReplase = true;
						break;
					}
				}
			}
			if (!bReplase)
				pKids->Add(pWidget);
		}

		CObjectBase* pFT = pParent->Get("FT");
		if (pFT && pFT->GetType() == object_type_NAME)
			return ((CNameObject*)pFT)->Get();
		return "";
	}
	bool CDocument::EditCO(const std::vector< std::pair<int, int> >& arrCO)
	{
		if (arrCO.empty())
			return true;

		if (!CheckAcroForm())
			return false;

		CArrayObject* pArray = new CArrayObject();
		if (!pArray)
			return false;

		m_pAcroForm->Add("CO", pArray);

		for (std::pair<int, int> CO : arrCO)
		{
			CDictObject* pObj = GetParent(CO.first);
			if (pObj)
				pArray->Add(pObj);
			else
			{
				CAnnotation* pAnnot = GetAnnot(CO.first);
				if (pAnnot)
					pArray->Add(pAnnot);
				else if (CO.second >= 0)
				{
					PdfWriter::CObjectBase* pBase = new PdfWriter::CObjectBase();
					pBase->SetRef(CO.first, CO.second);
					pArray->Add(new PdfWriter::CProxyObject(pBase, true));
				}
			}
		}

		return true;
	}
	CPage* CDocument::AddPage(int nPageIndex, CPage* _pNewPage)
	{
		if (!m_pPageTree)
			return NULL;

		CPage* pNewPage = _pNewPage ? _pNewPage : new CPage(m_pXref, NULL, this);
		if (!pNewPage)
			return NULL;
		bool bRes = m_pPageTree->InsertPage(nPageIndex, pNewPage);
		if (!bRes)
			return NULL;

		if (!_pNewPage)
			pNewPage->SetFilter(STREAM_FILTER_FLATE_DECODE);
		m_pCurPage = pNewPage;
		return pNewPage;
	}
	bool CDocument::DeletePage(int nPageIndex)
	{
		if (!m_pPageTree)
			return false;

		CObjectBase* pObj = m_pPageTree->RemovePage(nPageIndex);
		if (pObj)
		{
			if (pObj->IsIndirect())
				return true;
			if (!pObj->GetObjId())
			{
				delete pObj;
				return true;
			}
			CXref* pXref = new CXref(this, pObj->GetObjId(), pObj->GetGenNo());
			delete pObj;
			if (!pXref)
				return false;

			pXref->SetPrev(m_pLastXref);
			m_pLastXref = pXref;
			return true;
		}
		return false;
	}
	bool CDocument::MovePage(int nPageIndex, int nPos)
	{
		if (m_pPageTree)
		{
			CObjectBase* pObj = m_pPageTree->RemovePage(nPageIndex);
			if (pObj)
			{
				if (pObj->GetType() == object_type_UNKNOWN)
				{
					CObjectBase* pObjTemp = pObj->Copy();
					delete pObj;
					pObj = pObjTemp;
				}
				return m_pPageTree->InsertPage(nPos, pObj);
			}
		}
		return false;
	}
	bool CDocument::AddToFile(const std::wstring& wsPath, CXref* pXref, CDictObject* pTrailer, CXref* pInfoXref, CInfoDict* pInfo)
	{
		if (!pTrailer || wsPath.empty())
			return false;

		CFileStream* pStream = new CFileStream();
		if (!pStream)
			return false;

		if (!pStream->OpenFile(wsPath, false))
		{
			RELEASEOBJECT(pStream);
			return false;
		}

		m_pTrailer = pTrailer;
		m_pInfo = pInfo;
		if (!m_pInfo)
			m_pInfo = new PdfWriter::CInfoDict(m_pXref);

		std::wstring sCreator = NSSystemUtils::GetEnvVariable(NSSystemUtils::gc_EnvApplicationName);
		if (sCreator.empty())
			sCreator = NSSystemUtils::gc_EnvApplicationNameDefault;
		std::string sCreatorA = U_TO_UTF8(sCreator);

#if defined(INTVER)
		sCreatorA += "/";
		sCreatorA += VALUE2STR(INTVER);
#endif

		const char* cCreator = m_pInfo->GetInfo(InfoProducer);
		m_pInfo->SetInfo(InfoCreator, cCreator ? cCreator : sCreatorA.c_str());
		m_pInfo->SetInfo(InfoProducer, sCreatorA.c_str());

		if (pInfoXref)
		{
			pInfoXref->SetPrev(m_pLastXref);
			m_pLastXref = pInfoXref;
		}
		pXref->SetPrev(m_pLastXref);
		m_pLastXref = pXref;

		// Вторая часть идентификатора должна обновляться
		CObjectBase* pID = m_pTrailer->Get("ID");
		if ((pID && pID->GetType() == object_type_ARRAY) || !m_vMetaOForms.empty())
		{
			BYTE arrId[16];
			CEncryptDict::CreateId(m_pInfo, m_pXref, (BYTE*)arrId);

			CArrayObject* pArrID = (CArrayObject*)pID;
			if (pArrID)
			{
				CObjectBase* pObject = pArrID->Get(1, false);
				pArrID->Insert(pObject, new CBinaryObject(arrId, 16), true);
			}
			else
			{
				pArrID = new CArrayObject();
				m_pTrailer->Add("ID", pArrID);

				pArrID->Add(new CBinaryObject(arrId, 16));
				pArrID->Add(new CBinaryObject(arrId, 16));
			}

			for (int i = 0; i < m_vMetaOForms.size(); ++i)
				m_vMetaOForms[i]->Add("ID", new CBinaryObject(arrId, 16));
		}

		CEncrypt* pEncrypt = NULL;
		if (m_bEncrypt)
			pEncrypt = m_pEncryptDict->GetEncrypt();

		// Если m_pTrailer поток перекрестных ссылок, то при дозаписи тоже должен быть поток
		m_pTrailer->Remove("XRefStm");
		bool bNeedStreamXRef = false;
		pStream->WriteChar('\n');
		if (m_pTrailer->Get("Type"))
		{
			m_pTrailer->Remove("Length");
			m_pTrailer->Remove("Filter");
			m_pTrailer->Remove("DecodeParms");
			m_pTrailer->Remove("F");
			m_pTrailer->Remove("FFilter");
			m_pTrailer->Remove("FDecodeParms");
			m_pTrailer->Remove("DL");
			m_pTrailer->Remove("Type");
			m_pTrailer->Remove("Index");
			m_pTrailer->Remove("W");
			bNeedStreamXRef = true;

			m_pLastXref->WriteToStream(pStream, pEncrypt, bNeedStreamXRef);
		}
		else
			m_pLastXref->WriteToStream(pStream, pEncrypt);

		RELEASEOBJECT(pStream);
		unsigned int nSizeXRef = m_pXref->GetSizeXRef();
		m_pXref = m_pLastXref;
		Sign(wsPath, nSizeXRef, bNeedStreamXRef);
		RELEASEOBJECT(m_pEncryptDict);

		return true;
	}
	void CDocument::Sign(const TRect& oRect, CImageDict* pImage, ICertificate* pCertificate)
	{
		m_vSignatures.push_back({ oRect, m_pCurPage ? m_pCurPage : m_pPageTree->GetPage(0), pImage, pCertificate });
	}
	void CDocument::Sign(const std::wstring& wsPath, unsigned int nSizeXRef, bool bNeedStreamXRef)
	{
		unsigned int nPrevAddr = m_pXref->GetPrevAddr();
		std::vector<CXref*> vXRefForWrite;
		for (unsigned int i = 0; i < m_vSignatures.size(); i++)
		{
			CXref* pXrefBefore = m_pXref;
			m_pXref = new CXref(this, nSizeXRef);
			if (!m_pXref)
			{
				m_pXref = pXrefBefore;
				continue;
			}
			m_pXref->SetPrevAddr(nPrevAddr);

			CSignatureField* pField = CreateSignatureField();
			if (!pField)
			{
				RELEASEOBJECT(m_pXref);
				m_pXref = pXrefBefore;
				continue;
			}

			m_pAcroForm->Add("SigFlags", 3);
			pField->GetSignatureDict()->SetCert(m_vSignatures[i].pCertificate);
			pField->GetSignatureDict()->SetDate();
			pField->AddPageRect(m_vSignatures[i].pPage, m_vSignatures[i].oRect);
			pField->Add("F", 132);
			pField->SetFieldName("Sig" + std::to_string(i + m_unFormFields + 1));
			if (m_vSignatures[i].pImage)
				pField->SetAppearance(m_vSignatures[i].pImage);

			CFileStream* pStream = new CFileStream();
			if (!pStream || !pStream->OpenFile(wsPath, false))
			{
				RELEASEOBJECT(m_pXref);
				m_pXref = pXrefBefore;
				continue;
			}

			CXref* pXrefCatalog = new CXref(this, m_pCatalog->GetObjId());
			if (pXrefCatalog)
			{
				pXrefCatalog->Add(m_pCatalog->Copy(), m_pCatalog->GetGenNo());
				pXrefCatalog->SetPrev(m_pXref);
			}

			CXref* pXrefPage = new CXref(this, m_vSignatures[i].pPage->GetObjId());
			if (pXrefPage)
			{
				pXrefPage->Add(m_vSignatures[i].pPage->Copy(), m_vSignatures[i].pPage->GetGenNo());
				pXrefPage->SetPrev(pXrefCatalog);
			}

			CXref* pXref = new CXref(this, 0, 65535);
			if (pXref)
			{
				pXref->SetPrev(pXrefPage);
				CDictObject* pTrailer = pXref->GetTrailer();
				m_pTrailer->Copy(pTrailer);

				CEncrypt* pEncrypt = NULL;
				if (m_bEncrypt && m_pEncryptDict)
					pEncrypt = m_pEncryptDict->GetEncrypt();

				pXref->WriteToStream(pStream, pEncrypt, bNeedStreamXRef);
				nPrevAddr = pXref->GetPrevAddr();
				nSizeXRef = m_pXref->GetSizeXRef();
				vXRefForWrite.push_back(pXref);
			}

			RELEASEOBJECT(pStream);
			pStream = new CFileStream();
			if (pStream && pStream->OpenFile(wsPath, false))
				pField->GetSignatureDict()->WriteToStream(pStream, pStream->Size());

			m_pXref = pXrefBefore;
			RELEASEOBJECT(pStream);
		}
		for (CXref* XRef : vXRefForWrite)
			RELEASEOBJECT(XRef);
		vXRefForWrite.clear();
	}
	void CDocument::AddShapeXML(const std::string& sXML)
	{
		CDictObject* pResources = (CDictObject*)m_pCurPage->GetResourcesItem();
		if (!pResources)
		{
			pResources = new CResourcesDict(NULL, true, false);
			m_pCurPage->Add("Resources", pResources);
		}
		CDictObject* pProperties = (CDictObject*)pResources->Get("Properties");
		if (!pProperties)
		{
			pProperties = new CDictObject();
			pResources->Add("Properties", pProperties);
		}
		CObjectBase* pObj = pProperties->Get("OShapes");
		if (pObj && pObj->GetType() != object_type_DICT)
		{
			pProperties->Remove("OShapes");
			pObj = NULL;
		}

		CBinaryObject* sID = NULL;
		CArrayObject* pID = (CArrayObject*)m_pTrailer->Get("ID");
		if (!pID)
		{
			BYTE arrId[16];
			CEncryptDict::CreateId(m_pInfo, m_pXref, (BYTE*)arrId);

			pID = new CArrayObject();
			m_pTrailer->Add("ID", pID);

			pID->Add(new CBinaryObject(arrId, 16));
			pID->Add(new CBinaryObject(arrId, 16));

			sID = new CBinaryObject(arrId, 16);
		}
		else
			sID = (CBinaryObject*)pID->Get(1)->Copy();

		CDictObject* pMetaOForm = (CDictObject*)pObj;
		if (!pMetaOForm)
		{
			pMetaOForm = new CDictObject();
			m_pXref->Add(pMetaOForm);
			pMetaOForm->Add("Type", "OShapes");
			pProperties->Add("OShapes", pMetaOForm);
			m_vMetaOForms.push_back(pMetaOForm);
			pMetaOForm->Add("IDF", sID->Copy());
			pMetaOForm->Add("ID", sID->Copy());
		}
		CArrayObject* pArrayMeta = (CArrayObject*)pMetaOForm->Get("Metadata");
		if (!pArrayMeta)
		{
			pArrayMeta = new CArrayObject();
			pMetaOForm->Add("Metadata", pArrayMeta);
			CArrayObject* pArrayImage = new CArrayObject();
			pMetaOForm->Add("Image", pArrayImage);
		}
		CStringObject* pXML = new CStringObject();
		pXML->Set(sXML.c_str(), false, false, -1);
		pArrayMeta->Add(pXML);

		CDictObject* pBDC = new CDictObject();
		pBDC->Add("MCID", pArrayMeta->GetCount() - 1);
		pBDC->Add("IDF", sID);
		m_pCurPage->BeginMarkedContentDict("OShapes", pBDC);
		RELEASEOBJECT(pBDC);
	}
	void CDocument::EndShapeXML()
	{
		CDictObject* pResources = (CDictObject*)m_pCurPage->GetResourcesItem();
		if (!pResources)
			return;
		CDictObject* pProperties = (CDictObject*)pResources->Get("Properties");
		if (!pProperties)
			return;
		CObjectBase* pObj = pProperties->Get("OShapes");
		if (!pObj || pObj->GetType() != object_type_DICT)
			return;
		CDictObject* pMetaOForm = (CDictObject*)pObj;
		CArrayObject* pArrayImage = (CArrayObject*)pMetaOForm->Get("Image");
		if (!pArrayImage)
			return;

		pObj = m_pCurImage;
		if (!pObj)
			pObj = new PdfWriter::CNullObject();
		pArrayImage->Add(pObj);

		m_pCurPage->EndMarkedContent();
	}
	void CDocument::ClearPage()
	{
		m_pCurPage->ClearContent(m_pXref);
		m_pCurPage->StartTransform(1, 0, 0, 1, 0, 0);
	}
	void CDocument::ClearPageFull()
	{
		m_pCurPage->ClearContentFull(m_pXref);
	}
}