Remove JavaScript.h
[pdfium.git] / fpdfsdk / src / javascript / Field.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/javascript/IJavaScript.h"
8 #include "../../include/javascript/JS_Define.h"
9 #include "../../include/javascript/JS_Object.h"
10 #include "../../include/javascript/JS_Value.h"
11 #include "../../include/javascript/Field.h"
12 #include "../../include/javascript/JS_EventHandler.h"
13 #include "../../include/javascript/JS_Context.h"
14 #include "../../include/javascript/JS_Runtime.h"
15 #include "../../include/javascript/Document.h"
16 #include "../../include/javascript/color.h"
17 #include "../../include/javascript/PublicMethods.h"
18 #include "../../include/javascript/Icon.h"
19
20 /* ---------------------- Field ---------------------- */
21
22 BEGIN_JS_STATIC_CONST(CJS_Field)
23 END_JS_STATIC_CONST()
24
25 BEGIN_JS_STATIC_PROP(CJS_Field)
26 JS_STATIC_PROP_ENTRY(alignment)
27 JS_STATIC_PROP_ENTRY(borderStyle)
28 JS_STATIC_PROP_ENTRY(buttonAlignX)
29 JS_STATIC_PROP_ENTRY(buttonAlignY)
30 JS_STATIC_PROP_ENTRY(buttonFitBounds)
31 JS_STATIC_PROP_ENTRY(buttonPosition)
32 JS_STATIC_PROP_ENTRY(buttonScaleHow)
33 JS_STATIC_PROP_ENTRY(buttonScaleWhen)
34 JS_STATIC_PROP_ENTRY(calcOrderIndex)
35 JS_STATIC_PROP_ENTRY(charLimit)
36 JS_STATIC_PROP_ENTRY(comb)
37 JS_STATIC_PROP_ENTRY(commitOnSelChange)
38 JS_STATIC_PROP_ENTRY(currentValueIndices)
39 JS_STATIC_PROP_ENTRY(defaultStyle)
40 JS_STATIC_PROP_ENTRY(defaultValue)
41 JS_STATIC_PROP_ENTRY(doNotScroll)
42 JS_STATIC_PROP_ENTRY(doNotSpellCheck)
43 JS_STATIC_PROP_ENTRY(delay)
44 JS_STATIC_PROP_ENTRY(display)
45 JS_STATIC_PROP_ENTRY(doc)
46 JS_STATIC_PROP_ENTRY(editable)
47 JS_STATIC_PROP_ENTRY(exportValues)
48 JS_STATIC_PROP_ENTRY(hidden)
49 JS_STATIC_PROP_ENTRY(fileSelect)
50 JS_STATIC_PROP_ENTRY(fillColor)
51 JS_STATIC_PROP_ENTRY(lineWidth)
52 JS_STATIC_PROP_ENTRY(highlight)
53 JS_STATIC_PROP_ENTRY(multiline)
54 JS_STATIC_PROP_ENTRY(multipleSelection)
55 JS_STATIC_PROP_ENTRY(name)
56 JS_STATIC_PROP_ENTRY(numItems)
57 JS_STATIC_PROP_ENTRY(page)
58 JS_STATIC_PROP_ENTRY(password)
59 JS_STATIC_PROP_ENTRY(print)
60 JS_STATIC_PROP_ENTRY(radiosInUnison)
61 JS_STATIC_PROP_ENTRY(readonly)
62 JS_STATIC_PROP_ENTRY(rect)
63 JS_STATIC_PROP_ENTRY(required)
64 JS_STATIC_PROP_ENTRY(richText)
65 JS_STATIC_PROP_ENTRY(richValue)
66 JS_STATIC_PROP_ENTRY(rotation)
67 JS_STATIC_PROP_ENTRY(strokeColor)
68 JS_STATIC_PROP_ENTRY(style)
69 JS_STATIC_PROP_ENTRY(submitName)
70 JS_STATIC_PROP_ENTRY(textColor)
71 JS_STATIC_PROP_ENTRY(textFont)
72 JS_STATIC_PROP_ENTRY(textSize)
73 JS_STATIC_PROP_ENTRY(type)
74 JS_STATIC_PROP_ENTRY(userName)
75 JS_STATIC_PROP_ENTRY(value)
76 JS_STATIC_PROP_ENTRY(valueAsString)
77 JS_STATIC_PROP_ENTRY(source)
78 END_JS_STATIC_PROP()
79
80 BEGIN_JS_STATIC_METHOD(CJS_Field)
81 JS_STATIC_METHOD_ENTRY(browseForFileToSubmit)
82 JS_STATIC_METHOD_ENTRY(buttonGetCaption)
83 JS_STATIC_METHOD_ENTRY(buttonGetIcon)
84 JS_STATIC_METHOD_ENTRY(buttonImportIcon)
85 JS_STATIC_METHOD_ENTRY(buttonSetCaption)
86 JS_STATIC_METHOD_ENTRY(buttonSetIcon)
87 JS_STATIC_METHOD_ENTRY(checkThisBox)
88 JS_STATIC_METHOD_ENTRY(clearItems)
89 JS_STATIC_METHOD_ENTRY(defaultIsChecked)
90 JS_STATIC_METHOD_ENTRY(deleteItemAt)
91 JS_STATIC_METHOD_ENTRY(getArray)
92 JS_STATIC_METHOD_ENTRY(getItemAt)
93 JS_STATIC_METHOD_ENTRY(getLock)
94 JS_STATIC_METHOD_ENTRY(insertItemAt)
95 JS_STATIC_METHOD_ENTRY(isBoxChecked)
96 JS_STATIC_METHOD_ENTRY(isDefaultChecked)
97 JS_STATIC_METHOD_ENTRY(setAction)
98 JS_STATIC_METHOD_ENTRY(setFocus)
99 JS_STATIC_METHOD_ENTRY(setItems)
100 JS_STATIC_METHOD_ENTRY(setLock)
101 JS_STATIC_METHOD_ENTRY(signatureGetModifications)
102 JS_STATIC_METHOD_ENTRY(signatureGetSeedValue)
103 JS_STATIC_METHOD_ENTRY(signatureInfo)
104 JS_STATIC_METHOD_ENTRY(signatureSetSeedValue)
105 JS_STATIC_METHOD_ENTRY(signatureSign)
106 JS_STATIC_METHOD_ENTRY(signatureValidate)
107 END_JS_STATIC_METHOD()
108
109 IMPLEMENT_JS_CLASS(CJS_Field, Field)
110
111 FX_BOOL CJS_Field::InitInstance(IFXJS_Context* cc) {
112   CJS_Context* pContext = (CJS_Context*)cc;
113   ASSERT(pContext != NULL);
114
115   Field* pField = (Field*)GetEmbedObject();
116   ASSERT(pField != NULL);
117
118   pField->SetIsolate(pContext->GetJSRuntime()->GetIsolate());
119
120   return TRUE;
121 };
122
123 Field::Field(CJS_Object* pJSObject)
124     : CJS_EmbedObj(pJSObject),
125       m_pJSDoc(NULL),
126       m_pDocument(NULL),
127       m_nFormControlIndex(-1),
128       m_bCanSet(FALSE),
129       m_bDelay(FALSE),
130       m_isolate(NULL) {}
131
132 Field::~Field() {}
133
134 // note: iControlNo = -1, means not a widget.
135 void Field::ParseFieldName(const std::wstring& strFieldNameParsed,
136                            std::wstring& strFieldName,
137                            int& iControlNo) {
138   int iStart = strFieldNameParsed.find_last_of(L'.');
139   if (iStart == -1) {
140     strFieldName = strFieldNameParsed;
141     iControlNo = -1;
142     return;
143   }
144   std::wstring suffixal = strFieldNameParsed.substr(iStart + 1);
145   iControlNo = FXSYS_wtoi(suffixal.c_str());
146   if (iControlNo == 0) {
147     int iStart;
148     while ((iStart = suffixal.find_last_of(L" ")) != -1) {
149       suffixal.erase(iStart, 1);
150     }
151
152     if (suffixal.compare(L"0") != 0) {
153       strFieldName = strFieldNameParsed;
154       iControlNo = -1;
155       return;
156     }
157   }
158   strFieldName = strFieldNameParsed.substr(0, iStart);
159 }
160
161 FX_BOOL Field::AttachField(Document* pDocument,
162                            const CFX_WideString& csFieldName) {
163   ASSERT(pDocument != NULL);
164   m_pJSDoc = pDocument;
165
166   m_pDocument = pDocument->GetReaderDoc();
167   ASSERT(m_pDocument != NULL);
168
169   m_bCanSet = m_pDocument->GetPermissions(FPDFPERM_FILL_FORM) ||
170               m_pDocument->GetPermissions(FPDFPERM_ANNOT_FORM) ||
171               m_pDocument->GetPermissions(FPDFPERM_MODIFY);
172
173   CPDFSDK_InterForm* pRDInterForm = m_pDocument->GetInterForm();
174   ASSERT(pRDInterForm != NULL);
175
176   CPDF_InterForm* pInterForm = pRDInterForm->GetInterForm();
177   ASSERT(pInterForm != NULL);
178
179   CFX_WideString swFieldNameTemp = csFieldName;
180   swFieldNameTemp.Replace(L"..", L".");
181
182   if (pInterForm->CountFields(swFieldNameTemp) <= 0) {
183     std::wstring strFieldName;
184     int iControlNo = -1;
185     ParseFieldName(swFieldNameTemp.c_str(), strFieldName, iControlNo);
186     if (iControlNo == -1)
187       return FALSE;
188
189     m_FieldName = strFieldName.c_str();
190     m_nFormControlIndex = iControlNo;
191     return TRUE;
192   }
193
194   m_FieldName = swFieldNameTemp;
195   m_nFormControlIndex = -1;
196
197   return TRUE;
198 }
199
200 void Field::GetFormFields(CPDFSDK_Document* pDocument,
201                           const CFX_WideString& csFieldName,
202                           CFX_PtrArray& FieldArray) {
203   ASSERT(pDocument != NULL);
204
205   CPDFSDK_InterForm* pReaderInterForm = pDocument->GetInterForm();
206   ASSERT(pReaderInterForm != NULL);
207
208   CPDF_InterForm* pInterForm = pReaderInterForm->GetInterForm();
209   ASSERT(pInterForm != NULL);
210
211   ASSERT(FieldArray.GetSize() == 0);
212
213   for (int i = 0, sz = pInterForm->CountFields(csFieldName); i < sz; i++) {
214     if (CPDF_FormField* pFormField = pInterForm->GetField(i, csFieldName))
215       FieldArray.Add((void*)pFormField);
216   }
217 }
218
219 void Field::GetFormFields(const CFX_WideString& csFieldName,
220                           CFX_PtrArray& FieldArray) {
221   ASSERT(m_pDocument != NULL);
222
223   Field::GetFormFields(m_pDocument, csFieldName, FieldArray);
224 }
225
226 void Field::UpdateFormField(CPDFSDK_Document* pDocument,
227                             CPDF_FormField* pFormField,
228                             FX_BOOL bChangeMark,
229                             FX_BOOL bResetAP,
230                             FX_BOOL bRefresh) {
231   ASSERT(pDocument != NULL);
232   ASSERT(pFormField != NULL);
233
234   CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)pDocument->GetInterForm();
235   ASSERT(pInterForm != NULL);
236
237   CFX_PtrArray widgets;
238   pInterForm->GetWidgets(pFormField, widgets);
239
240   if (bResetAP) {
241     int nFieldType = pFormField->GetFieldType();
242     if (nFieldType == FIELDTYPE_COMBOBOX || nFieldType == FIELDTYPE_TEXTFIELD) {
243       for (int i = 0, sz = widgets.GetSize(); i < sz; i++) {
244         CPDFSDK_Widget* pWidget = (CPDFSDK_Widget*)widgets.GetAt(i);
245         ASSERT(pWidget != NULL);
246
247         FX_BOOL bFormated = FALSE;
248         CFX_WideString sValue = pWidget->OnFormat(bFormated);
249         if (bFormated)
250           pWidget->ResetAppearance(sValue.c_str(), FALSE);
251         else
252           pWidget->ResetAppearance(NULL, FALSE);
253       }
254     } else {
255       for (int i = 0, sz = widgets.GetSize(); i < sz; i++) {
256         CPDFSDK_Widget* pWidget = (CPDFSDK_Widget*)widgets.GetAt(i);
257         ASSERT(pWidget != NULL);
258
259         pWidget->ResetAppearance(NULL, FALSE);
260       }
261     }
262   }
263
264   if (bRefresh) {
265     for (int i = 0, sz = widgets.GetSize(); i < sz; i++) {
266       CPDFSDK_Widget* pWidget = (CPDFSDK_Widget*)widgets.GetAt(i);
267       ASSERT(pWidget != NULL);
268
269       CPDFSDK_InterForm* pInterForm = pWidget->GetInterForm();
270       CPDFSDK_Document* pDoc = pInterForm->GetDocument();
271       //          CReader_Page* pPage = pWidget->GetPage();
272       ASSERT(pDoc != NULL);
273       pDoc->UpdateAllViews(NULL, pWidget);
274     }
275   }
276
277   if (bChangeMark)
278     pDocument->SetChangeMark();
279 }
280
281 void Field::UpdateFormControl(CPDFSDK_Document* pDocument,
282                               CPDF_FormControl* pFormControl,
283                               FX_BOOL bChangeMark,
284                               FX_BOOL bResetAP,
285                               FX_BOOL bRefresh) {
286   ASSERT(pDocument != NULL);
287   ASSERT(pFormControl != NULL);
288
289   CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)pDocument->GetInterForm();
290   ASSERT(pInterForm != NULL);
291
292   CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl);
293
294   if (pWidget) {
295     if (bResetAP) {
296       int nFieldType = pWidget->GetFieldType();
297       if (nFieldType == FIELDTYPE_COMBOBOX ||
298           nFieldType == FIELDTYPE_TEXTFIELD) {
299         FX_BOOL bFormated = FALSE;
300         CFX_WideString sValue = pWidget->OnFormat(bFormated);
301         if (bFormated)
302           pWidget->ResetAppearance(sValue.c_str(), FALSE);
303         else
304           pWidget->ResetAppearance(NULL, FALSE);
305       } else {
306         pWidget->ResetAppearance(NULL, FALSE);
307       }
308     }
309
310     if (bRefresh) {
311       CPDFSDK_InterForm* pInterForm = pWidget->GetInterForm();
312       CPDFSDK_Document* pDoc = pInterForm->GetDocument();
313       ASSERT(pDoc != NULL);
314       pDoc->UpdateAllViews(NULL, pWidget);
315     }
316   }
317
318   if (bChangeMark)
319     pDocument->SetChangeMark();
320 }
321
322 CPDFSDK_Widget* Field::GetWidget(CPDFSDK_Document* pDocument,
323                                  CPDF_FormControl* pFormControl) {
324   ASSERT(pDocument != NULL);
325   ASSERT(pFormControl != NULL);
326
327   CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)pDocument->GetInterForm();
328   ASSERT(pInterForm != NULL);
329
330   return pInterForm->GetWidget(pFormControl);
331 }
332
333 FX_BOOL Field::ValueIsOccur(CPDF_FormField* pFormField,
334                             CFX_WideString csOptLabel) {
335   ASSERT(pFormField != NULL);
336
337   for (int i = 0, sz = pFormField->CountOptions(); i < sz; i++) {
338     if (csOptLabel.Compare(pFormField->GetOptionLabel(i)) == 0)
339       return TRUE;
340   }
341
342   return FALSE;
343 }
344
345 CPDF_FormControl* Field::GetSmartFieldControl(CPDF_FormField* pFormField) {
346   if (!pFormField->CountControls() ||
347       m_nFormControlIndex >= pFormField->CountControls())
348     return NULL;
349
350   if (m_nFormControlIndex < 0)
351     return pFormField->GetControl(0);
352
353   return pFormField->GetControl(m_nFormControlIndex);
354 }
355
356 /* ---------------------------------------- property
357  * ---------------------------------------- */
358
359 FX_BOOL Field::alignment(IFXJS_Context* cc,
360                          CJS_PropValue& vp,
361                          CFX_WideString& sError) {
362   ASSERT(m_pDocument != NULL);
363
364   if (vp.IsSetting()) {
365     if (!m_bCanSet)
366       return FALSE;
367
368     CFX_ByteString alignStr;
369     vp >> alignStr;
370
371     if (m_bDelay) {
372       AddDelay_String(FP_ALIGNMENT, alignStr);
373     } else {
374       Field::SetAlignment(m_pDocument, m_FieldName, m_nFormControlIndex,
375                           alignStr);
376     }
377   } else {
378     CFX_PtrArray FieldArray;
379     GetFormFields(m_FieldName, FieldArray);
380     if (FieldArray.GetSize() <= 0)
381       return FALSE;
382
383     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
384     ASSERT(pFormField != NULL);
385
386     if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
387       return FALSE;
388
389     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
390     if (!pFormControl)
391       return FALSE;
392
393     switch (pFormControl->GetControlAlignment()) {
394       case 1:
395         vp << L"center";
396         break;
397       case 0:
398         vp << L"left";
399         break;
400       case 2:
401         vp << L"right";
402         break;
403       default:
404         vp << L"";
405     }
406   }
407
408   return TRUE;
409 }
410
411 void Field::SetAlignment(CPDFSDK_Document* pDocument,
412                          const CFX_WideString& swFieldName,
413                          int nControlIndex,
414                          const CFX_ByteString& string) {
415   // Not supported.
416 }
417
418 FX_BOOL Field::borderStyle(IFXJS_Context* cc,
419                            CJS_PropValue& vp,
420                            CFX_WideString& sError) {
421   ASSERT(m_pDocument != NULL);
422
423   if (vp.IsSetting()) {
424     if (!m_bCanSet)
425       return FALSE;
426
427     CFX_ByteString strType = "";
428     vp >> strType;
429
430     if (m_bDelay) {
431       AddDelay_String(FP_BORDERSTYLE, strType);
432     } else {
433       Field::SetBorderStyle(m_pDocument, m_FieldName, m_nFormControlIndex,
434                             strType);
435     }
436   } else {
437     CFX_PtrArray FieldArray;
438     GetFormFields(m_FieldName, FieldArray);
439     if (FieldArray.GetSize() <= 0)
440       return FALSE;
441
442     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
443     if (!pFormField)
444       return FALSE;
445
446     CPDFSDK_Widget* pWidget =
447         GetWidget(m_pDocument, GetSmartFieldControl(pFormField));
448     if (!pWidget)
449       return FALSE;
450
451     int nBorderstyle = pWidget->GetBorderStyle();
452
453     switch (nBorderstyle) {
454       case BBS_SOLID:
455         vp << L"solid";
456         break;
457       case BBS_DASH:
458         vp << L"dashed";
459         break;
460       case BBS_BEVELED:
461         vp << L"beveled";
462         break;
463       case BBS_INSET:
464         vp << L"inset";
465         break;
466       case BBS_UNDERLINE:
467         vp << L"underline";
468         break;
469       default:
470         vp << L"";
471         break;
472     }
473   }
474
475   return TRUE;
476 }
477
478 void Field::SetBorderStyle(CPDFSDK_Document* pDocument,
479                            const CFX_WideString& swFieldName,
480                            int nControlIndex,
481                            const CFX_ByteString& string) {
482   ASSERT(pDocument != NULL);
483
484   int nBorderStyle = 0;
485
486   if (string == "solid")
487     nBorderStyle = BBS_SOLID;
488   else if (string == "beveled")
489     nBorderStyle = BBS_BEVELED;
490   else if (string == "dashed")
491     nBorderStyle = BBS_DASH;
492   else if (string == "inset")
493     nBorderStyle = BBS_INSET;
494   else if (string == "underline")
495     nBorderStyle = BBS_UNDERLINE;
496   else
497     return;
498
499   CFX_PtrArray FieldArray;
500   GetFormFields(pDocument, swFieldName, FieldArray);
501
502   for (int i = 0, isz = FieldArray.GetSize(); i < isz; i++) {
503     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
504     ASSERT(pFormField != NULL);
505
506     if (nControlIndex < 0) {
507       FX_BOOL bSet = FALSE;
508       for (int j = 0, jsz = pFormField->CountControls(); j < jsz; j++) {
509         if (CPDFSDK_Widget* pWidget =
510                 GetWidget(pDocument, pFormField->GetControl(j))) {
511           if (pWidget->GetBorderStyle() != nBorderStyle) {
512             pWidget->SetBorderStyle(nBorderStyle);
513             bSet = TRUE;
514           }
515         }
516       }
517       if (bSet)
518         UpdateFormField(pDocument, pFormField, TRUE, TRUE, TRUE);
519     } else {
520       if (nControlIndex >= pFormField->CountControls())
521         return;
522       if (CPDF_FormControl* pFormControl =
523               pFormField->GetControl(nControlIndex)) {
524         if (CPDFSDK_Widget* pWidget = GetWidget(pDocument, pFormControl)) {
525           if (pWidget->GetBorderStyle() != nBorderStyle) {
526             pWidget->SetBorderStyle(nBorderStyle);
527             UpdateFormControl(pDocument, pFormControl, TRUE, TRUE, TRUE);
528           }
529         }
530       }
531     }
532   }
533 }
534
535 FX_BOOL Field::buttonAlignX(IFXJS_Context* cc,
536                             CJS_PropValue& vp,
537                             CFX_WideString& sError) {
538   ASSERT(m_pDocument != NULL);
539
540   if (vp.IsSetting()) {
541     if (!m_bCanSet)
542       return FALSE;
543
544     int nVP;
545     vp >> nVP;
546
547     if (m_bDelay) {
548       AddDelay_Int(FP_BUTTONALIGNX, nVP);
549     } else {
550       Field::SetButtonAlignX(m_pDocument, m_FieldName, m_nFormControlIndex,
551                              nVP);
552     }
553   } else {
554     CFX_PtrArray FieldArray;
555     GetFormFields(m_FieldName, FieldArray);
556     if (FieldArray.GetSize() <= 0)
557       return FALSE;
558
559     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
560     ASSERT(pFormField != NULL);
561
562     if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
563       return FALSE;
564
565     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
566     if (!pFormControl)
567       return FALSE;
568
569     CPDF_IconFit IconFit = pFormControl->GetIconFit();
570
571     FX_FLOAT fLeft, fBottom;
572     IconFit.GetIconPosition(fLeft, fBottom);
573
574     vp << (int32_t)fLeft;
575   }
576
577   return TRUE;
578 }
579
580 void Field::SetButtonAlignX(CPDFSDK_Document* pDocument,
581                             const CFX_WideString& swFieldName,
582                             int nControlIndex,
583                             int number) {
584   // Not supported.
585 }
586
587 FX_BOOL Field::buttonAlignY(IFXJS_Context* cc,
588                             CJS_PropValue& vp,
589                             CFX_WideString& sError) {
590   ASSERT(m_pDocument != NULL);
591
592   if (vp.IsSetting()) {
593     if (!m_bCanSet)
594       return FALSE;
595
596     int nVP;
597     vp >> nVP;
598
599     if (m_bDelay) {
600       AddDelay_Int(FP_BUTTONALIGNY, nVP);
601     } else {
602       Field::SetButtonAlignY(m_pDocument, m_FieldName, m_nFormControlIndex,
603                              nVP);
604     }
605   } else {
606     CFX_PtrArray FieldArray;
607     GetFormFields(m_FieldName, FieldArray);
608     if (FieldArray.GetSize() <= 0)
609       return FALSE;
610
611     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
612     ASSERT(pFormField != NULL);
613
614     if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
615       return FALSE;
616
617     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
618     if (!pFormControl)
619       return FALSE;
620
621     CPDF_IconFit IconFit = pFormControl->GetIconFit();
622
623     FX_FLOAT fLeft, fBottom;
624     IconFit.GetIconPosition(fLeft, fBottom);
625
626     vp << (int32_t)fBottom;
627   }
628
629   return TRUE;
630 }
631
632 void Field::SetButtonAlignY(CPDFSDK_Document* pDocument,
633                             const CFX_WideString& swFieldName,
634                             int nControlIndex,
635                             int number) {
636   // Not supported.
637 }
638
639 FX_BOOL Field::buttonFitBounds(IFXJS_Context* cc,
640                                CJS_PropValue& vp,
641                                CFX_WideString& sError) {
642   ASSERT(m_pDocument != NULL);
643
644   if (vp.IsSetting()) {
645     if (!m_bCanSet)
646       return FALSE;
647
648     bool bVP;
649     vp >> bVP;
650
651     if (m_bDelay) {
652       AddDelay_Bool(FP_BUTTONFITBOUNDS, bVP);
653     } else {
654       Field::SetButtonFitBounds(m_pDocument, m_FieldName, m_nFormControlIndex,
655                                 bVP);
656     }
657   } else {
658     CFX_PtrArray FieldArray;
659     GetFormFields(m_FieldName, FieldArray);
660     if (FieldArray.GetSize() <= 0)
661       return FALSE;
662
663     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
664     ASSERT(pFormField != NULL);
665
666     if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
667       return FALSE;
668
669     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
670     if (!pFormControl)
671       return FALSE;
672
673     CPDF_IconFit IconFit = pFormControl->GetIconFit();
674     vp << IconFit.GetFittingBounds();
675   }
676
677   return TRUE;
678 }
679
680 void Field::SetButtonFitBounds(CPDFSDK_Document* pDocument,
681                                const CFX_WideString& swFieldName,
682                                int nControlIndex,
683                                bool b) {
684   // Not supported.
685 }
686
687 FX_BOOL Field::buttonPosition(IFXJS_Context* cc,
688                               CJS_PropValue& vp,
689                               CFX_WideString& sError) {
690   ASSERT(m_pDocument != NULL);
691
692   if (vp.IsSetting()) {
693     if (!m_bCanSet)
694       return FALSE;
695
696     int nVP;
697     vp >> nVP;
698
699     if (m_bDelay) {
700       AddDelay_Int(FP_BUTTONPOSITION, nVP);
701     } else {
702       Field::SetButtonPosition(m_pDocument, m_FieldName, m_nFormControlIndex,
703                                nVP);
704     }
705   } else {
706     CFX_PtrArray FieldArray;
707     GetFormFields(m_FieldName, FieldArray);
708     if (FieldArray.GetSize() <= 0)
709       return FALSE;
710
711     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
712     ASSERT(pFormField != NULL);
713
714     if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
715       return FALSE;
716
717     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
718     if (!pFormControl)
719       return FALSE;
720
721     vp << pFormControl->GetTextPosition();
722   }
723   return TRUE;
724 }
725
726 void Field::SetButtonPosition(CPDFSDK_Document* pDocument,
727                               const CFX_WideString& swFieldName,
728                               int nControlIndex,
729                               int number) {
730   // Not supported.
731 }
732
733 FX_BOOL Field::buttonScaleHow(IFXJS_Context* cc,
734                               CJS_PropValue& vp,
735                               CFX_WideString& sError) {
736   ASSERT(m_pDocument != NULL);
737
738   if (vp.IsSetting()) {
739     if (!m_bCanSet)
740       return FALSE;
741
742     int nVP;
743     vp >> nVP;
744
745     if (m_bDelay) {
746       AddDelay_Int(FP_BUTTONSCALEHOW, nVP);
747     } else {
748       Field::SetButtonScaleHow(m_pDocument, m_FieldName, m_nFormControlIndex,
749                                nVP);
750     }
751   } else {
752     CFX_PtrArray FieldArray;
753     GetFormFields(m_FieldName, FieldArray);
754     if (FieldArray.GetSize() <= 0)
755       return FALSE;
756
757     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
758     ASSERT(pFormField != NULL);
759
760     if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
761       return FALSE;
762
763     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
764     if (!pFormControl)
765       return FALSE;
766
767     CPDF_IconFit IconFit = pFormControl->GetIconFit();
768     if (IconFit.IsProportionalScale())
769       vp << (int32_t)0;
770     else
771       vp << (int32_t)1;
772   }
773
774   return TRUE;
775 }
776
777 void Field::SetButtonScaleHow(CPDFSDK_Document* pDocument,
778                               const CFX_WideString& swFieldName,
779                               int nControlIndex,
780                               int number) {
781   // Not supported.
782 }
783
784 FX_BOOL Field::buttonScaleWhen(IFXJS_Context* cc,
785                                CJS_PropValue& vp,
786                                CFX_WideString& sError) {
787   ASSERT(m_pDocument != NULL);
788
789   if (vp.IsSetting()) {
790     if (!m_bCanSet)
791       return FALSE;
792
793     int nVP;
794     vp >> nVP;
795
796     if (m_bDelay) {
797       AddDelay_Int(FP_BUTTONSCALEWHEN, nVP);
798     } else {
799       Field::SetButtonScaleWhen(m_pDocument, m_FieldName, m_nFormControlIndex,
800                                 nVP);
801     }
802   } else {
803     CFX_PtrArray FieldArray;
804     GetFormFields(m_FieldName, FieldArray);
805     if (FieldArray.GetSize() <= 0)
806       return FALSE;
807
808     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
809     ASSERT(pFormField != NULL);
810
811     if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
812       return FALSE;
813
814     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
815     if (!pFormControl)
816       return FALSE;
817
818     CPDF_IconFit IconFit = pFormControl->GetIconFit();
819     int ScaleM = IconFit.GetScaleMethod();
820     switch (ScaleM) {
821       case CPDF_IconFit::Always:
822         vp << (int32_t)CPDF_IconFit::Always;
823         break;
824       case CPDF_IconFit::Bigger:
825         vp << (int32_t)CPDF_IconFit::Bigger;
826         break;
827       case CPDF_IconFit::Never:
828         vp << (int32_t)CPDF_IconFit::Never;
829         break;
830       case CPDF_IconFit::Smaller:
831         vp << (int32_t)CPDF_IconFit::Smaller;
832         break;
833     }
834   }
835
836   return TRUE;
837 }
838
839 void Field::SetButtonScaleWhen(CPDFSDK_Document* pDocument,
840                                const CFX_WideString& swFieldName,
841                                int nControlIndex,
842                                int number) {
843   // Not supported.
844 }
845
846 FX_BOOL Field::calcOrderIndex(IFXJS_Context* cc,
847                               CJS_PropValue& vp,
848                               CFX_WideString& sError) {
849   ASSERT(m_pDocument != NULL);
850
851   if (vp.IsSetting()) {
852     if (!m_bCanSet)
853       return FALSE;
854
855     int nVP;
856     vp >> nVP;
857
858     if (m_bDelay) {
859       AddDelay_Int(FP_CALCORDERINDEX, nVP);
860     } else {
861       Field::SetCalcOrderIndex(m_pDocument, m_FieldName, m_nFormControlIndex,
862                                nVP);
863     }
864   } else {
865     CFX_PtrArray FieldArray;
866     GetFormFields(m_FieldName, FieldArray);
867     if (FieldArray.GetSize() <= 0)
868       return FALSE;
869
870     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
871     ASSERT(pFormField != NULL);
872
873     if (pFormField->GetFieldType() != FIELDTYPE_COMBOBOX &&
874         pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
875       return FALSE;
876
877     CPDFSDK_InterForm* pRDInterForm = m_pDocument->GetInterForm();
878     ASSERT(pRDInterForm != NULL);
879
880     CPDF_InterForm* pInterForm = pRDInterForm->GetInterForm();
881     ASSERT(pInterForm != NULL);
882
883     vp << (int32_t)pInterForm->FindFieldInCalculationOrder(pFormField);
884   }
885
886   return TRUE;
887 }
888
889 void Field::SetCalcOrderIndex(CPDFSDK_Document* pDocument,
890                               const CFX_WideString& swFieldName,
891                               int nControlIndex,
892                               int number) {
893   // Not supported.
894 }
895
896 FX_BOOL Field::charLimit(IFXJS_Context* cc,
897                          CJS_PropValue& vp,
898                          CFX_WideString& sError) {
899   ASSERT(m_pDocument != NULL);
900
901   if (vp.IsSetting()) {
902     if (!m_bCanSet)
903       return FALSE;
904
905     int nVP;
906     vp >> nVP;
907
908     if (m_bDelay) {
909       AddDelay_Int(FP_CHARLIMIT, nVP);
910     } else {
911       Field::SetCharLimit(m_pDocument, m_FieldName, m_nFormControlIndex, nVP);
912     }
913   } else {
914     CFX_PtrArray FieldArray;
915     GetFormFields(m_FieldName, FieldArray);
916     if (FieldArray.GetSize() <= 0)
917       return FALSE;
918
919     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
920     ASSERT(pFormField != NULL);
921
922     if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
923       return FALSE;
924
925     vp << (int32_t)pFormField->GetMaxLen();
926   }
927   return TRUE;
928 }
929
930 void Field::SetCharLimit(CPDFSDK_Document* pDocument,
931                          const CFX_WideString& swFieldName,
932                          int nControlIndex,
933                          int number) {
934   // Not supported.
935 }
936
937 FX_BOOL Field::comb(IFXJS_Context* cc,
938                     CJS_PropValue& vp,
939                     CFX_WideString& sError) {
940   ASSERT(m_pDocument != NULL);
941
942   if (vp.IsSetting()) {
943     if (!m_bCanSet)
944       return FALSE;
945
946     bool bVP;
947     vp >> bVP;
948
949     if (m_bDelay) {
950       AddDelay_Bool(FP_COMB, bVP);
951     } else {
952       Field::SetComb(m_pDocument, m_FieldName, m_nFormControlIndex, bVP);
953     }
954   } else {
955     CFX_PtrArray FieldArray;
956     GetFormFields(m_FieldName, FieldArray);
957     if (FieldArray.GetSize() <= 0)
958       return FALSE;
959
960     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
961     ASSERT(pFormField != NULL);
962
963     if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
964       return FALSE;
965
966     if (pFormField->GetFieldFlags() & FIELDFLAG_COMB)
967       vp << true;
968     else
969       vp << false;
970   }
971
972   return TRUE;
973 }
974
975 void Field::SetComb(CPDFSDK_Document* pDocument,
976                     const CFX_WideString& swFieldName,
977                     int nControlIndex,
978                     bool b) {
979   // Not supported.
980 }
981
982 FX_BOOL Field::commitOnSelChange(IFXJS_Context* cc,
983                                  CJS_PropValue& vp,
984                                  CFX_WideString& sError) {
985   ASSERT(m_pDocument != NULL);
986
987   if (vp.IsSetting()) {
988     if (!m_bCanSet)
989       return FALSE;
990
991     bool bVP;
992     vp >> bVP;
993
994     if (m_bDelay) {
995       AddDelay_Bool(FP_COMMITONSELCHANGE, bVP);
996     } else {
997       Field::SetCommitOnSelChange(m_pDocument, m_FieldName, m_nFormControlIndex,
998                                   bVP);
999     }
1000   } else {
1001     CFX_PtrArray FieldArray;
1002     GetFormFields(m_FieldName, FieldArray);
1003     if (FieldArray.GetSize() <= 0)
1004       return FALSE;
1005
1006     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1007     ASSERT(pFormField != NULL);
1008
1009     if (pFormField->GetFieldType() != FIELDTYPE_COMBOBOX &&
1010         pFormField->GetFieldType() != FIELDTYPE_LISTBOX)
1011       return FALSE;
1012
1013     if (pFormField->GetFieldFlags() & FIELDFLAG_COMMITONSELCHANGE)
1014       vp << true;
1015     else
1016       vp << false;
1017   }
1018
1019   return TRUE;
1020 }
1021
1022 void Field::SetCommitOnSelChange(CPDFSDK_Document* pDocument,
1023                                  const CFX_WideString& swFieldName,
1024                                  int nControlIndex,
1025                                  bool b) {
1026   // Not supported.
1027 }
1028
1029 FX_BOOL Field::currentValueIndices(IFXJS_Context* cc,
1030                                    CJS_PropValue& vp,
1031                                    CFX_WideString& sError) {
1032   ASSERT(m_pDocument != NULL);
1033
1034   if (vp.IsSetting()) {
1035     if (!m_bCanSet)
1036       return FALSE;
1037
1038     CFX_DWordArray array;
1039
1040     if (vp.GetType() == CJS_Value::VT_number) {
1041       int iSelecting = 0;
1042       vp >> iSelecting;
1043       array.Add(iSelecting);
1044     } else if (vp.IsArrayObject()) {
1045       CJS_Array SelArray(m_isolate);
1046       CJS_Value SelValue(m_isolate);
1047       int iSelecting;
1048       vp >> SelArray;
1049       for (int i = 0, sz = SelArray.GetLength(); i < sz; i++) {
1050         SelArray.GetElement(i, SelValue);
1051         iSelecting = SelValue.ToInt();
1052         array.Add(iSelecting);
1053       }
1054     }
1055
1056     if (m_bDelay) {
1057       AddDelay_WordArray(FP_CURRENTVALUEINDICES, array);
1058     } else {
1059       Field::SetCurrentValueIndices(m_pDocument, m_FieldName,
1060                                     m_nFormControlIndex, array);
1061     }
1062   } else {
1063     CFX_PtrArray FieldArray;
1064     GetFormFields(m_FieldName, FieldArray);
1065     if (FieldArray.GetSize() <= 0)
1066       return FALSE;
1067
1068     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1069     ASSERT(pFormField != NULL);
1070
1071     if (pFormField->GetFieldType() != FIELDTYPE_COMBOBOX &&
1072         pFormField->GetFieldType() != FIELDTYPE_LISTBOX)
1073       return FALSE;
1074
1075     if (pFormField->CountSelectedItems() == 1)
1076       vp << pFormField->GetSelectedIndex(0);
1077     else if (pFormField->CountSelectedItems() > 1) {
1078       CJS_Array SelArray(m_isolate);
1079       for (int i = 0, sz = pFormField->CountSelectedItems(); i < sz; i++) {
1080         SelArray.SetElement(
1081             i, CJS_Value(m_isolate, pFormField->GetSelectedIndex(i)));
1082       }
1083       vp << SelArray;
1084     } else
1085       vp << -1;
1086   }
1087
1088   return TRUE;
1089 }
1090
1091 void Field::SetCurrentValueIndices(CPDFSDK_Document* pDocument,
1092                                    const CFX_WideString& swFieldName,
1093                                    int nControlIndex,
1094                                    const CFX_DWordArray& array) {
1095   ASSERT(pDocument != NULL);
1096
1097   CFX_PtrArray FieldArray;
1098   GetFormFields(pDocument, swFieldName, FieldArray);
1099
1100   for (int i = 0, isz = FieldArray.GetSize(); i < isz; i++) {
1101     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
1102     ASSERT(pFormField != NULL);
1103
1104     int nFieldType = pFormField->GetFieldType();
1105     if (nFieldType == FIELDTYPE_COMBOBOX || nFieldType == FIELDTYPE_LISTBOX) {
1106       FX_DWORD dwFieldFlags = pFormField->GetFieldFlags();
1107       pFormField->ClearSelection(TRUE);
1108
1109       for (int i = 0, sz = array.GetSize(); i < sz; i++) {
1110         if (i > 0 && !(dwFieldFlags & (1 << 21))) {
1111           break;
1112         }
1113
1114         int iSelecting = (int32_t)array.GetAt(i);
1115         if (iSelecting < pFormField->CountOptions() &&
1116             !pFormField->IsItemSelected(iSelecting))
1117           pFormField->SetItemSelection(iSelecting, TRUE);
1118       }
1119       UpdateFormField(pDocument, pFormField, TRUE, TRUE, TRUE);
1120     }
1121   }
1122 }
1123
1124 FX_BOOL Field::defaultStyle(IFXJS_Context* cc,
1125                             CJS_PropValue& vp,
1126                             CFX_WideString& sError) {
1127   // MQG sError = JSGetStringFromID(IDS_STRING_NOTSUPPORT);
1128   return FALSE;
1129
1130   if (vp.IsSetting()) {
1131     if (!m_bCanSet)
1132       return FALSE;
1133
1134     ;
1135   } else {
1136     ;
1137   }
1138   return TRUE;
1139 }
1140
1141 void Field::SetDefaultStyle(CPDFSDK_Document* pDocument,
1142                             const CFX_WideString& swFieldName,
1143                             int nControlIndex) {
1144   // Not supported.
1145 }
1146
1147 FX_BOOL Field::defaultValue(IFXJS_Context* cc,
1148                             CJS_PropValue& vp,
1149                             CFX_WideString& sError) {
1150   ASSERT(m_pDocument != NULL);
1151
1152   if (vp.IsSetting()) {
1153     if (!m_bCanSet)
1154       return FALSE;
1155
1156     CFX_WideString WideStr;
1157     vp >> WideStr;
1158
1159     if (m_bDelay) {
1160       AddDelay_WideString(FP_DEFAULTVALUE, WideStr);
1161     } else {
1162       Field::SetDefaultValue(m_pDocument, m_FieldName, m_nFormControlIndex,
1163                              WideStr);
1164     }
1165   } else {
1166     CFX_PtrArray FieldArray;
1167     GetFormFields(m_FieldName, FieldArray);
1168     if (FieldArray.GetSize() <= 0)
1169       return FALSE;
1170
1171     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1172     ASSERT(pFormField != NULL);
1173
1174     if (pFormField->GetFieldType() == FIELDTYPE_PUSHBUTTON ||
1175         pFormField->GetFieldType() == FIELDTYPE_SIGNATURE)
1176       return FALSE;
1177
1178     vp << pFormField->GetDefaultValue();
1179   }
1180   return TRUE;
1181 }
1182
1183 void Field::SetDefaultValue(CPDFSDK_Document* pDocument,
1184                             const CFX_WideString& swFieldName,
1185                             int nControlIndex,
1186                             const CFX_WideString& string) {
1187   // Not supported.
1188 }
1189
1190 FX_BOOL Field::doNotScroll(IFXJS_Context* cc,
1191                            CJS_PropValue& vp,
1192                            CFX_WideString& sError) {
1193   ASSERT(m_pDocument != NULL);
1194
1195   if (vp.IsSetting()) {
1196     if (!m_bCanSet)
1197       return FALSE;
1198
1199     bool bVP;
1200     vp >> bVP;
1201
1202     if (m_bDelay) {
1203       AddDelay_Bool(FP_DONOTSCROLL, bVP);
1204     } else {
1205       Field::SetDoNotScroll(m_pDocument, m_FieldName, m_nFormControlIndex, bVP);
1206     }
1207   } else {
1208     CFX_PtrArray FieldArray;
1209     GetFormFields(m_FieldName, FieldArray);
1210     if (FieldArray.GetSize() <= 0)
1211       return FALSE;
1212
1213     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1214     ASSERT(pFormField != NULL);
1215
1216     if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
1217       return FALSE;
1218
1219     if (pFormField->GetFieldFlags() & FIELDFLAG_DONOTSCROLL)
1220       vp << true;
1221     else
1222       vp << false;
1223   }
1224
1225   return TRUE;
1226 }
1227
1228 void Field::SetDoNotScroll(CPDFSDK_Document* pDocument,
1229                            const CFX_WideString& swFieldName,
1230                            int nControlIndex,
1231                            bool b) {
1232   // Not supported.
1233 }
1234
1235 FX_BOOL Field::doNotSpellCheck(IFXJS_Context* cc,
1236                                CJS_PropValue& vp,
1237                                CFX_WideString& sError) {
1238   ASSERT(m_pDocument != NULL);
1239
1240   if (vp.IsSetting()) {
1241     if (!m_bCanSet)
1242       return FALSE;
1243
1244     bool bVP;
1245     vp >> bVP;
1246   } else {
1247     CFX_PtrArray FieldArray;
1248     GetFormFields(m_FieldName, FieldArray);
1249     if (FieldArray.GetSize() <= 0)
1250       return FALSE;
1251
1252     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1253     ASSERT(pFormField != NULL);
1254
1255     if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD &&
1256         pFormField->GetFieldType() != FIELDTYPE_COMBOBOX)
1257       return FALSE;
1258
1259     if (pFormField->GetFieldFlags() & FIELDFLAG_DONOTSPELLCHECK)
1260       vp << true;
1261     else
1262       vp << false;
1263   }
1264
1265   return TRUE;
1266 }
1267
1268 void Field::SetDelay(FX_BOOL bDelay) {
1269   m_bDelay = bDelay;
1270
1271   if (!m_bDelay) {
1272     if (m_pJSDoc)
1273       m_pJSDoc->DoFieldDelay(m_FieldName, m_nFormControlIndex);
1274   }
1275 }
1276
1277 FX_BOOL Field::delay(IFXJS_Context* cc,
1278                      CJS_PropValue& vp,
1279                      CFX_WideString& sError) {
1280   if (vp.IsSetting()) {
1281     if (!m_bCanSet)
1282       return FALSE;
1283
1284     bool bVP;
1285     vp >> bVP;
1286
1287     SetDelay(bVP);
1288   } else {
1289     vp << m_bDelay;
1290   }
1291   return TRUE;
1292 }
1293
1294 FX_BOOL Field::display(IFXJS_Context* cc,
1295                        CJS_PropValue& vp,
1296                        CFX_WideString& sError) {
1297   ASSERT(m_pDocument != NULL);
1298
1299   if (vp.IsSetting()) {
1300     if (!m_bCanSet)
1301       return FALSE;
1302
1303     int nVP;
1304     vp >> nVP;
1305
1306     if (m_bDelay) {
1307       AddDelay_Int(FP_DISPLAY, nVP);
1308     } else {
1309       Field::SetDisplay(m_pDocument, m_FieldName, m_nFormControlIndex, nVP);
1310     }
1311   } else {
1312     CFX_PtrArray FieldArray;
1313     GetFormFields(m_FieldName, FieldArray);
1314     if (FieldArray.GetSize() <= 0)
1315       return FALSE;
1316
1317     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1318     ASSERT(pFormField != NULL);
1319
1320     CPDFSDK_InterForm* pInterForm =
1321         (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
1322     ASSERT(pInterForm != NULL);
1323
1324     CPDFSDK_Widget* pWidget =
1325         pInterForm->GetWidget(GetSmartFieldControl(pFormField));
1326     if (!pWidget)
1327       return FALSE;
1328
1329     FX_DWORD dwFlag = pWidget->GetFlags();
1330
1331     if (ANNOTFLAG_INVISIBLE & dwFlag || ANNOTFLAG_HIDDEN & dwFlag) {
1332       vp << (int32_t)1;
1333     } else {
1334       if (ANNOTFLAG_PRINT & dwFlag) {
1335         if (ANNOTFLAG_NOVIEW & dwFlag) {
1336           vp << (int32_t)3;
1337         } else {
1338           vp << (int32_t)0;
1339         }
1340       } else {
1341         vp << (int32_t)2;
1342       }
1343     }
1344   }
1345
1346   return TRUE;
1347 }
1348
1349 void Field::SetDisplay(CPDFSDK_Document* pDocument,
1350                        const CFX_WideString& swFieldName,
1351                        int nControlIndex,
1352                        int number) {
1353   ASSERT(pDocument != NULL);
1354
1355   CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)pDocument->GetInterForm();
1356   ASSERT(pInterForm != NULL);
1357
1358   CFX_PtrArray FieldArray;
1359   GetFormFields(pDocument, swFieldName, FieldArray);
1360
1361   for (int i = 0, isz = FieldArray.GetSize(); i < isz; i++) {
1362     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
1363     ASSERT(pFormField != NULL);
1364
1365     if (nControlIndex < 0) {
1366       FX_BOOL bSet = FALSE;
1367       for (int j = 0, jsz = pFormField->CountControls(); j < jsz; j++) {
1368         CPDF_FormControl* pFormControl = pFormField->GetControl(j);
1369         ASSERT(pFormControl != NULL);
1370
1371         if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl)) {
1372           FX_DWORD dwFlag = pWidget->GetFlags();
1373           switch (number) {
1374             case 0:
1375               dwFlag &= (~ANNOTFLAG_INVISIBLE);
1376               dwFlag &= (~ANNOTFLAG_HIDDEN);
1377               dwFlag &= (~ANNOTFLAG_NOVIEW);
1378               dwFlag |= ANNOTFLAG_PRINT;
1379               break;
1380             case 1:
1381               dwFlag &= (~ANNOTFLAG_INVISIBLE);
1382               dwFlag &= (~ANNOTFLAG_NOVIEW);
1383               dwFlag |= (ANNOTFLAG_HIDDEN | ANNOTFLAG_PRINT);
1384               break;
1385             case 2:
1386               dwFlag &= (~ANNOTFLAG_INVISIBLE);
1387               dwFlag &= (~ANNOTFLAG_PRINT);
1388               dwFlag &= (~ANNOTFLAG_HIDDEN);
1389               dwFlag &= (~ANNOTFLAG_NOVIEW);
1390               break;
1391             case 3:
1392               dwFlag |= ANNOTFLAG_NOVIEW;
1393               dwFlag |= ANNOTFLAG_PRINT;
1394               dwFlag &= (~ANNOTFLAG_HIDDEN);
1395               break;
1396           }
1397
1398           if (dwFlag != pWidget->GetFlags()) {
1399             pWidget->SetFlags(dwFlag);
1400             bSet = TRUE;
1401           }
1402         }
1403       }
1404
1405       if (bSet)
1406         UpdateFormField(pDocument, pFormField, TRUE, FALSE, TRUE);
1407     } else {
1408       if (nControlIndex >= pFormField->CountControls())
1409         return;
1410       if (CPDF_FormControl* pFormControl =
1411               pFormField->GetControl(nControlIndex)) {
1412         if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl)) {
1413           FX_DWORD dwFlag = pWidget->GetFlags();
1414           switch (number) {
1415             case 0:
1416               dwFlag &= (~ANNOTFLAG_INVISIBLE);
1417               dwFlag &= (~ANNOTFLAG_HIDDEN);
1418               dwFlag &= (~ANNOTFLAG_NOVIEW);
1419               dwFlag |= ANNOTFLAG_PRINT;
1420               break;
1421             case 1:
1422               dwFlag &= (~ANNOTFLAG_INVISIBLE);
1423               dwFlag &= (~ANNOTFLAG_NOVIEW);
1424               dwFlag |= (ANNOTFLAG_HIDDEN | ANNOTFLAG_PRINT);
1425               break;
1426             case 2:
1427               dwFlag &= (~ANNOTFLAG_INVISIBLE);
1428               dwFlag &= (~ANNOTFLAG_PRINT);
1429               dwFlag &= (~ANNOTFLAG_HIDDEN);
1430               dwFlag &= (~ANNOTFLAG_NOVIEW);
1431               break;
1432             case 3:
1433               dwFlag |= ANNOTFLAG_NOVIEW;
1434               dwFlag |= ANNOTFLAG_PRINT;
1435               dwFlag &= (~ANNOTFLAG_HIDDEN);
1436               break;
1437           }
1438           if (dwFlag != pWidget->GetFlags()) {
1439             pWidget->SetFlags(dwFlag);
1440             UpdateFormControl(pDocument, pFormControl, TRUE, FALSE, TRUE);
1441           }
1442         }
1443       }
1444     }
1445   }
1446 }
1447
1448 FX_BOOL Field::doc(IFXJS_Context* cc,
1449                    CJS_PropValue& vp,
1450                    CFX_WideString& sError) {
1451   if (!vp.IsGetting()) {
1452     return FALSE;
1453   }
1454   vp << m_pJSDoc->GetCJSDoc();
1455   return TRUE;
1456 }
1457
1458 FX_BOOL Field::editable(IFXJS_Context* cc,
1459                         CJS_PropValue& vp,
1460                         CFX_WideString& sError) {
1461   ASSERT(m_pDocument != NULL);
1462   if (vp.IsSetting()) {
1463     if (!m_bCanSet)
1464       return FALSE;
1465
1466     bool bVP;
1467     vp >> bVP;
1468   } else {
1469     CFX_PtrArray FieldArray;
1470     GetFormFields(m_FieldName, FieldArray);
1471     if (FieldArray.GetSize() <= 0)
1472       return FALSE;
1473
1474     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1475     ASSERT(pFormField != NULL);
1476
1477     if (pFormField->GetFieldType() != FIELDTYPE_COMBOBOX)
1478       return FALSE;
1479
1480     if (pFormField->GetFieldFlags() & FIELDFLAG_EDIT)
1481       vp << true;
1482     else
1483       vp << false;
1484   }
1485
1486   return TRUE;
1487 }
1488
1489 FX_BOOL Field::exportValues(IFXJS_Context* cc,
1490                             CJS_PropValue& vp,
1491                             CFX_WideString& sError) {
1492   ASSERT(m_pDocument != NULL);
1493
1494   CFX_PtrArray FieldArray;
1495   GetFormFields(m_FieldName, FieldArray);
1496   if (FieldArray.GetSize() <= 0)
1497     return FALSE;
1498
1499   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1500   if (pFormField->GetFieldType() != FIELDTYPE_CHECKBOX &&
1501       pFormField->GetFieldType() != FIELDTYPE_RADIOBUTTON)
1502     return FALSE;
1503
1504   if (vp.IsSetting()) {
1505     if (!m_bCanSet)
1506       return FALSE;
1507
1508     if (!vp.IsArrayObject())
1509       return FALSE;
1510   } else {
1511     CJS_Array ExportValusArray(m_isolate);
1512     if (m_nFormControlIndex < 0) {
1513       for (int i = 0, sz = pFormField->CountControls(); i < sz; i++) {
1514         CPDF_FormControl* pFormControl = pFormField->GetControl(i);
1515         ExportValusArray.SetElement(
1516             i, CJS_Value(m_isolate, pFormControl->GetExportValue().c_str()));
1517       }
1518     } else {
1519       if (m_nFormControlIndex >= pFormField->CountControls())
1520         return FALSE;
1521
1522       CPDF_FormControl* pFormControl =
1523           pFormField->GetControl(m_nFormControlIndex);
1524       if (!pFormControl)
1525         return FALSE;
1526
1527       ExportValusArray.SetElement(
1528           0, CJS_Value(m_isolate, pFormControl->GetExportValue().c_str()));
1529     }
1530     vp << ExportValusArray;
1531   }
1532   return TRUE;
1533 }
1534
1535 FX_BOOL Field::fileSelect(IFXJS_Context* cc,
1536                           CJS_PropValue& vp,
1537                           CFX_WideString& sError) {
1538   ASSERT(m_pDocument != NULL);
1539
1540   CFX_PtrArray FieldArray;
1541   GetFormFields(m_FieldName, FieldArray);
1542   if (FieldArray.GetSize() <= 0)
1543     return FALSE;
1544
1545   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1546   if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
1547     return FALSE;
1548
1549   if (vp.IsSetting()) {
1550     if (!m_bCanSet)
1551       return FALSE;
1552
1553     bool bVP;
1554     vp >> bVP;
1555   } else {
1556     if (pFormField->GetFieldFlags() & FIELDFLAG_FILESELECT)
1557       vp << true;
1558     else
1559       vp << false;
1560   }
1561   return TRUE;
1562 }
1563
1564 FX_BOOL Field::fillColor(IFXJS_Context* cc,
1565                          CJS_PropValue& vp,
1566                          CFX_WideString& sError) {
1567   ASSERT(m_pDocument != NULL);
1568
1569   CJS_Array crArray(m_isolate);
1570
1571   CFX_PtrArray FieldArray;
1572   GetFormFields(m_FieldName, FieldArray);
1573   if (FieldArray.GetSize() <= 0)
1574     return FALSE;
1575
1576   if (vp.IsSetting()) {
1577     if (!m_bCanSet)
1578       return FALSE;
1579
1580     if (!vp.IsArrayObject())
1581       return FALSE;
1582
1583     vp >> crArray;
1584
1585     CPWL_Color color;
1586     color::ConvertArrayToPWLColor(crArray, color);
1587     if (m_bDelay) {
1588       AddDelay_Color(FP_FILLCOLOR, color);
1589     } else {
1590       Field::SetFillColor(m_pDocument, m_FieldName, m_nFormControlIndex, color);
1591     }
1592   } else {
1593     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1594     ASSERT(pFormField != NULL);
1595
1596     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
1597     if (!pFormControl)
1598       return FALSE;
1599
1600     int iColorType;
1601     pFormControl->GetBackgroundColor(iColorType);
1602
1603     CPWL_Color color;
1604     if (iColorType == COLORTYPE_TRANSPARENT) {
1605       color = CPWL_Color(COLORTYPE_TRANSPARENT);
1606     } else if (iColorType == COLORTYPE_GRAY) {
1607       color = CPWL_Color(COLORTYPE_GRAY,
1608                          pFormControl->GetOriginalBackgroundColor(0));
1609     } else if (iColorType == COLORTYPE_RGB) {
1610       color =
1611           CPWL_Color(COLORTYPE_RGB, pFormControl->GetOriginalBackgroundColor(0),
1612                      pFormControl->GetOriginalBackgroundColor(1),
1613                      pFormControl->GetOriginalBackgroundColor(2));
1614     } else if (iColorType == COLORTYPE_CMYK) {
1615       color = CPWL_Color(COLORTYPE_CMYK,
1616                          pFormControl->GetOriginalBackgroundColor(0),
1617                          pFormControl->GetOriginalBackgroundColor(1),
1618                          pFormControl->GetOriginalBackgroundColor(2),
1619                          pFormControl->GetOriginalBackgroundColor(3));
1620     } else
1621       return FALSE;
1622
1623     color::ConvertPWLColorToArray(color, crArray);
1624     vp << crArray;
1625   }
1626
1627   return TRUE;
1628 }
1629
1630 void Field::SetFillColor(CPDFSDK_Document* pDocument,
1631                          const CFX_WideString& swFieldName,
1632                          int nControlIndex,
1633                          const CPWL_Color& color) {
1634   // Not supported.
1635 }
1636
1637 FX_BOOL Field::hidden(IFXJS_Context* cc,
1638                       CJS_PropValue& vp,
1639                       CFX_WideString& sError) {
1640   ASSERT(m_pDocument != NULL);
1641
1642   if (vp.IsSetting()) {
1643     if (!m_bCanSet)
1644       return FALSE;
1645
1646     bool bVP;
1647     vp >> bVP;
1648
1649     if (m_bDelay) {
1650       AddDelay_Bool(FP_HIDDEN, bVP);
1651     } else {
1652       Field::SetHidden(m_pDocument, m_FieldName, m_nFormControlIndex, bVP);
1653     }
1654   } else {
1655     CFX_PtrArray FieldArray;
1656     GetFormFields(m_FieldName, FieldArray);
1657     if (FieldArray.GetSize() <= 0)
1658       return FALSE;
1659
1660     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1661     ASSERT(pFormField != NULL);
1662
1663     CPDFSDK_InterForm* pInterForm =
1664         (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
1665     ASSERT(pInterForm != NULL);
1666
1667     CPDFSDK_Widget* pWidget =
1668         pInterForm->GetWidget(GetSmartFieldControl(pFormField));
1669     if (!pWidget)
1670       return FALSE;
1671
1672     FX_DWORD dwFlags = pWidget->GetFlags();
1673
1674     if (ANNOTFLAG_INVISIBLE & dwFlags || ANNOTFLAG_HIDDEN & dwFlags) {
1675       vp << true;
1676     } else
1677       vp << false;
1678   }
1679
1680   return TRUE;
1681 }
1682
1683 void Field::SetHidden(CPDFSDK_Document* pDocument,
1684                       const CFX_WideString& swFieldName,
1685                       int nControlIndex,
1686                       bool b) {
1687   ASSERT(pDocument != NULL);
1688
1689   CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)pDocument->GetInterForm();
1690   ASSERT(pInterForm != NULL);
1691
1692   CFX_PtrArray FieldArray;
1693   GetFormFields(pDocument, swFieldName, FieldArray);
1694
1695   for (int i = 0, isz = FieldArray.GetSize(); i < isz; i++) {
1696     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
1697     ASSERT(pFormField != NULL);
1698
1699     if (nControlIndex < 0) {
1700       FX_BOOL bSet = FALSE;
1701       for (int j = 0, jsz = pFormField->CountControls(); j < jsz; j++) {
1702         if (CPDFSDK_Widget* pWidget =
1703                 pInterForm->GetWidget(pFormField->GetControl(j))) {
1704           FX_DWORD dwFlags = pWidget->GetFlags();
1705
1706           if (b) {
1707             dwFlags &= (~ANNOTFLAG_INVISIBLE);
1708             dwFlags &= (~ANNOTFLAG_NOVIEW);
1709             dwFlags |= (ANNOTFLAG_HIDDEN | ANNOTFLAG_PRINT);
1710           } else {
1711             dwFlags &= (~ANNOTFLAG_INVISIBLE);
1712             dwFlags &= (~ANNOTFLAG_HIDDEN);
1713             dwFlags &= (~ANNOTFLAG_NOVIEW);
1714             dwFlags |= ANNOTFLAG_PRINT;
1715           }
1716
1717           if (dwFlags != pWidget->GetFlags()) {
1718             pWidget->SetFlags(dwFlags);
1719             bSet = TRUE;
1720           }
1721         }
1722       }
1723
1724       if (bSet)
1725         UpdateFormField(pDocument, pFormField, TRUE, FALSE, TRUE);
1726     } else {
1727       if (nControlIndex >= pFormField->CountControls())
1728         return;
1729       if (CPDF_FormControl* pFormControl =
1730               pFormField->GetControl(nControlIndex)) {
1731         if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl)) {
1732           FX_DWORD dwFlags = pWidget->GetFlags();
1733
1734           if (b) {
1735             dwFlags &= (~ANNOTFLAG_INVISIBLE);
1736             dwFlags &= (~ANNOTFLAG_NOVIEW);
1737             dwFlags |= (ANNOTFLAG_HIDDEN | ANNOTFLAG_PRINT);
1738           } else {
1739             dwFlags &= (~ANNOTFLAG_INVISIBLE);
1740             dwFlags &= (~ANNOTFLAG_HIDDEN);
1741             dwFlags &= (~ANNOTFLAG_NOVIEW);
1742             dwFlags |= ANNOTFLAG_PRINT;
1743           }
1744
1745           if (dwFlags != pWidget->GetFlags()) {
1746             pWidget->SetFlags(dwFlags);
1747             UpdateFormControl(pDocument, pFormControl, TRUE, FALSE, TRUE);
1748           }
1749         }
1750       }
1751     }
1752   }
1753 }
1754
1755 FX_BOOL Field::highlight(IFXJS_Context* cc,
1756                          CJS_PropValue& vp,
1757                          CFX_WideString& sError) {
1758   ASSERT(m_pDocument != NULL);
1759
1760   if (vp.IsSetting()) {
1761     if (!m_bCanSet)
1762       return FALSE;
1763
1764     CFX_ByteString strMode;
1765     vp >> strMode;
1766
1767     if (m_bDelay) {
1768       AddDelay_String(FP_HIGHLIGHT, strMode);
1769     } else {
1770       Field::SetHighlight(m_pDocument, m_FieldName, m_nFormControlIndex,
1771                           strMode);
1772     }
1773   } else {
1774     CFX_PtrArray FieldArray;
1775     GetFormFields(m_FieldName, FieldArray);
1776     if (FieldArray.GetSize() <= 0)
1777       return FALSE;
1778
1779     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1780     ASSERT(pFormField != NULL);
1781
1782     if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
1783       return FALSE;
1784
1785     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
1786     if (!pFormControl)
1787       return FALSE;
1788
1789     int eHM = pFormControl->GetHighlightingMode();
1790     switch (eHM) {
1791       case CPDF_FormControl::None:
1792         vp << L"none";
1793         break;
1794       case CPDF_FormControl::Push:
1795         vp << L"push";
1796         break;
1797       case CPDF_FormControl::Invert:
1798         vp << L"invert";
1799         break;
1800       case CPDF_FormControl::Outline:
1801         vp << L"outline";
1802         break;
1803       case CPDF_FormControl::Toggle:
1804         vp << L"toggle";
1805         break;
1806     }
1807   }
1808
1809   return TRUE;
1810 }
1811
1812 void Field::SetHighlight(CPDFSDK_Document* pDocument,
1813                          const CFX_WideString& swFieldName,
1814                          int nControlIndex,
1815                          const CFX_ByteString& string) {
1816   // Not supported.
1817 }
1818
1819 FX_BOOL Field::lineWidth(IFXJS_Context* cc,
1820                          CJS_PropValue& vp,
1821                          CFX_WideString& sError) {
1822   ASSERT(m_pDocument != NULL);
1823
1824   if (vp.IsSetting()) {
1825     if (!m_bCanSet)
1826       return FALSE;
1827
1828     int iWidth;
1829     vp >> iWidth;
1830
1831     if (m_bDelay) {
1832       AddDelay_Int(FP_LINEWIDTH, iWidth);
1833     } else {
1834       Field::SetLineWidth(m_pDocument, m_FieldName, m_nFormControlIndex,
1835                           iWidth);
1836     }
1837   } else {
1838     CFX_PtrArray FieldArray;
1839     GetFormFields(m_FieldName, FieldArray);
1840     if (FieldArray.GetSize() <= 0)
1841       return FALSE;
1842
1843     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1844     ASSERT(pFormField != NULL);
1845
1846     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
1847     if (!pFormControl)
1848       return FALSE;
1849
1850     CPDFSDK_InterForm* pInterForm =
1851         (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
1852     ASSERT(pInterForm != NULL);
1853
1854     if (!pFormField->CountControls())
1855       return FALSE;
1856
1857     CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormField->GetControl(0));
1858     if (!pWidget)
1859       return FALSE;
1860
1861     vp << (int32_t)pWidget->GetBorderWidth();
1862   }
1863
1864   return TRUE;
1865 }
1866
1867 void Field::SetLineWidth(CPDFSDK_Document* pDocument,
1868                          const CFX_WideString& swFieldName,
1869                          int nControlIndex,
1870                          int number) {
1871   ASSERT(pDocument != NULL);
1872
1873   CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)pDocument->GetInterForm();
1874   ASSERT(pInterForm != NULL);
1875
1876   CFX_PtrArray FieldArray;
1877   GetFormFields(pDocument, swFieldName, FieldArray);
1878
1879   for (int i = 0, isz = FieldArray.GetSize(); i < isz; i++) {
1880     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
1881     ASSERT(pFormField != NULL);
1882
1883     if (nControlIndex < 0) {
1884       FX_BOOL bSet = FALSE;
1885       for (int j = 0, jsz = pFormField->CountControls(); j < jsz; j++) {
1886         CPDF_FormControl* pFormControl = pFormField->GetControl(j);
1887         ASSERT(pFormControl != NULL);
1888
1889         if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl)) {
1890           if (number != pWidget->GetBorderWidth()) {
1891             pWidget->SetBorderWidth(number);
1892             bSet = TRUE;
1893           }
1894         }
1895       }
1896       if (bSet)
1897         UpdateFormField(pDocument, pFormField, TRUE, TRUE, TRUE);
1898     } else {
1899       if (nControlIndex >= pFormField->CountControls())
1900         return;
1901       if (CPDF_FormControl* pFormControl =
1902               pFormField->GetControl(nControlIndex)) {
1903         if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl)) {
1904           if (number != pWidget->GetBorderWidth()) {
1905             pWidget->SetBorderWidth(number);
1906             UpdateFormControl(pDocument, pFormControl, TRUE, TRUE, TRUE);
1907           }
1908         }
1909       }
1910     }
1911   }
1912 }
1913
1914 FX_BOOL Field::multiline(IFXJS_Context* cc,
1915                          CJS_PropValue& vp,
1916                          CFX_WideString& sError) {
1917   ASSERT(m_pDocument != NULL);
1918
1919   if (vp.IsSetting()) {
1920     if (!m_bCanSet)
1921       return FALSE;
1922
1923     bool bVP;
1924     vp >> bVP;
1925
1926     if (m_bDelay) {
1927       AddDelay_Bool(FP_MULTILINE, bVP);
1928     } else {
1929       Field::SetMultiline(m_pDocument, m_FieldName, m_nFormControlIndex, bVP);
1930     }
1931   } else {
1932     CFX_PtrArray FieldArray;
1933     GetFormFields(m_FieldName, FieldArray);
1934     if (FieldArray.GetSize() <= 0)
1935       return FALSE;
1936
1937     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1938     ASSERT(pFormField != NULL);
1939
1940     if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
1941       return FALSE;
1942
1943     if (pFormField->GetFieldFlags() & FIELDFLAG_MULTILINE)
1944       vp << true;
1945     else
1946       vp << false;
1947   }
1948
1949   return TRUE;
1950 }
1951
1952 void Field::SetMultiline(CPDFSDK_Document* pDocument,
1953                          const CFX_WideString& swFieldName,
1954                          int nControlIndex,
1955                          bool b) {
1956   // Not supported.
1957 }
1958
1959 FX_BOOL Field::multipleSelection(IFXJS_Context* cc,
1960                                  CJS_PropValue& vp,
1961                                  CFX_WideString& sError) {
1962   ASSERT(m_pDocument != NULL);
1963
1964   if (vp.IsSetting()) {
1965     if (!m_bCanSet)
1966       return FALSE;
1967
1968     bool bVP;
1969     vp >> bVP;
1970
1971     if (m_bDelay) {
1972       AddDelay_Bool(FP_MULTIPLESELECTION, bVP);
1973     } else {
1974       Field::SetMultipleSelection(m_pDocument, m_FieldName, m_nFormControlIndex,
1975                                   bVP);
1976     }
1977   } else {
1978     CFX_PtrArray FieldArray;
1979     GetFormFields(m_FieldName, FieldArray);
1980     if (FieldArray.GetSize() <= 0)
1981       return FALSE;
1982
1983     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1984     ASSERT(pFormField != NULL);
1985
1986     if (pFormField->GetFieldType() != FIELDTYPE_LISTBOX)
1987       return FALSE;
1988
1989     if (pFormField->GetFieldFlags() & FIELDFLAG_MULTISELECT)
1990       vp << true;
1991     else
1992       vp << false;
1993   }
1994
1995   return TRUE;
1996 }
1997
1998 void Field::SetMultipleSelection(CPDFSDK_Document* pDocument,
1999                                  const CFX_WideString& swFieldName,
2000                                  int nControlIndex,
2001                                  bool b) {
2002   // Not supported.
2003 }
2004
2005 FX_BOOL Field::name(IFXJS_Context* cc,
2006                     CJS_PropValue& vp,
2007                     CFX_WideString& sError) {
2008   if (!vp.IsGetting())
2009     return FALSE;
2010
2011   CFX_PtrArray FieldArray;
2012   GetFormFields(m_FieldName, FieldArray);
2013   if (FieldArray.GetSize() <= 0)
2014     return FALSE;
2015
2016   vp << m_FieldName;
2017
2018   return TRUE;
2019 }
2020
2021 FX_BOOL Field::numItems(IFXJS_Context* cc,
2022                         CJS_PropValue& vp,
2023                         CFX_WideString& sError) {
2024   CFX_PtrArray FieldArray;
2025   GetFormFields(m_FieldName, FieldArray);
2026   if (FieldArray.GetSize() <= 0)
2027     return FALSE;
2028
2029   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2030   ASSERT(pFormField != NULL);
2031
2032   if (pFormField->GetFieldType() != FIELDTYPE_COMBOBOX &&
2033       pFormField->GetFieldType() != FIELDTYPE_LISTBOX)
2034     return FALSE;
2035
2036   if (!vp.IsGetting())
2037     return FALSE;
2038
2039   vp << (int32_t)pFormField->CountOptions();
2040
2041   return TRUE;
2042 }
2043
2044 FX_BOOL Field::page(IFXJS_Context* cc,
2045                     CJS_PropValue& vp,
2046                     CFX_WideString& sError) {
2047   if (!vp.IsGetting())
2048     return FALSE;
2049
2050   CFX_PtrArray FieldArray;
2051   GetFormFields(m_FieldName, FieldArray);
2052   if (FieldArray.GetSize() <= 0)
2053     return FALSE;
2054
2055   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2056   if (!pFormField)
2057     return FALSE;
2058
2059   ASSERT(m_pDocument != NULL);
2060
2061   CPDFSDK_InterForm* pInterForm =
2062       (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
2063   ASSERT(pInterForm != NULL);
2064
2065   CFX_PtrArray widgetArray;
2066   pInterForm->GetWidgets(pFormField, widgetArray);
2067
2068   if (widgetArray.GetSize() > 0) {
2069     CJS_Array PageArray(m_isolate);
2070
2071     for (int i = 0, sz = widgetArray.GetSize(); i < sz; i++) {
2072       CPDFSDK_Widget* pWidget = (CPDFSDK_Widget*)widgetArray.GetAt(i);
2073       ASSERT(pWidget != NULL);
2074
2075       CPDFSDK_PageView* pPageView = pWidget->GetPageView();
2076       if (!pPageView)
2077         return FALSE;
2078
2079       PageArray.SetElement(
2080           i, CJS_Value(m_isolate, (int32_t)pPageView->GetPageIndex()));
2081     }
2082
2083     vp << PageArray;
2084   } else {
2085     vp << (int32_t)-1;
2086   }
2087
2088   return TRUE;
2089 }
2090
2091 FX_BOOL Field::password(IFXJS_Context* cc,
2092                         CJS_PropValue& vp,
2093                         CFX_WideString& sError) {
2094   ASSERT(m_pDocument != NULL);
2095
2096   if (vp.IsSetting()) {
2097     if (!m_bCanSet)
2098       return FALSE;
2099
2100     bool bVP;
2101     vp >> bVP;
2102
2103     if (m_bDelay) {
2104       AddDelay_Bool(FP_PASSWORD, bVP);
2105     } else {
2106       Field::SetPassword(m_pDocument, m_FieldName, m_nFormControlIndex, bVP);
2107     }
2108   } else {
2109     CFX_PtrArray FieldArray;
2110     GetFormFields(m_FieldName, FieldArray);
2111     if (FieldArray.GetSize() <= 0)
2112       return FALSE;
2113
2114     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2115     ASSERT(pFormField != NULL);
2116
2117     if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
2118       return FALSE;
2119
2120     if (pFormField->GetFieldFlags() & FIELDFLAG_PASSWORD)
2121       vp << true;
2122     else
2123       vp << false;
2124   }
2125
2126   return TRUE;
2127 }
2128
2129 void Field::SetPassword(CPDFSDK_Document* pDocument,
2130                         const CFX_WideString& swFieldName,
2131                         int nControlIndex,
2132                         bool b) {
2133   // Not supported.
2134 }
2135
2136 FX_BOOL Field::print(IFXJS_Context* cc,
2137                      CJS_PropValue& vp,
2138                      CFX_WideString& sError) {
2139   ASSERT(m_pDocument != NULL);
2140
2141   CPDFSDK_InterForm* pInterForm =
2142       (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
2143   ASSERT(pInterForm != NULL);
2144
2145   CFX_PtrArray FieldArray;
2146   GetFormFields(m_FieldName, FieldArray);
2147   if (FieldArray.GetSize() <= 0)
2148     return FALSE;
2149
2150   if (vp.IsSetting()) {
2151     if (!m_bCanSet)
2152       return FALSE;
2153
2154     bool bVP;
2155     vp >> bVP;
2156
2157     for (int i = 0, isz = FieldArray.GetSize(); i < isz; i++) {
2158       CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
2159       ASSERT(pFormField != NULL);
2160
2161       if (m_nFormControlIndex < 0) {
2162         FX_BOOL bSet = FALSE;
2163         for (int j = 0, jsz = pFormField->CountControls(); j < jsz; j++) {
2164           if (CPDFSDK_Widget* pWidget =
2165                   pInterForm->GetWidget(pFormField->GetControl(j))) {
2166             FX_DWORD dwFlags = pWidget->GetFlags();
2167             if (bVP)
2168               dwFlags |= ANNOTFLAG_PRINT;
2169             else
2170               dwFlags &= ~ANNOTFLAG_PRINT;
2171
2172             if (dwFlags != pWidget->GetFlags()) {
2173               pWidget->SetFlags(dwFlags);
2174               bSet = TRUE;
2175             }
2176           }
2177         }
2178
2179         if (bSet)
2180           UpdateFormField(m_pDocument, pFormField, TRUE, FALSE, TRUE);
2181       } else {
2182         if (m_nFormControlIndex >= pFormField->CountControls())
2183           return FALSE;
2184         if (CPDF_FormControl* pFormControl =
2185                 pFormField->GetControl(m_nFormControlIndex)) {
2186           if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl)) {
2187             FX_DWORD dwFlags = pWidget->GetFlags();
2188             if (bVP)
2189               dwFlags |= ANNOTFLAG_PRINT;
2190             else
2191               dwFlags &= ~ANNOTFLAG_PRINT;
2192
2193             if (dwFlags != pWidget->GetFlags()) {
2194               pWidget->SetFlags(dwFlags);
2195               UpdateFormControl(m_pDocument,
2196                                 pFormField->GetControl(m_nFormControlIndex),
2197                                 TRUE, FALSE, TRUE);
2198             }
2199           }
2200         }
2201       }
2202     }
2203   } else {
2204     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2205     ASSERT(pFormField != NULL);
2206
2207     CPDFSDK_Widget* pWidget =
2208         pInterForm->GetWidget(GetSmartFieldControl(pFormField));
2209     if (!pWidget)
2210       return FALSE;
2211
2212     if (pWidget->GetFlags() & ANNOTFLAG_PRINT)
2213       vp << true;
2214     else
2215       vp << false;
2216   }
2217
2218   return TRUE;
2219 }
2220
2221 FX_BOOL Field::radiosInUnison(IFXJS_Context* cc,
2222                               CJS_PropValue& vp,
2223                               CFX_WideString& sError) {
2224   ASSERT(m_pDocument != NULL);
2225
2226   CFX_PtrArray FieldArray;
2227   GetFormFields(m_FieldName, FieldArray);
2228   if (FieldArray.GetSize() <= 0)
2229     return FALSE;
2230
2231   if (vp.IsSetting()) {
2232     if (!m_bCanSet)
2233       return FALSE;
2234
2235     bool bVP;
2236     vp >> bVP;
2237
2238   } else {
2239     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2240     ASSERT(pFormField != NULL);
2241
2242     if (pFormField->GetFieldType() != FIELDTYPE_RADIOBUTTON)
2243       return FALSE;
2244
2245     if (pFormField->GetFieldFlags() & FIELDFLAG_RADIOSINUNISON)
2246       vp << true;
2247     else
2248       vp << false;
2249   }
2250
2251   return TRUE;
2252 }
2253
2254 FX_BOOL Field::readonly(IFXJS_Context* cc,
2255                         CJS_PropValue& vp,
2256                         CFX_WideString& sError) {
2257   ASSERT(m_pDocument != NULL);
2258
2259   CFX_PtrArray FieldArray;
2260   GetFormFields(m_FieldName, FieldArray);
2261   if (FieldArray.GetSize() <= 0)
2262     return FALSE;
2263
2264   if (vp.IsSetting()) {
2265     if (!m_bCanSet)
2266       return FALSE;
2267
2268     bool bVP;
2269     vp >> bVP;
2270
2271   } else {
2272     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2273     ASSERT(pFormField != NULL);
2274
2275     if (pFormField->GetFieldFlags() & FIELDFLAG_READONLY)
2276       vp << true;
2277     else
2278       vp << false;
2279   }
2280
2281   return TRUE;
2282 }
2283
2284 FX_BOOL Field::rect(IFXJS_Context* cc,
2285                     CJS_PropValue& vp,
2286                     CFX_WideString& sError) {
2287   ASSERT(m_pDocument != NULL);
2288
2289   if (vp.IsSetting()) {
2290     if (!m_bCanSet)
2291       return FALSE;
2292     if (!vp.IsArrayObject())
2293       return FALSE;
2294
2295     CJS_Array rcArray(m_isolate);
2296     vp >> rcArray;
2297     CJS_Value Upper_Leftx(m_isolate), Upper_Lefty(m_isolate),
2298         Lower_Rightx(m_isolate), Lower_Righty(m_isolate);
2299     rcArray.GetElement(0, Upper_Leftx);
2300     rcArray.GetElement(1, Upper_Lefty);
2301     rcArray.GetElement(2, Lower_Rightx);
2302     rcArray.GetElement(3, Lower_Righty);
2303
2304     FX_FLOAT pArray[4] = {0.0f, 0.0f, 0.0f, 0.0f};
2305     pArray[0] = (FX_FLOAT)Upper_Leftx.ToInt();
2306     pArray[1] = (FX_FLOAT)Lower_Righty.ToInt();
2307     pArray[2] = (FX_FLOAT)Lower_Rightx.ToInt();
2308     pArray[3] = (FX_FLOAT)Upper_Lefty.ToInt();
2309
2310     CPDF_Rect crRect(pArray);
2311
2312     if (m_bDelay) {
2313       AddDelay_Rect(FP_RECT, crRect);
2314     } else {
2315       Field::SetRect(m_pDocument, m_FieldName, m_nFormControlIndex, crRect);
2316     }
2317   } else {
2318     CFX_PtrArray FieldArray;
2319     GetFormFields(m_FieldName, FieldArray);
2320     if (FieldArray.GetSize() <= 0)
2321       return FALSE;
2322
2323     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2324     ASSERT(pFormField != NULL);
2325
2326     CPDFSDK_InterForm* pInterForm =
2327         (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
2328     ASSERT(pInterForm != NULL);
2329
2330     CPDFSDK_Widget* pWidget =
2331         pInterForm->GetWidget(GetSmartFieldControl(pFormField));
2332     if (!pWidget)
2333       return FALSE;
2334
2335     CFX_FloatRect crRect = pWidget->GetRect();
2336     CJS_Value Upper_Leftx(m_isolate), Upper_Lefty(m_isolate),
2337         Lower_Rightx(m_isolate), Lower_Righty(m_isolate);
2338     Upper_Leftx = (int32_t)crRect.left;
2339     Upper_Lefty = (int32_t)crRect.top;
2340     Lower_Rightx = (int32_t)crRect.right;
2341     Lower_Righty = (int32_t)crRect.bottom;
2342
2343     CJS_Array rcArray(m_isolate);
2344     rcArray.SetElement(0, Upper_Leftx);
2345     rcArray.SetElement(1, Upper_Lefty);
2346     rcArray.SetElement(2, Lower_Rightx);
2347     rcArray.SetElement(3, Lower_Righty);
2348
2349     vp << rcArray;
2350   }
2351
2352   return TRUE;
2353 }
2354
2355 void Field::SetRect(CPDFSDK_Document* pDocument,
2356                     const CFX_WideString& swFieldName,
2357                     int nControlIndex,
2358                     const CPDF_Rect& rect) {
2359   ASSERT(pDocument != NULL);
2360
2361   CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)pDocument->GetInterForm();
2362   ASSERT(pInterForm != NULL);
2363
2364   CFX_PtrArray FieldArray;
2365   GetFormFields(pDocument, swFieldName, FieldArray);
2366
2367   for (int i = 0, isz = FieldArray.GetSize(); i < isz; i++) {
2368     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
2369     ASSERT(pFormField != NULL);
2370
2371     if (nControlIndex < 0) {
2372       FX_BOOL bSet = FALSE;
2373       for (int i = 0, sz = pFormField->CountControls(); i < sz; i++) {
2374         CPDF_FormControl* pFormControl = pFormField->GetControl(i);
2375         ASSERT(pFormControl != NULL);
2376
2377         if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl)) {
2378           CPDF_Rect crRect = rect;
2379
2380           CPDF_Page* pPDFPage = pWidget->GetPDFPage();
2381           ASSERT(pPDFPage != NULL);
2382
2383           //                  CPDF_Page* pPDFPage = pPage->GetPage();
2384           //                  ASSERT(pPDFPage != NULL);
2385
2386           crRect.Intersect(pPDFPage->GetPageBBox());
2387
2388           if (!crRect.IsEmpty()) {
2389             CPDF_Rect rcOld = pWidget->GetRect();
2390             if (crRect.left != rcOld.left || crRect.right != rcOld.right ||
2391                 crRect.top != rcOld.top || crRect.bottom != rcOld.bottom) {
2392               pWidget->SetRect(crRect);
2393               bSet = TRUE;
2394             }
2395           }
2396         }
2397       }
2398
2399       if (bSet)
2400         UpdateFormField(pDocument, pFormField, TRUE, TRUE, TRUE);
2401     } else {
2402       if (nControlIndex >= pFormField->CountControls())
2403         return;
2404       if (CPDF_FormControl* pFormControl =
2405               pFormField->GetControl(nControlIndex)) {
2406         if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl)) {
2407           CPDF_Rect crRect = rect;
2408
2409           CPDF_Page* pPDFPage = pWidget->GetPDFPage();
2410           ASSERT(pPDFPage != NULL);
2411
2412           //                  CPDF_Page* pPDFPage = pPage->GetPage();
2413           //                  ASSERT(pPDFPage != NULL);
2414
2415           crRect.Intersect(pPDFPage->GetPageBBox());
2416
2417           if (!crRect.IsEmpty()) {
2418             CPDF_Rect rcOld = pWidget->GetRect();
2419             if (crRect.left != rcOld.left || crRect.right != rcOld.right ||
2420                 crRect.top != rcOld.top || crRect.bottom != rcOld.bottom) {
2421               pWidget->SetRect(crRect);
2422               UpdateFormControl(pDocument, pFormControl, TRUE, TRUE, TRUE);
2423             }
2424           }
2425         }
2426       }
2427     }
2428   }
2429 }
2430
2431 FX_BOOL Field::required(IFXJS_Context* cc,
2432                         CJS_PropValue& vp,
2433                         CFX_WideString& sError) {
2434   ASSERT(m_pDocument != NULL);
2435
2436   CFX_PtrArray FieldArray;
2437   GetFormFields(m_FieldName, FieldArray);
2438   if (FieldArray.GetSize() <= 0)
2439     return FALSE;
2440
2441   if (vp.IsSetting()) {
2442     if (!m_bCanSet)
2443       return FALSE;
2444
2445     bool bVP;
2446     vp >> bVP;
2447
2448   } else {
2449     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2450     ASSERT(pFormField != NULL);
2451
2452     if (pFormField->GetFieldType() == FIELDTYPE_PUSHBUTTON)
2453       return FALSE;
2454
2455     if (pFormField->GetFieldFlags() & FIELDFLAG_REQUIRED)
2456       vp << true;
2457     else
2458       vp << false;
2459   }
2460
2461   return TRUE;
2462 }
2463
2464 FX_BOOL Field::richText(IFXJS_Context* cc,
2465                         CJS_PropValue& vp,
2466                         CFX_WideString& sError) {
2467   ASSERT(m_pDocument != NULL);
2468
2469   if (vp.IsSetting()) {
2470     if (!m_bCanSet)
2471       return FALSE;
2472
2473     bool bVP;
2474     vp >> bVP;
2475
2476     if (m_bDelay) {
2477       AddDelay_Bool(FP_RICHTEXT, bVP);
2478     } else {
2479       Field::SetRichText(m_pDocument, m_FieldName, m_nFormControlIndex, bVP);
2480     }
2481   } else {
2482     CFX_PtrArray FieldArray;
2483     GetFormFields(m_FieldName, FieldArray);
2484     if (FieldArray.GetSize() <= 0)
2485       return FALSE;
2486
2487     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2488     ASSERT(pFormField != NULL);
2489
2490     if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
2491       return FALSE;
2492
2493     if (pFormField->GetFieldFlags() & FIELDFLAG_RICHTEXT)
2494       vp << true;
2495     else
2496       vp << false;
2497   }
2498
2499   return TRUE;
2500 }
2501
2502 void Field::SetRichText(CPDFSDK_Document* pDocument,
2503                         const CFX_WideString& swFieldName,
2504                         int nControlIndex,
2505                         bool b) {
2506   // Not supported.
2507 }
2508
2509 FX_BOOL Field::richValue(IFXJS_Context* cc,
2510                          CJS_PropValue& vp,
2511                          CFX_WideString& sError) {
2512   return TRUE;
2513   if (vp.IsSetting()) {
2514     if (!m_bCanSet)
2515       return FALSE;
2516     ;
2517   } else {
2518     ;
2519   }
2520   return TRUE;
2521 }
2522
2523 void Field::SetRichValue(CPDFSDK_Document* pDocument,
2524                          const CFX_WideString& swFieldName,
2525                          int nControlIndex) {
2526   // Not supported.
2527 }
2528
2529 FX_BOOL Field::rotation(IFXJS_Context* cc,
2530                         CJS_PropValue& vp,
2531                         CFX_WideString& sError) {
2532   ASSERT(m_pDocument != NULL);
2533
2534   if (vp.IsSetting()) {
2535     if (!m_bCanSet)
2536       return FALSE;
2537
2538     int nVP;
2539     vp >> nVP;
2540
2541     if (m_bDelay) {
2542       AddDelay_Int(FP_ROTATION, nVP);
2543     } else {
2544       Field::SetRotation(m_pDocument, m_FieldName, m_nFormControlIndex, nVP);
2545     }
2546   } else {
2547     CFX_PtrArray FieldArray;
2548     GetFormFields(m_FieldName, FieldArray);
2549     if (FieldArray.GetSize() <= 0)
2550       return FALSE;
2551
2552     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2553     ASSERT(pFormField != NULL);
2554
2555     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
2556     if (!pFormControl)
2557       return FALSE;
2558
2559     vp << (int32_t)pFormControl->GetRotation();
2560   }
2561
2562   return TRUE;
2563 }
2564
2565 void Field::SetRotation(CPDFSDK_Document* pDocument,
2566                         const CFX_WideString& swFieldName,
2567                         int nControlIndex,
2568                         int number) {
2569   // Not supported.
2570 }
2571
2572 FX_BOOL Field::strokeColor(IFXJS_Context* cc,
2573                            CJS_PropValue& vp,
2574                            CFX_WideString& sError) {
2575   ASSERT(m_pDocument != NULL);
2576
2577   if (vp.IsSetting()) {
2578     if (!m_bCanSet)
2579       return FALSE;
2580
2581     if (!vp.IsArrayObject())
2582       return FALSE;
2583
2584     CJS_Array crArray(m_isolate);
2585     vp >> crArray;
2586
2587     CPWL_Color color;
2588     color::ConvertArrayToPWLColor(crArray, color);
2589
2590     if (m_bDelay) {
2591       AddDelay_Color(FP_STROKECOLOR, color);
2592     } else {
2593       Field::SetStrokeColor(m_pDocument, m_FieldName, m_nFormControlIndex,
2594                             color);
2595     }
2596   } else {
2597     CFX_PtrArray FieldArray;
2598     GetFormFields(m_FieldName, FieldArray);
2599     if (FieldArray.GetSize() <= 0)
2600       return FALSE;
2601
2602     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2603     ASSERT(pFormField != NULL);
2604
2605     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
2606     if (!pFormControl)
2607       return FALSE;
2608
2609     int iColorType;
2610     pFormControl->GetBorderColor(iColorType);
2611
2612     CPWL_Color color;
2613
2614     if (iColorType == COLORTYPE_TRANSPARENT) {
2615       color = CPWL_Color(COLORTYPE_TRANSPARENT);
2616     } else if (iColorType == COLORTYPE_GRAY) {
2617       color =
2618           CPWL_Color(COLORTYPE_GRAY, pFormControl->GetOriginalBorderColor(0));
2619     } else if (iColorType == COLORTYPE_RGB) {
2620       color = CPWL_Color(COLORTYPE_RGB, pFormControl->GetOriginalBorderColor(0),
2621                          pFormControl->GetOriginalBorderColor(1),
2622                          pFormControl->GetOriginalBorderColor(2));
2623     } else if (iColorType == COLORTYPE_CMYK) {
2624       color =
2625           CPWL_Color(COLORTYPE_CMYK, pFormControl->GetOriginalBorderColor(0),
2626                      pFormControl->GetOriginalBorderColor(1),
2627                      pFormControl->GetOriginalBorderColor(2),
2628                      pFormControl->GetOriginalBorderColor(3));
2629     } else
2630       return FALSE;
2631
2632     CJS_Array crArray(m_isolate);
2633     color::ConvertPWLColorToArray(color, crArray);
2634     vp << crArray;
2635   }
2636
2637   return TRUE;
2638 }
2639
2640 void Field::SetStrokeColor(CPDFSDK_Document* pDocument,
2641                            const CFX_WideString& swFieldName,
2642                            int nControlIndex,
2643                            const CPWL_Color& color) {
2644   // Not supported.
2645 }
2646
2647 FX_BOOL Field::style(IFXJS_Context* cc,
2648                      CJS_PropValue& vp,
2649                      CFX_WideString& sError) {
2650   ASSERT(m_pDocument != NULL);
2651
2652   if (vp.IsSetting()) {
2653     if (!m_bCanSet)
2654       return FALSE;
2655
2656     CFX_ByteString csBCaption;
2657     vp >> csBCaption;
2658
2659     if (m_bDelay) {
2660       AddDelay_String(FP_STYLE, csBCaption);
2661     } else {
2662       Field::SetStyle(m_pDocument, m_FieldName, m_nFormControlIndex,
2663                       csBCaption);
2664     }
2665   } else {
2666     CFX_PtrArray FieldArray;
2667     GetFormFields(m_FieldName, FieldArray);
2668     if (FieldArray.GetSize() <= 0)
2669       return FALSE;
2670
2671     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2672     ASSERT(pFormField != NULL);
2673
2674     if (pFormField->GetFieldType() != FIELDTYPE_RADIOBUTTON &&
2675         pFormField->GetFieldType() != FIELDTYPE_CHECKBOX)
2676       return FALSE;
2677
2678     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
2679     if (!pFormControl)
2680       return FALSE;
2681
2682     CFX_WideString csWCaption = pFormControl->GetNormalCaption();
2683     CFX_ByteString csBCaption;
2684
2685     switch (csWCaption[0]) {
2686       case L'l':
2687         csBCaption = "circle";
2688         break;
2689       case L'8':
2690         csBCaption = "cross";
2691         break;
2692       case L'u':
2693         csBCaption = "diamond";
2694         break;
2695       case L'n':
2696         csBCaption = "square";
2697         break;
2698       case L'H':
2699         csBCaption = "star";
2700         break;
2701       default:  // L'4'
2702         csBCaption = "check";
2703         break;
2704     }
2705     vp << csBCaption;
2706   }
2707
2708   return TRUE;
2709 }
2710
2711 void Field::SetStyle(CPDFSDK_Document* pDocument,
2712                      const CFX_WideString& swFieldName,
2713                      int nControlIndex,
2714                      const CFX_ByteString& string) {
2715   // Not supported.
2716 }
2717
2718 FX_BOOL Field::submitName(IFXJS_Context* cc,
2719                           CJS_PropValue& vp,
2720                           CFX_WideString& sError) {
2721   return TRUE;
2722 }
2723
2724 FX_BOOL Field::textColor(IFXJS_Context* cc,
2725                          CJS_PropValue& vp,
2726                          CFX_WideString& sError) {
2727   ASSERT(m_pDocument != NULL);
2728
2729   if (vp.IsSetting()) {
2730     if (!m_bCanSet)
2731       return FALSE;
2732
2733     CJS_Array crArray(m_isolate);
2734     if (!vp.IsArrayObject())
2735       return FALSE;
2736     vp >> crArray;
2737
2738     CPWL_Color color;
2739     color::ConvertArrayToPWLColor(crArray, color);
2740
2741     if (m_bDelay) {
2742       AddDelay_Color(FP_TEXTCOLOR, color);
2743     } else {
2744       Field::SetTextColor(m_pDocument, m_FieldName, m_nFormControlIndex, color);
2745     }
2746   } else {
2747     CFX_PtrArray FieldArray;
2748     GetFormFields(m_FieldName, FieldArray);
2749     if (FieldArray.GetSize() <= 0)
2750       return FALSE;
2751
2752     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2753     ASSERT(pFormField != NULL);
2754
2755     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
2756     if (!pFormControl)
2757       return FALSE;
2758
2759     int iColorType;
2760     FX_ARGB color;
2761     CPDF_DefaultAppearance FieldAppearance =
2762         pFormControl->GetDefaultAppearance();
2763     FieldAppearance.GetColor(color, iColorType);
2764     int32_t a, r, g, b;
2765     ArgbDecode(color, a, r, g, b);
2766
2767     CPWL_Color crRet =
2768         CPWL_Color(COLORTYPE_RGB, r / 255.0f, g / 255.0f, b / 255.0f);
2769
2770     if (iColorType == COLORTYPE_TRANSPARENT)
2771       crRet = CPWL_Color(COLORTYPE_TRANSPARENT);
2772
2773     CJS_Array crArray(m_isolate);
2774     color::ConvertPWLColorToArray(crRet, crArray);
2775     vp << crArray;
2776   }
2777
2778   return TRUE;
2779 }
2780
2781 void Field::SetTextColor(CPDFSDK_Document* pDocument,
2782                          const CFX_WideString& swFieldName,
2783                          int nControlIndex,
2784                          const CPWL_Color& color) {
2785   // Not supported.
2786 }
2787
2788 FX_BOOL Field::textFont(IFXJS_Context* cc,
2789                         CJS_PropValue& vp,
2790                         CFX_WideString& sError) {
2791   ASSERT(m_pDocument != NULL);
2792
2793   if (vp.IsSetting()) {
2794     if (!m_bCanSet)
2795       return FALSE;
2796
2797     CFX_ByteString csFontName;
2798     vp >> csFontName;
2799     if (csFontName.IsEmpty())
2800       return FALSE;
2801
2802     if (m_bDelay) {
2803       AddDelay_String(FP_TEXTFONT, csFontName);
2804     } else {
2805       Field::SetTextFont(m_pDocument, m_FieldName, m_nFormControlIndex,
2806                          csFontName);
2807     }
2808   } else {
2809     CFX_PtrArray FieldArray;
2810     GetFormFields(m_FieldName, FieldArray);
2811     if (FieldArray.GetSize() <= 0)
2812       return FALSE;
2813
2814     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2815     ASSERT(pFormField != NULL);
2816
2817     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
2818     if (!pFormControl)
2819       return FALSE;
2820
2821     int nFieldType = pFormField->GetFieldType();
2822
2823     if (nFieldType == FIELDTYPE_PUSHBUTTON ||
2824         nFieldType == FIELDTYPE_COMBOBOX || nFieldType == FIELDTYPE_LISTBOX ||
2825         nFieldType == FIELDTYPE_TEXTFIELD) {
2826       CPDF_Font* pFont = pFormControl->GetDefaultControlFont();
2827       if (!pFont)
2828         return FALSE;
2829
2830       vp << pFont->GetBaseFont();
2831     } else
2832       return FALSE;
2833   }
2834
2835   return TRUE;
2836 }
2837
2838 void Field::SetTextFont(CPDFSDK_Document* pDocument,
2839                         const CFX_WideString& swFieldName,
2840                         int nControlIndex,
2841                         const CFX_ByteString& string) {
2842   // Not supported.
2843 }
2844
2845 FX_BOOL Field::textSize(IFXJS_Context* cc,
2846                         CJS_PropValue& vp,
2847                         CFX_WideString& sError) {
2848   ASSERT(m_pDocument != NULL);
2849
2850   if (vp.IsSetting()) {
2851     if (!m_bCanSet)
2852       return FALSE;
2853
2854     int nVP;
2855     vp >> nVP;
2856
2857     if (m_bDelay) {
2858       AddDelay_Int(FP_TEXTSIZE, nVP);
2859     } else {
2860       Field::SetTextSize(m_pDocument, m_FieldName, m_nFormControlIndex, nVP);
2861     }
2862   } else {
2863     CFX_PtrArray FieldArray;
2864     GetFormFields(m_FieldName, FieldArray);
2865     if (FieldArray.GetSize() <= 0)
2866       return FALSE;
2867
2868     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2869     ASSERT(pFormField != NULL);
2870
2871     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
2872     if (!pFormControl)
2873       return FALSE;
2874
2875     CPDF_DefaultAppearance FieldAppearance =
2876         pFormControl->GetDefaultAppearance();
2877
2878     CFX_ByteString csFontNameTag;
2879     FX_FLOAT fFontSize;
2880     FieldAppearance.GetFont(csFontNameTag, fFontSize);
2881
2882     vp << (int)fFontSize;
2883   }
2884
2885   return TRUE;
2886 }
2887
2888 void Field::SetTextSize(CPDFSDK_Document* pDocument,
2889                         const CFX_WideString& swFieldName,
2890                         int nControlIndex,
2891                         int number) {
2892   // Not supported.
2893 }
2894
2895 FX_BOOL Field::type(IFXJS_Context* cc,
2896                     CJS_PropValue& vp,
2897                     CFX_WideString& sError) {
2898   ASSERT(m_pDocument != NULL);
2899
2900   if (!vp.IsGetting())
2901     return FALSE;
2902
2903   CFX_PtrArray FieldArray;
2904   GetFormFields(m_FieldName, FieldArray);
2905   if (FieldArray.GetSize() <= 0)
2906     return FALSE;
2907
2908   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2909   ASSERT(pFormField != NULL);
2910
2911   switch (pFormField->GetFieldType()) {
2912     case FIELDTYPE_UNKNOWN:
2913       vp << L"unknown";
2914       break;
2915     case FIELDTYPE_PUSHBUTTON:
2916       vp << L"button";
2917       break;
2918     case FIELDTYPE_CHECKBOX:
2919       vp << L"checkbox";
2920       break;
2921     case FIELDTYPE_RADIOBUTTON:
2922       vp << L"radiobutton";
2923       break;
2924     case FIELDTYPE_COMBOBOX:
2925       vp << L"combobox";
2926       break;
2927     case FIELDTYPE_LISTBOX:
2928       vp << L"listbox";
2929       break;
2930     case FIELDTYPE_TEXTFIELD:
2931       vp << L"text";
2932       break;
2933     case FIELDTYPE_SIGNATURE:
2934       vp << L"signature";
2935       break;
2936     default:
2937       vp << L"unknown";
2938       break;
2939   }
2940
2941   return TRUE;
2942 }
2943
2944 FX_BOOL Field::userName(IFXJS_Context* cc,
2945                         CJS_PropValue& vp,
2946                         CFX_WideString& sError) {
2947   ASSERT(m_pDocument != NULL);
2948
2949   if (vp.IsSetting()) {
2950     if (!m_bCanSet)
2951       return FALSE;
2952
2953     CFX_WideString swName;
2954     vp >> swName;
2955
2956     if (m_bDelay) {
2957       AddDelay_WideString(FP_USERNAME, swName);
2958     } else {
2959       Field::SetUserName(m_pDocument, m_FieldName, m_nFormControlIndex, swName);
2960     }
2961   } else {
2962     CFX_PtrArray FieldArray;
2963     GetFormFields(m_FieldName, FieldArray);
2964     if (FieldArray.GetSize() <= 0)
2965       return FALSE;
2966
2967     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2968     ASSERT(pFormField != NULL);
2969
2970     vp << (CFX_WideString)pFormField->GetAlternateName();
2971   }
2972
2973   return TRUE;
2974 }
2975
2976 void Field::SetUserName(CPDFSDK_Document* pDocument,
2977                         const CFX_WideString& swFieldName,
2978                         int nControlIndex,
2979                         const CFX_WideString& string) {
2980   // Not supported.
2981 }
2982
2983 FX_BOOL Field::value(IFXJS_Context* cc,
2984                      CJS_PropValue& vp,
2985                      CFX_WideString& sError) {
2986   ASSERT(m_pDocument != NULL);
2987
2988   if (vp.IsSetting()) {
2989     if (!m_bCanSet)
2990       return FALSE;
2991
2992     CJS_WideStringArray strArray;
2993
2994     if (vp.IsArrayObject()) {
2995       CJS_Array ValueArray(m_isolate);
2996       vp.ConvertToArray(ValueArray);
2997       for (int i = 0, sz = ValueArray.GetLength(); i < sz; i++) {
2998         CJS_Value ElementValue(m_isolate);
2999         ValueArray.GetElement(i, ElementValue);
3000         strArray.Add(ElementValue.ToCFXWideString());
3001       }
3002     } else {
3003       CFX_WideString swValue;
3004       vp >> swValue;
3005
3006       strArray.Add(swValue);
3007     }
3008
3009     if (m_bDelay) {
3010       AddDelay_WideStringArray(FP_VALUE, strArray);
3011     } else {
3012       Field::SetValue(m_pDocument, m_FieldName, m_nFormControlIndex, strArray);
3013     }
3014   } else {
3015     CFX_PtrArray FieldArray;
3016     GetFormFields(m_FieldName, FieldArray);
3017     if (FieldArray.GetSize() <= 0)
3018       return FALSE;
3019
3020     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3021     ASSERT(pFormField != NULL);
3022
3023     switch (pFormField->GetFieldType()) {
3024       case FIELDTYPE_PUSHBUTTON:
3025         return FALSE;
3026       case FIELDTYPE_COMBOBOX:
3027       case FIELDTYPE_TEXTFIELD: {
3028         CFX_WideString swValue = pFormField->GetValue();
3029
3030         double dRet;
3031         FX_BOOL bDot;
3032         if (CJS_PublicMethods::ConvertStringToNumber(swValue.c_str(), dRet,
3033                                                      bDot)) {
3034           if (bDot)
3035             vp << dRet;
3036           else
3037             vp << dRet;
3038         } else
3039           vp << swValue;
3040       } break;
3041       case FIELDTYPE_LISTBOX: {
3042         if (pFormField->CountSelectedItems() > 1) {
3043           CJS_Array ValueArray(m_isolate);
3044           CJS_Value ElementValue(m_isolate);
3045           int iIndex;
3046           for (int i = 0, sz = pFormField->CountSelectedItems(); i < sz; i++) {
3047             iIndex = pFormField->GetSelectedIndex(i);
3048             ElementValue = pFormField->GetOptionValue(iIndex).c_str();
3049             if (FXSYS_wcslen(ElementValue.ToCFXWideString().c_str()) == 0)
3050               ElementValue = pFormField->GetOptionLabel(iIndex).c_str();
3051             ValueArray.SetElement(i, ElementValue);
3052           }
3053           vp << ValueArray;
3054         } else {
3055           CFX_WideString swValue = pFormField->GetValue();
3056
3057           double dRet;
3058           FX_BOOL bDot;
3059           if (CJS_PublicMethods::ConvertStringToNumber(swValue.c_str(), dRet,
3060                                                        bDot)) {
3061             if (bDot)
3062               vp << dRet;
3063             else
3064               vp << dRet;
3065           } else
3066             vp << swValue;
3067         }
3068       } break;
3069       case FIELDTYPE_CHECKBOX:
3070       case FIELDTYPE_RADIOBUTTON: {
3071         FX_BOOL bFind = FALSE;
3072         for (int i = 0, sz = pFormField->CountControls(); i < sz; i++) {
3073           if (pFormField->GetControl(i)->IsChecked()) {
3074             CFX_WideString swValue =
3075                 pFormField->GetControl(i)->GetExportValue();
3076             double dRet;
3077             FX_BOOL bDot;
3078             if (CJS_PublicMethods::ConvertStringToNumber(swValue.c_str(), dRet,
3079                                                          bDot)) {
3080               if (bDot)
3081                 vp << dRet;
3082               else
3083                 vp << dRet;
3084             } else
3085               vp << swValue;
3086
3087             bFind = TRUE;
3088             break;
3089           } else
3090             continue;
3091         }
3092         if (!bFind)
3093           vp << L"Off";
3094       } break;
3095       default:
3096         vp << pFormField->GetValue();
3097         break;
3098     }
3099   }
3100
3101   return TRUE;
3102 }
3103
3104 void Field::SetValue(CPDFSDK_Document* pDocument,
3105                      const CFX_WideString& swFieldName,
3106                      int nControlIndex,
3107                      const CJS_WideStringArray& strArray) {
3108   ASSERT(pDocument != NULL);
3109
3110   if (strArray.GetSize() < 1)
3111     return;
3112
3113   CFX_PtrArray FieldArray;
3114   GetFormFields(pDocument, swFieldName, FieldArray);
3115
3116   for (int i = 0, isz = FieldArray.GetSize(); i < isz; i++) {
3117     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
3118     ASSERT(pFormField != NULL);
3119
3120     if (pFormField->GetFullName().Compare(swFieldName) != 0)
3121       continue;
3122
3123     switch (pFormField->GetFieldType()) {
3124       case FIELDTYPE_TEXTFIELD:
3125       case FIELDTYPE_COMBOBOX:
3126         if (pFormField->GetValue() != strArray.GetAt(0)) {
3127           CFX_WideString WideString = strArray.GetAt(0);
3128           pFormField->SetValue(strArray.GetAt(0), TRUE);
3129           UpdateFormField(pDocument, pFormField, TRUE, FALSE, TRUE);
3130         }
3131         break;
3132       case FIELDTYPE_CHECKBOX:  // mantis: 0004493
3133       case FIELDTYPE_RADIOBUTTON: {
3134         if (pFormField->GetValue() != strArray.GetAt(0)) {
3135           pFormField->SetValue(strArray.GetAt(0), TRUE);
3136           UpdateFormField(pDocument, pFormField, TRUE, FALSE, TRUE);
3137         }
3138       } break;
3139       case FIELDTYPE_LISTBOX: {
3140         FX_BOOL bModified = FALSE;
3141
3142         for (int i = 0, sz = strArray.GetSize(); i < sz; i++) {
3143           int iIndex = pFormField->FindOption(strArray.GetAt(i));
3144
3145           if (!pFormField->IsItemSelected(iIndex)) {
3146             bModified = TRUE;
3147             break;
3148           }
3149         }
3150
3151         if (bModified) {
3152           pFormField->ClearSelection(TRUE);
3153           for (int i = 0, sz = strArray.GetSize(); i < sz; i++) {
3154             int iIndex = pFormField->FindOption(strArray.GetAt(i));
3155             pFormField->SetItemSelection(iIndex, TRUE, TRUE);
3156           }
3157
3158           UpdateFormField(pDocument, pFormField, TRUE, FALSE, TRUE);
3159         }
3160       } break;
3161       default:
3162         break;
3163     }
3164   }
3165 }
3166
3167 FX_BOOL Field::valueAsString(IFXJS_Context* cc,
3168                              CJS_PropValue& vp,
3169                              CFX_WideString& sError) {
3170   ASSERT(m_pDocument != NULL);
3171
3172   if (!vp.IsGetting())
3173     return FALSE;
3174
3175   CFX_PtrArray FieldArray;
3176   GetFormFields(m_FieldName, FieldArray);
3177   if (FieldArray.GetSize() <= 0)
3178     return FALSE;
3179
3180   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3181   ASSERT(pFormField != NULL);
3182
3183   if (pFormField->GetFieldType() == FIELDTYPE_PUSHBUTTON)
3184     return FALSE;
3185
3186   if (pFormField->GetFieldType() == FIELDTYPE_CHECKBOX) {
3187     if (!pFormField->CountControls())
3188       return FALSE;
3189
3190     if (pFormField->GetControl(0)->IsChecked())
3191       vp << L"Yes";
3192     else
3193       vp << L"Off";
3194   } else if (pFormField->GetFieldType() == FIELDTYPE_RADIOBUTTON &&
3195              !(pFormField->GetFieldFlags() & FIELDFLAG_RADIOSINUNISON)) {
3196     for (int i = 0, sz = pFormField->CountControls(); i < sz; i++) {
3197       if (pFormField->GetControl(i)->IsChecked()) {
3198         vp << pFormField->GetControl(i)->GetExportValue().c_str();
3199         break;
3200       } else
3201         vp << L"Off";
3202     }
3203   } else if (pFormField->GetFieldType() == FIELDTYPE_LISTBOX &&
3204              (pFormField->CountSelectedItems() > 1)) {
3205     vp << L"";
3206   } else
3207     vp << pFormField->GetValue().c_str();
3208
3209   return TRUE;
3210 }
3211
3212 /* --------------------------------- methods ---------------------------------
3213  */
3214
3215 FX_BOOL Field::browseForFileToSubmit(IFXJS_Context* cc,
3216                                      const CJS_Parameters& params,
3217                                      CJS_Value& vRet,
3218                                      CFX_WideString& sError) {
3219   ASSERT(m_pDocument != NULL);
3220
3221   CFX_PtrArray FieldArray;
3222   GetFormFields(m_FieldName, FieldArray);
3223   if (FieldArray.GetSize() <= 0)
3224     return FALSE;
3225
3226   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3227   ASSERT(pFormField != NULL);
3228
3229   CPDFDoc_Environment* pApp = m_pDocument->GetEnv();
3230   ASSERT(pApp != NULL);
3231
3232   if ((pFormField->GetFieldFlags() & FIELDFLAG_FILESELECT) &&
3233       (pFormField->GetFieldType() == FIELDTYPE_TEXTFIELD)) {
3234     CFX_WideString wsFileName = pApp->JS_fieldBrowse();
3235     if (!wsFileName.IsEmpty()) {
3236       pFormField->SetValue(wsFileName);
3237       UpdateFormField(m_pDocument, pFormField, TRUE, TRUE, TRUE);
3238     }
3239   } else
3240     return FALSE;
3241
3242   return TRUE;
3243 }
3244
3245 FX_BOOL Field::buttonGetCaption(IFXJS_Context* cc,
3246                                 const CJS_Parameters& params,
3247                                 CJS_Value& vRet,
3248                                 CFX_WideString& sError) {
3249   ASSERT(m_pDocument != NULL);
3250
3251   int nface = 0;
3252   int iSize = params.size();
3253   if (iSize >= 1)
3254     nface = params[0].ToInt();
3255
3256   CFX_PtrArray FieldArray;
3257   GetFormFields(m_FieldName, FieldArray);
3258   if (FieldArray.GetSize() <= 0)
3259     return FALSE;
3260
3261   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3262   ASSERT(pFormField != NULL);
3263
3264   if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
3265     return FALSE;
3266
3267   CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
3268   if (!pFormControl)
3269     return FALSE;
3270
3271   if (nface == 0)
3272     vRet = pFormControl->GetNormalCaption().c_str();
3273   else if (nface == 1)
3274     vRet = pFormControl->GetDownCaption().c_str();
3275   else if (nface == 2)
3276     vRet = pFormControl->GetRolloverCaption().c_str();
3277   else
3278     return FALSE;
3279
3280   return TRUE;
3281 }
3282
3283 //#pragma warning(disable: 4800)
3284
3285 FX_BOOL Field::buttonGetIcon(IFXJS_Context* cc,
3286                              const CJS_Parameters& params,
3287                              CJS_Value& vRet,
3288                              CFX_WideString& sError) {
3289   ASSERT(m_pDocument != NULL);
3290
3291   int nface = 0;
3292   int iSize = params.size();
3293   if (iSize >= 1)
3294     nface = params[0].ToInt();
3295
3296   CFX_PtrArray FieldArray;
3297   GetFormFields(m_FieldName, FieldArray);
3298   if (FieldArray.GetSize() <= 0)
3299     return FALSE;
3300
3301   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3302   if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
3303     return FALSE;
3304
3305   CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
3306   if (!pFormControl)
3307     return FALSE;
3308
3309   CJS_Context* pContext = (CJS_Context*)cc;
3310   CJS_Runtime* pRuntime = pContext->GetJSRuntime();
3311   v8::Local<v8::Object> pObj =
3312       FXJS_NewFxDynamicObj(pRuntime->GetIsolate(), pContext,
3313                            FXJS_GetObjDefnID(pRuntime->GetIsolate(), L"Icon"));
3314   ASSERT(pObj.IsEmpty() == FALSE);
3315
3316   CJS_Icon* pJS_Icon = (CJS_Icon*)FXJS_GetPrivate(pRuntime->GetIsolate(), pObj);
3317   Icon* pIcon = (Icon*)pJS_Icon->GetEmbedObject();
3318
3319   CPDF_Stream* pIconStream = NULL;
3320   if (nface == 0)
3321     pIconStream = pFormControl->GetNormalIcon();
3322   else if (nface == 1)
3323     pIconStream = pFormControl->GetDownIcon();
3324   else if (nface == 2)
3325     pIconStream = pFormControl->GetRolloverIcon();
3326   else
3327     return FALSE;
3328
3329   pIcon->SetStream(pIconStream);
3330   vRet = pJS_Icon;
3331
3332   return TRUE;
3333 }
3334
3335 FX_BOOL Field::buttonImportIcon(IFXJS_Context* cc,
3336                                 const CJS_Parameters& params,
3337                                 CJS_Value& vRet,
3338                                 CFX_WideString& sError) {
3339 #if 0
3340     ASSERT(m_pDocument != NULL);
3341
3342     CFX_PtrArray FieldArray;
3343     GetFormFields(m_FieldName,FieldArray);
3344     if (FieldArray.GetSize() <= 0) return FALSE;
3345
3346     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3347     if (!pFormField)return FALSE;
3348
3349     CPDFDoc_Environment* pEnv = m_pDocument->GetEnv();
3350     ASSERT(pEnv);
3351
3352     CFX_WideString sIconFileName = pEnv->JS_fieldBrowse();
3353     if (sIconFileName.IsEmpty())
3354     {
3355         vRet = 1;
3356         return TRUE;
3357     }
3358
3359     CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
3360     ASSERT(pInterForm != NULL);
3361
3362     CPDF_Stream* pStream = pInterForm->LoadImageFromFile(sIconFileName);
3363     if (!pStream)
3364     {
3365         vRet = -1;
3366         return TRUE;
3367     }
3368
3369     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
3370     if (!pFormControl)return FALSE;
3371
3372     pFormControl->SetNormalIcon(pStream);
3373     UpdateFormControl(m_pDocument, pFormControl, TRUE, TRUE, TRUE);
3374
3375     vRet = 0;
3376 #endif  // 0
3377   return TRUE;
3378 }
3379
3380 FX_BOOL Field::buttonSetCaption(IFXJS_Context* cc,
3381                                 const CJS_Parameters& params,
3382                                 CJS_Value& vRet,
3383                                 CFX_WideString& sError) {
3384   return FALSE;
3385 }
3386
3387 FX_BOOL Field::buttonSetIcon(IFXJS_Context* cc,
3388                              const CJS_Parameters& params,
3389                              CJS_Value& vRet,
3390                              CFX_WideString& sError) {
3391   return FALSE;
3392 }
3393
3394 FX_BOOL Field::checkThisBox(IFXJS_Context* cc,
3395                             const CJS_Parameters& params,
3396                             CJS_Value& vRet,
3397                             CFX_WideString& sError) {
3398   ASSERT(m_pDocument != NULL);
3399
3400   if (!m_bCanSet)
3401     return FALSE;
3402
3403   int iSize = params.size();
3404   if (iSize < 1)
3405     return FALSE;
3406
3407   int nWidget = params[0].ToInt();
3408
3409   FX_BOOL bCheckit = TRUE;
3410   if (iSize >= 2)
3411     bCheckit = params[1].ToBool();
3412
3413   CFX_PtrArray FieldArray;
3414   GetFormFields(m_FieldName, FieldArray);
3415   if (FieldArray.GetSize() <= 0)
3416     return FALSE;
3417
3418   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3419   ASSERT(pFormField != NULL);
3420
3421   if (pFormField->GetFieldType() != FIELDTYPE_CHECKBOX &&
3422       pFormField->GetFieldType() != FIELDTYPE_RADIOBUTTON)
3423     return FALSE;
3424   if (nWidget < 0 || nWidget >= pFormField->CountControls())
3425     return FALSE;
3426   if (pFormField->GetFieldType() == FIELDTYPE_RADIOBUTTON)
3427     pFormField->CheckControl(nWidget, bCheckit, TRUE);
3428   else
3429     pFormField->CheckControl(nWidget, bCheckit, TRUE);
3430
3431   UpdateFormField(m_pDocument, pFormField, TRUE, TRUE, TRUE);
3432   return TRUE;
3433 }
3434
3435 FX_BOOL Field::clearItems(IFXJS_Context* cc,
3436                           const CJS_Parameters& params,
3437                           CJS_Value& vRet,
3438                           CFX_WideString& sError) {
3439   return TRUE;
3440 }
3441
3442 FX_BOOL Field::defaultIsChecked(IFXJS_Context* cc,
3443                                 const CJS_Parameters& params,
3444                                 CJS_Value& vRet,
3445                                 CFX_WideString& sError) {
3446   ASSERT(m_pDocument != NULL);
3447
3448   if (!m_bCanSet)
3449     return FALSE;
3450
3451   int iSize = params.size();
3452   if (iSize < 1)
3453     return FALSE;
3454
3455   int nWidget = params[0].ToInt();
3456
3457   CFX_PtrArray FieldArray;
3458   GetFormFields(m_FieldName, FieldArray);
3459   if (FieldArray.GetSize() <= 0)
3460     return FALSE;
3461
3462   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3463   ASSERT(pFormField != NULL);
3464
3465   if (nWidget < 0 || nWidget >= pFormField->CountControls()) {
3466     vRet = FALSE;
3467     return FALSE;
3468   }
3469   if ((pFormField->GetFieldType() == FIELDTYPE_CHECKBOX) ||
3470       (pFormField->GetFieldType() == FIELDTYPE_RADIOBUTTON)) {
3471     vRet = TRUE;
3472   } else
3473     vRet = FALSE;
3474
3475   return TRUE;
3476 }
3477
3478 FX_BOOL Field::deleteItemAt(IFXJS_Context* cc,
3479                             const CJS_Parameters& params,
3480                             CJS_Value& vRet,
3481                             CFX_WideString& sError) {
3482   return TRUE;
3483 }
3484
3485 int JS_COMPARESTRING(CFX_WideString* ps1, CFX_WideString* ps2) {
3486   ASSERT(ps1 != NULL);
3487   ASSERT(ps2 != NULL);
3488
3489   return ps1->Compare(*ps2);
3490 }
3491
3492 FX_BOOL Field::getArray(IFXJS_Context* cc,
3493                         const CJS_Parameters& params,
3494                         CJS_Value& vRet,
3495                         CFX_WideString& sError) {
3496   ASSERT(m_pDocument != NULL);
3497
3498   CFX_PtrArray FieldArray;
3499   GetFormFields(m_FieldName, FieldArray);
3500   if (FieldArray.GetSize() <= 0)
3501     return FALSE;
3502
3503   CGW_ArrayTemplate<CFX_WideString*> swSort;
3504
3505   for (int i = 0, sz = FieldArray.GetSize(); i < sz; i++) {
3506     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
3507     ASSERT(pFormField != NULL);
3508
3509     swSort.Add(new CFX_WideString(pFormField->GetFullName()));
3510   }
3511   swSort.Sort(JS_COMPARESTRING);
3512
3513   CJS_Context* pContext = (CJS_Context*)cc;
3514   ASSERT(pContext != NULL);
3515   CJS_Runtime* pRuntime = pContext->GetJSRuntime();
3516   ASSERT(pRuntime != NULL);
3517
3518   CJS_Array FormFieldArray(m_isolate);
3519   for (int j = 0, jsz = swSort.GetSize(); j < jsz; j++) {
3520     nonstd::unique_ptr<CFX_WideString> pStr(swSort.GetAt(j));
3521     v8::Local<v8::Object> pObj = FXJS_NewFxDynamicObj(
3522         pRuntime->GetIsolate(), pContext,
3523         FXJS_GetObjDefnID(pRuntime->GetIsolate(), L"Field"));
3524     ASSERT(pObj.IsEmpty() == FALSE);
3525
3526     CJS_Field* pJSField =
3527         (CJS_Field*)FXJS_GetPrivate(pRuntime->GetIsolate(), pObj);
3528     Field* pField = (Field*)pJSField->GetEmbedObject();
3529     pField->AttachField(m_pJSDoc, *pStr);
3530
3531     CJS_Value FormFieldValue(m_isolate);
3532     FormFieldValue = pJSField;
3533     FormFieldArray.SetElement(j, FormFieldValue);
3534   }
3535
3536   vRet = FormFieldArray;
3537   swSort.RemoveAll();
3538   return TRUE;
3539 }
3540
3541 FX_BOOL Field::getItemAt(IFXJS_Context* cc,
3542                          const CJS_Parameters& params,
3543                          CJS_Value& vRet,
3544                          CFX_WideString& sError) {
3545   ASSERT(m_pDocument != NULL);
3546   int iSize = params.size();
3547
3548   int nIdx = -1;
3549   if (iSize >= 1)
3550     nIdx = params[0].ToInt();
3551
3552   FX_BOOL bExport = TRUE;
3553   if (iSize >= 2)
3554     bExport = params[1].ToBool();
3555
3556   CFX_PtrArray FieldArray;
3557   GetFormFields(m_FieldName, FieldArray);
3558   if (FieldArray.GetSize() <= 0)
3559     return FALSE;
3560
3561   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3562   ASSERT(pFormField != NULL);
3563
3564   if ((pFormField->GetFieldType() == FIELDTYPE_LISTBOX) ||
3565       (pFormField->GetFieldType() == FIELDTYPE_COMBOBOX)) {
3566     if (nIdx == -1 || nIdx > pFormField->CountOptions())
3567       nIdx = pFormField->CountOptions() - 1;
3568     if (bExport) {
3569       CFX_WideString strval = pFormField->GetOptionValue(nIdx);
3570       if (strval.IsEmpty())
3571         vRet = pFormField->GetOptionLabel(nIdx).c_str();
3572       else
3573         vRet = strval.c_str();
3574     } else
3575       vRet = pFormField->GetOptionLabel(nIdx).c_str();
3576   } else
3577     return FALSE;
3578
3579   return TRUE;
3580 }
3581
3582 FX_BOOL Field::getLock(IFXJS_Context* cc,
3583                        const CJS_Parameters& params,
3584                        CJS_Value& vRet,
3585                        CFX_WideString& sError) {
3586   return FALSE;
3587 }
3588
3589 FX_BOOL Field::insertItemAt(IFXJS_Context* cc,
3590                             const CJS_Parameters& params,
3591                             CJS_Value& vRet,
3592                             CFX_WideString& sError) {
3593   return TRUE;
3594 }
3595
3596 FX_BOOL Field::isBoxChecked(IFXJS_Context* cc,
3597                             const CJS_Parameters& params,
3598                             CJS_Value& vRet,
3599                             CFX_WideString& sError) {
3600   ASSERT(m_pDocument != NULL);
3601
3602   int nIndex = -1;
3603   if (params.size() >= 1)
3604     nIndex = params[0].ToInt();
3605
3606   CFX_PtrArray FieldArray;
3607   GetFormFields(m_FieldName, FieldArray);
3608   if (FieldArray.GetSize() <= 0)
3609     return FALSE;
3610
3611   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3612   ASSERT(pFormField != NULL);
3613
3614   if (nIndex < 0 || nIndex >= pFormField->CountControls()) {
3615     vRet = FALSE;
3616     return FALSE;
3617   }
3618
3619   if ((pFormField->GetFieldType() == FIELDTYPE_CHECKBOX) ||
3620       (pFormField->GetFieldType() == FIELDTYPE_RADIOBUTTON)) {
3621     if (pFormField->GetControl(nIndex)->IsChecked() != 0)
3622       vRet = TRUE;
3623     else
3624       vRet = FALSE;
3625   } else
3626     vRet = FALSE;
3627
3628   return TRUE;
3629 }
3630
3631 FX_BOOL Field::isDefaultChecked(IFXJS_Context* cc,
3632                                 const CJS_Parameters& params,
3633                                 CJS_Value& vRet,
3634                                 CFX_WideString& sError) {
3635   ASSERT(m_pDocument != NULL);
3636
3637   int nIndex = -1;
3638   if (params.size() >= 1)
3639     nIndex = params[0].ToInt();
3640
3641   CFX_PtrArray FieldArray;
3642   GetFormFields(m_FieldName, FieldArray);
3643   if (FieldArray.GetSize() <= 0)
3644     return FALSE;
3645
3646   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3647   ASSERT(pFormField != NULL);
3648
3649   if (nIndex < 0 || nIndex >= pFormField->CountControls()) {
3650     vRet = FALSE;
3651     return FALSE;
3652   }
3653   if ((pFormField->GetFieldType() == FIELDTYPE_CHECKBOX) ||
3654       (pFormField->GetFieldType() == FIELDTYPE_RADIOBUTTON)) {
3655     if (pFormField->GetControl(nIndex)->IsDefaultChecked() != 0)
3656       vRet = TRUE;
3657     else
3658       vRet = FALSE;
3659   } else
3660     vRet = FALSE;
3661
3662   return TRUE;
3663 }
3664
3665 FX_BOOL Field::setAction(IFXJS_Context* cc,
3666                          const CJS_Parameters& params,
3667                          CJS_Value& vRet,
3668                          CFX_WideString& sError) {
3669   return TRUE;
3670 }
3671
3672 FX_BOOL Field::setFocus(IFXJS_Context* cc,
3673                         const CJS_Parameters& params,
3674                         CJS_Value& vRet,
3675                         CFX_WideString& sError) {
3676   ASSERT(m_pDocument != NULL);
3677
3678   CFX_PtrArray FieldArray;
3679   GetFormFields(m_FieldName, FieldArray);
3680   if (FieldArray.GetSize() <= 0)
3681     return FALSE;
3682
3683   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3684   ASSERT(pFormField != NULL);
3685
3686   int32_t nCount = pFormField->CountControls();
3687
3688   if (nCount < 1)
3689     return FALSE;
3690
3691   CPDFSDK_InterForm* pInterForm =
3692       (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
3693   ASSERT(pInterForm != NULL);
3694
3695   CPDFSDK_Widget* pWidget = NULL;
3696   if (nCount == 1) {
3697     pWidget = pInterForm->GetWidget(pFormField->GetControl(0));
3698   } else {
3699     CPDFDoc_Environment* pEnv = m_pDocument->GetEnv();
3700     ASSERT(pEnv);
3701     CPDF_Page* pPage =
3702         (CPDF_Page*)pEnv->FFI_GetCurrentPage(m_pDocument->GetDocument());
3703     if (!pPage)
3704       return FALSE;
3705     if (CPDFSDK_PageView* pCurPageView = m_pDocument->GetPageView(pPage)) {
3706       for (int32_t i = 0; i < nCount; i++) {
3707         if (CPDFSDK_Widget* pTempWidget =
3708                 pInterForm->GetWidget(pFormField->GetControl(i))) {
3709           if (pTempWidget->GetPDFPage() == pCurPageView->GetPDFPage()) {
3710             pWidget = pTempWidget;
3711             break;
3712           }
3713         }
3714       }
3715     }
3716   }
3717
3718   if (pWidget) {
3719     m_pDocument->SetFocusAnnot(pWidget);
3720   }
3721
3722   return TRUE;
3723 }
3724
3725 FX_BOOL Field::setItems(IFXJS_Context* cc,
3726                         const CJS_Parameters& params,
3727                         CJS_Value& vRet,
3728                         CFX_WideString& sError) {
3729   return TRUE;
3730 }
3731
3732 FX_BOOL Field::setLock(IFXJS_Context* cc,
3733                        const CJS_Parameters& params,
3734                        CJS_Value& vRet,
3735                        CFX_WideString& sError) {
3736   return FALSE;
3737 }
3738
3739 FX_BOOL Field::signatureGetModifications(IFXJS_Context* cc,
3740                                          const CJS_Parameters& params,
3741                                          CJS_Value& vRet,
3742                                          CFX_WideString& sError) {
3743   return FALSE;
3744 }
3745
3746 FX_BOOL Field::signatureGetSeedValue(IFXJS_Context* cc,
3747                                      const CJS_Parameters& params,
3748                                      CJS_Value& vRet,
3749                                      CFX_WideString& sError) {
3750   return FALSE;
3751 }
3752
3753 FX_BOOL Field::signatureInfo(IFXJS_Context* cc,
3754                              const CJS_Parameters& params,
3755                              CJS_Value& vRet,
3756                              CFX_WideString& sError) {
3757   return FALSE;
3758 }
3759
3760 FX_BOOL Field::signatureSetSeedValue(IFXJS_Context* cc,
3761                                      const CJS_Parameters& params,
3762                                      CJS_Value& vRet,
3763                                      CFX_WideString& sError) {
3764   return FALSE;
3765 }
3766
3767 FX_BOOL Field::signatureSign(IFXJS_Context* cc,
3768                              const CJS_Parameters& params,
3769                              CJS_Value& vRet,
3770                              CFX_WideString& sError) {
3771   return FALSE;
3772 }
3773
3774 FX_BOOL Field::signatureValidate(IFXJS_Context* cc,
3775                                  const CJS_Parameters& params,
3776                                  CJS_Value& vRet,
3777                                  CFX_WideString& sError) {
3778   return FALSE;
3779 }
3780
3781 FX_BOOL Field::source(IFXJS_Context* cc,
3782                       CJS_PropValue& vp,
3783                       CFX_WideString& sError) {
3784   if (vp.IsGetting()) {
3785     vp << (CJS_Object*)NULL;
3786   }
3787
3788   return TRUE;
3789 }
3790
3791 /////////////////////////////////////////// delay
3792 ////////////////////////////////////////////////
3793
3794 void Field::AddDelay_Int(enum FIELD_PROP prop, int32_t n) {
3795   ASSERT(m_pJSDoc != NULL);
3796
3797   CJS_DelayData* pNewData = new CJS_DelayData;
3798   pNewData->sFieldName = m_FieldName;
3799   pNewData->nControlIndex = m_nFormControlIndex;
3800   pNewData->eProp = prop;
3801   pNewData->num = n;
3802
3803   m_pJSDoc->AddDelayData(pNewData);
3804 }
3805
3806 void Field::AddDelay_Bool(enum FIELD_PROP prop, bool b) {
3807   ASSERT(m_pJSDoc != NULL);
3808
3809   CJS_DelayData* pNewData = new CJS_DelayData;
3810   pNewData->sFieldName = m_FieldName;
3811   pNewData->nControlIndex = m_nFormControlIndex;
3812   pNewData->eProp = prop;
3813   pNewData->b = b;
3814
3815   m_pJSDoc->AddDelayData(pNewData);
3816 }
3817
3818 void Field::AddDelay_String(enum FIELD_PROP prop,
3819                             const CFX_ByteString& string) {
3820   ASSERT(m_pJSDoc != NULL);
3821
3822   CJS_DelayData* pNewData = new CJS_DelayData;
3823   pNewData->sFieldName = m_FieldName;
3824   pNewData->nControlIndex = m_nFormControlIndex;
3825   pNewData->eProp = prop;
3826   pNewData->string = string;
3827
3828   m_pJSDoc->AddDelayData(pNewData);
3829 }
3830
3831 void Field::AddDelay_WideString(enum FIELD_PROP prop,
3832                                 const CFX_WideString& string) {
3833   ASSERT(m_pJSDoc != NULL);
3834
3835   CJS_DelayData* pNewData = new CJS_DelayData;
3836   pNewData->sFieldName = m_FieldName;
3837   pNewData->nControlIndex = m_nFormControlIndex;
3838   pNewData->eProp = prop;
3839   pNewData->widestring = string;
3840
3841   m_pJSDoc->AddDelayData(pNewData);
3842 }
3843
3844 void Field::AddDelay_Rect(enum FIELD_PROP prop, const CPDF_Rect& rect) {
3845   ASSERT(m_pJSDoc != NULL);
3846
3847   CJS_DelayData* pNewData = new CJS_DelayData;
3848   pNewData->sFieldName = m_FieldName;
3849   pNewData->nControlIndex = m_nFormControlIndex;
3850   pNewData->eProp = prop;
3851   pNewData->rect = rect;
3852
3853   m_pJSDoc->AddDelayData(pNewData);
3854 }
3855
3856 void Field::AddDelay_Color(enum FIELD_PROP prop, const CPWL_Color& color) {
3857   ASSERT(m_pJSDoc != NULL);
3858
3859   CJS_DelayData* pNewData = new CJS_DelayData;
3860   pNewData->sFieldName = m_FieldName;
3861   pNewData->nControlIndex = m_nFormControlIndex;
3862   pNewData->eProp = prop;
3863   pNewData->color = color;
3864
3865   m_pJSDoc->AddDelayData(pNewData);
3866 }
3867
3868 void Field::AddDelay_WordArray(enum FIELD_PROP prop,
3869                                const CFX_DWordArray& array) {
3870   ASSERT(m_pJSDoc != NULL);
3871
3872   CJS_DelayData* pNewData = new CJS_DelayData;
3873   pNewData->sFieldName = m_FieldName;
3874   pNewData->nControlIndex = m_nFormControlIndex;
3875   pNewData->eProp = prop;
3876
3877   for (int i = 0, sz = array.GetSize(); i < sz; i++)
3878     pNewData->wordarray.Add(array.GetAt(i));
3879
3880   m_pJSDoc->AddDelayData(pNewData);
3881 }
3882
3883 void Field::AddDelay_WideStringArray(enum FIELD_PROP prop,
3884                                      const CJS_WideStringArray& array) {
3885   ASSERT(m_pJSDoc != NULL);
3886
3887   CJS_DelayData* pNewData = new CJS_DelayData;
3888   pNewData->sFieldName = m_FieldName;
3889   pNewData->nControlIndex = m_nFormControlIndex;
3890   pNewData->eProp = prop;
3891   for (int i = 0, sz = array.GetSize(); i < sz; i++)
3892     pNewData->widestringarray.Add(array.GetAt(i));
3893
3894   m_pJSDoc->AddDelayData(pNewData);
3895 }
3896
3897 void Field::DoDelay(CPDFSDK_Document* pDocument, CJS_DelayData* pData) {
3898   ASSERT(pDocument != NULL);
3899   ASSERT(pData != NULL);
3900
3901   switch (pData->eProp) {
3902     case FP_ALIGNMENT:
3903       Field::SetAlignment(pDocument, pData->sFieldName, pData->nControlIndex,
3904                           pData->string);
3905       break;
3906     case FP_BORDERSTYLE:
3907       Field::SetBorderStyle(pDocument, pData->sFieldName, pData->nControlIndex,
3908                             pData->string);
3909       break;
3910     case FP_BUTTONALIGNX:
3911       Field::SetButtonAlignX(pDocument, pData->sFieldName, pData->nControlIndex,
3912                              pData->num);
3913       break;
3914     case FP_BUTTONALIGNY:
3915       Field::SetButtonAlignY(pDocument, pData->sFieldName, pData->nControlIndex,
3916                              pData->num);
3917       break;
3918     case FP_BUTTONFITBOUNDS:
3919       Field::SetButtonFitBounds(pDocument, pData->sFieldName,
3920                                 pData->nControlIndex, pData->b);
3921       break;
3922     case FP_BUTTONPOSITION:
3923       Field::SetButtonPosition(pDocument, pData->sFieldName,
3924                                pData->nControlIndex, pData->num);
3925       break;
3926     case FP_BUTTONSCALEHOW:
3927       Field::SetButtonScaleHow(pDocument, pData->sFieldName,
3928                                pData->nControlIndex, pData->num);
3929       break;
3930     case FP_BUTTONSCALEWHEN:
3931       Field::SetButtonScaleWhen(pDocument, pData->sFieldName,
3932                                 pData->nControlIndex, pData->num);
3933       break;
3934     case FP_CALCORDERINDEX:
3935       Field::SetCalcOrderIndex(pDocument, pData->sFieldName,
3936                                pData->nControlIndex, pData->num);
3937       break;
3938     case FP_CHARLIMIT:
3939       Field::SetCharLimit(pDocument, pData->sFieldName, pData->nControlIndex,
3940                           pData->num);
3941       break;
3942     case FP_COMB:
3943       Field::SetComb(pDocument, pData->sFieldName, pData->nControlIndex,
3944                      pData->b);
3945       break;
3946     case FP_COMMITONSELCHANGE:
3947       Field::SetCommitOnSelChange(pDocument, pData->sFieldName,
3948                                   pData->nControlIndex, pData->b);
3949       break;
3950     case FP_CURRENTVALUEINDICES:
3951       Field::SetCurrentValueIndices(pDocument, pData->sFieldName,
3952                                     pData->nControlIndex, pData->wordarray);
3953       break;
3954     case FP_DEFAULTVALUE:
3955       Field::SetDefaultValue(pDocument, pData->sFieldName, pData->nControlIndex,
3956                              pData->widestring);
3957       break;
3958     case FP_DONOTSCROLL:
3959       Field::SetDoNotScroll(pDocument, pData->sFieldName, pData->nControlIndex,
3960                             pData->b);
3961       break;
3962     case FP_DISPLAY:
3963       Field::SetDisplay(pDocument, pData->sFieldName, pData->nControlIndex,
3964                         pData->num);
3965       break;
3966     case FP_FILLCOLOR:
3967       Field::SetFillColor(pDocument, pData->sFieldName, pData->nControlIndex,
3968                           pData->color);
3969       break;
3970     case FP_HIDDEN:
3971       Field::SetHidden(pDocument, pData->sFieldName, pData->nControlIndex,
3972                        pData->b);
3973       break;
3974     case FP_HIGHLIGHT:
3975       Field::SetHighlight(pDocument, pData->sFieldName, pData->nControlIndex,
3976                           pData->string);
3977       break;
3978     case FP_LINEWIDTH:
3979       Field::SetLineWidth(pDocument, pData->sFieldName, pData->nControlIndex,
3980                           pData->num);
3981       break;
3982     case FP_MULTILINE:
3983       Field::SetMultiline(pDocument, pData->sFieldName, pData->nControlIndex,
3984                           pData->b);
3985       break;
3986     case FP_MULTIPLESELECTION:
3987       Field::SetMultipleSelection(pDocument, pData->sFieldName,
3988                                   pData->nControlIndex, pData->b);
3989       break;
3990     case FP_PASSWORD:
3991       Field::SetPassword(pDocument, pData->sFieldName, pData->nControlIndex,
3992                          pData->b);
3993       break;
3994     case FP_RECT:
3995       Field::SetRect(pDocument, pData->sFieldName, pData->nControlIndex,
3996                      pData->rect);
3997       break;
3998     case FP_RICHTEXT:
3999       Field::SetRichText(pDocument, pData->sFieldName, pData->nControlIndex,
4000                          pData->b);
4001       break;
4002     case FP_RICHVALUE:
4003       break;
4004     case FP_ROTATION:
4005       Field::SetRotation(pDocument, pData->sFieldName, pData->nControlIndex,
4006                          pData->num);
4007       break;
4008     case FP_STROKECOLOR:
4009       Field::SetStrokeColor(pDocument, pData->sFieldName, pData->nControlIndex,
4010                             pData->color);
4011       break;
4012     case FP_STYLE:
4013       Field::SetStyle(pDocument, pData->sFieldName, pData->nControlIndex,
4014                       pData->string);
4015       break;
4016     case FP_TEXTCOLOR:
4017       Field::SetTextColor(pDocument, pData->sFieldName, pData->nControlIndex,
4018                           pData->color);
4019       break;
4020     case FP_TEXTFONT:
4021       Field::SetTextFont(pDocument, pData->sFieldName, pData->nControlIndex,
4022                          pData->string);
4023       break;
4024     case FP_TEXTSIZE:
4025       Field::SetTextSize(pDocument, pData->sFieldName, pData->nControlIndex,
4026                          pData->num);
4027       break;
4028     case FP_USERNAME:
4029       Field::SetUserName(pDocument, pData->sFieldName, pData->nControlIndex,
4030                          pData->widestring);
4031       break;
4032     case FP_VALUE:
4033       Field::SetValue(pDocument, pData->sFieldName, pData->nControlIndex,
4034                       pData->widestringarray);
4035       break;
4036   }
4037 }
4038
4039 #define JS_FIELD_MINWIDTH 1
4040 #define JS_FIELD_MINHEIGHT 1
4041
4042 void Field::AddField(CPDFSDK_Document* pDocument,
4043                      int nPageIndex,
4044                      int nFieldType,
4045                      const CFX_WideString& sName,
4046                      const CPDF_Rect& rcCoords) {
4047   // Not supported.
4048 }