void CPDF_FormField::LoadDA() {
CPDF_Dictionary* pFormDict = m_pForm->m_pFormDict;
if (!pFormDict)
return;
CFX_ByteString DA;
if (CPDF_Object* pObj = FPDF_GetFieldAttr(m_pDict, "DA"))
DA = pObj->GetString();
if (DA.IsEmpty())
DA = pFormDict->GetStringBy("DA");
if (DA.IsEmpty())
return;
CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
if (!pDR)
return;
CPDF_Dictionary* pFont = pDR->GetDictBy("Font");
if (!pFont)
return;
CPDF_SimpleParser syntax(DA.AsStringC());
syntax.FindTagParamFromStart("Tf", 2);
CFX_ByteString font_name(syntax.GetWord());
CPDF_Dictionary* pFontDict = pFont->GetDictBy(font_name);
if (!pFontDict)
return;
m_pFont = m_pForm->m_pDocument->LoadFont(pFontDict);
m_FontSize = FX_atof(syntax.GetWord());
}
CPDF_NameTree::CPDF_NameTree(CPDF_Document* pDoc,
const CFX_ByteString& category)
: m_pRoot(nullptr) {
CPDF_Dictionary* pRoot = pDoc->GetRoot();
if (!pRoot)
return;
CPDF_Dictionary* pNames = pRoot->GetDictBy("Names");
if (!pNames)
return;
m_pRoot = pNames->GetDictBy(category);
}
void CBA_FontMap::AddFontToAnnotDict(CPDF_Font* pFont,
const CFX_ByteString& sAlias) {
if (!pFont)
return;
CPDF_Dictionary* pAPDict = m_pAnnotDict->GetDictBy("AP");
if (!pAPDict) {
pAPDict = new CPDF_Dictionary;
m_pAnnotDict->SetAt("AP", pAPDict);
}
// to avoid checkbox and radiobutton
CPDF_Object* pObject = pAPDict->GetObjectBy(m_sAPType);
if (ToDictionary(pObject))
return;
CPDF_Stream* pStream = pAPDict->GetStreamBy(m_sAPType);
if (!pStream) {
pStream = new CPDF_Stream(nullptr, 0, nullptr);
int32_t objnum = m_pDocument->AddIndirectObject(pStream);
pAPDict->SetAtReference(m_sAPType, m_pDocument, objnum);
}
CPDF_Dictionary* pStreamDict = pStream->GetDict();
if (!pStreamDict) {
pStreamDict = new CPDF_Dictionary;
pStream->InitStream(nullptr, 0, pStreamDict);
}
if (pStreamDict) {
CPDF_Dictionary* pStreamResList = pStreamDict->GetDictBy("Resources");
if (!pStreamResList) {
pStreamResList = new CPDF_Dictionary();
pStreamDict->SetAt("Resources", pStreamResList);
}
if (pStreamResList) {
CPDF_Dictionary* pStreamResFontList = pStreamResList->GetDictBy("Font");
if (!pStreamResFontList) {
pStreamResFontList = new CPDF_Dictionary;
int32_t objnum = m_pDocument->AddIndirectObject(pStreamResFontList);
pStreamResList->SetAtReference("Font", m_pDocument, objnum);
}
if (!pStreamResFontList->KeyExist(sAlias))
pStreamResFontList->SetAtReference(sAlias, m_pDocument,
pFont->GetFontDict());
}
}
}
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;
}
static CPDF_Dictionary* FPDFDOC_OCG_GetConfig(CPDF_Document* pDoc,
const CPDF_Dictionary* pOCGDict,
const CFX_ByteStringC& bsState) {
FXSYS_assert(pDoc && pOCGDict);
CPDF_Dictionary* pOCProperties = pDoc->GetRoot()->GetDictBy("OCProperties");
if (!pOCProperties) {
return NULL;
}
CPDF_Array* pOCGs = pOCProperties->GetArrayBy("OCGs");
if (!pOCGs) {
return NULL;
}
if (FPDFDOC_OCG_FindGroup(pOCGs, pOCGDict) < 0) {
return NULL;
}
CPDF_Dictionary* pConfig = pOCProperties->GetDictBy("D");
CPDF_Array* pConfigs = pOCProperties->GetArrayBy("Configs");
if (pConfigs) {
CPDF_Dictionary* pFind;
int32_t iCount = pConfigs->GetCount();
for (int32_t i = 0; i < iCount; i++) {
pFind = pConfigs->GetDictAt(i);
if (!pFind) {
continue;
}
if (!FPDFDOC_OCG_HasIntent(pFind, "View", "View")) {
continue;
}
pConfig = pFind;
break;
}
}
return pConfig;
}
FX_BOOL FindInterFormFont(CPDF_Dictionary* pFormDict,
const CPDF_Font* pFont,
CFX_ByteString& csNameTag) {
if (!pFormDict || !pFont) {
return FALSE;
}
CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
if (!pDR) {
return FALSE;
}
CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
if (!pFonts) {
return FALSE;
}
for (const auto& it : *pFonts) {
const CFX_ByteString& csKey = it.first;
CPDF_Object* pObj = it.second;
if (!pObj) {
continue;
}
CPDF_Dictionary* pElement = ToDictionary(pObj->GetDirect());
if (!pElement)
continue;
if (pElement->GetStringBy("Type") != "Font") {
continue;
}
if (pFont->GetFontDict() == pElement) {
csNameTag = csKey;
return TRUE;
}
}
return FALSE;
}
CPDF_Font* GetInterFormFont(CPDF_Dictionary* pFormDict,
CPDF_Document* pDocument,
FX_DWORD index,
CFX_ByteString& csNameTag) {
if (!pFormDict) {
return NULL;
}
CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
if (!pDR) {
return NULL;
}
CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
if (!pFonts) {
return NULL;
}
FX_DWORD dwCount = 0;
for (const auto& it : *pFonts) {
const CFX_ByteString& csKey = it.first;
CPDF_Object* pObj = it.second;
if (!pObj) {
continue;
}
CPDF_Dictionary* pElement = ToDictionary(pObj->GetDirect());
if (!pElement)
continue;
if (pElement->GetStringBy("Type") != "Font")
continue;
if (dwCount == index) {
csNameTag = csKey;
return pDocument->LoadFont(pElement);
}
dwCount++;
}
return NULL;
}
DLLEXPORT void STDCALL FORM_DoPageAAction(FPDF_PAGE page,
FPDF_FORMHANDLE hHandle,
int aaType) {
if (!hHandle)
return;
CPDFSDK_Document* pSDKDoc = ((CPDFDoc_Environment*)hHandle)->GetSDKDocument();
UnderlyingPageType* pPage = UnderlyingFromFPDFPage(page);
CPDF_Page* pPDFPage = CPDFPageFromFPDFPage(page);
if (!pPDFPage)
return;
if (pSDKDoc->GetPageView(pPage, FALSE)) {
CPDFDoc_Environment* pEnv = pSDKDoc->GetEnv();
CPDFSDK_ActionHandler* pActionHandler = pEnv->GetActionHander();
CPDF_Dictionary* pPageDict = pPDFPage->m_pFormDict;
CPDF_AAction aa(pPageDict->GetDictBy("AA"));
if (FPDFPAGE_AACTION_OPEN == aaType) {
if (aa.ActionExist(CPDF_AAction::OpenPage)) {
CPDF_Action action = aa.GetAction(CPDF_AAction::OpenPage);
pActionHandler->DoAction_Page(action, CPDF_AAction::OpenPage, pSDKDoc);
}
} else {
if (aa.ActionExist(CPDF_AAction::ClosePage)) {
CPDF_Action action = aa.GetAction(CPDF_AAction::ClosePage);
pActionHandler->DoAction_Page(action, CPDF_AAction::ClosePage, pSDKDoc);
}
}
}
}
FX_DWORD CountInterFormFonts(CPDF_Dictionary* pFormDict) {
if (!pFormDict) {
return 0;
}
CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
if (!pDR) {
return 0;
}
CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
if (!pFonts) {
return 0;
}
FX_DWORD dwCount = 0;
for (const auto& it : *pFonts) {
CPDF_Object* pObj = it.second;
if (!pObj) {
continue;
}
if (CPDF_Dictionary* pDirect = ToDictionary(pObj->GetDirect())) {
if (pDirect->GetStringBy("Type") == "Font") {
dwCount++;
}
}
}
return dwCount;
}
FX_BOOL CPDF_ViewerPreferences::PrintScaling() const {
CPDF_Dictionary* pDict = m_pDoc->GetRoot();
pDict = pDict->GetDictBy("ViewerPreferences");
if (!pDict) {
return TRUE;
}
return "None" != pDict->GetStringBy("PrintScaling");
}
FX_BOOL CPDF_ViewerPreferences::IsDirectionR2L() const {
CPDF_Dictionary* pDict = m_pDoc->GetRoot();
pDict = pDict->GetDictBy("ViewerPreferences");
if (!pDict) {
return FALSE;
}
return "R2L" == pDict->GetStringBy("Direction");
}
CFX_ByteString CPDF_ViewerPreferences::Duplex() const {
CPDF_Dictionary* pDict = m_pDoc->GetRoot();
pDict = pDict->GetDictBy("ViewerPreferences");
if (!pDict) {
return "None";
}
return pDict->GetStringBy("Duplex");
}
int32_t CPDF_ViewerPreferences::NumCopies() const {
CPDF_Dictionary* pDict = m_pDoc->GetRoot();
pDict = pDict->GetDictBy("ViewerPreferences");
if (!pDict) {
return 1;
}
return pDict->GetIntegerBy("NumCopies");
}
CPDF_Array* CPDF_ViewerPreferences::PrintPageRange() const {
CPDF_Dictionary* pDict = m_pDoc->GetRoot();
CPDF_Array* pRange = NULL;
pDict = pDict->GetDictBy("ViewerPreferences");
if (!pDict) {
return pRange;
}
pRange = pDict->GetArrayBy("PrintPageRange");
return pRange;
}
CPDF_Font* CBA_FontMap::GetAnnotDefaultFont(CFX_ByteString& sAlias) {
CPDF_Dictionary* pAcroFormDict = nullptr;
const bool bWidget = (m_pAnnotDict->GetStringBy("Subtype") == "Widget");
if (bWidget) {
if (CPDF_Dictionary* pRootDict = m_pDocument->GetRoot())
pAcroFormDict = pRootDict->GetDictBy("AcroForm");
}
CFX_ByteString sDA;
CPDF_Object* pObj = FPDF_GetFieldAttr(m_pAnnotDict, "DA");
if (pObj)
sDA = pObj->GetString();
if (bWidget) {
if (sDA.IsEmpty()) {
pObj = FPDF_GetFieldAttr(pAcroFormDict, "DA");
sDA = pObj ? pObj->GetString() : CFX_ByteString();
}
}
CPDF_Dictionary* pFontDict = nullptr;
if (!sDA.IsEmpty()) {
CPDF_SimpleParser syntax(sDA.AsStringC());
syntax.FindTagParamFromStart("Tf", 2);
CFX_ByteString sFontName(syntax.GetWord());
sAlias = PDF_NameDecode(sFontName).Mid(1);
if (CPDF_Dictionary* pDRDict = m_pAnnotDict->GetDictBy("DR"))
if (CPDF_Dictionary* pDRFontDict = pDRDict->GetDictBy("Font"))
pFontDict = pDRFontDict->GetDictBy(sAlias);
if (!pFontDict)
if (CPDF_Dictionary* pAPDict = m_pAnnotDict->GetDictBy("AP"))
if (CPDF_Dictionary* pNormalDict = pAPDict->GetDictBy("N"))
if (CPDF_Dictionary* pNormalResDict =
pNormalDict->GetDictBy("Resources"))
if (CPDF_Dictionary* pResFontDict =
pNormalResDict->GetDictBy("Font"))
pFontDict = pResFontDict->GetDictBy(sAlias);
if (bWidget) {
if (!pFontDict) {
if (pAcroFormDict) {
if (CPDF_Dictionary* pDRDict = pAcroFormDict->GetDictBy("DR"))
if (CPDF_Dictionary* pDRFontDict = pDRDict->GetDictBy("Font"))
pFontDict = pDRFontDict->GetDictBy(sAlias);
}
}
}
}
return pFontDict ? m_pDocument->LoadFont(pFontDict) : nullptr;
}
CPDF_Font* CBA_FontMap::FindFontSameCharset(CFX_ByteString& sFontAlias,
int32_t nCharset) {
if (m_pAnnotDict->GetStringBy("Subtype") != "Widget")
return nullptr;
CPDF_Document* pDocument = GetDocument();
CPDF_Dictionary* pRootDict = pDocument->GetRoot();
if (!pRootDict)
return nullptr;
CPDF_Dictionary* pAcroFormDict = pRootDict->GetDictBy("AcroForm");
if (!pAcroFormDict)
return nullptr;
CPDF_Dictionary* pDRDict = pAcroFormDict->GetDictBy("DR");
if (!pDRDict)
return nullptr;
return FindResFontSameCharset(pDRDict, sFontAlias, nCharset);
}
void CPDFSDK_BAAnnot::WriteAppearance(const CFX_ByteString& sAPType,
const CPDF_Rect& rcBBox,
const CFX_Matrix& matrix,
const CFX_ByteString& sContents,
const CFX_ByteString& sAPState) {
CPDF_Dictionary* pAPDict = m_pAnnot->GetAnnotDict()->GetDictBy("AP");
if (!pAPDict) {
pAPDict = new CPDF_Dictionary;
m_pAnnot->GetAnnotDict()->SetAt("AP", pAPDict);
}
CPDF_Stream* pStream = nullptr;
CPDF_Dictionary* pParentDict = nullptr;
if (sAPState.IsEmpty()) {
pParentDict = pAPDict;
pStream = pAPDict->GetStreamBy(sAPType);
} else {
CPDF_Dictionary* pAPTypeDict = pAPDict->GetDictBy(sAPType);
if (!pAPTypeDict) {
pAPTypeDict = new CPDF_Dictionary;
pAPDict->SetAt(sAPType, pAPTypeDict);
}
pParentDict = pAPTypeDict;
pStream = pAPTypeDict->GetStreamBy(sAPState);
}
if (!pStream) {
pStream = new CPDF_Stream(nullptr, 0, nullptr);
CPDF_Document* pDoc = m_pPageView->GetPDFDocument();
int32_t objnum = pDoc->AddIndirectObject(pStream);
pParentDict->SetAtReference(sAPType, pDoc, objnum);
}
CPDF_Dictionary* pStreamDict = pStream->GetDict();
if (!pStreamDict) {
pStreamDict = new CPDF_Dictionary;
pStreamDict->SetAtName("Type", "XObject");
pStreamDict->SetAtName("Subtype", "Form");
pStreamDict->SetAtInteger("FormType", 1);
pStream->InitStream(nullptr, 0, pStreamDict);
}
if (pStreamDict) {
pStreamDict->SetAtMatrix("Matrix", matrix);
pStreamDict->SetAtRect("BBox", rcBBox);
}
pStream->SetData((uint8_t*)sContents.c_str(), sContents.GetLength(), FALSE,
FALSE);
}
void RemoveInterFormFont(CPDF_Dictionary* pFormDict, const CPDF_Font* pFont) {
if (!pFormDict || !pFont) {
return;
}
CFX_ByteString csTag;
if (!FindInterFormFont(pFormDict, pFont, csTag)) {
return;
}
CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
pFonts->RemoveAt(csTag);
}
CPDF_Font* CPDF_FormControl::GetDefaultControlFont() {
CPDF_DefaultAppearance cDA = GetDefaultAppearance();
CFX_ByteString csFontNameTag;
FX_FLOAT fFontSize;
cDA.GetFont(csFontNameTag, fFontSize);
if (csFontNameTag.IsEmpty())
return nullptr;
CPDF_Object* pObj = FPDF_GetFieldAttr(m_pWidgetDict, "DR");
if (CPDF_Dictionary* pDict = ToDictionary(pObj)) {
CPDF_Dictionary* pFonts = pDict->GetDictBy("Font");
if (pFonts) {
CPDF_Dictionary* pElement = pFonts->GetDictBy(csFontNameTag);
if (pElement) {
CPDF_Font* pFont = m_pField->m_pForm->m_pDocument->LoadFont(pElement);
if (pFont) {
return pFont;
}
}
}
}
if (CPDF_Font* pFormFont = m_pField->m_pForm->GetFormFont(csFontNameTag))
return pFormFont;
CPDF_Dictionary* pPageDict = m_pWidgetDict->GetDictBy("P");
pObj = FPDF_GetFieldAttr(pPageDict, "Resources");
if (CPDF_Dictionary* pDict = ToDictionary(pObj)) {
CPDF_Dictionary* pFonts = pDict->GetDictBy("Font");
if (pFonts) {
CPDF_Dictionary* pElement = pFonts->GetDictBy(csFontNameTag);
if (pElement) {
CPDF_Font* pFont = m_pField->m_pForm->m_pDocument->LoadFont(pElement);
if (pFont) {
return pFont;
}
}
}
}
return nullptr;
}
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->GetStringBy("BaseState", "ON") != "OFF";
CPDF_Array* pArray = pConfig->GetArrayBy("ON");
if (pArray) {
if (FPDFDOC_OCG_FindGroup(pArray, pOCGDict) >= 0) {
bState = TRUE;
}
}
pArray = pConfig->GetArrayBy("OFF");
if (pArray) {
if (FPDFDOC_OCG_FindGroup(pArray, pOCGDict) >= 0) {
bState = FALSE;
}
}
pArray = pConfig->GetArrayBy("AS");
if (pArray) {
CFX_ByteString csFind = csConfig + "State";
int32_t iCount = pArray->GetCount();
for (int32_t i = 0; i < iCount; i++) {
CPDF_Dictionary* pUsage = pArray->GetDictAt(i);
if (!pUsage) {
continue;
}
if (pUsage->GetStringBy("Event", "View") != csConfig) {
continue;
}
CPDF_Array* pOCGs = pUsage->GetArrayBy("OCGs");
if (!pOCGs) {
continue;
}
if (FPDFDOC_OCG_FindGroup(pOCGs, pOCGDict) < 0) {
continue;
}
CPDF_Dictionary* pState = pUsage->GetDictBy(csConfig);
if (!pState) {
continue;
}
bState = pState->GetStringBy(csFind) != "OFF";
}
}
return bState;
}
void RemoveInterFormFont(CPDF_Dictionary* pFormDict, CFX_ByteString csNameTag) {
if (!pFormDict || csNameTag.IsEmpty()) {
return;
}
CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
if (!pDR) {
return;
}
CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
if (!pFonts) {
return;
}
pFonts->RemoveAt(csNameTag);
}
void CPDF_AnnotList::DisplayPass(CPDF_Page* pPage,
CFX_RenderDevice* pDevice,
CPDF_RenderContext* pContext,
FX_BOOL bPrinting,
CFX_Matrix* pMatrix,
FX_BOOL bWidgetPass,
CPDF_RenderOptions* pOptions,
FX_RECT* clip_rect) {
for (const auto& pAnnot : m_AnnotList) {
bool bWidget = pAnnot->GetSubtype() == CPDF_Annot::Subtype::WIDGET;
if ((bWidgetPass && !bWidget) || (!bWidgetPass && bWidget))
continue;
uint32_t annot_flags = pAnnot->GetFlags();
if (annot_flags & ANNOTFLAG_HIDDEN)
continue;
if (bPrinting && (annot_flags & ANNOTFLAG_PRINT) == 0)
continue;
if (!bPrinting && (annot_flags & ANNOTFLAG_NOVIEW))
continue;
if (pOptions) {
CPDF_OCContext* pOCContext = pOptions->m_pOCContext;
CPDF_Dictionary* pAnnotDict = pAnnot->GetAnnotDict();
if (pOCContext && pAnnotDict &&
!pOCContext->CheckOCGVisible(pAnnotDict->GetDictBy("OC"))) {
continue;
}
}
CFX_FloatRect annot_rect_f = pAnnot->GetRect();
CFX_Matrix matrix = *pMatrix;
if (clip_rect) {
annot_rect_f.Transform(&matrix);
FX_RECT annot_rect = annot_rect_f.GetOuterRect();
annot_rect.Intersect(*clip_rect);
if (annot_rect.IsEmpty()) {
continue;
}
}
if (pContext) {
pAnnot->DrawInContext(pPage, pContext, &matrix, CPDF_Annot::Normal);
} else if (!pAnnot->DrawAppearance(pPage, pDevice, &matrix,
CPDF_Annot::Normal, pOptions)) {
pAnnot->DrawBorder(pDevice, &matrix, pOptions);
}
}
}
CPDF_Font* GetInterFormFont(CPDF_Dictionary* pFormDict,
CPDF_Document* pDocument,
CFX_ByteString csNameTag) {
CFX_ByteString csAlias = PDF_NameDecode(csNameTag);
if (!pFormDict || csAlias.IsEmpty()) {
return NULL;
}
CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
if (!pDR) {
return NULL;
}
CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
if (!pFonts) {
return NULL;
}
CPDF_Dictionary* pElement = pFonts->GetDictBy(csAlias);
if (!pElement) {
return NULL;
}
if (pElement->GetStringBy("Type") == "Font") {
return pDocument->LoadFont(pElement);
}
return NULL;
}
FX_BOOL CPDF_OCContext::LoadOCGState(const CPDF_Dictionary* pOCGDict) const {
if (!FPDFDOC_OCG_HasIntent(pOCGDict, "View", "View")) {
return TRUE;
}
CFX_ByteString csState = FPDFDOC_OCG_GetUsageTypeString(m_eUsageType);
CPDF_Dictionary* pUsage = pOCGDict->GetDictBy("Usage");
if (pUsage) {
CPDF_Dictionary* pState = pUsage->GetDictBy(csState);
if (pState) {
CFX_ByteString csFind = csState + "State";
if (pState->KeyExist(csFind)) {
return pState->GetStringBy(csFind) != "OFF";
}
}
if (csState != "View") {
pState = pUsage->GetDictBy("View");
if (pState && pState->KeyExist("ViewState")) {
return pState->GetStringBy("ViewState") != "OFF";
}
}
}
FX_BOOL bDefValid = FALSE;
return LoadOCGStateFromConfig(csState, pOCGDict, bDefValid);
}
CPDF_AnnotList::CPDF_AnnotList(CPDF_Page* pPage)
: m_pDocument(pPage->m_pDocument) {
if (!pPage->m_pFormDict)
return;
CPDF_Array* pAnnots = pPage->m_pFormDict->GetArrayBy("Annots");
if (!pAnnots)
return;
CPDF_Dictionary* pRoot = m_pDocument->GetRoot();
CPDF_Dictionary* pAcroForm = pRoot->GetDictBy("AcroForm");
FX_BOOL bRegenerateAP =
pAcroForm && pAcroForm->GetBooleanBy("NeedAppearances");
for (size_t i = 0; i < pAnnots->GetCount(); ++i) {
CPDF_Dictionary* pDict = ToDictionary(pAnnots->GetDirectObjectAt(i));
if (!pDict)
continue;
uint32_t dwObjNum = pDict->GetObjNum();
if (dwObjNum == 0) {
dwObjNum = m_pDocument->AddIndirectObject(pDict);
CPDF_Reference* pAction = new CPDF_Reference(m_pDocument, dwObjNum);
pAnnots->InsertAt(i, pAction);
pAnnots->RemoveAt(i + 1);
pDict = pAnnots->GetDictAt(i);
}
// Skip creating Popup annotation in the PDF document since PDFium provides
// its own Popup annotations.
if (pDict->GetStringBy("Subtype") == "Popup")
continue;
m_AnnotList.push_back(
std::unique_ptr<CPDF_Annot>(new CPDF_Annot(pDict, m_pDocument, false)));
if (bRegenerateAP && pDict->GetStringBy("Subtype") == "Widget" &&
CPDF_InterForm::IsUpdateAPEnabled()) {
FPDF_GenerateAP(m_pDocument, pDict);
}
}
size_t nAnnotListSize = m_AnnotList.size();
for (size_t i = 0; i < nAnnotListSize; ++i) {
std::unique_ptr<CPDF_Annot> pPopupAnnot(
CreatePopupAnnot(m_AnnotList[i].get(), m_pDocument));
if (pPopupAnnot)
m_AnnotList.push_back(std::move(pPopupAnnot));
}
}
CFX_WideString GetFullName(CPDF_Dictionary* pFieldDict) {
CFX_WideString full_name;
CPDF_Dictionary* pLevel = pFieldDict;
while (pLevel) {
CFX_WideString short_name = pLevel->GetUnicodeTextBy("T");
if (short_name != L"") {
if (full_name == L"") {
full_name = short_name;
} else {
full_name = short_name + L"." + full_name;
}
}
pLevel = pLevel->GetDictBy("Parent");
}
return full_name;
}
static FX_BOOL LoadCryptInfo(CPDF_Dictionary* pEncryptDict,
const CFX_ByteString& name,
int& cipher,
int& keylen) {
int Version = pEncryptDict->GetIntegerBy("V");
cipher = FXCIPHER_RC4;
keylen = 0;
if (Version >= 4) {
CPDF_Dictionary* pCryptFilters = pEncryptDict->GetDictBy("CF");
if (!pCryptFilters) {
return FALSE;
}
if (name == "Identity") {
cipher = FXCIPHER_NONE;
} else {
CPDF_Dictionary* pDefFilter = pCryptFilters->GetDictBy(name);
if (!pDefFilter) {
return FALSE;
}
int nKeyBits = 0;
if (Version == 4) {
nKeyBits = pDefFilter->GetIntegerBy("Length", 0);
if (nKeyBits == 0) {
nKeyBits = pEncryptDict->GetIntegerBy("Length", 128);
}
} else {
nKeyBits = pEncryptDict->GetIntegerBy("Length", 256);
}
if (nKeyBits < 40) {
nKeyBits *= 8;
}
keylen = nKeyBits / 8;
CFX_ByteString cipher_name = pDefFilter->GetStringBy("CFM");
if (cipher_name == "AESV2" || cipher_name == "AESV3") {
cipher = FXCIPHER_AES;
}
}
} else {
keylen = Version > 1 ? pEncryptDict->GetIntegerBy("Length", 40) / 8 : 5;
}
if (keylen > 32 || keylen < 0) {
return FALSE;
}
return TRUE;
}
FX_BOOL FindInterFormFont(CPDF_Dictionary* pFormDict,
CPDF_Document* pDocument,
CFX_ByteString csFontName,
CPDF_Font*& pFont,
CFX_ByteString& csNameTag) {
if (!pFormDict) {
return FALSE;
}
CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
if (!pDR) {
return FALSE;
}
CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
if (!pFonts) {
return FALSE;
}
if (csFontName.GetLength() > 0) {
csFontName.Remove(' ');
}
for (const auto& it : *pFonts) {
const CFX_ByteString& csKey = it.first;
CPDF_Object* pObj = it.second;
if (!pObj) {
continue;
}
CPDF_Dictionary* pElement = ToDictionary(pObj->GetDirect());
if (!pElement)
continue;
if (pElement->GetStringBy("Type") != "Font") {
continue;
}
pFont = pDocument->LoadFont(pElement);
if (!pFont) {
continue;
}
CFX_ByteString csBaseFont;
csBaseFont = pFont->GetBaseFont();
csBaseFont.Remove(' ');
if (csBaseFont == csFontName) {
csNameTag = csKey;
return TRUE;
}
}
return FALSE;
}
CFX_ByteString CPDF_FormControl::GetOnStateName() const {
ASSERT(GetType() == CPDF_FormField::CheckBox ||
GetType() == CPDF_FormField::RadioButton);
CFX_ByteString csOn;
CPDF_Dictionary* pAP = m_pWidgetDict->GetDictBy("AP");
if (!pAP)
return csOn;
CPDF_Dictionary* pN = pAP->GetDictBy("N");
if (!pN)
return csOn;
for (const auto& it : *pN) {
if (it.first != "Off")
return it.first;
}
return CFX_ByteString();
}
CPDF_InterForm::CPDF_InterForm(CPDF_Document* pDocument)
: m_pDocument(pDocument),
m_pFormDict(nullptr),
m_pFieldTree(new CFieldTree),
m_pFormNotify(nullptr) {
CPDF_Dictionary* pRoot = m_pDocument->GetRoot();
if (!pRoot)
return;
m_pFormDict = pRoot->GetDictBy("AcroForm");
if (!m_pFormDict)
return;
CPDF_Array* pFields = m_pFormDict->GetArrayBy("Fields");
if (!pFields)
return;
for (size_t i = 0; i < pFields->GetCount(); i++)
LoadField(pFields->GetDictAt(i));
}
