summaryrefslogtreecommitdiff
path: root/fpdfsdk/fpdfppo.cpp
diff options
context:
space:
mode:
authorDan Sinclair <dsinclair@chromium.org>2016-03-14 13:51:24 -0400
committerDan Sinclair <dsinclair@chromium.org>2016-03-14 13:51:24 -0400
commitf766ad219f66543654520f6a1955836f519e26d1 (patch)
tree2edf8bc93b89503a3669f7add5b6c2a407b8a78c /fpdfsdk/fpdfppo.cpp
parent54b0abed08048008498471e39b7c72b034474090 (diff)
downloadpdfium-f766ad219f66543654520f6a1955836f519e26d1.tar.xz
Move fpdfsdk/src up to fpdfsdk/.
This CL moves the files in fpdfsdk/src/ up one level to fpdfsdk/ and fixes up the include paths, include guards and build files. R=tsepez@chromium.org Review URL: https://codereview.chromium.org/1799773002 .
Diffstat (limited to 'fpdfsdk/fpdfppo.cpp')
-rw-r--r--fpdfsdk/fpdfppo.cpp415
1 files changed, 415 insertions, 0 deletions
diff --git a/fpdfsdk/fpdfppo.cpp b/fpdfsdk/fpdfppo.cpp
new file mode 100644
index 0000000000..4253cc5fd9
--- /dev/null
+++ b/fpdfsdk/fpdfppo.cpp
@@ -0,0 +1,415 @@
+// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#include "public/fpdf_ppo.h"
+
+#include <map>
+#include <memory>
+#include <vector>
+
+#include "core/include/fpdfapi/cpdf_array.h"
+#include "core/include/fpdfapi/cpdf_document.h"
+#include "core/include/fpdfapi/cpdf_name.h"
+#include "core/include/fpdfapi/cpdf_number.h"
+#include "core/include/fpdfapi/cpdf_reference.h"
+#include "core/include/fpdfapi/cpdf_string.h"
+#include "fpdfsdk/include/fsdk_define.h"
+#include "third_party/base/stl_util.h"
+
+class CPDF_PageOrganizer {
+ public:
+ using ObjectNumberMap = std::map<FX_DWORD, FX_DWORD>;
+ CPDF_PageOrganizer();
+ ~CPDF_PageOrganizer();
+
+ FX_BOOL PDFDocInit(CPDF_Document* pDestPDFDoc, CPDF_Document* pSrcPDFDoc);
+ FX_BOOL ExportPage(CPDF_Document* pSrcPDFDoc,
+ std::vector<FX_WORD>* pPageNums,
+ CPDF_Document* pDestPDFDoc,
+ int nIndex);
+ CPDF_Object* PageDictGetInheritableTag(CPDF_Dictionary* pDict,
+ CFX_ByteString nSrctag);
+ FX_BOOL UpdateReference(CPDF_Object* pObj,
+ CPDF_Document* pDoc,
+ ObjectNumberMap* pObjNumberMap);
+ FX_DWORD GetNewObjId(CPDF_Document* pDoc,
+ ObjectNumberMap* pObjNumberMap,
+ CPDF_Reference* pRef);
+};
+
+CPDF_PageOrganizer::CPDF_PageOrganizer() {}
+
+CPDF_PageOrganizer::~CPDF_PageOrganizer() {}
+
+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, FALSE));
+
+ // Set type
+ CFX_ByteString cbRootType = pNewRoot->GetStringBy("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->GetStringBy("Type", "");
+ if (cbPageType.Equal("")) {
+ pNewPages->SetAt("Type", new CPDF_Name("Pages"));
+ }
+
+ CPDF_Array* pKeysArray = pNewPages->GetArrayBy("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;
+}
+
+FX_BOOL CPDF_PageOrganizer::ExportPage(CPDF_Document* pSrcPDFDoc,
+ std::vector<FX_WORD>* pPageNums,
+ CPDF_Document* pDestPDFDoc,
+ int nIndex) {
+ int curpage = nIndex;
+ std::unique_ptr<ObjectNumberMap> pObjNumberMap(new ObjectNumberMap);
+ int nSize = pdfium::CollectionSize<int>(*pPageNums);
+ for (int i = 0; i < nSize; ++i) {
+ CPDF_Dictionary* pCurPageDict = pDestPDFDoc->CreateNewPage(curpage);
+ CPDF_Dictionary* pSrcPageDict = pSrcPDFDoc->GetPage(pPageNums->at(i) - 1);
+ if (!pSrcPageDict || !pCurPageDict)
+ return FALSE;
+
+ // Clone the page dictionary
+ for (const auto& it : *pSrcPageDict) {
+ const CFX_ByteString& cbSrcKeyStr = it.first;
+ CPDF_Object* pObj = it.second;
+ if (cbSrcKeyStr.Compare(("Type")) && cbSrcKeyStr.Compare(("Parent"))) {
+ if (pCurPageDict->KeyExist(cbSrcKeyStr))
+ pCurPageDict->RemoveAt(cbSrcKeyStr);
+ pCurPageDict->SetAt(cbSrcKeyStr, pObj->Clone());
+ }
+ }
+
+ // inheritable item
+ CPDF_Object* pInheritable = nullptr;
+ // 1 MediaBox //required
+ if (!pCurPageDict->KeyExist("MediaBox")) {
+ pInheritable = PageDictGetInheritableTag(pSrcPageDict, "MediaBox");
+ if (!pInheritable) {
+ // Search the "CropBox" from source page dictionary,
+ // if not exists,we take the letter size.
+ pInheritable = PageDictGetInheritableTag(pSrcPageDict, "CropBox");
+ if (pInheritable) {
+ pCurPageDict->SetAt("MediaBox", pInheritable->Clone());
+ } else {
+ // Make the default size to be letter size (8.5'x11')
+ CPDF_Array* pArray = new CPDF_Array;
+ pArray->AddNumber(0);
+ pArray->AddNumber(0);
+ pArray->AddNumber(612);
+ pArray->AddNumber(792);
+ pCurPageDict->SetAt("MediaBox", pArray);
+ }
+ } else {
+ pCurPageDict->SetAt("MediaBox", pInheritable->Clone());
+ }
+ }
+ // 2 Resources //required
+ if (!pCurPageDict->KeyExist("Resources")) {
+ pInheritable = PageDictGetInheritableTag(pSrcPageDict, "Resources");
+ if (!pInheritable)
+ return FALSE;
+ pCurPageDict->SetAt("Resources", pInheritable->Clone());
+ }
+ // 3 CropBox //Optional
+ if (!pCurPageDict->KeyExist("CropBox")) {
+ pInheritable = PageDictGetInheritableTag(pSrcPageDict, "CropBox");
+ if (pInheritable)
+ pCurPageDict->SetAt("CropBox", pInheritable->Clone());
+ }
+ // 4 Rotate //Optional
+ if (!pCurPageDict->KeyExist("Rotate")) {
+ pInheritable = PageDictGetInheritableTag(pSrcPageDict, "Rotate");
+ if (pInheritable)
+ pCurPageDict->SetAt("Rotate", pInheritable->Clone());
+ }
+
+ // Update the reference
+ FX_DWORD dwOldPageObj = pSrcPageDict->GetObjNum();
+ FX_DWORD dwNewPageObj = pCurPageDict->GetObjNum();
+
+ (*pObjNumberMap)[dwOldPageObj] = dwNewPageObj;
+
+ UpdateReference(pCurPageDict, pDestPDFDoc, pObjNumberMap.get());
+ ++curpage;
+ }
+
+ return TRUE;
+}
+
+CPDF_Object* CPDF_PageOrganizer::PageDictGetInheritableTag(
+ CPDF_Dictionary* pDict,
+ CFX_ByteString nSrctag) {
+ if (!pDict || nSrctag.IsEmpty())
+ return nullptr;
+ if (!pDict->KeyExist("Parent") || !pDict->KeyExist("Type"))
+ return nullptr;
+
+ CPDF_Object* pType = pDict->GetElement("Type")->GetDirect();
+ if (!ToName(pType))
+ return nullptr;
+ if (pType->GetString().Compare("Page"))
+ return nullptr;
+
+ CPDF_Dictionary* pp = ToDictionary(pDict->GetElement("Parent")->GetDirect());
+ if (!pp)
+ return nullptr;
+
+ if (pDict->KeyExist((const char*)nSrctag))
+ return pDict->GetElement((const char*)nSrctag);
+
+ while (pp) {
+ if (pp->KeyExist((const char*)nSrctag))
+ return pp->GetElement((const char*)nSrctag);
+ if (!pp->KeyExist("Parent"))
+ break;
+ pp = ToDictionary(pp->GetElement("Parent")->GetDirect());
+ }
+ return nullptr;
+}
+
+FX_BOOL CPDF_PageOrganizer::UpdateReference(CPDF_Object* pObj,
+ CPDF_Document* pDoc,
+ ObjectNumberMap* pObjNumberMap) {
+ switch (pObj->GetType()) {
+ case CPDF_Object::REFERENCE: {
+ CPDF_Reference* pReference = pObj->AsReference();
+ FX_DWORD newobjnum = GetNewObjId(pDoc, pObjNumberMap, pReference);
+ if (newobjnum == 0)
+ return FALSE;
+ pReference->SetRef(pDoc, newobjnum);
+ break;
+ }
+ case CPDF_Object::DICTIONARY: {
+ CPDF_Dictionary* pDict = pObj->AsDictionary();
+ auto it = pDict->begin();
+ while (it != pDict->end()) {
+ const CFX_ByteString& key = it->first;
+ CPDF_Object* pNextObj = it->second;
+ ++it;
+ if (!FXSYS_strcmp(key, "Parent") || !FXSYS_strcmp(key, "Prev") ||
+ !FXSYS_strcmp(key, "First")) {
+ continue;
+ }
+ if (pNextObj) {
+ if (!UpdateReference(pNextObj, pDoc, pObjNumberMap))
+ pDict->RemoveAt(key);
+ } else {
+ return FALSE;
+ }
+ }
+ break;
+ }
+ case CPDF_Object::ARRAY: {
+ CPDF_Array* pArray = pObj->AsArray();
+ FX_DWORD count = pArray->GetCount();
+ for (FX_DWORD i = 0; i < count; ++i) {
+ CPDF_Object* pNextObj = pArray->GetElement(i);
+ if (!pNextObj)
+ return FALSE;
+ if (!UpdateReference(pNextObj, pDoc, pObjNumberMap))
+ return FALSE;
+ }
+ break;
+ }
+ case CPDF_Object::STREAM: {
+ CPDF_Stream* pStream = pObj->AsStream();
+ CPDF_Dictionary* pDict = pStream->GetDict();
+ if (pDict) {
+ if (!UpdateReference(pDict, pDoc, pObjNumberMap))
+ return FALSE;
+ } else {
+ return FALSE;
+ }
+ break;
+ }
+ default:
+ break;
+ }
+
+ return TRUE;
+}
+
+FX_DWORD CPDF_PageOrganizer::GetNewObjId(CPDF_Document* pDoc,
+ ObjectNumberMap* pObjNumberMap,
+ CPDF_Reference* pRef) {
+ if (!pRef)
+ return 0;
+
+ FX_DWORD dwObjnum = pRef->GetRefObjNum();
+ FX_DWORD dwNewObjNum = 0;
+ const auto it = pObjNumberMap->find(dwObjnum);
+ if (it != pObjNumberMap->end())
+ dwNewObjNum = it->second;
+ if (dwNewObjNum)
+ return dwNewObjNum;
+
+ CPDF_Object* pDirect = pRef->GetDirect();
+ if (!pDirect)
+ return 0;
+
+ CPDF_Object* pClone = pDirect->Clone();
+ if (!pClone)
+ return 0;
+
+ if (CPDF_Dictionary* pDictClone = pClone->AsDictionary()) {
+ if (pDictClone->KeyExist("Type")) {
+ CFX_ByteString strType = pDictClone->GetStringBy("Type");
+ if (!FXSYS_stricmp(strType, "Pages")) {
+ pDictClone->Release();
+ return 4;
+ }
+ if (!FXSYS_stricmp(strType, "Page")) {
+ pDictClone->Release();
+ return 0;
+ }
+ }
+ }
+ dwNewObjNum = pDoc->AddIndirectObject(pClone);
+ (*pObjNumberMap)[dwObjnum] = dwNewObjNum;
+ if (!UpdateReference(pClone, pDoc, pObjNumberMap)) {
+ pClone->Release();
+ return 0;
+ }
+ return dwNewObjNum;
+}
+
+FPDF_BOOL ParserPageRangeString(CFX_ByteString rangstring,
+ std::vector<FX_WORD>* pageArray,
+ int nCount) {
+ if (rangstring.GetLength() != 0) {
+ rangstring.Remove(' ');
+ int nLength = rangstring.GetLength();
+ CFX_ByteString cbCompareString("0123456789-,");
+ for (int i = 0; i < nLength; ++i) {
+ if (cbCompareString.Find(rangstring[i]) == -1)
+ return FALSE;
+ }
+ CFX_ByteString cbMidRange;
+ int nStringFrom = 0;
+ int nStringTo = 0;
+ while (nStringTo < nLength) {
+ nStringTo = rangstring.Find(',', nStringFrom);
+ if (nStringTo == -1)
+ nStringTo = nLength;
+ cbMidRange = rangstring.Mid(nStringFrom, nStringTo - nStringFrom);
+ int nMid = cbMidRange.Find('-');
+ if (nMid == -1) {
+ long lPageNum = atol(cbMidRange);
+ if (lPageNum <= 0 || lPageNum > nCount)
+ return FALSE;
+ pageArray->push_back((FX_WORD)lPageNum);
+ } else {
+ int nStartPageNum = atol(cbMidRange.Mid(0, nMid));
+ if (nStartPageNum == 0)
+ return FALSE;
+
+ ++nMid;
+ int nEnd = cbMidRange.GetLength() - nMid;
+ if (nEnd == 0)
+ return FALSE;
+
+ int nEndPageNum = atol(cbMidRange.Mid(nMid, nEnd));
+ if (nStartPageNum < 0 || nStartPageNum > nEndPageNum ||
+ nEndPageNum > nCount) {
+ return FALSE;
+ }
+ for (int i = nStartPageNum; i <= nEndPageNum; ++i) {
+ pageArray->push_back(i);
+ }
+ }
+ nStringFrom = nStringTo + 1;
+ }
+ }
+ return TRUE;
+}
+
+DLLEXPORT FPDF_BOOL STDCALL FPDF_ImportPages(FPDF_DOCUMENT dest_doc,
+ FPDF_DOCUMENT src_doc,
+ FPDF_BYTESTRING pagerange,
+ int index) {
+ CPDF_Document* pDestDoc = CPDFDocumentFromFPDFDocument(dest_doc);
+ if (!dest_doc)
+ return FALSE;
+
+ CPDF_Document* pSrcDoc = CPDFDocumentFromFPDFDocument(src_doc);
+ if (!pSrcDoc)
+ return FALSE;
+
+ std::vector<FX_WORD> pageArray;
+ int nCount = pSrcDoc->GetPageCount();
+ if (pagerange) {
+ if (!ParserPageRangeString(pagerange, &pageArray, nCount))
+ return FALSE;
+ } else {
+ for (int i = 1; i <= nCount; ++i) {
+ pageArray.push_back(i);
+ }
+ }
+
+ CPDF_PageOrganizer pageOrg;
+ pageOrg.PDFDocInit(pDestDoc, pSrcDoc);
+ return pageOrg.ExportPage(pSrcDoc, &pageArray, pDestDoc, index);
+}
+
+DLLEXPORT FPDF_BOOL STDCALL FPDF_CopyViewerPreferences(FPDF_DOCUMENT dest_doc,
+ FPDF_DOCUMENT src_doc) {
+ CPDF_Document* pDstDoc = CPDFDocumentFromFPDFDocument(dest_doc);
+ if (!pDstDoc)
+ return FALSE;
+
+ CPDF_Document* pSrcDoc = CPDFDocumentFromFPDFDocument(src_doc);
+ if (!pSrcDoc)
+ return FALSE;
+
+ CPDF_Dictionary* pSrcDict = pSrcDoc->GetRoot();
+ pSrcDict = pSrcDict->GetDictBy("ViewerPreferences");
+ if (!pSrcDict)
+ return FALSE;
+
+ CPDF_Dictionary* pDstDict = pDstDoc->GetRoot();
+ if (!pDstDict)
+ return FALSE;
+
+ pDstDict->SetAt("ViewerPreferences", pSrcDict->Clone(TRUE));
+ return TRUE;
+}