| OLD | NEW |
| 1 // Copyright 2014 PDFium Authors. All rights reserved. | 1 // Copyright 2014 PDFium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
| 4 | 4 |
| 5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com | 5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com |
| 6 | 6 |
| 7 #include "../../public/fpdf_flatten.h" | 7 #include "../../public/fpdf_flatten.h" |
| 8 #include "../include/fsdk_define.h" | 8 #include "../include/fsdk_define.h" |
| 9 | 9 |
| 10 typedef CFX_ArrayTemplate<CPDF_Dictionary*> CPDF_ObjectArray; | 10 typedef CFX_ArrayTemplate<CPDF_Dictionary*> CPDF_ObjectArray; |
| 11 typedef CFX_ArrayTemplate<CPDF_Rect> CPDF_RectArray; | 11 typedef CFX_ArrayTemplate<CPDF_Rect> CPDF_RectArray; |
| 12 | 12 |
| 13 enum FPDF_TYPE { MAX, MIN }; | 13 enum FPDF_TYPE { MAX, MIN }; |
| 14 enum FPDF_VALUE { TOP, LEFT, RIGHT, BOTTOM }; | 14 enum FPDF_VALUE { TOP, LEFT, RIGHT, BOTTOM }; |
| 15 | 15 |
| 16 FX_BOOL IsValiableRect(CPDF_Rect rect, CPDF_Rect rcPage) | 16 FX_BOOL IsValiableRect(CPDF_Rect rect, CPDF_Rect rcPage) { |
| 17 { | 17 if (rect.left - rect.right > 0.000001f || rect.bottom - rect.top > 0.000001f) |
| 18 if ( rect.left - rect.right > 0.000001f || | 18 return FALSE; |
| 19 rect.bottom - rect.top > 0.000001f) | 19 |
| 20 return FALSE; | 20 if (rect.left == 0.0f && rect.top == 0.0f && rect.right == 0.0f && |
| 21 | 21 rect.bottom == 0.0f) |
| 22 if (rect.left == 0.0f && | 22 return FALSE; |
| 23 rect.top == 0.0f && | 23 |
| 24 rect.right == 0.0f && | 24 if (!rcPage.IsEmpty()) { |
| 25 rect.bottom == 0.0f) | 25 if (rect.left - rcPage.left < -10.000001f || |
| 26 return FALSE; | 26 rect.right - rcPage.right > 10.000001f || |
| 27 | 27 rect.top - rcPage.top > 10.000001f || |
| 28 if (!rcPage.IsEmpty()) | 28 rect.bottom - rcPage.bottom < -10.000001f) |
| 29 { | 29 return FALSE; |
| 30 if (rect.left - rcPage.left < -10.000001f || | 30 } |
| 31 rect.right - rcPage.right > 10.000001f || | 31 |
| 32 rect.top - rcPage.top > 10.000001f || | 32 return TRUE; |
| 33 rect.bottom - rcPage.bottom < -10.000001f) | 33 } |
| 34 return FALSE; | 34 |
| 35 } | 35 FX_BOOL GetContentsRect(CPDF_Document* pDoc, |
| 36 | 36 CPDF_Dictionary* pDict, |
| 37 return TRUE; | 37 CPDF_RectArray* pRectArray) { |
| 38 } | 38 CPDF_Page* pPDFPage = new CPDF_Page; |
| 39 | 39 pPDFPage->Load(pDoc, pDict, FALSE); |
| 40 | 40 pPDFPage->ParseContent(); |
| 41 FX_BOOL GetContentsRect( CPDF_Document * pDoc, CPDF_Dictionary* pDict, CPDF_Rect
Array * pRectArray ) | 41 |
| 42 { | 42 FX_POSITION pos = pPDFPage->GetFirstObjectPosition(); |
| 43 CPDF_Page* pPDFPage = new CPDF_Page; | 43 |
| 44 pPDFPage->Load( pDoc, pDict, FALSE ); | 44 while (pos) { |
| 45 pPDFPage->ParseContent(); | 45 CPDF_PageObject* pPageObject = pPDFPage->GetNextObject(pos); |
| 46 | 46 if (!pPageObject) |
| 47 FX_POSITION pos = pPDFPage->GetFirstObjectPosition(); | 47 continue; |
| 48 | 48 |
| 49 while (pos) | 49 CPDF_Rect rc; |
| 50 { | 50 rc.left = pPageObject->m_Left; |
| 51 CPDF_PageObject* pPageObject = pPDFPage->GetNextObject(pos); | 51 rc.right = pPageObject->m_Right; |
| 52 if (!pPageObject)continue; | 52 rc.bottom = pPageObject->m_Bottom; |
| 53 | 53 rc.top = pPageObject->m_Top; |
| 54 CPDF_Rect rc; | 54 |
| 55 rc.left = pPageObject->m_Left; | 55 if (IsValiableRect(rc, pDict->GetRect("MediaBox"))) { |
| 56 rc.right = pPageObject->m_Right; | 56 pRectArray->Add(rc); |
| 57 rc.bottom = pPageObject->m_Bottom; | 57 } |
| 58 rc.top = pPageObject->m_Top; | 58 } |
| 59 | 59 |
| 60 if (IsValiableRect(rc, pDict->GetRect("MediaBox"))) | 60 delete pPDFPage; |
| 61 { | 61 return TRUE; |
| 62 pRectArray->Add(rc); | 62 } |
| 63 } | 63 |
| 64 } | 64 void ParserStream(CPDF_Dictionary* pPageDic, |
| 65 | 65 CPDF_Dictionary* pStream, |
| 66 delete pPDFPage; | 66 CPDF_RectArray* pRectArray, |
| 67 return TRUE; | 67 CPDF_ObjectArray* pObjectArray) { |
| 68 } | 68 if (!pStream) |
| 69 | 69 return; |
| 70 | 70 CPDF_Rect rect; |
| 71 void ParserStream( CPDF_Dictionary * pPageDic, CPDF_Dictionary* pStream, CPDF_Re
ctArray * pRectArray, CPDF_ObjectArray * pObjectArray ) | 71 if (pStream->KeyExist("Rect")) |
| 72 { | 72 rect = pStream->GetRect("Rect"); |
| 73 if (!pStream)return; | 73 else if (pStream->KeyExist("BBox")) |
| 74 CPDF_Rect rect; | 74 rect = pStream->GetRect("BBox"); |
| 75 if (pStream->KeyExist("Rect")) | 75 |
| 76 rect = pStream->GetRect("Rect"); | 76 if (IsValiableRect(rect, pPageDic->GetRect("MediaBox"))) |
| 77 else if (pStream->KeyExist("BBox")) | 77 pRectArray->Add(rect); |
| 78 rect = pStream->GetRect("BBox"); | 78 |
| 79 | 79 pObjectArray->Add(pStream); |
| 80 if (IsValiableRect(rect, pPageDic->GetRect("MediaBox"))) | 80 } |
| 81 pRectArray->Add(rect); | 81 |
| 82 | 82 int ParserAnnots(CPDF_Document* pSourceDoc, |
| 83 pObjectArray->Add(pStream); | 83 CPDF_Dictionary* pPageDic, |
| 84 } | 84 CPDF_RectArray* pRectArray, |
| 85 | 85 CPDF_ObjectArray* pObjectArray, |
| 86 | 86 int nUsage) { |
| 87 int ParserAnnots( CPDF_Document* pSourceDoc, CPDF_Dictionary * pPageDic, CPDF_Re
ctArray * pRectArray, CPDF_ObjectArray * pObjectArray, int nUsage) | 87 if (!pSourceDoc || !pPageDic) |
| 88 { | 88 return FLATTEN_FAIL; |
| 89 if (!pSourceDoc || !pPageDic) | 89 |
| 90 return FLATTEN_FAIL; | 90 GetContentsRect(pSourceDoc, pPageDic, pRectArray); |
| 91 | 91 CPDF_Array* pAnnots = pPageDic->GetArray("Annots"); |
| 92 GetContentsRect( pSourceDoc, pPageDic, pRectArray ); | 92 if (!pAnnots) |
| 93 CPDF_Array* pAnnots = pPageDic->GetArray("Annots"); | 93 return FLATTEN_NOTHINGTODO; |
| 94 if (!pAnnots) | 94 |
| 95 return FLATTEN_NOTHINGTODO; | 95 FX_DWORD dwSize = pAnnots->GetCount(); |
| 96 | 96 for (int i = 0; i < (int)dwSize; i++) { |
| 97 FX_DWORD dwSize = pAnnots->GetCount(); | 97 CPDF_Object* pObj = pAnnots->GetElementValue(i); |
| 98 for (int i = 0; i < (int)dwSize; i++) | 98 if (!pObj || pObj->GetType() != PDFOBJ_DICTIONARY) |
| 99 { | 99 continue; |
| 100 CPDF_Object* pObj = pAnnots->GetElementValue(i); | 100 |
| 101 if (!pObj || pObj->GetType() != PDFOBJ_DICTIONARY) | 101 CPDF_Dictionary* pAnnotDic = (CPDF_Dictionary*)pObj; |
| 102 continue; | 102 CFX_ByteString sSubtype = pAnnotDic->GetString("Subtype"); |
| 103 | 103 if (sSubtype == "Popup") |
| 104 CPDF_Dictionary* pAnnotDic = (CPDF_Dictionary*)pObj; | 104 continue; |
| 105 CFX_ByteString sSubtype = pAnnotDic->GetString("Subtype"); | 105 |
| 106 if (sSubtype == "Popup") | 106 int nAnnotFlag = pAnnotDic->GetInteger("F"); |
| 107 continue; | 107 if (nAnnotFlag & ANNOTFLAG_HIDDEN) |
| 108 | 108 continue; |
| 109 int nAnnotFlag = pAnnotDic->GetInteger("F"); | 109 |
| 110 if (nAnnotFlag & ANNOTFLAG_HIDDEN) | 110 if (nUsage == FLAT_NORMALDISPLAY) { |
| 111 continue; | 111 if (nAnnotFlag & ANNOTFLAG_INVISIBLE) |
| 112 | 112 continue; |
| 113 if(nUsage == FLAT_NORMALDISPLAY) | 113 |
| 114 { | 114 ParserStream(pPageDic, pAnnotDic, pRectArray, pObjectArray); |
| 115 if (nAnnotFlag & ANNOTFLAG_INVISIBLE) | 115 } else { |
| 116 continue; | 116 if (nAnnotFlag & ANNOTFLAG_PRINT) |
| 117 | 117 ParserStream(pPageDic, pAnnotDic, pRectArray, pObjectArray); |
| 118 ParserStream( pPageDic, pAnnotDic, pRectArray, pObjectArray ); | 118 } |
| 119 } |
| 120 return FLATTEN_SUCCESS; |
| 121 } |
| 122 |
| 123 FX_FLOAT GetMinMaxValue(CPDF_RectArray& array, |
| 124 FPDF_TYPE type, |
| 125 FPDF_VALUE value) { |
| 126 int nRects = array.GetSize(); |
| 127 FX_FLOAT fRet = 0.0f; |
| 128 |
| 129 if (nRects <= 0) |
| 130 return 0.0f; |
| 131 |
| 132 FX_FLOAT* pArray = new FX_FLOAT[nRects]; |
| 133 switch (value) { |
| 134 case LEFT: { |
| 135 for (int i = 0; i < nRects; i++) |
| 136 pArray[i] = CPDF_Rect(array.GetAt(i)).left; |
| 137 |
| 138 break; |
| 139 } |
| 140 case TOP: { |
| 141 for (int i = 0; i < nRects; i++) |
| 142 pArray[i] = CPDF_Rect(array.GetAt(i)).top; |
| 143 |
| 144 break; |
| 145 } |
| 146 case RIGHT: { |
| 147 for (int i = 0; i < nRects; i++) |
| 148 pArray[i] = CPDF_Rect(array.GetAt(i)).right; |
| 149 |
| 150 break; |
| 151 } |
| 152 case BOTTOM: { |
| 153 for (int i = 0; i < nRects; i++) |
| 154 pArray[i] = CPDF_Rect(array.GetAt(i)).bottom; |
| 155 |
| 156 break; |
| 157 } |
| 158 default: |
| 159 break; |
| 160 } |
| 161 fRet = pArray[0]; |
| 162 if (type == MAX) { |
| 163 for (int i = 1; i < nRects; i++) |
| 164 if (fRet <= pArray[i]) |
| 165 fRet = pArray[i]; |
| 166 } else { |
| 167 for (int i = 1; i < nRects; i++) |
| 168 if (fRet >= pArray[i]) |
| 169 fRet = pArray[i]; |
| 170 } |
| 171 delete[] pArray; |
| 172 return fRet; |
| 173 } |
| 174 |
| 175 CPDF_Rect CalculateRect(CPDF_RectArray* pRectArray) { |
| 176 CPDF_Rect rcRet; |
| 177 |
| 178 rcRet.left = GetMinMaxValue(*pRectArray, MIN, LEFT); |
| 179 rcRet.top = GetMinMaxValue(*pRectArray, MAX, TOP); |
| 180 rcRet.right = GetMinMaxValue(*pRectArray, MAX, RIGHT); |
| 181 rcRet.bottom = GetMinMaxValue(*pRectArray, MIN, BOTTOM); |
| 182 |
| 183 return rcRet; |
| 184 } |
| 185 |
| 186 void SetPageContents(CFX_ByteString key, |
| 187 CPDF_Dictionary* pPage, |
| 188 CPDF_Document* pDocument) { |
| 189 CPDF_Object* pContentsObj = pPage->GetStream("Contents"); |
| 190 if (!pContentsObj) { |
| 191 pContentsObj = pPage->GetArray("Contents"); |
| 192 } |
| 193 |
| 194 if (!pContentsObj) { |
| 195 // Create a new contents dictionary |
| 196 if (!key.IsEmpty()) { |
| 197 CPDF_Stream* pNewContents = new CPDF_Stream(NULL, 0, new CPDF_Dictionary); |
| 198 pPage->SetAtReference("Contents", pDocument, |
| 199 pDocument->AddIndirectObject(pNewContents)); |
| 200 |
| 201 CFX_ByteString sStream; |
| 202 sStream.Format("q 1 0 0 1 0 0 cm /%s Do Q", key.c_str()); |
| 203 pNewContents->SetData((const uint8_t*)sStream, sStream.GetLength(), FALSE, |
| 204 FALSE); |
| 205 } |
| 206 return; |
| 207 } |
| 208 |
| 209 int iType = pContentsObj->GetType(); |
| 210 CPDF_Array* pContentsArray = NULL; |
| 211 |
| 212 switch (iType) { |
| 213 case PDFOBJ_STREAM: { |
| 214 pContentsArray = new CPDF_Array; |
| 215 CPDF_Stream* pContents = (CPDF_Stream*)pContentsObj; |
| 216 FX_DWORD dwObjNum = pDocument->AddIndirectObject(pContents); |
| 217 CPDF_StreamAcc acc; |
| 218 acc.LoadAllData(pContents); |
| 219 CFX_ByteString sStream = "q\n"; |
| 220 CFX_ByteString sBody = |
| 221 CFX_ByteString((const FX_CHAR*)acc.GetData(), acc.GetSize()); |
| 222 sStream = sStream + sBody + "\nQ"; |
| 223 pContents->SetData((const uint8_t*)sStream, sStream.GetLength(), FALSE, |
| 224 FALSE); |
| 225 pContentsArray->AddReference(pDocument, dwObjNum); |
| 226 break; |
| 227 } |
| 228 |
| 229 case PDFOBJ_ARRAY: { |
| 230 pContentsArray = (CPDF_Array*)pContentsObj; |
| 231 break; |
| 232 } |
| 233 default: |
| 234 break; |
| 235 } |
| 236 |
| 237 if (!pContentsArray) |
| 238 return; |
| 239 |
| 240 FX_DWORD dwObjNum = pDocument->AddIndirectObject(pContentsArray); |
| 241 pPage->SetAtReference("Contents", pDocument, dwObjNum); |
| 242 |
| 243 if (!key.IsEmpty()) { |
| 244 CPDF_Stream* pNewContents = new CPDF_Stream(NULL, 0, new CPDF_Dictionary); |
| 245 dwObjNum = pDocument->AddIndirectObject(pNewContents); |
| 246 pContentsArray->AddReference(pDocument, dwObjNum); |
| 247 |
| 248 CFX_ByteString sStream; |
| 249 sStream.Format("q 1 0 0 1 0 0 cm /%s Do Q", key.c_str()); |
| 250 pNewContents->SetData((const uint8_t*)sStream, sStream.GetLength(), FALSE, |
| 251 FALSE); |
| 252 } |
| 253 } |
| 254 |
| 255 CFX_AffineMatrix GetMatrix(CPDF_Rect rcAnnot, |
| 256 CPDF_Rect rcStream, |
| 257 CFX_AffineMatrix matrix) { |
| 258 if (rcStream.IsEmpty()) |
| 259 return CFX_AffineMatrix(); |
| 260 |
| 261 matrix.TransformRect(rcStream); |
| 262 rcStream.Normalize(); |
| 263 |
| 264 FX_FLOAT a = rcAnnot.Width() / rcStream.Width(); |
| 265 FX_FLOAT d = rcAnnot.Height() / rcStream.Height(); |
| 266 |
| 267 FX_FLOAT e = rcAnnot.left - rcStream.left * a; |
| 268 FX_FLOAT f = rcAnnot.bottom - rcStream.bottom * d; |
| 269 return CFX_AffineMatrix(a, 0, 0, d, e, f); |
| 270 } |
| 271 |
| 272 void GetOffset(FX_FLOAT& fa, |
| 273 FX_FLOAT& fd, |
| 274 FX_FLOAT& fe, |
| 275 FX_FLOAT& ff, |
| 276 CPDF_Rect rcAnnot, |
| 277 CPDF_Rect rcStream, |
| 278 CFX_AffineMatrix matrix) { |
| 279 FX_FLOAT fStreamWidth = 0.0f; |
| 280 FX_FLOAT fStreamHeight = 0.0f; |
| 281 |
| 282 if (matrix.a != 0 && matrix.d != 0) { |
| 283 fStreamWidth = rcStream.right - rcStream.left; |
| 284 fStreamHeight = rcStream.top - rcStream.bottom; |
| 285 } else { |
| 286 fStreamWidth = rcStream.top - rcStream.bottom; |
| 287 fStreamHeight = rcStream.right - rcStream.left; |
| 288 } |
| 289 |
| 290 FX_FLOAT x1 = |
| 291 matrix.a * rcStream.left + matrix.c * rcStream.bottom + matrix.e; |
| 292 FX_FLOAT y1 = |
| 293 matrix.b * rcStream.left + matrix.d * rcStream.bottom + matrix.f; |
| 294 FX_FLOAT x2 = matrix.a * rcStream.left + matrix.c * rcStream.top + matrix.e; |
| 295 FX_FLOAT y2 = matrix.b * rcStream.left + matrix.d * rcStream.top + matrix.f; |
| 296 FX_FLOAT x3 = |
| 297 matrix.a * rcStream.right + matrix.c * rcStream.bottom + matrix.e; |
| 298 FX_FLOAT y3 = |
| 299 matrix.b * rcStream.right + matrix.d * rcStream.bottom + matrix.f; |
| 300 FX_FLOAT x4 = matrix.a * rcStream.right + matrix.c * rcStream.top + matrix.e; |
| 301 FX_FLOAT y4 = matrix.b * rcStream.right + matrix.d * rcStream.top + matrix.f; |
| 302 |
| 303 FX_FLOAT left = FX_MIN(FX_MIN(x1, x2), FX_MIN(x3, x4)); |
| 304 FX_FLOAT bottom = FX_MIN(FX_MIN(y1, y2), FX_MIN(y3, y4)); |
| 305 |
| 306 fa = (rcAnnot.right - rcAnnot.left) / fStreamWidth; |
| 307 fd = (rcAnnot.top - rcAnnot.bottom) / fStreamHeight; |
| 308 fe = rcAnnot.left - left * fa; |
| 309 ff = rcAnnot.bottom - bottom * fd; |
| 310 } |
| 311 |
| 312 DLLEXPORT int STDCALL FPDFPage_Flatten(FPDF_PAGE page, int nFlag) { |
| 313 if (!page) { |
| 314 return FLATTEN_FAIL; |
| 315 } |
| 316 |
| 317 CPDF_Page* pPage = (CPDF_Page*)(page); |
| 318 CPDF_Document* pDocument = pPage->m_pDocument; |
| 319 CPDF_Dictionary* pPageDict = pPage->m_pFormDict; |
| 320 |
| 321 if (!pDocument || !pPageDict) { |
| 322 return FLATTEN_FAIL; |
| 323 } |
| 324 |
| 325 CPDF_ObjectArray ObjectArray; |
| 326 CPDF_RectArray RectArray; |
| 327 |
| 328 int iRet = FLATTEN_FAIL; |
| 329 iRet = ParserAnnots(pDocument, pPageDict, &RectArray, &ObjectArray, nFlag); |
| 330 if (iRet == FLATTEN_NOTHINGTODO || iRet == FLATTEN_FAIL) |
| 331 return iRet; |
| 332 |
| 333 CPDF_Rect rcOriginalCB; |
| 334 CPDF_Rect rcMerger = CalculateRect(&RectArray); |
| 335 CPDF_Rect rcOriginalMB = pPageDict->GetRect("MediaBox"); |
| 336 |
| 337 if (pPageDict->KeyExist("CropBox")) |
| 338 rcOriginalMB = pPageDict->GetRect("CropBox"); |
| 339 |
| 340 if (rcOriginalMB.IsEmpty()) { |
| 341 rcOriginalMB = CPDF_Rect(0.0f, 0.0f, 612.0f, 792.0f); |
| 342 } |
| 343 |
| 344 rcMerger.left = |
| 345 rcMerger.left < rcOriginalMB.left ? rcOriginalMB.left : rcMerger.left; |
| 346 rcMerger.right = |
| 347 rcMerger.right > rcOriginalMB.right ? rcOriginalMB.right : rcMerger.right; |
| 348 rcMerger.top = |
| 349 rcMerger.top > rcOriginalMB.top ? rcOriginalMB.top : rcMerger.top; |
| 350 rcMerger.bottom = rcMerger.bottom < rcOriginalMB.bottom ? rcOriginalMB.bottom |
| 351 : rcMerger.bottom; |
| 352 |
| 353 if (pPageDict->KeyExist("ArtBox")) |
| 354 rcOriginalCB = pPageDict->GetRect("ArtBox"); |
| 355 else |
| 356 rcOriginalCB = rcOriginalMB; |
| 357 |
| 358 if (!rcOriginalMB.IsEmpty()) { |
| 359 CPDF_Array* pMediaBox = new CPDF_Array(); |
| 360 pMediaBox->Add(new CPDF_Number(rcOriginalMB.left)); |
| 361 pMediaBox->Add(new CPDF_Number(rcOriginalMB.bottom)); |
| 362 pMediaBox->Add(new CPDF_Number(rcOriginalMB.right)); |
| 363 pMediaBox->Add(new CPDF_Number(rcOriginalMB.top)); |
| 364 pPageDict->SetAt("MediaBox", pMediaBox); |
| 365 } |
| 366 |
| 367 if (!rcOriginalCB.IsEmpty()) { |
| 368 CPDF_Array* pCropBox = new CPDF_Array(); |
| 369 pCropBox->Add(new CPDF_Number(rcOriginalCB.left)); |
| 370 pCropBox->Add(new CPDF_Number(rcOriginalCB.bottom)); |
| 371 pCropBox->Add(new CPDF_Number(rcOriginalCB.right)); |
| 372 pCropBox->Add(new CPDF_Number(rcOriginalCB.top)); |
| 373 pPageDict->SetAt("ArtBox", pCropBox); |
| 374 } |
| 375 |
| 376 CPDF_Dictionary* pRes = pPageDict->GetDict("Resources"); |
| 377 if (!pRes) { |
| 378 pRes = new CPDF_Dictionary; |
| 379 pPageDict->SetAt("Resources", pRes); |
| 380 } |
| 381 |
| 382 CPDF_Stream* pNewXObject = new CPDF_Stream(NULL, 0, new CPDF_Dictionary); |
| 383 FX_DWORD dwObjNum = pDocument->AddIndirectObject(pNewXObject); |
| 384 CPDF_Dictionary* pPageXObject = pRes->GetDict("XObject"); |
| 385 if (!pPageXObject) { |
| 386 pPageXObject = new CPDF_Dictionary; |
| 387 pRes->SetAt("XObject", pPageXObject); |
| 388 } |
| 389 |
| 390 CFX_ByteString key = ""; |
| 391 int nStreams = ObjectArray.GetSize(); |
| 392 |
| 393 if (nStreams > 0) { |
| 394 for (int iKey = 0; /*iKey < 100*/; iKey++) { |
| 395 char sExtend[5] = {}; |
| 396 FXSYS_itoa(iKey, sExtend, 10); |
| 397 key = CFX_ByteString("FFT") + CFX_ByteString(sExtend); |
| 398 |
| 399 if (!pPageXObject->KeyExist(key)) |
| 400 break; |
| 401 } |
| 402 } |
| 403 |
| 404 SetPageContents(key, pPageDict, pDocument); |
| 405 |
| 406 CPDF_Dictionary* pNewXORes = NULL; |
| 407 |
| 408 if (!key.IsEmpty()) { |
| 409 pPageXObject->SetAtReference(key, pDocument, dwObjNum); |
| 410 CPDF_Dictionary* pNewOXbjectDic = pNewXObject->GetDict(); |
| 411 pNewXORes = new CPDF_Dictionary; |
| 412 pNewOXbjectDic->SetAt("Resources", pNewXORes); |
| 413 pNewOXbjectDic->SetAtName("Type", "XObject"); |
| 414 pNewOXbjectDic->SetAtName("Subtype", "Form"); |
| 415 pNewOXbjectDic->SetAtInteger("FormType", 1); |
| 416 pNewOXbjectDic->SetAtName("Name", "FRM"); |
| 417 CPDF_Rect rcBBox = pPageDict->GetRect("ArtBox"); |
| 418 pNewOXbjectDic->SetAtRect("BBox", rcBBox); |
| 419 } |
| 420 |
| 421 for (int i = 0; i < nStreams; i++) { |
| 422 CPDF_Dictionary* pAnnotDic = ObjectArray.GetAt(i); |
| 423 if (!pAnnotDic) |
| 424 continue; |
| 425 |
| 426 CPDF_Rect rcAnnot = pAnnotDic->GetRect("Rect"); |
| 427 rcAnnot.Normalize(); |
| 428 |
| 429 CFX_ByteString sAnnotState = pAnnotDic->GetString("AS"); |
| 430 CPDF_Dictionary* pAnnotAP = pAnnotDic->GetDict("AP"); |
| 431 if (!pAnnotAP) |
| 432 continue; |
| 433 |
| 434 CPDF_Stream* pAPStream = pAnnotAP->GetStream("N"); |
| 435 if (!pAPStream) { |
| 436 CPDF_Dictionary* pAPDic = pAnnotAP->GetDict("N"); |
| 437 if (!pAPDic) |
| 438 continue; |
| 439 |
| 440 if (!sAnnotState.IsEmpty()) { |
| 441 pAPStream = pAPDic->GetStream(sAnnotState); |
| 442 } else { |
| 443 FX_POSITION pos = pAPDic->GetStartPos(); |
| 444 if (pos) { |
| 445 CFX_ByteString sKey; |
| 446 CPDF_Object* pFirstObj = pAPDic->GetNextElement(pos, sKey); |
| 447 if (pFirstObj) { |
| 448 if (pFirstObj->GetType() == PDFOBJ_REFERENCE) |
| 449 pFirstObj = pFirstObj->GetDirect(); |
| 450 |
| 451 if (pFirstObj->GetType() != PDFOBJ_STREAM) |
| 452 continue; |
| 453 |
| 454 pAPStream = (CPDF_Stream*)pFirstObj; |
| 455 } |
| 119 } | 456 } |
| 120 else | 457 } |
| 121 { | 458 } |
| 122 if (nAnnotFlag & ANNOTFLAG_PRINT) | 459 |
| 123 ParserStream( pPageDic, pAnnotDic, pRectArray, pObjectArray ); | 460 if (!pAPStream) |
| 124 } | 461 continue; |
| 125 } | 462 |
| 126 return FLATTEN_SUCCESS; | 463 CPDF_Dictionary* pAPDic = pAPStream->GetDict(); |
| 127 } | 464 CFX_AffineMatrix matrix = pAPDic->GetMatrix("Matrix"); |
| 128 | 465 |
| 129 | 466 CPDF_Rect rcStream; |
| 130 FX_FLOAT GetMinMaxValue( CPDF_RectArray& array, FPDF_TYPE type, FPDF_VALUE value
) | 467 if (pAPDic->KeyExist("Rect")) |
| 131 { | 468 rcStream = pAPDic->GetRect("Rect"); |
| 132 int nRects = array.GetSize(); | 469 else if (pAPDic->KeyExist("BBox")) |
| 133 FX_FLOAT fRet = 0.0f; | 470 rcStream = pAPDic->GetRect("BBox"); |
| 134 | 471 |
| 135 if (nRects <= 0)return 0.0f; | 472 if (rcStream.IsEmpty()) |
| 136 | 473 continue; |
| 137 FX_FLOAT* pArray = new FX_FLOAT[nRects]; | 474 |
| 138 switch(value) | 475 CPDF_Object* pObj = pAPStream; |
| 139 { | 476 |
| 140 case LEFT: | 477 if (pObj) { |
| 141 { | 478 CPDF_Dictionary* pObjDic = pObj->GetDict(); |
| 142 for (int i = 0; i < nRects; i++) | 479 if (pObjDic) { |
| 143 pArray[i] = CPDF_Rect(array.GetAt(i)).left; | 480 pObjDic->SetAtName("Type", "XObject"); |
| 144 | 481 pObjDic->SetAtName("Subtype", "Form"); |
| 145 break; | 482 } |
| 146 } | 483 } |
| 147 case TOP: | 484 |
| 148 { | 485 CPDF_Dictionary* pXObject = pNewXORes->GetDict("XObject"); |
| 149 for (int i = 0; i < nRects; i++) | 486 if (!pXObject) { |
| 150 pArray[i] = CPDF_Rect(array.GetAt(i)).top; | 487 pXObject = new CPDF_Dictionary; |
| 151 | 488 pNewXORes->SetAt("XObject", pXObject); |
| 152 break; | 489 } |
| 153 } | 490 |
| 154 case RIGHT: | 491 CFX_ByteString sFormName; |
| 155 { | 492 sFormName.Format("F%d", i); |
| 156 for (int i = 0; i < nRects; i++) | 493 FX_DWORD dwObjNum = pDocument->AddIndirectObject(pObj); |
| 157 pArray[i] = CPDF_Rect(array.GetAt(i)).right; | 494 pXObject->SetAtReference(sFormName, pDocument, dwObjNum); |
| 158 | 495 |
| 159 break; | 496 CPDF_StreamAcc acc; |
| 160 } | 497 acc.LoadAllData(pNewXObject); |
| 161 case BOTTOM: | 498 |
| 162 { | 499 const uint8_t* pData = acc.GetData(); |
| 163 for (int i = 0; i < nRects; i++) | 500 CFX_ByteString sStream(pData, acc.GetSize()); |
| 164 pArray[i] = CPDF_Rect(array.GetAt(i)).bottom; | 501 CFX_ByteString sTemp; |
| 165 | 502 |
| 166 break; | 503 if (matrix.IsIdentity()) { |
| 167 } | 504 matrix.a = 1.0f; |
| 168 default: | 505 matrix.b = 0.0f; |
| 169 break; | 506 matrix.c = 0.0f; |
| 170 } | 507 matrix.d = 1.0f; |
| 171 fRet = pArray[0]; | 508 matrix.e = 0.0f; |
| 172 if (type == MAX) | 509 matrix.f = 0.0f; |
| 173 { | 510 } |
| 174 for (int i = 1; i < nRects; i++) | 511 |
| 175 if (fRet <= pArray[i]) | 512 CFX_AffineMatrix m = GetMatrix(rcAnnot, rcStream, matrix); |
| 176 fRet = pArray[i]; | 513 sTemp.Format("q %f 0 0 %f %f %f cm /%s Do Q\n", m.a, m.d, m.e, m.f, |
| 177 } | 514 sFormName.c_str()); |
| 178 else | 515 sStream += sTemp; |
| 179 { | 516 |
| 180 for (int i = 1; i < nRects; i++) | 517 pNewXObject->SetData((const uint8_t*)sStream, sStream.GetLength(), FALSE, |
| 181 if (fRet >= pArray[i]) | 518 FALSE); |
| 182 fRet = pArray[i]; | 519 } |
| 183 } | 520 pPageDict->RemoveAt("Annots"); |
| 184 delete[] pArray; | 521 |
| 185 return fRet; | 522 ObjectArray.RemoveAll(); |
| 186 } | 523 RectArray.RemoveAll(); |
| 187 | 524 |
| 188 CPDF_Rect CalculateRect( CPDF_RectArray * pRectArray ) | 525 return FLATTEN_SUCCESS; |
| 189 { | 526 } |
| 190 | |
| 191 CPDF_Rect rcRet; | |
| 192 | |
| 193 rcRet.left = GetMinMaxValue(*pRectArray, MIN, LEFT); | |
| 194 rcRet.top = GetMinMaxValue(*pRectArray, MAX, TOP); | |
| 195 rcRet.right = GetMinMaxValue(*pRectArray, MAX, RIGHT); | |
| 196 rcRet.bottom = GetMinMaxValue(*pRectArray, MIN, BOTTOM); | |
| 197 | |
| 198 return rcRet; | |
| 199 } | |
| 200 | |
| 201 | |
| 202 void SetPageContents(CFX_ByteString key, CPDF_Dictionary* pPage, CPDF_Document*
pDocument) | |
| 203 { | |
| 204 CPDF_Object* pContentsObj = pPage->GetStream("Contents"); | |
| 205 if (!pContentsObj) | |
| 206 { | |
| 207 pContentsObj = pPage->GetArray("Contents"); | |
| 208 } | |
| 209 | |
| 210 if (!pContentsObj) | |
| 211 { | |
| 212 //Create a new contents dictionary | |
| 213 if (!key.IsEmpty()) | |
| 214 { | |
| 215 CPDF_Stream* pNewContents = new CPDF_Stream(NULL, 0, new
CPDF_Dictionary); | |
| 216 pPage->SetAtReference("Contents", pDocument, pDocument->
AddIndirectObject(pNewContents)); | |
| 217 | |
| 218 CFX_ByteString sStream; | |
| 219 sStream.Format("q 1 0 0 1 0 0 cm /%s Do Q", key.c_str())
; | |
| 220 pNewContents->SetData((const uint8_t*)sStream, sStream.G
etLength(), FALSE, FALSE); | |
| 221 } | |
| 222 return; | |
| 223 } | |
| 224 | |
| 225 int iType = pContentsObj->GetType(); | |
| 226 CPDF_Array* pContentsArray = NULL; | |
| 227 | |
| 228 switch(iType) | |
| 229 { | |
| 230 case PDFOBJ_STREAM: | |
| 231 { | |
| 232 pContentsArray = new CPDF_Array; | |
| 233 CPDF_Stream* pContents = (CPDF_Stream*)pContentsObj; | |
| 234 FX_DWORD dwObjNum = pDocument->AddIndirectObject(pConten
ts); | |
| 235 CPDF_StreamAcc acc; | |
| 236 acc.LoadAllData(pContents); | |
| 237 CFX_ByteString sStream = "q\n"; | |
| 238 CFX_ByteString sBody = CFX_ByteString((const FX_CHAR*)ac
c.GetData(), acc.GetSize()); | |
| 239 sStream = sStream + sBody + "\nQ"; | |
| 240 pContents->SetData((const uint8_t*)sStream, sStream.GetL
ength(), FALSE, FALSE); | |
| 241 pContentsArray->AddReference(pDocument, dwObjNum); | |
| 242 break; | |
| 243 } | |
| 244 | |
| 245 case PDFOBJ_ARRAY: | |
| 246 { | |
| 247 pContentsArray = (CPDF_Array*)pContentsObj; | |
| 248 break; | |
| 249 } | |
| 250 default: | |
| 251 break; | |
| 252 } | |
| 253 | |
| 254 if (!pContentsArray)return; | |
| 255 | |
| 256 FX_DWORD dwObjNum = pDocument->AddIndirectObject(pContentsArray); | |
| 257 pPage->SetAtReference("Contents", pDocument, dwObjNum); | |
| 258 | |
| 259 if (!key.IsEmpty()) | |
| 260 { | |
| 261 CPDF_Stream* pNewContents = new CPDF_Stream(NULL, 0, new CPDF_Di
ctionary); | |
| 262 dwObjNum = pDocument->AddIndirectObject(pNewContents); | |
| 263 pContentsArray->AddReference(pDocument, dwObjNum); | |
| 264 | |
| 265 CFX_ByteString sStream; | |
| 266 sStream.Format("q 1 0 0 1 0 0 cm /%s Do Q", key.c_str()); | |
| 267 pNewContents->SetData((const uint8_t*)sStream, sStream.GetLength
(), FALSE, FALSE); | |
| 268 } | |
| 269 } | |
| 270 | |
| 271 CFX_AffineMatrix GetMatrix(CPDF_Rect rcAnnot, CPDF_Rect rcStream, CFX_AffineMatr
ix matrix) | |
| 272 { | |
| 273 if(rcStream.IsEmpty()) | |
| 274 return CFX_AffineMatrix(); | |
| 275 | |
| 276 matrix.TransformRect(rcStream); | |
| 277 rcStream.Normalize(); | |
| 278 | |
| 279 FX_FLOAT a = rcAnnot.Width()/rcStream.Width(); | |
| 280 FX_FLOAT d = rcAnnot.Height()/rcStream.Height(); | |
| 281 | |
| 282 FX_FLOAT e = rcAnnot.left - rcStream.left * a; | |
| 283 FX_FLOAT f = rcAnnot.bottom - rcStream.bottom * d; | |
| 284 return CFX_AffineMatrix(a, 0, 0, d, e, f); | |
| 285 } | |
| 286 | |
| 287 void GetOffset(FX_FLOAT& fa, FX_FLOAT& fd, FX_FLOAT& fe, FX_FLOAT& ff, CPDF_Rect
rcAnnot, CPDF_Rect rcStream, CFX_AffineMatrix matrix) | |
| 288 { | |
| 289 FX_FLOAT fStreamWidth = 0.0f; | |
| 290 FX_FLOAT fStreamHeight = 0.0f; | |
| 291 | |
| 292 | |
| 293 | |
| 294 if (matrix.a != 0 && matrix.d != 0) | |
| 295 { | |
| 296 fStreamWidth = rcStream.right - rcStream.left; | |
| 297 fStreamHeight = rcStream.top - rcStream.bottom; | |
| 298 } | |
| 299 else | |
| 300 { | |
| 301 fStreamWidth = rcStream.top - rcStream.bottom; | |
| 302 fStreamHeight = rcStream.right - rcStream.left; | |
| 303 } | |
| 304 | |
| 305 FX_FLOAT x1 = matrix.a * rcStream.left + matrix.c * rcStream.bottom + ma
trix.e; | |
| 306 FX_FLOAT y1 = matrix.b * rcStream.left + matrix.d * rcStream.bottom + ma
trix.f; | |
| 307 FX_FLOAT x2 = matrix.a * rcStream.left + matrix.c * rcStream.top + matri
x.e; | |
| 308 FX_FLOAT y2 = matrix.b * rcStream.left + matrix.d * rcStream.top + matri
x.f; | |
| 309 FX_FLOAT x3 = matrix.a * rcStream.right + matrix.c * rcStream.bottom + m
atrix.e; | |
| 310 FX_FLOAT y3 = matrix.b * rcStream.right + matrix.d * rcStream.bottom + m
atrix.f; | |
| 311 FX_FLOAT x4 = matrix.a * rcStream.right + matrix.c * rcStream.top + matr
ix.e; | |
| 312 FX_FLOAT y4 = matrix.b * rcStream.right + matrix.d * rcStream.top + matr
ix.f; | |
| 313 | |
| 314 FX_FLOAT left = FX_MIN(FX_MIN(x1, x2), FX_MIN(x3, x4)); | |
| 315 FX_FLOAT bottom = FX_MIN(FX_MIN(y1, y2), FX_MIN(y3, y4)); | |
| 316 | |
| 317 fa = (rcAnnot.right - rcAnnot.left)/fStreamWidth; | |
| 318 fd = (rcAnnot.top - rcAnnot.bottom)/fStreamHeight; | |
| 319 fe = rcAnnot.left - left * fa; | |
| 320 ff = rcAnnot.bottom - bottom * fd; | |
| 321 } | |
| 322 | |
| 323 | |
| 324 DLLEXPORT int STDCALL FPDFPage_Flatten( FPDF_PAGE page, int nFlag) | |
| 325 { | |
| 326 if (!page) | |
| 327 { | |
| 328 return FLATTEN_FAIL; | |
| 329 } | |
| 330 | |
| 331 CPDF_Page * pPage = (CPDF_Page*)( page ); | |
| 332 CPDF_Document * pDocument = pPage->m_pDocument; | |
| 333 CPDF_Dictionary * pPageDict = pPage->m_pFormDict; | |
| 334 | |
| 335 if ( !pDocument || !pPageDict ) | |
| 336 { | |
| 337 return FLATTEN_FAIL; | |
| 338 } | |
| 339 | |
| 340 CPDF_ObjectArray ObjectArray; | |
| 341 CPDF_RectArray RectArray; | |
| 342 | |
| 343 int iRet = FLATTEN_FAIL; | |
| 344 iRet = ParserAnnots( pDocument, pPageDict, &RectArray, &ObjectArray, nFl
ag); | |
| 345 if (iRet == FLATTEN_NOTHINGTODO || iRet == FLATTEN_FAIL) | |
| 346 return iRet; | |
| 347 | |
| 348 CPDF_Rect rcOriginalCB; | |
| 349 CPDF_Rect rcMerger = CalculateRect( &RectArray ); | |
| 350 CPDF_Rect rcOriginalMB = pPageDict->GetRect("MediaBox"); | |
| 351 | |
| 352 if (pPageDict->KeyExist("CropBox")) | |
| 353 rcOriginalMB = pPageDict->GetRect("CropBox"); | |
| 354 | |
| 355 if (rcOriginalMB.IsEmpty()) | |
| 356 { | |
| 357 rcOriginalMB = CPDF_Rect(0.0f, 0.0f, 612.0f, 792.0f); | |
| 358 } | |
| 359 | |
| 360 rcMerger.left = rcMerger.left < rcOriginalMB.left? rcOriginalMB.left : r
cMerger.left; | |
| 361 rcMerger.right = rcMerger.right > rcOriginalMB.right? rcOriginalMB.right
: rcMerger.right; | |
| 362 rcMerger.top = rcMerger.top > rcOriginalMB.top? rcOriginalMB.top : rcMer
ger.top; | |
| 363 rcMerger.bottom = rcMerger.bottom < rcOriginalMB.bottom? rcOriginalMB.bo
ttom : rcMerger.bottom; | |
| 364 | |
| 365 if (pPageDict->KeyExist("ArtBox")) | |
| 366 rcOriginalCB = pPageDict->GetRect("ArtBox"); | |
| 367 else | |
| 368 rcOriginalCB = rcOriginalMB; | |
| 369 | |
| 370 if (!rcOriginalMB.IsEmpty()) | |
| 371 { | |
| 372 CPDF_Array* pMediaBox = new CPDF_Array(); | |
| 373 pMediaBox->Add(new CPDF_Number(rcOriginalMB.left)); | |
| 374 pMediaBox->Add(new CPDF_Number(rcOriginalMB.bottom)); | |
| 375 pMediaBox->Add(new CPDF_Number(rcOriginalMB.right)); | |
| 376 pMediaBox->Add(new CPDF_Number(rcOriginalMB.top)); | |
| 377 pPageDict->SetAt("MediaBox",pMediaBox); | |
| 378 } | |
| 379 | |
| 380 if (!rcOriginalCB.IsEmpty()) | |
| 381 { | |
| 382 CPDF_Array* pCropBox = new CPDF_Array(); | |
| 383 pCropBox->Add(new CPDF_Number(rcOriginalCB.left)); | |
| 384 pCropBox->Add(new CPDF_Number(rcOriginalCB.bottom)); | |
| 385 pCropBox->Add(new CPDF_Number(rcOriginalCB.right)); | |
| 386 pCropBox->Add(new CPDF_Number(rcOriginalCB.top)); | |
| 387 pPageDict->SetAt("ArtBox", pCropBox); | |
| 388 } | |
| 389 | |
| 390 CPDF_Dictionary* pRes = pPageDict->GetDict("Resources"); | |
| 391 if (!pRes) | |
| 392 { | |
| 393 pRes = new CPDF_Dictionary; | |
| 394 pPageDict->SetAt("Resources", pRes ); | |
| 395 } | |
| 396 | |
| 397 CPDF_Stream* pNewXObject = new CPDF_Stream(NULL, 0, new CPDF_Dictionary)
; | |
| 398 FX_DWORD dwObjNum = pDocument->AddIndirectObject(pNewXObject); | |
| 399 CPDF_Dictionary* pPageXObject = pRes->GetDict("XObject"); | |
| 400 if (!pPageXObject) | |
| 401 { | |
| 402 pPageXObject = new CPDF_Dictionary; | |
| 403 pRes->SetAt("XObject", pPageXObject); | |
| 404 } | |
| 405 | |
| 406 CFX_ByteString key = ""; | |
| 407 int nStreams = ObjectArray.GetSize(); | |
| 408 | |
| 409 if (nStreams > 0) | |
| 410 { | |
| 411 for (int iKey = 0; /*iKey < 100*/; iKey++) | |
| 412 { | |
| 413 char sExtend[5] = {}; | |
| 414 FXSYS_itoa(iKey, sExtend, 10); | |
| 415 key = CFX_ByteString("FFT") + CFX_ByteString(sExtend); | |
| 416 | |
| 417 if (!pPageXObject->KeyExist(key)) | |
| 418 break; | |
| 419 } | |
| 420 } | |
| 421 | |
| 422 SetPageContents(key, pPageDict, pDocument); | |
| 423 | |
| 424 CPDF_Dictionary* pNewXORes = NULL; | |
| 425 | |
| 426 if (!key.IsEmpty()) | |
| 427 { | |
| 428 pPageXObject->SetAtReference(key, pDocument, dwObjNum); | |
| 429 CPDF_Dictionary* pNewOXbjectDic = pNewXObject->GetDict(); | |
| 430 pNewXORes = new CPDF_Dictionary; | |
| 431 pNewOXbjectDic->SetAt("Resources", pNewXORes); | |
| 432 pNewOXbjectDic->SetAtName("Type", "XObject"); | |
| 433 pNewOXbjectDic->SetAtName("Subtype", "Form"); | |
| 434 pNewOXbjectDic->SetAtInteger("FormType", 1); | |
| 435 pNewOXbjectDic->SetAtName("Name", "FRM"); | |
| 436 CPDF_Rect rcBBox = pPageDict->GetRect("ArtBox"); | |
| 437 pNewOXbjectDic->SetAtRect("BBox", rcBBox); | |
| 438 } | |
| 439 | |
| 440 for (int i = 0; i < nStreams; i++) | |
| 441 { | |
| 442 CPDF_Dictionary* pAnnotDic = ObjectArray.GetAt(i); | |
| 443 if (!pAnnotDic)continue; | |
| 444 | |
| 445 CPDF_Rect rcAnnot = pAnnotDic->GetRect("Rect"); | |
| 446 rcAnnot.Normalize(); | |
| 447 | |
| 448 CFX_ByteString sAnnotState = pAnnotDic->GetString("AS"); | |
| 449 CPDF_Dictionary* pAnnotAP = pAnnotDic->GetDict("AP"); | |
| 450 if (!pAnnotAP)continue; | |
| 451 | |
| 452 CPDF_Stream* pAPStream = pAnnotAP->GetStream("N"); | |
| 453 if (!pAPStream) | |
| 454 { | |
| 455 CPDF_Dictionary* pAPDic = pAnnotAP->GetDict("N"); | |
| 456 if (!pAPDic)continue; | |
| 457 | |
| 458 if (!sAnnotState.IsEmpty()) | |
| 459 { | |
| 460 pAPStream = pAPDic->GetStream(sAnnotState); | |
| 461 } | |
| 462 else | |
| 463 { | |
| 464 FX_POSITION pos = pAPDic->GetStartPos(); | |
| 465 if (pos) | |
| 466 { | |
| 467 CFX_ByteString sKey; | |
| 468 CPDF_Object* pFirstObj = pAPDic->GetNext
Element(pos, sKey); | |
| 469 if (pFirstObj) | |
| 470 { | |
| 471 if (pFirstObj->GetType() == PDFO
BJ_REFERENCE) | |
| 472 pFirstObj = pFirstObj->G
etDirect(); | |
| 473 | |
| 474 if (pFirstObj->GetType() != PDFO
BJ_STREAM) | |
| 475 continue; | |
| 476 | |
| 477 pAPStream = (CPDF_Stream*)pFirst
Obj; | |
| 478 } | |
| 479 } | |
| 480 } | |
| 481 } | |
| 482 | |
| 483 if (!pAPStream)continue; | |
| 484 | |
| 485 CPDF_Dictionary* pAPDic = pAPStream->GetDict(); | |
| 486 CFX_AffineMatrix matrix = pAPDic->GetMatrix("Matrix"); | |
| 487 | |
| 488 CPDF_Rect rcStream; | |
| 489 if (pAPDic->KeyExist("Rect")) | |
| 490 rcStream = pAPDic->GetRect("Rect"); | |
| 491 else if (pAPDic->KeyExist("BBox")) | |
| 492 rcStream = pAPDic->GetRect("BBox"); | |
| 493 | |
| 494 if (rcStream.IsEmpty())continue; | |
| 495 | |
| 496 CPDF_Object* pObj = pAPStream; | |
| 497 | |
| 498 if (pObj) | |
| 499 { | |
| 500 CPDF_Dictionary* pObjDic = pObj->GetDict(); | |
| 501 if (pObjDic) | |
| 502 { | |
| 503 pObjDic->SetAtName("Type", "XObject"); | |
| 504 pObjDic->SetAtName("Subtype", "Form"); | |
| 505 } | |
| 506 } | |
| 507 | |
| 508 CPDF_Dictionary* pXObject = pNewXORes->GetDict("XObject"); | |
| 509 if (!pXObject) | |
| 510 { | |
| 511 pXObject = new CPDF_Dictionary; | |
| 512 pNewXORes->SetAt("XObject", pXObject); | |
| 513 } | |
| 514 | |
| 515 CFX_ByteString sFormName; | |
| 516 sFormName.Format("F%d", i); | |
| 517 FX_DWORD dwObjNum = pDocument->AddIndirectObject(pObj); | |
| 518 pXObject->SetAtReference(sFormName, pDocument, dwObjNum); | |
| 519 | |
| 520 CPDF_StreamAcc acc; | |
| 521 acc.LoadAllData(pNewXObject); | |
| 522 | |
| 523 const uint8_t* pData = acc.GetData(); | |
| 524 CFX_ByteString sStream(pData, acc.GetSize()); | |
| 525 CFX_ByteString sTemp; | |
| 526 | |
| 527 if (matrix.IsIdentity()) | |
| 528 { | |
| 529 matrix.a = 1.0f; | |
| 530 matrix.b = 0.0f; | |
| 531 matrix.c = 0.0f; | |
| 532 matrix.d = 1.0f; | |
| 533 matrix.e = 0.0f; | |
| 534 matrix.f = 0.0f; | |
| 535 } | |
| 536 | |
| 537 CFX_AffineMatrix m = GetMatrix(rcAnnot, rcStream, matrix); | |
| 538 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()); | |
| 539 sStream += sTemp; | |
| 540 | |
| 541 pNewXObject->SetData((const uint8_t*)sStream, sStream.GetLength(
), FALSE, FALSE); | |
| 542 } | |
| 543 pPageDict->RemoveAt( "Annots" ); | |
| 544 | |
| 545 ObjectArray.RemoveAll(); | |
| 546 RectArray.RemoveAll(); | |
| 547 | |
| 548 return FLATTEN_SUCCESS; | |
| 549 } | |
| OLD | NEW |