path: root/fpdfsdk/src/fpdfppo.cpp

// 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 "../include/fsdk_define.h"
#include "../include/fpdfxfa/fpdfxfa_doc.h"

class CPDF_PageOrganizer
{
public:
    CPDF_PageOrganizer();
    ~CPDF_PageOrganizer();

public:
    FX_BOOL             PDFDocInit(CPDF_Document *pDestPDFDoc, CPDF_Document *pSrcPDFDoc);
    FX_BOOL             ExportPage(CPDF_Document *pSrcPDFDoc, CFX_WordArray* nPageNum, CPDF_Document *pDestPDFDoc, int nIndex);
    CPDF_Object*        PageDictGetInheritableTag(CPDF_Dictionary *pDict, CFX_ByteString nSrctag);
    FX_BOOL             UpdateReference(CPDF_Object *pObj, CPDF_Document *pDoc, CFX_MapPtrToPtr* pMapPtrToPtr);
    int                 GetNewObjId(CPDF_Document *pDoc, CFX_MapPtrToPtr* pMapPtrToPtr, 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));

    //Set type////////////////////////////////////////////////////////////////
    CFX_ByteString cbRootType = pNewRoot->GetString("Type","");
    if( cbRootType.Equal("") )
    {
        pNewRoot->SetAt("Type", new CPDF_Name("Catalog"));
    }

    CPDF_Dictionary* pNewPages = (CPDF_Dictionary*)(pNewRoot->GetElement("Pages")? pNewRoot->GetElement("Pages")->GetDirect() : NULL);
    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 == NULL)
    {
        CPDF_Array* pNewKids = new CPDF_Array;
        FX_DWORD Kidsobjnum = -1;
        Kidsobjnum = pDestPDFDoc->AddIndirectObject(pNewKids);//, Kidsobjnum, Kidsgennum);

        pNewPages->SetAt("Kids", new CPDF_Reference(pDestPDFDoc, Kidsobjnum));//, Kidsgennum));
        pNewPages->SetAt("Count", new CPDF_Number(0));
    }

    return true;
}

FX_BOOL CPDF_PageOrganizer::ExportPage(CPDF_Document *pSrcPDFDoc, CFX_WordArray* nPageNum,
                                                CPDF_Document *pDestPDFDoc,int nIndex)
{
    int curpage =nIndex;

    CFX_MapPtrToPtr* pMapPtrToPtr = new CFX_MapPtrToPtr;
    pMapPtrToPtr->InitHashTable(1001);

    for(int i=0; i<nPageNum->GetSize(); i++)
    {

        CPDF_Dictionary* pCurPageDict = pDestPDFDoc->CreateNewPage(curpage);
        CPDF_Dictionary* pSrcPageDict = pSrcPDFDoc->GetPage(nPageNum->GetAt(i)-1);
        if(!pSrcPageDict || !pCurPageDict)
        {
            delete pMapPtrToPtr;
            return FALSE;
        }

        // Clone the page dictionary///////////
        FX_POSITION SrcPos = pSrcPageDict->GetStartPos();
        while (SrcPos)
        {
            CFX_ByteString cbSrcKeyStr;
            CPDF_Object* pObj = pSrcPageDict->GetNextElement(SrcPos, cbSrcKeyStr);
            if(cbSrcKeyStr.Compare(("Type")) && cbSrcKeyStr.Compare(("Parent")))
            {
                if(pCurPageDict->KeyExist(cbSrcKeyStr))
                    pCurPageDict->RemoveAt(cbSrcKeyStr);
                pCurPageDict->SetAt(cbSrcKeyStr, pObj->Clone());
            }
        }

        //inheritable item///////////////////////
        CPDF_Object* pInheritable = NULL;
        //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)
            {
                delete pMapPtrToPtr;
                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();

        pMapPtrToPtr->SetAt((void*)(uintptr_t)dwOldPageObj, (void*)(uintptr_t)dwNewPageObj);

        UpdateReference(pCurPageDict, pDestPDFDoc, pMapPtrToPtr);
        curpage++;
    }

    delete pMapPtrToPtr;
    return TRUE;
}

CPDF_Object* CPDF_PageOrganizer::PageDictGetInheritableTag(CPDF_Dictionary *pDict, CFX_ByteString nSrctag)
{
    if(!pDict || !pDict->KeyExist("Type") || nSrctag.IsEmpty())
        return NULL;

    CPDF_Object* pType = pDict->GetElement("Type")->GetDirect();
    if(!pType || pType->GetType() != PDFOBJ_NAME)   return NULL;

    if(pType->GetString().Compare("Page"))  return NULL;

    if(!pDict->KeyExist("Parent"))  return NULL;
    CPDF_Object* pParent = pDict->GetElement("Parent")->GetDirect();
    if(!pParent || pParent->GetType() != PDFOBJ_DICTIONARY) return NULL;

    CPDF_Dictionary* pp = (CPDF_Dictionary*)pParent;

    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"))
        {
            pp = (CPDF_Dictionary*)pp->GetElement("Parent")->GetDirect();
            if (pp->GetType() == PDFOBJ_NULL)
                break;
        }
        else
            break;
    }

    return NULL;
}

FX_BOOL CPDF_PageOrganizer::UpdateReference(CPDF_Object *pObj, CPDF_Document *pDoc,
                                         CFX_MapPtrToPtr* pMapPtrToPtr)
{
    switch (pObj->GetType())
    {
    case PDFOBJ_REFERENCE:
        {
            CPDF_Reference* pReference = (CPDF_Reference*)pObj;
            int newobjnum = GetNewObjId(pDoc, pMapPtrToPtr, pReference);
            if (newobjnum == 0) return FALSE;
            pReference->SetRef(pDoc, newobjnum);//, 0);
            break;
        }
    case PDFOBJ_DICTIONARY:
        {
            CPDF_Dictionary* pDict = (CPDF_Dictionary*)pObj;

            FX_POSITION pos = pDict->GetStartPos();
            while(pos)
            {
                CFX_ByteString key("");
                CPDF_Object* pNextObj = pDict->GetNextElement(pos, key);
                if (!FXSYS_strcmp(key, "Parent") || !FXSYS_strcmp(key, "Prev") || !FXSYS_strcmp(key, "First"))
                    continue;
                if(pNextObj)
                {
                    if(!UpdateReference(pNextObj, pDoc, pMapPtrToPtr))
                        pDict->RemoveAt(key);
                }
                else
                    return FALSE;
            }
            break;
        }
    case    PDFOBJ_ARRAY:
        {
            CPDF_Array* pArray = (CPDF_Array*)pObj;
            FX_DWORD count = pArray->GetCount();
            for(FX_DWORD i = 0; i < count; i ++)
            {
                CPDF_Object* pNextObj = pArray->GetElement(i);
                if(pNextObj)
                {
                    if(!UpdateReference(pNextObj, pDoc, pMapPtrToPtr))
                        return FALSE;
                }
                else
                    return FALSE;
            }
            break;
        }
    case    PDFOBJ_STREAM:
        {
            CPDF_Stream* pStream = (CPDF_Stream*)pObj;
            CPDF_Dictionary* pDict = pStream->GetDict();
            if(pDict)
            {
                if(!UpdateReference(pDict, pDoc, pMapPtrToPtr))
                    return FALSE;
            }
            else
                return FALSE;
            break;
        }
    default:    break;
    }

    return TRUE;
}

int CPDF_PageOrganizer::GetNewObjId(CPDF_Document *pDoc, CFX_MapPtrToPtr* pMapPtrToPtr,
                                    CPDF_Reference *pRef)
{
    if(!pRef)
        return 0;

    size_t dwObjnum = pRef->GetRefObjNum();
    size_t dwNewObjNum = 0;

    pMapPtrToPtr->Lookup((void*)dwObjnum, (void*&)dwNewObjNum);
    if(dwNewObjNum)
    {
        return (int)dwNewObjNum;
    }

    CPDF_Object* pDirect = pRef->GetDirect();
    if(!pDirect)
    {
        return 0;
    }

    CPDF_Object* pClone = pDirect->Clone();
    if(!pClone)
    {
        return 0;
    }

    if(pClone->GetType() == PDFOBJ_DICTIONARY)
    {
        CPDF_Dictionary* pDictClone = (CPDF_Dictionary*)pClone;
        if(pDictClone->KeyExist("Type"))
        {
            CFX_ByteString strType = pDictClone->GetString("Type");
            if(!FXSYS_stricmp(strType, "Pages"))
            {
                pDictClone->Release();
                return 4;
            }
            else if(!FXSYS_stricmp(strType, "Page"))
            {
                pDictClone->Release();
                return  0;
            }
        }
    }

    dwNewObjNum = pDoc->AddIndirectObject(pClone);
    pMapPtrToPtr->SetAt((void*)dwObjnum, (void*)dwNewObjNum);
    if(!UpdateReference(pClone, pDoc, pMapPtrToPtr))
    {
        pClone->Release();
        return 0;
    }

    return (int)dwNewObjNum;
}

FPDF_BOOL ParserPageRangeString(CFX_ByteString rangstring, CFX_WordArray* 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->Add((FX_WORD)lPageNum);
            }
            else
            {
                int nStartPageNum = atol(cbMidRange.Mid(0,nMid));
                if (nStartPageNum ==0)
                    return FALSE;

                nMid = nMid+1;
                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 nIndex = nStartPageNum; nIndex <= nEndPageNum; ++nIndex)
                    pageArray->Add(nIndex);
            }
            nStringFrom = nStringTo + 1;
        }
    }
    return TRUE;
}

DLLEXPORT FPDF_BOOL STDCALL FPDF_ImportPages(FPDF_DOCUMENT dest_doc,FPDF_DOCUMENT src_doc,
                                             FPDF_BYTESTRING pagerange, int index)
{
    if(dest_doc == NULL || src_doc == NULL )
        return FALSE;
    CFX_WordArray pageArray;
    CPDFXFA_Document* pSrcDoc = (CPDFXFA_Document*)src_doc;
    CPDF_Document* pSrcPDFDoc = pSrcDoc->GetPDFDoc();
    int nCount = pSrcPDFDoc->GetPageCount();
    if(pagerange)
    {
        if(ParserPageRangeString(pagerange,&pageArray,nCount) == FALSE)
            return FALSE;
    }
    else
    {
        for(int i=1; i<=nCount; i++)
        {
            pageArray.Add(i);
        }
    }

    CPDFXFA_Document* pDestDoc = (CPDFXFA_Document*)dest_doc;
    CPDF_Document* pDestPDFDoc = pDestDoc->GetPDFDoc();
    CPDF_PageOrganizer pageOrg;

    pageOrg.PDFDocInit(pDestPDFDoc,pSrcPDFDoc);

    if(pageOrg.ExportPage(pSrcPDFDoc,&pageArray,pDestPDFDoc,index))
        return TRUE;
    return FALSE;
}

DLLEXPORT FPDF_BOOL STDCALL FPDF_CopyViewerPreferences(FPDF_DOCUMENT dest_doc, FPDF_DOCUMENT src_doc)
{
    if(src_doc == NULL || dest_doc == NULL)
        return false;
    CPDFXFA_Document* pSrcDoc = (CPDFXFA_Document*)src_doc;
    CPDF_Document* pSrcPDFDoc = pSrcDoc->GetPDFDoc();
    CPDF_Dictionary* pSrcDict = pSrcPDFDoc->GetRoot();
    pSrcDict = pSrcDict->GetDict(FX_BSTRC("ViewerPreferences"));
    if(!pSrcDict)
        return FALSE;
    CPDFXFA_Document* pDstDoc = (CPDFXFA_Document*)dest_doc;
    CPDF_Document* pDstPDFDoc = pDstDoc->GetPDFDoc();
    CPDF_Dictionary* pDstDict = pDstPDFDoc->GetRoot();
    if(!pDstDict)
        return FALSE;
    pDstDict->SetAt(FX_BSTRC("ViewerPreferences"), pSrcDict->Clone(TRUE));
    return TRUE;
}