void CPDF_ReflowedPage::FocusGetData(const CFX_AffineMatrix matrix, FX_INT32 x, FX_INT32 y, CFX_ByteString& str)
{
if (NULL == m_pReflowed) {
return;
}
CFX_AffineMatrix revMatrix;
revMatrix.SetReverse(matrix);
FX_FLOAT x1, y1;
revMatrix.Transform((float)x, (float)y, x1, y1);
int count = m_pReflowed->GetSize();
FX_FLOAT dx = 1000, dy = 1000;
FX_INT32 pos = 0;
FX_INT32 i;
for(i = 0; i < count; i++) {
CRF_Data* pData = (*m_pReflowed)[i];
FX_FLOAT tempdy = FXSYS_fabs(pData->m_PosY - y1);
if(FXSYS_fabs(tempdy - dy) < 1) {
continue;
}
CFX_FloatRect rect (0, pData->m_PosY + pData->m_Height, this->m_PageWidth, pData->m_PosY);
if(rect.Contains(x1, y1)) {
pos = i;
dx = 0;
dy = 0;
break;
} else if(tempdy < dy) {
dy = tempdy;
dx = FXSYS_fabs(pData->m_PosX - x1);
pos = i;
} else if (tempdy == dy) {
FX_FLOAT tempdx = FXSYS_fabs(pData->m_PosX - x1);
if(tempdx < dx) {
dx = tempdx;
pos = i;
}
} else if (tempdy > dy) {
break;
}
}
if(dx != 0 || dy != 0) {
count = count < (pos + 10) ? count : (pos + 10);
for(i = 0 > (pos - 10) ? 0 : (pos - 10); i < count; i++) {
CRF_Data* pData = (*m_pReflowed)[i];
FX_FLOAT tempdy = FXSYS_fabs(pData->m_PosY - y1);
if(tempdy < dy) {
dy = tempdy;
dx = FXSYS_fabs(pData->m_PosX - x1);
pos = i;
} else if (tempdy == dy) {
FX_FLOAT tempdx = FXSYS_fabs(pData->m_PosX - x1);
if(tempdx < dx) {
dx = tempdx;
pos = i;
}
}
}
}
str.Format("%d", pos);
}
FX_BOOL CPDF_FormField::CheckControl(int iControlIndex,
bool bChecked,
bool bNotify) {
ASSERT(GetType() == CheckBox || GetType() == RadioButton);
CPDF_FormControl* pControl = GetControl(iControlIndex);
if (!pControl) {
return FALSE;
}
if (!bChecked && pControl->IsChecked() == bChecked) {
return FALSE;
}
CFX_WideString csWExport = pControl->GetExportValue();
CFX_ByteString csBExport = PDF_EncodeText(csWExport);
int iCount = CountControls();
bool bUnison = PDF_FormField_IsUnison(this);
for (int i = 0; i < iCount; i++) {
CPDF_FormControl* pCtrl = GetControl(i);
if (bUnison) {
CFX_WideString csEValue = pCtrl->GetExportValue();
if (csEValue == csWExport) {
if (pCtrl->GetOnStateName() == pControl->GetOnStateName()) {
pCtrl->CheckControl(bChecked);
} else if (bChecked) {
pCtrl->CheckControl(FALSE);
}
} else if (bChecked) {
pCtrl->CheckControl(FALSE);
}
} else {
if (i == iControlIndex) {
pCtrl->CheckControl(bChecked);
} else if (bChecked) {
pCtrl->CheckControl(FALSE);
}
}
}
CPDF_Object* pOpt = FPDF_GetFieldAttr(m_pDict, "Opt");
if (!ToArray(pOpt)) {
if (bChecked) {
m_pDict->SetAtName("V", csBExport);
} else {
CFX_ByteString csV;
CPDF_Object* pV = FPDF_GetFieldAttr(m_pDict, "V");
if (pV) {
csV = pV->GetString();
}
if (csV == csBExport) {
m_pDict->SetAtName("V", "Off");
}
}
} else if (bChecked) {
CFX_ByteString csIndex;
csIndex.Format("%d", iControlIndex);
m_pDict->SetAtName("V", csIndex);
}
if (bNotify && m_pForm->m_pFormNotify)
m_pForm->m_pFormNotify->AfterCheckedStatusChange(this);
return TRUE;
}
FXFT_Face CFX_FontMgr::AddCachedTTCFace(int ttc_size, FX_DWORD checksum,
uint8_t* pData, FX_DWORD size, int font_offset)
{
CFX_ByteString key;
key.Format("%d:%d", ttc_size, checksum);
CTTFontDesc* pFontDesc = new CTTFontDesc;
pFontDesc->m_Type = 2;
pFontDesc->m_pFontData = pData;
for (int i = 0; i < 16; i ++) {
pFontDesc->m_TTCFace.m_pFaces[i] = NULL;
}
pFontDesc->m_RefCount ++;
key.Format("%d:%d", ttc_size, checksum);
m_FaceMap.SetAt(key, pFontDesc);
int face_index = GetTTCIndex(pFontDesc->m_pFontData, ttc_size, font_offset);
pFontDesc->m_TTCFace.m_pFaces[face_index] = GetFixedFace(pFontDesc->m_pFontData, ttc_size, face_index);
return pFontDesc->m_TTCFace.m_pFaces[face_index];
}
CFX_ByteString CPDF_InterForm::GenerateNewResourceName(
const CPDF_Dictionary* pResDict,
const FX_CHAR* csType,
int iMinLen,
const FX_CHAR* csPrefix) {
CFX_ByteString csStr = csPrefix;
CFX_ByteString csBType = csType;
if (csStr.IsEmpty()) {
if (csBType == "ExtGState") {
csStr = "GS";
} else if (csBType == "ColorSpace") {
csStr = "CS";
} else if (csBType == "Font") {
csStr = "ZiTi";
} else {
csStr = "Res";
}
}
CFX_ByteString csTmp = csStr;
int iCount = csStr.GetLength();
int m = 0;
if (iMinLen > 0) {
csTmp = "";
while (m < iMinLen && m < iCount) {
csTmp += csStr[m++];
}
while (m < iMinLen) {
csTmp += '0' + m % 10;
m++;
}
} else {
m = iCount;
}
if (pResDict == NULL) {
return csTmp;
}
CPDF_Dictionary* pDict = pResDict->GetDict(csType);
if (pDict == NULL) {
return csTmp;
}
int num = 0;
CFX_ByteString bsNum;
while (TRUE) {
if (!pDict->KeyExist(csTmp + bsNum)) {
return csTmp + bsNum;
}
if (m < iCount) {
csTmp += csStr[m++];
} else {
bsNum.Format("%d", num++);
}
m++;
}
return csTmp;
}
FX_BOOL CPDF_PageOrganizer::PDFDocInit(CPDF_Document* pDestPDFDoc,
CPDF_Document* pSrcPDFDoc) {
if (!pDestPDFDoc || !pSrcPDFDoc)
return FALSE;
CPDF_Dictionary* pNewRoot = pDestPDFDoc->GetRoot();
if (!pNewRoot)
return FALSE;
// Set the document information////////////////////////////////////////////
CPDF_Dictionary* DInfoDict = pDestPDFDoc->GetInfo();
if (!DInfoDict)
return FALSE;
CFX_ByteString producerstr;
producerstr.Format("PDFium");
DInfoDict->SetAt("Producer", new CPDF_String(producerstr));
// Set type////////////////////////////////////////////////////////////////
CFX_ByteString cbRootType = pNewRoot->GetString("Type", "");
if (cbRootType.Equal("")) {
pNewRoot->SetAt("Type", new CPDF_Name("Catalog"));
}
CPDF_Object* pElement = pNewRoot->GetElement("Pages");
CPDF_Dictionary* pNewPages =
pElement ? ToDictionary(pElement->GetDirect()) : nullptr;
if (!pNewPages) {
pNewPages = new CPDF_Dictionary;
FX_DWORD NewPagesON = pDestPDFDoc->AddIndirectObject(pNewPages);
pNewRoot->SetAt("Pages", new CPDF_Reference(pDestPDFDoc, NewPagesON));
}
CFX_ByteString cbPageType = pNewPages->GetString("Type", "");
if (cbPageType.Equal("")) {
pNewPages->SetAt("Type", new CPDF_Name("Pages"));
}
CPDF_Array* pKeysArray = pNewPages->GetArray("Kids");
if (!pKeysArray) {
CPDF_Array* pNewKids = new CPDF_Array;
FX_DWORD Kidsobjnum = -1;
Kidsobjnum = pDestPDFDoc->AddIndirectObject(pNewKids);
pNewPages->SetAt("Kids", new CPDF_Reference(pDestPDFDoc, Kidsobjnum));
pNewPages->SetAt("Count", new CPDF_Number(0));
}
return TRUE;
}
CFX_ByteString CPDF_FormControl::GetCheckedAPState() {
ASSERT(GetType() == CPDF_FormField::CheckBox ||
GetType() == CPDF_FormField::RadioButton);
CFX_ByteString csOn = GetOnStateName();
if (GetType() == CPDF_FormField::RadioButton ||
GetType() == CPDF_FormField::CheckBox) {
if (ToArray(FPDF_GetFieldAttr(m_pField->m_pDict, "Opt"))) {
int iIndex = m_pField->GetControlIndex(this);
csOn.Format("%d", iIndex);
}
}
if (csOn.IsEmpty())
csOn = "Yes";
return csOn;
}
CFX_ByteString CPDF_FormControl::GetCheckedAPState()
{
ASSERT(GetType() == CPDF_FormField::CheckBox || GetType() == CPDF_FormField::RadioButton);
CFX_ByteString csOn = GetOnStateName();
if (GetType() == CPDF_FormField::RadioButton || GetType() == CPDF_FormField::CheckBox) {
CPDF_Object* pOpt = FPDF_GetFieldAttr(m_pField->m_pDict, "Opt");
if (pOpt != NULL && pOpt->GetType() == PDFOBJ_ARRAY) {
int iIndex = m_pField->GetControlIndex(this);
csOn.Format("%d", iIndex);
}
}
if (csOn.IsEmpty()) {
csOn = "Yes";
}
return csOn;
}
FXFT_Face CFX_FontMgr::GetCachedTTCFace(int ttc_size, FX_DWORD checksum,
int font_offset, FX_LPBYTE& pFontData)
{
CFX_ByteString key;
key.Format("%d:%d", ttc_size, checksum);
CTTFontDesc* pFontDesc = NULL;
m_FaceMap.Lookup(key, (void*&)pFontDesc);
if (pFontDesc == NULL) {
return NULL;
}
pFontData = pFontDesc->m_pFontData;
pFontDesc->m_RefCount ++;
int face_index = GetTTCIndex(pFontDesc->m_pFontData, ttc_size, font_offset);
if (pFontDesc->m_TTCFace.m_pFaces[face_index] == NULL) {
pFontDesc->m_TTCFace.m_pFaces[face_index] = GetFixedFace(pFontDesc->m_pFontData, ttc_size, face_index);
}
return pFontDesc->m_TTCFace.m_pFaces[face_index];
}
FX_BOOL CPDF_PageOrganizer::PDFDocInit(CPDF_Document* pDestPDFDoc,
CPDF_Document* pSrcPDFDoc) {
if (!pDestPDFDoc || !pSrcPDFDoc)
return FALSE;
CPDF_Dictionary* pNewRoot = pDestPDFDoc->GetRoot();
if (!pNewRoot)
return FALSE;
CPDF_Dictionary* DInfoDict = pDestPDFDoc->GetInfo();
if (!DInfoDict)
return FALSE;
CFX_ByteString producerstr;
producerstr.Format("PDFium");
DInfoDict->SetFor("Producer", new CPDF_String(producerstr, FALSE));
CFX_ByteString cbRootType = pNewRoot->GetStringFor("Type", "");
if (cbRootType.IsEmpty())
pNewRoot->SetFor("Type", new CPDF_Name("Catalog"));
CPDF_Object* pElement = pNewRoot->GetObjectFor("Pages");
CPDF_Dictionary* pNewPages =
pElement ? ToDictionary(pElement->GetDirect()) : nullptr;
if (!pNewPages) {
pNewPages = new CPDF_Dictionary(pDestPDFDoc->GetByteStringPool());
pNewRoot->SetReferenceFor("Pages", pDestPDFDoc,
pDestPDFDoc->AddIndirectObject(pNewPages));
}
CFX_ByteString cbPageType = pNewPages->GetStringFor("Type", "");
if (cbPageType == "") {
pNewPages->SetFor("Type", new CPDF_Name("Pages"));
}
if (!pNewPages->GetArrayFor("Kids")) {
pNewPages->SetIntegerFor("Count", 0);
pNewPages->SetReferenceFor("Kids", pDestPDFDoc,
pDestPDFDoc->AddIndirectObject(new CPDF_Array));
}
return TRUE;
}
FX_BOOL CFX_PSRenderer::DrawText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont,
CFX_FontCache* pCache, const CFX_AffineMatrix* pObject2Device,
FX_FLOAT font_size, FX_DWORD color,
int alpha_flag, void* pIccTransform)
{
StartRendering();
int alpha = FXGETFLAG_COLORTYPE(alpha_flag) ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
if (alpha < 255) {
return FALSE;
}
if ((pObject2Device->a == 0 && pObject2Device->b == 0) || (pObject2Device->c == 0 && pObject2Device->d == 0)) {
return TRUE;
}
SetColor(color, alpha_flag, pIccTransform);
CFX_ByteTextBuf buf;
buf << FX_BSTRC("q[") << pObject2Device->a << FX_BSTRC(" ") << pObject2Device->b << FX_BSTRC(" ")
<< pObject2Device->c << FX_BSTRC(" ") << pObject2Device->d;
buf << FX_BSTRC(" ") << pObject2Device->e << FX_BSTRC(" ") << pObject2Device->f << "]cm\n";
if (pCache == NULL) {
pCache = CFX_GEModule::Get()->GetFontCache();
}
CFX_FaceCache* pFaceCache = pCache->GetCachedFace(pFont);
FX_FONTCACHE_DEFINE(pCache, pFont);
int last_fontnum = -1;
for (int i = 0; i < nChars; i ++) {
int ps_fontnum, ps_glyphindex;
FindPSFontGlyph(pFaceCache, pFont, pCharPos[i], ps_fontnum, ps_glyphindex);
if (last_fontnum != ps_fontnum) {
buf << FX_BSTRC("/X") << ps_fontnum << FX_BSTRC(" Ff ") << font_size
<< FX_BSTRC(" Fs Sf ");
last_fontnum = ps_fontnum;
}
buf << pCharPos[i].m_OriginX << FX_BSTRC(" ")
<< pCharPos[i].m_OriginY << FX_BSTRC(" m");
CFX_ByteString hex;
hex.Format("<%02X>", ps_glyphindex);
buf << hex << FX_BSTRC("Tj\n");
}
buf << FX_BSTRC("Q\n");
m_pOutput->OutputPS((FX_LPCSTR)buf.GetBuffer(), buf.GetSize());
return TRUE;
}
CFGAS_GEFont* CFGAS_FontMgrImp::GetFontByCodePage(
uint16_t wCodePage,
uint32_t dwFontStyles,
const FX_WCHAR* pszFontFamily) {
CFX_ByteString bsHash;
bsHash.Format("%d, %d", wCodePage, dwFontStyles);
bsHash += CFX_WideString(pszFontFamily).UTF8Encode();
uint32_t dwHash = FX_HashCode_GetA(bsHash.AsStringC(), false);
CFX_ArrayTemplate<CFGAS_GEFont*>* pFonts = nullptr;
if (m_Hash2Fonts.Lookup(dwHash, pFonts)) {
if (!pFonts)
return nullptr;
if (pFonts->GetSize() != 0)
return pFonts->GetAt(0)->Retain();
}
if (!pFonts)
pFonts = new CFX_ArrayTemplate<CFGAS_GEFont*>;
m_Hash2Fonts.SetAt(dwHash, pFonts);
CFX_FontDescriptorInfos* sortedFonts = nullptr;
if (!m_Hash2CandidateList.Lookup(dwHash, sortedFonts)) {
sortedFonts = new CFX_FontDescriptorInfos;
MatchFonts(*sortedFonts, wCodePage, dwFontStyles,
CFX_WideString(pszFontFamily), 0);
m_Hash2CandidateList.SetAt(dwHash, sortedFonts);
}
if (sortedFonts->GetSize() == 0)
return nullptr;
CFX_FontDescriptor* pDesc = sortedFonts->GetAt(0).pFont;
CFGAS_GEFont* pFont =
LoadFont(pDesc->m_wsFaceName, pDesc->m_nFaceIndex, nullptr);
if (pFont)
pFont->SetLogicalFontStyle(dwFontStyles);
pFonts->Add(pFont);
return pFont;
}
TEST(fxcrt, ByteStringFormatPrecision) {
{
CFX_ByteString str;
str.Format("%.2f", 1.12345);
EXPECT_EQ("1.12", str);
}
{
CFX_ByteString str;
str.Format("%.*f", 3, 1.12345);
EXPECT_EQ("1.123", str);
}
{
CFX_ByteString str;
str.Format("%f", 1.12345);
EXPECT_EQ("1.123450", str);
}
{
CFX_ByteString str;
str.Format("%-1f", 1.12345);
EXPECT_EQ("1.123450", str);
}
{
CFX_ByteString str;
str.Format("%0f", 1.12345);
EXPECT_EQ("1.123450", str);
}
{
CFX_ByteString str;
str.Format("%.1048576f", 1.2);
EXPECT_EQ("Bad precision", str);
}
}
TEST(fxcrt, ByteStringFormatWidth) {
{
CFX_ByteString str;
str.Format("%5d", 1);
EXPECT_EQ(" 1", str);
}
{
CFX_ByteString str;
str.Format("%d", 1);
EXPECT_EQ("1", str);
}
{
CFX_ByteString str;
str.Format("%*d", 5, 1);
EXPECT_EQ(" 1", str);
}
{
CFX_ByteString str;
str.Format("%-1d", 1);
EXPECT_EQ("1", str);
}
{
CFX_ByteString str;
str.Format("%0d", 1);
EXPECT_EQ("1", str);
}
{
CFX_ByteString str;
str.Format("%1048576d", 1);
EXPECT_EQ("Bad width", str);
}
}
DLLEXPORT FPDF_BOOL STDCALL FPDFPage_TransFormWithClip(FPDF_PAGE page,
FS_MATRIX* matrix,
FS_RECTF* clipRect) {
CPDF_Page* pPage = CPDFPageFromFPDFPage(page);
if (!pPage)
return FALSE;
CFX_ByteTextBuf textBuf;
textBuf << "q ";
CFX_FloatRect rect(clipRect->left, clipRect->bottom, clipRect->right,
clipRect->top);
rect.Normalize();
CFX_ByteString bsClipping;
bsClipping.Format("%f %f %f %f re W* n ", rect.left, rect.bottom,
rect.Width(), rect.Height());
textBuf << bsClipping;
CFX_ByteString bsMatix;
bsMatix.Format("%f %f %f %f %f %f cm ", matrix->a, matrix->b, matrix->c,
matrix->d, matrix->e, matrix->f);
textBuf << bsMatix;
CPDF_Dictionary* pPageDic = pPage->m_pFormDict;
CPDF_Object* pContentObj =
pPageDic ? pPageDic->GetElement("Contents") : nullptr;
if (!pContentObj)
pContentObj = pPageDic ? pPageDic->GetArrayBy("Contents") : nullptr;
if (!pContentObj)
return FALSE;
CPDF_Dictionary* pDic = new CPDF_Dictionary;
CPDF_Stream* pStream = new CPDF_Stream(nullptr, 0, pDic);
pStream->SetData(textBuf.GetBuffer(), textBuf.GetSize(), FALSE, FALSE);
CPDF_Document* pDoc = pPage->m_pDocument;
if (!pDoc)
return FALSE;
pDoc->AddIndirectObject(pStream);
pDic = new CPDF_Dictionary;
CPDF_Stream* pEndStream = new CPDF_Stream(nullptr, 0, pDic);
pEndStream->SetData((const uint8_t*)" Q", 2, FALSE, FALSE);
pDoc->AddIndirectObject(pEndStream);
CPDF_Array* pContentArray = nullptr;
if (CPDF_Array* pArray = ToArray(pContentObj)) {
pContentArray = pArray;
CPDF_Reference* pRef = new CPDF_Reference(pDoc, pStream->GetObjNum());
pContentArray->InsertAt(0, pRef);
pContentArray->AddReference(pDoc, pEndStream);
} else if (CPDF_Reference* pReference = ToReference(pContentObj)) {
CPDF_Object* pDirectObj = pReference->GetDirect();
if (pDirectObj) {
if (CPDF_Array* pArray = pDirectObj->AsArray()) {
pContentArray = pArray;
CPDF_Reference* pRef = new CPDF_Reference(pDoc, pStream->GetObjNum());
pContentArray->InsertAt(0, pRef);
pContentArray->AddReference(pDoc, pEndStream);
} else if (pDirectObj->IsStream()) {
pContentArray = new CPDF_Array();
pContentArray->AddReference(pDoc, pStream->GetObjNum());
pContentArray->AddReference(pDoc, pDirectObj->GetObjNum());
pContentArray->AddReference(pDoc, pEndStream);
pPageDic->SetAtReference("Contents", pDoc,
pDoc->AddIndirectObject(pContentArray));
}
}
}
// Need to transform the patterns as well.
CPDF_Dictionary* pRes = pPageDic->GetDictBy("Resources");
if (pRes) {
CPDF_Dictionary* pPattenDict = pRes->GetDictBy("Pattern");
if (pPattenDict) {
for (const auto& it : *pPattenDict) {
CPDF_Object* pObj = it.second;
if (pObj->IsReference())
pObj = pObj->GetDirect();
CPDF_Dictionary* pDict = nullptr;
if (pObj->IsDictionary())
pDict = pObj->AsDictionary();
else if (CPDF_Stream* pStream = pObj->AsStream())
pDict = pStream->GetDict();
else
continue;
CFX_Matrix m = pDict->GetMatrixBy("Matrix");
CFX_Matrix t = *(CFX_Matrix*)matrix;
m.Concat(t);
pDict->SetAtMatrix("Matrix", m);
}
}
}
return TRUE;
}
DLLEXPORT int STDCALL FPDFPage_Flatten(FPDF_PAGE page, int nFlag) {
CPDF_Page* pPage = CPDFPageFromFPDFPage(page);
if (!page) {
return FLATTEN_FAIL;
}
CPDF_Document* pDocument = pPage->m_pDocument;
CPDF_Dictionary* pPageDict = pPage->m_pFormDict;
if (!pDocument || !pPageDict) {
return FLATTEN_FAIL;
}
CPDF_ObjectArray ObjectArray;
CPDF_RectArray RectArray;
int iRet = FLATTEN_FAIL;
iRet = ParserAnnots(pDocument, pPageDict, &RectArray, &ObjectArray, nFlag);
if (iRet == FLATTEN_NOTHINGTODO || iRet == FLATTEN_FAIL)
return iRet;
CFX_FloatRect rcOriginalCB;
CFX_FloatRect rcMerger = CalculateRect(&RectArray);
CFX_FloatRect rcOriginalMB = pPageDict->GetRectFor("MediaBox");
if (pPageDict->KeyExist("CropBox"))
rcOriginalMB = pPageDict->GetRectFor("CropBox");
if (rcOriginalMB.IsEmpty()) {
rcOriginalMB = CFX_FloatRect(0.0f, 0.0f, 612.0f, 792.0f);
}
rcMerger.left =
rcMerger.left < rcOriginalMB.left ? rcOriginalMB.left : rcMerger.left;
rcMerger.right =
rcMerger.right > rcOriginalMB.right ? rcOriginalMB.right : rcMerger.right;
rcMerger.top =
rcMerger.top > rcOriginalMB.top ? rcOriginalMB.top : rcMerger.top;
rcMerger.bottom = rcMerger.bottom < rcOriginalMB.bottom ? rcOriginalMB.bottom
: rcMerger.bottom;
if (pPageDict->KeyExist("ArtBox"))
rcOriginalCB = pPageDict->GetRectFor("ArtBox");
else
rcOriginalCB = rcOriginalMB;
if (!rcOriginalMB.IsEmpty()) {
CPDF_Array* pMediaBox = new CPDF_Array();
pMediaBox->Add(new CPDF_Number(rcOriginalMB.left));
pMediaBox->Add(new CPDF_Number(rcOriginalMB.bottom));
pMediaBox->Add(new CPDF_Number(rcOriginalMB.right));
pMediaBox->Add(new CPDF_Number(rcOriginalMB.top));
pPageDict->SetFor("MediaBox", pMediaBox);
}
if (!rcOriginalCB.IsEmpty()) {
CPDF_Array* pCropBox = new CPDF_Array();
pCropBox->Add(new CPDF_Number(rcOriginalCB.left));
pCropBox->Add(new CPDF_Number(rcOriginalCB.bottom));
pCropBox->Add(new CPDF_Number(rcOriginalCB.right));
pCropBox->Add(new CPDF_Number(rcOriginalCB.top));
pPageDict->SetFor("ArtBox", pCropBox);
}
CPDF_Dictionary* pRes = pPageDict->GetDictFor("Resources");
if (!pRes) {
pRes = new CPDF_Dictionary(pDocument->GetByteStringPool());
pPageDict->SetFor("Resources", pRes);
}
CPDF_Stream* pNewXObject = new CPDF_Stream(
nullptr, 0, new CPDF_Dictionary(pDocument->GetByteStringPool()));
uint32_t dwObjNum = pDocument->AddIndirectObject(pNewXObject);
CPDF_Dictionary* pPageXObject = pRes->GetDictFor("XObject");
if (!pPageXObject) {
pPageXObject = new CPDF_Dictionary(pDocument->GetByteStringPool());
pRes->SetFor("XObject", pPageXObject);
}
CFX_ByteString key = "";
int nStreams = ObjectArray.GetSize();
if (nStreams > 0) {
for (int iKey = 0; /*iKey < 100*/; iKey++) {
char sExtend[5] = {};
FXSYS_itoa(iKey, sExtend, 10);
key = CFX_ByteString("FFT") + CFX_ByteString(sExtend);
if (!pPageXObject->KeyExist(key))
break;
}
}
SetPageContents(key, pPageDict, pDocument);
CPDF_Dictionary* pNewXORes = nullptr;
if (!key.IsEmpty()) {
pPageXObject->SetReferenceFor(key, pDocument, dwObjNum);
CPDF_Dictionary* pNewOXbjectDic = pNewXObject->GetDict();
pNewXORes = new CPDF_Dictionary(pDocument->GetByteStringPool());
pNewOXbjectDic->SetFor("Resources", pNewXORes);
pNewOXbjectDic->SetNameFor("Type", "XObject");
pNewOXbjectDic->SetNameFor("Subtype", "Form");
pNewOXbjectDic->SetIntegerFor("FormType", 1);
pNewOXbjectDic->SetNameFor("Name", "FRM");
CFX_FloatRect rcBBox = pPageDict->GetRectFor("ArtBox");
pNewOXbjectDic->SetRectFor("BBox", rcBBox);
}
for (int i = 0; i < nStreams; i++) {
CPDF_Dictionary* pAnnotDic = ObjectArray.GetAt(i);
if (!pAnnotDic)
continue;
CFX_FloatRect rcAnnot = pAnnotDic->GetRectFor("Rect");
rcAnnot.Normalize();
CFX_ByteString sAnnotState = pAnnotDic->GetStringFor("AS");
CPDF_Dictionary* pAnnotAP = pAnnotDic->GetDictFor("AP");
if (!pAnnotAP)
continue;
CPDF_Stream* pAPStream = pAnnotAP->GetStreamFor("N");
if (!pAPStream) {
CPDF_Dictionary* pAPDic = pAnnotAP->GetDictFor("N");
if (!pAPDic)
continue;
if (!sAnnotState.IsEmpty()) {
pAPStream = pAPDic->GetStreamFor(sAnnotState);
} else {
auto it = pAPDic->begin();
if (it != pAPDic->end()) {
CPDF_Object* pFirstObj = it->second;
if (pFirstObj) {
if (pFirstObj->IsReference())
pFirstObj = pFirstObj->GetDirect();
if (!pFirstObj->IsStream())
continue;
pAPStream = pFirstObj->AsStream();
}
}
}
}
if (!pAPStream)
continue;
CPDF_Dictionary* pAPDic = pAPStream->GetDict();
CFX_Matrix matrix = pAPDic->GetMatrixFor("Matrix");
CFX_FloatRect rcStream;
if (pAPDic->KeyExist("Rect"))
rcStream = pAPDic->GetRectFor("Rect");
else if (pAPDic->KeyExist("BBox"))
rcStream = pAPDic->GetRectFor("BBox");
if (rcStream.IsEmpty())
continue;
CPDF_Object* pObj = pAPStream;
if (pObj) {
CPDF_Dictionary* pObjDic = pObj->GetDict();
if (pObjDic) {
pObjDic->SetNameFor("Type", "XObject");
pObjDic->SetNameFor("Subtype", "Form");
}
}
CPDF_Dictionary* pXObject = pNewXORes->GetDictFor("XObject");
if (!pXObject) {
pXObject = new CPDF_Dictionary(pDocument->GetByteStringPool());
pNewXORes->SetFor("XObject", pXObject);
}
CFX_ByteString sFormName;
sFormName.Format("F%d", i);
pXObject->SetReferenceFor(sFormName, pDocument,
pDocument->AddIndirectObject(pObj));
CPDF_StreamAcc acc;
acc.LoadAllData(pNewXObject);
const uint8_t* pData = acc.GetData();
CFX_ByteString sStream(pData, acc.GetSize());
if (matrix.IsIdentity()) {
matrix.a = 1.0f;
matrix.b = 0.0f;
matrix.c = 0.0f;
matrix.d = 1.0f;
matrix.e = 0.0f;
matrix.f = 0.0f;
}
CFX_ByteString sTemp;
CFX_Matrix m = GetMatrix(rcAnnot, rcStream, matrix);
sTemp.Format("q %f 0 0 %f %f %f cm /%s Do Q\n", m.a, m.d, m.e, m.f,
sFormName.c_str());
sStream += sTemp;
pNewXObject->SetData(sStream.raw_str(), sStream.GetLength());
}
pPageDict->RemoveFor("Annots");
ObjectArray.RemoveAll();
RectArray.RemoveAll();
return FLATTEN_SUCCESS;
}
CFX_ByteString CPWL_FontMap::EncodeFontAlias(const CFX_ByteString& sFontName, int32_t nCharset)
{
CFX_ByteString sPostfix;
sPostfix.Format("_%02X", nCharset);
return EncodeFontAlias(sFontName) + sPostfix;
}
DLLEXPORT FPDF_BOOL STDCALL FPDFPage_TransFormWithClip(FPDF_PAGE page, FS_MATRIX* matrix, FS_RECTF* clipRect)
{
if(!page)
return FALSE;
CFX_ByteTextBuf textBuf;
textBuf<<"q ";
CFX_FloatRect rect(clipRect->left, clipRect->bottom, clipRect->right, clipRect->top);
rect.Normalize();
CFX_ByteString bsClipping;
bsClipping.Format("%f %f %f %f re W* n ", rect.left, rect.bottom, rect.Width(), rect.Height());
textBuf<<bsClipping;
CFX_ByteString bsMatix;
bsMatix.Format("%f %f %f %f %f %f cm ", matrix->a, matrix->b,matrix->c,matrix->d,matrix->e,matrix->f);
textBuf<<bsMatix;
CPDF_Page* pPage = (CPDF_Page*)page;
CPDF_Dictionary* pPageDic = pPage->m_pFormDict;
CPDF_Object* pContentObj = pPageDic->GetElement("Contents");
if(!pContentObj)
pContentObj = pPageDic->GetArray("Contents");
if(!pContentObj)
return FALSE;
CPDF_Dictionary* pDic = FX_NEW CPDF_Dictionary;
CPDF_Stream* pStream = FX_NEW CPDF_Stream(NULL,0, pDic);
pStream->SetData(textBuf.GetBuffer(), textBuf.GetSize(), FALSE, FALSE);
CPDF_Document* pDoc = pPage->m_pDocument;
if(!pDoc)
return FALSE;
pDoc->AddIndirectObject(pStream);
pDic = FX_NEW CPDF_Dictionary;
CPDF_Stream* pEndStream = FX_NEW CPDF_Stream(NULL,0, pDic);
pEndStream->SetData((FX_LPCBYTE)" Q", 2, FALSE, FALSE);
pDoc->AddIndirectObject(pEndStream);
CPDF_Array* pContentArray = NULL;
if (pContentObj && pContentObj->GetType() == PDFOBJ_ARRAY)
{
pContentArray = (CPDF_Array*)pContentObj;
CPDF_Reference* pRef = FX_NEW CPDF_Reference(pDoc, pStream->GetObjNum());
pContentArray->InsertAt(0, pRef);
pContentArray->AddReference(pDoc,pEndStream);
}
else if(pContentObj && pContentObj->GetType() == PDFOBJ_REFERENCE)
{
CPDF_Reference* pReference = (CPDF_Reference*)pContentObj;
CPDF_Object* pDirectObj = pReference->GetDirect();
if(pDirectObj != NULL)
{
if(pDirectObj->GetType() == PDFOBJ_ARRAY)
{
pContentArray = (CPDF_Array*)pDirectObj;
CPDF_Reference* pRef = FX_NEW CPDF_Reference(pDoc, pStream->GetObjNum());
pContentArray->InsertAt(0, pRef);
pContentArray->AddReference(pDoc,pEndStream);
}
else if(pDirectObj->GetType() == PDFOBJ_STREAM)
{
pContentArray = FX_NEW CPDF_Array();
pContentArray->AddReference(pDoc,pStream->GetObjNum());
pContentArray->AddReference(pDoc,pDirectObj->GetObjNum());
pContentArray->AddReference(pDoc, pEndStream);
pPageDic->SetAtReference("Contents", pDoc, pDoc->AddIndirectObject(pContentArray));
}
}
}
//Need to transform the patterns as well.
CPDF_Dictionary* pRes = pPageDic->GetDict(FX_BSTRC("Resources"));
if(pRes)
{
CPDF_Dictionary* pPattenDict = pRes->GetDict(FX_BSTRC("Pattern"));
if(pPattenDict)
{
FX_POSITION pos = pPattenDict->GetStartPos();
while(pos)
{
CPDF_Dictionary* pDict = NULL;
CFX_ByteString key;
CPDF_Object* pObj = pPattenDict->GetNextElement(pos, key);
if(pObj->GetType() == PDFOBJ_REFERENCE)
pObj = pObj->GetDirect();
if(pObj->GetType() == PDFOBJ_DICTIONARY)
{
pDict = (CPDF_Dictionary*)pObj;
}
else if(pObj->GetType() == PDFOBJ_STREAM)
{
pDict = ((CPDF_Stream*)pObj)->GetDict();
}
else
continue;
CFX_AffineMatrix m = pDict->GetMatrix(FX_BSTRC("Matrix"));
CFX_AffineMatrix t = *(CFX_AffineMatrix*)matrix;
m.Concat(t);
pDict->SetAtMatrix(FX_BSTRC("Matrix"), m);
}
}
}
return TRUE;
}
void CPDFXFA_DocEnvironment::ExportData(CXFA_FFDoc* hDoc,
const CFX_WideString& wsFilePath,
bool bXDP) {
if (hDoc != m_pContext->GetXFADoc())
return;
if (m_pContext->GetDocType() != DOCTYPE_DYNAMIC_XFA &&
m_pContext->GetDocType() != DOCTYPE_STATIC_XFA) {
return;
}
CPDFSDK_FormFillEnvironment* pFormFillEnv = m_pContext->GetFormFillEnv();
if (!pFormFillEnv)
return;
int fileType = bXDP ? FXFA_SAVEAS_XDP : FXFA_SAVEAS_XML;
CFX_ByteString bs = wsFilePath.UTF16LE_Encode();
if (wsFilePath.IsEmpty()) {
if (!pFormFillEnv->GetFormFillInfo() ||
!pFormFillEnv->GetFormFillInfo()->m_pJsPlatform) {
return;
}
CFX_WideString filepath = pFormFillEnv->JS_fieldBrowse();
bs = filepath.UTF16LE_Encode();
}
int len = bs.GetLength();
FPDF_FILEHANDLER* pFileHandler =
pFormFillEnv->OpenFile(bXDP ? FXFA_SAVEAS_XDP : FXFA_SAVEAS_XML,
(FPDF_WIDESTRING)bs.GetBuffer(len), "wb");
bs.ReleaseBuffer(len);
if (!pFileHandler)
return;
CFX_RetainPtr<IFX_SeekableStream> fileWrite =
MakeSeekableStream(pFileHandler);
CFX_ByteString content;
if (fileType == FXFA_SAVEAS_XML) {
content = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n";
fileWrite->WriteBlock(content.c_str(), fileWrite->GetSize(),
content.GetLength());
m_pContext->GetXFADocView()->GetDoc()->SavePackage(XFA_HASHCODE_Data,
fileWrite, nullptr);
} else if (fileType == FXFA_SAVEAS_XDP) {
if (!m_pContext->GetPDFDoc())
return;
CPDF_Dictionary* pRoot = m_pContext->GetPDFDoc()->GetRoot();
if (!pRoot)
return;
CPDF_Dictionary* pAcroForm = pRoot->GetDictFor("AcroForm");
if (!pAcroForm)
return;
CPDF_Array* pArray = ToArray(pAcroForm->GetObjectFor("XFA"));
if (!pArray)
return;
int size = pArray->GetCount();
for (int i = 1; i < size; i += 2) {
CPDF_Object* pPDFObj = pArray->GetObjectAt(i);
CPDF_Object* pPrePDFObj = pArray->GetObjectAt(i - 1);
if (!pPrePDFObj->IsString())
continue;
if (!pPDFObj->IsReference())
continue;
CPDF_Stream* pStream = ToStream(pPDFObj->GetDirect());
if (!pStream)
continue;
if (pPrePDFObj->GetString() == "form") {
m_pContext->GetXFADocView()->GetDoc()->SavePackage(XFA_HASHCODE_Form,
fileWrite, nullptr);
continue;
}
if (pPrePDFObj->GetString() == "datasets") {
m_pContext->GetXFADocView()->GetDoc()->SavePackage(
XFA_HASHCODE_Datasets, fileWrite, nullptr);
continue;
}
if (i == size - 1) {
CFX_WideString wPath = CFX_WideString::FromUTF16LE(
reinterpret_cast<const unsigned short*>(bs.c_str()),
bs.GetLength() / sizeof(unsigned short));
CFX_ByteString bPath = wPath.UTF8Encode();
const char* szFormat =
"\n<pdf href=\"%s\" xmlns=\"http://ns.adobe.com/xdp/pdf/\"/>";
content.Format(szFormat, bPath.c_str());
fileWrite->WriteBlock(content.c_str(), fileWrite->GetSize(),
content.GetLength());
}
std::unique_ptr<CPDF_StreamAcc> pAcc(new CPDF_StreamAcc);
pAcc->LoadAllData(pStream);
fileWrite->WriteBlock(pAcc->GetData(), fileWrite->GetSize(),
pAcc->GetSize());
}
}
fileWrite->Flush();
}
void SetPageContents(CFX_ByteString key, CPDF_Dictionary* pPage, CPDF_Document* pDocument)
{
CPDF_Object* pContentsObj = pPage->GetStream("Contents");
if (!pContentsObj)
{
pContentsObj = pPage->GetArray("Contents");
}
if (!pContentsObj)
{
//Create a new contents dictionary
if (!key.IsEmpty())
{
CPDF_Stream* pNewContents = FX_NEW CPDF_Stream(NULL, 0, FX_NEW CPDF_Dictionary);
if (!pNewContents)return;
pPage->SetAtReference("Contents", pDocument, pDocument->AddIndirectObject(pNewContents));
CFX_ByteString sStream;
sStream.Format("q 1 0 0 1 0 0 cm /%s Do Q", key.c_str());
pNewContents->SetData((FX_LPCBYTE)sStream, sStream.GetLength(), FALSE, FALSE);
}
return;
}
int iType = pContentsObj->GetType();
CPDF_Array* pContentsArray = NULL;
switch(iType)
{
case PDFOBJ_STREAM:
{
pContentsArray = FX_NEW CPDF_Array;
CPDF_Stream* pContents = (CPDF_Stream*)pContentsObj;
FX_DWORD dwObjNum = pDocument->AddIndirectObject(pContents);
CPDF_StreamAcc acc;
acc.LoadAllData(pContents);
CFX_ByteString sStream = "q\n";
CFX_ByteString sBody = CFX_ByteString((FX_LPCSTR)acc.GetData(), acc.GetSize());
sStream = sStream + sBody + "\nQ";
pContents->SetData((FX_LPCBYTE)sStream, sStream.GetLength(), FALSE, FALSE);
pContentsArray->AddReference(pDocument, dwObjNum);
break;
}
case PDFOBJ_ARRAY:
{
pContentsArray = (CPDF_Array*)pContentsObj;
break;
}
default:
break;
}
if (!pContentsArray)return;
FX_DWORD dwObjNum = pDocument->AddIndirectObject(pContentsArray);
pPage->SetAtReference("Contents", pDocument, dwObjNum);
if (!key.IsEmpty())
{
CPDF_Stream* pNewContents = FX_NEW CPDF_Stream(NULL, 0, FX_NEW CPDF_Dictionary);
dwObjNum = pDocument->AddIndirectObject(pNewContents);
pContentsArray->AddReference(pDocument, dwObjNum);
CFX_ByteString sStream;
sStream.Format("q 1 0 0 1 0 0 cm /%s Do Q", key.c_str());
pNewContents->SetData((FX_LPCBYTE)sStream, sStream.GetLength(), FALSE, FALSE);
}
}
void SetPageContents(CFX_ByteString key,
CPDF_Dictionary* pPage,
CPDF_Document* pDocument) {
CPDF_Object* pContentsObj = pPage->GetStreamFor("Contents");
if (!pContentsObj) {
pContentsObj = pPage->GetArrayFor("Contents");
}
if (!pContentsObj) {
// Create a new contents dictionary
if (!key.IsEmpty()) {
CPDF_Stream* pNewContents = new CPDF_Stream(
nullptr, 0, new CPDF_Dictionary(pDocument->GetByteStringPool()));
CFX_ByteString sStream;
sStream.Format("q 1 0 0 1 0 0 cm /%s Do Q", key.c_str());
pNewContents->SetData(sStream.raw_str(), sStream.GetLength());
pPage->SetReferenceFor("Contents", pDocument,
pDocument->AddIndirectObject(pNewContents));
}
return;
}
CPDF_Array* pContentsArray = nullptr;
switch (pContentsObj->GetType()) {
case CPDF_Object::STREAM: {
pContentsArray = new CPDF_Array;
CPDF_Stream* pContents = pContentsObj->AsStream();
uint32_t dwObjNum = pDocument->AddIndirectObject(pContents);
CPDF_StreamAcc acc;
acc.LoadAllData(pContents);
CFX_ByteString sStream = "q\n";
CFX_ByteString sBody =
CFX_ByteString((const FX_CHAR*)acc.GetData(), acc.GetSize());
sStream = sStream + sBody + "\nQ";
pContents->SetData(sStream.raw_str(), sStream.GetLength());
pContentsArray->AddReference(pDocument, dwObjNum);
break;
}
case CPDF_Object::ARRAY: {
pContentsArray = pContentsObj->AsArray();
break;
}
default:
break;
}
if (!pContentsArray)
return;
pPage->SetReferenceFor("Contents", pDocument,
pDocument->AddIndirectObject(pContentsArray));
if (!key.IsEmpty()) {
CPDF_Stream* pNewContents = new CPDF_Stream(
nullptr, 0, new CPDF_Dictionary(pDocument->GetByteStringPool()));
CFX_ByteString sStream;
sStream.Format("q 1 0 0 1 0 0 cm /%s Do Q", key.c_str());
pNewContents->SetData(sStream.raw_str(), sStream.GetLength());
pContentsArray->AddReference(pDocument,
pDocument->AddIndirectObject(pNewContents));
}
}
DLLEXPORT int STDCALL FPDFPage_Flatten( FPDF_PAGE page, int nFlag)
{
if (!page)
{
return FLATTEN_FAIL;
}
CPDF_Page * pPage = (CPDF_Page*)( page );
CPDF_Document * pDocument = pPage->m_pDocument;
CPDF_Dictionary * pPageDict = pPage->m_pFormDict;
if ( !pDocument || !pPageDict )
{
return FLATTEN_FAIL;
}
CPDF_ObjectArray ObjectArray;
CPDF_RectArray RectArray;
int iRet = FLATTEN_FAIL;
iRet = ParserAnnots( pDocument, pPageDict, &RectArray, &ObjectArray, nFlag);
if (iRet == FLATTEN_NOTINGTODO)
{
return FLATTEN_NOTINGTODO;
}else if (iRet == FLATTEN_FAIL)
{
return FLATTEN_FAIL;
}
CPDF_Rect rcOriginalCB;
CPDF_Rect rcMerger = CalculateRect( &RectArray );
CPDF_Rect rcOriginalMB = pPageDict->GetRect("MediaBox");
if (pPageDict->KeyExist("CropBox"))
rcOriginalMB = pPageDict->GetRect("CropBox");
if (rcOriginalMB.IsEmpty())
{
rcOriginalMB = CPDF_Rect(0.0f, 0.0f, 612.0f, 792.0f);
}
rcMerger.left = rcMerger.left < rcOriginalMB.left? rcOriginalMB.left : rcMerger.left;
rcMerger.right = rcMerger.right > rcOriginalMB.right? rcOriginalMB.right : rcMerger.right;
rcMerger.top = rcMerger.top > rcOriginalMB.top? rcOriginalMB.top : rcMerger.top;
rcMerger.bottom = rcMerger.bottom < rcOriginalMB.bottom? rcOriginalMB.bottom : rcMerger.bottom;
if (pPageDict->KeyExist("ArtBox"))
rcOriginalCB = pPageDict->GetRect("ArtBox");
else
rcOriginalCB = rcOriginalMB;
if (!rcOriginalMB.IsEmpty())
{
CPDF_Array* pMediaBox = FX_NEW CPDF_Array();
pMediaBox->Add(FX_NEW CPDF_Number(rcOriginalMB.left));
pMediaBox->Add(FX_NEW CPDF_Number(rcOriginalMB.bottom));
pMediaBox->Add(FX_NEW CPDF_Number(rcOriginalMB.right));
pMediaBox->Add(FX_NEW CPDF_Number(rcOriginalMB.top));
pPageDict->SetAt("MediaBox",pMediaBox);
}
if (!rcOriginalCB.IsEmpty())
{
CPDF_Array* pCropBox = FX_NEW CPDF_Array();
pCropBox->Add(FX_NEW CPDF_Number(rcOriginalCB.left));
pCropBox->Add(FX_NEW CPDF_Number(rcOriginalCB.bottom));
pCropBox->Add(FX_NEW CPDF_Number(rcOriginalCB.right));
pCropBox->Add(FX_NEW CPDF_Number(rcOriginalCB.top));
pPageDict->SetAt("ArtBox", pCropBox);
}
CPDF_Dictionary* pRes = NULL;
pRes = pPageDict->GetDict("Resources");
if (!pRes)
{
pRes = FX_NEW CPDF_Dictionary;
pPageDict->SetAt( "Resources", pRes );
}
CPDF_Stream* pNewXObject = FX_NEW CPDF_Stream(NULL, 0, FX_NEW CPDF_Dictionary);
FX_DWORD dwObjNum = pDocument->AddIndirectObject(pNewXObject);
CPDF_Dictionary* pPageXObject = pRes->GetDict("XObject");
if (!pPageXObject)
{
pPageXObject = FX_NEW CPDF_Dictionary;
pRes->SetAt("XObject", pPageXObject);
}
CFX_ByteString key = "";
int nStreams = ObjectArray.GetSize();
if (nStreams > 0)
{
for (int iKey = 0; /*iKey < 100*/; iKey++)
{
char sExtend[5] = {0};
FXSYS_itoa(iKey, sExtend, 10);
key = CFX_ByteString("FFT") + CFX_ByteString(sExtend);
if (!pPageXObject->KeyExist(key))
break;
}
}
SetPageContents(key, pPageDict, pDocument);
CPDF_Dictionary* pNewXORes = NULL;
if (!key.IsEmpty())
{
pPageXObject->SetAtReference(key, pDocument, dwObjNum);
CPDF_Dictionary* pNewOXbjectDic = pNewXObject->GetDict();
pNewXORes = FX_NEW CPDF_Dictionary;
pNewOXbjectDic->SetAt("Resources", pNewXORes);
pNewOXbjectDic->SetAtName("Type", "XObject");
pNewOXbjectDic->SetAtName("Subtype", "Form");
pNewOXbjectDic->SetAtInteger("FormType", 1);
pNewOXbjectDic->SetAtName("Name", "FRM");
CPDF_Rect rcBBox = pPageDict->GetRect("ArtBox");
pNewOXbjectDic->SetAtRect("BBox", rcBBox);
}
for (int i = 0; i < nStreams; i++)
{
CPDF_Dictionary* pAnnotDic = ObjectArray.GetAt(i);
if (!pAnnotDic)continue;
CPDF_Rect rcAnnot = pAnnotDic->GetRect("Rect");
rcAnnot.Normalize();
CFX_ByteString sAnnotState = pAnnotDic->GetString("AS");
CPDF_Dictionary* pAnnotAP = pAnnotDic->GetDict("AP");
if (!pAnnotAP)continue;
CPDF_Stream* pAPStream = pAnnotAP->GetStream("N");
if (!pAPStream)
{
CPDF_Dictionary* pAPDic = pAnnotAP->GetDict("N");
if (!pAPDic)continue;
if (!sAnnotState.IsEmpty())
{
pAPStream = pAPDic->GetStream(sAnnotState);
}
else
{
FX_POSITION pos = pAPDic->GetStartPos();
if (pos)
{
CFX_ByteString sKey;
CPDF_Object* pFirstObj = pAPDic->GetNextElement(pos, sKey);
if (pFirstObj)
{
if (pFirstObj->GetType() == PDFOBJ_REFERENCE)
pFirstObj = pFirstObj->GetDirect();
if (pFirstObj->GetType() != PDFOBJ_STREAM)
continue;
pAPStream = (CPDF_Stream*)pFirstObj;
}
}
}
}
if (!pAPStream)continue;
CPDF_Dictionary* pAPDic = pAPStream->GetDict();
CFX_AffineMatrix matrix = pAPDic->GetMatrix("Matrix");
CPDF_Rect rcStream;
if (pAPDic->KeyExist("Rect"))
rcStream = pAPDic->GetRect("Rect");
else if (pAPDic->KeyExist("BBox"))
rcStream = pAPDic->GetRect("BBox");
if (rcStream.IsEmpty())continue;
CPDF_Object* pObj = pAPStream;
if (pObj)
{
CPDF_Dictionary* pObjDic = pObj->GetDict();
if (pObjDic)
{
pObjDic->SetAtName("Type", "XObject");
pObjDic->SetAtName("Subtype", "Form");
}
}
CPDF_Dictionary* pXObject = pNewXORes->GetDict("XObject");
if (!pXObject)
{
pXObject = FX_NEW CPDF_Dictionary;
pNewXORes->SetAt("XObject", pXObject);
}
CFX_ByteString sFormName;
sFormName.Format("F%d", i);
FX_DWORD dwObjNum = pDocument->AddIndirectObject(pObj);
pXObject->SetAtReference(sFormName, pDocument, dwObjNum);
CPDF_StreamAcc acc;
acc.LoadAllData(pNewXObject);
FX_LPCBYTE pData = acc.GetData();
CFX_ByteString sStream(pData, acc.GetSize());
CFX_ByteString sTemp;
if (matrix.IsIdentity())
{
matrix.a = 1.0f;
matrix.b = 0.0f;
matrix.c = 0.0f;
matrix.d = 1.0f;
matrix.e = 0.0f;
matrix.f = 0.0f;
}
CFX_AffineMatrix m = GetMatrix(rcAnnot, rcStream, matrix);
sTemp.Format("q %f 0 0 %f %f %f cm /%s Do Q\n", m.a, m.d, m.e, m.f, sFormName.c_str());
sStream += sTemp;
pNewXObject->SetData((FX_LPCBYTE)sStream, sStream.GetLength(), FALSE, FALSE);
}
pPageDict->RemoveAt( "Annots" );
ObjectArray.RemoveAll();
RectArray.RemoveAll();
return FLATTEN_SUCCESS;
}
