FX_BOOL CPDF_OCContext::GetOCGVE(CPDF_Array* pExpression,
FX_BOOL bFromConfig,
int nLevel) {
if (nLevel > 32) {
return FALSE;
}
if (!pExpression) {
return FALSE;
}
int32_t iCount = pExpression->GetCount();
CPDF_Object* pOCGObj;
CFX_ByteString csOperator = pExpression->GetStringAt(0);
if (csOperator == "Not") {
pOCGObj = pExpression->GetElementValue(1);
if (!pOCGObj)
return FALSE;
if (CPDF_Dictionary* pDict = pOCGObj->AsDictionary())
return !(bFromConfig ? LoadOCGState(pDict) : GetOCGVisible(pDict));
if (CPDF_Array* pArray = pOCGObj->AsArray())
return !GetOCGVE(pArray, bFromConfig, nLevel + 1);
return FALSE;
}
if (csOperator == "Or" || csOperator == "And") {
FX_BOOL bValue = FALSE;
for (int32_t i = 1; i < iCount; i++) {
pOCGObj = pExpression->GetElementValue(1);
if (!pOCGObj) {
continue;
}
FX_BOOL bItem = FALSE;
if (CPDF_Dictionary* pDict = pOCGObj->AsDictionary())
bItem = bFromConfig ? LoadOCGState(pDict) : GetOCGVisible(pDict);
else if (CPDF_Array* pArray = pOCGObj->AsArray())
bItem = GetOCGVE(pArray, bFromConfig, nLevel + 1);
if (i == 1) {
bValue = bItem;
} else {
if (csOperator == "Or") {
bValue = bValue || bItem;
} else {
bValue = bValue && bItem;
}
}
}
return bValue;
}
return FALSE;
}
CPDF_Object* CPDF_ActionFields::GetField(size_t iIndex) const {
if (!m_pAction)
return nullptr;
CPDF_Dictionary* pDict = m_pAction->GetDict();
if (!pDict)
return nullptr;
CFX_ByteString csType = pDict->GetStringFor("S");
CPDF_Object* pFields = nullptr;
if (csType == "Hide")
pFields = pDict->GetDirectObjectFor("T");
else
pFields = pDict->GetArrayFor("Fields");
if (!pFields)
return nullptr;
CPDF_Object* pFindObj = nullptr;
if (pFields->IsDictionary() || pFields->IsString()) {
if (iIndex == 0)
pFindObj = pFields;
} else if (CPDF_Array* pArray = pFields->AsArray()) {
pFindObj = pArray->GetDirectObjectAt(iIndex);
}
return pFindObj;
}
void CPDF_ContentParser::Start(CPDF_Page* pPage, CPDF_ParseOptions* pOptions) {
if (m_Status != Ready || pPage == NULL || pPage->m_pDocument == NULL ||
pPage->m_pFormDict == NULL) {
m_Status = Done;
return;
}
m_pObjects = pPage;
m_bForm = FALSE;
if (pOptions) {
m_Options = *pOptions;
}
m_Status = ToBeContinued;
m_InternalStage = PAGEPARSE_STAGE_GETCONTENT;
m_CurrentOffset = 0;
CPDF_Object* pContent =
pPage->m_pFormDict->GetElementValue(FX_BSTRC("Contents"));
if (pContent == NULL) {
m_Status = Done;
return;
}
if (CPDF_Stream* pStream = pContent->AsStream()) {
m_nStreams = 0;
m_pSingleStream = new CPDF_StreamAcc;
m_pSingleStream->LoadAllData(pStream, FALSE);
} else if (CPDF_Array* pArray = pContent->AsArray()) {
m_nStreams = pArray->GetCount();
if (m_nStreams == 0) {
m_Status = Done;
return;
}
m_pStreamArray = FX_Alloc(CPDF_StreamAcc*, m_nStreams);
} else {
size_t CPDF_ActionFields::GetFieldsCount() const {
if (!m_pAction)
return 0;
CPDF_Dictionary* pDict = m_pAction->GetDict();
if (!pDict)
return 0;
CFX_ByteString csType = pDict->GetStringFor("S");
CPDF_Object* pFields = nullptr;
if (csType == "Hide")
pFields = pDict->GetDirectObjectFor("T");
else
pFields = pDict->GetArrayFor("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;
}
CFX_WideString CPDF_FormField::GetValue(FX_BOOL bDefault) const {
if (GetType() == CheckBox || GetType() == RadioButton)
return GetCheckValue(bDefault);
CPDF_Object* pValue = FPDF_GetFieldAttr(m_pDict, bDefault ? "DV" : "V");
if (!pValue) {
if (!bDefault) {
if (m_Type == RichText) {
pValue = FPDF_GetFieldAttr(m_pDict, "V");
}
if (!pValue && m_Type != Text) {
pValue = FPDF_GetFieldAttr(m_pDict, "DV");
}
}
if (!pValue)
return CFX_WideString();
}
switch (pValue->GetType()) {
case CPDF_Object::STRING:
case CPDF_Object::STREAM:
return pValue->GetUnicodeText();
case CPDF_Object::ARRAY:
pValue = pValue->AsArray()->GetDirectObjectAt(0);
if (pValue)
return pValue->GetUnicodeText();
break;
default:
break;
}
return CFX_WideString();
}
bool CPDF_DataAvail::GetPageKids(CPDF_Parser* pParser, CPDF_Object* pPages) {
if (!pParser) {
m_docStatus = PDF_DATAAVAIL_ERROR;
return false;
}
CPDF_Dictionary* pDict = pPages->GetDict();
CPDF_Object* pKids = pDict ? pDict->GetObjectFor("Kids") : nullptr;
if (!pKids)
return true;
switch (pKids->GetType()) {
case CPDF_Object::REFERENCE:
m_PageObjList.Add(pKids->AsReference()->GetRefObjNum());
break;
case CPDF_Object::ARRAY: {
CPDF_Array* pKidsArray = pKids->AsArray();
for (size_t i = 0; i < pKidsArray->GetCount(); ++i) {
if (CPDF_Reference* pRef = ToReference(pKidsArray->GetObjectAt(i)))
m_PageObjList.Add(pRef->GetRefObjNum());
}
} break;
default:
m_docStatus = PDF_DATAAVAIL_ERROR;
return false;
}
return true;
}
FX_BOOL CPDF_OCContext::LoadOCMDState(const CPDF_Dictionary* pOCMDDict,
FX_BOOL bFromConfig) {
CPDF_Array* pVE = pOCMDDict->GetArrayBy("VE");
if (pVE) {
return GetOCGVE(pVE, bFromConfig);
}
CFX_ByteString csP = pOCMDDict->GetStringBy("P", "AnyOn");
CPDF_Object* pOCGObj = pOCMDDict->GetElementValue("OCGs");
if (!pOCGObj)
return TRUE;
if (const CPDF_Dictionary* pDict = pOCGObj->AsDictionary())
return bFromConfig ? LoadOCGState(pDict) : GetOCGVisible(pDict);
CPDF_Array* pArray = pOCGObj->AsArray();
if (!pArray)
return TRUE;
FX_BOOL bState = FALSE;
if (csP == "AllOn" || csP == "AllOff") {
bState = TRUE;
}
int32_t iCount = pArray->GetCount();
for (int32_t i = 0; i < iCount; i++) {
FX_BOOL bItem = TRUE;
CPDF_Dictionary* pItemDict = pArray->GetDictAt(i);
if (pItemDict)
bItem = bFromConfig ? LoadOCGState(pItemDict) : GetOCGVisible(pItemDict);
if ((csP == "AnyOn" && bItem) || (csP == "AnyOff" && !bItem))
return TRUE;
if ((csP == "AllOn" && !bItem) || (csP == "AllOff" && bItem))
return FALSE;
}
return bState;
}
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->GetStringFor("S");
CPDF_Object* pFields;
if (csType == "Hide")
pFields = pDict->GetDirectObjectFor("T");
else
pFields = pDict->GetArrayFor("Fields");
if (!pFields)
return fields;
if (pFields->IsDictionary() || pFields->IsString()) {
fields.push_back(pFields);
} else if (CPDF_Array* pArray = pFields->AsArray()) {
for (size_t i = 0; i < pArray->GetCount(); ++i) {
CPDF_Object* pObj = pArray->GetDirectObjectAt(i);
if (pObj)
fields.push_back(pObj);
}
}
return fields;
}
FX_BOOL CPDF_StructTreeImpl::AddTopLevelNode(CPDF_Dictionary* pDict,
CPDF_StructElementImpl* pElement) {
CPDF_Object* pObj = m_pTreeRoot->GetDirectObjectBy("K");
if (!pObj)
return FALSE;
if (pObj->IsDictionary()) {
if (pObj->GetObjNum() != pDict->GetObjNum())
return FALSE;
m_Kids[0].Reset(pElement);
}
if (CPDF_Array* pTopKids = pObj->AsArray()) {
bool bSave = false;
for (size_t i = 0; i < pTopKids->GetCount(); i++) {
CPDF_Reference* pKidRef = ToReference(pTopKids->GetObjectAt(i));
if (pKidRef && pKidRef->GetRefObjNum() == pDict->GetObjNum()) {
m_Kids[i].Reset(pElement);
bSave = true;
}
}
if (!bSave)
return FALSE;
}
return TRUE;
}
void CPDF_ContentParser::Start(CPDF_Page* pPage) {
if (m_Status != Ready || !pPage || !pPage->m_pDocument ||
!pPage->m_pFormDict) {
m_Status = Done;
return;
}
m_pObjectHolder = pPage;
m_bForm = false;
m_Status = ToBeContinued;
m_InternalStage = STAGE_GETCONTENT;
m_CurrentOffset = 0;
CPDF_Object* pContent = pPage->m_pFormDict->GetDirectObjectFor("Contents");
if (!pContent) {
m_Status = Done;
return;
}
if (CPDF_Stream* pStream = pContent->AsStream()) {
m_nStreams = 0;
m_pSingleStream.reset(new CPDF_StreamAcc);
m_pSingleStream->LoadAllData(pStream, false);
} else if (CPDF_Array* pArray = pContent->AsArray()) {
m_nStreams = pArray->GetCount();
if (m_nStreams)
m_StreamArray.resize(m_nStreams);
else
m_Status = Done;
} else {
m_Status = Done;
}
}
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;
}
bool CPDF_DIBSource::LoadColorInfo(const CPDF_Dictionary* pFormResources,
const CPDF_Dictionary* pPageResources) {
m_bpc_orig = m_pDict->GetIntegerFor("BitsPerComponent");
if (m_pDict->GetIntegerFor("ImageMask"))
m_bImageMask = true;
if (m_bImageMask || !m_pDict->KeyExist("ColorSpace")) {
if (!m_bImageMask) {
CPDF_Object* pFilter = m_pDict->GetDirectObjectFor("Filter");
if (pFilter) {
CFX_ByteString filter;
if (pFilter->IsName()) {
filter = pFilter->GetString();
} else if (CPDF_Array* pArray = pFilter->AsArray()) {
filter = pArray->GetStringAt(pArray->GetCount() - 1);
}
if (filter == "JPXDecode") {
m_bDoBpcCheck = false;
return true;
}
}
}
m_bImageMask = true;
m_bpc = m_nComponents = 1;
CPDF_Array* pDecode = m_pDict->GetArrayFor("Decode");
m_bDefaultDecode = !pDecode || !pDecode->GetIntegerAt(0);
return true;
}
CPDF_Object* pCSObj = m_pDict->GetDirectObjectFor("ColorSpace");
if (!pCSObj)
return false;
CPDF_DocPageData* pDocPageData = m_pDocument->GetPageData();
if (pFormResources)
m_pColorSpace = pDocPageData->GetColorSpace(pCSObj, pFormResources);
if (!m_pColorSpace)
m_pColorSpace = pDocPageData->GetColorSpace(pCSObj, pPageResources);
if (!m_pColorSpace)
return false;
m_Family = m_pColorSpace->GetFamily();
m_nComponents = m_pColorSpace->CountComponents();
if (m_Family == PDFCS_ICCBASED && pCSObj->IsName()) {
CFX_ByteString cs = pCSObj->GetString();
if (cs == "DeviceGray") {
m_nComponents = 1;
} else if (cs == "DeviceRGB") {
m_nComponents = 3;
} else if (cs == "DeviceCMYK") {
m_nComponents = 4;
}
}
ValidateDictParam();
m_pCompData = GetDecodeAndMaskArray(m_bDefaultDecode, m_bColorKey);
return !!m_pCompData;
}
DIB_COMP_DATA* CPDF_DIBSource::GetDecodeAndMaskArray(bool& bDefaultDecode,
bool& bColorKey) {
if (!m_pColorSpace) {
return nullptr;
}
DIB_COMP_DATA* pCompData = FX_Alloc(DIB_COMP_DATA, m_nComponents);
int max_data = (1 << m_bpc) - 1;
CPDF_Array* pDecode = m_pDict->GetArrayFor("Decode");
if (pDecode) {
for (uint32_t i = 0; i < m_nComponents; i++) {
pCompData[i].m_DecodeMin = pDecode->GetNumberAt(i * 2);
FX_FLOAT max = pDecode->GetNumberAt(i * 2 + 1);
pCompData[i].m_DecodeStep = (max - pCompData[i].m_DecodeMin) / max_data;
FX_FLOAT def_value;
FX_FLOAT def_min;
FX_FLOAT def_max;
m_pColorSpace->GetDefaultValue(i, def_value, def_min, def_max);
if (m_Family == PDFCS_INDEXED) {
def_max = max_data;
}
if (def_min != pCompData[i].m_DecodeMin || def_max != max) {
bDefaultDecode = false;
}
}
} else {
for (uint32_t i = 0; i < m_nComponents; i++) {
FX_FLOAT def_value;
m_pColorSpace->GetDefaultValue(i, def_value, pCompData[i].m_DecodeMin,
pCompData[i].m_DecodeStep);
if (m_Family == PDFCS_INDEXED) {
pCompData[i].m_DecodeStep = max_data;
}
pCompData[i].m_DecodeStep =
(pCompData[i].m_DecodeStep - pCompData[i].m_DecodeMin) / max_data;
}
}
if (!m_pDict->KeyExist("SMask")) {
CPDF_Object* pMask = m_pDict->GetDirectObjectFor("Mask");
if (!pMask) {
return pCompData;
}
if (CPDF_Array* pArray = pMask->AsArray()) {
if (pArray->GetCount() >= m_nComponents * 2) {
for (uint32_t i = 0; i < m_nComponents; i++) {
int min_num = pArray->GetIntegerAt(i * 2);
int max_num = pArray->GetIntegerAt(i * 2 + 1);
pCompData[i].m_ColorKeyMin = std::max(min_num, 0);
pCompData[i].m_ColorKeyMax = std::min(max_num, max_data);
}
}
bColorKey = true;
}
}
return pCompData;
}
FX_DWORD CPDF_Action::GetSubActionsCount() const {
if (!m_pDict || !m_pDict->KeyExist("Next"))
return 0;
CPDF_Object* pNext = m_pDict->GetElementValue("Next");
if (!pNext)
return 0;
if (pNext->IsDictionary())
return 1;
if (CPDF_Array* pArray = pNext->AsArray())
return pArray->GetCount();
return 0;
}
size_t CPDF_Action::GetSubActionsCount() const {
if (!m_pDict || !m_pDict->KeyExist("Next"))
return 0;
CPDF_Object* pNext = m_pDict->GetDirectObjectFor("Next");
if (!pNext)
return 0;
if (pNext->IsDictionary())
return 1;
if (CPDF_Array* pArray = pNext->AsArray())
return pArray->GetCount();
return 0;
}
CPDF_Object* CPDF_StructElementImpl::GetAttr(const CFX_ByteStringC& owner,
const CFX_ByteStringC& name,
FX_BOOL bInheritable,
FX_FLOAT fLevel) {
if (fLevel > nMaxRecursion) {
return nullptr;
}
if (bInheritable) {
CPDF_Object* pAttr = GetAttr(owner, name, FALSE);
if (pAttr) {
return pAttr;
}
if (!m_pParent) {
return nullptr;
}
return m_pParent->GetAttr(owner, name, TRUE, fLevel + 1);
}
CPDF_Object* pA = m_pDict->GetDirectObjectBy("A");
if (pA) {
CPDF_Dictionary* pAttrDict = FindAttrDict(pA, owner);
if (pAttrDict) {
CPDF_Object* pAttr = pAttrDict->GetDirectObjectBy(CFX_ByteString(name));
if (pAttr) {
return pAttr;
}
}
}
CPDF_Object* pC = m_pDict->GetDirectObjectBy("C");
if (!pC)
return nullptr;
CPDF_Dictionary* pClassMap = m_pTree->m_pTreeRoot->GetDictBy("ClassMap");
if (!pClassMap)
return nullptr;
if (CPDF_Array* pArray = pC->AsArray()) {
for (uint32_t i = 0; i < pArray->GetCount(); i++) {
CFX_ByteString class_name = pArray->GetStringAt(i);
CPDF_Dictionary* pClassDict = pClassMap->GetDictBy(class_name);
if (pClassDict && pClassDict->GetStringBy("O") == owner)
return pClassDict->GetDirectObjectBy(CFX_ByteString(name));
}
return nullptr;
}
CFX_ByteString class_name = pC->GetString();
CPDF_Dictionary* pClassDict = pClassMap->GetDictBy(class_name);
if (pClassDict && pClassDict->GetStringBy("O") == owner)
return pClassDict->GetDirectObjectBy(CFX_ByteString(name));
return nullptr;
}
CFX_WideString CPDF_FormField::GetOptionText(int index, int sub_index) const {
CPDF_Array* pArray = ToArray(FPDF_GetFieldAttr(m_pDict, "Opt"));
if (!pArray)
return CFX_WideString();
CPDF_Object* pOption = pArray->GetDirectObjectAt(index);
if (!pOption)
return CFX_WideString();
if (CPDF_Array* pOptionArray = pOption->AsArray())
pOption = pOptionArray->GetDirectObjectAt(sub_index);
CPDF_String* pString = ToString(pOption);
return pString ? pString->GetUnicodeText() : CFX_WideString();
}
CPDF_Dest CPDF_Link::GetDest(CPDF_Document* pDoc) {
CPDF_Object* pDest = m_pDict->GetElementValue("Dest");
if (!pDest)
return CPDF_Dest();
if (pDest->IsString() || pDest->IsName()) {
CPDF_NameTree name_tree(pDoc, FX_BSTRC("Dests"));
CFX_ByteStringC name = pDest->GetString();
return CPDF_Dest(name_tree.LookupNamedDest(pDoc, name));
}
if (CPDF_Array* pArray = pDest->AsArray())
return CPDF_Dest(pArray);
return CPDF_Dest();
}
int CPDF_FormField::CountSelectedItems() const {
CPDF_Object* pValue = FPDF_GetFieldAttr(m_pDict, "V");
if (!pValue) {
pValue = FPDF_GetFieldAttr(m_pDict, "I");
if (!pValue)
return 0;
}
if (pValue->IsString() || pValue->IsNumber())
return pValue->GetString().IsEmpty() ? 0 : 1;
if (CPDF_Array* pArray = pValue->AsArray())
return pArray->GetCount();
return 0;
}
CPDF_Array* CPDF_NameTree::LookupNamedDest(CPDF_Document* pDoc,
const CFX_ByteStringC& sName) {
CPDF_Object* pValue = LookupValue(sName);
if (!pValue) {
CPDF_Dictionary* pDests = pDoc->GetRoot()->GetDictBy("Dests");
if (!pDests)
return nullptr;
pValue = pDests->GetElementValue(sName);
}
if (!pValue)
return nullptr;
if (CPDF_Array* pArray = pValue->AsArray())
return pArray;
if (CPDF_Dictionary* pDict = pValue->AsDictionary())
return pDict->GetArrayBy("D");
return nullptr;
}
void CPDF_CIDFont::LoadMetricsArray(CPDF_Array* pArray,
std::vector<uint32_t>* result,
int nElements) {
int width_status = 0;
int iCurElement = 0;
int first_code = 0;
int last_code = 0;
for (size_t i = 0; i < pArray->GetCount(); i++) {
CPDF_Object* pObj = pArray->GetDirectObjectAt(i);
if (!pObj)
continue;
if (CPDF_Array* pObjArray = pObj->AsArray()) {
if (width_status != 1)
return;
for (size_t j = 0; j < pObjArray->GetCount(); j += nElements) {
result->push_back(first_code);
result->push_back(first_code);
for (int k = 0; k < nElements; k++)
result->push_back(pObjArray->GetIntegerAt(j + k));
first_code++;
}
width_status = 0;
} else {
if (width_status == 0) {
first_code = pObj->GetInteger();
width_status = 1;
} else if (width_status == 1) {
last_code = pObj->GetInteger();
width_status = 2;
iCurElement = 0;
} else {
if (!iCurElement) {
result->push_back(first_code);
result->push_back(last_code);
}
result->push_back(pObj->GetInteger());
iCurElement++;
if (iCurElement == nElements)
width_status = 0;
}
}
}
}
FX_BOOL CPDF_FormField::IsItemSelected(int index) const {
ASSERT(GetType() == ComboBox || GetType() == ListBox);
if (index < 0 || index >= CountOptions()) {
return FALSE;
}
if (IsOptionSelected(index)) {
return TRUE;
}
CFX_WideString opt_value = GetOptionValue(index);
CPDF_Object* pValue = FPDF_GetFieldAttr(m_pDict, "V");
if (!pValue) {
pValue = FPDF_GetFieldAttr(m_pDict, "I");
if (!pValue) {
return FALSE;
}
}
if (pValue->IsString())
return pValue->GetUnicodeText() == opt_value;
if (pValue->IsNumber()) {
if (pValue->GetString().IsEmpty())
return FALSE;
return (pValue->GetInteger() == index);
}
CPDF_Array* pArray = pValue->AsArray();
if (!pArray)
return FALSE;
int iPos = -1;
for (int j = 0; j < CountSelectedOptions(); j++) {
if (GetSelectedOptionIndex(j) == index) {
iPos = j;
break;
}
}
for (int i = 0; i < static_cast<int>(pArray->GetCount()); i++)
if (pArray->GetDirectObjectAt(i)->GetUnicodeText() == opt_value &&
i == iPos) {
return TRUE;
}
return FALSE;
}
CPDF_Dest CPDF_Action::GetDest(CPDF_Document* pDoc) const {
if (!m_pDict)
return CPDF_Dest();
CFX_ByteString type = m_pDict->GetStringFor("S");
if (type != "GoTo" && type != "GoToR")
return CPDF_Dest();
CPDF_Object* pDest = m_pDict->GetDirectObjectFor("D");
if (!pDest)
return CPDF_Dest();
if (pDest->IsString() || pDest->IsName()) {
CPDF_NameTree name_tree(pDoc, "Dests");
return CPDF_Dest(name_tree.LookupNamedDest(pDoc, pDest->GetString()));
}
if (CPDF_Array* pArray = pDest->AsArray())
return CPDF_Dest(pArray);
return CPDF_Dest();
}
static FX_BOOL FPDFDOC_OCG_HasIntent(const CPDF_Dictionary* pDict,
const CFX_ByteStringC& csElement,
const CFX_ByteStringC& csDef = "") {
CPDF_Object* pIntent = pDict->GetElementValue("Intent");
if (!pIntent) {
return csElement == csDef;
}
CFX_ByteString bsIntent;
if (CPDF_Array* pArray = pIntent->AsArray()) {
FX_DWORD dwCount = pArray->GetCount();
for (FX_DWORD i = 0; i < dwCount; i++) {
bsIntent = pArray->GetStringAt(i);
if (bsIntent == "All" || bsIntent == csElement)
return TRUE;
}
return FALSE;
}
bsIntent = pIntent->GetString();
return bsIntent == "All" || bsIntent == csElement;
}
void CPDF_StructElementImpl::LoadKids(CPDF_Dictionary* pDict) {
CPDF_Object* pObj = pDict->GetObjectBy("Pg");
uint32_t PageObjNum = 0;
if (CPDF_Reference* pRef = ToReference(pObj))
PageObjNum = pRef->GetRefObjNum();
CPDF_Object* pKids = pDict->GetDirectObjectBy("K");
if (!pKids)
return;
m_Kids.clear();
if (CPDF_Array* pArray = pKids->AsArray()) {
m_Kids.resize(pArray->GetCount());
for (uint32_t i = 0; i < pArray->GetCount(); i++) {
CPDF_Object* pKid = pArray->GetDirectObjectAt(i);
LoadKid(PageObjNum, pKid, &m_Kids[i]);
}
} else {
m_Kids.resize(1);
LoadKid(PageObjNum, pKids, &m_Kids[0]);
}
}
int CPDF_FormField::GetSelectedIndex(int index) {
CPDF_Object* pValue = FPDF_GetFieldAttr(m_pDict, "V");
if (!pValue) {
pValue = FPDF_GetFieldAttr(m_pDict, "I");
if (!pValue)
return -1;
}
if (pValue->IsNumber())
return pValue->GetInteger();
CFX_WideString sel_value;
if (pValue->IsString()) {
if (index != 0)
return -1;
sel_value = pValue->GetUnicodeText();
} else {
CPDF_Array* pArray = pValue->AsArray();
if (!pArray || index < 0)
return -1;
CPDF_Object* elementValue = pArray->GetElementValue(index);
sel_value =
elementValue ? elementValue->GetUnicodeText() : CFX_WideString();
}
if (index < CountSelectedOptions()) {
int iOptIndex = GetSelectedOptionIndex(index);
CFX_WideString csOpt = GetOptionValue(iOptIndex);
if (csOpt == sel_value) {
return iOptIndex;
}
}
int nOpts = CountOptions();
for (int i = 0; i < nOpts; i++) {
if (sel_value == GetOptionValue(i)) {
return i;
}
}
return -1;
}
void CPDF_StructTreeImpl::LoadPageTree(const CPDF_Dictionary* pPageDict) {
m_pPage = pPageDict;
if (!m_pTreeRoot)
return;
CPDF_Object* pKids = m_pTreeRoot->GetDirectObjectBy("K");
if (!pKids)
return;
uint32_t dwKids = 0;
if (pKids->IsDictionary())
dwKids = 1;
else if (CPDF_Array* pArray = pKids->AsArray())
dwKids = pArray->GetCount();
else
return;
m_Kids.clear();
m_Kids.resize(dwKids);
CPDF_Dictionary* pParentTree = m_pTreeRoot->GetDictBy("ParentTree");
if (!pParentTree)
return;
CPDF_NumberTree parent_tree(pParentTree);
int parents_id = pPageDict->GetIntegerBy("StructParents", -1);
if (parents_id < 0)
return;
CPDF_Array* pParentArray = ToArray(parent_tree.LookupValue(parents_id));
if (!pParentArray)
return;
std::map<CPDF_Dictionary*, CPDF_StructElementImpl*> element_map;
for (size_t i = 0; i < pParentArray->GetCount(); i++) {
if (CPDF_Dictionary* pParent = pParentArray->GetDictAt(i))
AddPageNode(pParent, element_map);
}
}
bool CPDF_ShadingPattern::Load() {
if (m_ShadingType != kInvalidShading)
return true;
CPDF_Dictionary* pShadingDict =
m_pShadingObj ? m_pShadingObj->GetDict() : nullptr;
if (!pShadingDict)
return false;
m_pFunctions.clear();
CPDF_Object* pFunc = pShadingDict->GetDirectObjectFor("Function");
if (pFunc) {
if (CPDF_Array* pArray = pFunc->AsArray()) {
m_pFunctions.resize(std::min<size_t>(pArray->GetCount(), 4));
for (size_t i = 0; i < m_pFunctions.size(); ++i)
m_pFunctions[i] = CPDF_Function::Load(pArray->GetDirectObjectAt(i));
} else {
m_pFunctions.push_back(CPDF_Function::Load(pFunc));
}
}
CPDF_Object* pCSObj = pShadingDict->GetDirectObjectFor("ColorSpace");
if (!pCSObj)
return false;
CPDF_DocPageData* pDocPageData = m_pDocument->GetPageData();
m_pCS = pDocPageData->GetColorSpace(pCSObj, nullptr);
if (m_pCS)
m_pCountedCS = pDocPageData->FindColorSpacePtr(m_pCS->GetArray());
m_ShadingType = ToShadingType(pShadingDict->GetIntegerFor("ShadingType"));
// We expect to have a stream if our shading type is a mesh.
if (IsMeshShading() && !ToStream(m_pShadingObj))
return false;
return true;
}
