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