FX_BOOL CPDF_CalRGB::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
{
CPDF_Dictionary* pDict = pArray->GetDict(1);
CPDF_Array* pParam = pDict->GetArray(FX_BSTRC("WhitePoint"));
int i;
for (i = 0; i < 3; i ++) {
m_WhitePoint[i] = pParam ? pParam->GetNumber(i) : 0;
}
pParam = pDict->GetArray(FX_BSTRC("BlackPoint"));
for (i = 0; i < 3; i ++) {
m_BlackPoint[i] = pParam ? pParam->GetNumber(i) : 0;
}
pParam = pDict->GetArray(FX_BSTRC("Gamma"));
if (pParam) {
m_bGamma = TRUE;
for (i = 0; i < 3; i ++) {
m_Gamma[i] = pParam->GetNumber(i);
}
} else {
m_bGamma = FALSE;
}
pParam = pDict->GetArray(FX_BSTRC("Matrix"));
if (pParam) {
m_bMatrix = TRUE;
for (i = 0; i < 9; i ++) {
m_Matrix[i] = pParam->GetNumber(i);
}
} else {
m_bMatrix = FALSE;
}
return TRUE;
}
static CPDF_Dictionary* FPDFDOC_OCG_GetConfig(CPDF_Document *pDoc, const CPDF_Dictionary *pOCGDict, FX_BSTR bsState)
{
FXSYS_assert(pDoc && pOCGDict);
CPDF_Dictionary *pOCProperties = pDoc->GetRoot()->GetDict(FX_BSTRC("OCProperties"));
if (!pOCProperties) {
return NULL;
}
CPDF_Array *pOCGs = pOCProperties->GetArray(FX_BSTRC("OCGs"));
if (!pOCGs) {
return NULL;
}
if (FPDFDOC_OCG_FindGroup(pOCGs, pOCGDict) < 0) {
return NULL;
}
CPDF_Dictionary *pConfig = pOCProperties->GetDict(FX_BSTRC("D"));
CPDF_Array *pConfigs = pOCProperties->GetArray(FX_BSTRC("Configs"));
if (pConfigs) {
CPDF_Dictionary *pFind;
FX_INT32 iCount = pConfigs->GetCount();
for (FX_INT32 i = 0; i < iCount; i ++) {
pFind = pConfigs->GetDict(i);
if (!pFind) {
continue;
}
if (!FPDFDOC_OCG_HasIntent(pFind, FX_BSTRC("View"), FX_BSTRC("View"))) {
continue;
}
pConfig = pFind;
break;
}
}
return pConfig;
}
FX_BOOL CPDF_ExpIntFunc::v_Init(CPDF_Object* pObj) {
CPDF_Dictionary* pDict = pObj->GetDict();
if (pDict == NULL) {
return FALSE;
}
CPDF_Array* pArray0 = pDict->GetArray(FX_BSTRC("C0"));
if (m_nOutputs == 0) {
m_nOutputs = 1;
if (pArray0) {
m_nOutputs = pArray0->GetCount();
}
}
CPDF_Array* pArray1 = pDict->GetArray(FX_BSTRC("C1"));
m_pBeginValues = FX_Alloc2D(FX_FLOAT, m_nOutputs, 2);
m_pEndValues = FX_Alloc2D(FX_FLOAT, m_nOutputs, 2);
for (int i = 0; i < m_nOutputs; i++) {
m_pBeginValues[i] = pArray0 ? pArray0->GetFloat(i) : 0.0f;
m_pEndValues[i] = pArray1 ? pArray1->GetFloat(i) : 1.0f;
}
m_Exponent = pDict->GetFloat(FX_BSTRC("N"));
m_nOrigOutputs = m_nOutputs;
if (m_nOutputs && m_nInputs > INT_MAX / m_nOutputs) {
return FALSE;
}
m_nOutputs *= m_nInputs;
return TRUE;
}
FX_BOOL CPDF_SampledFunc::v_Init(CPDF_Object* pObj) {
if (pObj->GetType() != PDFOBJ_STREAM) {
return FALSE;
}
CPDF_Stream* pStream = (CPDF_Stream*)pObj;
CPDF_Dictionary* pDict = pStream->GetDict();
CPDF_Array* pSize = pDict->GetArray(FX_BSTRC("Size"));
CPDF_Array* pEncode = pDict->GetArray(FX_BSTRC("Encode"));
CPDF_Array* pDecode = pDict->GetArray(FX_BSTRC("Decode"));
m_nBitsPerSample = pDict->GetInteger(FX_BSTRC("BitsPerSample"));
if (m_nBitsPerSample > 32) {
return FALSE;
}
m_SampleMax = 0xffffffff >> (32 - m_nBitsPerSample);
m_pSampleStream = new CPDF_StreamAcc;
m_pSampleStream->LoadAllData(pStream, FALSE);
m_pEncodeInfo = FX_Alloc(SampleEncodeInfo, m_nInputs);
FX_SAFE_DWORD nTotalSampleBits = 1;
for (int i = 0; i < m_nInputs; i++) {
m_pEncodeInfo[i].sizes = pSize ? pSize->GetInteger(i) : 0;
if (!pSize && i == 0) {
m_pEncodeInfo[i].sizes = pDict->GetInteger(FX_BSTRC("Size"));
}
nTotalSampleBits *= m_pEncodeInfo[i].sizes;
if (pEncode) {
m_pEncodeInfo[i].encode_min = pEncode->GetFloat(i * 2);
m_pEncodeInfo[i].encode_max = pEncode->GetFloat(i * 2 + 1);
} else {
m_pEncodeInfo[i].encode_min = 0;
if (m_pEncodeInfo[i].sizes == 1) {
m_pEncodeInfo[i].encode_max = 1;
} else {
m_pEncodeInfo[i].encode_max = (FX_FLOAT)m_pEncodeInfo[i].sizes - 1;
}
}
}
nTotalSampleBits *= m_nBitsPerSample;
nTotalSampleBits *= m_nOutputs;
FX_SAFE_DWORD nTotalSampleBytes = nTotalSampleBits;
nTotalSampleBytes += 7;
nTotalSampleBytes /= 8;
if (!nTotalSampleBytes.IsValid() || nTotalSampleBytes.ValueOrDie() == 0 ||
nTotalSampleBytes.ValueOrDie() > m_pSampleStream->GetSize()) {
return FALSE;
}
m_pDecodeInfo = FX_Alloc(SampleDecodeInfo, m_nOutputs);
for (int i = 0; i < m_nOutputs; i++) {
if (pDecode) {
m_pDecodeInfo[i].decode_min = pDecode->GetFloat(2 * i);
m_pDecodeInfo[i].decode_max = pDecode->GetFloat(2 * i + 1);
} else {
m_pDecodeInfo[i].decode_min = m_pRanges[i * 2];
m_pDecodeInfo[i].decode_max = m_pRanges[i * 2 + 1];
}
}
return TRUE;
}
FX_BOOL CPDF_OCContext::LoadOCGStateFromConfig(const CFX_ByteStringC& csConfig,
const CPDF_Dictionary* pOCGDict,
FX_BOOL& bValidConfig) const {
CPDF_Dictionary* pConfig =
FPDFDOC_OCG_GetConfig(m_pDocument, pOCGDict, csConfig);
if (!pConfig) {
return TRUE;
}
bValidConfig = TRUE;
FX_BOOL bState = pConfig->GetString(FX_BSTRC("BaseState"), FX_BSTRC("ON")) !=
FX_BSTRC("OFF");
CPDF_Array* pArray = pConfig->GetArray(FX_BSTRC("ON"));
if (pArray) {
if (FPDFDOC_OCG_FindGroup(pArray, pOCGDict) >= 0) {
bState = TRUE;
}
}
pArray = pConfig->GetArray(FX_BSTRC("OFF"));
if (pArray) {
if (FPDFDOC_OCG_FindGroup(pArray, pOCGDict) >= 0) {
bState = FALSE;
}
}
pArray = pConfig->GetArray(FX_BSTRC("AS"));
if (pArray) {
CFX_ByteString csFind = csConfig + FX_BSTRC("State");
int32_t iCount = pArray->GetCount();
for (int32_t i = 0; i < iCount; i++) {
CPDF_Dictionary* pUsage = pArray->GetDict(i);
if (!pUsage) {
continue;
}
if (pUsage->GetString(FX_BSTRC("Event"), FX_BSTRC("View")) != csConfig) {
continue;
}
CPDF_Array* pOCGs = pUsage->GetArray(FX_BSTRC("OCGs"));
if (!pOCGs) {
continue;
}
if (FPDFDOC_OCG_FindGroup(pOCGs, pOCGDict) < 0) {
continue;
}
CPDF_Dictionary* pState = pUsage->GetDict(csConfig);
if (!pState) {
continue;
}
bState = pState->GetString(csFind) != FX_BSTRC("OFF");
}
}
return bState;
}
FX_BOOL CPDF_StitchFunc::v_Init(CPDF_Object* pObj)
{
CPDF_Dictionary* pDict = pObj->GetDict();
if (pDict == NULL) {
return FALSE;
}
CPDF_Array* pArray = pDict->GetArray(FX_BSTRC("Functions"));
if (pArray == NULL) {
return FALSE;
}
m_nSubs = pArray->GetCount();
if (m_nSubs == 0) {
return FALSE;
}
m_pSubFunctions = FX_Alloc(CPDF_Function*, m_nSubs);
m_nOutputs = 0;
int i;
for (i = 0; i < m_nSubs; i ++) {
CPDF_Object* pSub = pArray->GetElementValue(i);
if (pSub == pObj) {
return FALSE;
}
m_pSubFunctions[i] = CPDF_Function::Load(pSub);
if (m_pSubFunctions[i] == NULL) {
return FALSE;
}
if (m_pSubFunctions[i]->CountOutputs() > m_nOutputs) {
m_nOutputs = m_pSubFunctions[i]->CountOutputs();
}
}
m_pBounds = FX_Alloc(FX_FLOAT, m_nSubs + 1);
m_pBounds[0] = m_pDomains[0];
pArray = pDict->GetArray(FX_BSTRC("Bounds"));
if (pArray == NULL) {
return FALSE;
}
for (i = 0; i < m_nSubs - 1; i ++) {
m_pBounds[i + 1] = pArray->GetFloat(i);
}
m_pBounds[m_nSubs] = m_pDomains[1];
m_pEncode = FX_Alloc(FX_FLOAT, m_nSubs * 2);
pArray = pDict->GetArray(FX_BSTRC("Encode"));
if (pArray == NULL) {
return FALSE;
}
for (i = 0; i < m_nSubs * 2; i ++) {
m_pEncode[i] = pArray->GetFloat(i);
}
return TRUE;
}
void CPDFSDK_Annot::GetBorderDash(CFX_IntArray& array) const
{
ASSERT(m_pAnnot != NULL);
ASSERT(m_pAnnot->m_pAnnotDict != NULL);
CPDF_Array* pDash = NULL;
CPDF_Array* pBorder = m_pAnnot->m_pAnnotDict->GetArray("Border");
if (pBorder)
{
pDash = pBorder->GetArray(3);
}
else
{
CPDF_Dictionary* pBSDict = m_pAnnot->m_pAnnotDict->GetDict("BS");
if (pBSDict)
{
pDash = pBSDict->GetArray("D");
}
}
if (pDash)
{
for (int i=0,sz=pDash->GetCount(); i<sz; i++)
{
array.Add(pDash->GetInteger(i));
}
}
}
FX_BOOL CPDF_InterForm::ImportFromFDF(const CFDF_Document* pFDF,
FX_BOOL bNotify) {
if (pFDF == NULL) {
return FALSE;
}
CPDF_Dictionary* pMainDict = pFDF->GetRoot()->GetDict("FDF");
if (pMainDict == NULL) {
return FALSE;
}
CPDF_Array* pFields = pMainDict->GetArray("Fields");
if (pFields == NULL) {
return FALSE;
}
m_bsEncoding = pMainDict->GetString(FX_BSTRC("Encoding"));
if (bNotify && m_pFormNotify != NULL) {
int iRet = m_pFormNotify->BeforeFormImportData(this);
if (iRet < 0) {
return FALSE;
}
}
for (FX_DWORD i = 0; i < pFields->GetCount(); i++) {
CPDF_Dictionary* pField = pFields->GetDict(i);
if (pField == NULL) {
continue;
}
FDF_ImportField(pField, L"", bNotify);
}
if (bNotify && m_pFormNotify != NULL) {
m_pFormNotify->AfterFormImportData(this);
}
return TRUE;
}
FX_BOOL CPDFSDK_Document::ProcOpenAction() {
if (!m_pDoc)
return FALSE;
CPDF_Dictionary* pRoot = m_pDoc->GetRoot();
if (!pRoot)
return FALSE;
CPDF_Object* pOpenAction = pRoot->GetDict("OpenAction");
if (!pOpenAction)
pOpenAction = pRoot->GetArray("OpenAction");
if (!pOpenAction)
return FALSE;
if (pOpenAction->IsArray())
return TRUE;
if (CPDF_Dictionary* pDict = pOpenAction->AsDictionary()) {
CPDF_Action action(pDict);
if (m_pEnv->GetActionHander())
m_pEnv->GetActionHander()->DoAction_DocOpen(action, this);
return TRUE;
}
return FALSE;
}
FX_DWORD CPDF_ActionFields::GetFieldsCount() const {
if (!m_pAction) {
return 0;
}
CPDF_Dictionary* pDict = m_pAction->GetDict();
if (!pDict) {
return 0;
}
CFX_ByteString csType = pDict->GetString("S");
CPDF_Object* pFields = NULL;
if (csType == "Hide") {
pFields = pDict->GetElementValue("T");
} else {
pFields = pDict->GetArray("Fields");
}
if (!pFields)
return 0;
if (pFields->IsDictionary())
return 1;
if (pFields->IsString())
return 1;
if (CPDF_Array* pArray = pFields->AsArray())
return pArray->GetCount();
return 0;
}
CPDF_Object* CPDF_ActionFields::GetField(FX_DWORD iIndex) const {
if (!m_pAction) {
return NULL;
}
CPDF_Dictionary* pDict = m_pAction->GetDict();
if (!pDict) {
return NULL;
}
CFX_ByteString csType = pDict->GetString("S");
CPDF_Object* pFields = NULL;
if (csType == "Hide") {
pFields = pDict->GetElementValue("T");
} else {
pFields = pDict->GetArray("Fields");
}
if (!pFields) {
return NULL;
}
CPDF_Object* pFindObj = NULL;
if (pFields->IsDictionary() || pFields->IsString()) {
if (iIndex == 0)
pFindObj = pFields;
} else if (CPDF_Array* pArray = pFields->AsArray()) {
pFindObj = pArray->GetElementValue(iIndex);
}
return pFindObj;
}
std::vector<CPDF_Object*> CPDF_ActionFields::GetAllFields() const {
std::vector<CPDF_Object*> fields;
if (!m_pAction)
return fields;
CPDF_Dictionary* pDict = m_pAction->GetDict();
if (!pDict)
return fields;
CFX_ByteString csType = pDict->GetString("S");
CPDF_Object* pFields;
if (csType == "Hide")
pFields = pDict->GetElementValue("T");
else
pFields = pDict->GetArray("Fields");
if (!pFields)
return fields;
if (pFields->IsDictionary() || pFields->IsString()) {
fields.push_back(pFields);
} else if (CPDF_Array* pArray = pFields->AsArray()) {
FX_DWORD iCount = pArray->GetCount();
for (FX_DWORD i = 0; i < iCount; ++i) {
CPDF_Object* pObj = pArray->GetElementValue(i);
if (pObj) {
fields.push_back(pObj);
}
}
}
return fields;
}
FX_BOOL CPDFSDK_Document::ProcOpenAction()
{
if(!m_pDoc)
return FALSE;
CPDF_Dictionary* pRoot = m_pDoc->GetRoot();
if (!pRoot)
return FALSE;
CPDF_Object* pOpenAction = pRoot->GetDict("OpenAction");
if(!pOpenAction)
pOpenAction = pRoot->GetArray("OpenAction");
if(!pOpenAction)
return FALSE;
if(pOpenAction->GetType()==PDFOBJ_ARRAY)
return TRUE;
if(pOpenAction->GetType()==PDFOBJ_DICTIONARY)
{
CPDF_Dictionary * pDict=(CPDF_Dictionary*)pOpenAction;
CPDF_Action action(pDict);
if(m_pEnv->GetActionHander())
m_pEnv->GetActionHander()->DoAction_DocOpen(action, this);
return TRUE;
}
return FALSE;
}
static int InsertNewPage(CPDF_Document* pDoc, int iPage, CPDF_Dictionary* pPageDict, CFX_DWordArray &pageList)
{
CPDF_Dictionary* pRoot = pDoc->GetRoot();
if (!pRoot) {
return -1;
}
CPDF_Dictionary* pPages = pRoot->GetDict(FX_BSTRC("Pages"));
if (!pPages) {
return -1;
}
int nPages = pDoc->GetPageCount();
if (iPage < 0 || iPage > nPages) {
return -1;
}
if (iPage == nPages) {
CPDF_Array* pPagesList = pPages->GetArray(FX_BSTRC("Kids"));
if (!pPagesList) {
pPagesList = FX_NEW CPDF_Array;
pPages->SetAt(FX_BSTRC("Kids"), pPagesList);
}
pPagesList->Add(pPageDict, pDoc);
pPages->SetAtInteger(FX_BSTRC("Count"), nPages + 1);
pPageDict->SetAtReference(FX_BSTRC("Parent"), pDoc, pPages->GetObjNum());
} else {
CFX_PtrArray stack;
stack.Add(pPages);
if (InsertDeletePDFPage(pDoc, pPages, iPage, pPageDict, TRUE, stack) < 0) {
return -1;
}
}
pageList.InsertAt(iPage, pPageDict->GetObjNum());
return iPage;
}
FX_BOOL CPDF_CalGray::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) {
CPDF_Dictionary* pDict = pArray->GetDict(1);
CPDF_Array* pParam = pDict->GetArray(FX_BSTRC("WhitePoint"));
int i;
for (i = 0; i < 3; i++) {
m_WhitePoint[i] = pParam ? pParam->GetNumber(i) : 0;
}
pParam = pDict->GetArray(FX_BSTRC("BlackPoint"));
for (i = 0; i < 3; i++) {
m_BlackPoint[i] = pParam ? pParam->GetNumber(i) : 0;
}
m_Gamma = pDict->GetNumber(FX_BSTRC("Gamma"));
if (m_Gamma == 0) {
m_Gamma = 1.0f;
}
return TRUE;
}
DLLEXPORT int STDCALL FPDFLink_CountQuadPoints(FPDF_LINK linkAnnot) {
if (!linkAnnot)
return 0;
CPDF_Dictionary* pAnnotDict = (CPDF_Dictionary*)linkAnnot;
CPDF_Array* pArray = pAnnotDict->GetArray(FX_BSTRC("QuadPoints"));
if (!pArray)
return 0;
return pArray->GetCount() / 8;
}
DLLEXPORT int STDCALL FPDFLink_CountQuadPoints(FPDF_LINK linkAnnot) {
if (!linkAnnot)
return 0;
CPDF_Dictionary* pAnnotDict =
ToDictionary(static_cast<CPDF_Object*>(linkAnnot));
CPDF_Array* pArray = pAnnotDict->GetArray(FX_BSTRC("QuadPoints"));
if (!pArray)
return 0;
return pArray->GetCount() / 8;
}
CPDF_Array* CPDF_ViewerPreferences::PrintPageRange() const {
CPDF_Dictionary* pDict = m_pDoc->GetRoot();
CPDF_Array* pRange = NULL;
pDict = pDict->GetDict(FX_BSTRC("ViewerPreferences"));
if (!pDict) {
return pRange;
}
pRange = pDict->GetArray(FX_BSTRC("PrintPageRange"));
return pRange;
}
FX_BOOL CPDF_LabCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
{
CPDF_Dictionary* pDict = pArray->GetDict(1);
CPDF_Array* pParam = pDict->GetArray(FX_BSTRC("WhitePoint"));
int i;
for (i = 0; i < 3; i ++) {
m_WhitePoint[i] = pParam ? pParam->GetNumber(i) : 0;
}
pParam = pDict->GetArray(FX_BSTRC("BlackPoint"));
for (i = 0; i < 3; i ++) {
m_BlackPoint[i] = pParam ? pParam->GetNumber(i) : 0;
}
pParam = pDict->GetArray(FX_BSTRC("Range"));
const FX_FLOAT def_ranges[4] = { -100 * 1.0f, 100 * 1.0f, -100 * 1.0f, 100 * 1.0f};
for (i = 0; i < 4; i ++) {
m_Ranges[i] = pParam ? pParam->GetNumber(i) : def_ranges[i];
}
return TRUE;
}
FX_BOOL CPDF_Function::Init(CPDF_Object* pObj) {
CPDF_Dictionary* pDict;
if (pObj->GetType() == PDFOBJ_STREAM) {
pDict = ((CPDF_Stream*)pObj)->GetDict();
} else {
pDict = (CPDF_Dictionary*)pObj;
}
CPDF_Array* pDomains = pDict->GetArray(FX_BSTRC("Domain"));
if (pDomains == NULL) {
return FALSE;
}
m_nInputs = pDomains->GetCount() / 2;
if (m_nInputs == 0) {
return FALSE;
}
m_pDomains = FX_Alloc2D(FX_FLOAT, m_nInputs, 2);
for (int i = 0; i < m_nInputs * 2; i++) {
m_pDomains[i] = pDomains->GetFloat(i);
}
CPDF_Array* pRanges = pDict->GetArray(FX_BSTRC("Range"));
m_nOutputs = 0;
if (pRanges) {
m_nOutputs = pRanges->GetCount() / 2;
m_pRanges = FX_Alloc2D(FX_FLOAT, m_nOutputs, 2);
for (int i = 0; i < m_nOutputs * 2; i++) {
m_pRanges[i] = pRanges->GetFloat(i);
}
}
FX_DWORD old_outputs = m_nOutputs;
if (!v_Init(pObj)) {
return FALSE;
}
if (m_pRanges && m_nOutputs > (int)old_outputs) {
m_pRanges = FX_Realloc(FX_FLOAT, m_pRanges, m_nOutputs * 2);
if (m_pRanges) {
FXSYS_memset(m_pRanges + (old_outputs * 2), 0,
sizeof(FX_FLOAT) * (m_nOutputs - old_outputs) * 2);
}
}
return TRUE;
}
void CheckUnSupportError(CPDF_Document* pDoc, FX_DWORD err_code) {
// Security
if (err_code == FPDF_ERR_SECURITY) {
FPDF_UnSupportError(FPDF_UNSP_DOC_SECURITY);
return;
}
if (!pDoc)
return;
// Portfolios and Packages
CPDF_Dictionary* pRootDict = pDoc->GetRoot();
if (pRootDict) {
CFX_ByteString cbString;
if (pRootDict->KeyExist("Collection")) {
FPDF_UnSupportError(FPDF_UNSP_DOC_PORTABLECOLLECTION);
return;
}
if (pRootDict->KeyExist("Names")) {
CPDF_Dictionary* pNameDict = pRootDict->GetDict("Names");
if (pNameDict && pNameDict->KeyExist("EmbeddedFiles")) {
FPDF_UnSupportError(FPDF_UNSP_DOC_ATTACHMENT);
return;
}
if (pNameDict && pNameDict->KeyExist("JavaScript")) {
CPDF_Dictionary* pJSDict = pNameDict->GetDict("JavaScript");
CPDF_Array* pArray = pJSDict ? pJSDict->GetArray("Names") : NULL;
if (pArray) {
int nCount = pArray->GetCount();
for (int i = 0; i < nCount; i++) {
CFX_ByteString cbStr = pArray->GetString(i);
if (cbStr.Compare("com.adobe.acrobat.SharedReview.Register") == 0) {
FPDF_UnSupportError(FPDF_UNSP_DOC_SHAREDREVIEW);
return;
}
}
}
}
}
}
// SharedForm
CPDF_Metadata metaData(pDoc);
const CXML_Element* pElement = metaData.GetRoot();
if (pElement)
CheckSharedForm(pElement, "workflowType");
// XFA Forms
CPDF_InterForm* pInterForm = new CPDF_InterForm(pDoc, FALSE);
if (pInterForm->HasXFAForm()) {
FPDF_UnSupportError(FPDF_UNSP_DOC_XFAFORM);
}
delete pInterForm;
}
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;
}
DLLEXPORT FPDF_BOOL STDCALL FPDFPage_GetCropBox(FPDF_PAGE page, float* left, float* bottom, float* right, float* top)
{
if(!page)
return FALSE;
CPDF_Page* pPage = (CPDF_Page*)page;
CPDF_Dictionary* pPageDict = pPage->m_pFormDict;
CPDF_Array* pArray = pPageDict->GetArray("CropBox");
if(pArray)
{
*left = pArray->GetFloat(0);
*bottom = pArray->GetFloat(1);
*right = pArray->GetFloat(2);
*top = pArray->GetFloat(3);
return TRUE;
}
return FALSE;
}
void CPDF_InterForm::FixPageFields(const CPDF_Page* pPage) {
ASSERT(pPage != NULL);
CPDF_Dictionary* pPageDict = pPage->m_pFormDict;
if (pPageDict == NULL) {
return;
}
CPDF_Array* pAnnots = pPageDict->GetArray(FX_BSTRC("Annots"));
if (pAnnots == NULL) {
return;
}
int iAnnotCount = pAnnots->GetCount();
for (int i = 0; i < iAnnotCount; i++) {
CPDF_Dictionary* pAnnot = pAnnots->GetDict(i);
if (pAnnot != NULL && pAnnot->GetString(FX_BSTRC("Subtype")) == "Widget") {
LoadField(pAnnot);
}
}
}
DLLEXPORT FPDF_BOOL STDCALL FPDFLink_GetQuadPoints(FPDF_LINK linkAnnot, int quadIndex, FS_QUADPOINTSF* quadPoints)
{
if(!linkAnnot || !quadPoints)
return FALSE;
CPDF_Dictionary* pAnnotDict = (CPDF_Dictionary*)linkAnnot;
CPDF_Array* pArray = pAnnotDict->GetArray(FX_BSTRC("QuadPoints"));
if (pArray) {
if (0 > quadIndex || quadIndex >= (int)pArray->GetCount()/8 ||
((quadIndex*8+7) >= (int)pArray->GetCount())) return FALSE;
quadPoints->x1 = pArray->GetNumber(quadIndex*8);
quadPoints->y1 = pArray->GetNumber(quadIndex*8+1);
quadPoints->x2 = pArray->GetNumber(quadIndex*8+2);
quadPoints->y2 = pArray->GetNumber(quadIndex*8+3);
quadPoints->x3 = pArray->GetNumber(quadIndex*8+4);
quadPoints->y3 = pArray->GetNumber(quadIndex*8+5);
quadPoints->x4 = pArray->GetNumber(quadIndex*8+6);
quadPoints->y4 = pArray->GetNumber(quadIndex*8+7);
return TRUE;
}
return FALSE;
}
FX_BOOL CPDF_MeshStream::Load(CPDF_Stream* pShadingStream, CPDF_Function** pFuncs, int nFuncs, CPDF_ColorSpace* pCS)
{
m_Stream.LoadAllData(pShadingStream);
m_BitStream.Init(m_Stream.GetData(), m_Stream.GetSize());
m_pFuncs = pFuncs;
m_nFuncs = nFuncs;
m_pCS = pCS;
CPDF_Dictionary* pDict = pShadingStream->GetDict();
m_nCoordBits = pDict->GetInteger(FX_BSTRC("BitsPerCoordinate"));
m_nCompBits = pDict->GetInteger(FX_BSTRC("BitsPerComponent"));
m_nFlagBits = pDict->GetInteger(FX_BSTRC("BitsPerFlag"));
if (!m_nCoordBits || !m_nCompBits) {
return FALSE;
}
int nComps = pCS->CountComponents();
if (nComps > 8) {
return FALSE;
}
m_nComps = nFuncs ? 1 : nComps;
if (((int)m_nComps < 0) || m_nComps > 8) {
return FALSE;
}
m_CoordMax = m_nCoordBits == 32 ? -1 : (1 << m_nCoordBits) - 1;
m_CompMax = (1 << m_nCompBits) - 1;
CPDF_Array* pDecode = pDict->GetArray(FX_BSTRC("Decode"));
if (pDecode == NULL || pDecode->GetCount() != 4 + m_nComps * 2) {
return FALSE;
}
m_xmin = pDecode->GetNumber(0);
m_xmax = pDecode->GetNumber(1);
m_ymin = pDecode->GetNumber(2);
m_ymax = pDecode->GetNumber(3);
for (FX_DWORD i = 0; i < m_nComps; i ++) {
m_ColorMin[i] = pDecode->GetNumber(i * 2 + 4);
m_ColorMax[i] = pDecode->GetNumber(i * 2 + 5);
}
return TRUE;
}
void CPDF_Annot::DrawBorder(CFX_RenderDevice* pDevice, const CFX_AffineMatrix* pUser2Device, const CPDF_RenderOptions* pOptions)
{
if (GetSubType() == "Popup") {
return;
}
FX_DWORD annot_flags = GetFlags();
if (annot_flags & ANNOTFLAG_HIDDEN) {
return;
}
FX_BOOL bPrinting = pDevice->GetDeviceClass() == FXDC_PRINTER || (pOptions && (pOptions->m_Flags & RENDER_PRINTPREVIEW));
if (bPrinting && (annot_flags & ANNOTFLAG_PRINT) == 0) {
return;
}
if (!bPrinting && (annot_flags & ANNOTFLAG_NOVIEW)) {
return;
}
CPDF_Dictionary* pBS = m_pAnnotDict->GetDict("BS");
char style_char;
FX_FLOAT width;
CPDF_Array* pDashArray = NULL;
if (pBS == NULL) {
CPDF_Array* pBorderArray = m_pAnnotDict->GetArray("Border");
style_char = 'S';
if (pBorderArray) {
width = pBorderArray->GetNumber(2);
if (pBorderArray->GetCount() == 4) {
pDashArray = pBorderArray->GetArray(3);
if (pDashArray == NULL) {
return;
}
int nLen = pDashArray->GetCount();
int i = 0;
for (; i < nLen; ++i) {
CPDF_Object*pObj = pDashArray->GetElementValue(i);
if (pObj && pObj->GetInteger()) {
break;
}
}
if (i == nLen) {
return;
}
style_char = 'D';
}
} else {
width = 1;
}
} else {
CFX_ByteString style = pBS->GetString("S");
pDashArray = pBS->GetArray("D");
style_char = style[1];
width = pBS->GetNumber("W");
}
if (width <= 0) {
return;
}
CPDF_Array* pColor = m_pAnnotDict->GetArray("C");
FX_DWORD argb = 0xff000000;
if (pColor != NULL) {
int R = (FX_INT32)(pColor->GetNumber(0) * 255);
int G = (FX_INT32)(pColor->GetNumber(1) * 255);
int B = (FX_INT32)(pColor->GetNumber(2) * 255);
argb = ArgbEncode(0xff, R, G, B);
}
CPDF_GraphStateData graph_state;
graph_state.m_LineWidth = width;
if (style_char == 'D') {
if (pDashArray) {
FX_DWORD dash_count = pDashArray->GetCount();
if (dash_count % 2) {
dash_count ++;
}
graph_state.m_DashArray = FX_Alloc(FX_FLOAT, dash_count);
if (graph_state.m_DashArray == NULL) {
return ;
}
graph_state.m_DashCount = dash_count;
FX_DWORD i;
for (i = 0; i < pDashArray->GetCount(); i ++) {
graph_state.m_DashArray[i] = pDashArray->GetNumber(i);
}
if (i < dash_count) {
graph_state.m_DashArray[i] = graph_state.m_DashArray[i - 1];
}
} else {
graph_state.m_DashArray = FX_Alloc(FX_FLOAT, 2);
if (graph_state.m_DashArray == NULL) {
return ;
}
graph_state.m_DashCount = 2;
graph_state.m_DashArray[0] = graph_state.m_DashArray[1] = 3 * 1.0f;
}
}
CFX_FloatRect rect;
GetRect(rect);
CPDF_PathData path;
width /= 2;
path.AppendRect(rect.left + width, rect.bottom + width, rect.right - width, rect.top - width);
int fill_type = 0;
if (pOptions && (pOptions->m_Flags & RENDER_NOPATHSMOOTH)) {
fill_type |= FXFILL_NOPATHSMOOTH;
}
pDevice->DrawPath(&path, pUser2Device, &graph_state, argb, argb, fill_type);
}
FX_BOOL CPDF_ICCBasedCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
{
CPDF_Stream* pStream = pArray->GetStream(1);
if (pStream == NULL) {
return FALSE;
}
m_pProfile = pDoc->LoadIccProfile(pStream);
if (!m_pProfile) {
return FALSE;
}
m_nComponents = m_pProfile->GetComponents(); //Try using the nComponents from ICC profile
CPDF_Dictionary* pDict = pStream->GetDict();
if (m_pProfile->m_pTransform == NULL) { // No valid ICC profile or using sRGB
CPDF_Object* pAlterCSObj = pDict ? pDict->GetElementValue(FX_BSTRC("Alternate")) : NULL;
if (pAlterCSObj) {
CPDF_ColorSpace* pAlterCS = CPDF_ColorSpace::Load(pDoc, pAlterCSObj);
if (pAlterCS) {
if (m_nComponents == 0) { // NO valid ICC profile
if (pAlterCS->CountComponents() > 0) { // Use Alternative colorspace
m_nComponents = pAlterCS->CountComponents();
m_pAlterCS = pAlterCS;
m_bOwn = TRUE;
}
else { // No valid alternative colorspace
pAlterCS->ReleaseCS();
int32_t nDictComponents = pDict ? pDict->GetInteger(FX_BSTRC("N")) : 0;
if (nDictComponents != 1 && nDictComponents != 3 && nDictComponents != 4) {
return FALSE;
}
m_nComponents = nDictComponents;
}
}
else { // Using sRGB
if (pAlterCS->CountComponents() != m_nComponents) {
pAlterCS->ReleaseCS();
}
else {
m_pAlterCS = pAlterCS;
m_bOwn = TRUE;
}
}
}
}
if (!m_pAlterCS) {
if (m_nComponents == 1) {
m_pAlterCS = GetStockCS(PDFCS_DEVICEGRAY);
}
else if (m_nComponents == 3) {
m_pAlterCS = GetStockCS(PDFCS_DEVICERGB);
}
else if (m_nComponents == 4) {
m_pAlterCS = GetStockCS(PDFCS_DEVICECMYK);
}
}
}
CPDF_Array* pRanges = pDict->GetArray(FX_BSTRC("Range"));
m_pRanges = FX_Alloc2D(FX_FLOAT, m_nComponents, 2);
for (int i = 0; i < m_nComponents * 2; i ++) {
if (pRanges) {
m_pRanges[i] = pRanges->GetNumber(i);
} else if (i % 2) {
m_pRanges[i] = 1.0f;
} else {
m_pRanges[i] = 0;
}
}
return TRUE;
}
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;
}
DLLEXPORT void STDCALL FPDFPage_InsertClipPath(FPDF_PAGE page,FPDF_CLIPPATH clipPath)
{
if(!page)
return;
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;
CFX_ByteTextBuf strClip;
CPDF_ClipPath* pClipPath = (CPDF_ClipPath*)clipPath;
FX_DWORD i;
for (i = 0; i < pClipPath->GetPathCount(); i ++) {
CPDF_Path path = pClipPath->GetPath(i);
int iClipType = pClipPath->GetClipType(i);
if (path.GetPointCount() == 0) {
// Empty clipping (totally clipped out)
strClip << "0 0 m W n ";
} else {
OutputPath(strClip, path);
if (iClipType == FXFILL_WINDING)
strClip << "W n\n";
else
strClip << "W* n\n";
}
}
CPDF_Dictionary* pDic = FX_NEW CPDF_Dictionary;
CPDF_Stream* pStream = FX_NEW CPDF_Stream(NULL,0, pDic);
pStream->SetData(strClip.GetBuffer(), strClip.GetSize(), FALSE, FALSE);
CPDF_Document* pDoc = pPage->m_pDocument;
if(!pDoc)
return;
pDoc->AddIndirectObject(pStream);
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);
}
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);
}
else if(pDirectObj->GetType() == PDFOBJ_STREAM)
{
pContentArray = FX_NEW CPDF_Array();
pContentArray->AddReference(pDoc,pStream->GetObjNum());
pContentArray->AddReference(pDoc,pDirectObj->GetObjNum());
pPageDic->SetAtReference("Contents", pDoc, pDoc->AddIndirectObject(pContentArray));
}
}
}
}
