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