| // 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 "../../include/fpdfdoc/fpdf_doc.h" | |
| static FX_INT32 FPDFDOC_OCG_FindGroup(const CPDF_Object *pObject, const CPDF_Dictionary *pGroupDict) | |
| { | |
| if (pObject == NULL || pGroupDict == NULL) { | |
| return -1; | |
| } | |
| FX_INT32 iType = pObject->GetType(); | |
| if (iType == PDFOBJ_ARRAY) { | |
| FX_DWORD dwCount = ((CPDF_Array*)pObject)->GetCount(); | |
| for (FX_DWORD i = 0; i < dwCount; i++) { | |
| if (((CPDF_Array*)pObject)->GetDict(i) == pGroupDict) { | |
| return i; | |
| } | |
| } | |
| return -1; | |
| } | |
| if (pObject->GetDict() == pGroupDict) { | |
| return 0; | |
| } | |
| return -1; | |
| } | |
| static FX_BOOL FPDFDOC_OCG_HasIntent(const CPDF_Dictionary *pDict, FX_BSTR csElement, FX_BSTR csDef = FX_BSTRC("")) | |
| { | |
| FXSYS_assert(pDict != NULL); | |
| CPDF_Object *pIntent = pDict->GetElementValue(FX_BSTRC("Intent")); | |
| if (pIntent == NULL) { | |
| return csElement == csDef; | |
| } | |
| CFX_ByteString bsIntent; | |
| if (pIntent->GetType() == PDFOBJ_ARRAY) { | |
| FX_DWORD dwCount = ((CPDF_Array*)pIntent)->GetCount(); | |
| for (FX_DWORD i = 0; i < dwCount; i++) { | |
| bsIntent = ((CPDF_Array*)pIntent)->GetString(i); | |
| if (bsIntent == FX_BSTRC("All") || bsIntent == csElement) { | |
| return TRUE; | |
| } | |
| } | |
| return FALSE; | |
| } | |
| bsIntent = pIntent->GetString(); | |
| return bsIntent == FX_BSTRC("All") || bsIntent == csElement; | |
| } | |
| 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; | |
| } | |
| static CFX_ByteString FPDFDOC_OCG_GetUsageTypeString(CPDF_OCContext::UsageType eType) | |
| { | |
| CFX_ByteString csState = FX_BSTRC("View"); | |
| if (eType == CPDF_OCContext::Design) { | |
| csState = FX_BSTRC("Design"); | |
| } else if (eType == CPDF_OCContext::Print) { | |
| csState = FX_BSTRC("Print"); | |
| } else if (eType == CPDF_OCContext::Export) { | |
| csState = FX_BSTRC("Export"); | |
| } | |
| return csState; | |
| } | |
| CPDF_OCContext::CPDF_OCContext(CPDF_Document *pDoc, UsageType eUsageType) | |
| { | |
| FXSYS_assert(pDoc != NULL); | |
| m_pDocument = pDoc; | |
| m_eUsageType = eUsageType; | |
| } | |
| CPDF_OCContext::~CPDF_OCContext() | |
| { | |
| m_OCGStates.RemoveAll(); | |
| } | |
| FX_BOOL CPDF_OCContext::LoadOCGStateFromConfig(FX_BSTR 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"); | |
| FX_INT32 iCount = pArray->GetCount(); | |
| for (FX_INT32 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_OCContext::LoadOCGState(const CPDF_Dictionary *pOCGDict) const | |
| { | |
| if (!FPDFDOC_OCG_HasIntent(pOCGDict, FX_BSTRC("View"), FX_BSTRC("View"))) { | |
| return TRUE; | |
| } | |
| CFX_ByteString csState = FPDFDOC_OCG_GetUsageTypeString(m_eUsageType); | |
| CPDF_Dictionary *pUsage = pOCGDict->GetDict(FX_BSTRC("Usage")); | |
| if (pUsage) { | |
| CPDF_Dictionary *pState = pUsage->GetDict(csState); | |
| if (pState) { | |
| CFX_ByteString csFind = csState + FX_BSTRC("State"); | |
| if (pState->KeyExist(csFind)) { | |
| return pState->GetString(csFind) != FX_BSTRC("OFF"); | |
| } | |
| } | |
| if (csState != FX_BSTRC("View")) { | |
| pState = pUsage->GetDict(FX_BSTRC("View")); | |
| if (pState && pState->KeyExist(FX_BSTRC("ViewState"))) { | |
| return pState->GetString(FX_BSTRC("ViewState")) != FX_BSTRC("OFF"); | |
| } | |
| } | |
| } | |
| FX_BOOL bDefValid = FALSE; | |
| return LoadOCGStateFromConfig(csState, pOCGDict, bDefValid); | |
| } | |
| FX_BOOL CPDF_OCContext::GetOCGVisible(const CPDF_Dictionary *pOCGDict) | |
| { | |
| if (!pOCGDict) { | |
| return FALSE; | |
| } | |
| FX_LPVOID bState = NULL; | |
| if (m_OCGStates.Lookup(pOCGDict, bState)) { | |
| return (FX_UINTPTR)bState != 0; | |
| } | |
| bState = (FX_LPVOID)(FX_UINTPTR)LoadOCGState(pOCGDict); | |
| m_OCGStates.SetAt(pOCGDict, bState); | |
| return (FX_UINTPTR)bState != 0; | |
| } | |
| FX_BOOL CPDF_OCContext::GetOCGVE(CPDF_Array *pExpression, FX_BOOL bFromConfig, int nLevel) | |
| { | |
| if (nLevel > 32) { | |
| return FALSE; | |
| } | |
| if (pExpression == NULL) { | |
| return FALSE; | |
| } | |
| FX_INT32 iCount = pExpression->GetCount(); | |
| CPDF_Object *pOCGObj; | |
| CFX_ByteString csOperator = pExpression->GetString(0); | |
| if (csOperator == FX_BSTRC("Not")) { | |
| pOCGObj = pExpression->GetElementValue(1); | |
| if (pOCGObj == NULL) { | |
| return FALSE; | |
| } | |
| if (pOCGObj->GetType() == PDFOBJ_DICTIONARY) { | |
| return !(bFromConfig ? LoadOCGState((CPDF_Dictionary*)pOCGObj) : GetOCGVisible((CPDF_Dictionary*)pOCGObj)); | |
| } else if (pOCGObj->GetType() == PDFOBJ_ARRAY) { | |
| return !GetOCGVE((CPDF_Array*)pOCGObj, bFromConfig, nLevel + 1); | |
| } else { | |
| return FALSE; | |
| } | |
| } | |
| if (csOperator == FX_BSTRC("Or") || csOperator == FX_BSTRC("And")) { | |
| FX_BOOL bValue = FALSE; | |
| for (FX_INT32 i = 1; i < iCount; i ++) { | |
| pOCGObj = pExpression->GetElementValue(1); | |
| if (pOCGObj == NULL) { | |
| continue; | |
| } | |
| FX_BOOL bItem = FALSE; | |
| if (pOCGObj->GetType() == PDFOBJ_DICTIONARY) { | |
| bItem = bFromConfig ? LoadOCGState((CPDF_Dictionary*)pOCGObj) : GetOCGVisible((CPDF_Dictionary*)pOCGObj); | |
| } else if (pOCGObj->GetType() == PDFOBJ_ARRAY) { | |
| bItem = GetOCGVE((CPDF_Array*)pOCGObj, bFromConfig, nLevel + 1); | |
| } | |
| if (i == 1) { | |
| bValue = bItem; | |
| } else { | |
| if (csOperator == FX_BSTRC("Or")) { | |
| bValue = bValue || bItem; | |
| } else { | |
| bValue = bValue && bItem; | |
| } | |
| } | |
| } | |
| return bValue; | |
| } | |
| return FALSE; | |
| } | |
| FX_BOOL CPDF_OCContext::LoadOCMDState(const CPDF_Dictionary *pOCMDDict, FX_BOOL bFromConfig) | |
| { | |
| FXSYS_assert(pOCMDDict != NULL); | |
| CPDF_Array *pVE = pOCMDDict->GetArray(FX_BSTRC("VE")); | |
| if (pVE != NULL) { | |
| return GetOCGVE(pVE, bFromConfig); | |
| } | |
| CFX_ByteString csP = pOCMDDict->GetString(FX_BSTRC("P"), FX_BSTRC("AnyOn")); | |
| CPDF_Object *pOCGObj = pOCMDDict->GetElementValue(FX_BSTRC("OCGs")); | |
| if (pOCGObj == NULL) { | |
| return TRUE; | |
| } | |
| if (pOCGObj->GetType() == PDFOBJ_DICTIONARY) { | |
| return bFromConfig ? LoadOCGState((CPDF_Dictionary*)pOCGObj) : GetOCGVisible((CPDF_Dictionary*)pOCGObj); | |
| } | |
| if (pOCGObj->GetType() != PDFOBJ_ARRAY) { | |
| return TRUE; | |
| } | |
| FX_BOOL bState = FALSE; | |
| if (csP == FX_BSTRC("AllOn") || csP == FX_BSTRC("AllOff")) { | |
| bState = TRUE; | |
| } | |
| FX_INT32 iCount = ((CPDF_Array*)pOCGObj)->GetCount(); | |
| for (FX_INT32 i = 0; i < iCount; i ++) { | |
| FX_BOOL bItem = TRUE; | |
| CPDF_Dictionary* pItemDict = ((CPDF_Array*)pOCGObj)->GetDict(i); | |
| if (pItemDict) { | |
| bItem = bFromConfig ? LoadOCGState(pItemDict) : GetOCGVisible(pItemDict); | |
| } | |
| if (csP == FX_BSTRC("AnyOn") && bItem) { | |
| return TRUE; | |
| } | |
| if (csP == FX_BSTRC("AnyOff") && !bItem) { | |
| return TRUE; | |
| } | |
| if (csP == FX_BSTRC("AllOn") && !bItem) { | |
| return FALSE; | |
| } | |
| if (csP == FX_BSTRC("AllOff") && bItem) { | |
| return FALSE; | |
| } | |
| } | |
| return bState; | |
| } | |
| FX_BOOL CPDF_OCContext::CheckOCGVisible(const CPDF_Dictionary *pOCGDict) | |
| { | |
| if (pOCGDict == NULL) { | |
| return TRUE; | |
| } | |
| CFX_ByteString csType = pOCGDict->GetString(FX_BSTRC("Type"), FX_BSTRC("OCG")); | |
| if (csType == FX_BSTRC("OCG")) { | |
| return GetOCGVisible(pOCGDict); | |
| } else { | |
| return LoadOCMDState(pOCGDict, FALSE); | |
| } | |
| } | |
| void CPDF_OCContext::ResetOCContext() | |
| { | |
| m_OCGStates.RemoveAll(); | |
| } |