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