Fix windows-specific usage of CFX_WideStr::operator LPCWSTR().
[pdfium.git] / core / src / fpdfdoc / doc_form.cpp
1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4  
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6
7 #include "../../include/fpdfdoc/fpdf_doc.h"
8 #include "../../include/fxcrt/fx_xml.h"
9 CFX_WideString  GetFullName(CPDF_Dictionary* pFieldDict);
10 void                    InitInterFormDict(CPDF_Dictionary*& pFormDict, CPDF_Document* pDocument);
11 FX_DWORD                CountInterFormFonts(CPDF_Dictionary* pFormDict);
12 CPDF_Font*              GetInterFormFont(CPDF_Dictionary* pFormDict, CPDF_Document* pDocument, FX_DWORD index, CFX_ByteString& csNameTag);
13 CPDF_Font*              GetInterFormFont(CPDF_Dictionary* pFormDict, CPDF_Document* pDocument, CFX_ByteString csNameTag);
14 CPDF_Font*              GetInterFormFont(CPDF_Dictionary* pFormDict, CPDF_Document* pDocument, CFX_ByteString csFontName, CFX_ByteString& csNameTag);
15 CPDF_Font*              GetNativeInterFormFont(CPDF_Dictionary* pFormDict, CPDF_Document* pDocument, FX_BYTE charSet, CFX_ByteString& csNameTag);
16 CPDF_Font*              GetNativeInterFormFont(CPDF_Dictionary* pFormDict, CPDF_Document* pDocument, CFX_ByteString& csNameTag);
17 FX_BOOL                 FindInterFormFont(CPDF_Dictionary* pFormDict, const CPDF_Font* pFont, CFX_ByteString& csNameTag);
18 FX_BOOL                 FindInterFormFont(CPDF_Dictionary* pFormDict, CPDF_Document* pDocument, CFX_ByteString csFontName, CPDF_Font*& pFont, CFX_ByteString& csNameTag);
19 void                    AddInterFormFont(CPDF_Dictionary*& pFormDict, CPDF_Document* pDocument, const CPDF_Font* pFont, CFX_ByteString& csNameTag);
20 CPDF_Font*              AddNativeInterFormFont(CPDF_Dictionary*& pFormDict, CPDF_Document* pDocument, FX_BYTE charSet, CFX_ByteString& csNameTag);
21 CPDF_Font*              AddNativeInterFormFont(CPDF_Dictionary*& pFormDict, CPDF_Document* pDocument, CFX_ByteString& csNameTag);
22 void                    RemoveInterFormFont(CPDF_Dictionary* pFormDict, const CPDF_Font* pFont);
23 void                    RemoveInterFormFont(CPDF_Dictionary* pFormDict, CFX_ByteString csNameTag);
24 CPDF_Font*              GetDefaultInterFormFont(CPDF_Dictionary* pFormDict, CPDF_Document* pDocument);
25 void                    SetDefaultInterFormFont(CPDF_Dictionary*& pFormDict, CPDF_Document* pDocument, const CPDF_Font* pFont);
26 void                    SaveCheckedFieldStatus(CPDF_FormField* pField, CFX_ByteArray& statusArray);
27 FX_BOOL                 NeedPDFEncodeForFieldFullName(const CFX_WideString& csFieldName);
28 FX_BOOL                 NeedPDFEncodeForFieldTree(CPDF_Dictionary* pFieldDict, int nLevel = 0);
29 void                    EncodeFieldName(const CFX_WideString& csName, CFX_ByteString& csT);
30 void                    UpdateEncodeFieldName(CPDF_Dictionary* pFieldDict, int nLevel = 0);
31 const int nMaxRecursion = 32;
32 class _CFieldNameExtractor 
33 {
34 public:
35     _CFieldNameExtractor(const CFX_WideString& full_name)
36     {
37         m_pStart = full_name.c_str();
38         m_pEnd = m_pStart + full_name.GetLength();
39         m_pCur = m_pStart;
40     }
41     void GetNext(FX_LPCWSTR &pSubName, FX_STRSIZE& size)
42     {
43         pSubName = m_pCur;
44         while (m_pCur < m_pEnd && m_pCur[0] != L'.') {
45             m_pCur++;
46         }
47         size = (FX_STRSIZE)(m_pCur - pSubName);
48         if (m_pCur < m_pEnd && m_pCur[0] == L'.') {
49             m_pCur++;
50         }
51     }
52 protected:
53     FX_LPCWSTR m_pStart;
54     FX_LPCWSTR m_pEnd;
55     FX_LPCWSTR m_pCur;
56 };
57 class CFieldTree 
58 {
59 public:
60     struct _Node  {
61         _Node *parent;
62         CFX_PtrArray children;
63         CFX_WideString short_name;
64         CPDF_FormField *field_ptr;
65         int CountFields(int nLevel = 0)
66         {
67             if (nLevel > nMaxRecursion) {
68                 return 0;
69             }
70             if (field_ptr) {
71                 return 1;
72             }
73             int count = 0;
74             for (int i = 0; i < children.GetSize(); i ++) {
75                 count += ((_Node *)children.GetAt(i))->CountFields(nLevel + 1);
76             }
77             return count;
78         }
79         CPDF_FormField* GetField(int* fields_to_go)
80         {
81             if (field_ptr) {
82                 if (*fields_to_go == 0) {
83                     return field_ptr;
84                 }
85                 --*fields_to_go;
86                 return NULL;
87             }
88             for (int i = 0; i < children.GetSize(); i++) {
89                 _Node *pNode = (_Node *)children.GetAt(i);
90                 CPDF_FormField* pField = pNode->GetField(fields_to_go);
91                 if (pField) {
92                     return pField;
93                 }
94             }
95             return NULL;
96         }
97         CPDF_FormField* GetField(int index)
98         {
99             int fields_to_go = index;
100             return GetField(&fields_to_go);
101         }
102     };
103     CFieldTree();
104     ~CFieldTree();
105     void SetField(const CFX_WideString &full_name, CPDF_FormField *field_ptr);
106     CPDF_FormField *GetField(const CFX_WideString &full_name);
107     CPDF_FormField *RemoveField(const CFX_WideString &full_name);
108     void RemoveAll();
109     _Node *FindNode(const CFX_WideString &full_name);
110     _Node * AddChild(_Node *pParent, const CFX_WideString &short_name, CPDF_FormField *field_ptr);
111     void RemoveNode(_Node *pNode, int nLevel = 0);
112     _Node *_Lookup(_Node *pParent, const CFX_WideString &short_name);
113     _Node m_Root;
114 };
115 CFieldTree::CFieldTree()
116 {
117     m_Root.parent = NULL;
118     m_Root.field_ptr = NULL;
119 }
120 CFieldTree::~CFieldTree()
121 {
122     RemoveAll();
123 }
124 CFieldTree::_Node *CFieldTree::AddChild(_Node *pParent, const CFX_WideString &short_name, CPDF_FormField *field_ptr)
125 {
126     if (pParent == NULL) {
127         return NULL;
128     }
129     _Node* pNode = new _Node;
130     pNode->parent = pParent;
131     pNode->short_name = short_name;
132     pNode->field_ptr = field_ptr;
133     pParent->children.Add(pNode);
134     return pNode;
135 }
136 void CFieldTree::RemoveNode(_Node *pNode, int nLevel)
137 {
138     if (pNode == NULL) {
139         return ;
140     }
141     if (nLevel > nMaxRecursion) {
142         delete pNode;
143         return ;
144     }
145     CFX_PtrArray& ptr_array = pNode->children;
146     for (int i = 0; i < ptr_array.GetSize(); i ++) {
147         _Node *pChild = (_Node *)ptr_array[i];
148         RemoveNode(pChild, nLevel + 1);
149     }
150     delete pNode;
151 }
152 CFieldTree::_Node *CFieldTree::_Lookup(_Node *pParent, const CFX_WideString &short_name)
153 {
154     if (pParent == NULL) {
155         return NULL;
156     }
157     CFX_PtrArray& ptr_array = pParent->children;
158     for (int i = 0; i < ptr_array.GetSize(); i ++) {
159         _Node *pNode = (_Node *)ptr_array[i];
160         if (pNode->short_name.GetLength() == short_name.GetLength() &&
161                 FXSYS_memcmp32(pNode->short_name.c_str(), short_name.c_str(), short_name.GetLength()*sizeof(FX_WCHAR)) == 0) {
162             return pNode;
163         }
164     }
165     return NULL;
166 }
167 void CFieldTree::RemoveAll()
168 {
169     CFX_PtrArray& ptr_array = m_Root.children;
170     for (int i = 0; i < ptr_array.GetSize(); i ++) {
171         _Node *pNode = (_Node *)ptr_array[i];
172         RemoveNode(pNode);
173     }
174 }
175 void CFieldTree::SetField(const CFX_WideString &full_name, CPDF_FormField *field_ptr)
176 {
177     if (full_name == L"") {
178         return;
179     }
180     _CFieldNameExtractor name_extractor(full_name);
181     FX_LPCWSTR pName;
182     FX_STRSIZE nLength;
183     name_extractor.GetNext(pName, nLength);
184     _Node *pNode = &m_Root, *pLast = NULL;
185     while (nLength > 0) {
186         pLast = pNode;
187         CFX_WideString name = CFX_WideString(pName, nLength);
188         pNode = _Lookup(pLast, name);
189         if (pNode == NULL) {
190             pNode = AddChild(pLast, name, NULL);
191         }
192         name_extractor.GetNext(pName, nLength);
193     }
194     if (pNode != &m_Root) {
195         pNode->field_ptr = field_ptr;
196     }
197 }
198 CPDF_FormField *CFieldTree::GetField(const CFX_WideString &full_name)
199 {
200     if (full_name == L"") {
201         return NULL;
202     }
203     _CFieldNameExtractor name_extractor(full_name);
204     FX_LPCWSTR pName;
205     FX_STRSIZE nLength;
206     name_extractor.GetNext(pName, nLength);
207     _Node *pNode = &m_Root, *pLast = NULL;
208     while (nLength > 0 && pNode) {
209         pLast = pNode;
210         CFX_WideString name = CFX_WideString(pName, nLength);
211         pNode = _Lookup(pLast, name);
212         name_extractor.GetNext(pName, nLength);
213     }
214     return pNode ? pNode->field_ptr : NULL;
215 }
216 CPDF_FormField *CFieldTree::RemoveField(const CFX_WideString & full_name)
217 {
218     if (full_name == L"") {
219         return NULL;
220     }
221     _CFieldNameExtractor name_extractor(full_name);
222     FX_LPCWSTR pName;
223     FX_STRSIZE nLength;
224     name_extractor.GetNext(pName, nLength);
225     _Node *pNode = &m_Root, *pLast = NULL;
226     while (nLength > 0 && pNode) {
227         pLast = pNode;
228         CFX_WideString name = CFX_WideString(pName, nLength);
229         pNode = _Lookup(pLast, name);
230         name_extractor.GetNext(pName, nLength);
231     }
232     if (pNode && pNode != &m_Root) {
233         CFX_PtrArray& ptr_array = pLast->children;
234         for (int i = 0; i < ptr_array.GetSize(); i ++) {
235             if (pNode == (_Node *)ptr_array[i]) {
236                 ptr_array.RemoveAt(i);
237                 break;
238             }
239         }
240         CPDF_FormField *pField = pNode->field_ptr;
241         RemoveNode(pNode);
242         return pField;
243     }
244     return NULL;
245 }
246 CFieldTree::_Node *CFieldTree::FindNode(const CFX_WideString& full_name)
247 {
248     if (full_name == L"") {
249         return NULL;
250     }
251     _CFieldNameExtractor name_extractor(full_name);
252     FX_LPCWSTR pName;
253     FX_STRSIZE nLength;
254     name_extractor.GetNext(pName, nLength);
255     _Node *pNode = &m_Root, *pLast = NULL;
256     while (nLength > 0 && pNode) {
257         pLast = pNode;
258         CFX_WideString name = CFX_WideString(pName, nLength);
259         pNode = _Lookup(pLast, name);
260         name_extractor.GetNext(pName, nLength);
261     }
262     return pNode;
263 }
264 CPDF_InterForm::CPDF_InterForm(CPDF_Document* pDocument, FX_BOOL bGenerateAP) : CFX_PrivateData()
265 {
266     m_pDocument = pDocument;
267     m_bGenerateAP = bGenerateAP;
268     m_pFormNotify = NULL;
269     m_bUpdated = FALSE;
270     m_pFieldTree = new CFieldTree;
271     CPDF_Dictionary* pRoot = m_pDocument->GetRoot();
272     m_pFormDict = pRoot->GetDict("AcroForm");
273     if (m_pFormDict == NULL) {
274         return;
275     }
276     CPDF_Array* pFields = m_pFormDict->GetArray("Fields");
277     if (pFields == NULL) {
278         return;
279     }
280     int count = pFields->GetCount();
281     for (int i = 0; i < count; i ++) {
282         LoadField(pFields->GetDict(i));
283     }
284 }
285 CPDF_InterForm::~CPDF_InterForm()
286 {
287     FX_POSITION pos = m_ControlMap.GetStartPosition();
288     while (pos) {
289         FX_LPVOID key, value;
290         m_ControlMap.GetNextAssoc(pos, key, value);
291         delete (CPDF_FormControl*)value;
292     }
293     if (m_pFieldTree != NULL) {
294         int nCount = m_pFieldTree->m_Root.CountFields();
295         for (int i = 0; i < nCount; i++) {
296             CPDF_FormField *pField = m_pFieldTree->m_Root.GetField(i);
297             delete pField;
298         }
299         delete m_pFieldTree;
300     }
301 }
302 FX_BOOL CPDF_InterForm::m_bUpdateAP = TRUE;
303 FX_BOOL CPDF_InterForm::UpdatingAPEnabled()
304 {
305     return m_bUpdateAP;
306 }
307 void CPDF_InterForm::EnableUpdateAP(FX_BOOL bUpdateAP)
308 {
309     m_bUpdateAP = bUpdateAP;
310 }
311 CFX_ByteString CPDF_InterForm::GenerateNewResourceName(const CPDF_Dictionary* pResDict, FX_LPCSTR csType, int iMinLen, FX_LPCSTR csPrefix)
312 {
313     CFX_ByteString csStr = csPrefix;
314     CFX_ByteString csBType = csType;
315     if (csStr.IsEmpty()) {
316         if (csBType == "ExtGState") {
317             csStr = "GS";
318         } else if (csBType == "ColorSpace") {
319             csStr = "CS";
320         } else if (csBType == "Font") {
321             csStr = "ZiTi";
322         } else {
323             csStr = "Res";
324         }
325     }
326     CFX_ByteString csTmp = csStr;
327     int iCount = csStr.GetLength();
328     int m = 0;
329     if (iMinLen > 0) {
330         csTmp = "";
331         while (m < iMinLen && m < iCount) {
332             csTmp += csStr[m ++];
333         }
334         while (m < iMinLen) {
335             csTmp += '0' + m % 10;
336             m ++;
337         }
338     } else {
339         m = iCount;
340     }
341     if (pResDict == NULL) {
342         return csTmp;
343     }
344     CPDF_Dictionary* pDict = pResDict->GetDict(csType);
345     if (pDict == NULL) {
346         return csTmp;
347     }
348     int num = 0;
349     CFX_ByteString bsNum;
350     while (TRUE) {
351         if (!pDict->KeyExist(csTmp + bsNum)) {
352             return csTmp + bsNum;
353         }
354         if (m < iCount) {
355             csTmp += csStr[m ++];
356         } else {
357             bsNum.Format("%d", num++);
358         }
359         m ++;
360     }
361     return csTmp;
362 }
363 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
364 typedef struct _PDF_FONTDATA {
365     FX_BOOL             bFind;
366     LOGFONTA    lf;
367 } PDF_FONTDATA, FAR* LPDF_FONTDATA;
368 static int CALLBACK EnumFontFamExProc(  ENUMLOGFONTEXA *lpelfe,
369                                         NEWTEXTMETRICEX *lpntme,
370                                         DWORD FontType,
371                                         LPARAM lParam
372                                      )
373 {
374     if (FontType != 0x004 || strchr(lpelfe->elfLogFont.lfFaceName, '@') != NULL) {
375         return 1;
376     } else {
377         LPDF_FONTDATA pData = (LPDF_FONTDATA)lParam;
378         memcpy(&pData->lf, &lpelfe->elfLogFont, sizeof(LOGFONTA));
379         pData->bFind = TRUE;
380         return 0;
381     }
382 }
383 static FX_BOOL RetrieveSpecificFont(LOGFONTA& lf)
384 {
385     PDF_FONTDATA fd;
386     memset(&fd, 0, sizeof(PDF_FONTDATA));
387     HDC hDC = ::GetDC(NULL);
388     EnumFontFamiliesExA(hDC, &lf, (FONTENUMPROCA)EnumFontFamExProc, (LPARAM)&fd, 0);
389     ::ReleaseDC(NULL, hDC);
390     if (fd.bFind) {
391         memcpy(&lf, &fd.lf, sizeof(LOGFONTA));
392     }
393     return fd.bFind;
394 }
395 static FX_BOOL RetrieveSpecificFont(FX_BYTE charSet, FX_BYTE pitchAndFamily, LPCSTR pcsFontName, LOGFONTA& lf)
396 {
397     memset(&lf, 0, sizeof(LOGFONTA));
398     lf.lfCharSet = charSet;
399     lf.lfPitchAndFamily = pitchAndFamily;
400     if (pcsFontName != NULL) {
401         strcpy(lf.lfFaceName, pcsFontName);
402     }
403     return RetrieveSpecificFont(lf);
404 }
405 static FX_BOOL RetrieveStockFont(int iFontObject, FX_BYTE charSet, LOGFONTA& lf)
406 {
407     HFONT hFont = (HFONT)::GetStockObject(iFontObject);
408     if (hFont != NULL) {
409         memset(&lf, 0, sizeof(LOGFONTA));
410         int iRet = ::GetObject(hFont, sizeof(LOGFONTA), &lf);
411         if (iRet > 0 && (lf.lfCharSet == charSet || charSet == 255)) {
412             return RetrieveSpecificFont(lf);
413         }
414     }
415     return FALSE;
416 }
417 #endif
418 CPDF_Font* CPDF_InterForm::AddSystemDefaultFont(const CPDF_Document* pDocument)
419 {
420     if (pDocument == NULL) {
421         return NULL;
422     }
423     CPDF_Font* pFont = NULL;
424 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
425     LOGFONTA lf;
426     FX_BOOL bRet;
427     bRet = RetrieveStockFont(DEFAULT_GUI_FONT, 255, lf);
428     if (!bRet) {
429         bRet = RetrieveStockFont(SYSTEM_FONT, 255, lf);
430     }
431     if (bRet) {
432         pFont = ((CPDF_Document*)pDocument)->AddWindowsFont(&lf, FALSE, TRUE);
433     }
434 #endif
435     return pFont;
436 }
437 CPDF_Font* CPDF_InterForm::AddSystemFont(const CPDF_Document* pDocument, CFX_ByteString csFontName, FX_BYTE iCharSet)
438 {
439     if (pDocument == NULL || csFontName.IsEmpty()) {
440         return NULL;
441     }
442 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
443     if (iCharSet == 1) {
444         iCharSet = GetNativeCharSet();
445     }
446     HFONT hFont = ::CreateFontA(0, 0, 0, 0, 0, 0, 0, 0, iCharSet, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, csFontName.c_str());
447     if (hFont != NULL) {
448         LOGFONTA lf;
449         memset(&lf, 0, sizeof(LOGFONTA));
450         ::GetObjectA(hFont, sizeof(LOGFONTA), &lf);
451         ::DeleteObject(hFont);
452         if (strlen(lf.lfFaceName) > 0) {
453             return ((CPDF_Document*)pDocument)->AddWindowsFont(&lf, FALSE, TRUE);
454         }
455     }
456 #endif
457     return NULL;
458 }
459 CPDF_Font* CPDF_InterForm::AddSystemFont(const CPDF_Document* pDocument, CFX_WideString csFontName, FX_BYTE iCharSet)
460 {
461     if (pDocument == NULL || csFontName.IsEmpty()) {
462         return NULL;
463     }
464 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
465     if (iCharSet == 1) {
466         iCharSet = GetNativeCharSet();
467     }
468     HFONT hFont = ::CreateFontW(0, 0, 0, 0, 0, 0, 0, 0, iCharSet, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, csFontName.c_str());
469     if (hFont != NULL) {
470         LOGFONTA lf;
471         memset(&lf, 0, sizeof(LOGFONTA));
472         ::GetObject(hFont, sizeof(LOGFONTA), &lf);
473         ::DeleteObject(hFont);
474         if (strlen(lf.lfFaceName) > 0) {
475             return ((CPDF_Document*)pDocument)->AddWindowsFont(&lf, FALSE, TRUE);
476         }
477     }
478 #endif
479     return NULL;
480 }
481 CPDF_Font* CPDF_InterForm::AddStandardFont(const CPDF_Document* pDocument, CFX_ByteString csFontName)
482 {
483     if (pDocument == NULL || csFontName.IsEmpty()) {
484         return NULL;
485     }
486     CPDF_Font* pFont = NULL;
487     if (csFontName == "ZapfDingbats") {
488         pFont = ((CPDF_Document*)pDocument)->AddStandardFont(csFontName, NULL);
489     } else {
490         CPDF_FontEncoding encoding(PDFFONT_ENCODING_WINANSI);
491         pFont = ((CPDF_Document*)pDocument)->AddStandardFont(csFontName, &encoding);
492     }
493     return pFont;
494 }
495 CFX_ByteString CPDF_InterForm::GetNativeFont(FX_BYTE charSet, FX_LPVOID pLogFont)
496 {
497     CFX_ByteString csFontName;
498 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
499     LOGFONTA lf;
500     FX_BOOL bRet;
501     if (charSet == ANSI_CHARSET) {
502         csFontName = "Helvetica";
503         return csFontName;
504     }
505     bRet = FALSE;
506     if (charSet == SHIFTJIS_CHARSET) {
507         bRet = RetrieveSpecificFont(charSet, DEFAULT_PITCH | FF_DONTCARE, "MS Mincho", lf);
508     } else if (charSet == GB2312_CHARSET) {
509         bRet = RetrieveSpecificFont(charSet, DEFAULT_PITCH | FF_DONTCARE, "SimSun", lf);
510     } else if (charSet == CHINESEBIG5_CHARSET) {
511         bRet = RetrieveSpecificFont(charSet, DEFAULT_PITCH | FF_DONTCARE, "MingLiU", lf);
512     }
513     if (!bRet) {
514         bRet = RetrieveSpecificFont(charSet, DEFAULT_PITCH | FF_DONTCARE, "Arial Unicode MS", lf);
515     }
516     if (!bRet) {
517         bRet = RetrieveSpecificFont(charSet, DEFAULT_PITCH | FF_DONTCARE, "Microsoft Sans Serif", lf);
518     }
519     if (!bRet) {
520         bRet = RetrieveSpecificFont(charSet, DEFAULT_PITCH | FF_DONTCARE, NULL, lf);
521     }
522     if (bRet) {
523         if (pLogFont != NULL) {
524             memcpy(pLogFont, &lf, sizeof(LOGFONTA));
525         }
526         csFontName = lf.lfFaceName;
527         return csFontName;
528     }
529 #endif
530     return csFontName;
531 }
532 CFX_ByteString CPDF_InterForm::GetNativeFont(FX_LPVOID pLogFont)
533 {
534 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
535     FX_BYTE charSet = GetNativeCharSet();
536     return GetNativeFont(charSet, pLogFont);
537 #else
538     return CFX_ByteString();
539 #endif
540 }
541 FX_BYTE CPDF_InterForm::GetNativeCharSet()
542 {
543 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
544     FX_BYTE charSet = ANSI_CHARSET;
545     UINT iCodePage = ::GetACP();
546     switch (iCodePage) {
547         case 932:
548             charSet = SHIFTJIS_CHARSET;
549             break;
550         case 936:
551             charSet = GB2312_CHARSET;
552             break;
553         case 950:
554             charSet = CHINESEBIG5_CHARSET;
555             break;
556         case 1252:
557             charSet = ANSI_CHARSET;
558             break;
559         case 874:
560             charSet = THAI_CHARSET;
561             break;
562         case 949:
563             charSet = HANGUL_CHARSET;
564             break;
565         case 1200:
566             charSet = ANSI_CHARSET;
567             break;
568         case 1250:
569             charSet = EASTEUROPE_CHARSET;
570             break;
571         case 1251:
572             charSet = RUSSIAN_CHARSET;
573             break;
574         case 1253:
575             charSet = GREEK_CHARSET;
576             break;
577         case 1254:
578             charSet = TURKISH_CHARSET;
579             break;
580         case 1255:
581             charSet = HEBREW_CHARSET;
582             break;
583         case 1256:
584             charSet = ARABIC_CHARSET;
585             break;
586         case 1257:
587             charSet = BALTIC_CHARSET;
588             break;
589         case 1258:
590             charSet = VIETNAMESE_CHARSET;
591             break;
592         case 1361:
593             charSet = JOHAB_CHARSET;
594             break;
595     }
596     return charSet;
597 #else
598     return 0;
599 #endif
600 }
601 CPDF_Font* CPDF_InterForm::AddNativeFont(FX_BYTE charSet, const CPDF_Document* pDocument)
602 {
603     if (pDocument == NULL) {
604         return NULL;
605     }
606     CPDF_Font* pFont = NULL;
607 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
608     LOGFONTA lf;
609     CFX_ByteString csFontName = GetNativeFont(charSet, &lf);
610     if (!csFontName.IsEmpty()) {
611         if (csFontName == "Helvetica") {
612             pFont = AddStandardFont(pDocument, csFontName);
613         } else {
614             pFont = ((CPDF_Document*)pDocument)->AddWindowsFont(&lf, FALSE, TRUE);
615         }
616     }
617 #endif
618     return pFont;
619 }
620 CPDF_Font* CPDF_InterForm::AddNativeFont(const CPDF_Document* pDocument)
621 {
622     if (pDocument == NULL) {
623         return NULL;
624     }
625     CPDF_Font* pFont = NULL;
626     FX_BYTE charSet = GetNativeCharSet();
627     pFont = AddNativeFont(charSet, pDocument);
628     return pFont;
629 }
630 FX_BOOL CPDF_InterForm::ValidateFieldName(CFX_WideString& csNewFieldName, int iType, const CPDF_FormField* pExcludedField, const CPDF_FormControl* pExcludedControl)
631 {
632     if (csNewFieldName.IsEmpty()) {
633         return FALSE;
634     }
635     int iPos = 0;
636     int iLength = csNewFieldName.GetLength();
637     CFX_WideString csSub;
638     while (TRUE) {
639         while (iPos < iLength && (csNewFieldName[iPos] == L'.' || csNewFieldName[iPos] == L' ')) {
640             iPos ++;
641         }
642         if (iPos < iLength && !csSub.IsEmpty()) {
643             csSub += L'.';
644         }
645         while (iPos < iLength && csNewFieldName[iPos] != L'.') {
646             csSub += csNewFieldName[iPos ++];
647         }
648         for (int i = csSub.GetLength() - 1; i > -1; i --) {
649             if (csSub[i] == L' ' || csSub[i] == L'.') {
650                 csSub.SetAt(i, L'\0');
651             } else {
652                 break;
653             }
654         }
655         FX_DWORD dwCount = m_pFieldTree->m_Root.CountFields();
656         for (FX_DWORD m = 0; m < dwCount; m ++) {
657             CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(m);
658             if (pField == NULL) {
659                 continue;
660             }
661             if (pField == pExcludedField) {
662                 if (pExcludedControl != NULL) {
663                     if (pField->CountControls() < 2) {
664                         continue;
665                     }
666                 } else {
667                     continue;
668                 }
669             }
670             CFX_WideString csFullName = pField->GetFullName();
671             int iRet = CompareFieldName(csSub, csFullName);
672             if (iRet == 1) {
673                 if (pField->GetFieldType() != iType) {
674                     return FALSE;
675                 }
676             } else if (iRet == 2 && csSub == csNewFieldName) {
677                 if (csFullName[iPos] == L'.') {
678                     return FALSE;
679                 }
680             } else if (iRet == 3 && csSub == csNewFieldName) {
681                 if (csNewFieldName[csFullName.GetLength()] == L'.') {
682                     return FALSE;
683                 }
684             }
685         }
686         if (iPos >= iLength) {
687             break;
688         }
689     }
690     if (csSub.IsEmpty()) {
691         return FALSE;
692     }
693     csNewFieldName = csSub;
694     return TRUE;
695 }
696 FX_BOOL CPDF_InterForm::ValidateFieldName(CFX_WideString& csNewFieldName, int iType)
697 {
698     return ValidateFieldName(csNewFieldName, iType, NULL, NULL);
699 }
700 FX_BOOL CPDF_InterForm::ValidateFieldName(const CPDF_FormField* pField, CFX_WideString& csNewFieldName)
701 {
702     if (pField == NULL || csNewFieldName.IsEmpty()) {
703         return FALSE;
704     }
705     return ValidateFieldName(csNewFieldName, ((CPDF_FormField*)pField)->GetFieldType(), pField, NULL);
706 }
707 FX_BOOL CPDF_InterForm::ValidateFieldName(const CPDF_FormControl* pControl, CFX_WideString& csNewFieldName)
708 {
709     if (pControl == NULL || csNewFieldName.IsEmpty()) {
710         return FALSE;
711     }
712     CPDF_FormField* pField = ((CPDF_FormControl*)pControl)->GetField();
713     return ValidateFieldName(csNewFieldName, pField->GetFieldType(), pField, pControl);
714 }
715 int CPDF_InterForm::CompareFieldName(const CFX_ByteString& name1, const CFX_ByteString& name2)
716 {
717     FX_LPCSTR ptr1 = name1, ptr2 = name2;
718     if (name1.GetLength() != name2.GetLength()) {
719         int i = 0;
720         while (ptr1[i] == ptr2[i]) {
721             i ++;
722         }
723         if (i == name1.GetLength()) {
724             return 2;
725         }
726         if (i == name2.GetLength()) {
727             return 3;
728         }
729         return 0;
730     } else {
731         return name1 == name2 ? 1 : 0;
732     }
733 }
734 int CPDF_InterForm::CompareFieldName(const CFX_WideString& name1, const CFX_WideString& name2)
735 {
736     FX_LPCWSTR ptr1 = name1.c_str();
737     FX_LPCWSTR ptr2 = name2.c_str();
738     if (name1.GetLength() != name2.GetLength()) {
739         int i = 0;
740         while (ptr1[i] == ptr2[i]) {
741             i ++;
742         }
743         if (i == name1.GetLength()) {
744             return 2;
745         }
746         if (i == name2.GetLength()) {
747             return 3;
748         }
749         return 0;
750     } else {
751         return name1 == name2 ? 1 : 0;
752     }
753 }
754 FX_DWORD CPDF_InterForm::CountFields(const CFX_WideString &csFieldName)
755 {
756     if (csFieldName.IsEmpty()) {
757         return (FX_DWORD)m_pFieldTree->m_Root.CountFields();
758     }
759     CFieldTree::_Node *pNode = m_pFieldTree->FindNode(csFieldName);
760     if (pNode == NULL) {
761         return 0;
762     }
763     return pNode->CountFields();
764 }
765 CPDF_FormField* CPDF_InterForm::GetField(FX_DWORD index, const CFX_WideString &csFieldName)
766 {
767     if (csFieldName == L"") {
768         return m_pFieldTree->m_Root.GetField(index);
769     }
770     CFieldTree::_Node *pNode = m_pFieldTree->FindNode(csFieldName);
771     if (pNode == NULL) {
772         return NULL;
773     }
774     return pNode->GetField(index);
775 }
776 void CPDF_InterForm::GetAllFieldNames(CFX_WideStringArray& allFieldNames)
777 {
778     allFieldNames.RemoveAll();
779     int nCount = m_pFieldTree->m_Root.CountFields();
780     for (int i = 0; i < nCount; i ++) {
781         CPDF_FormField *pField = m_pFieldTree->m_Root.GetField(i);
782         if (pField) {
783             CFX_WideString full_name = GetFullName(pField->GetFieldDict());
784             allFieldNames.Add(full_name);
785         }
786     }
787 }
788 FX_BOOL CPDF_InterForm::IsValidFormField(const void* pField)
789 {
790     if (pField == NULL) {
791         return FALSE;
792     }
793     int nCount = m_pFieldTree->m_Root.CountFields();
794     for (int i = 0; i < nCount; i++) {
795         CPDF_FormField *pFormField = m_pFieldTree->m_Root.GetField(i);
796         if (pField == pFormField) {
797             return TRUE;
798         }
799     }
800     return FALSE;
801 }
802 CPDF_FormField* CPDF_InterForm::GetFieldByDict(CPDF_Dictionary* pFieldDict) const
803 {
804     if (pFieldDict == NULL) {
805         return NULL;
806     }
807     CFX_WideString csWName = GetFullName(pFieldDict);
808     return m_pFieldTree->GetField(csWName);
809 }
810 FX_DWORD CPDF_InterForm::CountControls(CFX_WideString csFieldName)
811 {
812     if (csFieldName.IsEmpty()) {
813         return (FX_DWORD)m_ControlMap.GetCount();
814     }
815     CPDF_FormField *pField = m_pFieldTree->GetField(csFieldName);
816     if (pField == NULL) {
817         return 0;
818     }
819     return pField->m_ControlList.GetSize();
820 }
821 CPDF_FormControl* CPDF_InterForm::GetControl(FX_DWORD index, CFX_WideString csFieldName)
822 {
823     CPDF_FormField *pField = m_pFieldTree->GetField(csFieldName);
824     if (pField == NULL) {
825         return NULL;
826     }
827     if (index < (FX_DWORD)pField->m_ControlList.GetSize()) {
828         return (CPDF_FormControl *)pField->m_ControlList.GetAt(index);
829     }
830     return NULL;
831 }
832 FX_BOOL CPDF_InterForm::IsValidFormControl(const void* pControl)
833 {
834     if (pControl == NULL) {
835         return FALSE;
836     }
837     FX_POSITION pos = m_ControlMap.GetStartPosition();
838     while (pos) {
839         CPDF_Dictionary* pWidgetDict = NULL;
840         void* pFormControl = NULL;
841         m_ControlMap.GetNextAssoc(pos, (FX_LPVOID&)pWidgetDict, pFormControl);
842         if (pControl == pFormControl) {
843             return TRUE;
844         }
845     }
846     return FALSE;
847 }
848 int CPDF_InterForm::CountPageControls(CPDF_Page* pPage) const
849 {
850     CPDF_Array* pAnnotList = pPage->m_pFormDict->GetArray("Annots");
851     if (pAnnotList == NULL) {
852         return 0;
853     }
854     int count = 0;
855     for (FX_DWORD i = 0; i < pAnnotList->GetCount(); i ++) {
856         CPDF_Dictionary* pAnnot = pAnnotList->GetDict(i);
857         if (pAnnot == NULL) {
858             continue;
859         }
860         CPDF_FormControl* pControl;
861         if (!m_ControlMap.Lookup(pAnnot, (FX_LPVOID&)pControl)) {
862             continue;
863         }
864         count ++;
865     }
866     return count;
867 }
868 CPDF_FormControl* CPDF_InterForm::GetPageControl(CPDF_Page* pPage, int index) const
869 {
870     CPDF_Array* pAnnotList = pPage->m_pFormDict->GetArray("Annots");
871     if (pAnnotList == NULL) {
872         return NULL;
873     }
874     int count = 0;
875     for (FX_DWORD i = 0; i < pAnnotList->GetCount(); i ++) {
876         CPDF_Dictionary* pAnnot = pAnnotList->GetDict(i);
877         if (pAnnot == NULL) {
878             continue;
879         }
880         CPDF_FormControl* pControl;
881         if (!m_ControlMap.Lookup(pAnnot, (FX_LPVOID&)pControl)) {
882             continue;
883         }
884         if (index == count) {
885             return pControl;
886         }
887         count ++;
888     }
889     return NULL;
890 }
891 CPDF_FormControl* CPDF_InterForm::GetControlAtPoint(CPDF_Page* pPage, FX_FLOAT pdf_x, FX_FLOAT pdf_y) const
892 {
893     CPDF_Array* pAnnotList = pPage->m_pFormDict->GetArray("Annots");
894     if (pAnnotList == NULL) {
895         return NULL;
896     }
897     for (FX_DWORD i = pAnnotList->GetCount(); i > 0; i --) {
898         CPDF_Dictionary* pAnnot = pAnnotList->GetDict(i - 1);
899         if (pAnnot == NULL) {
900             continue;
901         }
902         CPDF_FormControl* pControl;
903         if (!m_ControlMap.Lookup(pAnnot, (FX_LPVOID&)pControl)) {
904             continue;
905         }
906         CFX_FloatRect rect = pControl->GetRect();
907         if (rect.Contains(pdf_x, pdf_y)) {
908             return pControl;
909         }
910     }
911     return NULL;
912 }
913 CPDF_FormControl* CPDF_InterForm::GetControlByDict(CPDF_Dictionary* pWidgetDict) const
914 {
915     CPDF_FormControl* pControl = NULL;
916     m_ControlMap.Lookup(pWidgetDict, (FX_LPVOID&)pControl);
917     return pControl;
918 }
919 FX_DWORD CPDF_InterForm::CountInternalFields(const CFX_WideString& csFieldName) const
920 {
921     if (m_pFormDict == NULL) {
922         return 0;
923     }
924     CPDF_Array* pArray = m_pFormDict->GetArray("Fields");
925     if (pArray == NULL) {
926         return 0;
927     }
928     if (csFieldName.IsEmpty()) {
929         return pArray->GetCount();
930     } else {
931         int iLength = csFieldName.GetLength();
932         int iPos = 0;
933         CPDF_Dictionary* pDict = NULL;
934         while (pArray != NULL) {
935             CFX_WideString csSub;
936             if (iPos < iLength && csFieldName[iPos] == L'.') {
937                 iPos ++;
938             }
939             while (iPos < iLength && csFieldName[iPos] != L'.') {
940                 csSub += csFieldName[iPos ++];
941             }
942             int iCount = pArray->GetCount();
943             FX_BOOL bFind = FALSE;
944             for (int i = 0; i < iCount; i ++) {
945                 pDict = pArray->GetDict(i);
946                 if (pDict == NULL) {
947                     continue;
948                 }
949                 CFX_WideString csT = pDict->GetUnicodeText("T");
950                 if (csT == csSub) {
951                     bFind = TRUE;
952                     break;
953                 }
954             }
955             if (!bFind) {
956                 return 0;
957             }
958             if (iPos >= iLength) {
959                 break;
960             }
961             pArray = pDict->GetArray("Kids");
962         }
963         if (pDict == NULL) {
964             return 0;
965         } else {
966             pArray = pDict->GetArray("Kids");
967             if (pArray == NULL) {
968                 return 1;
969             } else {
970                 return pArray->GetCount();
971             }
972         }
973     }
974 }
975 CPDF_Dictionary* CPDF_InterForm::GetInternalField(FX_DWORD index, const CFX_WideString& csFieldName) const
976 {
977     if (m_pFormDict == NULL) {
978         return NULL;
979     }
980     CPDF_Array* pArray = m_pFormDict->GetArray("Fields");
981     if (pArray == NULL) {
982         return 0;
983     }
984     if (csFieldName.IsEmpty()) {
985         return pArray->GetDict(index);
986     } else {
987         int iLength = csFieldName.GetLength();
988         int iPos = 0;
989         CPDF_Dictionary* pDict = NULL;
990         while (pArray != NULL) {
991             CFX_WideString csSub;
992             if (iPos < iLength && csFieldName[iPos] == L'.') {
993                 iPos ++;
994             }
995             while (iPos < iLength && csFieldName[iPos] != L'.') {
996                 csSub += csFieldName[iPos ++];
997             }
998             int iCount = pArray->GetCount();
999             FX_BOOL bFind = FALSE;
1000             for (int i = 0; i < iCount; i ++) {
1001                 pDict = pArray->GetDict(i);
1002                 if (pDict == NULL) {
1003                     continue;
1004                 }
1005                 CFX_WideString csT = pDict->GetUnicodeText("T");
1006                 if (csT == csSub) {
1007                     bFind = TRUE;
1008                     break;
1009                 }
1010             }
1011             if (!bFind) {
1012                 return NULL;
1013             }
1014             if (iPos >= iLength) {
1015                 break;
1016             }
1017             pArray = pDict->GetArray("Kids");
1018         }
1019         if (pDict == NULL) {
1020             return NULL;
1021         } else {
1022             pArray = pDict->GetArray("Kids");
1023             if (pArray == NULL) {
1024                 return pDict;
1025             } else {
1026                 return pArray->GetDict(index);
1027             }
1028         }
1029     }
1030 }
1031 FX_BOOL CPDF_InterForm::NeedConstructAP()
1032 {
1033     if (m_pFormDict == NULL) {
1034         return FALSE;
1035     }
1036     return m_pFormDict->GetBoolean("NeedAppearances");
1037 }
1038 void CPDF_InterForm::NeedConstructAP(FX_BOOL bNeedAP)
1039 {
1040     if (m_pFormDict == NULL) {
1041         InitInterFormDict(m_pFormDict, m_pDocument);
1042     }
1043     m_pFormDict->SetAtBoolean("NeedAppearances", bNeedAP);
1044     m_bGenerateAP = bNeedAP;
1045 }
1046 int CPDF_InterForm::CountFieldsInCalculationOrder()
1047 {
1048     if (m_pFormDict == NULL) {
1049         return 0;
1050     }
1051     CPDF_Array* pArray = m_pFormDict->GetArray("CO");
1052     if (pArray == NULL) {
1053         return 0;
1054     }
1055     return pArray->GetCount();
1056 }
1057 CPDF_FormField* CPDF_InterForm::GetFieldInCalculationOrder(int index)
1058 {
1059     if (m_pFormDict == NULL || index < 0) {
1060         return NULL;
1061     }
1062     CPDF_Array* pArray = m_pFormDict->GetArray("CO");
1063     if (pArray == NULL) {
1064         return NULL;
1065     }
1066     CPDF_Object* pElement = pArray->GetElementValue(index);
1067     if (pElement != NULL && pElement->GetType() == PDFOBJ_DICTIONARY) {
1068         return GetFieldByDict((CPDF_Dictionary*)pElement);
1069     }
1070     return NULL;
1071 }
1072 int CPDF_InterForm::FindFieldInCalculationOrder(const CPDF_FormField* pField)
1073 {
1074     if (m_pFormDict == NULL || pField == NULL) {
1075         return -1;
1076     }
1077     CPDF_Array* pArray = m_pFormDict->GetArray("CO");
1078     if (pArray == NULL) {
1079         return -1;
1080     }
1081     for (FX_DWORD i = 0; i < pArray->GetCount(); i ++) {
1082         CPDF_Object* pElement = pArray->GetElementValue(i);
1083         if (pElement == pField->m_pDict) {
1084             return i;
1085         }
1086     }
1087     return -1;
1088 }
1089 FX_DWORD CPDF_InterForm::CountFormFonts()
1090 {
1091     return CountInterFormFonts(m_pFormDict);
1092 }
1093 CPDF_Font* CPDF_InterForm::GetFormFont(FX_DWORD index, CFX_ByteString& csNameTag)
1094 {
1095     return GetInterFormFont(m_pFormDict, m_pDocument, index, csNameTag);
1096 }
1097 CPDF_Font* CPDF_InterForm::GetFormFont(CFX_ByteString csNameTag)
1098 {
1099     return GetInterFormFont(m_pFormDict, m_pDocument, csNameTag);
1100 }
1101 CPDF_Font* CPDF_InterForm::GetFormFont(CFX_ByteString csFontName, CFX_ByteString& csNameTag)
1102 {
1103     return GetInterFormFont(m_pFormDict, m_pDocument, csFontName, csNameTag);
1104 }
1105 CPDF_Font* CPDF_InterForm::GetNativeFormFont(FX_BYTE charSet, CFX_ByteString& csNameTag)
1106 {
1107     return GetNativeInterFormFont(m_pFormDict, m_pDocument, charSet, csNameTag);
1108 }
1109 CPDF_Font* CPDF_InterForm::GetNativeFormFont(CFX_ByteString& csNameTag)
1110 {
1111     return GetNativeInterFormFont(m_pFormDict, m_pDocument, csNameTag);
1112 }
1113 FX_BOOL CPDF_InterForm::FindFormFont(const CPDF_Font* pFont, CFX_ByteString& csNameTag)
1114 {
1115     return FindInterFormFont(m_pFormDict, pFont, csNameTag);
1116 }
1117 FX_BOOL CPDF_InterForm::FindFormFont(CFX_ByteString csFontName, CPDF_Font*& pFont, CFX_ByteString& csNameTag)
1118 {
1119     return FindInterFormFont(m_pFormDict, m_pDocument, csFontName, pFont, csNameTag);
1120 }
1121 void CPDF_InterForm::AddFormFont(const CPDF_Font* pFont, CFX_ByteString& csNameTag)
1122 {
1123     AddInterFormFont(m_pFormDict, m_pDocument, pFont, csNameTag);
1124     m_bUpdated = TRUE;
1125 }
1126 CPDF_Font* CPDF_InterForm::AddNativeFormFont(FX_BYTE charSet, CFX_ByteString& csNameTag)
1127 {
1128     m_bUpdated = TRUE;
1129     return AddNativeInterFormFont(m_pFormDict, m_pDocument, charSet, csNameTag);
1130 }
1131 CPDF_Font* CPDF_InterForm::AddNativeFormFont(CFX_ByteString& csNameTag)
1132 {
1133     m_bUpdated = TRUE;
1134     return AddNativeInterFormFont(m_pFormDict, m_pDocument, csNameTag);
1135 }
1136 void CPDF_InterForm::RemoveFormFont(const CPDF_Font* pFont)
1137 {
1138     m_bUpdated = TRUE;
1139     RemoveInterFormFont(m_pFormDict, pFont);
1140 }
1141 void CPDF_InterForm::RemoveFormFont(CFX_ByteString csNameTag)
1142 {
1143     m_bUpdated = TRUE;
1144     RemoveInterFormFont(m_pFormDict, csNameTag);
1145 }
1146 CPDF_DefaultAppearance CPDF_InterForm::GetDefaultAppearance()
1147 {
1148     CFX_ByteString csDA;
1149     if (m_pFormDict == NULL) {
1150         return csDA;
1151     }
1152     csDA = m_pFormDict->GetString("DA");
1153     return csDA;
1154 }
1155 CPDF_Font* CPDF_InterForm::GetDefaultFormFont()
1156 {
1157     return GetDefaultInterFormFont(m_pFormDict, m_pDocument);
1158 }
1159 int CPDF_InterForm::GetFormAlignment()
1160 {
1161     if (m_pFormDict == NULL) {
1162         return 0;
1163     }
1164     return m_pFormDict->GetInteger("Q", 0);
1165 }
1166 FX_BOOL CPDF_InterForm::ResetForm(const CFX_PtrArray& fields, FX_BOOL bIncludeOrExclude, FX_BOOL bNotify)
1167 {
1168     if (bNotify && m_pFormNotify != NULL) {
1169         int iRet = m_pFormNotify->BeforeFormReset(this);
1170         if (iRet < 0) {
1171             return FALSE;
1172         }
1173     }
1174     int nCount = m_pFieldTree->m_Root.CountFields();
1175     for (int i = 0; i < nCount; i++) {
1176         CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(i);
1177         if (pField == NULL) {
1178             continue;
1179         }
1180         FX_BOOL bFind = FALSE;
1181         int iCount = fields.GetSize();
1182         for (int i = 0; i < iCount; i ++) {
1183             if (pField == (CPDF_FormField*)fields[i]) {
1184                 bFind = TRUE;
1185                 break;
1186             }
1187         }
1188         if ((bIncludeOrExclude && bFind) || (!bIncludeOrExclude && !bFind)) {
1189             pField->ResetField(bNotify);
1190         }
1191     }
1192     if (bNotify && m_pFormNotify != NULL) {
1193         m_pFormNotify->AfterFormReset(this);
1194     }
1195     return TRUE;
1196 }
1197 FX_BOOL CPDF_InterForm::ResetForm(FX_BOOL bNotify)
1198 {
1199     if (bNotify && m_pFormNotify != NULL) {
1200         int iRet = m_pFormNotify->BeforeFormReset(this);
1201         if (iRet < 0) {
1202             return FALSE;
1203         }
1204     }
1205     int nCount = m_pFieldTree->m_Root.CountFields();
1206     for (int i = 0; i < nCount; i++) {
1207         CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(i);
1208         if (pField == NULL) {
1209             continue;
1210         }
1211         pField->ResetField(bNotify);
1212     }
1213     if (bNotify && m_pFormNotify != NULL) {
1214         m_pFormNotify->AfterFormReset(this);
1215     }
1216     return TRUE;
1217 }
1218 void CPDF_InterForm::ReloadForm()
1219 {
1220     FX_POSITION pos = m_ControlMap.GetStartPosition();
1221     while (pos) {
1222         CPDF_Dictionary* pWidgetDict;
1223         CPDF_FormControl* pControl;
1224         m_ControlMap.GetNextAssoc(pos, (FX_LPVOID&)pWidgetDict, (FX_LPVOID&)pControl);
1225         delete pControl;
1226     }
1227     m_ControlMap.RemoveAll();
1228     int nCount = m_pFieldTree->m_Root.CountFields();
1229     for (int k = 0; k < nCount; k ++) {
1230         CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(k);
1231         delete pField;
1232     }
1233     m_pFieldTree->RemoveAll();
1234     if (m_pFormDict == NULL) {
1235         return;
1236     }
1237     CPDF_Array* pFields = m_pFormDict->GetArray("Fields");
1238     if (pFields == NULL) {
1239         return;
1240     }
1241     int iCount = pFields->GetCount();
1242     for (int i = 0; i < iCount; i ++) {
1243         LoadField(pFields->GetDict(i));
1244     }
1245 }
1246 void CPDF_InterForm::LoadField(CPDF_Dictionary* pFieldDict, int nLevel)
1247 {
1248     if (nLevel > nMaxRecursion) {
1249         return;
1250     }
1251     if (pFieldDict == NULL) {
1252         return;
1253     }
1254     FX_DWORD dwParentObjNum = pFieldDict->GetObjNum();
1255     CPDF_Array* pKids = pFieldDict->GetArray("Kids");
1256     if (!pKids) {
1257         AddTerminalField(pFieldDict);
1258         return;
1259     }
1260     CPDF_Dictionary* pFirstKid = pKids->GetDict(0);
1261     if (pFirstKid == NULL) {
1262         return;
1263     }
1264     if (pFirstKid->KeyExist("T") || pFirstKid->KeyExist("Kids")) {
1265         for (FX_DWORD i = 0; i < pKids->GetCount(); i ++) {
1266             CPDF_Dictionary * pChildDict = pKids->GetDict(i);
1267             if (pChildDict) {
1268                 if (pChildDict->GetObjNum() != dwParentObjNum) {
1269                     LoadField(pChildDict, nLevel + 1);
1270                 }
1271             }
1272         }
1273     } else {
1274         AddTerminalField(pFieldDict);
1275     }
1276 }
1277 FX_BOOL CPDF_InterForm::HasXFAForm() const
1278 {
1279     return m_pFormDict && m_pFormDict->GetArray(FX_BSTRC("XFA")) != NULL;
1280 }
1281 void CPDF_InterForm::FixPageFields(const CPDF_Page* pPage)
1282 {
1283     ASSERT(pPage != NULL);
1284     CPDF_Dictionary* pPageDict = pPage->m_pFormDict;
1285     if (pPageDict == NULL) {
1286         return;
1287     }
1288     CPDF_Array* pAnnots = pPageDict->GetArray(FX_BSTRC("Annots"));
1289     if (pAnnots == NULL) {
1290         return;
1291     }
1292     int iAnnotCount = pAnnots->GetCount();
1293     for (int i = 0; i < iAnnotCount; i++) {
1294         CPDF_Dictionary* pAnnot = pAnnots->GetDict(i);
1295         if (pAnnot != NULL && pAnnot->GetString(FX_BSTRC("Subtype")) == "Widget") {
1296             LoadField(pAnnot);
1297         }
1298     }
1299 }
1300 CPDF_FormField* CPDF_InterForm::AddTerminalField(const CPDF_Dictionary* pFieldDict)
1301 {
1302     if (!pFieldDict->KeyExist(FX_BSTRC("T"))) {
1303         return NULL;
1304     }
1305     CPDF_Dictionary* pDict = (CPDF_Dictionary*)pFieldDict;
1306     CFX_WideString csWName = GetFullName(pDict);
1307     if (csWName.IsEmpty()) {
1308         return NULL;
1309     }
1310     CPDF_FormField* pField = NULL;
1311     pField = m_pFieldTree->GetField(csWName);
1312     if (pField == NULL) {
1313         CPDF_Dictionary *pParent = (CPDF_Dictionary*)pFieldDict;
1314         if (!pFieldDict->KeyExist(FX_BSTR("T")) &&
1315                 pFieldDict->GetString(FX_BSTRC("Subtype")) == FX_BSTRC("Widget")) {
1316             pParent = pFieldDict->GetDict(FX_BSTRC("Parent"));
1317             if (!pParent) {
1318                 pParent = (CPDF_Dictionary*)pFieldDict;
1319             }
1320         }
1321         if (pParent && pParent != pFieldDict && !pParent->KeyExist(FX_BSTRC("FT"))) {
1322             if (pFieldDict->KeyExist(FX_BSTRC("FT"))) {
1323                 CPDF_Object *pFTValue = pFieldDict->GetElementValue(FX_BSTRC("FT"));
1324                 if (pFTValue) {
1325                     pParent->SetAt(FX_BSTRC("FT"), pFTValue->Clone());
1326                 }
1327             }
1328             if (pFieldDict->KeyExist(FX_BSTRC("Ff"))) {
1329                 CPDF_Object *pFfValue = pFieldDict->GetElementValue(FX_BSTRC("Ff"));
1330                 if (pFfValue) {
1331                     pParent->SetAt(FX_BSTRC("Ff"), pFfValue->Clone());
1332                 }
1333             }
1334         }
1335         pField = new CPDF_FormField(this, pParent);
1336         CPDF_Object* pTObj = pDict->GetElement("T");
1337         if (pTObj && pTObj->GetType() == PDFOBJ_REFERENCE) {
1338             CPDF_Object* pClone = pTObj->Clone(TRUE);
1339             if (pClone) {
1340                 pDict->SetAt("T", pClone);
1341             } else {
1342                 pDict->SetAtName("T", "");
1343             }
1344         }
1345         m_pFieldTree->SetField(csWName, pField);
1346     }
1347     CPDF_Array* pKids = pFieldDict->GetArray("Kids");
1348     if (pKids == NULL) {
1349         if (pFieldDict->GetString("Subtype") == "Widget") {
1350             AddControl(pField, pFieldDict);
1351         }
1352     } else {
1353         for (FX_DWORD i = 0; i < pKids->GetCount(); i ++) {
1354             CPDF_Dictionary* pKid = pKids->GetDict(i);
1355             if (pKid == NULL) {
1356                 continue;
1357             }
1358             if (pKid->GetString("Subtype") != "Widget") {
1359                 continue;
1360             }
1361             AddControl(pField, pKid);
1362         }
1363     }
1364     return pField;
1365 }
1366 CPDF_FormControl* CPDF_InterForm::AddControl(const CPDF_FormField* pField, const CPDF_Dictionary* pWidgetDict)
1367 {
1368     void *rValue = NULL;
1369     if (m_ControlMap.Lookup((CPDF_Dictionary*)pWidgetDict, rValue)) {
1370         return (CPDF_FormControl*)rValue;
1371     }
1372     CPDF_FormControl* pControl = new CPDF_FormControl((CPDF_FormField*)pField, (CPDF_Dictionary*)pWidgetDict);
1373     m_ControlMap.SetAt((CPDF_Dictionary*)pWidgetDict, pControl);
1374     ((CPDF_FormField*)pField)->m_ControlList.Add(pControl);
1375     return pControl;
1376 }
1377 CPDF_FormField* CPDF_InterForm::CheckRequiredFields(const CFX_PtrArray *fields, FX_BOOL bIncludeOrExclude) const
1378 {
1379     int nCount = m_pFieldTree->m_Root.CountFields();
1380     for (int i = 0; i < nCount; i++) {
1381         CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(i);
1382         if (pField == NULL) {
1383             continue;
1384         }
1385         FX_INT32 iType = pField->GetType();
1386         if (iType == CPDF_FormField::PushButton || iType == CPDF_FormField::CheckBox || iType == CPDF_FormField::ListBox) {
1387             continue;
1388         }
1389         FX_DWORD dwFlags = pField->GetFieldFlags();
1390         if (dwFlags & 0x04) {
1391             continue;
1392         }
1393         FX_BOOL bFind = TRUE;
1394         if (fields != NULL) {
1395             bFind = fields->Find(pField, 0) >= 0;
1396         }
1397         if ((bIncludeOrExclude && bFind) || (!bIncludeOrExclude && !bFind)) {
1398             CPDF_Dictionary *pFieldDict = pField->m_pDict;
1399             if ((dwFlags & 0x02) != 0 && pFieldDict->GetString("V").IsEmpty()) {
1400                 return pField;
1401             }
1402         }
1403     }
1404     return NULL;
1405 }
1406 CFDF_Document* CPDF_InterForm::ExportToFDF(FX_WSTR pdf_path, FX_BOOL bSimpleFileSpec) const
1407 {
1408     CFX_PtrArray fields;
1409     int nCount = m_pFieldTree->m_Root.CountFields();
1410     for (int i = 0; i < nCount; i ++) {
1411         CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(i);
1412         fields.Add(pField);
1413     }
1414     return ExportToFDF(pdf_path, fields, TRUE, bSimpleFileSpec);
1415 }
1416 CFX_WideString FILESPEC_EncodeFileName(FX_WSTR filepath);
1417 CFDF_Document* CPDF_InterForm::ExportToFDF(FX_WSTR pdf_path, CFX_PtrArray& fields, FX_BOOL bIncludeOrExclude, FX_BOOL bSimpleFileSpec) const
1418 {
1419     CFDF_Document* pDoc = CFDF_Document::CreateNewDoc();
1420     if (pDoc == NULL) {
1421         return NULL;
1422     }
1423     CPDF_Dictionary* pMainDict = pDoc->GetRoot()->GetDict("FDF");
1424     if (!pdf_path.IsEmpty()) {
1425         if (bSimpleFileSpec) {
1426             CFX_WideString wsFilePath = FILESPEC_EncodeFileName(pdf_path);
1427             pMainDict->SetAtString(FX_BSTRC("F"), CFX_ByteString::FromUnicode(wsFilePath));
1428             pMainDict->SetAtString(FX_BSTRC("UF"), PDF_EncodeText(wsFilePath));
1429         } else {
1430             CPDF_FileSpec filespec;
1431             filespec.SetFileName(pdf_path);
1432             pMainDict->SetAt("F", (CPDF_Object*)filespec);
1433         }
1434     }
1435     CPDF_Array* pFields = CPDF_Array::Create();
1436     if (pFields == NULL) {
1437         return NULL;
1438     }
1439     pMainDict->SetAt("Fields", pFields);
1440     int nCount = m_pFieldTree->m_Root.CountFields();
1441     for (int i = 0; i < nCount; i ++) {
1442         CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(i);
1443         if (pField == NULL || pField->GetType() == CPDF_FormField::PushButton) {
1444             continue;
1445         }
1446         FX_DWORD dwFlags = pField->GetFieldFlags();
1447         if (dwFlags & 0x04) {
1448             continue;
1449         }
1450         FX_BOOL bFind = fields.Find(pField, 0) >= 0;
1451         if ((bIncludeOrExclude && bFind) || (!bIncludeOrExclude && !bFind)) {
1452             if ((dwFlags & 0x02) != 0 && pField->m_pDict->GetString("V").IsEmpty()) {
1453                 continue;
1454             }
1455             CFX_WideString fullname = GetFullName(pField->GetFieldDict());
1456             CPDF_Dictionary* pFieldDict = CPDF_Dictionary::Create();
1457             if (pFieldDict == NULL) {
1458                 return NULL;
1459             }
1460             CPDF_String* pString = CPDF_String::Create(fullname);
1461             if (pString == NULL) {
1462                 pFieldDict->Release();
1463                 return NULL;
1464             }
1465             pFieldDict->SetAt("T", pString);
1466             if (pField->GetType() == CPDF_FormField::CheckBox || pField->GetType() == CPDF_FormField::RadioButton) {
1467                 CFX_WideString csExport = pField->GetCheckValue(FALSE);
1468                 CFX_ByteString csBExport = PDF_EncodeText(csExport);
1469                 CPDF_Object* pOpt = FPDF_GetFieldAttr(pField->m_pDict, "Opt");
1470                 if (pOpt == NULL) {
1471                     pFieldDict->SetAtName("V", csBExport);
1472                 } else {
1473                     pFieldDict->SetAtString("V", csBExport);
1474                 }
1475             } else {
1476                 CPDF_Object* pV = FPDF_GetFieldAttr(pField->m_pDict, "V");
1477                 if (pV != NULL) {
1478                     pFieldDict->SetAt("V", pV->Clone(TRUE));
1479                 }
1480             }
1481             pFields->Add(pFieldDict);
1482         }
1483     }
1484     return pDoc;
1485 }
1486 const struct _SupportFieldEncoding {
1487     FX_LPCSTR m_name;
1488     FX_INT32 m_codePage;
1489 } g_fieldEncoding[] = {
1490     { "BigFive", 950 },
1491     { "GBK", 936 },
1492     { "Shift-JIS", 932 },
1493     { "UHC", 949 },
1494 };
1495 static void FPDFDOC_FDF_GetFieldValue(CPDF_Dictionary *pFieldDict, CFX_WideString &csValue, CFX_ByteString &bsEncoding)
1496 {
1497     ASSERT(pFieldDict != NULL);
1498     CFX_ByteString csBValue = pFieldDict->GetString("V");
1499     FX_INT32 iCount = sizeof(g_fieldEncoding) / sizeof(g_fieldEncoding[0]);
1500     FX_INT32 i = 0;
1501     for (; i < iCount; ++i)
1502         if (bsEncoding == g_fieldEncoding[i].m_name) {
1503             break;
1504         }
1505     if (i < iCount) {
1506         CFX_CharMap *pCharMap = CFX_CharMap::GetDefaultMapper(g_fieldEncoding[i].m_codePage);
1507         FXSYS_assert(pCharMap != NULL);
1508         csValue.ConvertFrom(csBValue, pCharMap);
1509         return;
1510     }
1511     CFX_ByteString csTemp = csBValue.Left(2);
1512     if (csTemp == "\xFF\xFE" || csTemp == "\xFE\xFF") {
1513         csValue = PDF_DecodeText(csBValue);
1514     } else {
1515         csValue = CFX_WideString::FromLocal(csBValue);
1516     }
1517 }
1518 void CPDF_InterForm::FDF_ImportField(CPDF_Dictionary* pFieldDict, const CFX_WideString& parent_name, FX_BOOL bNotify, int nLevel)
1519 {
1520     CFX_WideString name;
1521     if (!parent_name.IsEmpty()) {
1522         name = parent_name + L".";
1523     }
1524     name += pFieldDict->GetUnicodeText("T");
1525     CPDF_Array* pKids = pFieldDict->GetArray("Kids");
1526     if (pKids) {
1527         for (FX_DWORD i = 0; i < pKids->GetCount(); i ++) {
1528             CPDF_Dictionary* pKid = pKids->GetDict(i);
1529             if (pKid == NULL) {
1530                 continue;
1531             }
1532             if (nLevel <= nMaxRecursion) {
1533                 FDF_ImportField(pKid, name, bNotify, nLevel + 1);
1534             }
1535         }
1536         return;
1537     }
1538     if (!pFieldDict->KeyExist("V")) {
1539         return;
1540     }
1541     CPDF_FormField* pField = m_pFieldTree->GetField(name);
1542     if (pField == NULL) {
1543         return;
1544     }
1545     CFX_WideString csWValue;
1546     FPDFDOC_FDF_GetFieldValue(pFieldDict, csWValue, m_bsEncoding);
1547     int iType = pField->GetFieldType();
1548     if (bNotify && m_pFormNotify != NULL) {
1549         int iRet = 0;
1550         if (iType == FIELDTYPE_LISTBOX) {
1551             iRet = m_pFormNotify->BeforeSelectionChange(pField, csWValue);
1552         } else if (iType == FIELDTYPE_COMBOBOX || iType == FIELDTYPE_TEXTFIELD) {
1553             iRet = m_pFormNotify->BeforeValueChange(pField, csWValue);
1554         }
1555         if (iRet < 0) {
1556             return;
1557         }
1558     }
1559     CFX_ByteArray statusArray;
1560     if (iType == FIELDTYPE_CHECKBOX || iType == FIELDTYPE_RADIOBUTTON) {
1561         SaveCheckedFieldStatus(pField, statusArray);
1562     }
1563     pField->SetValue(csWValue);
1564     CPDF_FormField::Type eType = pField->GetType();
1565     if ((eType == CPDF_FormField::ListBox || eType == CPDF_FormField::ComboBox) && pFieldDict->KeyExist("Opt")) {
1566         pField->m_pDict->SetAt("Opt", pFieldDict->GetElementValue("Opt")->Clone(TRUE));
1567     }
1568     if (bNotify && m_pFormNotify != NULL) {
1569         if (iType == FIELDTYPE_CHECKBOX || iType == FIELDTYPE_RADIOBUTTON) {
1570             m_pFormNotify->AfterCheckedStatusChange(pField, statusArray);
1571         } else if (iType == FIELDTYPE_LISTBOX) {
1572             m_pFormNotify->AfterSelectionChange(pField);
1573         } else if (iType == FIELDTYPE_COMBOBOX || iType == FIELDTYPE_TEXTFIELD) {
1574             m_pFormNotify->AfterValueChange(pField);
1575         }
1576     }
1577     if (CPDF_InterForm::m_bUpdateAP) {
1578         pField->UpdateAP(NULL);
1579     }
1580 }
1581 FX_BOOL CPDF_InterForm::ImportFromFDF(const CFDF_Document* pFDF, FX_BOOL bNotify)
1582 {
1583     if (pFDF == NULL) {
1584         return FALSE;
1585     }
1586     CPDF_Dictionary* pMainDict = pFDF->GetRoot()->GetDict("FDF");
1587     if (pMainDict == NULL) {
1588         return FALSE;
1589     }
1590     CPDF_Array* pFields = pMainDict->GetArray("Fields");
1591     if (pFields == NULL) {
1592         return FALSE;
1593     }
1594     m_bsEncoding = pMainDict->GetString(FX_BSTRC("Encoding"));
1595     if (bNotify && m_pFormNotify != NULL) {
1596         int iRet = m_pFormNotify->BeforeFormImportData(this);
1597         if (iRet < 0) {
1598             return FALSE;
1599         }
1600     }
1601     for (FX_DWORD i = 0; i < pFields->GetCount(); i ++) {
1602         CPDF_Dictionary* pField = pFields->GetDict(i);
1603         if (pField == NULL) {
1604             continue;
1605         }
1606         FDF_ImportField(pField, L"", bNotify);
1607     }
1608     if (bNotify && m_pFormNotify != NULL) {
1609         m_pFormNotify->AfterFormImportData(this);
1610     }
1611     return TRUE;
1612 }
1613 void CPDF_InterForm::SetFormNotify(const CPDF_FormNotify* pNotify)
1614 {
1615     m_pFormNotify = (CPDF_FormNotify*)pNotify;
1616 }
1617 int CPDF_InterForm::GetPageWithWidget(int iCurPage, FX_BOOL bNext)
1618 {
1619     if (iCurPage < 0) {
1620         return -1;
1621     }
1622     int iPageCount = m_pDocument->GetPageCount();
1623     if (iCurPage >= iPageCount) {
1624         return -1;
1625     }
1626     int iNewPage = iCurPage;
1627     do {
1628         iNewPage += bNext ? 1 : -1;
1629         if (iNewPage >= iPageCount) {
1630             iNewPage = 0;
1631         }
1632         if (iNewPage < 0) {
1633             iNewPage = iPageCount - 1;
1634         }
1635         if (iNewPage == iCurPage) {
1636             break;
1637         }
1638         CPDF_Dictionary* pPageDict = m_pDocument->GetPage(iNewPage);
1639         if (pPageDict == NULL) {
1640             continue;
1641         }
1642         CPDF_Array* pAnnots = pPageDict->GetArray("Annots");
1643         if (pAnnots == NULL) {
1644             continue;
1645         }
1646         FX_DWORD dwCount = pAnnots->GetCount();
1647         for (FX_DWORD i = 0; i < dwCount; i ++) {
1648             CPDF_Object* pAnnotDict = pAnnots->GetElementValue(i);
1649             if (pAnnotDict == NULL) {
1650                 continue;
1651             }
1652             CPDF_FormControl* pControl = NULL;
1653             if (m_ControlMap.Lookup(pAnnotDict, (void*&)pControl)) {
1654                 return iNewPage;
1655             }
1656         }
1657     } while (TRUE);
1658     return -1;
1659 }