mirror of
https://github.com/ONLYOFFICE/core.git
synced 2026-07-11 03:42:47 +08:00
1823 lines
47 KiB
C++
1823 lines
47 KiB
C++
/*
|
||
* (c) Copyright Ascensio System SIA 2010-2017
|
||
*
|
||
* This program is a free software product. You can redistribute it and/or
|
||
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
||
* version 3 as published by the Free Software Foundation. In accordance with
|
||
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
|
||
* that Ascensio System SIA expressly excludes the warranty of non-infringement
|
||
* of any third-party rights.
|
||
*
|
||
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
||
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
||
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
||
*
|
||
* You can contact Ascensio System SIA at Lubanas st. 125a-25, Riga, Latvia,
|
||
* EU, LV-1021.
|
||
*
|
||
* The interactive user interfaces in modified source and object code versions
|
||
* of the Program must display Appropriate Legal Notices, as required under
|
||
* Section 5 of the GNU AGPL version 3.
|
||
*
|
||
* Pursuant to Section 7(b) of the License you must retain the original Product
|
||
* logo when distributing the program. Pursuant to Section 7(e) we decline to
|
||
* grant you any rights under trademark law for use of our trademarks.
|
||
*
|
||
* All the Product's GUI elements, including illustrations and icon sets, as
|
||
* well as technical writing content are licensed under the terms of the
|
||
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
|
||
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
||
*
|
||
*/
|
||
#include <stdlib.h>
|
||
#include <math.h>
|
||
#include "MemoryUtils.h"
|
||
#include "List.h"
|
||
#include "Object.h"
|
||
#include "Catalog.h"
|
||
#include "Graphics.h"
|
||
#include "GFont.h"
|
||
#include "Lexer.h"
|
||
#include "Annot.h"
|
||
#include "Dict.h"
|
||
|
||
//-------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
#define annotFlagHidden 0x0002
|
||
#define annotFlagPrint 0x0004
|
||
#define annotFlagNoView 0x0020
|
||
|
||
#define fieldFlagReadOnly 0x00000001
|
||
#define fieldFlagRequired 0x00000002
|
||
#define fieldFlagNoExport 0x00000004
|
||
#define fieldFlagMultiline 0x00001000
|
||
#define fieldFlagPassword 0x00002000
|
||
#define fieldFlagNoToggleToOff 0x00004000
|
||
#define fieldFlagRadio 0x00008000
|
||
#define fieldFlagPushbutton 0x00010000
|
||
#define fieldFlagCombo 0x00020000
|
||
#define fieldFlagEdit 0x00040000
|
||
#define fieldFlagSort 0x00080000
|
||
#define fieldFlagFileSelect 0x00100000
|
||
#define fieldFlagMultiSelect 0x00200000
|
||
#define fieldFlagDoNotSpellCheck 0x00400000
|
||
#define fieldFlagDoNotScroll 0x00800000
|
||
#define fieldFlagComb 0x01000000
|
||
#define fieldFlagRichText 0x02000000
|
||
#define fieldFlagRadiosInUnison 0x02000000
|
||
#define fieldFlagCommitOnSelChange 0x04000000
|
||
|
||
#define fieldQuadLeft 0
|
||
#define fieldQuadCenter 1
|
||
#define fieldQuadRight 2
|
||
|
||
namespace PdfReader
|
||
{
|
||
//-------------------------------------------------------------------------------------------------------------------------------
|
||
// AnnotBorderStyle
|
||
//-------------------------------------------------------------------------------------------------------------------------------
|
||
AnnotBorderStyle::AnnotBorderStyle(AnnotBorderType eType, double dWidth, double *pDash, int nDashLength, double dR, double dG, double dB)
|
||
{
|
||
m_eType = eType;
|
||
m_dWidth = dWidth;
|
||
m_pDash = pDash;
|
||
m_nDashLength = nDashLength;
|
||
m_dR = dR;
|
||
m_dG = dG;
|
||
m_dB = dB;
|
||
}
|
||
AnnotBorderStyle::~AnnotBorderStyle()
|
||
{
|
||
MemUtilsFree(m_pDash);
|
||
}
|
||
//-------------------------------------------------------------------------------------------------------------------------------
|
||
// Annot
|
||
//-------------------------------------------------------------------------------------------------------------------------------
|
||
Annot::Annot(GlobalParams *pGlobalParams, XRef *pXref, Dict *pAcroForm, Dict *pDict, Ref *pRef)
|
||
{
|
||
m_pGlobalParams = pGlobalParams;
|
||
|
||
m_bValid = true;
|
||
m_pXref = pXref;
|
||
m_oRef = *pRef;
|
||
m_seType = NULL;
|
||
m_seAppBuffer = NULL;
|
||
m_pBorderStyle = NULL;
|
||
|
||
// SubType
|
||
Object oDictItem;
|
||
if (pDict->Search("Subtype", &oDictItem)->IsName())
|
||
{
|
||
m_seType = new StringExt(oDictItem.GetName());
|
||
}
|
||
oDictItem.Free();
|
||
|
||
// Rect
|
||
if (pDict->Search("Rect", &oDictItem)->IsArray() && oDictItem.ArrayGetLength() == 4)
|
||
{
|
||
Object oTemp;
|
||
m_dMinX = m_dMinY = m_dMaxX = m_dMaxY = 0;
|
||
if (oDictItem.ArrayGet(0, &oTemp)->IsNum())
|
||
{
|
||
m_dMinX = oTemp.GetNum();
|
||
}
|
||
oTemp.Free();
|
||
|
||
if (oDictItem.ArrayGet(1, &oTemp)->IsNum())
|
||
{
|
||
m_dMinY = oTemp.GetNum();
|
||
}
|
||
oTemp.Free();
|
||
|
||
if (oDictItem.ArrayGet(2, &oTemp)->IsNum())
|
||
{
|
||
m_dMaxX = oTemp.GetNum();
|
||
}
|
||
oTemp.Free();
|
||
|
||
if (oDictItem.ArrayGet(3, &oTemp)->IsNum())
|
||
{
|
||
m_dMaxY = oTemp.GetNum();
|
||
}
|
||
oTemp.Free();
|
||
|
||
if (m_dMinX > m_dMaxX)
|
||
{
|
||
double dTemp = m_dMinX;
|
||
m_dMinX = m_dMaxX;
|
||
m_dMaxX = dTemp;
|
||
}
|
||
|
||
if (m_dMinY > m_dMaxY)
|
||
{
|
||
double dTemp = m_dMinY;
|
||
m_dMinY = m_dMaxY;
|
||
m_dMaxY = dTemp;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// TO DO: Error "Bad bounding box for annotation"
|
||
m_bValid = false;
|
||
}
|
||
oDictItem.Free();
|
||
|
||
// F (flags)
|
||
if (pDict->Search("F", &oDictItem)->IsInt())
|
||
{
|
||
m_nFlags = oDictItem.GetInt();
|
||
}
|
||
else
|
||
{
|
||
m_nFlags = 0;
|
||
}
|
||
oDictItem.Free();
|
||
|
||
//Border style
|
||
|
||
AnnotBorderType eBorderType = annotBorderSolid;
|
||
double dBorderWidth = 1;
|
||
double *pBorderDash = NULL;
|
||
int nBorderDashLength = 0;
|
||
double dBorderR = 0;
|
||
double dBorderG = 0;
|
||
double dBorderB = 1;
|
||
if (pDict->Search("BS", &oDictItem)->IsDict())
|
||
{
|
||
Object oTemp;
|
||
if (oDictItem.DictLookup("S", &oTemp)->IsName())
|
||
{
|
||
if (oTemp.IsName("S"))
|
||
{
|
||
eBorderType = annotBorderSolid;
|
||
}
|
||
else if (oTemp.IsName("D"))
|
||
{
|
||
eBorderType = annotBorderDashed;
|
||
}
|
||
else if (oTemp.IsName("B"))
|
||
{
|
||
eBorderType = annotBorderBeveled;
|
||
}
|
||
else if (oTemp.IsName("I"))
|
||
{
|
||
eBorderType = annotBorderInset;
|
||
}
|
||
else if (oTemp.IsName("U"))
|
||
{
|
||
eBorderType = annotBorderUnderlined;
|
||
}
|
||
}
|
||
oTemp.Free();
|
||
|
||
if (oDictItem.DictLookup("W", &oTemp)->IsNum())
|
||
{
|
||
dBorderWidth = oTemp.GetNum();
|
||
}
|
||
oTemp.Free();
|
||
|
||
if (oDictItem.DictLookup("D", &oTemp)->IsArray())
|
||
{
|
||
nBorderDashLength = oTemp.ArrayGetLength();
|
||
pBorderDash = (double *)MemUtilsMallocArray(nBorderDashLength, sizeof(double));
|
||
|
||
for (int nIndex = 0; nIndex < nBorderDashLength; ++nIndex)
|
||
{
|
||
Object oArrayItem;
|
||
if (oTemp.ArrayGet(nIndex, &oArrayItem)->IsNum())
|
||
{
|
||
pBorderDash[nIndex] = oArrayItem.GetNum();
|
||
}
|
||
else
|
||
{
|
||
pBorderDash[nIndex] = 1;
|
||
}
|
||
oArrayItem.Free();
|
||
}
|
||
}
|
||
oTemp.Free();
|
||
}
|
||
else
|
||
{
|
||
oDictItem.Free();
|
||
if (pDict->Search("Border", &oDictItem)->IsArray())
|
||
{
|
||
Object oTemp;
|
||
if (oDictItem.ArrayGetLength() >= 3)
|
||
{
|
||
if (oDictItem.ArrayGet(2, &oTemp)->IsNum())
|
||
{
|
||
dBorderWidth = oTemp.GetNum();
|
||
}
|
||
oTemp.Free();
|
||
if (oDictItem.ArrayGetLength() >= 4)
|
||
{
|
||
if (oDictItem.ArrayGet(3, &oTemp)->IsArray())
|
||
{
|
||
eBorderType = annotBorderDashed;
|
||
nBorderDashLength = oTemp.ArrayGetLength();
|
||
pBorderDash = (double *)MemUtilsMallocArray(nBorderDashLength, sizeof(double));
|
||
|
||
for (int nIndex = 0; nIndex < nBorderDashLength; ++nIndex)
|
||
{
|
||
Object oArrayItem;
|
||
if (oTemp.ArrayGet(nIndex, &oArrayItem)->IsNum())
|
||
{
|
||
pBorderDash[nIndex] = oArrayItem.GetNum();
|
||
}
|
||
else
|
||
{
|
||
pBorderDash[nIndex] = 1;
|
||
}
|
||
oArrayItem.Free();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
dBorderWidth = 0;
|
||
}
|
||
oTemp.Free();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
oDictItem.Free();
|
||
|
||
// C (border color)
|
||
// TO DO: надо сделать чтение случаев, когда в массике не только 3 элемента, а 0, 1, 3, 4
|
||
if (pDict->Search("C", &oDictItem)->IsArray() && oDictItem.ArrayGetLength() == 3)
|
||
{
|
||
Object oTemp;
|
||
if (oDictItem.ArrayGet(0, &oTemp)->IsNum())
|
||
{
|
||
dBorderR = oTemp.GetNum();
|
||
}
|
||
oTemp.Free();
|
||
|
||
if (oDictItem.ArrayGet(1, &oTemp)->IsNum())
|
||
{
|
||
dBorderG = oTemp.GetNum();
|
||
}
|
||
oTemp.Free();
|
||
|
||
if (oDictItem.ArrayGet(2, &oTemp)->IsNum())
|
||
{
|
||
dBorderB = oTemp.GetNum();
|
||
}
|
||
oTemp.Free();
|
||
}
|
||
oDictItem.Free();
|
||
|
||
m_pBorderStyle = new AnnotBorderStyle(eBorderType, dBorderWidth, pBorderDash, nBorderDashLength, dBorderR, dBorderG, dBorderB);
|
||
|
||
// AP (appereance)
|
||
Object oAP;
|
||
if (pDict->Search("AP", &oAP)->IsDict())
|
||
{
|
||
Object oAS;
|
||
if (pDict->Search("AS", &oAS)->IsName())
|
||
{
|
||
Object oItem;
|
||
if (oAP.DictLookup("N", &oItem)->IsDict())
|
||
{
|
||
Object oTemp;
|
||
if (oItem.DictLookupAndCopy(oAS.GetName(), &oTemp)->IsRef())
|
||
{
|
||
oTemp.Copy(&m_oAppearance);
|
||
m_bValid = true;
|
||
}
|
||
else
|
||
{
|
||
oTemp.Free();
|
||
if (oItem.DictLookupAndCopy("Off", &oTemp)->IsRef())
|
||
{
|
||
oTemp.Copy(&m_oAppearance);
|
||
}
|
||
}
|
||
oTemp.Free();
|
||
}
|
||
oItem.Free();
|
||
}
|
||
else
|
||
{
|
||
Object oItem;
|
||
if (oAP.DictLookupAndCopy("N", &oItem)->IsRef())
|
||
{
|
||
oItem.Copy(&m_oAppearance);
|
||
}
|
||
oItem.Free();
|
||
}
|
||
oAS.Free();
|
||
}
|
||
oAP.Free();
|
||
}
|
||
Annot::~Annot()
|
||
{
|
||
if (m_seType)
|
||
{
|
||
delete m_seType;
|
||
}
|
||
m_oAppearance.Free();
|
||
|
||
if (m_seAppBuffer)
|
||
{
|
||
delete m_seAppBuffer;
|
||
}
|
||
if (m_pBorderStyle)
|
||
{
|
||
delete m_pBorderStyle;
|
||
}
|
||
}
|
||
void Annot::GenerateFieldAppearance(Dict *pField, Dict *pAnnot, Dict *pAcroForm)
|
||
{
|
||
// Тип Annotation должен быть Widget
|
||
if (m_seType->Compare("Widget"))
|
||
{
|
||
return;
|
||
}
|
||
|
||
m_seAppBuffer = new StringExt();
|
||
|
||
// Appearance characteristics (MK) dictionary
|
||
Object oMKObject;
|
||
Dict *pMKDict;
|
||
if (pAnnot->Search("MK", &oMKObject)->IsDict())
|
||
{
|
||
pMKDict = oMKObject.GetDict();
|
||
}
|
||
else
|
||
{
|
||
pMKDict = NULL;
|
||
}
|
||
|
||
// Рисуем фон (BackGround)
|
||
Object oDictItem;
|
||
if (pMKDict)
|
||
{
|
||
if (pMKDict->Search("BG", &oDictItem)->IsArray() && oDictItem.ArrayGetLength() > 0)
|
||
{
|
||
SetColor(oDictItem.GetArray(), true, 0);
|
||
m_seAppBuffer->AppendFormat("0 0 {0:.2f} {1:.2f} re f\n", m_dMaxX - m_dMinX, m_dMaxY - m_dMinY);
|
||
}
|
||
oDictItem.Free();
|
||
}
|
||
|
||
// Считываем тип поля
|
||
// FT (File Type)
|
||
Object oFTobject;
|
||
FieldLookup(pField, "FT", &oFTobject);
|
||
|
||
// Ff (Filed flags)
|
||
int nFiledFlags = 0;
|
||
if (FieldLookup(pField, "Ff", &oDictItem)->IsInt())
|
||
{
|
||
nFiledFlags = oDictItem.GetInt();
|
||
}
|
||
else
|
||
{
|
||
nFiledFlags = 0;
|
||
}
|
||
oDictItem.Free();
|
||
|
||
// Рисуем рамку
|
||
if (pMKDict)
|
||
{
|
||
double dWidth = m_pBorderStyle->GetWidth();
|
||
if (dWidth > 0)
|
||
{
|
||
// BC (Border Color), если такого поля нет, тогда используем цвет из BG
|
||
pMKDict->Search("BC", &oDictItem);
|
||
if (!(oDictItem.IsArray() && oDictItem.ArrayGetLength() > 0))
|
||
{
|
||
pMKDict->Search("BG", &oDictItem);
|
||
}
|
||
if (oDictItem.IsArray() && oDictItem.ArrayGetLength() > 0)
|
||
{
|
||
double dDx = m_dMaxX - m_dMinX;
|
||
double dDy = m_dMaxY - m_dMinY;
|
||
double *pDash;
|
||
int nDashLength = 0;
|
||
|
||
Object oTemp;
|
||
bool bHasCaption = pMKDict->Search("CA", &oTemp)->IsString();
|
||
oTemp.Free();
|
||
|
||
if (oFTobject.IsName("Btn") && (nFiledFlags & fieldFlagRadio) && !bHasCaption)
|
||
{
|
||
double dRad = 0.5 * (dDx < dDy ? dDx : dDy);
|
||
switch (m_pBorderStyle->GetType())
|
||
{
|
||
case annotBorderDashed:
|
||
m_seAppBuffer->Append("[");
|
||
m_pBorderStyle->GetDash(&pDash, &nDashLength);
|
||
for (int nIndex = 0; nIndex < nDashLength; ++nIndex)
|
||
{
|
||
m_seAppBuffer->AppendFormat(" {0:.2f}", pDash[nIndex]);
|
||
}
|
||
m_seAppBuffer->Append("] 0 d\n");
|
||
// Дальше как в случае не пунктирной линии
|
||
case annotBorderSolid:
|
||
case annotBorderUnderlined:
|
||
m_seAppBuffer->AppendFormat("{0:.2f} w\n", dWidth);
|
||
SetColor(oDictItem.GetArray(), false, 0);
|
||
DrawCircle(0.5 * dDx, 0.5 * dDy, dRad - 0.5 * dWidth, false);
|
||
break;
|
||
case annotBorderBeveled:
|
||
case annotBorderInset:
|
||
m_seAppBuffer->AppendFormat("{0:.2f} w\n", 0.5 * dWidth);
|
||
|
||
SetColor(oDictItem.GetArray(), false, 0);
|
||
DrawCircle(0.5 * dDx, 0.5 * dDy, dRad - 0.25 * dWidth, false);
|
||
|
||
SetColor(oDictItem.GetArray(), false, m_pBorderStyle->GetType() == annotBorderBeveled ? 1 : -1);
|
||
DrawCircleTopLeft(0.5 * dDx, 0.5 * dDy, dRad - 0.75 * dWidth);
|
||
|
||
SetColor(oDictItem.GetArray(), false, m_pBorderStyle->GetType() == annotBorderBeveled ? -1 : 1);
|
||
DrawCircleBottomRight(0.5 * dDx, 0.5 * dDy, dRad - 0.75 * dWidth);
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
switch (m_pBorderStyle->GetType())
|
||
{
|
||
case annotBorderDashed:
|
||
m_seAppBuffer->Append("[");
|
||
m_pBorderStyle->GetDash(&pDash, &nDashLength);
|
||
for (int nIndex = 0; nIndex < nDashLength; ++nIndex)
|
||
{
|
||
m_seAppBuffer->AppendFormat(" {0:.2f}", pDash[nIndex]);
|
||
}
|
||
m_seAppBuffer->Append("] 0 d\n");
|
||
// Дальше как в случае не пунктирной линии
|
||
case annotBorderSolid:
|
||
m_seAppBuffer->AppendFormat("{0:.2f} w\n", dWidth);
|
||
SetColor(oDictItem.GetArray(), false, 0);
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {0:.2f} {1:.2f} {2:.2f} re s\n", 0.5 * dWidth, dDx - dWidth, dDy - dWidth);
|
||
break;
|
||
case annotBorderBeveled:
|
||
case annotBorderInset:
|
||
|
||
SetColor(oDictItem.GetArray(), true, m_pBorderStyle->GetType() == annotBorderBeveled ? 1 : -1);
|
||
m_seAppBuffer->Append("0 0 m\n");
|
||
m_seAppBuffer->AppendFormat("0 {0:.2f} l\n", dDy);
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {1:.2f} l\n", dDx, dDy);
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {1:.2f} l\n", dDx - dWidth, dDy - dWidth);
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {1:.2f} l\n", dWidth, dDy - dWidth);
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {0:.2f} l\n", dWidth);
|
||
m_seAppBuffer->Append("f\n");
|
||
|
||
SetColor(oDictItem.GetArray(), true, m_pBorderStyle->GetType() == annotBorderBeveled ? -1 : 1);
|
||
m_seAppBuffer->Append("0 0 m\n");
|
||
m_seAppBuffer->AppendFormat("{0:.2f} 0 l\n", dDx);
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {1:.2f} l\n", dDx, dDy);
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {1:.2f} l\n", dDx - dWidth, dDy - dWidth);
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {1:.2f} l\n", dDx - dWidth, dWidth);
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {0:.2f} l\n", dWidth);
|
||
m_seAppBuffer->Append("f\n");
|
||
break;
|
||
case annotBorderUnderlined:
|
||
m_seAppBuffer->AppendFormat("{0:.2f} w\n", dWidth);
|
||
SetColor(oDictItem.GetArray(), false, 0);
|
||
m_seAppBuffer->AppendFormat("0 0 m {0:.2f} 0 l s\n", dDx);
|
||
break;
|
||
}
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {0:.2f} {1:.2f} {2:.2f} re W n\n", dWidth, dDx - 2 * dWidth, dDy - 2 * dWidth);
|
||
}
|
||
}
|
||
oDictItem.Free();
|
||
}
|
||
}
|
||
|
||
// DR
|
||
Object oDRobject;
|
||
pAcroForm->Search("DR", &oDRobject);
|
||
|
||
// Font dictionary
|
||
GrFontDict *pFontDict;
|
||
if (oDRobject.IsDict() && oDRobject.DictLookup("Font", &oDictItem)->IsDict())
|
||
{
|
||
pFontDict = new GrFontDict(m_pXref, NULL, oDictItem.GetDict(), m_pGlobalParams);
|
||
}
|
||
else
|
||
{
|
||
pFontDict = NULL;
|
||
}
|
||
oDictItem.Free();
|
||
|
||
// DA (Default appereance string)
|
||
StringExt *seDA;
|
||
if (FieldLookup(pField, "DA", &oDictItem)->IsNull())
|
||
{
|
||
oDictItem.Free();
|
||
pAcroForm->Search("DA", &oDictItem);
|
||
}
|
||
if (oDictItem.IsString())
|
||
{
|
||
seDA = oDictItem.GetString()->Copy();
|
||
}
|
||
else
|
||
{
|
||
seDA = NULL;
|
||
}
|
||
oDictItem.Free();
|
||
|
||
// Рисуем содержимео Filed
|
||
if (oFTobject.IsName("Btn"))
|
||
{
|
||
StringExt *seCaption = NULL;
|
||
if (pMKDict)
|
||
{
|
||
if (pMKDict->Search("CA", &oDictItem)->IsString())
|
||
{
|
||
seCaption = oDictItem.GetString()->Copy();
|
||
}
|
||
oDictItem.Free();
|
||
}
|
||
|
||
// Radio button
|
||
if (nFiledFlags & fieldFlagRadio)
|
||
{
|
||
// Акробат не рисует Caption, если нет AP
|
||
if (FieldLookup(pField, "V", &oDictItem)->IsName())
|
||
{
|
||
Object oAppStream;
|
||
if (pAnnot->Search("AS", &oAppStream)->IsName(oDictItem.GetName()))
|
||
{
|
||
if (seCaption)
|
||
{
|
||
DrawText(seCaption, seDA, pFontDict, false, 0, fieldQuadCenter, false, true);
|
||
}
|
||
else
|
||
{
|
||
if (pMKDict)
|
||
{
|
||
Object oTemp;
|
||
if (pMKDict->Search("BC", &oTemp)->IsArray() && oTemp.ArrayGetLength() > 0)
|
||
{
|
||
double dDx = m_dMaxX - m_dMinX;
|
||
double dDy = m_dMaxY - m_dMinY;
|
||
SetColor(oTemp.GetArray(), true, 0);
|
||
DrawCircle(0.5 * dDx, 0.5 * dDy, 0.2 * (dDx < dDy ? dDx : dDy), true);
|
||
}
|
||
oTemp.Free();
|
||
}
|
||
}
|
||
}
|
||
oAppStream.Free();
|
||
}
|
||
oDictItem.Free();
|
||
}
|
||
else if (nFiledFlags & fieldFlagPushbutton) // PushButton
|
||
{
|
||
if (seCaption)
|
||
{
|
||
DrawText(seCaption, seDA, pFontDict, false, 0, fieldQuadCenter, false, false);
|
||
}
|
||
}
|
||
else // CheckBox
|
||
{
|
||
// "Yes" - для включенного состояние, "off" - для выключенного.
|
||
if (FieldLookup(pField, "V", &oDictItem)->IsName("Yes"))
|
||
{
|
||
if (!seCaption)
|
||
{
|
||
seCaption = new StringExt("3"); // ZapfDingbats checkmark
|
||
}
|
||
DrawText(seCaption, seDA, pFontDict, false, 0, fieldQuadCenter, false, true);
|
||
}
|
||
oDictItem.Free();
|
||
}
|
||
if (seCaption)
|
||
{
|
||
delete seCaption;
|
||
}
|
||
}
|
||
else if (oFTobject.IsName("Tx"))
|
||
{
|
||
// Строковые значения могут быть юникодными
|
||
Object oValue;
|
||
if (FieldLookup(pField, "V", &oValue)->IsString())
|
||
{
|
||
Object oTemp;
|
||
int nQuadding = 0;
|
||
if (FieldLookup(pField, "Q", &oTemp)->IsInt())
|
||
{
|
||
nQuadding = oTemp.GetInt();
|
||
}
|
||
else
|
||
{
|
||
nQuadding = fieldQuadLeft;
|
||
}
|
||
oTemp.Free();
|
||
int nComb = 0;
|
||
if (nFiledFlags & fieldFlagComb)
|
||
{
|
||
if (FieldLookup(pField, "MaxLen", &oTemp)->IsInt())
|
||
{
|
||
nComb = oTemp.GetInt();
|
||
}
|
||
oTemp.Free();
|
||
}
|
||
DrawText(oValue.GetString(), seDA, pFontDict, 0 != (nFiledFlags & fieldFlagMultiline), nComb, nQuadding, true, false);
|
||
}
|
||
oValue.Free();
|
||
}
|
||
else if (oFTobject.IsName("Ch"))
|
||
{
|
||
// Строковые значения могут быть юникодными
|
||
int nQuadding = 0;
|
||
Object oTemp;
|
||
if (FieldLookup(pField, "Q", &oTemp)->IsInt())
|
||
{
|
||
nQuadding = oTemp.GetInt();
|
||
}
|
||
else
|
||
{
|
||
nQuadding = fieldQuadLeft;
|
||
}
|
||
oTemp.Free();
|
||
|
||
// ComboBox
|
||
if (nFiledFlags & fieldFlagCombo)
|
||
{
|
||
Object oValue;
|
||
if (FieldLookup(pField, "V", &oValue)->IsString())
|
||
{
|
||
DrawText(oValue.GetString(), seDA, pFontDict, false, 0, nQuadding, true, false);
|
||
//~ Acrobat draws a popup icon on the right side
|
||
}
|
||
oValue.Free();
|
||
}
|
||
else // ListBox
|
||
{
|
||
Object oOptions;
|
||
if (pField->Search("Opt", &oOptions)->IsArray())
|
||
{
|
||
int nOptionsCount = oOptions.ArrayGetLength();
|
||
// Option text
|
||
StringExt **ppText = (StringExt **)MemUtilsMallocArray(nOptionsCount, sizeof(StringExt *));
|
||
for (int nIndex = 0; nIndex < nOptionsCount; ++nIndex)
|
||
{
|
||
ppText[nIndex] = NULL;
|
||
Object oTemp;
|
||
oOptions.ArrayGet(nIndex, &oTemp);
|
||
if (oTemp.IsString())
|
||
{
|
||
ppText[nIndex] = oTemp.GetString()->Copy();
|
||
}
|
||
else if (oTemp.IsArray() && oTemp.ArrayGetLength() == 2)
|
||
{
|
||
Object oArrayItem;
|
||
if (oTemp.ArrayGet(1, &oArrayItem)->IsString())
|
||
{
|
||
ppText[nIndex] = oArrayItem.GetString()->Copy();
|
||
}
|
||
oArrayItem.Free();
|
||
}
|
||
oTemp.Free();
|
||
if (!ppText[nIndex])
|
||
{
|
||
ppText[nIndex] = new StringExt();
|
||
}
|
||
}
|
||
// Selected option(s)
|
||
bool *pSelection = (bool *)MemUtilsMallocArray(nOptionsCount, sizeof(bool));
|
||
//~ need to use the I field in addition to the V field
|
||
Object oValue;
|
||
FieldLookup(pField, "V", &oValue);
|
||
for (int nIndex = 0; nIndex < nOptionsCount; ++nIndex)
|
||
{
|
||
pSelection[nIndex] = false;
|
||
if (oValue.IsString())
|
||
{
|
||
if (!oValue.GetString()->Compare(ppText[nIndex]))
|
||
{
|
||
pSelection[nIndex] = true;
|
||
}
|
||
}
|
||
else if (oValue.IsArray())
|
||
{
|
||
for (int nJ = 0; nJ < oValue.ArrayGetLength(); ++nJ)
|
||
{
|
||
Object oTemp;
|
||
if (oValue.ArrayGet(nJ, &oTemp)->IsString() && !oTemp.GetString()->Compare(ppText[nIndex]))
|
||
{
|
||
pSelection[nIndex] = true;
|
||
}
|
||
oTemp.Free();
|
||
}
|
||
}
|
||
}
|
||
oValue.Free();
|
||
|
||
// TI (Top Index)
|
||
int nTopIndex = 0;
|
||
if (pField->Search("TI", &oValue)->IsInt())
|
||
{
|
||
nTopIndex = oValue.GetInt();
|
||
}
|
||
else
|
||
{
|
||
nTopIndex = 0;
|
||
}
|
||
oValue.Free();
|
||
|
||
DrawListBox(ppText, pSelection, nOptionsCount, nTopIndex, seDA, pFontDict, nQuadding);
|
||
for (int nIndex = 0; nIndex < nOptionsCount; ++nIndex)
|
||
{
|
||
delete ppText[nIndex];
|
||
}
|
||
MemUtilsFree(ppText);
|
||
MemUtilsFree(pSelection);
|
||
}
|
||
oOptions.Free();
|
||
}
|
||
}
|
||
else if (oFTobject.IsName("Sig"))
|
||
{
|
||
//~unimp
|
||
}
|
||
else
|
||
{
|
||
// TO DO: Error "Unknown field type"
|
||
}
|
||
|
||
if (seDA)
|
||
{
|
||
delete seDA;
|
||
}
|
||
|
||
// Appearance stream dictionary
|
||
Object oAppearanceDict;
|
||
|
||
oAppearanceDict.InitDict(m_pXref);
|
||
oAppearanceDict.DictAdd(CopyString("Length"), oDictItem.InitInt(m_seAppBuffer->GetLength()));
|
||
oAppearanceDict.DictAdd(CopyString("Subtype"), oDictItem.InitName("Form"));
|
||
oDictItem.InitArray(m_pXref);
|
||
Object oTemp;
|
||
oDictItem.ArrayAdd(oTemp.InitReal(0));
|
||
oDictItem.ArrayAdd(oTemp.InitReal(0));
|
||
oDictItem.ArrayAdd(oTemp.InitReal(m_dMaxX - m_dMinX));
|
||
oDictItem.ArrayAdd(oTemp.InitReal(m_dMaxY - m_dMinY));
|
||
oAppearanceDict.DictAdd(CopyString("BBox"), &oDictItem);
|
||
|
||
// Resource dictionary
|
||
if (oDRobject.IsDict())
|
||
{
|
||
oAppearanceDict.DictAdd(CopyString("Resources"), oDRobject.Copy(&oDictItem));
|
||
}
|
||
oDRobject.Free();
|
||
|
||
// Appearance stream
|
||
MemoryStream *pAppearStream = new MemoryStream(m_seAppBuffer->GetBuffer(), 0, m_seAppBuffer->GetLength(), &oAppearanceDict);
|
||
m_oAppearance.Free();
|
||
m_oAppearance.InitStream(pAppearStream);
|
||
|
||
if (pFontDict)
|
||
{
|
||
delete pFontDict;
|
||
}
|
||
oFTobject.Free();
|
||
oMKObject.Free();
|
||
}
|
||
|
||
// Устанавливаем цвет для заливки или обводки; цвет здается массиом <pArray> (в котором должно быть
|
||
// 1, 3, или 4 элемента). Если <nAdjust> равно +1, цвет color is высветляется, если <nAdjust> равно
|
||
// -1, цвет затемняется, в противном случае, цвет не меняется.
|
||
void Annot::SetColor(Array *pArray, bool bFill, int nAdjust)
|
||
{
|
||
double arrColor[4];
|
||
|
||
int nComponentsCount = pArray->GetCount();
|
||
if (nComponentsCount > 4)
|
||
{
|
||
nComponentsCount = 4;
|
||
}
|
||
for (int nIndex = 0; nIndex < nComponentsCount && nIndex < 4; ++nIndex)
|
||
{
|
||
Object oTemp;
|
||
if (pArray->Get(nIndex, &oTemp)->IsNum())
|
||
{
|
||
arrColor[nIndex] = oTemp.GetNum();
|
||
}
|
||
else
|
||
{
|
||
arrColor[nIndex] = 0;
|
||
}
|
||
oTemp.Free();
|
||
}
|
||
if (4 == nComponentsCount)
|
||
{
|
||
nAdjust = -nAdjust;
|
||
}
|
||
if (nAdjust > 0)
|
||
{
|
||
for (int nIndex = 0; nIndex < nComponentsCount; ++nIndex)
|
||
{
|
||
arrColor[nIndex] = 0.5 * arrColor[nIndex] + 0.5;
|
||
}
|
||
}
|
||
else if (nAdjust < 0)
|
||
{
|
||
for (int nIndex = 0; nIndex < nComponentsCount; ++nIndex)
|
||
{
|
||
arrColor[nIndex] = 0.5 * arrColor[nIndex];
|
||
}
|
||
}
|
||
if (4 == nComponentsCount)
|
||
{
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {1:.2f} {2:.2f} {3:.2f} {4:c}\n", arrColor[0], arrColor[1], arrColor[2], arrColor[3], bFill ? 'k' : 'K');
|
||
}
|
||
else if (3 == nComponentsCount)
|
||
{
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {1:.2f} {2:.2f} {3:s}\n", arrColor[0], arrColor[1], arrColor[2], bFill ? "rg" : "RG");
|
||
}
|
||
else
|
||
{
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {1:c}\n", arrColor[0], bFill ? 'g' : 'G');
|
||
}
|
||
}
|
||
|
||
// Рисуем текст или название для Field.
|
||
void Annot::DrawText(StringExt *seText, StringExt *seDA, GrFontDict *pFontDict, bool bMultiline, int nComb, int nQuadding, bool bTextField, bool bForceZapfDingbats)
|
||
{
|
||
CList *pListDA;
|
||
StringExt *seToken;
|
||
double dX, dY, dWidth;
|
||
int i, j, k, nChar;
|
||
|
||
// Парсим Default Appearance string
|
||
|
||
int nTfPos = -1, nTmPos = -1;
|
||
if (seDA)
|
||
{
|
||
pListDA = new CList();
|
||
i = 0;
|
||
while (i < seDA->GetLength())
|
||
{
|
||
while (i < seDA->GetLength() && Lexer::IsSpace(seDA->GetAt(i)))
|
||
{
|
||
++i;
|
||
}
|
||
if (i < seDA->GetLength())
|
||
{
|
||
for (j = i + 1; j < seDA->GetLength() && !Lexer::IsSpace(seDA->GetAt(j)); ++j);
|
||
pListDA->Append(new StringExt(seDA, i, j - i));
|
||
i = j;
|
||
}
|
||
}
|
||
for (i = 2; i < pListDA->GetLength(); ++i)
|
||
{
|
||
if (i >= 2 && !((StringExt *)pListDA->GetByIndex(i))->Compare("Tf"))
|
||
{
|
||
nTfPos = i - 2;
|
||
}
|
||
else if (i >= 6 && !((StringExt *)pListDA->GetByIndex(i))->Compare("Tm"))
|
||
{
|
||
nTmPos = i - 6;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
pListDA = NULL;
|
||
}
|
||
|
||
// ZapfDingbats
|
||
if (bForceZapfDingbats)
|
||
{
|
||
if (nTfPos >= 0)
|
||
{
|
||
seToken = (StringExt *)pListDA->GetByIndex(nTfPos);
|
||
if (seToken->Compare("/ZaDb"))
|
||
{
|
||
seToken->Clear();
|
||
seToken->Append("/ZaDb");
|
||
}
|
||
}
|
||
}
|
||
|
||
// Считываем шрифт и размер шрифта
|
||
GrFont *pFont = NULL;
|
||
double dFontSize = 0;
|
||
if (nTfPos >= 0)
|
||
{
|
||
seToken = (StringExt *)pListDA->GetByIndex(nTfPos);
|
||
if (seToken->GetLength() >= 1 && seToken->GetAt(0) == '/')
|
||
{
|
||
if (!pFontDict || !(pFont = pFontDict->Search(seToken->GetBuffer() + 1)))
|
||
{
|
||
// TO DO: Error "Unknown font in field's DA string"
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// TO DO: Error "Invalid font name in 'Tf' operator in field's DA string"
|
||
}
|
||
seToken = (StringExt *)pListDA->GetByIndex(nTfPos + 1);
|
||
dFontSize = atof(seToken->GetBuffer());
|
||
}
|
||
else
|
||
{
|
||
// TO DO: Error "Missing 'Tf' operator in field's DA string"
|
||
}
|
||
|
||
// Border Width
|
||
double dBorderWidth = m_pBorderStyle->GetWidth();
|
||
|
||
if (bTextField)
|
||
{
|
||
m_seAppBuffer->Append("/Tx BMC\n");
|
||
}
|
||
m_seAppBuffer->Append("q\n");
|
||
m_seAppBuffer->Append("BT\n");
|
||
|
||
// Многострочный текст
|
||
if (bMultiline)
|
||
{
|
||
// Флаги nComb игнорируются в многострочном тексте
|
||
|
||
double dWMax = m_dMaxX - m_dMinX - 2 * dBorderWidth - 4;
|
||
|
||
// Вычислим размер шрифта (если он не был установлен)
|
||
if (0 == dFontSize)
|
||
{
|
||
for (dFontSize = 20; dFontSize > 1; --dFontSize)
|
||
{
|
||
dY = m_dMaxY - m_dMinY;
|
||
double dMaxLineWidth = 0;
|
||
i = 0;
|
||
while (i < seText->GetLength())
|
||
{
|
||
GetNextLine(seText, i, pFont, dFontSize, dWMax, &j, &dWidth, &k);
|
||
if (dWidth > dMaxLineWidth)
|
||
{
|
||
dMaxLineWidth = dWidth;
|
||
}
|
||
i = k;
|
||
dY -= dFontSize;
|
||
}
|
||
|
||
if (dY >= 0.33 * dFontSize)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
if (nTfPos >= 0)
|
||
{
|
||
seToken = (StringExt *)pListDA->GetByIndex(nTfPos + 1);
|
||
seToken->Clear();
|
||
seToken->AppendFormat("{0:.2f}", dFontSize);
|
||
}
|
||
}
|
||
|
||
// Начальная координата Y
|
||
// (Каждая новая линий начинается с оператора Td)
|
||
dY = m_dMaxY - m_dMinY;
|
||
|
||
// Font Matrix
|
||
if (nTmPos >= 0)
|
||
{
|
||
seToken = (StringExt *)pListDA->GetByIndex(nTmPos + 4);
|
||
seToken->Clear();
|
||
seToken->Append('0');
|
||
seToken = (StringExt *)pListDA->GetByIndex(nTmPos + 5);
|
||
seToken->Clear();
|
||
seToken->AppendFormat("{0:.2f}", dY);
|
||
}
|
||
|
||
// Пишем DA-string
|
||
if (pListDA)
|
||
{
|
||
for (i = 0; i < pListDA->GetLength(); ++i)
|
||
{
|
||
m_seAppBuffer->Append((StringExt *)pListDA->GetByIndex(i))->Append(' ');
|
||
}
|
||
}
|
||
|
||
// Пишем Font Matrix (если она не была уже в DA-string)
|
||
if (nTmPos < 0)
|
||
{
|
||
m_seAppBuffer->AppendFormat("1 0 0 1 0 {0:.2f} Tm\n", dY);
|
||
}
|
||
|
||
i = 0;
|
||
double dPrevX = 0;
|
||
while (i < seText->GetLength())
|
||
{
|
||
GetNextLine(seText, i, pFont, dFontSize, dWMax, &j, &dWidth, &k);
|
||
// Вычислим начальную позицию текста
|
||
switch (nQuadding)
|
||
{
|
||
case fieldQuadLeft:
|
||
default:
|
||
dX = dBorderWidth + 2;
|
||
break;
|
||
case fieldQuadCenter:
|
||
dX = (m_dMaxX - m_dMinX - dWidth) / 2;
|
||
break;
|
||
case fieldQuadRight:
|
||
dX = m_dMaxX - m_dMinX - dBorderWidth - 2 - dWidth;
|
||
break;
|
||
}
|
||
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {1:.2f} Td\n", dX - dPrevX, -dFontSize);
|
||
m_seAppBuffer->Append('(');
|
||
for (; i < j; ++i)
|
||
{
|
||
nChar = seText->GetAt(i) & 0xff;
|
||
if (nChar == '(' || nChar == ')' || nChar == '\\')
|
||
{
|
||
m_seAppBuffer->Append('\\');
|
||
m_seAppBuffer->Append(nChar);
|
||
}
|
||
else if (nChar < 0x20 || nChar >= 0x80)
|
||
{
|
||
m_seAppBuffer->AppendFormat("\\{0:03o}", nChar);
|
||
}
|
||
else
|
||
{
|
||
m_seAppBuffer->Append(nChar);
|
||
}
|
||
}
|
||
m_seAppBuffer->Append(") Tj\n");
|
||
|
||
// Следующая строка
|
||
i = k;
|
||
dPrevX = dX;
|
||
}
|
||
|
||
}
|
||
else // Однострочный текст
|
||
{
|
||
if (nComb > 0)
|
||
{
|
||
dWidth = (m_dMaxX - m_dMinX - 2 * dBorderWidth) / nComb;
|
||
|
||
// Вычислим размер шрифта (если он не был установлен)
|
||
if (0 == dFontSize)
|
||
{
|
||
dFontSize = m_dMaxY - m_dMinY - 2 * dBorderWidth;
|
||
if (dWidth < dFontSize)
|
||
{
|
||
dFontSize = dWidth;
|
||
}
|
||
dFontSize = floor(dFontSize);
|
||
if (nTfPos >= 0)
|
||
{
|
||
seToken = (StringExt *)pListDA->GetByIndex(nTfPos + 1);
|
||
seToken->Clear();
|
||
seToken->AppendFormat("{0:.2f}", dFontSize);
|
||
}
|
||
}
|
||
|
||
// Вычислим начальную позицию текста
|
||
switch (nQuadding)
|
||
{
|
||
case fieldQuadLeft:
|
||
default:
|
||
dX = dBorderWidth + 2;
|
||
break;
|
||
case fieldQuadCenter:
|
||
dX = dBorderWidth + 2 + 0.5 * (nComb - seText->GetLength()) * dWidth;
|
||
break;
|
||
case fieldQuadRight:
|
||
dX = dBorderWidth + 2 + (nComb - seText->GetLength()) * dWidth;
|
||
break;
|
||
}
|
||
dY = 0.5 * (m_dMaxY - m_dMinY) - 0.4 * dFontSize;
|
||
|
||
// Font Matrix
|
||
if (nTmPos >= 0)
|
||
{
|
||
seToken = (StringExt *)pListDA->GetByIndex(nTmPos + 4);
|
||
seToken->Clear();
|
||
seToken->AppendFormat("{0:.2f}", dX);
|
||
seToken = (StringExt *)pListDA->GetByIndex(nTmPos + 5);
|
||
seToken->Clear();
|
||
seToken->AppendFormat("{0:.2f}", dY);
|
||
}
|
||
|
||
// DA-string
|
||
if (pListDA)
|
||
{
|
||
for (i = 0; i < pListDA->GetLength(); ++i)
|
||
{
|
||
m_seAppBuffer->Append((StringExt *)pListDA->GetByIndex(i))->Append(' ');
|
||
}
|
||
}
|
||
|
||
// Пишем Font Matrix (если она не была уже в DA-string)
|
||
if (nTmPos < 0)
|
||
{
|
||
m_seAppBuffer->AppendFormat("1 0 0 1 {0:.2f} {1:.2f} Tm\n", dX, dY);
|
||
}
|
||
|
||
// write the text string
|
||
//~ this should center (instead of left-justify) each character within
|
||
//~ its comb cell
|
||
for (i = 0; i < seText->GetLength(); ++i)
|
||
{
|
||
if (i > 0)
|
||
{
|
||
m_seAppBuffer->AppendFormat("{0:.2f} 0 Td\n", dWidth);
|
||
}
|
||
m_seAppBuffer->Append('(');
|
||
nChar = seText->GetAt(i) & 0xff;
|
||
if (nChar == '(' || nChar == ')' || nChar == '\\')
|
||
{
|
||
m_seAppBuffer->Append('\\');
|
||
m_seAppBuffer->Append(nChar);
|
||
}
|
||
else if (nChar < 0x20 || nChar >= 0x80)
|
||
{
|
||
m_seAppBuffer->AppendFormat("{0:.2f} 0 Td\n", dWidth);
|
||
}
|
||
else
|
||
{
|
||
m_seAppBuffer->Append(nChar);
|
||
}
|
||
m_seAppBuffer->Append(") Tj\n");
|
||
}
|
||
}
|
||
else // обычное форматирование (non-comb)
|
||
{
|
||
// Вычислим ширину строки
|
||
if (pFont && !pFont->IsCIDFont())
|
||
{
|
||
dWidth = 0;
|
||
for (i = 0; i < seText->GetLength(); ++i)
|
||
{
|
||
dWidth += ((Gr8BitFont *)pFont)->GetWidth(seText->GetAt(i));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
dWidth = seText->GetLength() * 0.5;
|
||
}
|
||
|
||
// Вычислим размер шрифта (если он не был установлен)
|
||
if (0 == dFontSize)
|
||
{
|
||
dFontSize = m_dMaxY - m_dMinY - 2 * dBorderWidth;
|
||
double dTempFontSize = (m_dMaxX - m_dMinX - 4 - 2 * dBorderWidth) / dWidth;
|
||
if (dTempFontSize < dFontSize)
|
||
{
|
||
dFontSize = dTempFontSize;
|
||
}
|
||
dFontSize = floor(dFontSize);
|
||
if (nTfPos >= 0)
|
||
{
|
||
seToken = (StringExt *)pListDA->GetByIndex(nTfPos + 1);
|
||
seToken->Clear();
|
||
seToken->AppendFormat("{0:.2f}", dFontSize);
|
||
}
|
||
}
|
||
|
||
// Вычислим начальную позицию текста
|
||
dWidth *= dFontSize;
|
||
switch (nQuadding)
|
||
{
|
||
case fieldQuadLeft:
|
||
default:
|
||
dX = dBorderWidth + 2;
|
||
break;
|
||
case fieldQuadCenter:
|
||
dX = (m_dMaxX - m_dMinX - dWidth) / 2;
|
||
break;
|
||
case fieldQuadRight:
|
||
dX = m_dMaxX - m_dMinX - dBorderWidth - 2 - dWidth;
|
||
break;
|
||
}
|
||
dY = 0.5 * (m_dMaxY - m_dMinY) - 0.4 * dFontSize;
|
||
|
||
// Font Matrix
|
||
if (nTmPos >= 0)
|
||
{
|
||
seToken = (StringExt *)pListDA->GetByIndex(nTmPos + 4);
|
||
seToken->Clear();
|
||
seToken->AppendFormat("{0:.2f}", dX);
|
||
seToken = (StringExt *)pListDA->GetByIndex(nTmPos + 5);
|
||
seToken->Clear();
|
||
seToken->AppendFormat("{0:.2f}", dY);
|
||
}
|
||
|
||
// DA-string
|
||
if (pListDA)
|
||
{
|
||
for (i = 0; i < pListDA->GetLength(); ++i)
|
||
{
|
||
m_seAppBuffer->Append((StringExt *)pListDA->GetByIndex(i))->Append(' ');
|
||
}
|
||
}
|
||
|
||
// Пишем Font Matrix (если она не была уже в DA-string)
|
||
if (nTmPos < 0)
|
||
{
|
||
m_seAppBuffer->AppendFormat("1 0 0 1 {0:.2f} {1:.2f} Tm\n", dX, dY);
|
||
}
|
||
|
||
// Пишем текст
|
||
m_seAppBuffer->Append('(');
|
||
for (i = 0; i < seText->GetLength(); ++i)
|
||
{
|
||
nChar = seText->GetAt(i) & 0xff;
|
||
if (nChar == '(' || nChar == ')' || nChar == '\\')
|
||
{
|
||
m_seAppBuffer->Append('\\');
|
||
m_seAppBuffer->Append(nChar);
|
||
}
|
||
else if (nChar < 0x20 || nChar >= 0x80)
|
||
{
|
||
m_seAppBuffer->AppendFormat("\\{0:03o}", nChar);
|
||
}
|
||
else
|
||
{
|
||
m_seAppBuffer->Append(nChar);
|
||
}
|
||
}
|
||
m_seAppBuffer->Append(") Tj\n");
|
||
}
|
||
}
|
||
|
||
m_seAppBuffer->Append("ET\n");
|
||
m_seAppBuffer->Append("Q\n");
|
||
|
||
if (bTextField)
|
||
{
|
||
m_seAppBuffer->Append("EMC\n");
|
||
}
|
||
|
||
if (pListDA)
|
||
{
|
||
DeleteCList(pListDA, StringExt);
|
||
}
|
||
}
|
||
|
||
// Рисуем текст или название для Field.
|
||
void Annot::DrawListBox(StringExt **ppText, bool *pSelection, int nOptionsCount, int nTopIndex, StringExt *seDA, GrFontDict *pFontDict, int nQuadding)
|
||
{
|
||
CList *pListDA;
|
||
StringExt *seToken;
|
||
int i, j;
|
||
|
||
// Парсим Default appearance string
|
||
int nTfPos = -1, nTmPos = -1;
|
||
if (seDA)
|
||
{
|
||
pListDA = new CList();
|
||
i = 0;
|
||
while (i < seDA->GetLength())
|
||
{
|
||
while (i < seDA->GetLength() && Lexer::IsSpace(seDA->GetAt(i)))
|
||
{
|
||
++i;
|
||
}
|
||
if (i < seDA->GetLength())
|
||
{
|
||
for (j = i + 1; j < seDA->GetLength() && !Lexer::IsSpace(seDA->GetAt(j)); ++j);
|
||
pListDA->Append(new StringExt(seDA, i, j - i));
|
||
i = j;
|
||
}
|
||
}
|
||
for (i = 2; i < pListDA->GetLength(); ++i)
|
||
{
|
||
if (i >= 2 && !((StringExt *)pListDA->GetByIndex(i))->Compare("Tf"))
|
||
{
|
||
nTfPos = i - 2;
|
||
}
|
||
else if (i >= 6 && !((StringExt *)pListDA->GetByIndex(i))->Compare("Tm"))
|
||
{
|
||
nTmPos = i - 6;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
pListDA = NULL;
|
||
}
|
||
|
||
// Считываем шрифт и размер шрифта
|
||
GrFont *pFont = NULL;
|
||
double dFontSize = 0;
|
||
if (nTfPos >= 0)
|
||
{
|
||
seToken = (StringExt *)pListDA->GetByIndex(nTfPos);
|
||
if (seToken->GetLength() >= 1 && seToken->GetAt(0) == '/')
|
||
{
|
||
if (!pFontDict || !(pFont = pFontDict->Search(seToken->GetBuffer() + 1)))
|
||
{
|
||
// TO DO: Error "Unknown font in field's DA string"
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// TO DO: Error "Invalid font name in 'Tf' operator in field's DA string"
|
||
}
|
||
seToken = (StringExt *)pListDA->GetByIndex(nTfPos + 1);
|
||
dFontSize = atof(seToken->GetBuffer());
|
||
}
|
||
else
|
||
{
|
||
// TO DO: Error "Missing 'Tf' operator in field's DA string"
|
||
}
|
||
|
||
// Border width
|
||
double dBorder = m_pBorderStyle->GetWidth();
|
||
|
||
// Вычислим размер фонта, если он не был задан
|
||
double dWidth = 0;
|
||
if (0 == dFontSize)
|
||
{
|
||
double dMaxW = 0;
|
||
for (i = 0; i < nOptionsCount; ++i)
|
||
{
|
||
if (pFont && !pFont->IsCIDFont())
|
||
{
|
||
dWidth = 0;
|
||
for (j = 0; j < ppText[i]->GetLength(); ++j)
|
||
{
|
||
dWidth += ((Gr8BitFont *)pFont)->GetWidth(ppText[i]->GetAt(j));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// грубая оценка
|
||
dWidth = ppText[i]->GetLength() * 0.5;
|
||
}
|
||
if (dWidth > dMaxW)
|
||
{
|
||
dMaxW = dWidth;
|
||
}
|
||
}
|
||
dFontSize = m_dMaxY - m_dMinY - 2 * dBorder;
|
||
double dFontSize2 = (m_dMaxX - m_dMinX - 4 - 2 * dBorder) / dMaxW;
|
||
|
||
if (dFontSize2 < dFontSize)
|
||
{
|
||
dFontSize = dFontSize2;
|
||
}
|
||
dFontSize = floor(dFontSize);
|
||
|
||
if (nTfPos >= 0)
|
||
{
|
||
seToken = (StringExt *)pListDA->GetByIndex(nTfPos + 1);
|
||
seToken->Clear();
|
||
seToken->AppendFormat("{0:.2f}", dFontSize);
|
||
}
|
||
}
|
||
|
||
// Рисуем текст
|
||
double dY = m_dMaxY - m_dMinY - 1.1 * dFontSize;
|
||
|
||
for (i = nTopIndex; i < nOptionsCount; ++i)
|
||
{
|
||
m_seAppBuffer->Append("q\n");
|
||
|
||
// Background
|
||
if (pSelection[i])
|
||
{
|
||
m_seAppBuffer->Append("0 g f\n");
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {1:.2f} {2:.2f} {3:.2f} re f\n", dBorder, dY - 0.2 * dFontSize, m_dMaxX - m_dMinX - 2 * dBorder, 1.1 * dFontSize);
|
||
}
|
||
|
||
m_seAppBuffer->Append("BT\n");
|
||
|
||
// Вычислим ширину строки
|
||
if (pFont && !pFont->IsCIDFont())
|
||
{
|
||
dWidth = 0;
|
||
for (j = 0; j < ppText[i]->GetLength(); ++j)
|
||
{
|
||
dWidth += ((Gr8BitFont *)pFont)->GetWidth(ppText[i]->GetAt(j));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// грубая оценка
|
||
dWidth = ppText[i]->GetLength() * 0.5;
|
||
}
|
||
|
||
// Вычислим начальную позицию текста
|
||
double dX = 0;
|
||
dWidth *= dFontSize;
|
||
switch (nQuadding)
|
||
{
|
||
case fieldQuadLeft:
|
||
default:
|
||
dX = dBorder + 2;
|
||
break;
|
||
case fieldQuadCenter:
|
||
dX = (m_dMaxX - m_dMinX - dWidth) / 2;
|
||
break;
|
||
case fieldQuadRight:
|
||
dX = m_dMaxX - m_dMinX - dBorder - 2 - dWidth;
|
||
break;
|
||
}
|
||
|
||
// Font Matrix
|
||
if (nTmPos >= 0)
|
||
{
|
||
seToken = (StringExt *)pListDA->GetByIndex(nTmPos + 4);
|
||
seToken->Clear();
|
||
seToken->AppendFormat("{0:.2f}", dX);
|
||
seToken = (StringExt *)pListDA->GetByIndex(nTmPos + 5);
|
||
seToken->Clear();
|
||
seToken->AppendFormat("{0:.2f}", dY);
|
||
}
|
||
|
||
// DA string
|
||
if (pListDA)
|
||
{
|
||
for (j = 0; j < pListDA->GetLength(); ++j)
|
||
{
|
||
m_seAppBuffer->Append((StringExt *)pListDA->GetByIndex(j))->Append(' ');
|
||
}
|
||
}
|
||
|
||
// Пишем Font Matrix (если он не был частью DA-string)
|
||
if (nTmPos < 0)
|
||
{
|
||
m_seAppBuffer->AppendFormat("1 0 0 1 {0:.2f} {1:.2f} Tm\n", dX, dY);
|
||
}
|
||
|
||
if (pSelection[i])
|
||
{
|
||
m_seAppBuffer->Append("1 g\n");
|
||
}
|
||
|
||
// Пишем текст
|
||
m_seAppBuffer->Append('(');
|
||
for (j = 0; j < ppText[i]->GetLength(); ++j)
|
||
{
|
||
int nChar = ppText[i]->GetAt(j) & 0xff;
|
||
if (nChar == '(' || nChar == ')' || nChar == '\\')
|
||
{
|
||
m_seAppBuffer->Append('\\');
|
||
m_seAppBuffer->Append(nChar);
|
||
}
|
||
else if (nChar < 0x20 || nChar >= 0x80)
|
||
{
|
||
m_seAppBuffer->AppendFormat("\\{0:03o}", nChar);
|
||
}
|
||
else
|
||
{
|
||
m_seAppBuffer->Append(nChar);
|
||
}
|
||
}
|
||
m_seAppBuffer->Append(") Tj\n");
|
||
|
||
m_seAppBuffer->Append("ET\n");
|
||
m_seAppBuffer->Append("Q\n");
|
||
|
||
// Следующая строка
|
||
dY -= 1.1 * dFontSize;
|
||
}
|
||
|
||
if (pListDA)
|
||
{
|
||
DeleteCList(pListDA, StringExt);
|
||
}
|
||
}
|
||
|
||
void Annot::GetNextLine(StringExt *seText, int nStart, GrFont *pFont, double dFontSize, double dMaxW, int *pEnd, double *pWidth, int *pNext)
|
||
{
|
||
double dWidth = 0, dTempWidth;
|
||
int j, k;
|
||
|
||
|
||
for (j = nStart; j < seText->GetLength() && dWidth <= dMaxW; ++j)
|
||
{
|
||
int nChar = seText->GetAt(j) & 0xff;
|
||
if (nChar == 0x0a || nChar == 0x0d)
|
||
{
|
||
break;
|
||
}
|
||
if (pFont && !pFont->IsCIDFont())
|
||
{
|
||
dTempWidth = ((Gr8BitFont *)pFont)->GetWidth(nChar) * dFontSize;
|
||
}
|
||
else
|
||
{
|
||
// грубая оценка
|
||
dTempWidth = 0.5 * dFontSize;
|
||
}
|
||
dWidth += dTempWidth;
|
||
}
|
||
if (dWidth > dMaxW)
|
||
{
|
||
for (k = j; k > nStart && seText->GetAt(k - 1) != ' '; --k);
|
||
for (; k > nStart && seText->GetAt(k - 1) == ' '; --k);
|
||
if (k > nStart)
|
||
{
|
||
j = k;
|
||
}
|
||
|
||
if (j == nStart)
|
||
{
|
||
// Обрабатываем странный случай, когда первый символ слишком широкий для первой строки
|
||
j = nStart + 1;
|
||
}
|
||
}
|
||
*pEnd = j;
|
||
|
||
// Вычисляем ширину
|
||
dWidth = 0;
|
||
for (k = nStart; k < j; ++k)
|
||
{
|
||
if (pFont && !pFont->IsCIDFont())
|
||
{
|
||
dTempWidth = ((Gr8BitFont *)pFont)->GetWidth(seText->GetAt(k)) * dFontSize;
|
||
}
|
||
else
|
||
{
|
||
dTempWidth = 0.5 * dFontSize;
|
||
}
|
||
dWidth += dTempWidth;
|
||
}
|
||
*pWidth = dWidth;
|
||
|
||
while (j < seText->GetLength() && seText->GetAt(j) == ' ')
|
||
{
|
||
++j;
|
||
}
|
||
if (j < seText->GetLength() && seText->GetAt(j) == 0x0d)
|
||
{
|
||
++j;
|
||
}
|
||
if (j < seText->GetLength() && seText->GetAt(j) == 0x0a)
|
||
{
|
||
++j;
|
||
}
|
||
*pNext = j;
|
||
}
|
||
|
||
|
||
// Расстояние от центра до контрольных точек кривой Безье
|
||
// = (4 * (sqrt(2) - 1) / 3) * r
|
||
#define Kappa 0.55228475
|
||
|
||
// Рисуем окружность с помощью кривых Безье. (dX, dY) - центр, dRad - радиус.
|
||
// bFill - будем заливать или обводить?
|
||
void Annot::DrawCircle(double dX, double dY, double dRad, bool bFill)
|
||
{
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {1:.2f} m\n", dX + dRad, dY);
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {1:.2f} {2:.2f} {3:.2f} {4:.2f} {5:.2f} c\n", dX + dRad, dY + Kappa * dRad, dX + Kappa * dRad, dY + dRad, dX, dY + dRad);
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {1:.2f} {2:.2f} {3:.2f} {4:.2f} {5:.2f} c\n", dX - Kappa * dRad, dY + dRad, dX - dRad, dY + Kappa * dRad, dX - dRad, dY);
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {1:.2f} {2:.2f} {3:.2f} {4:.2f} {5:.2f} c\n", dX - dRad, dY - Kappa * dRad, dX - Kappa * dRad, dY - dRad, dX, dY - dRad);
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {1:.2f} {2:.2f} {3:.2f} {4:.2f} {5:.2f} c\n", dX + Kappa * dRad, dY - dRad, dX + dRad, dY - Kappa * dRad, dX + dRad, dY);
|
||
m_seAppBuffer->Append(bFill ? "f\n" : "s\n");
|
||
}
|
||
|
||
// Рисуем половину окружности (левую верхнюю) с помощью кривых Безье. (dX, dY) - центр, dRad - радиус.
|
||
void Annot::DrawCircleTopLeft(double dX, double dY, double dRad)
|
||
{
|
||
double dRad2 = dRad / sqrt(2.0);
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {1:.2f} m\n", dX + dRad2, dY + dRad2);
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {1:.2f} {2:.2f} {3:.2f} {4:.2f} {5:.2f} c\n", dX + (1 - Kappa) * dRad2, dY + (1 + Kappa) * dRad2, dX - (1 - Kappa) * dRad2, dY + (1 + Kappa) * dRad2, dX - dRad2, dY + dRad2);
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {1:.2f} {2:.2f} {3:.2f} {4:.2f} {5:.2f} c\n", dX - (1 + Kappa) * dRad2, dY + (1 - Kappa) * dRad2, dX - (1 + Kappa) * dRad2, dY - (1 - Kappa) * dRad2, dX - dRad2, dY - dRad2);
|
||
m_seAppBuffer->Append("S\n");
|
||
}
|
||
|
||
// Рисуем половину окружности (правую нижнюю) с помощью кривых Безье. (dX, dY) - центр, dRad - радиус.
|
||
void Annot::DrawCircleBottomRight(double dX, double dY, double dRad)
|
||
{
|
||
double dRad2 = dRad / sqrt(2.0);
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {1:.2f} m\n", dX - dRad2, dY - dRad2);
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {1:.2f} {2:.2f} {3:.2f} {4:.2f} {5:.2f} c\n", dX - (1 - Kappa) * dRad2, dY - (1 + Kappa) * dRad2, dX + (1 - Kappa) * dRad2, dY - (1 + Kappa) * dRad2, dX + dRad2, dY - dRad2);
|
||
m_seAppBuffer->AppendFormat("{0:.2f} {1:.2f} {2:.2f} {3:.2f} {4:.2f} {5:.2f} c\n", dX + (1 + Kappa) * dRad2, dY - (1 - Kappa) * dRad2, dX + (1 + Kappa) * dRad2, dY + (1 - Kappa) * dRad2, dX + dRad2, dY + dRad2);
|
||
m_seAppBuffer->Append("S\n");
|
||
}
|
||
|
||
Object *Annot::FieldLookup(Dict *pField, char *sKey, Object *pObject)
|
||
{
|
||
Dict *pDict = pField;
|
||
if (!pDict->Search(sKey, pObject)->IsNull())
|
||
{
|
||
return pObject;
|
||
}
|
||
pObject->Free();
|
||
|
||
Object oParent;
|
||
if (pDict->Search("Parent", &oParent)->IsDict())
|
||
{
|
||
FieldLookup(oParent.GetDict(), sKey, pObject);
|
||
}
|
||
else
|
||
{
|
||
pObject->InitNull();
|
||
}
|
||
oParent.Free();
|
||
return pObject;
|
||
}
|
||
|
||
void Annot::Draw(Graphics *pGraphics, bool bPrinting)
|
||
{
|
||
// Flags
|
||
if ((m_nFlags & annotFlagHidden) || (bPrinting && !(m_nFlags & annotFlagPrint)) || (!bPrinting && (m_nFlags & annotFlagNoView)))
|
||
{
|
||
return;
|
||
}
|
||
|
||
// Appearance stream
|
||
bool bIsLink = m_seType && !m_seType->Compare("Link");
|
||
|
||
Object oTemp;
|
||
m_oAppearance.Fetch(m_pXref, &oTemp);
|
||
pGraphics->DrawAnnotation(&oTemp, (bIsLink ? m_pBorderStyle : (AnnotBorderStyle *)NULL), m_dMinX, m_dMinY, m_dMaxX, m_dMaxY);
|
||
oTemp.Free();
|
||
}
|
||
|
||
//-------------------------------------------------------------------------------------------------------------------------------
|
||
// Annots
|
||
//-------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
Annots::Annots(GlobalParams *pGlobalParams, XRef *pXref, Catalog *pCatalog, Object *pAnnotsObject)
|
||
{
|
||
m_pGlobalParams = pGlobalParams;
|
||
|
||
Annot *pAnnot = NULL;
|
||
Ref oRef;
|
||
|
||
m_ppAnnots = NULL;
|
||
int nSize = 0;
|
||
m_nAnnotsCount = 0;
|
||
|
||
Dict *pAcroForm = (pCatalog->GetAcroForm()->IsDict() ? pCatalog->GetAcroForm()->GetDict() : NULL);
|
||
if (pAnnotsObject->IsArray())
|
||
{
|
||
for (int nIndex = 0; nIndex < pAnnotsObject->ArrayGetLength(); ++nIndex)
|
||
{
|
||
Object oTemp;
|
||
if (pAnnotsObject->ArrayGetCopy(nIndex, &oTemp)->IsRef())
|
||
{
|
||
oRef = oTemp.GetRef();
|
||
oTemp.Free();
|
||
pAnnotsObject->ArrayGet(nIndex, &oTemp);
|
||
}
|
||
else
|
||
{
|
||
oRef.nNum = oRef.nGen = -1;
|
||
}
|
||
if (oTemp.IsDict())
|
||
{
|
||
pAnnot = new Annot(m_pGlobalParams, pXref, pAcroForm, oTemp.GetDict(), &oRef);
|
||
if (pAnnot->CheckValidation())
|
||
{
|
||
if (m_nAnnotsCount >= nSize)
|
||
{
|
||
nSize += 16;
|
||
m_ppAnnots = (Annot **)MemUtilsReallocArray(m_ppAnnots, nSize, sizeof(Annot *));
|
||
}
|
||
m_ppAnnots[m_nAnnotsCount++] = pAnnot;
|
||
}
|
||
else
|
||
{
|
||
delete pAnnot;
|
||
}
|
||
}
|
||
oTemp.Free();
|
||
}
|
||
}
|
||
}
|
||
|
||
Annots::~Annots()
|
||
{
|
||
for (int nIndex = 0; nIndex < m_nAnnotsCount; ++nIndex)
|
||
{
|
||
delete m_ppAnnots[nIndex];
|
||
}
|
||
MemUtilsFree(m_ppAnnots);
|
||
}
|
||
|
||
void Annots::GenerateAppearances(Dict *pAcroForm)
|
||
{
|
||
Ref oRef;
|
||
|
||
Object oField;
|
||
if (pAcroForm->Search("Fields", &oField)->IsArray())
|
||
{
|
||
for (int nIndex = 0; nIndex < oField.ArrayGetLength(); ++nIndex)
|
||
{
|
||
Object oItem;
|
||
if (oField.ArrayGetCopy(nIndex, &oItem)->IsRef())
|
||
{
|
||
oRef = oItem.GetRef();
|
||
oItem.Free();
|
||
oField.ArrayGet(nIndex, &oItem);
|
||
}
|
||
else
|
||
{
|
||
oRef.nNum = oRef.nGen = -1;
|
||
}
|
||
if (oItem.IsDict())
|
||
{
|
||
ScanFieldAppearances(oItem.GetDict(), &oRef, NULL, pAcroForm);
|
||
}
|
||
oItem.Free();
|
||
}
|
||
}
|
||
oField.Free();
|
||
}
|
||
|
||
void Annots::ScanFieldAppearances(Dict *pNode, Ref *pRef, Dict *pParent, Dict *pAcroForm)
|
||
{
|
||
Annot *pAnnot = NULL;
|
||
Ref oRef2;
|
||
|
||
Object oNodeItem;
|
||
if (pNode->Search("Kids", &oNodeItem)->IsArray())
|
||
{
|
||
for (int nIndex = 0; nIndex < oNodeItem.ArrayGetLength(); ++nIndex)
|
||
{
|
||
Object oTemp;
|
||
if (oNodeItem.ArrayGetCopy(nIndex, &oTemp)->IsRef())
|
||
{
|
||
oRef2 = oTemp.GetRef();
|
||
oTemp.Free();
|
||
oNodeItem.ArrayGet(nIndex, &oTemp);
|
||
}
|
||
else
|
||
{
|
||
oRef2.nNum = oRef2.nGen = -1;
|
||
}
|
||
if (oTemp.IsDict())
|
||
{
|
||
ScanFieldAppearances(oTemp.GetDict(), &oRef2, pNode, pAcroForm);
|
||
}
|
||
oTemp.Free();
|
||
}
|
||
oNodeItem.Free();
|
||
return;
|
||
}
|
||
oNodeItem.Free();
|
||
|
||
if ((pAnnot = FindAnnot(pRef)))
|
||
{
|
||
pNode->SearchAndCopy("Parent", &oNodeItem);
|
||
if (!pParent || !oNodeItem.IsNull())
|
||
{
|
||
pAnnot->GenerateFieldAppearance(pNode, pNode, pAcroForm);
|
||
}
|
||
else
|
||
{
|
||
pAnnot->GenerateFieldAppearance(pParent, pNode, pAcroForm);
|
||
}
|
||
oNodeItem.Free();
|
||
}
|
||
}
|
||
|
||
Annot *Annots::FindAnnot(Ref *pRef)
|
||
{
|
||
for (int nIndex = 0; nIndex < m_nAnnotsCount; ++nIndex)
|
||
{
|
||
if (m_ppAnnots[nIndex]->Match(pRef))
|
||
{
|
||
return m_ppAnnots[nIndex];
|
||
}
|
||
}
|
||
return NULL;
|
||
}
|
||
}
|