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