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