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