Wean CJS_Value off of v8::Isolate.
[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(IJS_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(IJS_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(IJS_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(IJS_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(IJS_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(IJS_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(IJS_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(IJS_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(IJS_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(IJS_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(IJS_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(IJS_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(IJS_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(IJS_Context* cc,
1032                                    CJS_PropValue& vp,
1033                                    CFX_WideString& sError) {
1034   CJS_Runtime* pRuntime = CJS_Runtime::FromContext(cc);
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(pRuntime);
1048       CJS_Value SelValue(pRuntime);
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(pRuntime);
1081       for (int i = 0, sz = pFormField->CountSelectedItems(); i < sz; i++) {
1082         SelArray.SetElement(
1083             i, CJS_Value(pRuntime, 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(IJS_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(IJS_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(IJS_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(IJS_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(IJS_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(IJS_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(IJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError) {
1451   if (!vp.IsGetting()) {
1452     return FALSE;
1453   }
1454   vp << m_pJSDoc->GetCJSDoc();
1455   return TRUE;
1456 }
1457
1458 FX_BOOL Field::editable(IJS_Context* cc,
1459                         CJS_PropValue& vp,
1460                         CFX_WideString& sError) {
1461   ASSERT(m_pDocument != NULL);
1462   if (vp.IsSetting()) {
1463     if (!m_bCanSet)
1464       return FALSE;
1465
1466     bool bVP;
1467     vp >> bVP;
1468   } else {
1469     CFX_PtrArray FieldArray;
1470     GetFormFields(m_FieldName, FieldArray);
1471     if (FieldArray.GetSize() <= 0)
1472       return FALSE;
1473
1474     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1475     ASSERT(pFormField != NULL);
1476
1477     if (pFormField->GetFieldType() != FIELDTYPE_COMBOBOX)
1478       return FALSE;
1479
1480     if (pFormField->GetFieldFlags() & FIELDFLAG_EDIT)
1481       vp << true;
1482     else
1483       vp << false;
1484   }
1485
1486   return TRUE;
1487 }
1488
1489 FX_BOOL Field::exportValues(IJS_Context* cc,
1490                             CJS_PropValue& vp,
1491                             CFX_WideString& sError) {
1492   CFX_PtrArray FieldArray;
1493   GetFormFields(m_FieldName, FieldArray);
1494   if (FieldArray.GetSize() <= 0)
1495     return FALSE;
1496
1497   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1498   if (pFormField->GetFieldType() != FIELDTYPE_CHECKBOX &&
1499       pFormField->GetFieldType() != FIELDTYPE_RADIOBUTTON)
1500     return FALSE;
1501
1502   if (vp.IsSetting()) {
1503     if (!m_bCanSet)
1504       return FALSE;
1505
1506     if (!vp.IsArrayObject())
1507       return FALSE;
1508   } else {
1509     CJS_Runtime* pRuntime = CJS_Runtime::FromContext(cc);
1510     CJS_Array ExportValusArray(pRuntime);
1511     if (m_nFormControlIndex < 0) {
1512       for (int i = 0, sz = pFormField->CountControls(); i < sz; i++) {
1513         CPDF_FormControl* pFormControl = pFormField->GetControl(i);
1514         ExportValusArray.SetElement(
1515             i, CJS_Value(pRuntime, pFormControl->GetExportValue().c_str()));
1516       }
1517     } else {
1518       if (m_nFormControlIndex >= pFormField->CountControls())
1519         return FALSE;
1520
1521       CPDF_FormControl* pFormControl =
1522           pFormField->GetControl(m_nFormControlIndex);
1523       if (!pFormControl)
1524         return FALSE;
1525
1526       ExportValusArray.SetElement(
1527           0, CJS_Value(pRuntime, pFormControl->GetExportValue().c_str()));
1528     }
1529     vp << ExportValusArray;
1530   }
1531   return TRUE;
1532 }
1533
1534 FX_BOOL Field::fileSelect(IJS_Context* cc,
1535                           CJS_PropValue& vp,
1536                           CFX_WideString& sError) {
1537   ASSERT(m_pDocument != NULL);
1538
1539   CFX_PtrArray FieldArray;
1540   GetFormFields(m_FieldName, FieldArray);
1541   if (FieldArray.GetSize() <= 0)
1542     return FALSE;
1543
1544   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1545   if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
1546     return FALSE;
1547
1548   if (vp.IsSetting()) {
1549     if (!m_bCanSet)
1550       return FALSE;
1551
1552     bool bVP;
1553     vp >> bVP;
1554   } else {
1555     if (pFormField->GetFieldFlags() & FIELDFLAG_FILESELECT)
1556       vp << true;
1557     else
1558       vp << false;
1559   }
1560   return TRUE;
1561 }
1562
1563 FX_BOOL Field::fillColor(IJS_Context* cc,
1564                          CJS_PropValue& vp,
1565                          CFX_WideString& sError) {
1566   CJS_Runtime* pRuntime = CJS_Runtime::FromContext(cc);
1567   CJS_Array crArray(pRuntime);
1568   CFX_PtrArray FieldArray;
1569   GetFormFields(m_FieldName, FieldArray);
1570   if (FieldArray.GetSize() <= 0)
1571     return FALSE;
1572
1573   if (vp.IsSetting()) {
1574     if (!m_bCanSet)
1575       return FALSE;
1576
1577     if (!vp.IsArrayObject())
1578       return FALSE;
1579
1580     vp >> crArray;
1581
1582     CPWL_Color color;
1583     color::ConvertArrayToPWLColor(crArray, color);
1584     if (m_bDelay) {
1585       AddDelay_Color(FP_FILLCOLOR, color);
1586     } else {
1587       Field::SetFillColor(m_pDocument, m_FieldName, m_nFormControlIndex, color);
1588     }
1589   } else {
1590     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1591     ASSERT(pFormField != NULL);
1592
1593     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
1594     if (!pFormControl)
1595       return FALSE;
1596
1597     int iColorType;
1598     pFormControl->GetBackgroundColor(iColorType);
1599
1600     CPWL_Color color;
1601     if (iColorType == COLORTYPE_TRANSPARENT) {
1602       color = CPWL_Color(COLORTYPE_TRANSPARENT);
1603     } else if (iColorType == COLORTYPE_GRAY) {
1604       color = CPWL_Color(COLORTYPE_GRAY,
1605                          pFormControl->GetOriginalBackgroundColor(0));
1606     } else if (iColorType == COLORTYPE_RGB) {
1607       color =
1608           CPWL_Color(COLORTYPE_RGB, pFormControl->GetOriginalBackgroundColor(0),
1609                      pFormControl->GetOriginalBackgroundColor(1),
1610                      pFormControl->GetOriginalBackgroundColor(2));
1611     } else if (iColorType == COLORTYPE_CMYK) {
1612       color = CPWL_Color(COLORTYPE_CMYK,
1613                          pFormControl->GetOriginalBackgroundColor(0),
1614                          pFormControl->GetOriginalBackgroundColor(1),
1615                          pFormControl->GetOriginalBackgroundColor(2),
1616                          pFormControl->GetOriginalBackgroundColor(3));
1617     } else
1618       return FALSE;
1619
1620     color::ConvertPWLColorToArray(color, crArray);
1621     vp << crArray;
1622   }
1623
1624   return TRUE;
1625 }
1626
1627 void Field::SetFillColor(CPDFSDK_Document* pDocument,
1628                          const CFX_WideString& swFieldName,
1629                          int nControlIndex,
1630                          const CPWL_Color& color) {
1631   // Not supported.
1632 }
1633
1634 FX_BOOL Field::hidden(IJS_Context* cc,
1635                       CJS_PropValue& vp,
1636                       CFX_WideString& sError) {
1637   ASSERT(m_pDocument != NULL);
1638
1639   if (vp.IsSetting()) {
1640     if (!m_bCanSet)
1641       return FALSE;
1642
1643     bool bVP;
1644     vp >> bVP;
1645
1646     if (m_bDelay) {
1647       AddDelay_Bool(FP_HIDDEN, bVP);
1648     } else {
1649       Field::SetHidden(m_pDocument, m_FieldName, m_nFormControlIndex, bVP);
1650     }
1651   } else {
1652     CFX_PtrArray FieldArray;
1653     GetFormFields(m_FieldName, FieldArray);
1654     if (FieldArray.GetSize() <= 0)
1655       return FALSE;
1656
1657     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1658     ASSERT(pFormField != NULL);
1659
1660     CPDFSDK_InterForm* pInterForm =
1661         (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
1662     ASSERT(pInterForm != NULL);
1663
1664     CPDFSDK_Widget* pWidget =
1665         pInterForm->GetWidget(GetSmartFieldControl(pFormField));
1666     if (!pWidget)
1667       return FALSE;
1668
1669     FX_DWORD dwFlags = pWidget->GetFlags();
1670
1671     if (ANNOTFLAG_INVISIBLE & dwFlags || ANNOTFLAG_HIDDEN & dwFlags) {
1672       vp << true;
1673     } else
1674       vp << false;
1675   }
1676
1677   return TRUE;
1678 }
1679
1680 void Field::SetHidden(CPDFSDK_Document* pDocument,
1681                       const CFX_WideString& swFieldName,
1682                       int nControlIndex,
1683                       bool b) {
1684   ASSERT(pDocument != NULL);
1685
1686   CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)pDocument->GetInterForm();
1687   ASSERT(pInterForm != NULL);
1688
1689   CFX_PtrArray FieldArray;
1690   GetFormFields(pDocument, swFieldName, FieldArray);
1691
1692   for (int i = 0, isz = FieldArray.GetSize(); i < isz; i++) {
1693     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
1694     ASSERT(pFormField != NULL);
1695
1696     if (nControlIndex < 0) {
1697       FX_BOOL bSet = FALSE;
1698       for (int j = 0, jsz = pFormField->CountControls(); j < jsz; j++) {
1699         if (CPDFSDK_Widget* pWidget =
1700                 pInterForm->GetWidget(pFormField->GetControl(j))) {
1701           FX_DWORD dwFlags = pWidget->GetFlags();
1702
1703           if (b) {
1704             dwFlags &= (~ANNOTFLAG_INVISIBLE);
1705             dwFlags &= (~ANNOTFLAG_NOVIEW);
1706             dwFlags |= (ANNOTFLAG_HIDDEN | ANNOTFLAG_PRINT);
1707           } else {
1708             dwFlags &= (~ANNOTFLAG_INVISIBLE);
1709             dwFlags &= (~ANNOTFLAG_HIDDEN);
1710             dwFlags &= (~ANNOTFLAG_NOVIEW);
1711             dwFlags |= ANNOTFLAG_PRINT;
1712           }
1713
1714           if (dwFlags != pWidget->GetFlags()) {
1715             pWidget->SetFlags(dwFlags);
1716             bSet = TRUE;
1717           }
1718         }
1719       }
1720
1721       if (bSet)
1722         UpdateFormField(pDocument, pFormField, TRUE, FALSE, TRUE);
1723     } else {
1724       if (nControlIndex >= pFormField->CountControls())
1725         return;
1726       if (CPDF_FormControl* pFormControl =
1727               pFormField->GetControl(nControlIndex)) {
1728         if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl)) {
1729           FX_DWORD dwFlags = pWidget->GetFlags();
1730
1731           if (b) {
1732             dwFlags &= (~ANNOTFLAG_INVISIBLE);
1733             dwFlags &= (~ANNOTFLAG_NOVIEW);
1734             dwFlags |= (ANNOTFLAG_HIDDEN | ANNOTFLAG_PRINT);
1735           } else {
1736             dwFlags &= (~ANNOTFLAG_INVISIBLE);
1737             dwFlags &= (~ANNOTFLAG_HIDDEN);
1738             dwFlags &= (~ANNOTFLAG_NOVIEW);
1739             dwFlags |= ANNOTFLAG_PRINT;
1740           }
1741
1742           if (dwFlags != pWidget->GetFlags()) {
1743             pWidget->SetFlags(dwFlags);
1744             UpdateFormControl(pDocument, pFormControl, TRUE, FALSE, TRUE);
1745           }
1746         }
1747       }
1748     }
1749   }
1750 }
1751
1752 FX_BOOL Field::highlight(IJS_Context* cc,
1753                          CJS_PropValue& vp,
1754                          CFX_WideString& sError) {
1755   ASSERT(m_pDocument != NULL);
1756
1757   if (vp.IsSetting()) {
1758     if (!m_bCanSet)
1759       return FALSE;
1760
1761     CFX_ByteString strMode;
1762     vp >> strMode;
1763
1764     if (m_bDelay) {
1765       AddDelay_String(FP_HIGHLIGHT, strMode);
1766     } else {
1767       Field::SetHighlight(m_pDocument, m_FieldName, m_nFormControlIndex,
1768                           strMode);
1769     }
1770   } else {
1771     CFX_PtrArray FieldArray;
1772     GetFormFields(m_FieldName, FieldArray);
1773     if (FieldArray.GetSize() <= 0)
1774       return FALSE;
1775
1776     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1777     ASSERT(pFormField != NULL);
1778
1779     if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
1780       return FALSE;
1781
1782     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
1783     if (!pFormControl)
1784       return FALSE;
1785
1786     int eHM = pFormControl->GetHighlightingMode();
1787     switch (eHM) {
1788       case CPDF_FormControl::None:
1789         vp << L"none";
1790         break;
1791       case CPDF_FormControl::Push:
1792         vp << L"push";
1793         break;
1794       case CPDF_FormControl::Invert:
1795         vp << L"invert";
1796         break;
1797       case CPDF_FormControl::Outline:
1798         vp << L"outline";
1799         break;
1800       case CPDF_FormControl::Toggle:
1801         vp << L"toggle";
1802         break;
1803     }
1804   }
1805
1806   return TRUE;
1807 }
1808
1809 void Field::SetHighlight(CPDFSDK_Document* pDocument,
1810                          const CFX_WideString& swFieldName,
1811                          int nControlIndex,
1812                          const CFX_ByteString& string) {
1813   // Not supported.
1814 }
1815
1816 FX_BOOL Field::lineWidth(IJS_Context* cc,
1817                          CJS_PropValue& vp,
1818                          CFX_WideString& sError) {
1819   ASSERT(m_pDocument != NULL);
1820
1821   if (vp.IsSetting()) {
1822     if (!m_bCanSet)
1823       return FALSE;
1824
1825     int iWidth;
1826     vp >> iWidth;
1827
1828     if (m_bDelay) {
1829       AddDelay_Int(FP_LINEWIDTH, iWidth);
1830     } else {
1831       Field::SetLineWidth(m_pDocument, m_FieldName, m_nFormControlIndex,
1832                           iWidth);
1833     }
1834   } else {
1835     CFX_PtrArray FieldArray;
1836     GetFormFields(m_FieldName, FieldArray);
1837     if (FieldArray.GetSize() <= 0)
1838       return FALSE;
1839
1840     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1841     ASSERT(pFormField != NULL);
1842
1843     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
1844     if (!pFormControl)
1845       return FALSE;
1846
1847     CPDFSDK_InterForm* pInterForm =
1848         (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
1849     ASSERT(pInterForm != NULL);
1850
1851     if (!pFormField->CountControls())
1852       return FALSE;
1853
1854     CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormField->GetControl(0));
1855     if (!pWidget)
1856       return FALSE;
1857
1858     vp << (int32_t)pWidget->GetBorderWidth();
1859   }
1860
1861   return TRUE;
1862 }
1863
1864 void Field::SetLineWidth(CPDFSDK_Document* pDocument,
1865                          const CFX_WideString& swFieldName,
1866                          int nControlIndex,
1867                          int number) {
1868   ASSERT(pDocument != NULL);
1869
1870   CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)pDocument->GetInterForm();
1871   ASSERT(pInterForm != NULL);
1872
1873   CFX_PtrArray FieldArray;
1874   GetFormFields(pDocument, swFieldName, FieldArray);
1875
1876   for (int i = 0, isz = FieldArray.GetSize(); i < isz; i++) {
1877     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
1878     ASSERT(pFormField != NULL);
1879
1880     if (nControlIndex < 0) {
1881       FX_BOOL bSet = FALSE;
1882       for (int j = 0, jsz = pFormField->CountControls(); j < jsz; j++) {
1883         CPDF_FormControl* pFormControl = pFormField->GetControl(j);
1884         ASSERT(pFormControl != NULL);
1885
1886         if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl)) {
1887           if (number != pWidget->GetBorderWidth()) {
1888             pWidget->SetBorderWidth(number);
1889             bSet = TRUE;
1890           }
1891         }
1892       }
1893       if (bSet)
1894         UpdateFormField(pDocument, pFormField, TRUE, TRUE, TRUE);
1895     } else {
1896       if (nControlIndex >= pFormField->CountControls())
1897         return;
1898       if (CPDF_FormControl* pFormControl =
1899               pFormField->GetControl(nControlIndex)) {
1900         if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl)) {
1901           if (number != pWidget->GetBorderWidth()) {
1902             pWidget->SetBorderWidth(number);
1903             UpdateFormControl(pDocument, pFormControl, TRUE, TRUE, TRUE);
1904           }
1905         }
1906       }
1907     }
1908   }
1909 }
1910
1911 FX_BOOL Field::multiline(IJS_Context* cc,
1912                          CJS_PropValue& vp,
1913                          CFX_WideString& sError) {
1914   ASSERT(m_pDocument != NULL);
1915
1916   if (vp.IsSetting()) {
1917     if (!m_bCanSet)
1918       return FALSE;
1919
1920     bool bVP;
1921     vp >> bVP;
1922
1923     if (m_bDelay) {
1924       AddDelay_Bool(FP_MULTILINE, bVP);
1925     } else {
1926       Field::SetMultiline(m_pDocument, m_FieldName, m_nFormControlIndex, bVP);
1927     }
1928   } else {
1929     CFX_PtrArray FieldArray;
1930     GetFormFields(m_FieldName, FieldArray);
1931     if (FieldArray.GetSize() <= 0)
1932       return FALSE;
1933
1934     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1935     ASSERT(pFormField != NULL);
1936
1937     if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
1938       return FALSE;
1939
1940     if (pFormField->GetFieldFlags() & FIELDFLAG_MULTILINE)
1941       vp << true;
1942     else
1943       vp << false;
1944   }
1945
1946   return TRUE;
1947 }
1948
1949 void Field::SetMultiline(CPDFSDK_Document* pDocument,
1950                          const CFX_WideString& swFieldName,
1951                          int nControlIndex,
1952                          bool b) {
1953   // Not supported.
1954 }
1955
1956 FX_BOOL Field::multipleSelection(IJS_Context* cc,
1957                                  CJS_PropValue& vp,
1958                                  CFX_WideString& sError) {
1959   ASSERT(m_pDocument != NULL);
1960
1961   if (vp.IsSetting()) {
1962     if (!m_bCanSet)
1963       return FALSE;
1964
1965     bool bVP;
1966     vp >> bVP;
1967
1968     if (m_bDelay) {
1969       AddDelay_Bool(FP_MULTIPLESELECTION, bVP);
1970     } else {
1971       Field::SetMultipleSelection(m_pDocument, m_FieldName, m_nFormControlIndex,
1972                                   bVP);
1973     }
1974   } else {
1975     CFX_PtrArray FieldArray;
1976     GetFormFields(m_FieldName, FieldArray);
1977     if (FieldArray.GetSize() <= 0)
1978       return FALSE;
1979
1980     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1981     ASSERT(pFormField != NULL);
1982
1983     if (pFormField->GetFieldType() != FIELDTYPE_LISTBOX)
1984       return FALSE;
1985
1986     if (pFormField->GetFieldFlags() & FIELDFLAG_MULTISELECT)
1987       vp << true;
1988     else
1989       vp << false;
1990   }
1991
1992   return TRUE;
1993 }
1994
1995 void Field::SetMultipleSelection(CPDFSDK_Document* pDocument,
1996                                  const CFX_WideString& swFieldName,
1997                                  int nControlIndex,
1998                                  bool b) {
1999   // Not supported.
2000 }
2001
2002 FX_BOOL Field::name(IJS_Context* cc,
2003                     CJS_PropValue& vp,
2004                     CFX_WideString& sError) {
2005   if (!vp.IsGetting())
2006     return FALSE;
2007
2008   CFX_PtrArray FieldArray;
2009   GetFormFields(m_FieldName, FieldArray);
2010   if (FieldArray.GetSize() <= 0)
2011     return FALSE;
2012
2013   vp << m_FieldName;
2014
2015   return TRUE;
2016 }
2017
2018 FX_BOOL Field::numItems(IJS_Context* cc,
2019                         CJS_PropValue& vp,
2020                         CFX_WideString& sError) {
2021   if (!vp.IsGetting())
2022     return FALSE;
2023
2024   CFX_PtrArray FieldArray;
2025   GetFormFields(m_FieldName, FieldArray);
2026   if (FieldArray.GetSize() <= 0)
2027     return FALSE;
2028
2029   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2030   if (pFormField->GetFieldType() != FIELDTYPE_COMBOBOX &&
2031       pFormField->GetFieldType() != FIELDTYPE_LISTBOX)
2032     return FALSE;
2033
2034   vp << (int32_t)pFormField->CountOptions();
2035   return TRUE;
2036 }
2037
2038 FX_BOOL Field::page(IJS_Context* cc,
2039                     CJS_PropValue& vp,
2040                     CFX_WideString& sError) {
2041   if (!vp.IsGetting())
2042     return FALSE;
2043
2044   CFX_PtrArray FieldArray;
2045   GetFormFields(m_FieldName, FieldArray);
2046   if (FieldArray.GetSize() <= 0)
2047     return FALSE;
2048
2049   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2050   if (!pFormField)
2051     return FALSE;
2052
2053   CFX_PtrArray widgetArray;
2054   CPDFSDK_InterForm* pInterForm =
2055       (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
2056   pInterForm->GetWidgets(pFormField, widgetArray);
2057
2058   if (widgetArray.GetSize() > 0) {
2059     CJS_Runtime* pRuntime = CJS_Runtime::FromContext(cc);
2060     CJS_Array PageArray(pRuntime);
2061     for (int i = 0, sz = widgetArray.GetSize(); i < sz; i++) {
2062       CPDFSDK_Widget* pWidget = (CPDFSDK_Widget*)widgetArray.GetAt(i);
2063       CPDFSDK_PageView* pPageView = pWidget->GetPageView();
2064       if (!pPageView)
2065         return FALSE;
2066
2067       PageArray.SetElement(
2068           i, CJS_Value(pRuntime, (int32_t)pPageView->GetPageIndex()));
2069     }
2070
2071     vp << PageArray;
2072   } else {
2073     vp << (int32_t)-1;
2074   }
2075
2076   return TRUE;
2077 }
2078
2079 FX_BOOL Field::password(IJS_Context* cc,
2080                         CJS_PropValue& vp,
2081                         CFX_WideString& sError) {
2082   ASSERT(m_pDocument != NULL);
2083
2084   if (vp.IsSetting()) {
2085     if (!m_bCanSet)
2086       return FALSE;
2087
2088     bool bVP;
2089     vp >> bVP;
2090
2091     if (m_bDelay) {
2092       AddDelay_Bool(FP_PASSWORD, bVP);
2093     } else {
2094       Field::SetPassword(m_pDocument, m_FieldName, m_nFormControlIndex, bVP);
2095     }
2096   } else {
2097     CFX_PtrArray FieldArray;
2098     GetFormFields(m_FieldName, FieldArray);
2099     if (FieldArray.GetSize() <= 0)
2100       return FALSE;
2101
2102     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2103     ASSERT(pFormField != NULL);
2104
2105     if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
2106       return FALSE;
2107
2108     if (pFormField->GetFieldFlags() & FIELDFLAG_PASSWORD)
2109       vp << true;
2110     else
2111       vp << false;
2112   }
2113
2114   return TRUE;
2115 }
2116
2117 void Field::SetPassword(CPDFSDK_Document* pDocument,
2118                         const CFX_WideString& swFieldName,
2119                         int nControlIndex,
2120                         bool b) {
2121   // Not supported.
2122 }
2123
2124 FX_BOOL Field::print(IJS_Context* cc,
2125                      CJS_PropValue& vp,
2126                      CFX_WideString& sError) {
2127   ASSERT(m_pDocument != NULL);
2128
2129   CPDFSDK_InterForm* pInterForm =
2130       (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
2131   ASSERT(pInterForm != NULL);
2132
2133   CFX_PtrArray FieldArray;
2134   GetFormFields(m_FieldName, FieldArray);
2135   if (FieldArray.GetSize() <= 0)
2136     return FALSE;
2137
2138   if (vp.IsSetting()) {
2139     if (!m_bCanSet)
2140       return FALSE;
2141
2142     bool bVP;
2143     vp >> bVP;
2144
2145     for (int i = 0, isz = FieldArray.GetSize(); i < isz; i++) {
2146       CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
2147       ASSERT(pFormField != NULL);
2148
2149       if (m_nFormControlIndex < 0) {
2150         FX_BOOL bSet = FALSE;
2151         for (int j = 0, jsz = pFormField->CountControls(); j < jsz; j++) {
2152           if (CPDFSDK_Widget* pWidget =
2153                   pInterForm->GetWidget(pFormField->GetControl(j))) {
2154             FX_DWORD dwFlags = pWidget->GetFlags();
2155             if (bVP)
2156               dwFlags |= ANNOTFLAG_PRINT;
2157             else
2158               dwFlags &= ~ANNOTFLAG_PRINT;
2159
2160             if (dwFlags != pWidget->GetFlags()) {
2161               pWidget->SetFlags(dwFlags);
2162               bSet = TRUE;
2163             }
2164           }
2165         }
2166
2167         if (bSet)
2168           UpdateFormField(m_pDocument, pFormField, TRUE, FALSE, TRUE);
2169       } else {
2170         if (m_nFormControlIndex >= pFormField->CountControls())
2171           return FALSE;
2172         if (CPDF_FormControl* pFormControl =
2173                 pFormField->GetControl(m_nFormControlIndex)) {
2174           if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl)) {
2175             FX_DWORD dwFlags = pWidget->GetFlags();
2176             if (bVP)
2177               dwFlags |= ANNOTFLAG_PRINT;
2178             else
2179               dwFlags &= ~ANNOTFLAG_PRINT;
2180
2181             if (dwFlags != pWidget->GetFlags()) {
2182               pWidget->SetFlags(dwFlags);
2183               UpdateFormControl(m_pDocument,
2184                                 pFormField->GetControl(m_nFormControlIndex),
2185                                 TRUE, FALSE, TRUE);
2186             }
2187           }
2188         }
2189       }
2190     }
2191   } else {
2192     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2193     ASSERT(pFormField != NULL);
2194
2195     CPDFSDK_Widget* pWidget =
2196         pInterForm->GetWidget(GetSmartFieldControl(pFormField));
2197     if (!pWidget)
2198       return FALSE;
2199
2200     if (pWidget->GetFlags() & ANNOTFLAG_PRINT)
2201       vp << true;
2202     else
2203       vp << false;
2204   }
2205
2206   return TRUE;
2207 }
2208
2209 FX_BOOL Field::radiosInUnison(IJS_Context* cc,
2210                               CJS_PropValue& vp,
2211                               CFX_WideString& sError) {
2212   ASSERT(m_pDocument != NULL);
2213
2214   CFX_PtrArray FieldArray;
2215   GetFormFields(m_FieldName, FieldArray);
2216   if (FieldArray.GetSize() <= 0)
2217     return FALSE;
2218
2219   if (vp.IsSetting()) {
2220     if (!m_bCanSet)
2221       return FALSE;
2222
2223     bool bVP;
2224     vp >> bVP;
2225
2226   } else {
2227     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2228     ASSERT(pFormField != NULL);
2229
2230     if (pFormField->GetFieldType() != FIELDTYPE_RADIOBUTTON)
2231       return FALSE;
2232
2233     if (pFormField->GetFieldFlags() & FIELDFLAG_RADIOSINUNISON)
2234       vp << true;
2235     else
2236       vp << false;
2237   }
2238
2239   return TRUE;
2240 }
2241
2242 FX_BOOL Field::readonly(IJS_Context* cc,
2243                         CJS_PropValue& vp,
2244                         CFX_WideString& sError) {
2245   ASSERT(m_pDocument != NULL);
2246
2247   CFX_PtrArray FieldArray;
2248   GetFormFields(m_FieldName, FieldArray);
2249   if (FieldArray.GetSize() <= 0)
2250     return FALSE;
2251
2252   if (vp.IsSetting()) {
2253     if (!m_bCanSet)
2254       return FALSE;
2255
2256     bool bVP;
2257     vp >> bVP;
2258
2259   } else {
2260     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2261     ASSERT(pFormField != NULL);
2262
2263     if (pFormField->GetFieldFlags() & FIELDFLAG_READONLY)
2264       vp << true;
2265     else
2266       vp << false;
2267   }
2268
2269   return TRUE;
2270 }
2271
2272 FX_BOOL Field::rect(IJS_Context* cc,
2273                     CJS_PropValue& vp,
2274                     CFX_WideString& sError) {
2275   CJS_Runtime* pRuntime = CJS_Runtime::FromContext(cc);
2276   CJS_Value Upper_Leftx(pRuntime);
2277   CJS_Value Upper_Lefty(pRuntime);
2278   CJS_Value Lower_Rightx(pRuntime);
2279   CJS_Value Lower_Righty(pRuntime);
2280
2281   if (vp.IsSetting()) {
2282     if (!m_bCanSet)
2283       return FALSE;
2284     if (!vp.IsArrayObject())
2285       return FALSE;
2286
2287     CJS_Array rcArray(pRuntime);
2288     vp >> rcArray;
2289     rcArray.GetElement(0, Upper_Leftx);
2290     rcArray.GetElement(1, Upper_Lefty);
2291     rcArray.GetElement(2, Lower_Rightx);
2292     rcArray.GetElement(3, Lower_Righty);
2293
2294     FX_FLOAT pArray[4] = {0.0f, 0.0f, 0.0f, 0.0f};
2295     pArray[0] = (FX_FLOAT)Upper_Leftx.ToInt();
2296     pArray[1] = (FX_FLOAT)Lower_Righty.ToInt();
2297     pArray[2] = (FX_FLOAT)Lower_Rightx.ToInt();
2298     pArray[3] = (FX_FLOAT)Upper_Lefty.ToInt();
2299
2300     CPDF_Rect crRect(pArray);
2301     if (m_bDelay) {
2302       AddDelay_Rect(FP_RECT, crRect);
2303     } else {
2304       Field::SetRect(m_pDocument, m_FieldName, m_nFormControlIndex, crRect);
2305     }
2306   } else {
2307     CFX_PtrArray FieldArray;
2308     GetFormFields(m_FieldName, FieldArray);
2309     if (FieldArray.GetSize() <= 0)
2310       return FALSE;
2311
2312     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2313     CPDFSDK_InterForm* pInterForm =
2314         (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
2315     CPDFSDK_Widget* pWidget =
2316         pInterForm->GetWidget(GetSmartFieldControl(pFormField));
2317     if (!pWidget)
2318       return FALSE;
2319
2320     CFX_FloatRect crRect = pWidget->GetRect();
2321     Upper_Leftx = (int32_t)crRect.left;
2322     Upper_Lefty = (int32_t)crRect.top;
2323     Lower_Rightx = (int32_t)crRect.right;
2324     Lower_Righty = (int32_t)crRect.bottom;
2325
2326     CJS_Array rcArray(pRuntime);
2327     rcArray.SetElement(0, Upper_Leftx);
2328     rcArray.SetElement(1, Upper_Lefty);
2329     rcArray.SetElement(2, Lower_Rightx);
2330     rcArray.SetElement(3, Lower_Righty);
2331     vp << rcArray;
2332   }
2333   return TRUE;
2334 }
2335
2336 void Field::SetRect(CPDFSDK_Document* pDocument,
2337                     const CFX_WideString& swFieldName,
2338                     int nControlIndex,
2339                     const CPDF_Rect& rect) {
2340   ASSERT(pDocument != NULL);
2341
2342   CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)pDocument->GetInterForm();
2343   ASSERT(pInterForm != NULL);
2344
2345   CFX_PtrArray FieldArray;
2346   GetFormFields(pDocument, swFieldName, FieldArray);
2347
2348   for (int i = 0, isz = FieldArray.GetSize(); i < isz; i++) {
2349     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
2350     ASSERT(pFormField != NULL);
2351
2352     if (nControlIndex < 0) {
2353       FX_BOOL bSet = FALSE;
2354       for (int i = 0, sz = pFormField->CountControls(); i < sz; i++) {
2355         CPDF_FormControl* pFormControl = pFormField->GetControl(i);
2356         ASSERT(pFormControl != NULL);
2357
2358         if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl)) {
2359           CPDF_Rect crRect = rect;
2360
2361           CPDF_Page* pPDFPage = pWidget->GetPDFPage();
2362           ASSERT(pPDFPage != NULL);
2363
2364           //                  CPDF_Page* pPDFPage = pPage->GetPage();
2365           //                  ASSERT(pPDFPage != NULL);
2366
2367           crRect.Intersect(pPDFPage->GetPageBBox());
2368
2369           if (!crRect.IsEmpty()) {
2370             CPDF_Rect rcOld = pWidget->GetRect();
2371             if (crRect.left != rcOld.left || crRect.right != rcOld.right ||
2372                 crRect.top != rcOld.top || crRect.bottom != rcOld.bottom) {
2373               pWidget->SetRect(crRect);
2374               bSet = TRUE;
2375             }
2376           }
2377         }
2378       }
2379
2380       if (bSet)
2381         UpdateFormField(pDocument, pFormField, TRUE, TRUE, TRUE);
2382     } else {
2383       if (nControlIndex >= pFormField->CountControls())
2384         return;
2385       if (CPDF_FormControl* pFormControl =
2386               pFormField->GetControl(nControlIndex)) {
2387         if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl)) {
2388           CPDF_Rect crRect = rect;
2389
2390           CPDF_Page* pPDFPage = pWidget->GetPDFPage();
2391           ASSERT(pPDFPage != NULL);
2392
2393           //                  CPDF_Page* pPDFPage = pPage->GetPage();
2394           //                  ASSERT(pPDFPage != NULL);
2395
2396           crRect.Intersect(pPDFPage->GetPageBBox());
2397
2398           if (!crRect.IsEmpty()) {
2399             CPDF_Rect rcOld = pWidget->GetRect();
2400             if (crRect.left != rcOld.left || crRect.right != rcOld.right ||
2401                 crRect.top != rcOld.top || crRect.bottom != rcOld.bottom) {
2402               pWidget->SetRect(crRect);
2403               UpdateFormControl(pDocument, pFormControl, TRUE, TRUE, TRUE);
2404             }
2405           }
2406         }
2407       }
2408     }
2409   }
2410 }
2411
2412 FX_BOOL Field::required(IJS_Context* cc,
2413                         CJS_PropValue& vp,
2414                         CFX_WideString& sError) {
2415   ASSERT(m_pDocument != NULL);
2416
2417   CFX_PtrArray FieldArray;
2418   GetFormFields(m_FieldName, FieldArray);
2419   if (FieldArray.GetSize() <= 0)
2420     return FALSE;
2421
2422   if (vp.IsSetting()) {
2423     if (!m_bCanSet)
2424       return FALSE;
2425
2426     bool bVP;
2427     vp >> bVP;
2428
2429   } else {
2430     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2431     ASSERT(pFormField != NULL);
2432
2433     if (pFormField->GetFieldType() == FIELDTYPE_PUSHBUTTON)
2434       return FALSE;
2435
2436     if (pFormField->GetFieldFlags() & FIELDFLAG_REQUIRED)
2437       vp << true;
2438     else
2439       vp << false;
2440   }
2441
2442   return TRUE;
2443 }
2444
2445 FX_BOOL Field::richText(IJS_Context* cc,
2446                         CJS_PropValue& vp,
2447                         CFX_WideString& sError) {
2448   ASSERT(m_pDocument != NULL);
2449
2450   if (vp.IsSetting()) {
2451     if (!m_bCanSet)
2452       return FALSE;
2453
2454     bool bVP;
2455     vp >> bVP;
2456
2457     if (m_bDelay) {
2458       AddDelay_Bool(FP_RICHTEXT, bVP);
2459     } else {
2460       Field::SetRichText(m_pDocument, m_FieldName, m_nFormControlIndex, bVP);
2461     }
2462   } else {
2463     CFX_PtrArray FieldArray;
2464     GetFormFields(m_FieldName, FieldArray);
2465     if (FieldArray.GetSize() <= 0)
2466       return FALSE;
2467
2468     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2469     ASSERT(pFormField != NULL);
2470
2471     if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
2472       return FALSE;
2473
2474     if (pFormField->GetFieldFlags() & FIELDFLAG_RICHTEXT)
2475       vp << true;
2476     else
2477       vp << false;
2478   }
2479
2480   return TRUE;
2481 }
2482
2483 void Field::SetRichText(CPDFSDK_Document* pDocument,
2484                         const CFX_WideString& swFieldName,
2485                         int nControlIndex,
2486                         bool b) {
2487   // Not supported.
2488 }
2489
2490 FX_BOOL Field::richValue(IJS_Context* cc,
2491                          CJS_PropValue& vp,
2492                          CFX_WideString& sError) {
2493   return TRUE;
2494   if (vp.IsSetting()) {
2495     if (!m_bCanSet)
2496       return FALSE;
2497     ;
2498   } else {
2499     ;
2500   }
2501   return TRUE;
2502 }
2503
2504 void Field::SetRichValue(CPDFSDK_Document* pDocument,
2505                          const CFX_WideString& swFieldName,
2506                          int nControlIndex) {
2507   // Not supported.
2508 }
2509
2510 FX_BOOL Field::rotation(IJS_Context* cc,
2511                         CJS_PropValue& vp,
2512                         CFX_WideString& sError) {
2513   ASSERT(m_pDocument != NULL);
2514
2515   if (vp.IsSetting()) {
2516     if (!m_bCanSet)
2517       return FALSE;
2518
2519     int nVP;
2520     vp >> nVP;
2521
2522     if (m_bDelay) {
2523       AddDelay_Int(FP_ROTATION, nVP);
2524     } else {
2525       Field::SetRotation(m_pDocument, m_FieldName, m_nFormControlIndex, nVP);
2526     }
2527   } else {
2528     CFX_PtrArray FieldArray;
2529     GetFormFields(m_FieldName, FieldArray);
2530     if (FieldArray.GetSize() <= 0)
2531       return FALSE;
2532
2533     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2534     ASSERT(pFormField != NULL);
2535
2536     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
2537     if (!pFormControl)
2538       return FALSE;
2539
2540     vp << (int32_t)pFormControl->GetRotation();
2541   }
2542
2543   return TRUE;
2544 }
2545
2546 void Field::SetRotation(CPDFSDK_Document* pDocument,
2547                         const CFX_WideString& swFieldName,
2548                         int nControlIndex,
2549                         int number) {
2550   // Not supported.
2551 }
2552
2553 FX_BOOL Field::strokeColor(IJS_Context* cc,
2554                            CJS_PropValue& vp,
2555                            CFX_WideString& sError) {
2556   CJS_Runtime* pRuntime = CJS_Runtime::FromContext(cc);
2557   CJS_Array crArray(pRuntime);
2558
2559   if (vp.IsSetting()) {
2560     if (!m_bCanSet)
2561       return FALSE;
2562
2563     if (!vp.IsArrayObject())
2564       return FALSE;
2565
2566     vp >> crArray;
2567
2568     CPWL_Color color;
2569     color::ConvertArrayToPWLColor(crArray, color);
2570
2571     if (m_bDelay) {
2572       AddDelay_Color(FP_STROKECOLOR, color);
2573     } else {
2574       Field::SetStrokeColor(m_pDocument, m_FieldName, m_nFormControlIndex,
2575                             color);
2576     }
2577   } else {
2578     CFX_PtrArray FieldArray;
2579     GetFormFields(m_FieldName, FieldArray);
2580     if (FieldArray.GetSize() <= 0)
2581       return FALSE;
2582
2583     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2584     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
2585     if (!pFormControl)
2586       return FALSE;
2587
2588     int iColorType;
2589     pFormControl->GetBorderColor(iColorType);
2590
2591     CPWL_Color color;
2592     if (iColorType == COLORTYPE_TRANSPARENT) {
2593       color = CPWL_Color(COLORTYPE_TRANSPARENT);
2594     } else if (iColorType == COLORTYPE_GRAY) {
2595       color =
2596           CPWL_Color(COLORTYPE_GRAY, pFormControl->GetOriginalBorderColor(0));
2597     } else if (iColorType == COLORTYPE_RGB) {
2598       color = CPWL_Color(COLORTYPE_RGB, pFormControl->GetOriginalBorderColor(0),
2599                          pFormControl->GetOriginalBorderColor(1),
2600                          pFormControl->GetOriginalBorderColor(2));
2601     } else if (iColorType == COLORTYPE_CMYK) {
2602       color =
2603           CPWL_Color(COLORTYPE_CMYK, pFormControl->GetOriginalBorderColor(0),
2604                      pFormControl->GetOriginalBorderColor(1),
2605                      pFormControl->GetOriginalBorderColor(2),
2606                      pFormControl->GetOriginalBorderColor(3));
2607     } else
2608       return FALSE;
2609
2610     color::ConvertPWLColorToArray(color, crArray);
2611     vp << crArray;
2612   }
2613   return TRUE;
2614 }
2615
2616 void Field::SetStrokeColor(CPDFSDK_Document* pDocument,
2617                            const CFX_WideString& swFieldName,
2618                            int nControlIndex,
2619                            const CPWL_Color& color) {
2620   // Not supported.
2621 }
2622
2623 FX_BOOL Field::style(IJS_Context* cc,
2624                      CJS_PropValue& vp,
2625                      CFX_WideString& sError) {
2626   ASSERT(m_pDocument != NULL);
2627
2628   if (vp.IsSetting()) {
2629     if (!m_bCanSet)
2630       return FALSE;
2631
2632     CFX_ByteString csBCaption;
2633     vp >> csBCaption;
2634
2635     if (m_bDelay) {
2636       AddDelay_String(FP_STYLE, csBCaption);
2637     } else {
2638       Field::SetStyle(m_pDocument, m_FieldName, m_nFormControlIndex,
2639                       csBCaption);
2640     }
2641   } else {
2642     CFX_PtrArray FieldArray;
2643     GetFormFields(m_FieldName, FieldArray);
2644     if (FieldArray.GetSize() <= 0)
2645       return FALSE;
2646
2647     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2648     ASSERT(pFormField != NULL);
2649
2650     if (pFormField->GetFieldType() != FIELDTYPE_RADIOBUTTON &&
2651         pFormField->GetFieldType() != FIELDTYPE_CHECKBOX)
2652       return FALSE;
2653
2654     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
2655     if (!pFormControl)
2656       return FALSE;
2657
2658     CFX_WideString csWCaption = pFormControl->GetNormalCaption();
2659     CFX_ByteString csBCaption;
2660
2661     switch (csWCaption[0]) {
2662       case L'l':
2663         csBCaption = "circle";
2664         break;
2665       case L'8':
2666         csBCaption = "cross";
2667         break;
2668       case L'u':
2669         csBCaption = "diamond";
2670         break;
2671       case L'n':
2672         csBCaption = "square";
2673         break;
2674       case L'H':
2675         csBCaption = "star";
2676         break;
2677       default:  // L'4'
2678         csBCaption = "check";
2679         break;
2680     }
2681     vp << csBCaption;
2682   }
2683
2684   return TRUE;
2685 }
2686
2687 void Field::SetStyle(CPDFSDK_Document* pDocument,
2688                      const CFX_WideString& swFieldName,
2689                      int nControlIndex,
2690                      const CFX_ByteString& string) {
2691   // Not supported.
2692 }
2693
2694 FX_BOOL Field::submitName(IJS_Context* cc,
2695                           CJS_PropValue& vp,
2696                           CFX_WideString& sError) {
2697   return TRUE;
2698 }
2699
2700 FX_BOOL Field::textColor(IJS_Context* cc,
2701                          CJS_PropValue& vp,
2702                          CFX_WideString& sError) {
2703   CJS_Runtime* pRuntime = CJS_Runtime::FromContext(cc);
2704   CJS_Array crArray(pRuntime);
2705
2706   if (vp.IsSetting()) {
2707     if (!m_bCanSet)
2708       return FALSE;
2709
2710     if (!vp.IsArrayObject())
2711       return FALSE;
2712
2713     vp >> crArray;
2714
2715     CPWL_Color color;
2716     color::ConvertArrayToPWLColor(crArray, color);
2717
2718     if (m_bDelay) {
2719       AddDelay_Color(FP_TEXTCOLOR, color);
2720     } else {
2721       Field::SetTextColor(m_pDocument, m_FieldName, m_nFormControlIndex, color);
2722     }
2723   } else {
2724     CFX_PtrArray FieldArray;
2725     GetFormFields(m_FieldName, FieldArray);
2726     if (FieldArray.GetSize() <= 0)
2727       return FALSE;
2728
2729     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2730     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
2731     if (!pFormControl)
2732       return FALSE;
2733
2734     int iColorType;
2735     FX_ARGB color;
2736     CPDF_DefaultAppearance FieldAppearance =
2737         pFormControl->GetDefaultAppearance();
2738     FieldAppearance.GetColor(color, iColorType);
2739     int32_t a, r, g, b;
2740     ArgbDecode(color, a, r, g, b);
2741
2742     CPWL_Color crRet =
2743         CPWL_Color(COLORTYPE_RGB, r / 255.0f, g / 255.0f, b / 255.0f);
2744
2745     if (iColorType == COLORTYPE_TRANSPARENT)
2746       crRet = CPWL_Color(COLORTYPE_TRANSPARENT);
2747
2748     color::ConvertPWLColorToArray(crRet, crArray);
2749     vp << crArray;
2750   }
2751   return TRUE;
2752 }
2753
2754 void Field::SetTextColor(CPDFSDK_Document* pDocument,
2755                          const CFX_WideString& swFieldName,
2756                          int nControlIndex,
2757                          const CPWL_Color& color) {
2758   // Not supported.
2759 }
2760
2761 FX_BOOL Field::textFont(IJS_Context* cc,
2762                         CJS_PropValue& vp,
2763                         CFX_WideString& sError) {
2764   ASSERT(m_pDocument != NULL);
2765
2766   if (vp.IsSetting()) {
2767     if (!m_bCanSet)
2768       return FALSE;
2769
2770     CFX_ByteString csFontName;
2771     vp >> csFontName;
2772     if (csFontName.IsEmpty())
2773       return FALSE;
2774
2775     if (m_bDelay) {
2776       AddDelay_String(FP_TEXTFONT, csFontName);
2777     } else {
2778       Field::SetTextFont(m_pDocument, m_FieldName, m_nFormControlIndex,
2779                          csFontName);
2780     }
2781   } else {
2782     CFX_PtrArray FieldArray;
2783     GetFormFields(m_FieldName, FieldArray);
2784     if (FieldArray.GetSize() <= 0)
2785       return FALSE;
2786
2787     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2788     ASSERT(pFormField != NULL);
2789
2790     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
2791     if (!pFormControl)
2792       return FALSE;
2793
2794     int nFieldType = pFormField->GetFieldType();
2795
2796     if (nFieldType == FIELDTYPE_PUSHBUTTON ||
2797         nFieldType == FIELDTYPE_COMBOBOX || nFieldType == FIELDTYPE_LISTBOX ||
2798         nFieldType == FIELDTYPE_TEXTFIELD) {
2799       CPDF_Font* pFont = pFormControl->GetDefaultControlFont();
2800       if (!pFont)
2801         return FALSE;
2802
2803       vp << pFont->GetBaseFont();
2804     } else
2805       return FALSE;
2806   }
2807
2808   return TRUE;
2809 }
2810
2811 void Field::SetTextFont(CPDFSDK_Document* pDocument,
2812                         const CFX_WideString& swFieldName,
2813                         int nControlIndex,
2814                         const CFX_ByteString& string) {
2815   // Not supported.
2816 }
2817
2818 FX_BOOL Field::textSize(IJS_Context* cc,
2819                         CJS_PropValue& vp,
2820                         CFX_WideString& sError) {
2821   ASSERT(m_pDocument != NULL);
2822
2823   if (vp.IsSetting()) {
2824     if (!m_bCanSet)
2825       return FALSE;
2826
2827     int nVP;
2828     vp >> nVP;
2829
2830     if (m_bDelay) {
2831       AddDelay_Int(FP_TEXTSIZE, nVP);
2832     } else {
2833       Field::SetTextSize(m_pDocument, m_FieldName, m_nFormControlIndex, nVP);
2834     }
2835   } else {
2836     CFX_PtrArray FieldArray;
2837     GetFormFields(m_FieldName, FieldArray);
2838     if (FieldArray.GetSize() <= 0)
2839       return FALSE;
2840
2841     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2842     ASSERT(pFormField != NULL);
2843
2844     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
2845     if (!pFormControl)
2846       return FALSE;
2847
2848     CPDF_DefaultAppearance FieldAppearance =
2849         pFormControl->GetDefaultAppearance();
2850
2851     CFX_ByteString csFontNameTag;
2852     FX_FLOAT fFontSize;
2853     FieldAppearance.GetFont(csFontNameTag, fFontSize);
2854
2855     vp << (int)fFontSize;
2856   }
2857
2858   return TRUE;
2859 }
2860
2861 void Field::SetTextSize(CPDFSDK_Document* pDocument,
2862                         const CFX_WideString& swFieldName,
2863                         int nControlIndex,
2864                         int number) {
2865   // Not supported.
2866 }
2867
2868 FX_BOOL Field::type(IJS_Context* cc,
2869                     CJS_PropValue& vp,
2870                     CFX_WideString& sError) {
2871   ASSERT(m_pDocument != NULL);
2872
2873   if (!vp.IsGetting())
2874     return FALSE;
2875
2876   CFX_PtrArray FieldArray;
2877   GetFormFields(m_FieldName, FieldArray);
2878   if (FieldArray.GetSize() <= 0)
2879     return FALSE;
2880
2881   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2882   ASSERT(pFormField != NULL);
2883
2884   switch (pFormField->GetFieldType()) {
2885     case FIELDTYPE_UNKNOWN:
2886       vp << L"unknown";
2887       break;
2888     case FIELDTYPE_PUSHBUTTON:
2889       vp << L"button";
2890       break;
2891     case FIELDTYPE_CHECKBOX:
2892       vp << L"checkbox";
2893       break;
2894     case FIELDTYPE_RADIOBUTTON:
2895       vp << L"radiobutton";
2896       break;
2897     case FIELDTYPE_COMBOBOX:
2898       vp << L"combobox";
2899       break;
2900     case FIELDTYPE_LISTBOX:
2901       vp << L"listbox";
2902       break;
2903     case FIELDTYPE_TEXTFIELD:
2904       vp << L"text";
2905       break;
2906     case FIELDTYPE_SIGNATURE:
2907       vp << L"signature";
2908       break;
2909     default:
2910       vp << L"unknown";
2911       break;
2912   }
2913
2914   return TRUE;
2915 }
2916
2917 FX_BOOL Field::userName(IJS_Context* cc,
2918                         CJS_PropValue& vp,
2919                         CFX_WideString& sError) {
2920   ASSERT(m_pDocument != NULL);
2921
2922   if (vp.IsSetting()) {
2923     if (!m_bCanSet)
2924       return FALSE;
2925
2926     CFX_WideString swName;
2927     vp >> swName;
2928
2929     if (m_bDelay) {
2930       AddDelay_WideString(FP_USERNAME, swName);
2931     } else {
2932       Field::SetUserName(m_pDocument, m_FieldName, m_nFormControlIndex, swName);
2933     }
2934   } else {
2935     CFX_PtrArray FieldArray;
2936     GetFormFields(m_FieldName, FieldArray);
2937     if (FieldArray.GetSize() <= 0)
2938       return FALSE;
2939
2940     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2941     ASSERT(pFormField != NULL);
2942
2943     vp << (CFX_WideString)pFormField->GetAlternateName();
2944   }
2945
2946   return TRUE;
2947 }
2948
2949 void Field::SetUserName(CPDFSDK_Document* pDocument,
2950                         const CFX_WideString& swFieldName,
2951                         int nControlIndex,
2952                         const CFX_WideString& string) {
2953   // Not supported.
2954 }
2955
2956 FX_BOOL Field::value(IJS_Context* cc,
2957                      CJS_PropValue& vp,
2958                      CFX_WideString& sError) {
2959   CJS_Runtime* pRuntime = CJS_Runtime::FromContext(cc);
2960
2961   if (vp.IsSetting()) {
2962     if (!m_bCanSet)
2963       return FALSE;
2964
2965     CJS_WideStringArray strArray;
2966
2967     if (vp.IsArrayObject()) {
2968       CJS_Array ValueArray(pRuntime);
2969       vp.ConvertToArray(ValueArray);
2970       for (int i = 0, sz = ValueArray.GetLength(); i < sz; i++) {
2971         CJS_Value ElementValue(pRuntime);
2972         ValueArray.GetElement(i, ElementValue);
2973         strArray.Add(ElementValue.ToCFXWideString());
2974       }
2975     } else {
2976       CFX_WideString swValue;
2977       vp >> swValue;
2978       strArray.Add(swValue);
2979     }
2980
2981     if (m_bDelay) {
2982       AddDelay_WideStringArray(FP_VALUE, strArray);
2983     } else {
2984       Field::SetValue(m_pDocument, m_FieldName, m_nFormControlIndex, strArray);
2985     }
2986   } else {
2987     CFX_PtrArray FieldArray;
2988     GetFormFields(m_FieldName, FieldArray);
2989     if (FieldArray.GetSize() <= 0)
2990       return FALSE;
2991
2992     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2993     switch (pFormField->GetFieldType()) {
2994       case FIELDTYPE_PUSHBUTTON:
2995         return FALSE;
2996       case FIELDTYPE_COMBOBOX:
2997       case FIELDTYPE_TEXTFIELD: {
2998         CFX_WideString swValue = pFormField->GetValue();
2999
3000         double dRet;
3001         FX_BOOL bDot;
3002         if (CJS_PublicMethods::ConvertStringToNumber(swValue.c_str(), dRet,
3003                                                      bDot)) {
3004           if (bDot)
3005             vp << dRet;
3006           else
3007             vp << dRet;
3008         } else
3009           vp << swValue;
3010       } break;
3011       case FIELDTYPE_LISTBOX: {
3012         if (pFormField->CountSelectedItems() > 1) {
3013           CJS_Array ValueArray(pRuntime);
3014           CJS_Value ElementValue(pRuntime);
3015           int iIndex;
3016           for (int i = 0, sz = pFormField->CountSelectedItems(); i < sz; i++) {
3017             iIndex = pFormField->GetSelectedIndex(i);
3018             ElementValue = pFormField->GetOptionValue(iIndex).c_str();
3019             if (FXSYS_wcslen(ElementValue.ToCFXWideString().c_str()) == 0)
3020               ElementValue = pFormField->GetOptionLabel(iIndex).c_str();
3021             ValueArray.SetElement(i, ElementValue);
3022           }
3023           vp << ValueArray;
3024         } else {
3025           CFX_WideString swValue = pFormField->GetValue();
3026
3027           double dRet;
3028           FX_BOOL bDot;
3029           if (CJS_PublicMethods::ConvertStringToNumber(swValue.c_str(), dRet,
3030                                                        bDot)) {
3031             if (bDot)
3032               vp << dRet;
3033             else
3034               vp << dRet;
3035           } else
3036             vp << swValue;
3037         }
3038       } break;
3039       case FIELDTYPE_CHECKBOX:
3040       case FIELDTYPE_RADIOBUTTON: {
3041         FX_BOOL bFind = FALSE;
3042         for (int i = 0, sz = pFormField->CountControls(); i < sz; i++) {
3043           if (pFormField->GetControl(i)->IsChecked()) {
3044             CFX_WideString swValue =
3045                 pFormField->GetControl(i)->GetExportValue();
3046             double dRet;
3047             FX_BOOL bDot;
3048             if (CJS_PublicMethods::ConvertStringToNumber(swValue.c_str(), dRet,
3049                                                          bDot)) {
3050               if (bDot)
3051                 vp << dRet;
3052               else
3053                 vp << dRet;
3054             } else
3055               vp << swValue;
3056
3057             bFind = TRUE;
3058             break;
3059           } else
3060             continue;
3061         }
3062         if (!bFind)
3063           vp << L"Off";
3064       } break;
3065       default:
3066         vp << pFormField->GetValue();
3067         break;
3068     }
3069   }
3070
3071   return TRUE;
3072 }
3073
3074 void Field::SetValue(CPDFSDK_Document* pDocument,
3075                      const CFX_WideString& swFieldName,
3076                      int nControlIndex,
3077                      const CJS_WideStringArray& strArray) {
3078   ASSERT(pDocument != NULL);
3079
3080   if (strArray.GetSize() < 1)
3081     return;
3082
3083   CFX_PtrArray FieldArray;
3084   GetFormFields(pDocument, swFieldName, FieldArray);
3085
3086   for (int i = 0, isz = FieldArray.GetSize(); i < isz; i++) {
3087     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
3088     ASSERT(pFormField != NULL);
3089
3090     if (pFormField->GetFullName().Compare(swFieldName) != 0)
3091       continue;
3092
3093     switch (pFormField->GetFieldType()) {
3094       case FIELDTYPE_TEXTFIELD:
3095       case FIELDTYPE_COMBOBOX:
3096         if (pFormField->GetValue() != strArray.GetAt(0)) {
3097           CFX_WideString WideString = strArray.GetAt(0);
3098           pFormField->SetValue(strArray.GetAt(0), TRUE);
3099           UpdateFormField(pDocument, pFormField, TRUE, FALSE, TRUE);
3100         }
3101         break;
3102       case FIELDTYPE_CHECKBOX:  // mantis: 0004493
3103       case FIELDTYPE_RADIOBUTTON: {
3104         if (pFormField->GetValue() != strArray.GetAt(0)) {
3105           pFormField->SetValue(strArray.GetAt(0), TRUE);
3106           UpdateFormField(pDocument, pFormField, TRUE, FALSE, TRUE);
3107         }
3108       } break;
3109       case FIELDTYPE_LISTBOX: {
3110         FX_BOOL bModified = FALSE;
3111
3112         for (int i = 0, sz = strArray.GetSize(); i < sz; i++) {
3113           int iIndex = pFormField->FindOption(strArray.GetAt(i));
3114
3115           if (!pFormField->IsItemSelected(iIndex)) {
3116             bModified = TRUE;
3117             break;
3118           }
3119         }
3120
3121         if (bModified) {
3122           pFormField->ClearSelection(TRUE);
3123           for (int i = 0, sz = strArray.GetSize(); i < sz; i++) {
3124             int iIndex = pFormField->FindOption(strArray.GetAt(i));
3125             pFormField->SetItemSelection(iIndex, TRUE, TRUE);
3126           }
3127
3128           UpdateFormField(pDocument, pFormField, TRUE, FALSE, TRUE);
3129         }
3130       } break;
3131       default:
3132         break;
3133     }
3134   }
3135 }
3136
3137 FX_BOOL Field::valueAsString(IJS_Context* cc,
3138                              CJS_PropValue& vp,
3139                              CFX_WideString& sError) {
3140   ASSERT(m_pDocument != NULL);
3141
3142   if (!vp.IsGetting())
3143     return FALSE;
3144
3145   CFX_PtrArray FieldArray;
3146   GetFormFields(m_FieldName, FieldArray);
3147   if (FieldArray.GetSize() <= 0)
3148     return FALSE;
3149
3150   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3151   ASSERT(pFormField != NULL);
3152
3153   if (pFormField->GetFieldType() == FIELDTYPE_PUSHBUTTON)
3154     return FALSE;
3155
3156   if (pFormField->GetFieldType() == FIELDTYPE_CHECKBOX) {
3157     if (!pFormField->CountControls())
3158       return FALSE;
3159
3160     if (pFormField->GetControl(0)->IsChecked())
3161       vp << L"Yes";
3162     else
3163       vp << L"Off";
3164   } else if (pFormField->GetFieldType() == FIELDTYPE_RADIOBUTTON &&
3165              !(pFormField->GetFieldFlags() & FIELDFLAG_RADIOSINUNISON)) {
3166     for (int i = 0, sz = pFormField->CountControls(); i < sz; i++) {
3167       if (pFormField->GetControl(i)->IsChecked()) {
3168         vp << pFormField->GetControl(i)->GetExportValue().c_str();
3169         break;
3170       } else
3171         vp << L"Off";
3172     }
3173   } else if (pFormField->GetFieldType() == FIELDTYPE_LISTBOX &&
3174              (pFormField->CountSelectedItems() > 1)) {
3175     vp << L"";
3176   } else
3177     vp << pFormField->GetValue().c_str();
3178
3179   return TRUE;
3180 }
3181
3182 /* --------------------------------- methods ---------------------------------
3183  */
3184
3185 FX_BOOL Field::browseForFileToSubmit(IJS_Context* cc,
3186                                      const CJS_Parameters& params,
3187                                      CJS_Value& vRet,
3188                                      CFX_WideString& sError) {
3189   ASSERT(m_pDocument != NULL);
3190
3191   CFX_PtrArray FieldArray;
3192   GetFormFields(m_FieldName, FieldArray);
3193   if (FieldArray.GetSize() <= 0)
3194     return FALSE;
3195
3196   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3197   ASSERT(pFormField != NULL);
3198
3199   CPDFDoc_Environment* pApp = m_pDocument->GetEnv();
3200   ASSERT(pApp != NULL);
3201
3202   if ((pFormField->GetFieldFlags() & FIELDFLAG_FILESELECT) &&
3203       (pFormField->GetFieldType() == FIELDTYPE_TEXTFIELD)) {
3204     CFX_WideString wsFileName = pApp->JS_fieldBrowse();
3205     if (!wsFileName.IsEmpty()) {
3206       pFormField->SetValue(wsFileName);
3207       UpdateFormField(m_pDocument, pFormField, TRUE, TRUE, TRUE);
3208     }
3209   } else
3210     return FALSE;
3211
3212   return TRUE;
3213 }
3214
3215 FX_BOOL Field::buttonGetCaption(IJS_Context* cc,
3216                                 const CJS_Parameters& params,
3217                                 CJS_Value& vRet,
3218                                 CFX_WideString& sError) {
3219   ASSERT(m_pDocument != NULL);
3220
3221   int nface = 0;
3222   int iSize = params.size();
3223   if (iSize >= 1)
3224     nface = params[0].ToInt();
3225
3226   CFX_PtrArray FieldArray;
3227   GetFormFields(m_FieldName, FieldArray);
3228   if (FieldArray.GetSize() <= 0)
3229     return FALSE;
3230
3231   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3232   ASSERT(pFormField != NULL);
3233
3234   if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
3235     return FALSE;
3236
3237   CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
3238   if (!pFormControl)
3239     return FALSE;
3240
3241   if (nface == 0)
3242     vRet = pFormControl->GetNormalCaption().c_str();
3243   else if (nface == 1)
3244     vRet = pFormControl->GetDownCaption().c_str();
3245   else if (nface == 2)
3246     vRet = pFormControl->GetRolloverCaption().c_str();
3247   else
3248     return FALSE;
3249
3250   return TRUE;
3251 }
3252
3253 //#pragma warning(disable: 4800)
3254
3255 FX_BOOL Field::buttonGetIcon(IJS_Context* cc,
3256                              const CJS_Parameters& params,
3257                              CJS_Value& vRet,
3258                              CFX_WideString& sError) {
3259   ASSERT(m_pDocument != NULL);
3260
3261   int nface = 0;
3262   int iSize = params.size();
3263   if (iSize >= 1)
3264     nface = params[0].ToInt();
3265
3266   CFX_PtrArray FieldArray;
3267   GetFormFields(m_FieldName, FieldArray);
3268   if (FieldArray.GetSize() <= 0)
3269     return FALSE;
3270
3271   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3272   if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
3273     return FALSE;
3274
3275   CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
3276   if (!pFormControl)
3277     return FALSE;
3278
3279   CJS_Context* pContext = (CJS_Context*)cc;
3280   CJS_Runtime* pRuntime = pContext->GetJSRuntime();
3281   v8::Local<v8::Object> pObj = FXJS_NewFxDynamicObj(
3282       pRuntime->GetIsolate(), pContext, CJS_Icon::g_nObjDefnID);
3283   ASSERT(pObj.IsEmpty() == FALSE);
3284
3285   CJS_Icon* pJS_Icon = (CJS_Icon*)FXJS_GetPrivate(pRuntime->GetIsolate(), pObj);
3286   Icon* pIcon = (Icon*)pJS_Icon->GetEmbedObject();
3287
3288   CPDF_Stream* pIconStream = NULL;
3289   if (nface == 0)
3290     pIconStream = pFormControl->GetNormalIcon();
3291   else if (nface == 1)
3292     pIconStream = pFormControl->GetDownIcon();
3293   else if (nface == 2)
3294     pIconStream = pFormControl->GetRolloverIcon();
3295   else
3296     return FALSE;
3297
3298   pIcon->SetStream(pIconStream);
3299   vRet = pJS_Icon;
3300
3301   return TRUE;
3302 }
3303
3304 FX_BOOL Field::buttonImportIcon(IJS_Context* cc,
3305                                 const CJS_Parameters& params,
3306                                 CJS_Value& vRet,
3307                                 CFX_WideString& sError) {
3308 #if 0
3309     ASSERT(m_pDocument != NULL);
3310
3311     CFX_PtrArray FieldArray;
3312     GetFormFields(m_FieldName,FieldArray);
3313     if (FieldArray.GetSize() <= 0) return FALSE;
3314
3315     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3316     if (!pFormField)return FALSE;
3317
3318     CPDFDoc_Environment* pEnv = m_pDocument->GetEnv();
3319     ASSERT(pEnv);
3320
3321     CFX_WideString sIconFileName = pEnv->JS_fieldBrowse();
3322     if (sIconFileName.IsEmpty())
3323     {
3324         vRet = 1;
3325         return TRUE;
3326     }
3327
3328     CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
3329     ASSERT(pInterForm != NULL);
3330
3331     CPDF_Stream* pStream = pInterForm->LoadImageFromFile(sIconFileName);
3332     if (!pStream)
3333     {
3334         vRet = -1;
3335         return TRUE;
3336     }
3337
3338     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
3339     if (!pFormControl)return FALSE;
3340
3341     pFormControl->SetNormalIcon(pStream);
3342     UpdateFormControl(m_pDocument, pFormControl, TRUE, TRUE, TRUE);
3343
3344     vRet = 0;
3345 #endif  // 0
3346   return TRUE;
3347 }
3348
3349 FX_BOOL Field::buttonSetCaption(IJS_Context* cc,
3350                                 const CJS_Parameters& params,
3351                                 CJS_Value& vRet,
3352                                 CFX_WideString& sError) {
3353   return FALSE;
3354 }
3355
3356 FX_BOOL Field::buttonSetIcon(IJS_Context* cc,
3357                              const CJS_Parameters& params,
3358                              CJS_Value& vRet,
3359                              CFX_WideString& sError) {
3360   return FALSE;
3361 }
3362
3363 FX_BOOL Field::checkThisBox(IJS_Context* cc,
3364                             const CJS_Parameters& params,
3365                             CJS_Value& vRet,
3366                             CFX_WideString& sError) {
3367   ASSERT(m_pDocument != NULL);
3368
3369   if (!m_bCanSet)
3370     return FALSE;
3371
3372   int iSize = params.size();
3373   if (iSize < 1)
3374     return FALSE;
3375
3376   int nWidget = params[0].ToInt();
3377
3378   FX_BOOL bCheckit = TRUE;
3379   if (iSize >= 2)
3380     bCheckit = params[1].ToBool();
3381
3382   CFX_PtrArray FieldArray;
3383   GetFormFields(m_FieldName, FieldArray);
3384   if (FieldArray.GetSize() <= 0)
3385     return FALSE;
3386
3387   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3388   ASSERT(pFormField != NULL);
3389
3390   if (pFormField->GetFieldType() != FIELDTYPE_CHECKBOX &&
3391       pFormField->GetFieldType() != FIELDTYPE_RADIOBUTTON)
3392     return FALSE;
3393   if (nWidget < 0 || nWidget >= pFormField->CountControls())
3394     return FALSE;
3395   if (pFormField->GetFieldType() == FIELDTYPE_RADIOBUTTON)
3396     pFormField->CheckControl(nWidget, bCheckit, TRUE);
3397   else
3398     pFormField->CheckControl(nWidget, bCheckit, TRUE);
3399
3400   UpdateFormField(m_pDocument, pFormField, TRUE, TRUE, TRUE);
3401   return TRUE;
3402 }
3403
3404 FX_BOOL Field::clearItems(IJS_Context* cc,
3405                           const CJS_Parameters& params,
3406                           CJS_Value& vRet,
3407                           CFX_WideString& sError) {
3408   return TRUE;
3409 }
3410
3411 FX_BOOL Field::defaultIsChecked(IJS_Context* cc,
3412                                 const CJS_Parameters& params,
3413                                 CJS_Value& vRet,
3414                                 CFX_WideString& sError) {
3415   ASSERT(m_pDocument != NULL);
3416
3417   if (!m_bCanSet)
3418     return FALSE;
3419
3420   int iSize = params.size();
3421   if (iSize < 1)
3422     return FALSE;
3423
3424   int nWidget = params[0].ToInt();
3425
3426   CFX_PtrArray FieldArray;
3427   GetFormFields(m_FieldName, FieldArray);
3428   if (FieldArray.GetSize() <= 0)
3429     return FALSE;
3430
3431   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3432   ASSERT(pFormField != NULL);
3433
3434   if (nWidget < 0 || nWidget >= pFormField->CountControls()) {
3435     vRet = FALSE;
3436     return FALSE;
3437   }
3438   if ((pFormField->GetFieldType() == FIELDTYPE_CHECKBOX) ||
3439       (pFormField->GetFieldType() == FIELDTYPE_RADIOBUTTON)) {
3440     vRet = TRUE;
3441   } else
3442     vRet = FALSE;
3443
3444   return TRUE;
3445 }
3446
3447 FX_BOOL Field::deleteItemAt(IJS_Context* cc,
3448                             const CJS_Parameters& params,
3449                             CJS_Value& vRet,
3450                             CFX_WideString& sError) {
3451   return TRUE;
3452 }
3453
3454 int JS_COMPARESTRING(CFX_WideString* ps1, CFX_WideString* ps2) {
3455   ASSERT(ps1 != NULL);
3456   ASSERT(ps2 != NULL);
3457
3458   return ps1->Compare(*ps2);
3459 }
3460
3461 FX_BOOL Field::getArray(IJS_Context* cc,
3462                         const CJS_Parameters& params,
3463                         CJS_Value& vRet,
3464                         CFX_WideString& sError) {
3465   ASSERT(m_pDocument != NULL);
3466
3467   CFX_PtrArray FieldArray;
3468   GetFormFields(m_FieldName, FieldArray);
3469   if (FieldArray.GetSize() <= 0)
3470     return FALSE;
3471
3472   CGW_ArrayTemplate<CFX_WideString*> swSort;
3473
3474   for (int i = 0, sz = FieldArray.GetSize(); i < sz; i++) {
3475     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
3476     ASSERT(pFormField != NULL);
3477
3478     swSort.Add(new CFX_WideString(pFormField->GetFullName()));
3479   }
3480   swSort.Sort(JS_COMPARESTRING);
3481
3482   CJS_Context* pContext = (CJS_Context*)cc;
3483   ASSERT(pContext != NULL);
3484   CJS_Runtime* pRuntime = pContext->GetJSRuntime();
3485   ASSERT(pRuntime != NULL);
3486
3487   CJS_Array FormFieldArray(pRuntime);
3488   for (int j = 0, jsz = swSort.GetSize(); j < jsz; j++) {
3489     nonstd::unique_ptr<CFX_WideString> pStr(swSort.GetAt(j));
3490     v8::Local<v8::Object> pObj = FXJS_NewFxDynamicObj(
3491         pRuntime->GetIsolate(), pContext, CJS_Field::g_nObjDefnID);
3492     ASSERT(!pObj.IsEmpty());
3493
3494     CJS_Field* pJSField =
3495         (CJS_Field*)FXJS_GetPrivate(pRuntime->GetIsolate(), pObj);
3496     Field* pField = (Field*)pJSField->GetEmbedObject();
3497     pField->AttachField(m_pJSDoc, *pStr);
3498
3499     CJS_Value FormFieldValue(pRuntime);
3500     FormFieldValue = pJSField;
3501     FormFieldArray.SetElement(j, FormFieldValue);
3502   }
3503
3504   vRet = FormFieldArray;
3505   swSort.RemoveAll();
3506   return TRUE;
3507 }
3508
3509 FX_BOOL Field::getItemAt(IJS_Context* cc,
3510                          const CJS_Parameters& params,
3511                          CJS_Value& vRet,
3512                          CFX_WideString& sError) {
3513   ASSERT(m_pDocument != NULL);
3514   int iSize = params.size();
3515
3516   int nIdx = -1;
3517   if (iSize >= 1)
3518     nIdx = params[0].ToInt();
3519
3520   FX_BOOL bExport = TRUE;
3521   if (iSize >= 2)
3522     bExport = params[1].ToBool();
3523
3524   CFX_PtrArray FieldArray;
3525   GetFormFields(m_FieldName, FieldArray);
3526   if (FieldArray.GetSize() <= 0)
3527     return FALSE;
3528
3529   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3530   ASSERT(pFormField != NULL);
3531
3532   if ((pFormField->GetFieldType() == FIELDTYPE_LISTBOX) ||
3533       (pFormField->GetFieldType() == FIELDTYPE_COMBOBOX)) {
3534     if (nIdx == -1 || nIdx > pFormField->CountOptions())
3535       nIdx = pFormField->CountOptions() - 1;
3536     if (bExport) {
3537       CFX_WideString strval = pFormField->GetOptionValue(nIdx);
3538       if (strval.IsEmpty())
3539         vRet = pFormField->GetOptionLabel(nIdx).c_str();
3540       else
3541         vRet = strval.c_str();
3542     } else
3543       vRet = pFormField->GetOptionLabel(nIdx).c_str();
3544   } else
3545     return FALSE;
3546
3547   return TRUE;
3548 }
3549
3550 FX_BOOL Field::getLock(IJS_Context* cc,
3551                        const CJS_Parameters& params,
3552                        CJS_Value& vRet,
3553                        CFX_WideString& sError) {
3554   return FALSE;
3555 }
3556
3557 FX_BOOL Field::insertItemAt(IJS_Context* cc,
3558                             const CJS_Parameters& params,
3559                             CJS_Value& vRet,
3560                             CFX_WideString& sError) {
3561   return TRUE;
3562 }
3563
3564 FX_BOOL Field::isBoxChecked(IJS_Context* cc,
3565                             const CJS_Parameters& params,
3566                             CJS_Value& vRet,
3567                             CFX_WideString& sError) {
3568   ASSERT(m_pDocument != NULL);
3569
3570   int nIndex = -1;
3571   if (params.size() >= 1)
3572     nIndex = params[0].ToInt();
3573
3574   CFX_PtrArray FieldArray;
3575   GetFormFields(m_FieldName, FieldArray);
3576   if (FieldArray.GetSize() <= 0)
3577     return FALSE;
3578
3579   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3580   ASSERT(pFormField != NULL);
3581
3582   if (nIndex < 0 || nIndex >= pFormField->CountControls()) {
3583     vRet = FALSE;
3584     return FALSE;
3585   }
3586
3587   if ((pFormField->GetFieldType() == FIELDTYPE_CHECKBOX) ||
3588       (pFormField->GetFieldType() == FIELDTYPE_RADIOBUTTON)) {
3589     if (pFormField->GetControl(nIndex)->IsChecked() != 0)
3590       vRet = TRUE;
3591     else
3592       vRet = FALSE;
3593   } else
3594     vRet = FALSE;
3595
3596   return TRUE;
3597 }
3598
3599 FX_BOOL Field::isDefaultChecked(IJS_Context* cc,
3600                                 const CJS_Parameters& params,
3601                                 CJS_Value& vRet,
3602                                 CFX_WideString& sError) {
3603   ASSERT(m_pDocument != NULL);
3604
3605   int nIndex = -1;
3606   if (params.size() >= 1)
3607     nIndex = params[0].ToInt();
3608
3609   CFX_PtrArray FieldArray;
3610   GetFormFields(m_FieldName, FieldArray);
3611   if (FieldArray.GetSize() <= 0)
3612     return FALSE;
3613
3614   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3615   ASSERT(pFormField != NULL);
3616
3617   if (nIndex < 0 || nIndex >= pFormField->CountControls()) {
3618     vRet = FALSE;
3619     return FALSE;
3620   }
3621   if ((pFormField->GetFieldType() == FIELDTYPE_CHECKBOX) ||
3622       (pFormField->GetFieldType() == FIELDTYPE_RADIOBUTTON)) {
3623     if (pFormField->GetControl(nIndex)->IsDefaultChecked() != 0)
3624       vRet = TRUE;
3625     else
3626       vRet = FALSE;
3627   } else
3628     vRet = FALSE;
3629
3630   return TRUE;
3631 }
3632
3633 FX_BOOL Field::setAction(IJS_Context* cc,
3634                          const CJS_Parameters& params,
3635                          CJS_Value& vRet,
3636                          CFX_WideString& sError) {
3637   return TRUE;
3638 }
3639
3640 FX_BOOL Field::setFocus(IJS_Context* cc,
3641                         const CJS_Parameters& params,
3642                         CJS_Value& vRet,
3643                         CFX_WideString& sError) {
3644   ASSERT(m_pDocument != NULL);
3645
3646   CFX_PtrArray FieldArray;
3647   GetFormFields(m_FieldName, FieldArray);
3648   if (FieldArray.GetSize() <= 0)
3649     return FALSE;
3650
3651   CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3652   ASSERT(pFormField != NULL);
3653
3654   int32_t nCount = pFormField->CountControls();
3655
3656   if (nCount < 1)
3657     return FALSE;
3658
3659   CPDFSDK_InterForm* pInterForm =
3660       (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
3661   ASSERT(pInterForm != NULL);
3662
3663   CPDFSDK_Widget* pWidget = NULL;
3664   if (nCount == 1) {
3665     pWidget = pInterForm->GetWidget(pFormField->GetControl(0));