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