summaryrefslogtreecommitdiff
path: root/core/fpdfdoc/doc_form.cpp
diff options
context:
space:
mode:
authorDan Sinclair <dsinclair@chromium.org>2016-03-14 13:35:12 -0400
committerDan Sinclair <dsinclair@chromium.org>2016-03-14 13:35:12 -0400
commit764ec513eecbebd12781bcc96ce81ed5e736ee92 (patch)
tree12763fde4be1f10ea1183d92185917b2b587e00b /core/fpdfdoc/doc_form.cpp
parent97da97662417085774f75c26e535c6fbe70266ae (diff)
downloadpdfium-764ec513eecbebd12781bcc96ce81ed5e736ee92.tar.xz
Move core/src/ up to core/.
This CL moves the core/src/ files up to core/ and fixes up the include guards, includes and build files. R=tsepez@chromium.org Review URL: https://codereview.chromium.org/1800523005 .
Diffstat (limited to 'core/fpdfdoc/doc_form.cpp')
-rw-r--r--core/fpdfdoc/doc_form.cpp1207
1 files changed, 1207 insertions, 0 deletions
diff --git a/core/fpdfdoc/doc_form.cpp b/core/fpdfdoc/doc_form.cpp
new file mode 100644
index 0000000000..c205588335
--- /dev/null
+++ b/core/fpdfdoc/doc_form.cpp
@@ -0,0 +1,1207 @@
+// 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 <vector>
+
+#include "core/fpdfdoc/doc_utils.h"
+#include "core/include/fpdfapi/cfdf_document.h"
+#include "core/include/fpdfapi/cpdf_array.h"
+#include "core/include/fpdfapi/cpdf_document.h"
+#include "core/include/fpdfapi/cpdf_string.h"
+#include "core/include/fpdfdoc/fpdf_doc.h"
+#include "third_party/base/stl_util.h"
+
+namespace {
+
+const int nMaxRecursion = 32;
+
+const struct SupportFieldEncoding {
+ const FX_CHAR* m_name;
+ FX_WORD m_codePage;
+} g_fieldEncoding[] = {
+ {"BigFive", 950},
+ {"GBK", 936},
+ {"Shift-JIS", 932},
+ {"UHC", 949},
+};
+
+CFX_WideString FPDFDOC_FDF_GetFieldValue(const CPDF_Dictionary& pFieldDict,
+ const CFX_ByteString& bsEncoding) {
+ const CFX_ByteString csBValue = pFieldDict.GetStringBy("V");
+ for (const auto& encoding : g_fieldEncoding) {
+ if (bsEncoding == encoding.m_name)
+ return CFX_WideString::FromCodePage(csBValue, encoding.m_codePage);
+ }
+ CFX_ByteString csTemp = csBValue.Left(2);
+ if (csTemp == "\xFF\xFE" || csTemp == "\xFE\xFF")
+ return PDF_DecodeText(csBValue);
+ return CFX_WideString::FromLocal(csBValue);
+}
+
+} // namespace
+
+class CFieldNameExtractor {
+ public:
+ explicit CFieldNameExtractor(const CFX_WideString& full_name) {
+ m_pStart = full_name.c_str();
+ m_pEnd = m_pStart + full_name.GetLength();
+ m_pCur = m_pStart;
+ }
+ void GetNext(const FX_WCHAR*& pSubName, FX_STRSIZE& size) {
+ pSubName = m_pCur;
+ while (m_pCur < m_pEnd && m_pCur[0] != L'.') {
+ m_pCur++;
+ }
+ size = (FX_STRSIZE)(m_pCur - pSubName);
+ if (m_pCur < m_pEnd && m_pCur[0] == L'.') {
+ m_pCur++;
+ }
+ }
+
+ protected:
+ const FX_WCHAR* m_pStart;
+ const FX_WCHAR* m_pEnd;
+ const FX_WCHAR* m_pCur;
+};
+class CFieldTree {
+ public:
+ struct _Node {
+ _Node* parent;
+ CFX_ArrayTemplate<_Node*> children;
+ CFX_WideString short_name;
+ CPDF_FormField* field_ptr;
+ int CountFields(int nLevel = 0) {
+ if (nLevel > nMaxRecursion) {
+ return 0;
+ }
+ if (field_ptr) {
+ return 1;
+ }
+ int count = 0;
+ for (int i = 0; i < children.GetSize(); i++) {
+ count += children.GetAt(i)->CountFields(nLevel + 1);
+ }
+ return count;
+ }
+ CPDF_FormField* GetField(int* fields_to_go) {
+ if (field_ptr) {
+ if (*fields_to_go == 0) {
+ return field_ptr;
+ }
+ --*fields_to_go;
+ return NULL;
+ }
+ for (int i = 0; i < children.GetSize(); i++) {
+ if (CPDF_FormField* pField = children.GetAt(i)->GetField(fields_to_go))
+ return pField;
+ }
+ return NULL;
+ }
+ CPDF_FormField* GetField(int index) {
+ int fields_to_go = index;
+ return GetField(&fields_to_go);
+ }
+ };
+ CFieldTree();
+ ~CFieldTree();
+ void SetField(const CFX_WideString& full_name, CPDF_FormField* field_ptr);
+ CPDF_FormField* GetField(const CFX_WideString& full_name);
+ CPDF_FormField* RemoveField(const CFX_WideString& full_name);
+ void RemoveAll();
+ _Node* FindNode(const CFX_WideString& full_name);
+ _Node* AddChild(_Node* pParent,
+ const CFX_WideString& short_name,
+ CPDF_FormField* field_ptr);
+ void RemoveNode(_Node* pNode, int nLevel = 0);
+ _Node* _Lookup(_Node* pParent, const CFX_WideString& short_name);
+ _Node m_Root;
+};
+CFieldTree::CFieldTree() {
+ m_Root.parent = NULL;
+ m_Root.field_ptr = NULL;
+}
+CFieldTree::~CFieldTree() {
+ RemoveAll();
+}
+CFieldTree::_Node* CFieldTree::AddChild(_Node* pParent,
+ const CFX_WideString& short_name,
+ CPDF_FormField* field_ptr) {
+ if (!pParent) {
+ return NULL;
+ }
+ _Node* pNode = new _Node;
+ pNode->parent = pParent;
+ pNode->short_name = short_name;
+ pNode->field_ptr = field_ptr;
+ pParent->children.Add(pNode);
+ return pNode;
+}
+void CFieldTree::RemoveNode(_Node* pNode, int nLevel) {
+ if (!pNode) {
+ return;
+ }
+ if (nLevel <= nMaxRecursion) {
+ for (int i = 0; i < pNode->children.GetSize(); i++) {
+ RemoveNode(pNode->children[i], nLevel + 1);
+ }
+ }
+ delete pNode;
+}
+CFieldTree::_Node* CFieldTree::_Lookup(_Node* pParent,
+ const CFX_WideString& short_name) {
+ if (!pParent) {
+ return NULL;
+ }
+ for (int i = 0; i < pParent->children.GetSize(); i++) {
+ _Node* pNode = pParent->children[i];
+ if (pNode->short_name.GetLength() == short_name.GetLength() &&
+ FXSYS_memcmp(pNode->short_name.c_str(), short_name.c_str(),
+ short_name.GetLength() * sizeof(FX_WCHAR)) == 0) {
+ return pNode;
+ }
+ }
+ return NULL;
+}
+void CFieldTree::RemoveAll() {
+ for (int i = 0; i < m_Root.children.GetSize(); i++) {
+ RemoveNode(m_Root.children[i]);
+ }
+}
+void CFieldTree::SetField(const CFX_WideString& full_name,
+ CPDF_FormField* field_ptr) {
+ if (full_name == L"") {
+ return;
+ }
+ CFieldNameExtractor name_extractor(full_name);
+ const FX_WCHAR* pName;
+ FX_STRSIZE nLength;
+ name_extractor.GetNext(pName, nLength);
+ _Node *pNode = &m_Root, *pLast = NULL;
+ while (nLength > 0) {
+ pLast = pNode;
+ CFX_WideString name = CFX_WideString(pName, nLength);
+ pNode = _Lookup(pLast, name);
+ if (!pNode) {
+ pNode = AddChild(pLast, name, NULL);
+ }
+ name_extractor.GetNext(pName, nLength);
+ }
+ if (pNode != &m_Root) {
+ pNode->field_ptr = field_ptr;
+ }
+}
+CPDF_FormField* CFieldTree::GetField(const CFX_WideString& full_name) {
+ if (full_name == L"") {
+ return NULL;
+ }
+ CFieldNameExtractor name_extractor(full_name);
+ const FX_WCHAR* pName;
+ FX_STRSIZE nLength;
+ name_extractor.GetNext(pName, nLength);
+ _Node *pNode = &m_Root, *pLast = NULL;
+ while (nLength > 0 && pNode) {
+ pLast = pNode;
+ CFX_WideString name = CFX_WideString(pName, nLength);
+ pNode = _Lookup(pLast, name);
+ name_extractor.GetNext(pName, nLength);
+ }
+ return pNode ? pNode->field_ptr : NULL;
+}
+CPDF_FormField* CFieldTree::RemoveField(const CFX_WideString& full_name) {
+ if (full_name == L"") {
+ return NULL;
+ }
+ CFieldNameExtractor name_extractor(full_name);
+ const FX_WCHAR* pName;
+ FX_STRSIZE nLength;
+ name_extractor.GetNext(pName, nLength);
+ _Node *pNode = &m_Root, *pLast = NULL;
+ while (nLength > 0 && pNode) {
+ pLast = pNode;
+ CFX_WideString name = CFX_WideString(pName, nLength);
+ pNode = _Lookup(pLast, name);
+ name_extractor.GetNext(pName, nLength);
+ }
+ if (pNode && pNode != &m_Root) {
+ for (int i = 0; i < pLast->children.GetSize(); i++) {
+ if (pNode == pLast->children[i]) {
+ pLast->children.RemoveAt(i);
+ break;
+ }
+ }
+ CPDF_FormField* pField = pNode->field_ptr;
+ RemoveNode(pNode);
+ return pField;
+ }
+ return NULL;
+}
+CFieldTree::_Node* CFieldTree::FindNode(const CFX_WideString& full_name) {
+ if (full_name == L"") {
+ return NULL;
+ }
+ CFieldNameExtractor name_extractor(full_name);
+ const FX_WCHAR* pName;
+ FX_STRSIZE nLength;
+ name_extractor.GetNext(pName, nLength);
+ _Node *pNode = &m_Root, *pLast = NULL;
+ while (nLength > 0 && pNode) {
+ pLast = pNode;
+ CFX_WideString name = CFX_WideString(pName, nLength);
+ pNode = _Lookup(pLast, name);
+ name_extractor.GetNext(pName, nLength);
+ }
+ return pNode;
+}
+CPDF_InterForm::CPDF_InterForm(CPDF_Document* pDocument, FX_BOOL bGenerateAP)
+ : CFX_PrivateData(),
+ m_pDocument(pDocument),
+ m_bGenerateAP(bGenerateAP),
+ m_pFormDict(nullptr),
+ m_pFieldTree(new CFieldTree),
+ m_pFormNotify(nullptr),
+ m_bUpdated(FALSE) {
+ 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;
+
+ int count = pFields->GetCount();
+ for (int i = 0; i < count; i++) {
+ LoadField(pFields->GetDictAt(i));
+ }
+}
+
+CPDF_InterForm::~CPDF_InterForm() {
+ for (auto it : m_ControlMap)
+ delete it.second;
+
+ int nCount = m_pFieldTree->m_Root.CountFields();
+ for (int i = 0; i < nCount; ++i) {
+ delete m_pFieldTree->m_Root.GetField(i);
+ }
+}
+
+FX_BOOL CPDF_InterForm::m_bUpdateAP = TRUE;
+FX_BOOL CPDF_InterForm::UpdatingAPEnabled() {
+ return m_bUpdateAP;
+}
+void CPDF_InterForm::EnableUpdateAP(FX_BOOL bUpdateAP) {
+ m_bUpdateAP = bUpdateAP;
+}
+CFX_ByteString CPDF_InterForm::GenerateNewResourceName(
+ const CPDF_Dictionary* pResDict,
+ const FX_CHAR* csType,
+ int iMinLen,
+ const FX_CHAR* csPrefix) {
+ CFX_ByteString csStr = csPrefix;
+ CFX_ByteString csBType = csType;
+ if (csStr.IsEmpty()) {
+ if (csBType == "ExtGState") {
+ csStr = "GS";
+ } else if (csBType == "ColorSpace") {
+ csStr = "CS";
+ } else if (csBType == "Font") {
+ csStr = "ZiTi";
+ } else {
+ csStr = "Res";
+ }
+ }
+ CFX_ByteString csTmp = csStr;
+ int iCount = csStr.GetLength();
+ int m = 0;
+ if (iMinLen > 0) {
+ csTmp = "";
+ while (m < iMinLen && m < iCount) {
+ csTmp += csStr[m++];
+ }
+ while (m < iMinLen) {
+ csTmp += '0' + m % 10;
+ m++;
+ }
+ } else {
+ m = iCount;
+ }
+ if (!pResDict) {
+ return csTmp;
+ }
+ CPDF_Dictionary* pDict = pResDict->GetDictBy(csType);
+ if (!pDict) {
+ return csTmp;
+ }
+ int num = 0;
+ CFX_ByteString bsNum;
+ while (TRUE) {
+ if (!pDict->KeyExist(csTmp + bsNum)) {
+ return csTmp + bsNum;
+ }
+ if (m < iCount) {
+ csTmp += csStr[m++];
+ } else {
+ bsNum.Format("%d", num++);
+ }
+ m++;
+ }
+ return csTmp;
+}
+#if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
+typedef struct PDF_FONTDATA_ {
+ FX_BOOL bFind;
+ LOGFONTA lf;
+} PDF_FONTDATA, FAR* LPDF_FONTDATA;
+static int CALLBACK EnumFontFamExProc(ENUMLOGFONTEXA* lpelfe,
+ NEWTEXTMETRICEX* lpntme,
+ DWORD FontType,
+ LPARAM lParam) {
+ if (FontType != 0x004 || strchr(lpelfe->elfLogFont.lfFaceName, '@')) {
+ return 1;
+ }
+ LPDF_FONTDATA pData = (LPDF_FONTDATA)lParam;
+ memcpy(&pData->lf, &lpelfe->elfLogFont, sizeof(LOGFONTA));
+ pData->bFind = TRUE;
+ return 0;
+}
+static FX_BOOL RetrieveSpecificFont(LOGFONTA& lf) {
+ PDF_FONTDATA fd;
+ memset(&fd, 0, sizeof(PDF_FONTDATA));
+ HDC hDC = ::GetDC(NULL);
+ EnumFontFamiliesExA(hDC, &lf, (FONTENUMPROCA)EnumFontFamExProc, (LPARAM)&fd,
+ 0);
+ ::ReleaseDC(NULL, hDC);
+ if (fd.bFind) {
+ memcpy(&lf, &fd.lf, sizeof(LOGFONTA));
+ }
+ return fd.bFind;
+}
+static FX_BOOL RetrieveSpecificFont(uint8_t charSet,
+ uint8_t pitchAndFamily,
+ LPCSTR pcsFontName,
+ LOGFONTA& lf) {
+ memset(&lf, 0, sizeof(LOGFONTA));
+ lf.lfCharSet = charSet;
+ lf.lfPitchAndFamily = pitchAndFamily;
+ if (pcsFontName) {
+ // TODO(dsinclair): Should this be strncpy?
+ strcpy(lf.lfFaceName, pcsFontName);
+ }
+ return RetrieveSpecificFont(lf);
+}
+#endif // _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
+
+CPDF_Font* CPDF_InterForm::AddStandardFont(CPDF_Document* pDocument,
+ CFX_ByteString csFontName) {
+ if (!pDocument || csFontName.IsEmpty())
+ return nullptr;
+
+ if (csFontName == "ZapfDingbats")
+ return pDocument->AddStandardFont(csFontName.c_str(), nullptr);
+
+ CPDF_FontEncoding encoding(PDFFONT_ENCODING_WINANSI);
+ return pDocument->AddStandardFont(csFontName.c_str(), &encoding);
+}
+
+CFX_ByteString CPDF_InterForm::GetNativeFont(uint8_t charSet, void* pLogFont) {
+ CFX_ByteString csFontName;
+#if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
+ LOGFONTA lf;
+ FX_BOOL bRet;
+ if (charSet == ANSI_CHARSET) {
+ csFontName = "Helvetica";
+ return csFontName;
+ }
+ bRet = FALSE;
+ if (charSet == SHIFTJIS_CHARSET) {
+ bRet = RetrieveSpecificFont(charSet, DEFAULT_PITCH | FF_DONTCARE,
+ "MS Mincho", lf);
+ } else if (charSet == GB2312_CHARSET) {
+ bRet = RetrieveSpecificFont(charSet, DEFAULT_PITCH | FF_DONTCARE, "SimSun",
+ lf);
+ } else if (charSet == CHINESEBIG5_CHARSET) {
+ bRet = RetrieveSpecificFont(charSet, DEFAULT_PITCH | FF_DONTCARE, "MingLiU",
+ lf);
+ }
+ if (!bRet) {
+ bRet = RetrieveSpecificFont(charSet, DEFAULT_PITCH | FF_DONTCARE,
+ "Arial Unicode MS", lf);
+ }
+ if (!bRet) {
+ bRet = RetrieveSpecificFont(charSet, DEFAULT_PITCH | FF_DONTCARE,
+ "Microsoft Sans Serif", lf);
+ }
+ if (!bRet) {
+ bRet = RetrieveSpecificFont(charSet, DEFAULT_PITCH | FF_DONTCARE, NULL, lf);
+ }
+ if (bRet) {
+ if (pLogFont) {
+ memcpy(pLogFont, &lf, sizeof(LOGFONTA));
+ }
+ csFontName = lf.lfFaceName;
+ return csFontName;
+ }
+#endif
+ return csFontName;
+}
+CFX_ByteString CPDF_InterForm::GetNativeFont(void* pLogFont) {
+#if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
+ uint8_t charSet = GetNativeCharSet();
+ return GetNativeFont(charSet, pLogFont);
+#else
+ return CFX_ByteString();
+#endif
+}
+uint8_t CPDF_InterForm::GetNativeCharSet() {
+#if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
+ uint8_t charSet = ANSI_CHARSET;
+ UINT iCodePage = ::GetACP();
+ switch (iCodePage) {
+ case 932:
+ charSet = SHIFTJIS_CHARSET;
+ break;
+ case 936:
+ charSet = GB2312_CHARSET;
+ break;
+ case 950:
+ charSet = CHINESEBIG5_CHARSET;
+ break;
+ case 1252:
+ charSet = ANSI_CHARSET;
+ break;
+ case 874:
+ charSet = THAI_CHARSET;
+ break;
+ case 949:
+ charSet = HANGUL_CHARSET;
+ break;
+ case 1200:
+ charSet = ANSI_CHARSET;
+ break;
+ case 1250:
+ charSet = EASTEUROPE_CHARSET;
+ break;
+ case 1251:
+ charSet = RUSSIAN_CHARSET;
+ break;
+ case 1253:
+ charSet = GREEK_CHARSET;
+ break;
+ case 1254:
+ charSet = TURKISH_CHARSET;
+ break;
+ case 1255:
+ charSet = HEBREW_CHARSET;
+ break;
+ case 1256:
+ charSet = ARABIC_CHARSET;
+ break;
+ case 1257:
+ charSet = BALTIC_CHARSET;
+ break;
+ case 1258:
+ charSet = VIETNAMESE_CHARSET;
+ break;
+ case 1361:
+ charSet = JOHAB_CHARSET;
+ break;
+ }
+ return charSet;
+#else
+ return 0;
+#endif
+}
+
+CPDF_Font* CPDF_InterForm::AddNativeFont(uint8_t charSet,
+ CPDF_Document* pDocument) {
+ if (!pDocument)
+ return nullptr;
+
+#if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
+ LOGFONTA lf;
+ CFX_ByteString csFontName = GetNativeFont(charSet, &lf);
+ if (!csFontName.IsEmpty()) {
+ if (csFontName == "Helvetica")
+ return AddStandardFont(pDocument, csFontName);
+ return pDocument->AddWindowsFont(&lf, FALSE, TRUE);
+ }
+#endif
+ return nullptr;
+}
+
+CPDF_Font* CPDF_InterForm::AddNativeFont(CPDF_Document* pDocument) {
+ return pDocument ? AddNativeFont(GetNativeCharSet(), pDocument) : nullptr;
+}
+
+FX_BOOL CPDF_InterForm::ValidateFieldName(
+ CFX_WideString& csNewFieldName,
+ int iType,
+ const CPDF_FormField* pExcludedField,
+ const CPDF_FormControl* pExcludedControl) {
+ if (csNewFieldName.IsEmpty()) {
+ return FALSE;
+ }
+ int iPos = 0;
+ int iLength = csNewFieldName.GetLength();
+ CFX_WideString csSub;
+ while (TRUE) {
+ while (iPos < iLength &&
+ (csNewFieldName[iPos] == L'.' || csNewFieldName[iPos] == L' ')) {
+ iPos++;
+ }
+ if (iPos < iLength && !csSub.IsEmpty()) {
+ csSub += L'.';
+ }
+ while (iPos < iLength && csNewFieldName[iPos] != L'.') {
+ csSub += csNewFieldName[iPos++];
+ }
+ for (int i = csSub.GetLength() - 1; i > -1; i--) {
+ if (csSub[i] == L' ' || csSub[i] == L'.') {
+ csSub.SetAt(i, L'\0');
+ } else {
+ break;
+ }
+ }
+ FX_DWORD dwCount = m_pFieldTree->m_Root.CountFields();
+ for (FX_DWORD m = 0; m < dwCount; m++) {
+ CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(m);
+ if (!pField) {
+ continue;
+ }
+ if (pField == pExcludedField) {
+ if (pExcludedControl) {
+ if (pField->CountControls() < 2) {
+ continue;
+ }
+ } else {
+ continue;
+ }
+ }
+ CFX_WideString csFullName = pField->GetFullName();
+ int iRet = CompareFieldName(csSub, csFullName);
+ if (iRet == 1) {
+ if (pField->GetFieldType() != iType) {
+ return FALSE;
+ }
+ } else if (iRet == 2 && csSub == csNewFieldName) {
+ if (csFullName[iPos] == L'.') {
+ return FALSE;
+ }
+ } else if (iRet == 3 && csSub == csNewFieldName) {
+ if (csNewFieldName[csFullName.GetLength()] == L'.') {
+ return FALSE;
+ }
+ }
+ }
+ if (iPos >= iLength) {
+ break;
+ }
+ }
+ if (csSub.IsEmpty()) {
+ return FALSE;
+ }
+ csNewFieldName = csSub;
+ return TRUE;
+}
+FX_BOOL CPDF_InterForm::ValidateFieldName(CFX_WideString& csNewFieldName,
+ int iType) {
+ return ValidateFieldName(csNewFieldName, iType, NULL, NULL);
+}
+FX_BOOL CPDF_InterForm::ValidateFieldName(const CPDF_FormField* pField,
+ CFX_WideString& csNewFieldName) {
+ return pField && !csNewFieldName.IsEmpty() &&
+ ValidateFieldName(csNewFieldName,
+ ((CPDF_FormField*)pField)->GetFieldType(), pField,
+ NULL);
+}
+FX_BOOL CPDF_InterForm::ValidateFieldName(const CPDF_FormControl* pControl,
+ CFX_WideString& csNewFieldName) {
+ if (!pControl || csNewFieldName.IsEmpty()) {
+ return FALSE;
+ }
+ CPDF_FormField* pField = ((CPDF_FormControl*)pControl)->GetField();
+ return ValidateFieldName(csNewFieldName, pField->GetFieldType(), pField,
+ pControl);
+}
+int CPDF_InterForm::CompareFieldName(const CFX_ByteString& name1,
+ const CFX_ByteString& name2) {
+ const FX_CHAR* ptr1 = name1;
+ const FX_CHAR* ptr2 = name2;
+ if (name1.GetLength() == name2.GetLength()) {
+ return name1 == name2 ? 1 : 0;
+ }
+ int i = 0;
+ while (ptr1[i] == ptr2[i]) {
+ i++;
+ }
+ if (i == name1.GetLength()) {
+ return 2;
+ }
+ if (i == name2.GetLength()) {
+ return 3;
+ }
+ return 0;
+}
+int CPDF_InterForm::CompareFieldName(const CFX_WideString& name1,
+ const CFX_WideString& name2) {
+ const FX_WCHAR* ptr1 = name1.c_str();
+ const FX_WCHAR* ptr2 = name2.c_str();
+ if (name1.GetLength() == name2.GetLength()) {
+ return name1 == name2 ? 1 : 0;
+ }
+ int i = 0;
+ while (ptr1[i] == ptr2[i]) {
+ i++;
+ }
+ if (i == name1.GetLength()) {
+ return 2;
+ }
+ if (i == name2.GetLength()) {
+ return 3;
+ }
+ return 0;
+}
+FX_DWORD CPDF_InterForm::CountFields(const CFX_WideString& csFieldName) {
+ if (csFieldName.IsEmpty()) {
+ return (FX_DWORD)m_pFieldTree->m_Root.CountFields();
+ }
+ CFieldTree::_Node* pNode = m_pFieldTree->FindNode(csFieldName);
+ return pNode ? pNode->CountFields() : 0;
+}
+CPDF_FormField* CPDF_InterForm::GetField(FX_DWORD index,
+ const CFX_WideString& csFieldName) {
+ if (csFieldName == L"") {
+ return m_pFieldTree->m_Root.GetField(index);
+ }
+ CFieldTree::_Node* pNode = m_pFieldTree->FindNode(csFieldName);
+ return pNode ? pNode->GetField(index) : nullptr;
+}
+
+CPDF_FormField* CPDF_InterForm::GetFieldByDict(
+ CPDF_Dictionary* pFieldDict) const {
+ if (!pFieldDict) {
+ return NULL;
+ }
+ CFX_WideString csWName = GetFullName(pFieldDict);
+ return m_pFieldTree->GetField(csWName);
+}
+
+CPDF_FormControl* CPDF_InterForm::GetControlAtPoint(CPDF_Page* pPage,
+ FX_FLOAT pdf_x,
+ FX_FLOAT pdf_y,
+ int* z_order) const {
+ CPDF_Array* pAnnotList = pPage->m_pFormDict->GetArrayBy("Annots");
+ if (!pAnnotList)
+ return nullptr;
+
+ for (FX_DWORD i = pAnnotList->GetCount(); i > 0; --i) {
+ FX_DWORD annot_index = i - 1;
+ CPDF_Dictionary* pAnnot = pAnnotList->GetDictAt(annot_index);
+ if (!pAnnot)
+ continue;
+
+ const auto it = m_ControlMap.find(pAnnot);
+ if (it == m_ControlMap.end())
+ continue;
+
+ CPDF_FormControl* pControl = it->second;
+ CFX_FloatRect rect = pControl->GetRect();
+ if (!rect.Contains(pdf_x, pdf_y))
+ continue;
+
+ if (z_order)
+ *z_order = annot_index;
+ return pControl;
+ }
+ return nullptr;
+}
+
+CPDF_FormControl* CPDF_InterForm::GetControlByDict(
+ const CPDF_Dictionary* pWidgetDict) const {
+ const auto it = m_ControlMap.find(pWidgetDict);
+ return it != m_ControlMap.end() ? it->second : nullptr;
+}
+
+FX_BOOL CPDF_InterForm::NeedConstructAP() {
+ return m_pFormDict && m_pFormDict->GetBooleanBy("NeedAppearances");
+}
+void CPDF_InterForm::NeedConstructAP(FX_BOOL bNeedAP) {
+ if (!m_pFormDict) {
+ InitInterFormDict(m_pFormDict, m_pDocument);
+ }
+ m_pFormDict->SetAtBoolean("NeedAppearances", bNeedAP);
+ m_bGenerateAP = bNeedAP;
+}
+int CPDF_InterForm::CountFieldsInCalculationOrder() {
+ if (!m_pFormDict) {
+ return 0;
+ }
+ CPDF_Array* pArray = m_pFormDict->GetArrayBy("CO");
+ return pArray ? pArray->GetCount() : 0;
+}
+CPDF_FormField* CPDF_InterForm::GetFieldInCalculationOrder(int index) {
+ if (!m_pFormDict || index < 0) {
+ return NULL;
+ }
+ CPDF_Array* pArray = m_pFormDict->GetArrayBy("CO");
+ if (!pArray) {
+ return NULL;
+ }
+ if (CPDF_Dictionary* pElement =
+ ToDictionary(pArray->GetElementValue(index))) {
+ return GetFieldByDict(pElement);
+ }
+ return NULL;
+}
+int CPDF_InterForm::FindFieldInCalculationOrder(const CPDF_FormField* pField) {
+ if (!m_pFormDict || !pField) {
+ return -1;
+ }
+ CPDF_Array* pArray = m_pFormDict->GetArrayBy("CO");
+ if (!pArray) {
+ return -1;
+ }
+ for (FX_DWORD i = 0; i < pArray->GetCount(); i++) {
+ CPDF_Object* pElement = pArray->GetElementValue(i);
+ if (pElement == pField->m_pDict) {
+ return i;
+ }
+ }
+ return -1;
+}
+FX_DWORD CPDF_InterForm::CountFormFonts() {
+ return CountInterFormFonts(m_pFormDict);
+}
+CPDF_Font* CPDF_InterForm::GetFormFont(FX_DWORD index,
+ CFX_ByteString& csNameTag) {
+ return GetInterFormFont(m_pFormDict, m_pDocument, index, csNameTag);
+}
+CPDF_Font* CPDF_InterForm::GetFormFont(CFX_ByteString csNameTag) {
+ return GetInterFormFont(m_pFormDict, m_pDocument, csNameTag);
+}
+CPDF_Font* CPDF_InterForm::GetFormFont(CFX_ByteString csFontName,
+ CFX_ByteString& csNameTag) {
+ return GetInterFormFont(m_pFormDict, m_pDocument, csFontName, csNameTag);
+}
+CPDF_Font* CPDF_InterForm::GetNativeFormFont(uint8_t charSet,
+ CFX_ByteString& csNameTag) {
+ return GetNativeInterFormFont(m_pFormDict, m_pDocument, charSet, csNameTag);
+}
+CPDF_Font* CPDF_InterForm::GetNativeFormFont(CFX_ByteString& csNameTag) {
+ return GetNativeInterFormFont(m_pFormDict, m_pDocument, csNameTag);
+}
+FX_BOOL CPDF_InterForm::FindFormFont(const CPDF_Font* pFont,
+ CFX_ByteString& csNameTag) {
+ return FindInterFormFont(m_pFormDict, pFont, csNameTag);
+}
+FX_BOOL CPDF_InterForm::FindFormFont(CFX_ByteString csFontName,
+ CPDF_Font*& pFont,
+ CFX_ByteString& csNameTag) {
+ return FindInterFormFont(m_pFormDict, m_pDocument, csFontName, pFont,
+ csNameTag);
+}
+void CPDF_InterForm::AddFormFont(const CPDF_Font* pFont,
+ CFX_ByteString& csNameTag) {
+ AddInterFormFont(m_pFormDict, m_pDocument, pFont, csNameTag);
+ m_bUpdated = TRUE;
+}
+CPDF_Font* CPDF_InterForm::AddNativeFormFont(uint8_t charSet,
+ CFX_ByteString& csNameTag) {
+ m_bUpdated = TRUE;
+ return AddNativeInterFormFont(m_pFormDict, m_pDocument, charSet, csNameTag);
+}
+CPDF_Font* CPDF_InterForm::AddNativeFormFont(CFX_ByteString& csNameTag) {
+ m_bUpdated = TRUE;
+ return AddNativeInterFormFont(m_pFormDict, m_pDocument, csNameTag);
+}
+void CPDF_InterForm::RemoveFormFont(const CPDF_Font* pFont) {
+ m_bUpdated = TRUE;
+ RemoveInterFormFont(m_pFormDict, pFont);
+}
+void CPDF_InterForm::RemoveFormFont(CFX_ByteString csNameTag) {
+ m_bUpdated = TRUE;
+ RemoveInterFormFont(m_pFormDict, csNameTag);
+}
+
+CPDF_DefaultAppearance CPDF_InterForm::GetDefaultAppearance() {
+ if (!m_pFormDict)
+ return CPDF_DefaultAppearance();
+ return CPDF_DefaultAppearance(m_pFormDict->GetStringBy("DA"));
+}
+
+CPDF_Font* CPDF_InterForm::GetDefaultFormFont() {
+ return GetDefaultInterFormFont(m_pFormDict, m_pDocument);
+}
+int CPDF_InterForm::GetFormAlignment() {
+ return m_pFormDict ? m_pFormDict->GetIntegerBy("Q", 0) : 0;
+}
+
+bool CPDF_InterForm::ResetForm(const std::vector<CPDF_FormField*>& fields,
+ bool bIncludeOrExclude,
+ bool bNotify) {
+ if (bNotify && m_pFormNotify && m_pFormNotify->BeforeFormReset(this) < 0)
+ return false;
+
+ int nCount = m_pFieldTree->m_Root.CountFields();
+ for (int i = 0; i < nCount; ++i) {
+ CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(i);
+ if (!pField)
+ continue;
+
+ if (bIncludeOrExclude == pdfium::ContainsValue(fields, pField))
+ pField->ResetField(bNotify);
+ }
+ if (bNotify && m_pFormNotify)
+ m_pFormNotify->AfterFormReset(this);
+ return true;
+}
+
+bool CPDF_InterForm::ResetForm(bool bNotify) {
+ if (bNotify && m_pFormNotify && m_pFormNotify->BeforeFormReset(this) < 0)
+ return false;
+
+ int nCount = m_pFieldTree->m_Root.CountFields();
+ for (int i = 0; i < nCount; ++i) {
+ CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(i);
+ if (!pField)
+ continue;
+
+ pField->ResetField(bNotify);
+ }
+ if (bNotify && m_pFormNotify)
+ m_pFormNotify->AfterFormReset(this);
+ return true;
+}
+
+void CPDF_InterForm::LoadField(CPDF_Dictionary* pFieldDict, int nLevel) {
+ if (nLevel > nMaxRecursion) {
+ return;
+ }
+ if (!pFieldDict) {
+ return;
+ }
+ FX_DWORD dwParentObjNum = pFieldDict->GetObjNum();
+ CPDF_Array* pKids = pFieldDict->GetArrayBy("Kids");
+ if (!pKids) {
+ AddTerminalField(pFieldDict);
+ return;
+ }
+ CPDF_Dictionary* pFirstKid = pKids->GetDictAt(0);
+ if (!pFirstKid) {
+ return;
+ }
+ if (pFirstKid->KeyExist("T") || pFirstKid->KeyExist("Kids")) {
+ for (FX_DWORD i = 0; i < pKids->GetCount(); i++) {
+ CPDF_Dictionary* pChildDict = pKids->GetDictAt(i);
+ if (pChildDict) {
+ if (pChildDict->GetObjNum() != dwParentObjNum) {
+ LoadField(pChildDict, nLevel + 1);
+ }
+ }
+ }
+ } else {
+ AddTerminalField(pFieldDict);
+ }
+}
+FX_BOOL CPDF_InterForm::HasXFAForm() const {
+ return m_pFormDict && m_pFormDict->GetArrayBy("XFA");
+}
+void CPDF_InterForm::FixPageFields(const CPDF_Page* pPage) {
+ CPDF_Dictionary* pPageDict = pPage->m_pFormDict;
+ if (!pPageDict) {
+ return;
+ }
+ CPDF_Array* pAnnots = pPageDict->GetArrayBy("Annots");
+ if (!pAnnots) {
+ return;
+ }
+ int iAnnotCount = pAnnots->GetCount();
+ for (int i = 0; i < iAnnotCount; i++) {
+ CPDF_Dictionary* pAnnot = pAnnots->GetDictAt(i);
+ if (pAnnot && pAnnot->GetStringBy("Subtype") == "Widget") {
+ LoadField(pAnnot);
+ }
+ }
+}
+CPDF_FormField* CPDF_InterForm::AddTerminalField(CPDF_Dictionary* pFieldDict) {
+ if (!pFieldDict->KeyExist("T")) {
+ return NULL;
+ }
+ CPDF_Dictionary* pDict = pFieldDict;
+ CFX_WideString csWName = GetFullName(pFieldDict);
+ if (csWName.IsEmpty()) {
+ return NULL;
+ }
+ CPDF_FormField* pField = NULL;
+ pField = m_pFieldTree->GetField(csWName);
+ if (!pField) {
+ CPDF_Dictionary* pParent = pFieldDict;
+ if (!pFieldDict->KeyExist("T") &&
+ pFieldDict->GetStringBy("Subtype") == "Widget") {
+ pParent = pFieldDict->GetDictBy("Parent");
+ if (!pParent) {
+ pParent = pFieldDict;
+ }
+ }
+ if (pParent && pParent != pFieldDict && !pParent->KeyExist("FT")) {
+ if (pFieldDict->KeyExist("FT")) {
+ CPDF_Object* pFTValue = pFieldDict->GetElementValue("FT");
+ if (pFTValue) {
+ pParent->SetAt("FT", pFTValue->Clone());
+ }
+ }
+ if (pFieldDict->KeyExist("Ff")) {
+ CPDF_Object* pFfValue = pFieldDict->GetElementValue("Ff");
+ if (pFfValue) {
+ pParent->SetAt("Ff", pFfValue->Clone());
+ }
+ }
+ }
+ pField = new CPDF_FormField(this, pParent);
+ CPDF_Object* pTObj = pDict->GetElement("T");
+ if (ToReference(pTObj)) {
+ CPDF_Object* pClone = pTObj->Clone(TRUE);
+ if (pClone)
+ pDict->SetAt("T", pClone);
+ else
+ pDict->SetAtName("T", "");
+ }
+ m_pFieldTree->SetField(csWName, pField);
+ }
+ CPDF_Array* pKids = pFieldDict->GetArrayBy("Kids");
+ if (!pKids) {
+ if (pFieldDict->GetStringBy("Subtype") == "Widget") {
+ AddControl(pField, pFieldDict);
+ }
+ } else {
+ for (FX_DWORD i = 0; i < pKids->GetCount(); i++) {
+ CPDF_Dictionary* pKid = pKids->GetDictAt(i);
+ if (!pKid) {
+ continue;
+ }
+ if (pKid->GetStringBy("Subtype") != "Widget") {
+ continue;
+ }
+ AddControl(pField, pKid);
+ }
+ }
+ return pField;
+}
+CPDF_FormControl* CPDF_InterForm::AddControl(const CPDF_FormField* pField,
+ CPDF_Dictionary* pWidgetDict) {
+ const auto it = m_ControlMap.find(pWidgetDict);
+ if (it != m_ControlMap.end())
+ return it->second;
+
+ CPDF_FormControl* pControl =
+ new CPDF_FormControl((CPDF_FormField*)pField, pWidgetDict);
+ m_ControlMap[pWidgetDict] = pControl;
+ ((CPDF_FormField*)pField)->m_ControlList.Add(pControl);
+ return pControl;
+}
+
+CPDF_FormField* CPDF_InterForm::CheckRequiredFields(
+ const std::vector<CPDF_FormField*>* fields,
+ bool bIncludeOrExclude) const {
+ int nCount = m_pFieldTree->m_Root.CountFields();
+ for (int i = 0; i < nCount; ++i) {
+ CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(i);
+ if (!pField)
+ continue;
+
+ int32_t iType = pField->GetType();
+ if (iType == CPDF_FormField::PushButton ||
+ iType == CPDF_FormField::CheckBox || iType == CPDF_FormField::ListBox) {
+ continue;
+ }
+ FX_DWORD dwFlags = pField->GetFieldFlags();
+ // TODO(thestig): Look up these magic numbers and add constants for them.
+ if (dwFlags & 0x04)
+ continue;
+
+ bool bFind = true;
+ if (fields)
+ bFind = pdfium::ContainsValue(*fields, pField);
+ if (bIncludeOrExclude == bFind) {
+ CPDF_Dictionary* pFieldDict = pField->m_pDict;
+ if ((dwFlags & 0x02) != 0 && pFieldDict->GetStringBy("V").IsEmpty()) {
+ return pField;
+ }
+ }
+ }
+ return nullptr;
+}
+
+CFDF_Document* CPDF_InterForm::ExportToFDF(const CFX_WideStringC& pdf_path,
+ bool bSimpleFileSpec) const {
+ std::vector<CPDF_FormField*> fields;
+ int nCount = m_pFieldTree->m_Root.CountFields();
+ for (int i = 0; i < nCount; ++i)
+ fields.push_back(m_pFieldTree->m_Root.GetField(i));
+ return ExportToFDF(pdf_path, fields, true, bSimpleFileSpec);
+}
+
+CFDF_Document* CPDF_InterForm::ExportToFDF(
+ const CFX_WideStringC& pdf_path,
+ const std::vector<CPDF_FormField*>& fields,
+ bool bIncludeOrExclude,
+ bool bSimpleFileSpec) const {
+ CFDF_Document* pDoc = CFDF_Document::CreateNewDoc();
+ if (!pDoc) {
+ return NULL;
+ }
+ CPDF_Dictionary* pMainDict = pDoc->GetRoot()->GetDictBy("FDF");
+ if (!pdf_path.IsEmpty()) {
+ if (bSimpleFileSpec) {
+ CFX_WideString wsFilePath = CPDF_FileSpec::EncodeFileName(pdf_path);
+ pMainDict->SetAtString("F", CFX_ByteString::FromUnicode(wsFilePath));
+ pMainDict->SetAtString("UF", PDF_EncodeText(wsFilePath));
+ } else {
+ CPDF_FileSpec filespec;
+ filespec.SetFileName(pdf_path);
+ pMainDict->SetAt("F", filespec.GetObj());
+ }
+ }
+ CPDF_Array* pFields = new CPDF_Array;
+ pMainDict->SetAt("Fields", pFields);
+ int nCount = m_pFieldTree->m_Root.CountFields();
+ for (int i = 0; i < nCount; i++) {
+ CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(i);
+ if (!pField || pField->GetType() == CPDF_FormField::PushButton) {
+ continue;
+ }
+ FX_DWORD dwFlags = pField->GetFieldFlags();
+ if (dwFlags & 0x04)
+ continue;
+
+ if (bIncludeOrExclude == pdfium::ContainsValue(fields, pField)) {
+ if ((dwFlags & 0x02) != 0 && pField->m_pDict->GetStringBy("V").IsEmpty())
+ continue;
+
+ CFX_WideString fullname = GetFullName(pField->GetFieldDict());
+ CPDF_Dictionary* pFieldDict = new CPDF_Dictionary;
+ pFieldDict->SetAt("T", new CPDF_String(fullname));
+ if (pField->GetType() == CPDF_FormField::CheckBox ||
+ pField->GetType() == CPDF_FormField::RadioButton) {
+ CFX_WideString csExport = pField->GetCheckValue(FALSE);
+ CFX_ByteString csBExport = PDF_EncodeText(csExport);
+ CPDF_Object* pOpt = FPDF_GetFieldAttr(pField->m_pDict, "Opt");
+ if (pOpt)
+ pFieldDict->SetAtString("V", csBExport);
+ else
+ pFieldDict->SetAtName("V", csBExport);
+ } else {
+ CPDF_Object* pV = FPDF_GetFieldAttr(pField->m_pDict, "V");
+ if (pV)
+ pFieldDict->SetAt("V", pV->Clone(TRUE));
+ }
+ pFields->Add(pFieldDict);
+ }
+ }
+ return pDoc;
+}
+
+void CPDF_InterForm::FDF_ImportField(CPDF_Dictionary* pFieldDict,
+ const CFX_WideString& parent_name,
+ FX_BOOL bNotify,
+ int nLevel) {
+ CFX_WideString name;
+ if (!parent_name.IsEmpty()) {
+ name = parent_name + L".";
+ }
+ name += pFieldDict->GetUnicodeTextBy("T");
+ CPDF_Array* pKids = pFieldDict->GetArrayBy("Kids");
+ if (pKids) {
+ for (FX_DWORD i = 0; i < pKids->GetCount(); i++) {
+ CPDF_Dictionary* pKid = pKids->GetDictAt(i);
+ if (!pKid) {
+ continue;
+ }
+ if (nLevel <= nMaxRecursion) {
+ FDF_ImportField(pKid, name, bNotify, nLevel + 1);
+ }
+ }
+ return;
+ }
+ if (!pFieldDict->KeyExist("V")) {
+ return;
+ }
+ CPDF_FormField* pField = m_pFieldTree->GetField(name);
+ if (!pField) {
+ return;
+ }
+ CFX_WideString csWValue =
+ FPDFDOC_FDF_GetFieldValue(*pFieldDict, m_bsEncoding);
+ int iType = pField->GetFieldType();
+ if (bNotify && m_pFormNotify) {
+ int iRet = 0;
+ if (iType == FIELDTYPE_LISTBOX) {
+ iRet = m_pFormNotify->BeforeSelectionChange(pField, csWValue);
+ } else if (iType == FIELDTYPE_COMBOBOX || iType == FIELDTYPE_TEXTFIELD) {
+ iRet = m_pFormNotify->BeforeValueChange(pField, csWValue);
+ }
+ if (iRet < 0) {
+ return;
+ }
+ }
+ pField->SetValue(csWValue);
+ CPDF_FormField::Type eType = pField->GetType();
+ if ((eType == CPDF_FormField::ListBox || eType == CPDF_FormField::ComboBox) &&
+ pFieldDict->KeyExist("Opt")) {
+ pField->m_pDict->SetAt("Opt",
+ pFieldDict->GetElementValue("Opt")->Clone(TRUE));
+ }
+ if (bNotify && m_pFormNotify) {
+ if (iType == FIELDTYPE_CHECKBOX || iType == FIELDTYPE_RADIOBUTTON) {
+ m_pFormNotify->AfterCheckedStatusChange(pField);
+ } else if (iType == FIELDTYPE_LISTBOX) {
+ m_pFormNotify->AfterSelectionChange(pField);
+ } else if (iType == FIELDTYPE_COMBOBOX || iType == FIELDTYPE_TEXTFIELD) {
+ m_pFormNotify->AfterValueChange(pField);
+ }
+ }
+ if (CPDF_InterForm::m_bUpdateAP) {
+ pField->UpdateAP(NULL);
+ }
+}
+FX_BOOL CPDF_InterForm::ImportFromFDF(const CFDF_Document* pFDF,
+ FX_BOOL bNotify) {
+ if (!pFDF) {
+ return FALSE;
+ }
+ CPDF_Dictionary* pMainDict = pFDF->GetRoot()->GetDictBy("FDF");
+ if (!pMainDict) {
+ return FALSE;
+ }
+ CPDF_Array* pFields = pMainDict->GetArrayBy("Fields");
+ if (!pFields) {
+ return FALSE;
+ }
+ m_bsEncoding = pMainDict->GetStringBy("Encoding");
+ if (bNotify && m_pFormNotify) {
+ int iRet = m_pFormNotify->BeforeFormImportData(this);
+ if (iRet < 0) {
+ return FALSE;
+ }
+ }
+ for (FX_DWORD i = 0; i < pFields->GetCount(); i++) {
+ CPDF_Dictionary* pField = pFields->GetDictAt(i);
+ if (!pField) {
+ continue;
+ }
+ FDF_ImportField(pField, L"", bNotify);
+ }
+ if (bNotify && m_pFormNotify) {
+ m_pFormNotify->AfterFormImportData(this);
+ }
+ return TRUE;
+}
+void CPDF_InterForm::SetFormNotify(const CPDF_FormNotify* pNotify) {
+ m_pFormNotify = (CPDF_FormNotify*)pNotify;
+}