Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(92)

Side by Side Diff: fpdfsdk/src/fsdk_baseform.cpp

Issue 453133004: clang-format all code (Closed) Base URL: https://pdfium.googlesource.com/pdfium.git@master
Patch Set: Created 6 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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/fsdk_define.h" 7 #include "../include/fsdk_define.h"
8 #include "../include/fsdk_mgr.h" 8 #include "../include/fsdk_mgr.h"
9 #include "../include/fsdk_baseannot.h" 9 #include "../include/fsdk_baseannot.h"
10 #include "../include/fsdk_baseform.h" 10 #include "../include/fsdk_baseform.h"
11 #include "../include/formfiller/FFL_FormFiller.h" 11 #include "../include/formfiller/FFL_FormFiller.h"
12 #include "../include/fsdk_actionhandler.h" 12 #include "../include/fsdk_actionhandler.h"
13 13
14 #include "../include/javascript/IJavaScript.h" 14 #include "../include/javascript/IJavaScript.h"
15 15
16 //------------------------------------------------------------------------------ ------ 16 //------------------------------------------------------------------------------ ------
17 //*» » » » » » » » » » CPDFSDK_Widget 17 //*
18 //CPDFSDK_Widget
18 //------------------------------------------------------------------------------ ------ 19 //------------------------------------------------------------------------------ ------
19 20
20 #define IsFloatZero(f) ((f) < 0.01 && ( f) > -0.01) 21 #define IsFloatZero(f) ((f) < 0.01 && (f) > -0.01)
21 #define IsFloatBigger(fa,fb) ((fa) > (fb) && !IsFloat Zero((fa) - (fb))) 22 #define IsFloatBigger(fa, fb) ((fa) > (fb) && !IsFloatZero((fa) - (fb)))
22 #define IsFloatSmaller(fa,fb) ((fa) < (fb) && !IsFloat Zero((fa) - (fb))) 23 #define IsFloatSmaller(fa, fb) ((fa) < (fb) && !IsFloatZero((fa) - (fb)))
23 #define IsFloatEqual(fa,fb) IsFloatZero((fa) -(fb)) 24 #define IsFloatEqual(fa, fb) IsFloatZero((fa) - (fb))
24 25
25 CPDFSDK_Widget::CPDFSDK_Widget(CPDF_Annot* pAnnot, CPDFSDK_PageView* pPageView, CPDFSDK_InterForm* pInterForm) : 26 CPDFSDK_Widget::CPDFSDK_Widget(CPDF_Annot* pAnnot,
26 CPDFSDK_Annot(pAnnot, pPageView), 27 CPDFSDK_PageView* pPageView,
27 m_pInterForm(pInterForm), 28 CPDFSDK_InterForm* pInterForm)
28 m_nAppAge(0), 29 : CPDFSDK_Annot(pAnnot, pPageView),
29 m_nValueAge(0) 30 m_pInterForm(pInterForm),
30 { 31 m_nAppAge(0),
31 ASSERT(m_pInterForm != NULL); 32 m_nValueAge(0) {
32 } 33 ASSERT(m_pInterForm != NULL);
33 34 }
34 CPDFSDK_Widget::~CPDFSDK_Widget() 35
35 { 36 CPDFSDK_Widget::~CPDFSDK_Widget() {
36 37 }
37 } 38
38 39 FX_BOOL CPDFSDK_Widget::IsWidgetAppearanceValid(
39 FX_BOOL CPDFSDK_Widget::IsWidgetAppearanceValid(CPDF_Annot::AppearanceMo de mode) 40 CPDF_Annot::AppearanceMode mode) {
40 { 41 ASSERT(m_pAnnot != NULL);
41 ASSERT(m_pAnnot != NULL); 42 ASSERT(m_pAnnot->m_pAnnotDict != NULL);
42 ASSERT(m_pAnnot->m_pAnnotDict != NULL); 43
43 44 CPDF_Dictionary* pAP = m_pAnnot->m_pAnnotDict->GetDict("AP");
44 CPDF_Dictionary* pAP = m_pAnnot->m_pAnnotDict->GetDict("AP"); 45 if (pAP == NULL)
45 if (pAP == NULL) return FALSE; 46 return FALSE;
46 47
47 // Choose the right sub-ap 48 // Choose the right sub-ap
48 const FX_CHAR* ap_entry = "N"; 49 const FX_CHAR* ap_entry = "N";
49 if (mode == CPDF_Annot::Down) 50 if (mode == CPDF_Annot::Down)
50 ap_entry = "D"; 51 ap_entry = "D";
51 else if (mode == CPDF_Annot::Rollover) 52 else if (mode == CPDF_Annot::Rollover)
52 ap_entry = "R"; 53 ap_entry = "R";
53 if (!pAP->KeyExist(ap_entry)) 54 if (!pAP->KeyExist(ap_entry))
54 ap_entry = "N"; 55 ap_entry = "N";
55 56
56 // Get the AP stream or subdirectory 57 // Get the AP stream or subdirectory
57 CPDF_Object* psub = pAP->GetElementValue(ap_entry); 58 CPDF_Object* psub = pAP->GetElementValue(ap_entry);
58 if (psub == NULL) return FALSE; 59 if (psub == NULL)
59 60 return FALSE;
60 int nFieldType = GetFieldType(); 61
61 switch (nFieldType) 62 int nFieldType = GetFieldType();
62 { 63 switch (nFieldType) {
63 case FIELDTYPE_PUSHBUTTON: 64 case FIELDTYPE_PUSHBUTTON:
64 case FIELDTYPE_COMBOBOX: 65 case FIELDTYPE_COMBOBOX:
65 case FIELDTYPE_LISTBOX: 66 case FIELDTYPE_LISTBOX:
66 case FIELDTYPE_TEXTFIELD: 67 case FIELDTYPE_TEXTFIELD:
67 case FIELDTYPE_SIGNATURE: 68 case FIELDTYPE_SIGNATURE:
68 return psub->GetType() == PDFOBJ_STREAM; 69 return psub->GetType() == PDFOBJ_STREAM;
69 case FIELDTYPE_CHECKBOX: 70 case FIELDTYPE_CHECKBOX:
70 case FIELDTYPE_RADIOBUTTON: 71 case FIELDTYPE_RADIOBUTTON:
71 if (psub->GetType() == PDFOBJ_DICTIONARY) 72 if (psub->GetType() == PDFOBJ_DICTIONARY) {
72 { 73 CPDF_Dictionary* pSubDict = (CPDF_Dictionary*)psub;
73 CPDF_Dictionary* pSubDict = (CPDF_Dictionary*)psub; 74
74 75 return pSubDict->GetStream(this->GetAppState()) != NULL;
75 return pSubDict->GetStream(this->GetAppState()) != NULL; 76 } else
76 } 77 return FALSE;
77 else 78 break;
78 return FALSE; 79 }
79 break; 80
80 } 81 return TRUE;
81 82 }
82 return TRUE; 83
83 } 84 int CPDFSDK_Widget::GetFieldType() const {
84 85 CPDF_FormField* pField = GetFormField();
85 int CPDFSDK_Widget::GetFieldType() const 86 ASSERT(pField != NULL);
86 { 87
87 CPDF_FormField* pField = GetFormField(); 88 return pField->GetFieldType();
88 ASSERT(pField != NULL); 89 }
89 90
90 return pField->GetFieldType(); 91 int CPDFSDK_Widget::GetFieldFlags() const {
91 } 92 CPDF_InterForm* pPDFInterForm = m_pInterForm->GetInterForm();
92 93 ASSERT(pPDFInterForm != NULL);
93 int CPDFSDK_Widget::GetFieldFlags() const 94
94 { 95 CPDF_FormControl* pFormControl =
95 CPDF_InterForm* pPDFInterForm = m_pInterForm->GetInterForm(); 96 pPDFInterForm->GetControlByDict(m_pAnnot->m_pAnnotDict);
96 ASSERT(pPDFInterForm != NULL); 97 CPDF_FormField* pFormField = pFormControl->GetField();
97 98 return pFormField->GetFieldFlags();
98 CPDF_FormControl* pFormControl = pPDFInterForm->GetControlByDict(m_pAnno t->m_pAnnotDict); 99 }
99 CPDF_FormField* pFormField = pFormControl->GetField(); 100
100 return pFormField->GetFieldFlags(); 101 CFX_ByteString CPDFSDK_Widget::GetSubType() const {
101 } 102 int nType = GetFieldType();
102 103
103 CFX_ByteString CPDFSDK_Widget::GetSubType() const 104 if (nType == FIELDTYPE_SIGNATURE)
104 { 105 return BFFT_SIGNATURE;
105 int nType = GetFieldType(); 106 return CPDFSDK_Annot::GetSubType();
106 107 }
107 if (nType == FIELDTYPE_SIGNATURE) 108
108 return BFFT_SIGNATURE; 109 CPDF_FormField* CPDFSDK_Widget::GetFormField() const {
109 return CPDFSDK_Annot::GetSubType(); 110 ASSERT(m_pInterForm != NULL);
110 } 111
111 112 CPDF_FormControl* pCtrl = GetFormControl();
112 CPDF_FormField* CPDFSDK_Widget::GetFormField() const 113 ASSERT(pCtrl != NULL);
113 { 114
114 ASSERT(m_pInterForm != NULL); 115 return pCtrl->GetField();
115 116 }
116 CPDF_FormControl* pCtrl = GetFormControl(); 117
117 ASSERT(pCtrl != NULL); 118 CPDF_FormControl* CPDFSDK_Widget::GetFormControl() const {
118 119 ASSERT(m_pInterForm != NULL);
119 return pCtrl->GetField(); 120
120 } 121 CPDF_InterForm* pPDFInterForm = m_pInterForm->GetInterForm();
121 122 ASSERT(pPDFInterForm != NULL);
122 CPDF_FormControl* CPDFSDK_Widget::GetFormControl() const 123
123 { 124 return pPDFInterForm->GetControlByDict(GetAnnotDict());
124 ASSERT(m_pInterForm != NULL); 125 }
125 126 static CPDF_Dictionary* BF_GetField(CPDF_Dictionary* pFieldDict,
126 CPDF_InterForm* pPDFInterForm = m_pInterForm->GetInterForm(); 127 const FX_CHAR* name) {
127 ASSERT(pPDFInterForm != NULL); 128 if (pFieldDict == NULL)
128 129 return NULL;
129 return pPDFInterForm->GetControlByDict(GetAnnotDict()); 130 // First check the dictionary itself
130 } 131 CPDF_Object* pAttr = pFieldDict->GetElementValue(name);
131 static CPDF_Dictionary* BF_GetField(CPDF_Dictionary* pFieldDict, const FX_CHAR* name) 132 if (pAttr)
132 { 133 return pFieldDict;
133 if (pFieldDict == NULL) return NULL; 134
134 // First check the dictionary itself 135 // Now we need to search from parents
135 CPDF_Object* pAttr = pFieldDict->GetElementValue(name); 136 CPDF_Dictionary* pParent = pFieldDict->GetDict("Parent");
136 if (pAttr) return pFieldDict; 137 if (pParent == NULL)
137 138 return NULL;
138 // Now we need to search from parents 139
139 CPDF_Dictionary* pParent = pFieldDict->GetDict("Parent"); 140 return BF_GetField(pParent, name);
140 if (pParent == NULL) return NULL; 141 }
141 142
142 return BF_GetField(pParent, name); 143 CPDF_FormControl* CPDFSDK_Widget::GetFormControl(CPDF_InterForm* pInterForm,
143 } 144 CPDF_Dictionary* pAnnotDict) {
144 145 ASSERT(pInterForm != NULL);
145 CPDF_FormControl* CPDFSDK_Widget::GetFormControl(CPDF_InterForm* pInterForm, CPD F_Dictionary* pAnnotDict) 146 ASSERT(pAnnotDict != NULL);
146 { 147
147 ASSERT(pInterForm != NULL); 148 CPDF_FormControl* pControl = pInterForm->GetControlByDict(pAnnotDict);
148 ASSERT(pAnnotDict != NULL); 149
149 150 return pControl;
150 CPDF_FormControl* pControl = pInterForm->GetControlByDict(pAnnotDict); 151 }
151 152
152 return pControl; 153 int CPDFSDK_Widget::GetRotate() const {
153 } 154 CPDF_FormControl* pCtrl = this->GetFormControl();
154 155 ASSERT(pCtrl != NULL);
155 int CPDFSDK_Widget::GetRotate() const 156
156 { 157 return pCtrl->GetRotation() % 360;
157 CPDF_FormControl* pCtrl = this->GetFormControl(); 158 }
158 ASSERT(pCtrl != NULL); 159
159 160 FX_BOOL CPDFSDK_Widget::GetFillColor(FX_COLORREF& color) const {
160 return pCtrl->GetRotation() % 360; 161 CPDF_FormControl* pFormCtrl = GetFormControl();
161 } 162 ASSERT(pFormCtrl != NULL);
162 163
163 FX_BOOL CPDFSDK_Widget::GetFillColor(FX_COLORREF& color) const 164 int iColorType = 0;
164 { 165 color = FX_ARGBTOCOLORREF(pFormCtrl->GetBackgroundColor(iColorType));
165 CPDF_FormControl* pFormCtrl = GetFormControl(); 166
166 ASSERT(pFormCtrl != NULL); 167 return iColorType != COLORTYPE_TRANSPARENT;
167 168 }
168 int iColorType = 0; 169
169 color = FX_ARGBTOCOLORREF(pFormCtrl->GetBackgroundColor(iColorType)); 170 FX_BOOL CPDFSDK_Widget::GetBorderColor(FX_COLORREF& color) const {
170 171 CPDF_FormControl* pFormCtrl = GetFormControl();
171 return iColorType != COLORTYPE_TRANSPARENT; 172 ASSERT(pFormCtrl != NULL);
172 } 173
173 174 int iColorType = 0;
174 FX_BOOL CPDFSDK_Widget::GetBorderColor(FX_COLORREF& color) const 175 color = FX_ARGBTOCOLORREF(pFormCtrl->GetBorderColor(iColorType));
175 { 176
176 CPDF_FormControl* pFormCtrl = GetFormControl(); 177 return iColorType != COLORTYPE_TRANSPARENT;
177 ASSERT(pFormCtrl != NULL); 178 }
178 179
179 int iColorType = 0; 180 FX_BOOL CPDFSDK_Widget::GetTextColor(FX_COLORREF& color) const {
180 color = FX_ARGBTOCOLORREF(pFormCtrl->GetBorderColor(iColorType)); 181 CPDF_FormControl* pFormCtrl = GetFormControl();
181 182 ASSERT(pFormCtrl != NULL);
182 return iColorType != COLORTYPE_TRANSPARENT; 183
183 } 184 CPDF_DefaultAppearance da = pFormCtrl->GetDefaultAppearance();
184 185 if (da.HasColor()) {
185 FX_BOOL CPDFSDK_Widget::GetTextColor(FX_COLORREF& color) const 186 FX_ARGB argb;
186 { 187 int iColorType = COLORTYPE_TRANSPARENT;
187 CPDF_FormControl* pFormCtrl = GetFormControl(); 188 da.GetColor(argb, iColorType);
188 ASSERT(pFormCtrl != NULL); 189 color = FX_ARGBTOCOLORREF(argb);
189 190
190 CPDF_DefaultAppearance da = pFormCtrl->GetDefaultAppearance(); 191 return iColorType != COLORTYPE_TRANSPARENT;
191 if (da.HasColor()) 192 }
192 { 193
193 FX_ARGB argb; 194 return FALSE;
194 int iColorType = COLORTYPE_TRANSPARENT; 195 }
195 da.GetColor(argb, iColorType); 196
196 color = FX_ARGBTOCOLORREF(argb); 197 FX_FLOAT CPDFSDK_Widget::GetFontSize() const {
197 198 CPDF_FormControl* pFormCtrl = GetFormControl();
198 return iColorType != COLORTYPE_TRANSPARENT; 199 ASSERT(pFormCtrl != NULL);
199 } 200
200 201 CPDF_DefaultAppearance pDa = pFormCtrl->GetDefaultAppearance();
201 return FALSE; 202 CFX_ByteString csFont = "";
202 } 203 FX_FLOAT fFontSize = 0.0f;
203 204 pDa.GetFont(csFont, fFontSize);
204 FX_FLOAT CPDFSDK_Widget::GetFontSize() const 205
205 { 206 return fFontSize;
206 CPDF_FormControl* pFormCtrl = GetFormControl(); 207 }
207 ASSERT(pFormCtrl != NULL); 208
208 209 int CPDFSDK_Widget::GetSelectedIndex(int nIndex) const {
209 CPDF_DefaultAppearance pDa = pFormCtrl->GetDefaultAppearance(); 210 CPDF_FormField* pFormField = GetFormField();
210 CFX_ByteString csFont = ""; 211 ASSERT(pFormField != NULL);
211 FX_FLOAT fFontSize = 0.0f; 212
212 pDa.GetFont(csFont, fFontSize); 213 return pFormField->GetSelectedIndex(nIndex);
213 214 }
214 return fFontSize; 215
215 } 216 CFX_WideString CPDFSDK_Widget::GetValue() const {
216 217 CPDF_FormField* pFormField = GetFormField();
217 int CPDFSDK_Widget::GetSelectedIndex(int nIndex) const 218 ASSERT(pFormField != NULL);
218 { 219
219 CPDF_FormField* pFormField = GetFormField(); 220 return pFormField->GetValue();
220 ASSERT(pFormField != NULL); 221 }
221 222
222 return pFormField->GetSelectedIndex(nIndex); 223 CFX_WideString CPDFSDK_Widget::GetDefaultValue() const {
223 } 224 CPDF_FormField* pFormField = GetFormField();
224 225 ASSERT(pFormField != NULL);
225 CFX_WideString CPDFSDK_Widget::GetValue() const 226
226 { 227 return pFormField->GetDefaultValue();
227 CPDF_FormField* pFormField = GetFormField(); 228 }
228 ASSERT(pFormField != NULL); 229
229 230 CFX_WideString CPDFSDK_Widget::GetOptionLabel(int nIndex) const {
230 return pFormField->GetValue(); 231 CPDF_FormField* pFormField = GetFormField();
231 } 232 ASSERT(pFormField != NULL);
232 233
233 CFX_WideString CPDFSDK_Widget::GetDefaultValue() const 234 return pFormField->GetOptionLabel(nIndex);
234 { 235 }
235 CPDF_FormField* pFormField = GetFormField(); 236
236 ASSERT(pFormField != NULL); 237 int CPDFSDK_Widget::CountOptions() const {
237 238 CPDF_FormField* pFormField = GetFormField();
238 return pFormField->GetDefaultValue(); 239 ASSERT(pFormField != NULL);
239 } 240
240 241 return pFormField->CountOptions();
241 CFX_WideString CPDFSDK_Widget::GetOptionLabel(int nIndex) const 242 }
242 { 243
243 CPDF_FormField* pFormField = GetFormField(); 244 FX_BOOL CPDFSDK_Widget::IsOptionSelected(int nIndex) const {
244 ASSERT(pFormField != NULL); 245 CPDF_FormField* pFormField = GetFormField();
245 246 ASSERT(pFormField != NULL);
246 return pFormField->GetOptionLabel(nIndex); 247
247 } 248 return pFormField->IsItemSelected(nIndex);
248 249 }
249 int CPDFSDK_Widget::CountOptions() const 250
250 { 251 int CPDFSDK_Widget::GetTopVisibleIndex() const {
251 CPDF_FormField* pFormField = GetFormField(); 252 CPDF_FormField* pFormField = GetFormField();
252 ASSERT(pFormField != NULL); 253 ASSERT(pFormField != NULL);
253 254
254 return pFormField->CountOptions(); 255 return pFormField->GetTopVisibleIndex();
255 } 256 }
256 257
257 FX_BOOL CPDFSDK_Widget::IsOptionSelected(int nIndex) const 258 FX_BOOL CPDFSDK_Widget::IsChecked() const {
258 { 259 CPDF_FormControl* pFormCtrl = GetFormControl();
259 CPDF_FormField* pFormField = GetFormField(); 260 ASSERT(pFormCtrl != NULL);
260 ASSERT(pFormField != NULL); 261
261 262 return pFormCtrl->IsChecked();
262 return pFormField->IsItemSelected(nIndex); 263 }
263 } 264
264 265 int CPDFSDK_Widget::GetAlignment() const {
265 int CPDFSDK_Widget::GetTopVisibleIndex() const 266 CPDF_FormControl* pFormCtrl = GetFormControl();
266 { 267 ASSERT(pFormCtrl != NULL);
267 CPDF_FormField* pFormField = GetFormField(); 268
268 ASSERT(pFormField != NULL); 269 return pFormCtrl->GetControlAlignment();
269 270 }
270 return pFormField->GetTopVisibleIndex(); 271
271 } 272 int CPDFSDK_Widget::GetMaxLen() const {
272 273 CPDF_FormField* pFormField = GetFormField();
273 FX_BOOL CPDFSDK_Widget::IsChecked() const 274 ASSERT(pFormField != NULL);
274 { 275
275 CPDF_FormControl* pFormCtrl = GetFormControl(); 276 return pFormField->GetMaxLen();
276 ASSERT(pFormCtrl != NULL); 277 }
277 278
278 return pFormCtrl->IsChecked(); 279 void CPDFSDK_Widget::SetCheck(FX_BOOL bChecked, FX_BOOL bNotify) {
279 } 280 CPDF_FormControl* pFormCtrl = GetFormControl();
280 281 ASSERT(pFormCtrl != NULL);
281 int CPDFSDK_Widget::GetAlignment() const 282
282 { 283 CPDF_FormField* pFormField = pFormCtrl->GetField();
283 CPDF_FormControl* pFormCtrl = GetFormControl(); 284 ASSERT(pFormField != NULL);
284 ASSERT(pFormCtrl != NULL); 285
285 286 pFormField->CheckControl(
286 return pFormCtrl->GetControlAlignment(); 287 pFormField->GetControlIndex(pFormCtrl), bChecked, bNotify);
287 } 288 }
288 289
289 int CPDFSDK_Widget::GetMaxLen() const 290 void CPDFSDK_Widget::SetValue(const CFX_WideString& sValue, FX_BOOL bNotify) {
290 { 291 CPDF_FormField* pFormField = GetFormField();
291 CPDF_FormField* pFormField = GetFormField(); 292 ASSERT(pFormField != NULL);
292 ASSERT(pFormField != NULL); 293
293 294 pFormField->SetValue(sValue, bNotify);
294 return pFormField->GetMaxLen(); 295 }
295 } 296
296 297 void CPDFSDK_Widget::SetDefaultValue(const CFX_WideString& sValue) {
297 void CPDFSDK_Widget::SetCheck(FX_BOOL bChecked, FX_BOOL bNotify) 298 }
298 { 299 void CPDFSDK_Widget::SetOptionSelection(int index,
299 CPDF_FormControl* pFormCtrl = GetFormControl(); 300 FX_BOOL bSelected,
300 ASSERT(pFormCtrl != NULL); 301 FX_BOOL bNotify) {
301 302 CPDF_FormField* pFormField = GetFormField();
302 CPDF_FormField* pFormField = pFormCtrl->GetField(); 303 ASSERT(pFormField != NULL);
303 ASSERT(pFormField != NULL); 304
304 305 pFormField->SetItemSelection(index, bSelected, bNotify);
305 pFormField->CheckControl(pFormField->GetControlIndex(pFormCtrl), bChecke d, bNotify); 306 }
306 } 307
307 308 void CPDFSDK_Widget::ClearSelection(FX_BOOL bNotify) {
308 void CPDFSDK_Widget::SetValue(const CFX_WideString& sValue, FX_BOOL bNotify) 309 CPDF_FormField* pFormField = GetFormField();
309 { 310 ASSERT(pFormField != NULL);
310 CPDF_FormField* pFormField = GetFormField(); 311
311 ASSERT(pFormField != NULL); 312 pFormField->ClearSelection(bNotify);
312 313 }
313 pFormField->SetValue(sValue, bNotify); 314
314 } 315 void CPDFSDK_Widget::SetTopVisibleIndex(int index) {
315 316 }
316 void CPDFSDK_Widget::SetDefaultValue(const CFX_WideString& sValue) 317
317 { 318 void CPDFSDK_Widget::SetAppModified() {
318 } 319 m_bAppModified = TRUE;
319 void CPDFSDK_Widget::SetOptionSelection(int index, FX_BOOL bSelected, FX_BOOL bN otify) 320 }
320 { 321
321 CPDF_FormField* pFormField = GetFormField(); 322 void CPDFSDK_Widget::ClearAppModified() {
322 ASSERT(pFormField != NULL); 323 m_bAppModified = FALSE;
323 324 }
324 pFormField->SetItemSelection(index, bSelected, bNotify); 325
325 } 326 FX_BOOL CPDFSDK_Widget::IsAppModified() const {
326 327 return m_bAppModified;
327 void CPDFSDK_Widget::ClearSelection(FX_BOOL bNotify) 328 }
328 { 329
329 CPDF_FormField* pFormField = GetFormField(); 330 void CPDFSDK_Widget::ResetAppearance(FX_LPCWSTR sValue, FX_BOOL bValueChanged) {
330 ASSERT(pFormField != NULL); 331 SetAppModified();
331 332
332 pFormField->ClearSelection(bNotify); 333 m_nAppAge++;
333 } 334 if (m_nAppAge > 999999)
334 335 m_nAppAge = 0;
335 void CPDFSDK_Widget::SetTopVisibleIndex(int index) 336 if (bValueChanged)
336 { 337 m_nValueAge++;
337 } 338
338 339 int nFieldType = GetFieldType();
339 void CPDFSDK_Widget::SetAppModified() 340
340 { 341 switch (nFieldType) {
341 m_bAppModified = TRUE; 342 case FIELDTYPE_PUSHBUTTON:
342 } 343 ResetAppearance_PushButton();
343 344 break;
344 void CPDFSDK_Widget::ClearAppModified() 345 case FIELDTYPE_CHECKBOX:
345 { 346 ResetAppearance_CheckBox();
346 m_bAppModified = FALSE; 347 break;
347 } 348 case FIELDTYPE_RADIOBUTTON:
348 349 ResetAppearance_RadioButton();
349 FX_BOOL CPDFSDK_Widget::IsAppModified() const 350 break;
350 { 351 case FIELDTYPE_COMBOBOX:
351 return m_bAppModified; 352 ResetAppearance_ComboBox(sValue);
352 } 353 break;
353 354 case FIELDTYPE_LISTBOX:
354 void CPDFSDK_Widget::ResetAppearance(FX_LPCWSTR sValue, FX_BOOL bValueChanged) 355 ResetAppearance_ListBox();
355 { 356 break;
356 SetAppModified(); 357 case FIELDTYPE_TEXTFIELD:
357 358 ResetAppearance_TextField(sValue);
358 m_nAppAge++; 359 break;
359 if (m_nAppAge > 999999) 360 }
360 m_nAppAge = 0; 361
361 if (bValueChanged) 362 ASSERT(m_pAnnot != NULL);
362 m_nValueAge++; 363 m_pAnnot->ClearCachedAP();
363 364 }
364 int nFieldType = GetFieldType(); 365
365 366 CFX_WideString CPDFSDK_Widget::OnFormat(int nCommitKey, FX_BOOL& bFormated) {
366 switch (nFieldType) 367 CPDF_FormField* pFormField = GetFormField();
367 { 368 ASSERT(pFormField != NULL);
368 case FIELDTYPE_PUSHBUTTON: 369
369 ResetAppearance_PushButton(); 370 ASSERT(m_pInterForm != NULL);
370 break; 371
371 case FIELDTYPE_CHECKBOX: 372 return m_pInterForm->OnFormat(pFormField, nCommitKey, bFormated);
372 ResetAppearance_CheckBox(); 373 }
373 break; 374
374 case FIELDTYPE_RADIOBUTTON: 375 void CPDFSDK_Widget::ResetFieldAppearance(FX_BOOL bValueChanged) {
375 ResetAppearance_RadioButton(); 376 CPDF_FormField* pFormField = GetFormField();
376 break; 377 ASSERT(pFormField != NULL);
377 case FIELDTYPE_COMBOBOX: 378
378 ResetAppearance_ComboBox(sValue); 379 ASSERT(m_pInterForm != NULL);
379 break; 380
380 case FIELDTYPE_LISTBOX: 381 m_pInterForm->ResetFieldAppearance(pFormField, NULL, bValueChanged);
381 ResetAppearance_ListBox(); 382 }
382 break; 383
383 case FIELDTYPE_TEXTFIELD: 384 void CPDFSDK_Widget::DrawAppearance(CFX_RenderDevice* pDevice,
384 ResetAppearance_TextField(sValue); 385 const CPDF_Matrix* pUser2Device,
385 break; 386 CPDF_Annot::AppearanceMode mode,
386 } 387 const CPDF_RenderOptions* pOptions) {
387 388 int nFieldType = GetFieldType();
388 ASSERT(m_pAnnot != NULL); 389
389 m_pAnnot->ClearCachedAP(); 390 if ((nFieldType == FIELDTYPE_CHECKBOX ||
390 } 391 nFieldType == FIELDTYPE_RADIOBUTTON) &&
391 392 mode == CPDF_Annot::Normal &&
392 CFX_WideString CPDFSDK_Widget::OnFormat(int nCommitKey, FX_BOOL& bFormated) 393 !this->IsWidgetAppearanceValid(CPDF_Annot::Normal)) {
393 { 394 CFX_PathData pathData;
394 CPDF_FormField* pFormField = GetFormField(); 395
395 ASSERT(pFormField != NULL); 396 CPDF_Rect rcAnnot = this->GetRect();
396 397
397 ASSERT(m_pInterForm != NULL); 398 pathData.AppendRect(
398 399 rcAnnot.left, rcAnnot.bottom, rcAnnot.right, rcAnnot.top);
399 return m_pInterForm->OnFormat(pFormField, nCommitKey, bFormated); 400
400 401 CFX_GraphStateData gsd;
401 } 402 gsd.m_LineWidth = 0.0f;
402 403
403 void CPDFSDK_Widget::ResetFieldAppearance(FX_BOOL bValueChanged) 404 pDevice->DrawPath(
404 { 405 &pathData, pUser2Device, &gsd, 0, 0xFFAAAAAA, FXFILL_ALTERNATE);
405 CPDF_FormField* pFormField = GetFormField(); 406 } else {
406 ASSERT(pFormField != NULL); 407 CPDFSDK_Annot::DrawAppearance(pDevice, pUser2Device, mode, pOptions);
407 408 }
408 ASSERT(m_pInterForm != NULL); 409 }
409 410
410 m_pInterForm->ResetFieldAppearance(pFormField, NULL, bValueChanged); 411 void CPDFSDK_Widget::UpdateField() {
411 } 412 CPDF_FormField* pFormField = GetFormField();
412 413 ASSERT(pFormField != NULL);
413 void CPDFSDK_Widget::DrawAppearance(CFX_RenderDevice* pDevice, const CPDF_Mat rix* pUser2Device, 414
414 CPDF_Annot::AppearanceMode mode, const CPDF_RenderOptions* pOpti ons) 415 ASSERT(m_pInterForm != NULL);
415 { 416 m_pInterForm->UpdateField(pFormField);
416 int nFieldType = GetFieldType(); 417 }
417 418
418 if ((nFieldType == FIELDTYPE_CHECKBOX || nFieldType == FIELDTYPE_RADIOBU TTON) && 419 void CPDFSDK_Widget::DrawShadow(CFX_RenderDevice* pDevice,
419 mode == CPDF_Annot::Normal && 420 CPDFSDK_PageView* pPageView) {
420 !this->IsWidgetAppearanceValid(CPDF_Annot::Normal)) 421 ASSERT(m_pInterForm != NULL);
421 { 422
422 CFX_PathData pathData; 423 int nFieldType = GetFieldType();
423 424 if (m_pInterForm->IsNeedHighLight(nFieldType)) {
424 CPDF_Rect rcAnnot = this->GetRect(); 425 // if (nFieldType != FIELDTYPE_PUSHBUTTON)
425 426 // {
426 pathData.AppendRect(rcAnnot.left, rcAnnot.bottom, 427 CPDF_Rect rc = GetRect();
427 rcAnnot.right, rcAnnot.top); 428 FX_COLORREF color = m_pInterForm->GetHighlightColor(nFieldType);
428 429 FX_BYTE alpha = m_pInterForm->GetHighlightAlpha();
429 CFX_GraphStateData gsd; 430
430 gsd.m_LineWidth = 0.0f; 431 CFX_FloatRect rcDevice;
431 432 ASSERT(m_pInterForm->GetDocument());
432 pDevice->DrawPath(&pathData, pUser2Device, &gsd, 0, 0xFFAAAAAA, FXFILL_ALTERNATE); 433 CPDFDoc_Environment* pEnv = m_pInterForm->GetDocument()->GetEnv();
433 } 434 if (!pEnv)
434 else 435 return;
435 { 436 CFX_AffineMatrix page2device;
436 CPDFSDK_Annot::DrawAppearance(pDevice, pUser2Device, mode, pOpti ons); 437 pPageView->GetCurrentMatrix(page2device);
437 } 438 page2device.Transform(((FX_FLOAT)rc.left),
438 } 439 ((FX_FLOAT)rc.bottom),
439 440 rcDevice.left,
440 void CPDFSDK_Widget::UpdateField() 441 rcDevice.bottom);
441 { 442 // pEnv->FFI_PageToDevice(m_pPageView->GetPDFPage(), rc.lef t, rc.bottom,
442 CPDF_FormField* pFormField = GetFormField(); 443 // &rcDevice.left, &rcDevice.bottom);
443 ASSERT(pFormField != NULL); 444 // pEnv->FFI_PageToDevice(m_pPageView->GetPDFPage(), rc.rig ht, rc.top,
444 445 // &rcDevice.right, &rcDevice.top);
445 ASSERT(m_pInterForm != NULL); 446 page2device.Transform(
446 m_pInterForm->UpdateField(pFormField); 447 ((FX_FLOAT)rc.right), ((FX_FLOAT)rc.top), rcDevice.right, rcDevice.top);
447 } 448
448 449 rcDevice.Normalize();
449 void CPDFSDK_Widget::DrawShadow(CFX_RenderDevice* pDevice, CPDFSDK_PageView* pPa geView) 450
450 { 451 FX_ARGB argb = ArgbEncode((int)alpha, color);
451 ASSERT(m_pInterForm != NULL); 452 FX_RECT rcDev((int)rcDevice.left,
452 453 (int)rcDevice.top,
453 int nFieldType = GetFieldType(); 454 (int)rcDevice.right,
454 if (m_pInterForm->IsNeedHighLight(nFieldType)) 455 (int)rcDevice.bottom);
455 { 456 pDevice->FillRect(&rcDev, argb);
456 457 /* }*/
457 // if (nFieldType != FIELDTYPE_PUSHBUTTON) 458 }
458 // { 459 }
459 CPDF_Rect rc = GetRect(); 460
460 FX_COLORREF color = m_pInterForm->GetHighlightColor(nFie ldType); 461 void CPDFSDK_Widget::ResetAppearance_PushButton() {
461 FX_BYTE alpha = m_pInterForm->GetHighlightAlpha(); 462 CPDF_FormControl* pControl = GetFormControl();
462 463 ASSERT(pControl != NULL);
463 CFX_FloatRect rcDevice; 464
464 ASSERT(m_pInterForm->GetDocument()); 465 CPDF_Rect rcWindow = GetRotatedRect();
465 CPDFDoc_Environment* pEnv = m_pInterForm->GetDocument()- >GetEnv(); 466
466 if(!pEnv) 467 FX_INT32 nLayout = 0;
467 return; 468
468 CFX_AffineMatrix page2device; 469 switch (pControl->GetTextPosition()) {
469 pPageView->GetCurrentMatrix(page2device); 470 case TEXTPOS_ICON:
470 page2device.Transform(((FX_FLOAT)rc.left), ((FX_FLOAT)rc .bottom), rcDevice.left, rcDevice.bottom); 471 nLayout = PPBL_ICON;
471 // pEnv->FFI_PageToDevice(m_pPageView->GetPDFPage(), rc.lef t, rc.bottom, &rcDevice.left, &rcDevice.bottom); 472 break;
472 // pEnv->FFI_PageToDevice(m_pPageView->GetPDFPage(), rc.rig ht, rc.top, &rcDevice.right, &rcDevice.top); 473 case TEXTPOS_BELOW:
473 page2device.Transform(((FX_FLOAT)rc.right), ((FX_FLOAT)r c.top), rcDevice.right, rcDevice.top); 474 nLayout = PPBL_ICONTOPLABELBOTTOM;
474 475 break;
475 rcDevice.Normalize(); 476 case TEXTPOS_ABOVE:
476 477 nLayout = PPBL_LABELTOPICONBOTTOM;
477 FX_ARGB argb = ArgbEncode((int)alpha, color); 478 break;
478 FX_RECT rcDev((int)rcDevice.left,(int)rcDevice.top,(int) rcDevice.right,(int)rcDevice.bottom); 479 case TEXTPOS_RIGHT:
479 pDevice->FillRect(&rcDev, argb); 480 nLayout = PPBL_ICONLEFTLABELRIGHT;
480 /* }*/ 481 break;
481 } 482 case TEXTPOS_LEFT:
482 } 483 nLayout = PPBL_LABELLEFTICONRIGHT;
483 484 break;
484 void CPDFSDK_Widget::ResetAppearance_PushButton() 485 case TEXTPOS_OVERLAID:
485 { 486 nLayout = PPBL_LABELOVERICON;
486 CPDF_FormControl* pControl = GetFormControl(); 487 break;
487 ASSERT(pControl != NULL); 488 default:
488 489 nLayout = PPBL_LABEL;
489 490 break;
490 491 }
491 CPDF_Rect rcWindow = GetRotatedRect(); 492
492 493 CPWL_Color crBackground, crBorder;
493 FX_INT32 nLayout = 0; 494
494 495 int iColorType;
495 switch (pControl->GetTextPosition()) 496 FX_FLOAT fc[4];
496 { 497
497 case TEXTPOS_ICON: 498 pControl->GetOriginalBackgroundColor(iColorType, fc);
498 nLayout = PPBL_ICON; 499 if (iColorType > 0)
499 break; 500 crBackground = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3]);
500 case TEXTPOS_BELOW: 501
501 nLayout = PPBL_ICONTOPLABELBOTTOM; 502 pControl->GetOriginalBorderColor(iColorType, fc);
502 break; 503 if (iColorType > 0)
503 case TEXTPOS_ABOVE: 504 crBorder = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3]);
504 nLayout = PPBL_LABELTOPICONBOTTOM; 505
505 break; 506 FX_FLOAT fBorderWidth = (FX_FLOAT)GetBorderWidth();
506 case TEXTPOS_RIGHT: 507 FX_INT32 nBorderStyle = 0;
507 nLayout = PPBL_ICONLEFTLABELRIGHT; 508 CPWL_Dash dsBorder(3, 0, 0);
508 break; 509 CPWL_Color crLeftTop, crRightBottom;
509 case TEXTPOS_LEFT: 510
510 nLayout = PPBL_LABELLEFTICONRIGHT; 511 switch (GetBorderStyle()) {
511 break; 512 case BBS_DASH:
512 case TEXTPOS_OVERLAID: 513 nBorderStyle = PBS_DASH;
513 nLayout = PPBL_LABELOVERICON; 514 dsBorder = CPWL_Dash(3, 3, 0);
514 break; 515 break;
515 default: 516 case BBS_BEVELED:
516 nLayout = PPBL_LABEL; 517 nBorderStyle = PBS_BEVELED;
517 break; 518 fBorderWidth *= 2;
518 } 519 crLeftTop = CPWL_Color(COLORTYPE_GRAY, 1);
519 520 crRightBottom = CPWL_Utils::DevideColor(crBackground, 2);
520 CPWL_Color crBackground, crBorder; 521 break;
521 522 case BBS_INSET:
522 int iColorType; 523 nBorderStyle = PBS_INSET;
523 FX_FLOAT fc[4]; 524 fBorderWidth *= 2;
524 525 crLeftTop = CPWL_Color(COLORTYPE_GRAY, 0.5);
525 pControl->GetOriginalBackgroundColor(iColorType, fc); 526 crRightBottom = CPWL_Color(COLORTYPE_GRAY, 0.75);
526 if (iColorType > 0) 527 break;
527 crBackground = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3] ); 528 case BBS_UNDERLINE:
528 529 nBorderStyle = PBS_UNDERLINED;
529 pControl->GetOriginalBorderColor(iColorType, fc); 530 break;
530 if (iColorType > 0) 531 default:
531 crBorder = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3]); 532 nBorderStyle = PBS_SOLID;
532 533 break;
533 FX_FLOAT fBorderWidth = (FX_FLOAT)GetBorderWidth(); 534 }
534 FX_INT32 nBorderStyle = 0; 535
535 CPWL_Dash dsBorder(3,0,0); 536 CPDF_Rect rcClient = CPWL_Utils::DeflateRect(rcWindow, fBorderWidth);
536 CPWL_Color crLeftTop,crRightBottom; 537
537 538 CPWL_Color crText(COLORTYPE_GRAY, 0);
538 switch (GetBorderStyle()) 539
539 { 540 FX_FLOAT fFontSize = 12.0f;
540 case BBS_DASH: 541 CFX_ByteString csNameTag;
541 nBorderStyle = PBS_DASH; 542
542 dsBorder = CPWL_Dash(3, 3, 0); 543 CPDF_DefaultAppearance da = pControl->GetDefaultAppearance();
543 break; 544 if (da.HasColor()) {
544 case BBS_BEVELED: 545 da.GetColor(iColorType, fc);
545 nBorderStyle = PBS_BEVELED; 546 crText = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3]);
546 fBorderWidth *= 2; 547 }
547 crLeftTop = CPWL_Color(COLORTYPE_GRAY,1); 548
548 crRightBottom = CPWL_Utils::DevideColor(crBackground,2); 549 if (da.HasFont())
549 break; 550 da.GetFont(csNameTag, fFontSize);
550 case BBS_INSET: 551
551 nBorderStyle = PBS_INSET; 552 CFX_WideString csWCaption;
552 fBorderWidth *= 2; 553 CFX_WideString csNormalCaption, csRolloverCaption, csDownCaption;
553 crLeftTop = CPWL_Color(COLORTYPE_GRAY,0.5); 554
554 crRightBottom = CPWL_Color(COLORTYPE_GRAY,0.75); 555 if (pControl->HasMKEntry("CA")) {
555 break; 556 csNormalCaption = pControl->GetNormalCaption();
556 case BBS_UNDERLINE: 557 }
557 nBorderStyle = PBS_UNDERLINED; 558 if (pControl->HasMKEntry("RC")) {
558 break; 559 csRolloverCaption = pControl->GetRolloverCaption();
559 default: 560 }
560 nBorderStyle = PBS_SOLID; 561 if (pControl->HasMKEntry("AC")) {
561 break; 562 csDownCaption = pControl->GetDownCaption();
562 } 563 }
563 564
564 CPDF_Rect rcClient = CPWL_Utils::DeflateRect(rcWindow,fBorderWidth); 565 CPDF_Stream* pNormalIcon = NULL;
565 566 CPDF_Stream* pRolloverIcon = NULL;
566 CPWL_Color crText(COLORTYPE_GRAY,0); 567 CPDF_Stream* pDownIcon = NULL;
567 568
568 FX_FLOAT fFontSize = 12.0f; 569 if (pControl->HasMKEntry("I")) {
569 CFX_ByteString csNameTag; 570 pNormalIcon = pControl->GetNormalIcon();
570 571 }
571 CPDF_DefaultAppearance da = pControl->GetDefaultAppearance(); 572 if (pControl->HasMKEntry("RI")) {
572 if (da.HasColor()) 573 pRolloverIcon = pControl->GetRolloverIcon();
573 { 574 }
574 da.GetColor(iColorType, fc); 575 if (pControl->HasMKEntry("IX")) {
575 crText = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3]); 576 pDownIcon = pControl->GetDownIcon();
576 } 577 }
577 578
578 if (da.HasFont()) 579 if (pNormalIcon) {
579 da.GetFont(csNameTag, fFontSize); 580 if (CPDF_Dictionary* pImageDict = pNormalIcon->GetDict()) {
580 581 if (pImageDict->GetString("Name").IsEmpty())
581 CFX_WideString csWCaption; 582 pImageDict->SetAtString("Name", "ImgA");
582 CFX_WideString csNormalCaption, csRolloverCaption, csDownCaption; 583 }
583 584 }
584 if (pControl->HasMKEntry("CA")) 585
585 { 586 if (pRolloverIcon) {
586 csNormalCaption = pControl->GetNormalCaption(); 587 if (CPDF_Dictionary* pImageDict = pRolloverIcon->GetDict()) {
587 } 588 if (pImageDict->GetString("Name").IsEmpty())
588 if (pControl->HasMKEntry("RC")) 589 pImageDict->SetAtString("Name", "ImgB");
589 { 590 }
590 csRolloverCaption = pControl->GetRolloverCaption(); 591 }
591 } 592
592 if (pControl->HasMKEntry("AC")) 593 if (pDownIcon) {
593 { 594 if (CPDF_Dictionary* pImageDict = pDownIcon->GetDict()) {
594 csDownCaption = pControl->GetDownCaption(); 595 if (pImageDict->GetString("Name").IsEmpty())
595 } 596 pImageDict->SetAtString("Name", "ImgC");
596 597 }
597 CPDF_Stream* pNormalIcon = NULL; 598 }
598 CPDF_Stream* pRolloverIcon = NULL; 599
599 CPDF_Stream* pDownIcon = NULL; 600 CPDF_IconFit iconFit = pControl->GetIconFit();
600 601
601 if (pControl->HasMKEntry("I")) 602 // ASSERT(this->m_pBaseForm != NULL);
602 { 603 ASSERT(this->m_pInterForm != NULL);
603 pNormalIcon = pControl->GetNormalIcon(); 604 CPDFSDK_Document* pDoc = m_pInterForm->GetDocument();
604 } 605 ASSERT(pDoc != NULL);
605 if (pControl->HasMKEntry("RI")) 606 CPDFDoc_Environment* pEnv = pDoc->GetEnv();
606 { 607
607 pRolloverIcon = pControl->GetRolloverIcon(); 608 CBA_FontMap FontMap(
608 } 609 this,
609 if (pControl->HasMKEntry("IX")) 610 pEnv->GetSysHandler()); //,
610 { 611 //ISystemHandle::GetSystemHandler(m_pBaseForm->Ge tEnv()));
611 pDownIcon = pControl->GetDownIcon(); 612 FontMap.Initial();
612 } 613
613 614 FontMap.SetAPType("N");
614 if (pNormalIcon) 615
615 { 616 CFX_ByteString csAP =
616 if (CPDF_Dictionary* pImageDict = pNormalIcon->GetDict()) 617 CPWL_Utils::GetRectFillAppStream(rcWindow, crBackground) +
617 { 618 CPWL_Utils::GetBorderAppStream(rcWindow,
618 if (pImageDict->GetString("Name").IsEmpty()) 619 fBorderWidth,
619 pImageDict->SetAtString("Name", "ImgA"); 620 crBorder,
620 } 621 crLeftTop,
621 } 622 crRightBottom,
622 623 nBorderStyle,
623 if (pRolloverIcon) 624 dsBorder) +
624 { 625 CPWL_Utils::GetPushButtonAppStream(
625 if (CPDF_Dictionary* pImageDict = pRolloverIcon->GetDict()) 626 iconFit.GetFittingBounds() ? rcWindow : rcClient,
626 { 627 &FontMap,
627 if (pImageDict->GetString("Name").IsEmpty()) 628 pNormalIcon,
628 pImageDict->SetAtString("Name", "ImgB"); 629 iconFit,
629 } 630 csNormalCaption,
630 } 631 crText,
631 632 fFontSize,
632 if (pDownIcon) 633 nLayout);
633 { 634
634 if (CPDF_Dictionary* pImageDict = pDownIcon->GetDict()) 635 WriteAppearance("N", GetRotatedRect(), GetMatrix(), csAP);
635 { 636 if (pNormalIcon)
636 if (pImageDict->GetString("Name").IsEmpty()) 637 AddImageToAppearance("N", pNormalIcon);
637 pImageDict->SetAtString("Name", "ImgC"); 638
638 } 639 CPDF_FormControl::HighlightingMode eHLM = pControl->GetHighlightingMode();
639 } 640 if (eHLM == CPDF_FormControl::Push || eHLM == CPDF_FormControl::Toggle) {
640 641 if (csRolloverCaption.IsEmpty() && !pRolloverIcon) {
641 CPDF_IconFit iconFit = pControl->GetIconFit(); 642 csRolloverCaption = csNormalCaption;
642 643 pRolloverIcon = pNormalIcon;
643 // ASSERT(this->m_pBaseForm != NULL); 644 }
644 ASSERT(this->m_pInterForm != NULL); 645
645 CPDFSDK_Document* pDoc = m_pInterForm->GetDocument(); 646 FontMap.SetAPType("R");
646 ASSERT(pDoc != NULL); 647
647 CPDFDoc_Environment* pEnv = pDoc->GetEnv(); 648 csAP = CPWL_Utils::GetRectFillAppStream(rcWindow, crBackground) +
648 649 CPWL_Utils::GetBorderAppStream(rcWindow,
649 CBA_FontMap FontMap(this,pEnv->GetSysHandler());//, ISystemHandle::GetSy stemHandler(m_pBaseForm->GetEnv())); 650 fBorderWidth,
650 FontMap.Initial(); 651 crBorder,
651 652 crLeftTop,
652 FontMap.SetAPType("N"); 653 crRightBottom,
653 654 nBorderStyle,
654 CFX_ByteString csAP = CPWL_Utils::GetRectFillAppStream(rcWindow, crBackg round) + 655 dsBorder) +
655 CPWL_Utils::GetBorderAppStream(rcWindow, fBorderWidth, crBorder, crLeftTop, crRightBottom, nBorderStyle, dsBorder) + 656 CPWL_Utils::GetPushButtonAppStream(
656 CPWL_Utils::GetPushButtonAppStream(iconFit.GetFittingBounds() ? rcWindow : rcClient, &FontMap, pNormalIcon, iconFit, csNormalCaption, crText, fF ontSize, nLayout); 657 iconFit.GetFittingBounds() ? rcWindow : rcClient,
657 658 &FontMap,
658 WriteAppearance("N", GetRotatedRect(), GetMatrix(), csAP); 659 pRolloverIcon,
659 if (pNormalIcon) 660 iconFit,
660 AddImageToAppearance("N", pNormalIcon); 661 csRolloverCaption,
661 662 crText,
662 CPDF_FormControl::HighlightingMode eHLM = pControl->GetHighlightingMode( ); 663 fFontSize,
663 if (eHLM == CPDF_FormControl::Push || eHLM == CPDF_FormControl::Toggle) 664 nLayout);
664 { 665
665 if (csRolloverCaption.IsEmpty() && !pRolloverIcon) 666 WriteAppearance("R", GetRotatedRect(), GetMatrix(), csAP);
666 { 667 if (pRolloverIcon)
667 csRolloverCaption = csNormalCaption; 668 AddImageToAppearance("R", pRolloverIcon);
668 pRolloverIcon = pNormalIcon; 669
669 } 670 if (csDownCaption.IsEmpty() && !pDownIcon) {
670 671 csDownCaption = csNormalCaption;
671 FontMap.SetAPType("R"); 672 pDownIcon = pNormalIcon;
672 673 }
673 csAP = CPWL_Utils::GetRectFillAppStream(rcWindow, crBackground) + 674
674 CPWL_Utils::GetBorderAppStream(rcWindow, fBorder Width, crBorder, crLeftTop, crRightBottom, nBorderStyle, dsBorder) + 675 switch (nBorderStyle) {
675 CPWL_Utils::GetPushButtonAppStream(iconFit.GetFi ttingBounds() ? rcWindow : rcClient, &FontMap, pRolloverIcon, iconFit, csRollove rCaption, crText, fFontSize, nLayout); 676 case PBS_BEVELED: {
676 677 CPWL_Color crTemp = crLeftTop;
677 WriteAppearance("R", GetRotatedRect(), GetMatrix(), csAP); 678 crLeftTop = crRightBottom;
678 if (pRolloverIcon) 679 crRightBottom = crTemp;
679 AddImageToAppearance("R", pRolloverIcon); 680 } break;
680 681 case PBS_INSET:
681 if (csDownCaption.IsEmpty() && !pDownIcon) 682 crLeftTop = CPWL_Color(COLORTYPE_GRAY, 0);
682 { 683 crRightBottom = CPWL_Color(COLORTYPE_GRAY, 1);
683 csDownCaption = csNormalCaption; 684 break;
684 pDownIcon = pNormalIcon; 685 }
685 } 686
686 687 FontMap.SetAPType("D");
687 switch (nBorderStyle) 688
688 { 689 csAP = CPWL_Utils::GetRectFillAppStream(
689 case PBS_BEVELED: 690 rcWindow, CPWL_Utils::SubstractColor(crBackground, 0.25f)) +
690 { 691 CPWL_Utils::GetBorderAppStream(rcWindow,
691 CPWL_Color crTemp = crLeftTop; 692 fBorderWidth,
692 crLeftTop = crRightBottom; 693 crBorder,
693 crRightBottom = crTemp; 694 crLeftTop,
694 } 695 crRightBottom,
695 break; 696 nBorderStyle,
696 case PBS_INSET: 697 dsBorder) +
697 crLeftTop = CPWL_Color(COLORTYPE_GRAY,0); 698 CPWL_Utils::GetPushButtonAppStream(
698 crRightBottom = CPWL_Color(COLORTYPE_GRAY,1); 699 iconFit.GetFittingBounds() ? rcWindow : rcClient,
699 break; 700 &FontMap,
700 } 701 pDownIcon,
701 702 iconFit,
702 FontMap.SetAPType("D"); 703 csDownCaption,
703 704 crText,
704 csAP = CPWL_Utils::GetRectFillAppStream(rcWindow, CPWL_Utils::Su bstractColor(crBackground,0.25f)) + 705 fFontSize,
705 CPWL_Utils::GetBorderAppStream(rcWindow, fBorderWidth, c rBorder, crLeftTop, crRightBottom, nBorderStyle, dsBorder) + 706 nLayout);
706 CPWL_Utils::GetPushButtonAppStream(iconFit.GetFittingBou nds() ? rcWindow : rcClient, &FontMap, pDownIcon, iconFit, csDownCaption, crText , fFontSize, nLayout); 707
707 708 WriteAppearance("D", GetRotatedRect(), GetMatrix(), csAP);
708 WriteAppearance("D", GetRotatedRect(), GetMatrix(), csAP); 709 if (pDownIcon)
709 if (pDownIcon) 710 AddImageToAppearance("D", pDownIcon);
710 AddImageToAppearance("D", pDownIcon); 711 } else {
711 } 712 RemoveAppearance("D");
712 else 713 RemoveAppearance("R");
713 { 714 }
714 RemoveAppearance("D"); 715 }
715 RemoveAppearance("R"); 716
716 } 717 void CPDFSDK_Widget::ResetAppearance_CheckBox() {
717 } 718 CPDF_FormControl* pControl = GetFormControl();
718 719 ASSERT(pControl != NULL);
719 void CPDFSDK_Widget::ResetAppearance_CheckBox() 720
720 { 721 CPWL_Color crBackground, crBorder, crText;
721 CPDF_FormControl* pControl = GetFormControl(); 722
722 ASSERT(pControl != NULL); 723 int iColorType;
723 724 FX_FLOAT fc[4];
724 725
725 726 pControl->GetOriginalBackgroundColor(iColorType, fc);
726 CPWL_Color crBackground, crBorder, crText; 727 if (iColorType > 0)
727 728 crBackground = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3]);
728 int iColorType; 729
729 FX_FLOAT fc[4]; 730 pControl->GetOriginalBorderColor(iColorType, fc);
730 731 if (iColorType > 0)
731 pControl->GetOriginalBackgroundColor(iColorType, fc); 732 crBorder = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3]);
732 if (iColorType > 0) 733
733 crBackground = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3] ); 734 FX_FLOAT fBorderWidth = (FX_FLOAT)GetBorderWidth();
734 735 FX_INT32 nBorderStyle = 0;
735 pControl->GetOriginalBorderColor(iColorType, fc); 736 CPWL_Dash dsBorder(3, 0, 0);
736 if (iColorType > 0) 737 CPWL_Color crLeftTop, crRightBottom;
737 crBorder = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3]); 738
738 739 switch (GetBorderStyle()) {
739 FX_FLOAT fBorderWidth = (FX_FLOAT)GetBorderWidth(); 740 case BBS_DASH:
740 FX_INT32 nBorderStyle = 0; 741 nBorderStyle = PBS_DASH;
741 CPWL_Dash dsBorder(3,0,0); 742 dsBorder = CPWL_Dash(3, 3, 0);
742 CPWL_Color crLeftTop,crRightBottom; 743 break;
743 744 case BBS_BEVELED:
744 switch (GetBorderStyle()) 745 nBorderStyle = PBS_BEVELED;
745 { 746 fBorderWidth *= 2;
746 case BBS_DASH: 747 crLeftTop = CPWL_Color(COLORTYPE_GRAY, 1);
747 nBorderStyle = PBS_DASH; 748 crRightBottom = CPWL_Utils::DevideColor(crBackground, 2);
748 dsBorder = CPWL_Dash(3, 3, 0); 749 break;
749 break; 750 case BBS_INSET:
750 case BBS_BEVELED: 751 nBorderStyle = PBS_INSET;
751 nBorderStyle = PBS_BEVELED; 752 fBorderWidth *= 2;
752 fBorderWidth *= 2; 753 crLeftTop = CPWL_Color(COLORTYPE_GRAY, 0.5);
753 crLeftTop = CPWL_Color(COLORTYPE_GRAY,1); 754 crRightBottom = CPWL_Color(COLORTYPE_GRAY, 0.75);
754 crRightBottom = CPWL_Utils::DevideColor(crBackground,2); 755 break;
755 break; 756 case BBS_UNDERLINE:
756 case BBS_INSET: 757 nBorderStyle = PBS_UNDERLINED;
757 nBorderStyle = PBS_INSET; 758 break;
758 fBorderWidth *= 2; 759 default:
759 crLeftTop = CPWL_Color(COLORTYPE_GRAY,0.5); 760 nBorderStyle = PBS_SOLID;
760 crRightBottom = CPWL_Color(COLORTYPE_GRAY,0.75); 761 break;
761 break; 762 }
762 case BBS_UNDERLINE: 763
763 nBorderStyle = PBS_UNDERLINED; 764 CPDF_Rect rcWindow = GetRotatedRect();
764 break; 765 CPDF_Rect rcClient = CPWL_Utils::DeflateRect(rcWindow, fBorderWidth);
765 default: 766
766 nBorderStyle = PBS_SOLID; 767 CPDF_DefaultAppearance da = pControl->GetDefaultAppearance();
767 break; 768 if (da.HasColor()) {
768 } 769 da.GetColor(iColorType, fc);
769 770 crText = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3]);
770 CPDF_Rect rcWindow = GetRotatedRect(); 771 }
771 CPDF_Rect rcClient = CPWL_Utils::DeflateRect(rcWindow,fBorderWidth); 772
772 773 FX_INT32 nStyle = 0;
773 CPDF_DefaultAppearance da = pControl->GetDefaultAppearance(); 774
774 if (da.HasColor()) 775 CFX_WideString csWCaption = pControl->GetNormalCaption();
775 { 776 if (csWCaption.GetLength() > 0) {
776 da.GetColor(iColorType, fc); 777 switch (csWCaption[0]) {
777 crText = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3]); 778 case L'l':
778 } 779 nStyle = PCS_CIRCLE;
779 780 break;
780 FX_INT32 nStyle = 0; 781 case L'8':
781 782 nStyle = PCS_CROSS;
782 CFX_WideString csWCaption = pControl->GetNormalCaption(); 783 break;
783 if (csWCaption.GetLength() > 0) 784 case L'u':
784 { 785 nStyle = PCS_DIAMOND;
785 switch (csWCaption[0]) 786 break;
786 { 787 case L'n':
787 case L'l': 788 nStyle = PCS_SQUARE;
788 nStyle = PCS_CIRCLE; 789 break;
789 break; 790 case L'H':
790 case L'8': 791 nStyle = PCS_STAR;
791 nStyle = PCS_CROSS; 792 break;
792 break; 793 default: // L'4'
793 case L'u': 794 nStyle = PCS_CHECK;
794 nStyle = PCS_DIAMOND; 795 break;
795 break; 796 }
796 case L'n': 797 } else {
797 nStyle = PCS_SQUARE; 798 nStyle = PCS_CHECK;
798 break; 799 }
799 case L'H': 800
800 nStyle = PCS_STAR; 801 CFX_ByteString csAP_N_ON =
801 break; 802 CPWL_Utils::GetRectFillAppStream(rcWindow, crBackground) +
802 default: //L'4' 803 CPWL_Utils::GetBorderAppStream(rcWindow,
803 nStyle = PCS_CHECK; 804 fBorderWidth,
804 break; 805 crBorder,
805 } 806 crLeftTop,
806 } 807 crRightBottom,
807 else 808 nBorderStyle,
808 { 809 dsBorder);
809 nStyle = PCS_CHECK; 810
810 } 811 CFX_ByteString csAP_N_OFF = csAP_N_ON;
811 812
812 CFX_ByteString csAP_N_ON = CPWL_Utils::GetRectFillAppStream(rcWindow,crB ackground) + 813 switch (nBorderStyle) {
813 CPWL_Utils::GetBorderAppStream(rcWindow,fBorderWidth,crBorder,cr LeftTop,crRightBottom,nBorderStyle,dsBorder); 814 case PBS_BEVELED: {
814 815 CPWL_Color crTemp = crLeftTop;
815 CFX_ByteString csAP_N_OFF = csAP_N_ON; 816 crLeftTop = crRightBottom;
816 817 crRightBottom = crTemp;
817 switch (nBorderStyle) 818 } break;
818 { 819 case PBS_INSET:
819 case PBS_BEVELED: 820 crLeftTop = CPWL_Color(COLORTYPE_GRAY, 0);
820 { 821 crRightBottom = CPWL_Color(COLORTYPE_GRAY, 1);
821 CPWL_Color crTemp = crLeftTop; 822 break;
822 crLeftTop = crRightBottom; 823 }
823 crRightBottom = crTemp; 824
824 } 825 CFX_ByteString csAP_D_ON =
825 break; 826 CPWL_Utils::GetRectFillAppStream(
826 case PBS_INSET: 827 rcWindow, CPWL_Utils::SubstractColor(crBackground, 0.25f)) +
827 crLeftTop = CPWL_Color(COLORTYPE_GRAY,0); 828 CPWL_Utils::GetBorderAppStream(rcWindow,
828 crRightBottom = CPWL_Color(COLORTYPE_GRAY,1); 829 fBorderWidth,
829 break; 830 crBorder,
830 } 831 crLeftTop,
831 832 crRightBottom,
832 CFX_ByteString csAP_D_ON = CPWL_Utils::GetRectFillAppStream(rcWindow,CPW L_Utils::SubstractColor(crBackground,0.25f)) + 833 nBorderStyle,
833 CPWL_Utils::GetBorderAppStream(rcWindow,fBorderWidth,crBorder,cr LeftTop,crRightBottom,nBorderStyle,dsBorder); 834 dsBorder);
834 835
835 CFX_ByteString csAP_D_OFF = csAP_D_ON; 836 CFX_ByteString csAP_D_OFF = csAP_D_ON;
836 837
837 csAP_N_ON += CPWL_Utils::GetCheckBoxAppStream(rcClient,nStyle,crText); 838 csAP_N_ON += CPWL_Utils::GetCheckBoxAppStream(rcClient, nStyle, crText);
838 csAP_D_ON += CPWL_Utils::GetCheckBoxAppStream(rcClient,nStyle,crText); 839 csAP_D_ON += CPWL_Utils::GetCheckBoxAppStream(rcClient, nStyle, crText);
839 840
840 WriteAppearance("N", GetRotatedRect(), GetMatrix(), csAP_N_ON, pControl- >GetCheckedAPState()); 841 WriteAppearance("N",
841 WriteAppearance("N", GetRotatedRect(), GetMatrix(), csAP_N_OFF, "Off"); 842 GetRotatedRect(),
842 843 GetMatrix(),
843 WriteAppearance("D", GetRotatedRect(), GetMatrix(), csAP_D_ON, pControl- >GetCheckedAPState()); 844 csAP_N_ON,
844 WriteAppearance("D", GetRotatedRect(), GetMatrix(), csAP_D_OFF, "Off"); 845 pControl->GetCheckedAPState());
845 846 WriteAppearance("N", GetRotatedRect(), GetMatrix(), csAP_N_OFF, "Off");
846 CFX_ByteString csAS = GetAppState(); 847
847 if (csAS.IsEmpty()) 848 WriteAppearance("D",
848 SetAppState("Off"); 849 GetRotatedRect(),
849 } 850 GetMatrix(),
850 851 csAP_D_ON,
851 void CPDFSDK_Widget::ResetAppearance_RadioButton() 852 pControl->GetCheckedAPState());
852 { 853 WriteAppearance("D", GetRotatedRect(), GetMatrix(), csAP_D_OFF, "Off");
853 CPDF_FormControl* pControl = GetFormControl(); 854
854 ASSERT(pControl != NULL); 855 CFX_ByteString csAS = GetAppState();
855 856 if (csAS.IsEmpty())
856 857 SetAppState("Off");
857 858 }
858 CPWL_Color crBackground, crBorder, crText; 859
859 860 void CPDFSDK_Widget::ResetAppearance_RadioButton() {
860 int iColorType; 861 CPDF_FormControl* pControl = GetFormControl();
861 FX_FLOAT fc[4]; 862 ASSERT(pControl != NULL);
862 863
863 pControl->GetOriginalBackgroundColor(iColorType, fc); 864 CPWL_Color crBackground, crBorder, crText;
864 if (iColorType > 0) 865
865 crBackground = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3] ); 866 int iColorType;
866 867 FX_FLOAT fc[4];
867 pControl->GetOriginalBorderColor(iColorType, fc); 868
868 if (iColorType > 0) 869 pControl->GetOriginalBackgroundColor(iColorType, fc);
869 crBorder = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3]); 870 if (iColorType > 0)
870 871 crBackground = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3]);
871 FX_FLOAT fBorderWidth = (FX_FLOAT)GetBorderWidth(); 872
872 FX_INT32 nBorderStyle = 0; 873 pControl->GetOriginalBorderColor(iColorType, fc);
873 CPWL_Dash dsBorder(3,0,0); 874 if (iColorType > 0)
874 CPWL_Color crLeftTop,crRightBottom; 875 crBorder = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3]);
875 876
876 switch (GetBorderStyle()) 877 FX_FLOAT fBorderWidth = (FX_FLOAT)GetBorderWidth();
877 { 878 FX_INT32 nBorderStyle = 0;
878 case BBS_DASH: 879 CPWL_Dash dsBorder(3, 0, 0);
879 nBorderStyle = PBS_DASH; 880 CPWL_Color crLeftTop, crRightBottom;
880 dsBorder = CPWL_Dash(3, 3, 0); 881
881 break; 882 switch (GetBorderStyle()) {
882 case BBS_BEVELED: 883 case BBS_DASH:
883 nBorderStyle = PBS_BEVELED; 884 nBorderStyle = PBS_DASH;
884 fBorderWidth *= 2; 885 dsBorder = CPWL_Dash(3, 3, 0);
885 crLeftTop = CPWL_Color(COLORTYPE_GRAY,1); 886 break;
886 crRightBottom = CPWL_Utils::DevideColor(crBackground,2); 887 case BBS_BEVELED:
887 break; 888 nBorderStyle = PBS_BEVELED;
888 case BBS_INSET: 889 fBorderWidth *= 2;
889 nBorderStyle = PBS_INSET; 890 crLeftTop = CPWL_Color(COLORTYPE_GRAY, 1);
890 fBorderWidth *= 2; 891 crRightBottom = CPWL_Utils::DevideColor(crBackground, 2);
891 crLeftTop = CPWL_Color(COLORTYPE_GRAY,0.5); 892 break;
892 crRightBottom = CPWL_Color(COLORTYPE_GRAY,0.75); 893 case BBS_INSET:
893 break; 894 nBorderStyle = PBS_INSET;
894 case BBS_UNDERLINE: 895 fBorderWidth *= 2;
895 nBorderStyle = PBS_UNDERLINED; 896 crLeftTop = CPWL_Color(COLORTYPE_GRAY, 0.5);
896 break; 897 crRightBottom = CPWL_Color(COLORTYPE_GRAY, 0.75);
897 default: 898 break;
898 nBorderStyle = PBS_SOLID; 899 case BBS_UNDERLINE:
899 break; 900 nBorderStyle = PBS_UNDERLINED;
900 } 901 break;
901 902 default:
902 CPDF_Rect rcWindow = GetRotatedRect(); 903 nBorderStyle = PBS_SOLID;
903 CPDF_Rect rcClient = CPWL_Utils::DeflateRect(rcWindow, fBorderWidth); 904 break;
904 905 }
905 CPDF_DefaultAppearance da = pControl->GetDefaultAppearance(); 906
906 if (da.HasColor()) 907 CPDF_Rect rcWindow = GetRotatedRect();
907 { 908 CPDF_Rect rcClient = CPWL_Utils::DeflateRect(rcWindow, fBorderWidth);
908 da.GetColor(iColorType, fc); 909
909 crText = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3]); 910 CPDF_DefaultAppearance da = pControl->GetDefaultAppearance();
910 } 911 if (da.HasColor()) {
911 912 da.GetColor(iColorType, fc);
912 FX_INT32 nStyle = 0; 913 crText = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3]);
913 914 }
914 CFX_WideString csWCaption = pControl->GetNormalCaption(); 915
915 if (csWCaption.GetLength() > 0) 916 FX_INT32 nStyle = 0;
916 { 917
917 switch (csWCaption[0]) 918 CFX_WideString csWCaption = pControl->GetNormalCaption();
918 { 919 if (csWCaption.GetLength() > 0) {
919 default: //L'l': 920 switch (csWCaption[0]) {
920 nStyle = PCS_CIRCLE; 921 default: // L'l':
921 break; 922 nStyle = PCS_CIRCLE;
922 case L'8': 923 break;
923 nStyle = PCS_CROSS; 924 case L'8':
924 break; 925 nStyle = PCS_CROSS;
925 case L'u': 926 break;
926 nStyle = PCS_DIAMOND; 927 case L'u':
927 break; 928 nStyle = PCS_DIAMOND;
928 case L'n': 929 break;
929 nStyle = PCS_SQUARE; 930 case L'n':
930 break; 931 nStyle = PCS_SQUARE;
931 case L'H': 932 break;
932 nStyle = PCS_STAR; 933 case L'H':
933 break; 934 nStyle = PCS_STAR;
934 case L'4': 935 break;
935 nStyle = PCS_CHECK; 936 case L'4':
936 break; 937 nStyle = PCS_CHECK;
937 } 938 break;
938 } 939 }
939 else 940 } else {
940 { 941 nStyle = PCS_CIRCLE;
941 nStyle = PCS_CIRCLE; 942 }
942 } 943
943 944 CFX_ByteString csAP_N_ON;
944 CFX_ByteString csAP_N_ON; 945
945 946 CPDF_Rect rcCenter =
946 CPDF_Rect rcCenter = CPWL_Utils::DeflateRect(CPWL_Utils::GetCenterSquare (rcWindow), 1.0f); 947 CPWL_Utils::DeflateRect(CPWL_Utils::GetCenterSquare(rcWindow), 1.0f);
947 948
948 if (nStyle == PCS_CIRCLE) 949 if (nStyle == PCS_CIRCLE) {
949 { 950 if (nBorderStyle == PBS_BEVELED) {
950 if (nBorderStyle == PBS_BEVELED) 951 crLeftTop = CPWL_Color(COLORTYPE_GRAY, 1);
951 { 952 crRightBottom = CPWL_Utils::SubstractColor(crBackground, 0.25f);
952 crLeftTop = CPWL_Color(COLORTYPE_GRAY, 1); 953 } else if (nBorderStyle == PBS_INSET) {
953 crRightBottom = CPWL_Utils::SubstractColor(crBackground, 0.25f); 954 crLeftTop = CPWL_Color(COLORTYPE_GRAY, 0.5f);
954 } 955 crRightBottom = CPWL_Color(COLORTYPE_GRAY, 0.75f);
955 else if (nBorderStyle == PBS_INSET) 956 }
956 { 957
957 crLeftTop = CPWL_Color(COLORTYPE_GRAY,0.5f); 958 csAP_N_ON = CPWL_Utils::GetCircleFillAppStream(rcCenter, crBackground) +
958 crRightBottom = CPWL_Color(COLORTYPE_GRAY,0.75f); 959 CPWL_Utils::GetCircleBorderAppStream(rcCenter,
959 } 960 fBorderWidth,
960 961 crBorder,
961 csAP_N_ON = CPWL_Utils::GetCircleFillAppStream(rcCenter,crBackgr ound) + 962 crLeftTop,
962 CPWL_Utils::GetCircleBorderAppStream(rcCenter,fBorderWid th,crBorder,crLeftTop,crRightBottom,nBorderStyle,dsBorder); 963 crRightBottom,
963 } 964 nBorderStyle,
964 else 965 dsBorder);
965 { 966 } else {
966 csAP_N_ON = CPWL_Utils::GetRectFillAppStream(rcWindow,crBackgrou nd) + 967 csAP_N_ON = CPWL_Utils::GetRectFillAppStream(rcWindow, crBackground) +
967 CPWL_Utils::GetBorderAppStream(rcWindow,fBorderWidth,crB order,crLeftTop,crRightBottom,nBorderStyle,dsBorder); 968 CPWL_Utils::GetBorderAppStream(rcWindow,
968 } 969 fBorderWidth,
969 970 crBorder,
970 CFX_ByteString csAP_N_OFF = csAP_N_ON; 971 crLeftTop,
971 972 crRightBottom,
972 switch (nBorderStyle) 973 nBorderStyle,
973 { 974 dsBorder);
974 case PBS_BEVELED: 975 }
975 { 976
976 CPWL_Color crTemp = crLeftTop; 977 CFX_ByteString csAP_N_OFF = csAP_N_ON;
977 crLeftTop = crRightBottom; 978
978 crRightBottom = crTemp; 979 switch (nBorderStyle) {
979 } 980 case PBS_BEVELED: {
980 break; 981 CPWL_Color crTemp = crLeftTop;
981 case PBS_INSET: 982 crLeftTop = crRightBottom;
982 crLeftTop = CPWL_Color(COLORTYPE_GRAY,0); 983 crRightBottom = crTemp;
983 crRightBottom = CPWL_Color(COLORTYPE_GRAY,1); 984 } break;
984 break; 985 case PBS_INSET:
985 } 986 crLeftTop = CPWL_Color(COLORTYPE_GRAY, 0);
986 987 crRightBottom = CPWL_Color(COLORTYPE_GRAY, 1);
987 CFX_ByteString csAP_D_ON; 988 break;
988 989 }
989 if (nStyle == PCS_CIRCLE) 990
990 { 991 CFX_ByteString csAP_D_ON;
991 CPWL_Color crBK = CPWL_Utils::SubstractColor(crBackground,0.25f) ; 992
992 if (nBorderStyle == PBS_BEVELED) 993 if (nStyle == PCS_CIRCLE) {
993 { 994 CPWL_Color crBK = CPWL_Utils::SubstractColor(crBackground, 0.25f);
994 crLeftTop = CPWL_Utils::SubstractColor(crBackground,0.25 f); 995 if (nBorderStyle == PBS_BEVELED) {
995 crRightBottom = CPWL_Color(COLORTYPE_GRAY, 1); 996 crLeftTop = CPWL_Utils::SubstractColor(crBackground, 0.25f);
996 crBK = crBackground; 997 crRightBottom = CPWL_Color(COLORTYPE_GRAY, 1);
997 } 998 crBK = crBackground;
998 else if (nBorderStyle == PBS_INSET) 999 } else if (nBorderStyle == PBS_INSET) {
999 { 1000 crLeftTop = CPWL_Color(COLORTYPE_GRAY, 0);
1000 crLeftTop = CPWL_Color(COLORTYPE_GRAY,0); 1001 crRightBottom = CPWL_Color(COLORTYPE_GRAY, 1);
1001 crRightBottom = CPWL_Color(COLORTYPE_GRAY,1); 1002 }
1002 } 1003
1003 1004 csAP_D_ON = CPWL_Utils::GetCircleFillAppStream(rcCenter, crBK) +
1004 csAP_D_ON = CPWL_Utils::GetCircleFillAppStream(rcCenter,crBK) 1005 CPWL_Utils::GetCircleBorderAppStream(rcCenter,
1005 + CPWL_Utils::GetCircleBorderAppStream(rcCenter,fBorderW idth,crBorder,crLeftTop,crRightBottom,nBorderStyle,dsBorder); 1006 fBorderWidth,
1006 } 1007 crBorder,
1007 else 1008 crLeftTop,
1008 { 1009 crRightBottom,
1009 csAP_D_ON = CPWL_Utils::GetRectFillAppStream(rcWindow,CPWL_Utils ::SubstractColor(crBackground,0.25f)) + 1010 nBorderStyle,
1010 CPWL_Utils::GetBorderAppStream(rcWindow,fBorderWidth,crB order,crLeftTop,crRightBottom,nBorderStyle,dsBorder); 1011 dsBorder);
1011 } 1012 } else {
1012 1013 csAP_D_ON = CPWL_Utils::GetRectFillAppStream(
1013 CFX_ByteString csAP_D_OFF = csAP_D_ON; 1014 rcWindow, CPWL_Utils::SubstractColor(crBackground, 0.25f)) +
1014 1015 CPWL_Utils::GetBorderAppStream(rcWindow,
1015 csAP_N_ON += CPWL_Utils::GetRadioButtonAppStream(rcClient,nStyle,crText) ; 1016 fBorderWidth,
1016 csAP_D_ON += CPWL_Utils::GetRadioButtonAppStream(rcClient,nStyle,crText) ; 1017 crBorder,
1017 1018 crLeftTop,
1018 WriteAppearance("N", GetRotatedRect(), GetMatrix(), csAP_N_ON, pControl- >GetCheckedAPState()); 1019 crRightBottom,
1019 WriteAppearance("N", GetRotatedRect(), GetMatrix(), csAP_N_OFF, "Off"); 1020 nBorderStyle,
1020 1021 dsBorder);
1021 WriteAppearance("D", GetRotatedRect(), GetMatrix(), csAP_D_ON, pControl- >GetCheckedAPState()); 1022 }
1022 WriteAppearance("D", GetRotatedRect(), GetMatrix(), csAP_D_OFF, "Off"); 1023
1023 1024 CFX_ByteString csAP_D_OFF = csAP_D_ON;
1024 CFX_ByteString csAS = GetAppState(); 1025
1025 if (csAS.IsEmpty()) 1026 csAP_N_ON += CPWL_Utils::GetRadioButtonAppStream(rcClient, nStyle, crText);
1026 SetAppState("Off"); 1027 csAP_D_ON += CPWL_Utils::GetRadioButtonAppStream(rcClient, nStyle, crText);
1027 } 1028
1028 1029 WriteAppearance("N",
1029 void CPDFSDK_Widget::ResetAppearance_ComboBox(FX_LPCWSTR sValue) 1030 GetRotatedRect(),
1030 { 1031 GetMatrix(),
1031 CPDF_FormControl* pControl = GetFormControl(); 1032 csAP_N_ON,
1032 ASSERT(pControl != NULL); 1033 pControl->GetCheckedAPState());
1033 CPDF_FormField* pField = pControl->GetField(); 1034 WriteAppearance("N", GetRotatedRect(), GetMatrix(), csAP_N_OFF, "Off");
1034 ASSERT(pField != NULL); 1035
1035 1036 WriteAppearance("D",
1036 CFX_ByteTextBuf sBody, sLines; 1037 GetRotatedRect(),
1037 1038 GetMatrix(),
1038 CPDF_Rect rcClient = GetClientRect(); 1039 csAP_D_ON,
1039 CPDF_Rect rcButton = rcClient; 1040 pControl->GetCheckedAPState());
1040 rcButton.left = rcButton.right - 13; 1041 WriteAppearance("D", GetRotatedRect(), GetMatrix(), csAP_D_OFF, "Off");
1041 rcButton.Normalize(); 1042
1042 1043 CFX_ByteString csAS = GetAppState();
1043 if (IFX_Edit * pEdit = IFX_Edit::NewEdit()) 1044 if (csAS.IsEmpty())
1044 { 1045 SetAppState("Off");
1045 pEdit->EnableRefresh(FALSE); 1046 }
1046 1047
1047 ASSERT(this->m_pInterForm != NULL); 1048 void CPDFSDK_Widget::ResetAppearance_ComboBox(FX_LPCWSTR sValue) {
1048 CPDFSDK_Document* pDoc = m_pInterForm->GetDocument(); 1049 CPDF_FormControl* pControl = GetFormControl();
1049 ASSERT(pDoc != NULL); 1050 ASSERT(pControl != NULL);
1050 CPDFDoc_Environment* pEnv = pDoc->GetEnv(); 1051 CPDF_FormField* pField = pControl->GetField();
1051 CBA_FontMap FontMap(this,pEnv->GetSysHandler()); 1052 ASSERT(pField != NULL);
1052 FontMap.Initial(); 1053
1053 pEdit->SetFontMap(&FontMap); 1054 CFX_ByteTextBuf sBody, sLines;
1054 1055
1055 CPDF_Rect rcEdit = rcClient; 1056 CPDF_Rect rcClient = GetClientRect();
1056 rcEdit.right = rcButton.left; 1057 CPDF_Rect rcButton = rcClient;
1057 rcEdit.Normalize(); 1058 rcButton.left = rcButton.right - 13;
1058 1059 rcButton.Normalize();
1059 pEdit->SetPlateRect(rcEdit); 1060
1060 pEdit->SetAlignmentV(1); 1061 if (IFX_Edit* pEdit = IFX_Edit::NewEdit()) {
1061 1062 pEdit->EnableRefresh(FALSE);
1062 FX_FLOAT fFontSize = this->GetFontSize(); 1063
1063 if (IsFloatZero(fFontSize)) 1064 ASSERT(this->m_pInterForm != NULL);
1064 pEdit->SetAutoFontSize(TRUE); 1065 CPDFSDK_Document* pDoc = m_pInterForm->GetDocument();
1065 else 1066 ASSERT(pDoc != NULL);
1066 pEdit->SetFontSize(fFontSize); 1067 CPDFDoc_Environment* pEnv = pDoc->GetEnv();
1067 1068 CBA_FontMap FontMap(this, pEnv->GetSysHandler());
1068 pEdit->Initialize(); 1069 FontMap.Initial();
1069 1070 pEdit->SetFontMap(&FontMap);
1070 if (sValue) 1071
1071 pEdit->SetText(sValue); 1072 CPDF_Rect rcEdit = rcClient;
1072 else 1073 rcEdit.right = rcButton.left;
1073 { 1074 rcEdit.Normalize();
1074 FX_INT32 nCurSel = pField->GetSelectedIndex(0); 1075
1075 1076 pEdit->SetPlateRect(rcEdit);
1076 if (nCurSel < 0) 1077 pEdit->SetAlignmentV(1);
1077 pEdit->SetText((FX_LPCWSTR)pField->GetValue()); 1078
1078 else 1079 FX_FLOAT fFontSize = this->GetFontSize();
1079 pEdit->SetText((FX_LPCWSTR)pField->GetOptionLabe l(nCurSel)); 1080 if (IsFloatZero(fFontSize))
1080 } 1081 pEdit->SetAutoFontSize(TRUE);
1081 1082 else
1082 CPDF_Rect rcContent = pEdit->GetContentRect(); 1083 pEdit->SetFontSize(fFontSize);
1083 1084
1084 CFX_ByteString sEdit = CPWL_Utils::GetEditAppStream(pEdit,CPDF_P oint(0.0f,0.0f)); 1085 pEdit->Initialize();
1085 if (sEdit.GetLength() > 0) 1086
1086 { 1087 if (sValue)
1087 sBody << "/Tx BMC\n" << "q\n"; 1088 pEdit->SetText(sValue);
1088 if (rcContent.Width() > rcEdit.Width() || 1089 else {
1089 rcContent.Height() > rcEdit.Height()) 1090 FX_INT32 nCurSel = pField->GetSelectedIndex(0);
1090 { 1091
1091 sBody << rcEdit.left << " " << rcEdit.bottom << " " 1092 if (nCurSel < 0)
1092 << rcEdit.Width() << " " << rcEdit.Heigh t() << " re\nW\nn\n"; 1093 pEdit->SetText((FX_LPCWSTR)pField->GetValue());
1093 } 1094 else
1094 1095 pEdit->SetText((FX_LPCWSTR)pField->GetOptionLabel(nCurSel));
1095 CPWL_Color crText = GetTextPWLColor(); 1096 }
1096 sBody << "BT\n" << CPWL_Utils::GetColorAppStream(crText) << sEdit << "ET\n" << "Q\nEMC\n"; 1097
1097 } 1098 CPDF_Rect rcContent = pEdit->GetContentRect();
1098 1099
1099 IFX_Edit::DelEdit(pEdit); 1100 CFX_ByteString sEdit =
1100 } 1101 CPWL_Utils::GetEditAppStream(pEdit, CPDF_Point(0.0f, 0.0f));
1101 1102 if (sEdit.GetLength() > 0) {
1102 sBody << CPWL_Utils::GetDropButtonAppStream(rcButton); 1103 sBody << "/Tx BMC\n"
1103 1104 << "q\n";
1104 CFX_ByteString sAP = GetBackgroundAppStream() + GetBorderAppStream() + s Lines.GetByteString() + sBody.GetByteString(); 1105 if (rcContent.Width() > rcEdit.Width() ||
1105 1106 rcContent.Height() > rcEdit.Height()) {
1106 WriteAppearance("N", GetRotatedRect(), GetMatrix(), sAP); 1107 sBody << rcEdit.left << " " << rcEdit.bottom << " " << rcEdit.Width()
1107 } 1108 << " " << rcEdit.Height() << " re\nW\nn\n";
1108 1109 }
1109 void CPDFSDK_Widget::ResetAppearance_ListBox() 1110
1110 { 1111 CPWL_Color crText = GetTextPWLColor();
1111 CPDF_FormControl* pControl = GetFormControl(); 1112 sBody << "BT\n" << CPWL_Utils::GetColorAppStream(crText) << sEdit
1112 ASSERT(pControl != NULL); 1113 << "ET\n"
1113 CPDF_FormField* pField = pControl->GetField(); 1114 << "Q\nEMC\n";
1114 ASSERT(pField != NULL); 1115 }
1115 1116
1116 CPDF_Rect rcClient = GetClientRect(); 1117 IFX_Edit::DelEdit(pEdit);
1117 1118 }
1118 CFX_ByteTextBuf sBody, sLines; 1119
1119 1120 sBody << CPWL_Utils::GetDropButtonAppStream(rcButton);
1120 if (IFX_Edit * pEdit = IFX_Edit::NewEdit()) 1121
1121 { 1122 CFX_ByteString sAP = GetBackgroundAppStream() + GetBorderAppStream() +
1122 pEdit->EnableRefresh(FALSE); 1123 sLines.GetByteString() + sBody.GetByteString();
1123 1124
1124 // ASSERT(this->m_pBaseForm != NULL); 1125 WriteAppearance("N", GetRotatedRect(), GetMatrix(), sAP);
1125 ASSERT(this->m_pInterForm != NULL); 1126 }
1126 CPDFSDK_Document* pDoc = m_pInterForm->GetDocument(); 1127
1127 ASSERT(pDoc != NULL); 1128 void CPDFSDK_Widget::ResetAppearance_ListBox() {
1128 CPDFDoc_Environment* pEnv = pDoc->GetEnv(); 1129 CPDF_FormControl* pControl = GetFormControl();
1129 1130 ASSERT(pControl != NULL);
1130 CBA_FontMap FontMap(this,pEnv->GetSysHandler()); 1131 CPDF_FormField* pField = pControl->GetField();
1131 FontMap.Initial(); 1132 ASSERT(pField != NULL);
1132 pEdit->SetFontMap(&FontMap); 1133
1133 1134 CPDF_Rect rcClient = GetClientRect();
1134 pEdit->SetPlateRect(CPDF_Rect(rcClient.left,0.0f,rcClient.right, 0.0f)); 1135
1135 1136 CFX_ByteTextBuf sBody, sLines;
1136 FX_FLOAT fFontSize = GetFontSize(); 1137
1137 1138 if (IFX_Edit* pEdit = IFX_Edit::NewEdit()) {
1138 if (IsFloatZero(fFontSize)) 1139 pEdit->EnableRefresh(FALSE);
1139 pEdit->SetFontSize(12.0f); 1140
1140 else 1141 // ASSERT(this->m_pBaseForm != NULL);
1141 pEdit->SetFontSize(fFontSize); 1142 ASSERT(this->m_pInterForm != NULL);
1142 1143 CPDFSDK_Document* pDoc = m_pInterForm->GetDocument();
1143 pEdit->Initialize(); 1144 ASSERT(pDoc != NULL);
1144 1145 CPDFDoc_Environment* pEnv = pDoc->GetEnv();
1145 CFX_ByteTextBuf sList; 1146
1146 FX_FLOAT fy = rcClient.top; 1147 CBA_FontMap FontMap(this, pEnv->GetSysHandler());
1147 1148 FontMap.Initial();
1148 FX_INT32 nTop = pField->GetTopVisibleIndex(); 1149 pEdit->SetFontMap(&FontMap);
1149 FX_INT32 nCount = pField->CountOptions(); 1150
1150 FX_INT32 nSelCount = pField->CountSelectedItems(); 1151 pEdit->SetPlateRect(CPDF_Rect(rcClient.left, 0.0f, rcClient.right, 0.0f));
1151 1152
1152 for (FX_INT32 i=nTop; i<nCount; i++) 1153 FX_FLOAT fFontSize = GetFontSize();
1153 { 1154
1154 FX_BOOL bSelected = FALSE; 1155 if (IsFloatZero(fFontSize))
1155 for (FX_INT32 j=0; j<nSelCount; j++) 1156 pEdit->SetFontSize(12.0f);
1156 { 1157 else
1157 if (pField->GetSelectedIndex(j) == i) 1158 pEdit->SetFontSize(fFontSize);
1158 { 1159
1159 bSelected = TRUE; 1160 pEdit->Initialize();
1160 break; 1161
1161 } 1162 CFX_ByteTextBuf sList;
1162 } 1163 FX_FLOAT fy = rcClient.top;
1163 1164
1164 pEdit->SetText((FX_LPCWSTR)pField->GetOptionLabel(i)); 1165 FX_INT32 nTop = pField->GetTopVisibleIndex();
1165 1166 FX_INT32 nCount = pField->CountOptions();
1166 CPDF_Rect rcContent = pEdit->GetContentRect(); 1167 FX_INT32 nSelCount = pField->CountSelectedItems();
1167 FX_FLOAT fItemHeight = rcContent.Height(); 1168
1168 1169 for (FX_INT32 i = nTop; i < nCount; i++) {
1169 if (bSelected) 1170 FX_BOOL bSelected = FALSE;
1170 { 1171 for (FX_INT32 j = 0; j < nSelCount; j++) {
1171 CPDF_Rect rcItem = CPDF_Rect(rcClient.left,fy-fI temHeight,rcClient.right,fy); 1172 if (pField->GetSelectedIndex(j) == i) {
1172 sList << "q\n" << CPWL_Utils::GetColorAppStream( CPWL_Color(COLORTYPE_RGB,0,51.0f/255.0f,113.0f/255.0f),TRUE) 1173 bSelected = TRUE;
1173 << rcItem.left << " " << rcItem.bottom < < " " << rcItem.Width() << " " << rcItem.Height() << " re f\n" << "Q\n"; 1174 break;
1174 1175 }
1175 sList << "BT\n" << CPWL_Utils::GetColorAppStream (CPWL_Color(COLORTYPE_GRAY,1),TRUE) << 1176 }
1176 CPWL_Utils::GetEditAppStream(pEdit,CPDF_ Point(0.0f,fy)) << "ET\n"; 1177
1177 } 1178 pEdit->SetText((FX_LPCWSTR)pField->GetOptionLabel(i));
1178 else 1179
1179 { 1180 CPDF_Rect rcContent = pEdit->GetContentRect();
1180 CPWL_Color crText = GetTextPWLColor(); 1181 FX_FLOAT fItemHeight = rcContent.Height();
1181 sList << "BT\n" << CPWL_Utils::GetColorAppStream (crText,TRUE) << 1182
1182 CPWL_Utils::GetEditAppStream(pEdit,CPDF_Point(0. 0f,fy)) << "ET\n"; 1183 if (bSelected) {
1183 } 1184 CPDF_Rect rcItem =
1184 1185 CPDF_Rect(rcClient.left, fy - fItemHeight, rcClient.right, fy);
1185 fy -= fItemHeight; 1186 sList << "q\n"
1186 } 1187 << CPWL_Utils::GetColorAppStream(
1187 1188 CPWL_Color(
1188 if (sList.GetSize() > 0) 1189 COLORTYPE_RGB, 0, 51.0f / 255.0f, 113.0f / 255.0f),
1189 { 1190 TRUE) << rcItem.left << " " << rcItem.bottom << " "
1190 sBody << "/Tx BMC\n" << "q\n" << rcClient.left << " " << rcClient.bottom << " " 1191 << rcItem.Width() << " " << rcItem.Height() << " re f\n"
1191 << rcClient.Width() << " " << rcClient.H eight() << " re\nW\nn\n"; 1192 << "Q\n";
1192 sBody << sList << "Q\nEMC\n"; 1193
1193 } 1194 sList << "BT\n" << CPWL_Utils::GetColorAppStream(
1194 1195 CPWL_Color(COLORTYPE_GRAY, 1), TRUE)
1195 IFX_Edit::DelEdit(pEdit); 1196 << CPWL_Utils::GetEditAppStream(pEdit, CPDF_Point(0.0f, fy))
1196 } 1197 << "ET\n";
1197 1198 } else {
1198 CFX_ByteString sAP = GetBackgroundAppStream() + GetBorderAppStream() + s Lines.GetByteString() + sBody.GetByteString(); 1199 CPWL_Color crText = GetTextPWLColor();
1199 1200 sList << "BT\n" << CPWL_Utils::GetColorAppStream(crText, TRUE)
1200 WriteAppearance("N", GetRotatedRect(), GetMatrix(), sAP); 1201 << CPWL_Utils::GetEditAppStream(pEdit, CPDF_Point(0.0f, fy))
1201 } 1202 << "ET\n";
1202 1203 }
1203 void CPDFSDK_Widget::ResetAppearance_TextField(FX_LPCWSTR sValue) 1204
1204 { 1205 fy -= fItemHeight;
1205 CPDF_FormControl* pControl = GetFormControl(); 1206 }
1206 ASSERT(pControl != NULL); 1207
1207 CPDF_FormField* pField = pControl->GetField(); 1208 if (sList.GetSize() > 0) {
1208 ASSERT(pField != NULL); 1209 sBody << "/Tx BMC\n"
1209 1210 << "q\n" << rcClient.left << " " << rcClient.bottom << " "
1210 CFX_ByteTextBuf sBody, sLines; 1211 << rcClient.Width() << " " << rcClient.Height() << " re\nW\nn\n";
1211 1212 sBody << sList << "Q\nEMC\n";
1212 if (IFX_Edit * pEdit = IFX_Edit::NewEdit()) 1213 }
1213 { 1214
1214 pEdit->EnableRefresh(FALSE); 1215 IFX_Edit::DelEdit(pEdit);
1215 1216 }
1216 // ASSERT(this->m_pBaseForm != NULL); 1217
1217 ASSERT(this->m_pInterForm != NULL); 1218 CFX_ByteString sAP = GetBackgroundAppStream() + GetBorderAppStream() +
1218 CPDFSDK_Document* pDoc = m_pInterForm->GetDocument(); 1219 sLines.GetByteString() + sBody.GetByteString();
1219 ASSERT(pDoc != NULL); 1220
1220 CPDFDoc_Environment* pEnv = pDoc->GetEnv(); 1221 WriteAppearance("N", GetRotatedRect(), GetMatrix(), sAP);
1221 1222 }
1222 CBA_FontMap FontMap(this,pEnv->GetSysHandler());//, ISystemHandl e::GetSystemHandler(m_pBaseForm->GetEnv())); 1223
1223 FontMap.Initial(); 1224 void CPDFSDK_Widget::ResetAppearance_TextField(FX_LPCWSTR sValue) {
1224 pEdit->SetFontMap(&FontMap); 1225 CPDF_FormControl* pControl = GetFormControl();
1225 1226 ASSERT(pControl != NULL);
1226 CPDF_Rect rcClient = GetClientRect(); 1227 CPDF_FormField* pField = pControl->GetField();
1227 pEdit->SetPlateRect(rcClient); 1228 ASSERT(pField != NULL);
1228 pEdit->SetAlignmentH(pControl->GetControlAlignment()); 1229
1229 1230 CFX_ByteTextBuf sBody, sLines;
1230 FX_DWORD dwFieldFlags = pField->GetFieldFlags(); 1231
1231 FX_BOOL bMultiLine = (dwFieldFlags >> 12) & 1; 1232 if (IFX_Edit* pEdit = IFX_Edit::NewEdit()) {
1232 1233 pEdit->EnableRefresh(FALSE);
1233 if (bMultiLine) 1234
1234 { 1235 // ASSERT(this->m_pBaseForm != NULL);
1235 pEdit->SetMultiLine(TRUE); 1236 ASSERT(this->m_pInterForm != NULL);
1236 pEdit->SetAutoReturn(TRUE); 1237 CPDFSDK_Document* pDoc = m_pInterForm->GetDocument();
1237 } 1238 ASSERT(pDoc != NULL);
1238 else 1239 CPDFDoc_Environment* pEnv = pDoc->GetEnv();
1239 { 1240
1240 pEdit->SetAlignmentV(1); 1241 CBA_FontMap FontMap(
1241 } 1242 this,
1242 1243 pEnv->GetSysHandler()); //,
1243 FX_WORD subWord = 0; 1244 //ISystemHandle::GetSystemHandler(m_pBaseForm-> GetEnv()));
1244 if ((dwFieldFlags >> 13) & 1) 1245 FontMap.Initial();
1245 { 1246 pEdit->SetFontMap(&FontMap);
1246 subWord = '*'; 1247
1247 pEdit->SetPasswordChar(subWord); 1248 CPDF_Rect rcClient = GetClientRect();
1248 } 1249 pEdit->SetPlateRect(rcClient);
1249 1250 pEdit->SetAlignmentH(pControl->GetControlAlignment());
1250 int nMaxLen = pField->GetMaxLen(); 1251
1251 FX_BOOL bCharArray = (dwFieldFlags >> 24) & 1; 1252 FX_DWORD dwFieldFlags = pField->GetFieldFlags();
1252 FX_FLOAT fFontSize = GetFontSize(); 1253 FX_BOOL bMultiLine = (dwFieldFlags >> 12) & 1;
1253 1254
1254 if (nMaxLen > 0) 1255 if (bMultiLine) {
1255 { 1256 pEdit->SetMultiLine(TRUE);
1256 if (bCharArray) 1257 pEdit->SetAutoReturn(TRUE);
1257 { 1258 } else {
1258 pEdit->SetCharArray(nMaxLen); 1259 pEdit->SetAlignmentV(1);
1259 1260 }
1260 if (IsFloatZero(fFontSize)) 1261
1261 { 1262 FX_WORD subWord = 0;
1262 fFontSize = CPWL_Edit::GetCharArrayAutoF ontSize(FontMap.GetPDFFont(0),rcClient,nMaxLen); 1263 if ((dwFieldFlags >> 13) & 1) {
1263 } 1264 subWord = '*';
1264 } 1265 pEdit->SetPasswordChar(subWord);
1265 else 1266 }
1266 { 1267
1267 if (sValue) 1268 int nMaxLen = pField->GetMaxLen();
1268 nMaxLen = wcslen((const wchar_t*)sValue) ; 1269 FX_BOOL bCharArray = (dwFieldFlags >> 24) & 1;
1269 pEdit->SetLimitChar(nMaxLen); 1270 FX_FLOAT fFontSize = GetFontSize();
1270 } 1271
1271 } 1272 if (nMaxLen > 0) {
1272 1273 if (bCharArray) {
1273 if (IsFloatZero(fFontSize)) 1274 pEdit->SetCharArray(nMaxLen);
1274 pEdit->SetAutoFontSize(TRUE); 1275
1275 else 1276 if (IsFloatZero(fFontSize)) {
1276 pEdit->SetFontSize(fFontSize); 1277 fFontSize = CPWL_Edit::GetCharArrayAutoFontSize(
1277 1278 FontMap.GetPDFFont(0), rcClient, nMaxLen);
1278 pEdit->Initialize(); 1279 }
1279 1280 } else {
1280 if (sValue) 1281 if (sValue)
1281 pEdit->SetText(sValue); 1282 nMaxLen = wcslen((const wchar_t*)sValue);
1282 else 1283 pEdit->SetLimitChar(nMaxLen);
1283 pEdit->SetText((FX_LPCWSTR)pField->GetValue()); 1284 }
1284 1285 }
1285 CPDF_Rect rcContent = pEdit->GetContentRect(); 1286
1286 1287 if (IsFloatZero(fFontSize))
1287 CFX_ByteString sEdit = CPWL_Utils::GetEditAppStream(pEdit,CPDF_P oint(0.0f,0.0f), 1288 pEdit->SetAutoFontSize(TRUE);
1288 NULL,!bCharArray,subWord ); 1289 else
1289 1290 pEdit->SetFontSize(fFontSize);
1290 if (sEdit.GetLength() > 0) 1291
1291 { 1292 pEdit->Initialize();
1292 sBody << "/Tx BMC\n" << "q\n"; 1293
1293 if (rcContent.Width() > rcClient.Width() || 1294 if (sValue)
1294 rcContent.Height() > rcClient.Height()) 1295 pEdit->SetText(sValue);
1295 { 1296 else
1296 sBody << rcClient.left << " " << rcClient.bottom << " " 1297 pEdit->SetText((FX_LPCWSTR)pField->GetValue());
1297 << rcClient.Width() << " " << rcClient.H eight() << " re\nW\nn\n"; 1298
1298 } 1299 CPDF_Rect rcContent = pEdit->GetContentRect();
1299 CPWL_Color crText = GetTextPWLColor(); 1300
1300 sBody << "BT\n" << CPWL_Utils::GetColorAppStream(crText) << sEdit << "ET\n" << "Q\nEMC\n"; 1301 CFX_ByteString sEdit = CPWL_Utils::GetEditAppStream(
1301 } 1302 pEdit, CPDF_Point(0.0f, 0.0f), NULL, !bCharArray, subWord);
1302 1303
1303 if (bCharArray) 1304 if (sEdit.GetLength() > 0) {
1304 { 1305 sBody << "/Tx BMC\n"
1305 switch (GetBorderStyle()) 1306 << "q\n";
1306 { 1307 if (rcContent.Width() > rcClient.Width() ||
1307 case BBS_SOLID: 1308 rcContent.Height() > rcClient.Height()) {
1308 { 1309 sBody << rcClient.left << " " << rcClient.bottom << " "
1309 CFX_ByteString sColor = CPWL_Utils::GetC olorAppStream(GetBorderPWLColor(),FALSE); 1310 << rcClient.Width() << " " << rcClient.Height() << " re\nW\nn\n";
1310 if (sColor.GetLength() > 0) 1311 }
1311 { 1312 CPWL_Color crText = GetTextPWLColor();
1312 sLines << "q\n" << GetBorderWidt h() << " w\n" 1313 sBody << "BT\n" << CPWL_Utils::GetColorAppStream(crText) << sEdit
1313 << CPWL_Utils::GetColorA ppStream(GetBorderPWLColor(),FALSE) << " 2 J 0 j\n"; 1314 << "ET\n"
1314 1315 << "Q\nEMC\n";
1315 for (FX_INT32 i=1;i<nMaxLen;i++) 1316 }
1316 { 1317
1317 sLines << rcClient.left + ((rcClient.right - rcClient.left)/nMaxLen)*i << " " 1318 if (bCharArray) {
1318 << rcClient.bott om << " m\n" 1319 switch (GetBorderStyle()) {
1319 << rcClient.left + ((rcClient.right - rcClient.left)/nMaxLen)*i << " " 1320 case BBS_SOLID: {
1320 << rcClient.top << " l S\n"; 1321 CFX_ByteString sColor =
1321 } 1322 CPWL_Utils::GetColorAppStream(GetBorderPWLColor(), FALSE);
1322 1323 if (sColor.GetLength() > 0) {
1323 sLines << "Q\n"; 1324 sLines << "q\n" << GetBorderWidth() << " w\n"
1324 } 1325 << CPWL_Utils::GetColorAppStream(GetBorderPWLColor(), FALSE)
1325 } 1326 << " 2 J 0 j\n";
1326 break; 1327
1327 case BBS_DASH: 1328 for (FX_INT32 i = 1; i < nMaxLen; i++) {
1328 { 1329 sLines << rcClient.left +
1329 CFX_ByteString sColor = CPWL_Utils::GetC olorAppStream(GetBorderPWLColor(),FALSE); 1330 ((rcClient.right - rcClient.left) / nMaxLen) * i
1330 if (sColor.GetLength() > 0) 1331 << " " << rcClient.bottom << " m\n"
1331 { 1332 << rcClient.left +
1332 CPWL_Dash dsBorder = CPWL_Dash(3 , 3, 0); 1333 ((rcClient.right - rcClient.left) / nMaxLen) * i
1333 1334 << " " << rcClient.top << " l S\n";
1334 sLines << "q\n" << GetBorderWidt h() << " w\n" 1335 }
1335 << CPWL_Utils::GetColorA ppStream(GetBorderPWLColor(),FALSE) 1336
1336 << "[" << dsBorder.nDash << " " 1337 sLines << "Q\n";
1337 << dsBorder.nGap << "] " 1338 }
1338 << dsBorder.nPhase << " d\n"; 1339 } break;
1339 1340 case BBS_DASH: {
1340 for (FX_INT32 i=1;i<nMaxLen;i++) 1341 CFX_ByteString sColor =
1341 { 1342 CPWL_Utils::GetColorAppStream(GetBorderPWLColor(), FALSE);
1342 sLines << rcClient.left + ((rcClient.right - rcClient.left)/nMaxLen)*i << " " 1343 if (sColor.GetLength() > 0) {
1343 << rcClient.bott om << " m\n" 1344 CPWL_Dash dsBorder = CPWL_Dash(3, 3, 0);
1344 << rcClient.left + ((rcClient.right - rcClient.left)/nMaxLen)*i << " " 1345
1345 << rcClient.top << " l S\n"; 1346 sLines << "q\n" << GetBorderWidth() << " w\n"
1346 } 1347 << CPWL_Utils::GetColorAppStream(GetBorderPWLColor(), FALSE)
1347 1348 << "[" << dsBorder.nDash << " " << dsBorder.nGap << "] "
1348 sLines << "Q\n"; 1349 << dsBorder.nPhase << " d\n";
1349 } 1350
1350 } 1351 for (FX_INT32 i = 1; i < nMaxLen; i++) {
1351 break; 1352 sLines << rcClient.left +
1352 } 1353 ((rcClient.right - rcClient.left) / nMaxLen) * i
1353 } 1354 << " " << rcClient.bottom << " m\n"
1354 1355 << rcClient.left +
1355 IFX_Edit::DelEdit(pEdit); 1356 ((rcClient.right - rcClient.left) / nMaxLen) * i
1356 } 1357 << " " << rcClient.top << " l S\n";
1357 1358 }
1358 CFX_ByteString sAP = GetBackgroundAppStream() + GetBorderAppStream() + s Lines.GetByteString() + sBody.GetByteString(); 1359
1359 WriteAppearance("N", GetRotatedRect(), GetMatrix(), sAP); 1360 sLines << "Q\n";
1360 } 1361 }
1361 1362 } break;
1362 CPDF_Rect CPDFSDK_Widget::GetClientRect() const 1363 }
1363 { 1364 }
1364 CPDF_Rect rcWindow = GetRotatedRect(); 1365
1365 FX_FLOAT fBorderWidth = (FX_FLOAT)GetBorderWidth(); 1366 IFX_Edit::DelEdit(pEdit);
1366 switch (GetBorderStyle()) 1367 }
1367 { 1368
1368 case BBS_BEVELED: 1369 CFX_ByteString sAP = GetBackgroundAppStream() + GetBorderAppStream() +
1369 case BBS_INSET: 1370 sLines.GetByteString() + sBody.GetByteString();
1370 fBorderWidth *= 2.0f; 1371 WriteAppearance("N", GetRotatedRect(), GetMatrix(), sAP);
1371 break; 1372 }
1372 } 1373
1373 1374 CPDF_Rect CPDFSDK_Widget::GetClientRect() const {
1374 return CPWL_Utils::DeflateRect(rcWindow, fBorderWidth); 1375 CPDF_Rect rcWindow = GetRotatedRect();
1375 } 1376 FX_FLOAT fBorderWidth = (FX_FLOAT)GetBorderWidth();
1376 1377 switch (GetBorderStyle()) {
1377 CPDF_Rect CPDFSDK_Widget::GetRotatedRect() const 1378 case BBS_BEVELED:
1378 { 1379 case BBS_INSET:
1379 CPDF_Rect rectAnnot = GetRect(); 1380 fBorderWidth *= 2.0f;
1380 FX_FLOAT fWidth = rectAnnot.right - rectAnnot.left; 1381 break;
1381 FX_FLOAT fHeight = rectAnnot.top - rectAnnot.bottom; 1382 }
1382 1383
1383 CPDF_FormControl* pControl = GetFormControl(); 1384 return CPWL_Utils::DeflateRect(rcWindow, fBorderWidth);
1384 ASSERT(pControl != NULL); 1385 }
1385 1386
1386 CPDF_Rect rcPDFWindow; 1387 CPDF_Rect CPDFSDK_Widget::GetRotatedRect() const {
1387 switch(abs(pControl->GetRotation() % 360)) 1388 CPDF_Rect rectAnnot = GetRect();
1388 { 1389 FX_FLOAT fWidth = rectAnnot.right - rectAnnot.left;
1389 case 0: 1390 FX_FLOAT fHeight = rectAnnot.top - rectAnnot.bottom;
1390 case 180: 1391
1391 default: 1392 CPDF_FormControl* pControl = GetFormControl();
1392 rcPDFWindow = CPDF_Rect(0, 0, fWidth, fHeight); 1393 ASSERT(pControl != NULL);
1393 break; 1394
1394 case 90: 1395 CPDF_Rect rcPDFWindow;
1395 case 270: 1396 switch (abs(pControl->GetRotation() % 360)) {
1396 rcPDFWindow = CPDF_Rect(0, 0, fHeight, fWidth); 1397 case 0:
1397 break; 1398 case 180:
1398 } 1399 default:
1399 1400 rcPDFWindow = CPDF_Rect(0, 0, fWidth, fHeight);
1400 return rcPDFWindow; 1401 break;
1401 } 1402 case 90:
1402 1403 case 270:
1403 CFX_ByteString CPDFSDK_Widget::GetBackgroundAppStream() const 1404 rcPDFWindow = CPDF_Rect(0, 0, fHeight, fWidth);
1404 { 1405 break;
1405 CPWL_Color crBackground = GetFillPWLColor(); 1406 }
1406 if (crBackground.nColorType != COLORTYPE_TRANSPARENT) 1407
1407 return CPWL_Utils::GetRectFillAppStream(GetRotatedRect(), crBack ground); 1408 return rcPDFWindow;
1408 else 1409 }
1409 return ""; 1410
1410 } 1411 CFX_ByteString CPDFSDK_Widget::GetBackgroundAppStream() const {
1411 1412 CPWL_Color crBackground = GetFillPWLColor();
1412 CFX_ByteString CPDFSDK_Widget::GetBorderAppStream() const 1413 if (crBackground.nColorType != COLORTYPE_TRANSPARENT)
1413 { 1414 return CPWL_Utils::GetRectFillAppStream(GetRotatedRect(), crBackground);
1414 CPDF_Rect rcWindow = GetRotatedRect(); 1415 else
1415 CPWL_Color crBorder = GetBorderPWLColor(); 1416 return "";
1416 CPWL_Color crBackground = GetFillPWLColor(); 1417 }
1417 CPWL_Color crLeftTop, crRightBottom; 1418
1418 1419 CFX_ByteString CPDFSDK_Widget::GetBorderAppStream() const {
1419 FX_FLOAT fBorderWidth = (FX_FLOAT)GetBorderWidth(); 1420 CPDF_Rect rcWindow = GetRotatedRect();
1420 FX_INT32 nBorderStyle = 0; 1421 CPWL_Color crBorder = GetBorderPWLColor();
1421 CPWL_Dash dsBorder(3,0,0); 1422 CPWL_Color crBackground = GetFillPWLColor();
1422 1423 CPWL_Color crLeftTop, crRightBottom;
1423 switch (GetBorderStyle()) 1424
1424 { 1425 FX_FLOAT fBorderWidth = (FX_FLOAT)GetBorderWidth();
1425 case BBS_DASH: 1426 FX_INT32 nBorderStyle = 0;
1426 nBorderStyle = PBS_DASH; 1427 CPWL_Dash dsBorder(3, 0, 0);
1427 dsBorder = CPWL_Dash(3, 3, 0); 1428
1428 break; 1429 switch (GetBorderStyle()) {
1429 case BBS_BEVELED: 1430 case BBS_DASH:
1430 nBorderStyle = PBS_BEVELED; 1431 nBorderStyle = PBS_DASH;
1431 fBorderWidth *= 2; 1432 dsBorder = CPWL_Dash(3, 3, 0);
1432 crLeftTop = CPWL_Color(COLORTYPE_GRAY, 1); 1433 break;
1433 crRightBottom = CPWL_Utils::DevideColor(crBackground, 2); 1434 case BBS_BEVELED:
1434 break; 1435 nBorderStyle = PBS_BEVELED;
1435 case BBS_INSET: 1436 fBorderWidth *= 2;
1436 nBorderStyle = PBS_INSET; 1437 crLeftTop = CPWL_Color(COLORTYPE_GRAY, 1);
1437 fBorderWidth *= 2; 1438 crRightBottom = CPWL_Utils::DevideColor(crBackground, 2);
1438 crLeftTop = CPWL_Color(COLORTYPE_GRAY, 0.5); 1439 break;
1439 crRightBottom = CPWL_Color(COLORTYPE_GRAY, 0.75); 1440 case BBS_INSET:
1440 break; 1441 nBorderStyle = PBS_INSET;
1441 case BBS_UNDERLINE: 1442 fBorderWidth *= 2;
1442 nBorderStyle = PBS_UNDERLINED; 1443 crLeftTop = CPWL_Color(COLORTYPE_GRAY, 0.5);
1443 break; 1444 crRightBottom = CPWL_Color(COLORTYPE_GRAY, 0.75);
1444 default: 1445 break;
1445 nBorderStyle = PBS_SOLID; 1446 case BBS_UNDERLINE:
1446 break; 1447 nBorderStyle = PBS_UNDERLINED;
1447 } 1448 break;
1448 1449 default:
1449 return CPWL_Utils::GetBorderAppStream(rcWindow, fBorderWidth, crBorder, crLeftTop, 1450 nBorderStyle = PBS_SOLID;
1450 crRightBottom, nBorderStyle, dsBorder); 1451 break;
1451 } 1452 }
1452 1453
1453 CPDF_Matrix CPDFSDK_Widget::GetMatrix() const 1454 return CPWL_Utils::GetBorderAppStream(rcWindow,
1454 { 1455 fBorderWidth,
1455 CPDF_Matrix mt; 1456 crBorder,
1456 CPDF_FormControl* pControl = GetFormControl(); 1457 crLeftTop,
1457 ASSERT(pControl != NULL); 1458 crRightBottom,
1458 1459 nBorderStyle,
1459 CPDF_Rect rcAnnot = GetRect(); 1460 dsBorder);
1460 FX_FLOAT fWidth = rcAnnot.right - rcAnnot.left; 1461 }
1461 FX_FLOAT fHeight = rcAnnot.top - rcAnnot.bottom; 1462
1462 1463 CPDF_Matrix CPDFSDK_Widget::GetMatrix() const {
1463 1464 CPDF_Matrix mt;
1464 1465 CPDF_FormControl* pControl = GetFormControl();
1465 switch (abs(pControl->GetRotation() % 360)) 1466 ASSERT(pControl != NULL);
1466 { 1467
1467 case 0: 1468 CPDF_Rect rcAnnot = GetRect();
1468 default: 1469 FX_FLOAT fWidth = rcAnnot.right - rcAnnot.left;
1469 mt = CPDF_Matrix(1, 0, 0, 1, 0, 0); 1470 FX_FLOAT fHeight = rcAnnot.top - rcAnnot.bottom;
1470 break; 1471
1471 case 90: 1472 switch (abs(pControl->GetRotation() % 360)) {
1472 mt = CPDF_Matrix(0, 1, -1, 0, fWidth, 0); 1473 case 0:
1473 break; 1474 default:
1474 case 180: 1475 mt = CPDF_Matrix(1, 0, 0, 1, 0, 0);
1475 mt = CPDF_Matrix(-1, 0, 0, -1, fWidth, fHeight); 1476 break;
1476 break; 1477 case 90:
1477 case 270: 1478 mt = CPDF_Matrix(0, 1, -1, 0, fWidth, 0);
1478 mt = CPDF_Matrix(0, -1, 1, 0, 0, fHeight); 1479 break;
1479 break; 1480 case 180:
1480 } 1481 mt = CPDF_Matrix(-1, 0, 0, -1, fWidth, fHeight);
1481 1482 break;
1482 return mt; 1483 case 270:
1483 } 1484 mt = CPDF_Matrix(0, -1, 1, 0, 0, fHeight);
1484 1485 break;
1485 CPWL_Color CPDFSDK_Widget::GetTextPWLColor() const 1486 }
1486 { 1487
1487 CPWL_Color crText = CPWL_Color(COLORTYPE_GRAY, 0); 1488 return mt;
1488 1489 }
1489 CPDF_FormControl* pFormCtrl = GetFormControl(); 1490
1490 ASSERT(pFormCtrl != NULL); 1491 CPWL_Color CPDFSDK_Widget::GetTextPWLColor() const {
1491 1492 CPWL_Color crText = CPWL_Color(COLORTYPE_GRAY, 0);
1492 CPDF_DefaultAppearance da = pFormCtrl->GetDefaultAppearance(); 1493
1493 if (da.HasColor()) 1494 CPDF_FormControl* pFormCtrl = GetFormControl();
1494 { 1495 ASSERT(pFormCtrl != NULL);
1495 FX_INT32 iColorType; 1496
1496 FX_FLOAT fc[4]; 1497 CPDF_DefaultAppearance da = pFormCtrl->GetDefaultAppearance();
1497 da.GetColor(iColorType, fc); 1498 if (da.HasColor()) {
1498 crText = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3]); 1499 FX_INT32 iColorType;
1499 } 1500 FX_FLOAT fc[4];
1500 1501 da.GetColor(iColorType, fc);
1501 return crText; 1502 crText = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3]);
1502 } 1503 }
1503 1504
1504 CPWL_Color CPDFSDK_Widget::GetBorderPWLColor() const 1505 return crText;
1505 { 1506 }
1506 CPWL_Color crBorder; 1507
1507 1508 CPWL_Color CPDFSDK_Widget::GetBorderPWLColor() const {
1508 CPDF_FormControl* pFormCtrl = GetFormControl(); 1509 CPWL_Color crBorder;
1509 ASSERT(pFormCtrl != NULL); 1510
1510 1511 CPDF_FormControl* pFormCtrl = GetFormControl();
1511 FX_INT32 iColorType; 1512 ASSERT(pFormCtrl != NULL);
1512 FX_FLOAT fc[4]; 1513
1513 pFormCtrl->GetOriginalBorderColor(iColorType, fc); 1514 FX_INT32 iColorType;
1514 if (iColorType > 0) 1515 FX_FLOAT fc[4];
1515 crBorder = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3]); 1516 pFormCtrl->GetOriginalBorderColor(iColorType, fc);
1516 1517 if (iColorType > 0)
1517 return crBorder; 1518 crBorder = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3]);
1518 } 1519
1519 1520 return crBorder;
1520 CPWL_Color CPDFSDK_Widget::GetFillPWLColor() const 1521 }
1521 { 1522
1522 CPWL_Color crFill; 1523 CPWL_Color CPDFSDK_Widget::GetFillPWLColor() const {
1523 1524 CPWL_Color crFill;
1524 CPDF_FormControl* pFormCtrl = GetFormControl(); 1525
1525 ASSERT(pFormCtrl != NULL); 1526 CPDF_FormControl* pFormCtrl = GetFormControl();
1526 1527 ASSERT(pFormCtrl != NULL);
1527 FX_INT32 iColorType; 1528
1528 FX_FLOAT fc[4]; 1529 FX_INT32 iColorType;
1529 pFormCtrl->GetOriginalBackgroundColor(iColorType, fc); 1530 FX_FLOAT fc[4];
1530 if (iColorType > 0) 1531 pFormCtrl->GetOriginalBackgroundColor(iColorType, fc);
1531 crFill = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3]); 1532 if (iColorType > 0)
1532 1533 crFill = CPWL_Color(iColorType, fc[0], fc[1], fc[2], fc[3]);
1533 return crFill; 1534
1534 } 1535 return crFill;
1535 1536 }
1536 void CPDFSDK_Widget::AddImageToAppearance(const CFX_ByteString& sAPType, CPDF_St ream* pImage) 1537
1537 { 1538 void CPDFSDK_Widget::AddImageToAppearance(const CFX_ByteString& sAPType,
1538 ASSERT(pImage != NULL); 1539 CPDF_Stream* pImage) {
1539 1540 ASSERT(pImage != NULL);
1540 ASSERT(m_pAnnot != NULL); 1541
1541 ASSERT(m_pAnnot->m_pAnnotDict != NULL); 1542 ASSERT(m_pAnnot != NULL);
1542 1543 ASSERT(m_pAnnot->m_pAnnotDict != NULL);
1543 CPDF_Document* pDoc = m_pPageView->GetPDFDocument();//pDocument->GetDocu ment(); 1544
1544 ASSERT(pDoc != NULL); 1545 CPDF_Document* pDoc =
1545 1546 m_pPageView->GetPDFDocument(); // pDocument->GetDocument();
1546 CPDF_Dictionary* pAPDict = m_pAnnot->m_pAnnotDict->GetDict("AP"); 1547 ASSERT(pDoc != NULL);
1547 ASSERT(pAPDict != NULL); 1548
1548 1549 CPDF_Dictionary* pAPDict = m_pAnnot->m_pAnnotDict->GetDict("AP");
1549 CPDF_Stream* pStream = pAPDict->GetStream(sAPType); 1550 ASSERT(pAPDict != NULL);
1550 ASSERT(pStream != NULL); 1551
1551 1552 CPDF_Stream* pStream = pAPDict->GetStream(sAPType);
1552 CPDF_Dictionary* pStreamDict = pStream->GetDict(); 1553 ASSERT(pStream != NULL);
1553 ASSERT(pStreamDict != NULL); 1554
1554 1555 CPDF_Dictionary* pStreamDict = pStream->GetDict();
1555 CFX_ByteString sImageAlias = "IMG"; 1556 ASSERT(pStreamDict != NULL);
1556 1557
1557 if (CPDF_Dictionary* pImageDict = pImage->GetDict()) 1558 CFX_ByteString sImageAlias = "IMG";
1558 { 1559
1559 sImageAlias = pImageDict->GetString("Name"); 1560 if (CPDF_Dictionary* pImageDict = pImage->GetDict()) {
1560 if (sImageAlias.IsEmpty()) 1561 sImageAlias = pImageDict->GetString("Name");
1561 sImageAlias = "IMG"; 1562 if (sImageAlias.IsEmpty())
1562 } 1563 sImageAlias = "IMG";
1563 1564 }
1564 CPDF_Dictionary* pStreamResList = pStreamDict->GetDict("Resources"); 1565
1565 if (!pStreamResList) 1566 CPDF_Dictionary* pStreamResList = pStreamDict->GetDict("Resources");
1566 { 1567 if (!pStreamResList) {
1567 pStreamResList = FX_NEW CPDF_Dictionary(); 1568 pStreamResList = FX_NEW CPDF_Dictionary();
1568 pStreamDict->SetAt("Resources", pStreamResList); 1569 pStreamDict->SetAt("Resources", pStreamResList);
1569 } 1570 }
1570 1571
1571 if (pStreamResList) 1572 if (pStreamResList) {
1572 { 1573 CPDF_Dictionary* pXObject = FX_NEW CPDF_Dictionary;
1573 CPDF_Dictionary* pXObject = FX_NEW CPDF_Dictionary; 1574 pXObject->SetAtReference(sImageAlias, pDoc, pImage);
1574 pXObject->SetAtReference(sImageAlias, pDoc, pImage); 1575 pStreamResList->SetAt("XObject", pXObject);
1575 pStreamResList->SetAt("XObject", pXObject); 1576 }
1576 } 1577 }
1577 } 1578
1578 1579 void CPDFSDK_Widget::RemoveAppearance(const CFX_ByteString& sAPType) {
1579 void CPDFSDK_Widget::RemoveAppearance(const CFX_ByteString& sAPType) 1580 ASSERT(m_pAnnot != NULL);
1580 { 1581 ASSERT(m_pAnnot->m_pAnnotDict != NULL);
1581 ASSERT(m_pAnnot != NULL); 1582
1582 ASSERT(m_pAnnot->m_pAnnotDict != NULL); 1583 if (CPDF_Dictionary* pAPDict = m_pAnnot->m_pAnnotDict->GetDict("AP")) {
1583 1584 pAPDict->RemoveAt(sAPType);
1584 if (CPDF_Dictionary* pAPDict = m_pAnnot->m_pAnnotDict->GetDict("AP")) 1585 }
1585 { 1586 }
1586 pAPDict->RemoveAt(sAPType); 1587
1587 } 1588 FX_BOOL CPDFSDK_Widget::OnAAction(CPDF_AAction::AActionType type,
1588 } 1589 PDFSDK_FieldAction& data,
1589 1590 CPDFSDK_PageView* pPageView) {
1590 FX_BOOL CPDFSDK_Widget::OnAAction(CPDF_AAction::AActionType type, PDFSDK_FieldAc tion& data, CPDFSDK_PageView* pPageView) 1591 CPDF_Action action = GetAAction(type);
1591 { 1592
1592 CPDF_Action action = GetAAction(type); 1593 if (action && action.GetType() != CPDF_Action::Unknown) {
1593 1594 CPDFSDK_Document* pDocument = pPageView->GetSDKDocument();
1594 if (action && action.GetType() != CPDF_Action::Unknown) 1595 ASSERT(pDocument != NULL);
1595 { 1596
1596 CPDFSDK_Document* pDocument = pPageView->GetSDKDocument(); 1597 CPDFDoc_Environment* pEnv = pDocument->GetEnv();
1597 ASSERT(pDocument != NULL); 1598 ASSERT(pEnv != NULL);
1598 1599
1599 CPDFDoc_Environment* pEnv = pDocument->GetEnv(); 1600 CPDFSDK_ActionHandler* pActionHandler =
1600 ASSERT(pEnv != NULL); 1601 pEnv->GetActionHander(); /*(CPDFSDK_ActionHandler*)pApp->GetActionHandle r();*/
1601 1602 ASSERT(pActionHandler != NULL);
1602 CPDFSDK_ActionHandler* pActionHandler = pEnv->GetActionHander(); /*(CPDFSDK_ActionHandler*)pApp->GetActionHandler();*/ 1603
1603 ASSERT(pActionHandler != NULL); 1604 return pActionHandler->DoAction_Field(
1604 1605 action, type, pDocument, GetFormField(), data);
1605 return pActionHandler->DoAction_Field(action, type, pDocument, G etFormField(), data); 1606 }
1606 } 1607
1607 1608 return FALSE;
1608 return FALSE; 1609 }
1609 } 1610
1610 1611 CPDF_Action CPDFSDK_Widget::GetAAction(CPDF_AAction::AActionType eAAT) {
1611 CPDF_Action CPDFSDK_Widget::GetAAction(CPDF_AAction::AActionType eAAT) 1612 switch (eAAT) {
1612 { 1613 case CPDF_AAction::CursorEnter:
1613 switch (eAAT) 1614 case CPDF_AAction::CursorExit:
1614 { 1615 case CPDF_AAction::ButtonDown:
1615 case CPDF_AAction::CursorEnter: 1616 case CPDF_AAction::ButtonUp:
1616 case CPDF_AAction::CursorExit: 1617 case CPDF_AAction::GetFocus:
1617 case CPDF_AAction::ButtonDown: 1618 case CPDF_AAction::LoseFocus:
1618 case CPDF_AAction::ButtonUp: 1619 case CPDF_AAction::PageOpen:
1619 case CPDF_AAction::GetFocus: 1620 case CPDF_AAction::PageClose:
1620 case CPDF_AAction::LoseFocus: 1621 case CPDF_AAction::PageVisible:
1621 case CPDF_AAction::PageOpen: 1622 case CPDF_AAction::PageInvisible:
1622 case CPDF_AAction::PageClose: 1623 return CPDFSDK_Annot::GetAAction(eAAT);
1623 case CPDF_AAction::PageVisible: 1624 case CPDF_AAction::KeyStroke:
1624 case CPDF_AAction::PageInvisible: 1625 case CPDF_AAction::Format:
1625 return CPDFSDK_Annot::GetAAction(eAAT); 1626 case CPDF_AAction::Validate:
1626 case CPDF_AAction::KeyStroke: 1627 case CPDF_AAction::Calculate: {
1627 case CPDF_AAction::Format: 1628 CPDF_FormField* pField = this->GetFormField();
1628 case CPDF_AAction::Validate: 1629 ASSERT(pField != NULL);
1629 case CPDF_AAction::Calculate: 1630
1630 { 1631 if (CPDF_AAction aa = pField->GetAdditionalAction())
1631 CPDF_FormField* pField = this->GetFormField(); 1632 return aa.GetAction(eAAT);
1632 ASSERT(pField != NULL); 1633 else
1633 1634 return CPDFSDK_Annot::GetAAction(eAAT);
1634 if (CPDF_AAction aa = pField->GetAdditionalAction()) 1635 }
1635 return aa.GetAction(eAAT); 1636 default:
1636 else 1637 return NULL;
1637 return CPDFSDK_Annot::GetAAction(eAAT); 1638 }
1638 } 1639
1639 default: 1640 return NULL;
1640 return NULL; 1641 }
1641 } 1642
1642 1643 CFX_WideString CPDFSDK_Widget::GetAlternateName() const {
1643 return NULL; 1644 CPDF_FormField* pFormField = GetFormField();
1644 } 1645 ASSERT(pFormField != NULL);
1645 1646
1646 1647 return pFormField->GetAlternateName();
1647 CFX_WideString CPDFSDK_Widget::GetAlternateName() const 1648 }
1648 { 1649
1649 CPDF_FormField* pFormField = GetFormField(); 1650 FX_INT32 CPDFSDK_Widget::GetAppearanceAge() const {
1650 ASSERT(pFormField != NULL); 1651 return m_nAppAge;
1651 1652 }
1652 return pFormField->GetAlternateName(); 1653
1653 } 1654 FX_INT32 CPDFSDK_Widget::GetValueAge() const {
1654 1655 return m_nValueAge;
1655 FX_INT32 CPDFSDK_Widget::GetAppearanceAge() const 1656 }
1656 { 1657
1657 return m_nAppAge; 1658 FX_BOOL CPDFSDK_Widget::HitTest(FX_FLOAT pageX, FX_FLOAT pageY) {
1658 } 1659 CPDF_Annot* pAnnot = GetPDFAnnot();
1659 1660 CFX_FloatRect annotRect;
1660 FX_INT32 CPDFSDK_Widget::GetValueAge() const 1661 pAnnot->GetRect(annotRect);
1661 { 1662 if (annotRect.Contains(pageX, pageY)) {
1662 return m_nValueAge; 1663 if (!IsVisible())
1663 } 1664 return FALSE;
1664 1665
1665 1666 int nFieldFlags = GetFieldFlags();
1666 FX_BOOL CPDFSDK_Widget::HitTest(FX_FLOAT pageX, FX_FLOAT pageY) 1667 if ((nFieldFlags & FIELDFLAG_READONLY) == FIELDFLAG_READONLY)
1667 { 1668 return FALSE;
1668 CPDF_Annot* pAnnot = GetPDFAnnot(); 1669
1669 CFX_FloatRect annotRect; 1670 return TRUE;
1670 pAnnot->GetRect(annotRect); 1671 }
1671 if(annotRect.Contains(pageX, pageY)) 1672 return FALSE;
1672 {
1673 if (!IsVisible()) return FALSE;
1674
1675 int nFieldFlags = GetFieldFlags();
1676 if ((nFieldFlags & FIELDFLAG_READONLY) == FIELDFLAG_READONLY)
1677 return FALSE;
1678
1679 return TRUE;
1680 }
1681 return FALSE;
1682 } 1673 }
1683 1674
1684 CPDFSDK_InterForm::CPDFSDK_InterForm(CPDFSDK_Document* pDocument) 1675 CPDFSDK_InterForm::CPDFSDK_InterForm(CPDFSDK_Document* pDocument)
1685 » :m_pDocument(pDocument), 1676 : m_pDocument(pDocument),
1686 » m_pInterForm(NULL), 1677 m_pInterForm(NULL),
1687 » m_bCalculate(TRUE), 1678 m_bCalculate(TRUE),
1688 » m_bBusy(FALSE) 1679 m_bBusy(FALSE) {
1689 { 1680 ASSERT(m_pDocument != NULL);
1690 » ASSERT(m_pDocument != NULL); 1681 m_pInterForm = new CPDF_InterForm(m_pDocument->GetDocument(), FALSE);
1691 » m_pInterForm = new CPDF_InterForm(m_pDocument->GetDocument(), FALSE); 1682 ASSERT(m_pInterForm != NULL);
1692 » ASSERT(m_pInterForm != NULL); 1683 m_pInterForm->SetFormNotify(this);
1693 » m_pInterForm->SetFormNotify(this); 1684
1694 1685 for (int i = 0; i < 6; i++)
1695 » for(int i=0; i<6; i++) 1686 m_bNeedHightlight[i] = FALSE;
1696 » » m_bNeedHightlight[i] = FALSE; 1687 m_iHighlightAlpha = 0;
1697 » m_iHighlightAlpha = 0; 1688 }
1698 } 1689
1699 1690 CPDFSDK_InterForm::~CPDFSDK_InterForm() {
1700 CPDFSDK_InterForm::~CPDFSDK_InterForm() 1691 ASSERT(m_pInterForm != NULL);
1701 { 1692 delete m_pInterForm;
1702 » ASSERT(m_pInterForm != NULL); 1693 m_pInterForm = NULL;
1703 » delete m_pInterForm; 1694
1704 » m_pInterForm = NULL; 1695 m_Map.RemoveAll();
1705 1696 }
1706 » m_Map.RemoveAll(); 1697
1707 } 1698 void CPDFSDK_InterForm::Destroy() {
1708 1699 delete this;
1709 void CPDFSDK_InterForm::Destroy() 1700 }
1710 { 1701
1711 » delete this; 1702 CPDF_InterForm* CPDFSDK_InterForm::GetInterForm() {
1712 } 1703 return m_pInterForm;
1713 1704 }
1714 CPDF_InterForm* CPDFSDK_InterForm::GetInterForm() 1705
1715 { 1706 CPDFSDK_Document* CPDFSDK_InterForm::GetDocument() {
1716 » return m_pInterForm; 1707 return m_pDocument;
1717 } 1708 }
1718 1709
1719 CPDFSDK_Document* CPDFSDK_InterForm::GetDocument() 1710 FX_BOOL CPDFSDK_InterForm::HighlightWidgets() {
1720 { 1711 return FALSE;
1721 » return m_pDocument; 1712 }
1722 } 1713
1723 1714 CPDFSDK_Widget* CPDFSDK_InterForm::GetSibling(CPDFSDK_Widget* pWidget,
1724 FX_BOOL CPDFSDK_InterForm::HighlightWidgets() 1715 FX_BOOL bNext) const {
1725 { 1716 ASSERT(pWidget != NULL);
1726 » return FALSE; 1717
1727 } 1718 CBA_AnnotIterator* pIterator =
1728 1719 new CBA_AnnotIterator(pWidget->GetPageView(), "Widget", "");
1729 CPDFSDK_Widget* CPDFSDK_InterForm::GetSibling(CPDFSDK_Widget* pWidget, FX_BOOL b Next) const 1720 ASSERT(pIterator != NULL);
1730 { 1721
1731 » ASSERT(pWidget != NULL); 1722 CPDFSDK_Widget* pRet = NULL;
1732 1723
1733 » CBA_AnnotIterator* pIterator = new CBA_AnnotIterator(pWidget->GetPageVie w(), "Widget", ""); 1724 if (bNext)
1734 » ASSERT(pIterator != NULL); 1725 pRet = (CPDFSDK_Widget*)pIterator->GetNextAnnot(pWidget);
1735 1726 else
1736 » CPDFSDK_Widget* pRet = NULL; 1727 pRet = (CPDFSDK_Widget*)pIterator->GetPrevAnnot(pWidget);
1737 1728
1738 » if (bNext) 1729 pIterator->Release();
1739 » » pRet = (CPDFSDK_Widget*)pIterator->GetNextAnnot(pWidget); 1730
1740 » else 1731 return pRet;
1741 » » pRet = (CPDFSDK_Widget*)pIterator->GetPrevAnnot(pWidget); 1732 }
1742 1733
1743 » pIterator->Release(); 1734 CPDFSDK_Widget* CPDFSDK_InterForm::GetWidget(CPDF_FormControl* pControl) const {
1744 » 1735 if (!pControl || !m_pInterForm)
1745 » return pRet; 1736 return NULL;
1746 1737
1747 } 1738 CPDFSDK_Widget* pWidget = NULL;
1748 1739 m_Map.Lookup(pControl, pWidget);
1749 CPDFSDK_Widget*»CPDFSDK_InterForm::GetWidget(CPDF_FormControl* pControl) const 1740
1750 { 1741 if (pWidget)
1751 » if(!pControl || !m_pInterForm) return NULL; 1742 return pWidget;
1752 » 1743
1753 » CPDFSDK_Widget* pWidget = NULL; 1744 CPDF_Dictionary* pControlDict = pControl->GetWidget();
1754 » m_Map.Lookup(pControl, pWidget); 1745 ASSERT(pControlDict != NULL);
1755 1746
1756 » if (pWidget) return pWidget; 1747 ASSERT(m_pDocument != NULL);
1757 1748 CPDF_Document* pDocument = m_pDocument->GetDocument();
1758 » CPDF_Dictionary* pControlDict = pControl->GetWidget(); 1749
1759 » ASSERT(pControlDict != NULL); 1750 CPDFSDK_PageView* pPage = NULL;
1760 1751
1761 » ASSERT(m_pDocument != NULL); 1752 if (CPDF_Dictionary* pPageDict = pControlDict->GetDict("P")) {
1762 » CPDF_Document* pDocument = m_pDocument->GetDocument(); 1753 int nPageIndex = pDocument->GetPageIndex(pPageDict->GetObjNum());
1763 1754 if (nPageIndex >= 0) {
1764 » CPDFSDK_PageView* pPage = NULL; 1755 pPage = m_pDocument->GetPageView(nPageIndex);
1765 1756 }
1766 » if (CPDF_Dictionary* pPageDict = pControlDict->GetDict("P")) 1757 }
1767 » { 1758
1768 » » int nPageIndex = pDocument->GetPageIndex(pPageDict->GetObjNum()) ; 1759 if (!pPage) {
1769 » » if (nPageIndex >= 0) 1760 int nPageIndex = GetPageIndexByAnnotDict(pDocument, pControlDict);
1770 » » { 1761 if (nPageIndex >= 0) {
1771 » » » pPage = m_pDocument->GetPageView(nPageIndex); 1762 pPage = m_pDocument->GetPageView(nPageIndex);
1772 » » } 1763 }
1773 » } 1764 }
1774 1765
1775 » if (!pPage) 1766 if (pPage)
1776 » { 1767 return (CPDFSDK_Widget*)pPage->GetAnnotByDict(pControlDict);
1777 » » int nPageIndex = GetPageIndexByAnnotDict(pDocument, pControlDict ); 1768
1778 » » if (nPageIndex >= 0) 1769 return NULL;
1779 » » { 1770 }
1780 » » » pPage = m_pDocument->GetPageView(nPageIndex); 1771
1781 » » } 1772 void CPDFSDK_InterForm::GetWidgets(const CFX_WideString& sFieldName,
1782 » } 1773 CFX_PtrArray& widgets) {
1783 1774 ASSERT(m_pInterForm != NULL);
1784 » if (pPage) 1775
1785 » » return (CPDFSDK_Widget*)pPage->GetAnnotByDict(pControlDict); 1776 for (int i = 0, sz = m_pInterForm->CountFields(sFieldName); i < sz; i++) {
1786 1777 CPDF_FormField* pFormField = m_pInterForm->GetField(i, sFieldName);
1787 » return NULL; 1778 ASSERT(pFormField != NULL);
1788 } 1779
1789 1780 GetWidgets(pFormField, widgets);
1790 void CPDFSDK_InterForm::GetWidgets(const CFX_WideString& sFieldName, CFX_PtrArra y& widgets) 1781 }
1791 { 1782 }
1792 » ASSERT(m_pInterForm != NULL); 1783
1793 1784 void CPDFSDK_InterForm::GetWidgets(CPDF_FormField* pField,
1794 » for (int i=0,sz=m_pInterForm->CountFields(sFieldName); i<sz; i++) 1785 CFX_PtrArray& widgets) {
1795 » { 1786 ASSERT(pField != NULL);
1796 » » CPDF_FormField* pFormField = m_pInterForm->GetField(i, sFieldNam e); 1787
1797 » » ASSERT(pFormField != NULL); 1788 for (int i = 0, isz = pField->CountControls(); i < isz; i++) {
1798 1789 CPDF_FormControl* pFormCtrl = pField->GetControl(i);
1799 » » GetWidgets(pFormField, widgets);» 1790 ASSERT(pFormCtrl != NULL);
1800 » } 1791
1801 } 1792 CPDFSDK_Widget* pWidget = GetWidget(pFormCtrl);
1802 1793
1803 void CPDFSDK_InterForm::GetWidgets(CPDF_FormField* pField, CFX_PtrArray& widgets ) 1794 if (pWidget)
1804 { 1795 widgets.Add(pWidget);
1805 » ASSERT(pField != NULL); 1796 }
1806 1797 }
1807 » for (int i=0,isz=pField->CountControls(); i<isz; i++) 1798
1808 » { 1799 int CPDFSDK_InterForm::GetPageIndexByAnnotDict(
1809 » » CPDF_FormControl* pFormCtrl = pField->GetControl(i); 1800 CPDF_Document* pDocument,
1810 » » ASSERT(pFormCtrl != NULL); 1801 CPDF_Dictionary* pAnnotDict) const {
1811 1802 ASSERT(pDocument != NULL);
1812 » » CPDFSDK_Widget* pWidget = GetWidget(pFormCtrl); 1803 ASSERT(pAnnotDict != NULL);
1813 1804
1814 » » if (pWidget) 1805 for (int i = 0, sz = pDocument->GetPageCount(); i < sz; i++) {
1815 » » » widgets.Add(pWidget); 1806 if (CPDF_Dictionary* pPageDict = pDocument->GetPage(i)) {
1816 » } 1807 if (CPDF_Array* pAnnots = pPageDict->GetArray("Annots")) {
1817 } 1808 for (int j = 0, jsz = pAnnots->GetCount(); j < jsz; j++) {
1818 1809 CPDF_Object* pDict = pAnnots->GetElementValue(j);
1819 int CPDFSDK_InterForm::GetPageIndexByAnnotDict(CPDF_Document* pDocument, CPDF_Di ctionary* pAnnotDict) const 1810 if (pAnnotDict == pDict) {
1820 { 1811 return i;
1821 » ASSERT(pDocument != NULL); 1812 }
1822 » ASSERT(pAnnotDict != NULL); 1813 }
1823 1814 }
1824 » for (int i=0,sz=pDocument->GetPageCount(); i<sz; i++) 1815 }
1825 » { 1816 }
1826 » » if (CPDF_Dictionary* pPageDict = pDocument->GetPage(i)) 1817
1827 » » {» » » 1818 return -1;
1828 » » » if (CPDF_Array* pAnnots = pPageDict->GetArray("Annots")) 1819 }
1829 » » » { 1820
1830 » » » » for (int j=0,jsz=pAnnots->GetCount(); j<jsz; j++ ) 1821 void CPDFSDK_InterForm::AddMap(CPDF_FormControl* pControl,
1831 » » » » { 1822 CPDFSDK_Widget* pWidget) {
1832 » » » » » CPDF_Object* pDict = pAnnots->GetElement Value(j); 1823 m_Map.SetAt(pControl, pWidget);
1833 » » » » » if (pAnnotDict == pDict) 1824 }
1834 » » » » » { 1825
1835 » » » » » » return i; 1826 void CPDFSDK_InterForm::RemoveMap(CPDF_FormControl* pControl) {
1836 » » » » » } 1827 m_Map.RemoveKey(pControl);
1837 » » » » } 1828 }
1838 » » » } 1829
1839 » » } 1830 void CPDFSDK_InterForm::EnableCalculate(FX_BOOL bEnabled) {
1840 » } 1831 m_bCalculate = bEnabled;
1841 1832 }
1842 » return -1; 1833
1843 } 1834 FX_BOOL CPDFSDK_InterForm::IsCalculateEnabled() const {
1844 1835 return m_bCalculate;
1845 void CPDFSDK_InterForm::AddMap(CPDF_FormControl* pControl, CPDFSDK_Widget* pWidg et)
1846 {
1847 » m_Map.SetAt(pControl, pWidget);
1848 }
1849
1850 void CPDFSDK_InterForm::RemoveMap(CPDF_FormControl* pControl)
1851 {
1852 » m_Map.RemoveKey(pControl);
1853 }
1854
1855 void CPDFSDK_InterForm::EnableCalculate(FX_BOOL bEnabled)
1856 {
1857 » m_bCalculate = bEnabled;
1858 }
1859
1860 FX_BOOL CPDFSDK_InterForm::IsCalculateEnabled() const
1861 {
1862 » return m_bCalculate;
1863 } 1836 }
1864 1837
1865 #ifdef _WIN32 1838 #ifdef _WIN32
1866 CPDF_Stream* CPDFSDK_InterForm::LoadImageFromFile(const CFX_WideString& sFile) 1839 CPDF_Stream* CPDFSDK_InterForm::LoadImageFromFile(const CFX_WideString& sFile) {
1867 { 1840 ASSERT(m_pDocument != NULL);
1868 » ASSERT(m_pDocument != NULL); 1841 CPDF_Document* pDocument = m_pDocument->GetDocument();
1869 » CPDF_Document* pDocument = m_pDocument->GetDocument(); 1842 ASSERT(pDocument != NULL);
1870 » ASSERT(pDocument != NULL); 1843
1871 1844 CPDF_Stream* pRetStream = NULL;
1872 » CPDF_Stream* pRetStream = NULL; 1845
1873 1846 if (CFX_DIBitmap* pBmp = CFX_WindowsDIB::LoadFromFile(sFile)) {
1874 » if (CFX_DIBitmap* pBmp = CFX_WindowsDIB::LoadFromFile(sFile)) 1847 int nWidth = pBmp->GetWidth();
1875 » { 1848 int nHeight = pBmp->GetHeight();
1876 » » int nWidth = pBmp->GetWidth(); 1849
1877 » » int nHeight = pBmp->GetHeight(); 1850 CPDF_Image Image(pDocument);
1878 1851 Image.SetImage(pBmp, FALSE);
1879 » » CPDF_Image Image(pDocument); 1852 CPDF_Stream* pImageStream = Image.GetStream();
1880 » » Image.SetImage(pBmp, FALSE); 1853 if (pImageStream) {
1881 » » CPDF_Stream* pImageStream = Image.GetStream(); 1854 if (pImageStream->GetObjNum() == 0)
1882 » » if (pImageStream) 1855 pDocument->AddIndirectObject(pImageStream);
1883 » » { 1856
1884 » » » if (pImageStream->GetObjNum() == 0) 1857 CPDF_Dictionary* pStreamDict = new CPDF_Dictionary();
1885 » » » » pDocument->AddIndirectObject(pImageStream); 1858 pStreamDict->SetAtName("Subtype", "Form");
1886 1859 pStreamDict->SetAtName("Name", "IMG");
1887 » » » CPDF_Dictionary* pStreamDict = new CPDF_Dictionary(); 1860 CPDF_Array* pMatrix = new CPDF_Array();
1888 » » » pStreamDict->SetAtName("Subtype", "Form"); 1861 pStreamDict->SetAt("Matrix", pMatrix);
1889 » » » pStreamDict->SetAtName("Name", "IMG"); 1862 pMatrix->AddInteger(1);
1890 » » » CPDF_Array* pMatrix = new CPDF_Array(); 1863 pMatrix->AddInteger(0);
1891 » » » pStreamDict->SetAt("Matrix", pMatrix); 1864 pMatrix->AddInteger(0);
1892 » » » pMatrix->AddInteger(1); 1865 pMatrix->AddInteger(1);
1893 » » » pMatrix->AddInteger(0); 1866 pMatrix->AddInteger(-nWidth / 2);
1894 » » » pMatrix->AddInteger(0); 1867 pMatrix->AddInteger(-nHeight / 2);
1895 » » » pMatrix->AddInteger(1); 1868 CPDF_Dictionary* pResource = new CPDF_Dictionary();
1896 » » » pMatrix->AddInteger(-nWidth / 2); 1869 pStreamDict->SetAt("Resources", pResource);
1897 » » » pMatrix->AddInteger(-nHeight / 2); 1870 CPDF_Dictionary* pXObject = new CPDF_Dictionary();
1898 » » » CPDF_Dictionary* pResource = new CPDF_Dictionary(); 1871 pResource->SetAt("XObject", pXObject);
1899 » » » pStreamDict->SetAt("Resources", pResource); 1872 pXObject->SetAtReference("Img", pDocument, pImageStream);
1900 » » » CPDF_Dictionary* pXObject = new CPDF_Dictionary(); 1873 CPDF_Array* pProcSet = new CPDF_Array();
1901 » » » pResource->SetAt("XObject", pXObject); 1874 pResource->SetAt("ProcSet", pProcSet);
1902 » » » pXObject->SetAtReference("Img", pDocument, pImageStream) ; 1875 pProcSet->AddName("PDF");
1903 » » » CPDF_Array* pProcSet = new CPDF_Array(); 1876 pProcSet->AddName("ImageC");
1904 » » » pResource->SetAt("ProcSet", pProcSet); 1877 pStreamDict->SetAtName("Type", "XObject");
1905 » » » pProcSet->AddName("PDF"); 1878 CPDF_Array* pBBox = new CPDF_Array();
1906 » » » pProcSet->AddName("ImageC"); 1879 pStreamDict->SetAt("BBox", pBBox);
1907 » » » pStreamDict->SetAtName("Type", "XObject"); 1880 pBBox->AddInteger(0);
1908 » » » CPDF_Array* pBBox = new CPDF_Array(); 1881 pBBox->AddInteger(0);
1909 » » » pStreamDict->SetAt("BBox", pBBox); 1882 pBBox->AddInteger(nWidth);
1910 » » » pBBox->AddInteger(0); 1883 pBBox->AddInteger(nHeight);
1911 » » » pBBox->AddInteger(0); 1884 pStreamDict->SetAtInteger("FormType", 1);
1912 » » » pBBox->AddInteger(nWidth); 1885
1913 » » » pBBox->AddInteger(nHeight); 1886 pRetStream = new CPDF_Stream(NULL, 0, NULL);
1914 » » » pStreamDict->SetAtInteger("FormType", 1); 1887 CFX_ByteString csStream;
1915 1888 csStream.Format("q\n%d 0 0 %d 0 0 cm\n/Img Do\nQ", nWidth, nHeight);
1916 » » » pRetStream = new CPDF_Stream(NULL, 0, NULL); 1889 pRetStream->InitStream(
1917 » » » CFX_ByteString csStream; 1890 (FX_BYTE*)(FX_LPCSTR) csStream, csStream.GetLength(), pStreamDict);
1918 » » » csStream.Format("q\n%d 0 0 %d 0 0 cm\n/Img Do\nQ", nWidt h, nHeight); 1891 pDocument->AddIndirectObject(pRetStream);
1919 » » » pRetStream->InitStream((FX_BYTE*)(FX_LPCSTR)csStream, cs Stream.GetLength(), pStreamDict); 1892 }
1920 » » » pDocument->AddIndirectObject(pRetStream); 1893
1921 » » } 1894 delete pBmp;
1922 1895 }
1923 » » delete pBmp; 1896
1924 » } 1897 return pRetStream;
1925
1926 » return pRetStream;
1927 } 1898 }
1928 #endif 1899 #endif
1929 1900
1930 void CPDFSDK_InterForm::OnCalculate(CPDF_FormField* pFormField) 1901 void CPDFSDK_InterForm::OnCalculate(CPDF_FormField* pFormField) {
1931 { 1902 ASSERT(m_pDocument != NULL);
1932 ASSERT(m_pDocument != NULL); 1903 CPDFDoc_Environment* pEnv = m_pDocument->GetEnv();
1933 CPDFDoc_Environment* pEnv = m_pDocument->GetEnv(); 1904 ASSERT(pEnv);
1934 ASSERT(pEnv); 1905 if (!pEnv->IsJSInitiated())
1935 if(!pEnv->IsJSInitiated()) 1906 return;
1936 return; 1907
1937 1908 if (m_bBusy)
1938 if (m_bBusy) return; 1909 return;
1939 1910
1940 m_bBusy = TRUE; 1911 m_bBusy = TRUE;
1941 1912
1942 if (this->IsCalculateEnabled()) 1913 if (this->IsCalculateEnabled()) {
1943 { 1914 IFXJS_Runtime* pRuntime = m_pDocument->GetJsRuntime();
1944 IFXJS_Runtime* pRuntime = m_pDocument->GetJsRuntime(); 1915 ASSERT(pRuntime != NULL);
1945 ASSERT(pRuntime != NULL); 1916
1946 1917 pRuntime->SetReaderDocument(m_pDocument);
1947 pRuntime->SetReaderDocument(m_pDocument); 1918
1948 1919 int nSize = m_pInterForm->CountFieldsInCalculationOrder();
1949 int nSize = m_pInterForm->CountFieldsInCalculationOrder(); 1920 for (int i = 0; i < nSize; i++) {
1950 for (int i=0; i<nSize; i++) 1921 if (CPDF_FormField* pField =
1951 { 1922 m_pInterForm->GetFieldInCalculationOrder(i)) {
1952 if(CPDF_FormField* pField = m_pInterForm->GetFieldInCalc ulationOrder(i)) 1923 // ASSERT(pField != NULL);
1953 { 1924 int nType = pField->GetFieldType();
1954 // ASSERT(pField != NULL); 1925 if (nType == FIELDTYPE_COMBOBOX || nType == FIELDTYPE_TEXTFIELD) {
1955 int nType = pField->GetFieldType(); 1926 CPDF_AAction aAction = pField->GetAdditionalAction();
1956 if (nType == FIELDTYPE_COMBOBOX || nType == FIEL DTYPE_TEXTFIELD) 1927 if (aAction && aAction.ActionExist(CPDF_AAction::Calculate)) {
1957 { 1928 CPDF_Action action = aAction.GetAction(CPDF_AAction::Calculate);
1958 CPDF_AAction aAction = pField->GetAdditi onalAction(); 1929 if (action) {
1959 if (aAction && aAction.ActionExist(CPDF_ AAction::Calculate)) 1930 CFX_WideString csJS = action.GetJavaScript();
1960 { 1931 if (!csJS.IsEmpty()) {
1961 CPDF_Action action = aAction.Get Action(CPDF_AAction::Calculate); 1932 IFXJS_Context* pContext = pRuntime->NewContext();
1962 if (action) 1933 ASSERT(pContext != NULL);
1963 { 1934
1964 CFX_WideString csJS = ac tion.GetJavaScript(); 1935 CFX_WideString sOldValue = pField->GetValue();
1965 if (!csJS.IsEmpty()) 1936 CFX_WideString sValue = sOldValue;
1966 { 1937 FX_BOOL bRC = TRUE;
1967 IFXJS_Context* p Context = pRuntime->NewContext(); 1938 pContext->OnField_Calculate(pFormField, pField, sValue, bRC);
1968 ASSERT(pContext != NULL); 1939
1969 1940 CFX_WideString sInfo;
1970 CFX_WideString s OldValue = pField->GetValue(); 1941 FX_BOOL bRet = pContext->RunScript(csJS, sInfo);
1971 CFX_WideString s Value = sOldValue; 1942 pRuntime->ReleaseContext(pContext);
1972 FX_BOOL bRC = TR UE; 1943
1973 pContext->OnFiel d_Calculate(pFormField, pField, sValue, bRC); 1944 if (bRet) {
1974 1945 if (bRC) {
1975 CFX_WideString s Info; 1946 if (sValue.Compare(sOldValue) != 0)
1976 FX_BOOL bRet = p Context->RunScript(csJS, sInfo); 1947 pField->SetValue(sValue, TRUE);
1977 pRuntime->Releas eContext(pContext); 1948 }
1978 1949 }
1979 if (bRet) 1950 }
1980 { 1951 }
1981 if (bRC) 1952 }
1982 { 1953 }
1983 if (sValue.Compare(sOldValue) != 0) 1954 }
1984 pField->SetValue(sValue, TRUE); 1955 }
1985 } 1956 }
1986 } 1957
1987 } 1958 m_bBusy = FALSE;
1988 } 1959 }
1989 } 1960
1990 } 1961 CFX_WideString CPDFSDK_InterForm::OnFormat(CPDF_FormField* pFormField,
1991 } 1962 int nCommitKey,
1992 } 1963 FX_BOOL& bFormated) {
1993 1964 ASSERT(m_pDocument != NULL);
1994 1965 ASSERT(pFormField != NULL);
1995 } 1966
1996 1967 CFX_WideString sValue = pFormField->GetValue();
1997 m_bBusy = FALSE; 1968 CPDFDoc_Environment* pEnv = m_pDocument->GetEnv();
1998 } 1969 ASSERT(pEnv);
1999 1970 if (!pEnv->IsJSInitiated()) {
2000 CFX_WideString CPDFSDK_InterForm::OnFormat(CPDF_FormField* pFormField, int nComm itKey, FX_BOOL& bFormated) 1971 bFormated = FALSE;
2001 { 1972 return sValue;
2002 ASSERT(m_pDocument != NULL); 1973 }
2003 ASSERT(pFormField != NULL); 1974
2004 1975 IFXJS_Runtime* pRuntime = m_pDocument->GetJsRuntime();
2005 CFX_WideString sValue = pFormField->GetValue(); 1976 ASSERT(pRuntime != NULL);
2006 CPDFDoc_Environment* pEnv = m_pDocument->GetEnv(); 1977
2007 ASSERT(pEnv); 1978 pRuntime->SetReaderDocument(m_pDocument);
2008 if(!pEnv->IsJSInitiated()) 1979
2009 { 1980 if (pFormField->GetFieldType() == FIELDTYPE_COMBOBOX) {
2010 bFormated = FALSE; 1981 if (pFormField->CountSelectedItems() > 0) {
2011 return sValue; 1982 int index = pFormField->GetSelectedIndex(0);
2012 } 1983 if (index >= 0)
2013 1984 sValue = pFormField->GetOptionLabel(index);
2014 IFXJS_Runtime* pRuntime = m_pDocument->GetJsRuntime(); 1985 }
2015 ASSERT(pRuntime != NULL); 1986 }
2016 1987
2017 pRuntime->SetReaderDocument(m_pDocument); 1988 bFormated = FALSE;
2018 1989
2019 if (pFormField->GetFieldType() == FIELDTYPE_COMBOBOX) 1990 CPDF_AAction aAction = pFormField->GetAdditionalAction();
2020 { 1991 if (aAction != NULL && aAction.ActionExist(CPDF_AAction::Format)) {
2021 if (pFormField->CountSelectedItems() > 0) 1992 CPDF_Action action = aAction.GetAction(CPDF_AAction::Format);
2022 { 1993 if (action) {
2023 int index = pFormField->GetSelectedIndex(0); 1994 CFX_WideString script = action.GetJavaScript();
2024 if (index >= 0) 1995 if (!script.IsEmpty()) {
2025 sValue = pFormField->GetOptionLabel(index); 1996 CFX_WideString Value = sValue;
2026 } 1997
2027 } 1998 IFXJS_Context* pContext = pRuntime->NewContext();
2028 1999 ASSERT(pContext != NULL);
2029 bFormated = FALSE; 2000
2030 2001 pContext->OnField_Format(nCommitKey, pFormField, Value, TRUE);
2031 CPDF_AAction aAction = pFormField->GetAdditionalAction(); 2002
2032 if (aAction != NULL && aAction.ActionExist(CPDF_AAction::Format)) 2003 CFX_WideString sInfo;
2033 { 2004 FX_BOOL bRet = pContext->RunScript(script, sInfo);
2034 CPDF_Action action = aAction.GetAction(CPDF_AAction::Format); 2005 pRuntime->ReleaseContext(pContext);
2035 if (action) 2006
2036 { 2007 if (bRet) {
2037 CFX_WideString script = action.GetJavaScript(); 2008 sValue = Value;
2038 if (!script.IsEmpty()) 2009 bFormated = TRUE;
2039 { 2010 }
2040 CFX_WideString Value = sValue; 2011 }
2041 2012 }
2042 IFXJS_Context* pContext = pRuntime->NewContext() ; 2013 }
2043 ASSERT(pContext != NULL); 2014
2044 2015 return sValue;
2045 pContext->OnField_Format(nCommitKey, pFormField, Value, TRUE); 2016 }
2046 2017
2047 CFX_WideString sInfo; 2018 void CPDFSDK_InterForm::ResetFieldAppearance(CPDF_FormField* pFormField,
2048 FX_BOOL bRet = pContext->RunScript(script, sInfo ); 2019 FX_LPCWSTR sValue,
2049 pRuntime->ReleaseContext(pContext); 2020 FX_BOOL bValueChanged) {
2050 2021 ASSERT(pFormField != NULL);
2051 if (bRet) 2022
2052 { 2023 for (int i = 0, sz = pFormField->CountControls(); i < sz; i++) {
2053 sValue = Value; 2024 CPDF_FormControl* pFormCtrl = pFormField->GetControl(i);
2054 bFormated = TRUE; 2025 ASSERT(pFormCtrl != NULL);
2055 } 2026
2056 } 2027 ASSERT(m_pInterForm != NULL);
2057 } 2028 if (CPDFSDK_Widget* pWidget = GetWidget(pFormCtrl))
2058 } 2029 pWidget->ResetAppearance(sValue, bValueChanged);
2059 2030 }
2060 return sValue; 2031 }
2061 } 2032
2062 2033 void CPDFSDK_InterForm::UpdateField(CPDF_FormField* pFormField) {
2063 void CPDFSDK_InterForm::ResetFieldAppearance(CPDF_FormField* pFormField, FX_LPCW STR sValue, FX_BOOL bValueChanged) 2034 ASSERT(pFormField != NULL);
2064 { 2035
2065 ASSERT(pFormField != NULL); 2036 for (int i = 0, sz = pFormField->CountControls(); i < sz; i++) {
2066 2037 CPDF_FormControl* pFormCtrl = pFormField->GetControl(i);
2067 for (int i=0,sz=pFormField->CountControls(); i<sz; i++) 2038 ASSERT(pFormCtrl != NULL);
2068 { 2039
2069 CPDF_FormControl* pFormCtrl = pFormField->GetControl(i); 2040 if (CPDFSDK_Widget* pWidget = GetWidget(pFormCtrl)) {
2070 ASSERT(pFormCtrl != NULL); 2041 CPDFDoc_Environment* pEnv = m_pDocument->GetEnv();
2071 2042 CFFL_IFormFiller* pIFormFiller = pEnv->GetIFormFiller();
2072 ASSERT(m_pInterForm != NULL); 2043
2073 if(CPDFSDK_Widget* pWidget = GetWidget(pFormCtrl)) 2044 CPDF_Page* pPage = pWidget->GetPDFPage();
2074 pWidget->ResetAppearance(sValue, bValueChanged); 2045 CPDFSDK_PageView* pPageView = m_pDocument->GetPageView(pPage, FALSE);
2075 } 2046
2076 } 2047 FX_RECT rcBBox = pIFormFiller->GetViewBBox(pPageView, pWidget);
2077 2048
2078 void CPDFSDK_InterForm::UpdateField(CPDF_FormField* pFormField) 2049 pEnv->FFI_Invalidate(
2079 { 2050 pPage, rcBBox.left, rcBBox.top, rcBBox.right, rcBBox.bottom);
2080 ASSERT(pFormField != NULL); 2051 }
2081 2052 }
2082 for (int i=0,sz=pFormField->CountControls(); i<sz; i++) 2053 }
2083 { 2054
2084 CPDF_FormControl* pFormCtrl = pFormField->GetControl(i); 2055 void CPDFSDK_InterForm::OnKeyStrokeCommit(CPDF_FormField* pFormField,
2085 ASSERT(pFormCtrl != NULL); 2056 CFX_WideString& csValue,
2086 2057 FX_BOOL& bRC) {
2087 if(CPDFSDK_Widget* pWidget = GetWidget(pFormCtrl)) 2058 ASSERT(pFormField != NULL);
2088 { 2059
2089 CPDFDoc_Environment * pEnv = m_pDocument->GetEnv(); 2060 CPDF_AAction aAction = pFormField->GetAdditionalAction();
2090 CFFL_IFormFiller* pIFormFiller = pEnv->GetIFormFiller(); 2061 if (aAction != NULL && aAction.ActionExist(CPDF_AAction::KeyStroke)) {
2091 2062 CPDF_Action action = aAction.GetAction(CPDF_AAction::KeyStroke);
2092 CPDF_Page * pPage = pWidget->GetPDFPage(); 2063 if (action) {
2093 CPDFSDK_PageView * pPageView = m_pDocument->GetPageView( pPage,FALSE); 2064 ASSERT(m_pDocument != NULL);
2094 2065 CPDFDoc_Environment* pEnv = m_pDocument->GetEnv();
2095 FX_RECT rcBBox = pIFormFiller->GetViewBBox(pPageView, pW idget); 2066 ASSERT(pEnv != NULL);
2096 2067
2097 pEnv->FFI_Invalidate(pPage,rcBBox.left, rcBBox.top, rcBB ox.right, rcBBox.bottom); 2068 CPDFSDK_ActionHandler* pActionHandler = pEnv->GetActionHander();
2098 } 2069 ASSERT(pActionHandler != NULL);
2099 } 2070
2100 } 2071 PDFSDK_FieldAction fa;
2101 2072 fa.bModifier = pEnv->FFI_IsCTRLKeyDown(0);
2102 void CPDFSDK_InterForm::OnKeyStrokeCommit(CPDF_FormField* pFormField, CFX_WideSt ring& csValue, FX_BOOL& bRC) 2073 fa.bShift = pEnv->FFI_IsSHIFTKeyDown(0);
2103 { 2074 fa.sValue = csValue;
2104 ASSERT(pFormField != NULL); 2075
2105 2076 pActionHandler->DoAction_FieldJavaScript(
2106 CPDF_AAction aAction = pFormField->GetAdditionalAction(); 2077 action, CPDF_AAction::KeyStroke, m_pDocument, pFormField, fa);
2107 if (aAction != NULL && aAction.ActionExist(CPDF_AAction::KeyStroke)) 2078 bRC = fa.bRC;
2108 { 2079 }
2109 CPDF_Action action = aAction.GetAction(CPDF_AAction::KeyStroke); 2080 }
2110 if (action) 2081 }
2111 { 2082
2112 ASSERT(m_pDocument != NULL); 2083 void CPDFSDK_InterForm::OnValidate(CPDF_FormField* pFormField,
2113 CPDFDoc_Environment* pEnv = m_pDocument->GetEnv(); 2084 CFX_WideString& csValue,
2114 ASSERT(pEnv != NULL); 2085 FX_BOOL& bRC) {
2115 2086 ASSERT(pFormField != NULL);
2116 CPDFSDK_ActionHandler* pActionHandler = pEnv->GetActionH ander(); 2087
2117 ASSERT(pActionHandler != NULL); 2088 CPDF_AAction aAction = pFormField->GetAdditionalAction();
2118 2089 if (aAction != NULL && aAction.ActionExist(CPDF_AAction::Validate)) {
2119 PDFSDK_FieldAction fa; 2090 CPDF_Action action = aAction.GetAction(CPDF_AAction::Validate);
2120 fa.bModifier = pEnv->FFI_IsCTRLKeyDown(0); 2091 if (action) {
2121 fa.bShift = pEnv->FFI_IsSHIFTKeyDown(0); 2092 ASSERT(m_pDocument != NULL);
2122 fa.sValue = csValue; 2093 CPDFDoc_Environment* pEnv = m_pDocument->GetEnv();
2123 2094 ASSERT(pEnv != NULL);
2124 pActionHandler->DoAction_FieldJavaScript(action, CPDF_AA ction::KeyStroke, 2095
2125 m_pDocument, pFormField, fa); 2096 CPDFSDK_ActionHandler* pActionHandler = pEnv->GetActionHander();
2126 bRC = fa.bRC; 2097 ASSERT(pActionHandler != NULL);
2127 } 2098
2128 } 2099 PDFSDK_FieldAction fa;
2129 } 2100 fa.bModifier = pEnv->FFI_IsCTRLKeyDown(0);
2130 2101 fa.bShift = pEnv->FFI_IsSHIFTKeyDown(0);
2131 void CPDFSDK_InterForm::OnValidate(CPDF_FormField* pFormField, CFX_WideString& c sValue, FX_BOOL& bRC) 2102 fa.sValue = csValue;
2132 { 2103
2133 ASSERT(pFormField != NULL); 2104 pActionHandler->DoAction_FieldJavaScript(
2134 2105 action, CPDF_AAction::Validate, m_pDocument, pFormField, fa);
2135 CPDF_AAction aAction = pFormField->GetAdditionalAction(); 2106 bRC = fa.bRC;
2136 if (aAction != NULL && aAction.ActionExist(CPDF_AAction::Validate)) 2107 }
2137 { 2108 }
2138 CPDF_Action action = aAction.GetAction(CPDF_AAction::Validate);
2139 if (action)
2140 {
2141 ASSERT(m_pDocument != NULL);
2142 CPDFDoc_Environment* pEnv = m_pDocument->GetEnv();
2143 ASSERT(pEnv != NULL);
2144
2145 CPDFSDK_ActionHandler* pActionHandler = pEnv->GetActionH ander();
2146 ASSERT(pActionHandler != NULL);
2147
2148 PDFSDK_FieldAction fa;
2149 fa.bModifier = pEnv->FFI_IsCTRLKeyDown(0);
2150 fa.bShift = pEnv->FFI_IsSHIFTKeyDown(0);
2151 fa.sValue = csValue;
2152
2153 pActionHandler->DoAction_FieldJavaScript(action, CPDF_AA ction::Validate, m_pDocument, pFormField, fa);
2154 bRC = fa.bRC;
2155
2156 }
2157 }
2158 } 2109 }
2159 2110
2160 /* ----------------------------- action ----------------------------- */ 2111 /* ----------------------------- action ----------------------------- */
2161 2112
2162 FX_BOOL CPDFSDK_InterForm::DoAction_Hide(const CPDF_Action& action) 2113 FX_BOOL CPDFSDK_InterForm::DoAction_Hide(const CPDF_Action& action) {
2163 { 2114 ASSERT(action != NULL);
2164 ASSERT(action != NULL); 2115
2165 2116 CPDF_ActionFields af = action.GetWidgets();
2166 CPDF_ActionFields af = action.GetWidgets(); 2117 CFX_PtrArray fieldObjects;
2167 CFX_PtrArray fieldObjects; 2118 af.GetAllFields(fieldObjects);
2168 af.GetAllFields(fieldObjects); 2119 CFX_PtrArray widgetArray;
2169 CFX_PtrArray widgetArray; 2120 CFX_PtrArray fields;
2170 CFX_PtrArray fields; 2121 GetFieldFromObjects(fieldObjects, fields);
2171 GetFieldFromObjects(fieldObjects, fields); 2122
2172 2123 FX_BOOL bHide = action.GetHideStatus();
2173 FX_BOOL bHide = action.GetHideStatus(); 2124
2174 2125 FX_BOOL bChanged = FALSE;
2175 FX_BOOL bChanged = FALSE; 2126
2176 2127 for (int i = 0, sz = fields.GetSize(); i < sz; i++) {
2177 for (int i=0, sz=fields.GetSize(); i<sz; i++) 2128 CPDF_FormField* pField = (CPDF_FormField*)fields[i];
2178 { 2129 ASSERT(pField != NULL);
2179 CPDF_FormField* pField = (CPDF_FormField*)fields[i]; 2130
2180 ASSERT(pField != NULL); 2131 for (int j = 0, jsz = pField->CountControls(); j < jsz; j++) {
2181 2132 CPDF_FormControl* pControl = pField->GetControl(j);
2182 2133 ASSERT(pControl != NULL);
2183 for (int j=0,jsz=pField->CountControls(); j<jsz; j++) 2134
2184 { 2135 if (CPDFSDK_Widget* pWidget = GetWidget(pControl)) {
2185 CPDF_FormControl* pControl = pField->GetControl(j); 2136 int nFlags = pWidget->GetFlags();
2186 ASSERT(pControl != NULL); 2137 if (bHide) {
2187 2138 nFlags &= (~ANNOTFLAG_INVISIBLE);
2188 if (CPDFSDK_Widget* pWidget = GetWidget(pControl)) 2139 nFlags &= (~ANNOTFLAG_NOVIEW);
2189 { 2140 nFlags |= (ANNOTFLAG_HIDDEN);
2190 int nFlags = pWidget->GetFlags(); 2141 } else {
2191 if (bHide) 2142 nFlags &= (~ANNOTFLAG_INVISIBLE);
2192 { 2143 nFlags &= (~ANNOTFLAG_HIDDEN);
2193 nFlags &= (~ANNOTFLAG_INVISIBLE); 2144 nFlags &= (~ANNOTFLAG_NOVIEW);
2194 nFlags &= (~ANNOTFLAG_NOVIEW); 2145 }
2195 nFlags |= (ANNOTFLAG_HIDDEN); 2146 pWidget->SetFlags(nFlags);
2196 } 2147
2197 else 2148 CPDFSDK_PageView* pPageView = pWidget->GetPageView();
2198 { 2149 ASSERT(pPageView != NULL);
2199 nFlags &= (~ANNOTFLAG_INVISIBLE); 2150
2200 nFlags &= (~ANNOTFLAG_HIDDEN); 2151 pPageView->UpdateView(pWidget);
2201 nFlags &= (~ANNOTFLAG_NOVIEW); 2152
2202 } 2153 bChanged = TRUE;
2203 pWidget->SetFlags(nFlags); 2154 }
2204 2155 }
2205 CPDFSDK_PageView* pPageView = pWidget->GetPageVi ew(); 2156 }
2206 ASSERT(pPageView != NULL); 2157
2207 2158 return bChanged;
2208 pPageView->UpdateView(pWidget); 2159 }
2209 2160
2210 bChanged = TRUE; 2161 FX_BOOL CPDFSDK_InterForm::DoAction_SubmitForm(const CPDF_Action& action) {
2211 } 2162 ASSERT(action != NULL);
2212 } 2163 ASSERT(m_pInterForm != NULL);
2213 } 2164
2214 2165 CFX_WideString sDestination = action.GetFilePath();
2215 return bChanged; 2166 if (sDestination.IsEmpty())
2216 } 2167 return FALSE;
2217 2168
2218 FX_BOOL CPDFSDK_InterForm::DoAction_SubmitForm(const CPDF_Action& action) 2169 CPDF_Dictionary* pActionDict = action;
2219 { 2170 if (pActionDict->KeyExist("Fields")) {
2220 ASSERT(action != NULL); 2171 CPDF_ActionFields af = action.GetWidgets();
2221 ASSERT(m_pInterForm != NULL); 2172 FX_DWORD dwFlags = action.GetFlags();
2222 2173
2223 CFX_WideString sDestination = action.GetFilePath(); 2174 CFX_PtrArray fieldObjects;
2224 if (sDestination.IsEmpty()) return FALSE; 2175 af.GetAllFields(fieldObjects);
2225 2176 CFX_PtrArray fields;
2226 CPDF_Dictionary* pActionDict = action; 2177 GetFieldFromObjects(fieldObjects, fields);
2227 if (pActionDict->KeyExist("Fields")) 2178
2228 { 2179 if (fields.GetSize() != 0) {
2229 CPDF_ActionFields af = action.GetWidgets(); 2180 FX_BOOL bIncludeOrExclude = !(dwFlags & 0x01);
2230 FX_DWORD dwFlags = action.GetFlags(); 2181 if (m_pInterForm->CheckRequiredFields(&fields, bIncludeOrExclude)) {
2231 2182 return FALSE;
2232 CFX_PtrArray fieldObjects; 2183 }
2233 af.GetAllFields(fieldObjects); 2184 return SubmitFields(sDestination, fields, bIncludeOrExclude, FALSE);
2234 CFX_PtrArray fields; 2185 } else {
2235 GetFieldFromObjects(fieldObjects, fields); 2186 if (m_pInterForm->CheckRequiredFields()) {
2236 2187 return FALSE;
2237 if (fields.GetSize() != 0) 2188 }
2238 { 2189
2239 FX_BOOL bIncludeOrExclude = !(dwFlags & 0x01); 2190 return SubmitForm(sDestination, FALSE);
2240 if (m_pInterForm->CheckRequiredFields(&fields, bIncludeO rExclude)) 2191 }
2241 { 2192 } else {
2242 return FALSE; 2193 if (m_pInterForm->CheckRequiredFields()) {
2243 } 2194 return FALSE;
2244 return SubmitFields(sDestination, fields, bIncludeOrExcl ude, FALSE); 2195 }
2245 } 2196
2246 else 2197 return SubmitForm(sDestination, FALSE);
2247 { 2198 }
2248 if ( m_pInterForm->CheckRequiredFields()) 2199 }
2249 { 2200
2250 return FALSE; 2201 FX_BOOL CPDFSDK_InterForm::SubmitFields(const CFX_WideString& csDestination,
2251 } 2202 const CFX_PtrArray& fields,
2252 2203 FX_BOOL bIncludeOrExclude,
2253 return SubmitForm(sDestination, FALSE); 2204 FX_BOOL bUrlEncoded) {
2254 } 2205 CPDFDoc_Environment* pEnv = m_pDocument->GetEnv();
2255 } 2206 ASSERT(pEnv != NULL);
2256 else 2207
2257 { 2208 CFX_ByteTextBuf textBuf;
2258 if ( m_pInterForm->CheckRequiredFields()) 2209 ExportFieldsToFDFTextBuf(fields, bIncludeOrExclude, textBuf);
2259 { 2210
2260 return FALSE; 2211 FX_LPBYTE pBuffer = textBuf.GetBuffer();
2261 } 2212 FX_STRSIZE nBufSize = textBuf.GetLength();
2262 2213
2263 return SubmitForm(sDestination, FALSE); 2214 if (bUrlEncoded) {
2264 } 2215 if (!FDFToURLEncodedData(pBuffer, nBufSize))
2265 } 2216 return FALSE;
2266 2217 }
2267 FX_BOOL CPDFSDK_InterForm::SubmitFields(const CFX_WideString& csDestination, con st CFX_PtrArray& fields, 2218
2268 FX_BOOL bIncludeOrExclude, FX_BOOL bUrlEncoded) 2219 pEnv->JS_docSubmitForm(pBuffer, nBufSize, (FX_LPCWSTR)csDestination);
2269 { 2220
2270 CPDFDoc_Environment* pEnv = m_pDocument->GetEnv(); 2221 if (bUrlEncoded && pBuffer) {
2271 ASSERT(pEnv != NULL); 2222 FX_Free(pBuffer);
2272 2223 pBuffer = NULL;
2273 CFX_ByteTextBuf textBuf; 2224 }
2274 ExportFieldsToFDFTextBuf(fields, bIncludeOrExclude, textBuf); 2225
2275 2226 return TRUE;
2276 FX_LPBYTE pBuffer = textBuf.GetBuffer(); 2227 }
2277 FX_STRSIZE nBufSize = textBuf.GetLength(); 2228
2278 2229 void CPDFSDK_InterForm::DoFDFBuffer(CFX_ByteString sBuffer) {
2279 if (bUrlEncoded) 2230 ASSERT(m_pDocument != NULL);
2280 { 2231
2281 if(!FDFToURLEncodedData(pBuffer, nBufSize)) 2232 if (CFDF_Document* pFDFDocument = CFDF_Document::ParseMemory(
2282 return FALSE; 2233 (const unsigned char*)sBuffer.GetBuffer(sBuffer.GetLength()),
2283 } 2234 sBuffer.GetLength())) {
2284 2235 CPDF_Dictionary* pRootDic = pFDFDocument->GetRoot();
2285 pEnv->JS_docSubmitForm(pBuffer, nBufSize, (FX_LPCWSTR)csDestination); 2236 if (pRootDic) {
2286 2237 CPDF_Dictionary* pFDFDict = pRootDic->GetDict("FDF");
2287 if (bUrlEncoded && pBuffer) 2238 if (pFDFDict) {
2288 { 2239 CPDF_Dictionary* pJSDict = pFDFDict->GetDict("JavaScript");
2289 FX_Free(pBuffer); 2240 if (pJSDict) {
2290 pBuffer = NULL; 2241 CFX_WideString csJS;
2291 } 2242
2292 2243 CPDF_Object* pJS = pJSDict->GetElementValue("Before");
2293 return TRUE; 2244 if (pJS != NULL) {
2294 } 2245 int iType = pJS->GetType();
2295 2246 if (iType == PDFOBJ_STRING)
2296 void CPDFSDK_InterForm::DoFDFBuffer(CFX_ByteString sBuffer) 2247 csJS = pJSDict->GetUnicodeText("Before");
2297 { 2248 else if (iType == PDFOBJ_STREAM)
2298 ASSERT(m_pDocument != NULL); 2249 csJS = pJS->GetUnicodeText();
2299 2250 }
2300 if (CFDF_Document *pFDFDocument = CFDF_Document::ParseMemory((const unsi gned char *)sBuffer.GetBuffer(sBuffer.GetLength()), sBuffer.GetLength())) 2251 }
2301 { 2252 }
2302 CPDF_Dictionary* pRootDic = pFDFDocument->GetRoot(); 2253 }
2303 if(pRootDic) 2254 delete pFDFDocument;
2304 { 2255 }
2305 CPDF_Dictionary * pFDFDict=pRootDic->GetDict("FDF"); 2256
2306 if(pFDFDict) 2257 sBuffer.ReleaseBuffer();
2307 { 2258 }
2308 CPDF_Dictionary * pJSDict = pFDFDict->GetDict("J avaScript"); 2259
2309 if(pJSDict) 2260 FX_BOOL CPDFSDK_InterForm::FDFToURLEncodedData(CFX_WideString csFDFFile,
2310 { 2261 CFX_WideString csTxtFile) {
2311 CFX_WideString csJS; 2262 return TRUE;
2312 2263 }
2313 CPDF_Object* pJS = pJSDict->GetElementVa lue("Before"); 2264
2314 if (pJS != NULL) 2265 FX_BOOL CPDFSDK_InterForm::FDFToURLEncodedData(FX_LPBYTE& pBuf,
2315 { 2266 FX_STRSIZE& nBufSize) {
2316 int iType = pJS->GetType(); 2267 CFDF_Document* pFDF = CFDF_Document::ParseMemory(pBuf, nBufSize);
2317 if (iType == PDFOBJ_STRING) 2268 if (pFDF) {
2318 csJS = pJSDict->GetUnico deText("Before"); 2269 CPDF_Dictionary* pMainDict = pFDF->GetRoot()->GetDict("FDF");
2319 else if (iType == PDFOBJ_STREAM) 2270 if (pMainDict == NULL)
2320 csJS = pJS->GetUnicodeTe xt(); 2271 return FALSE;
2321 } 2272
2322 2273 // Get fields
2323 } 2274 CPDF_Array* pFields = pMainDict->GetArray("Fields");
2324 } 2275 if (pFields == NULL)
2325 } 2276 return FALSE;
2326 delete pFDFDocument; 2277
2327 } 2278 CFX_ByteTextBuf fdfEncodedData;
2328 2279
2329 sBuffer.ReleaseBuffer(); 2280 for (FX_DWORD i = 0; i < pFields->GetCount(); i++) {
2330 } 2281 CPDF_Dictionary* pField = pFields->GetDict(i);
2331 2282 if (pField == NULL)
2332 FX_BOOL CPDFSDK_InterForm::FDFToURLEncodedData(CFX_WideString csFDFFile, CFX_Wid eString csTxtFile) 2283 continue;
2333 { 2284 CFX_WideString name;
2334 return TRUE; 2285 name = pField->GetUnicodeText("T");
2335 } 2286 CFX_ByteString name_b = CFX_ByteString::FromUnicode(name);
2336 2287 CFX_ByteString csBValue = pField->GetString("V");
2337 FX_BOOL CPDFSDK_InterForm::FDFToURLEncodedData(FX_LPBYTE& pBuf, FX_STRSIZE& nBuf Size) 2288 CFX_WideString csWValue = PDF_DecodeText(csBValue);
2338 { 2289 CFX_ByteString csValue_b = CFX_ByteString::FromUnicode(csWValue);
2339 CFDF_Document* pFDF = CFDF_Document::ParseMemory(pBuf, nBufSize); 2290
2340 if (pFDF) 2291 fdfEncodedData = fdfEncodedData << name_b.GetBuffer(name_b.GetLength());
2341 { 2292 name_b.ReleaseBuffer();
2342 CPDF_Dictionary* pMainDict = pFDF->GetRoot()->GetDict("FDF"); 2293 fdfEncodedData = fdfEncodedData << "=";
2343 if (pMainDict == NULL) return FALSE; 2294 fdfEncodedData = fdfEncodedData
2344 2295 << csValue_b.GetBuffer(csValue_b.GetLength());
2345 // Get fields 2296 csValue_b.ReleaseBuffer();
2346 CPDF_Array* pFields = pMainDict->GetArray("Fields"); 2297 if (i != pFields->GetCount() - 1)
2347 if (pFields == NULL) return FALSE; 2298 fdfEncodedData = fdfEncodedData << "&";
2348 2299 }
2349 CFX_ByteTextBuf fdfEncodedData; 2300
2350 2301 nBufSize = fdfEncodedData.GetLength();
2351 for (FX_DWORD i = 0; i < pFields->GetCount(); i ++) 2302 pBuf = FX_Alloc(FX_BYTE, nBufSize);
2352 { 2303 if (!pBuf)
2353 CPDF_Dictionary* pField = pFields->GetDict(i); 2304 return FALSE;
2354 if (pField == NULL) continue; 2305 FXSYS_memcpy(pBuf, fdfEncodedData.GetBuffer(), nBufSize);
2355 CFX_WideString name; 2306 }
2356 name = pField->GetUnicodeText("T"); 2307 return TRUE;
2357 CFX_ByteString name_b = CFX_ByteString::FromUnicode(name ); 2308 }
2358 CFX_ByteString csBValue = pField->GetString("V"); 2309
2359 CFX_WideString csWValue = PDF_DecodeText(csBValue); 2310 FX_BOOL CPDFSDK_InterForm::ExportFieldsToFDFFile(
2360 CFX_ByteString csValue_b = CFX_ByteString::FromUnicode(c sWValue); 2311 const CFX_WideString& sFDFFileName,
2361 2312 const CFX_PtrArray& fields,
2362 fdfEncodedData = fdfEncodedData<<name_b.GetBuffer(name_b .GetLength()); 2313 FX_BOOL bIncludeOrExclude) {
2363 name_b.ReleaseBuffer(); 2314 if (sFDFFileName.IsEmpty())
2364 fdfEncodedData = fdfEncodedData<<"="; 2315 return FALSE;
2365 fdfEncodedData = fdfEncodedData<<csValue_b.GetBuffer(csV alue_b.GetLength()); 2316 ASSERT(m_pDocument != NULL);
2366 csValue_b.ReleaseBuffer(); 2317 ASSERT(m_pInterForm != NULL);
2367 if(i != pFields->GetCount()-1) 2318
2368 fdfEncodedData = fdfEncodedData<<"&"; 2319 CFDF_Document* pFDF = m_pInterForm->ExportToFDF(
2369 } 2320 m_pDocument->GetPath(), (CFX_PtrArray&)fields, bIncludeOrExclude);
2370 2321 if (!pFDF)
2371 nBufSize = fdfEncodedData.GetLength(); 2322 return FALSE;
2372 pBuf = FX_Alloc(FX_BYTE, nBufSize); 2323 FX_BOOL bRet = pFDF->WriteFile(sFDFFileName.UTF8Encode()); // = FALSE;//
2373 if(!pBuf) 2324 delete pFDF;
2374 return FALSE; 2325
2375 FXSYS_memcpy(pBuf, fdfEncodedData.GetBuffer(), nBufSize); 2326 return bRet;
2376 2327 }
2377 } 2328 FX_BOOL CPDFSDK_InterForm::ExportFieldsToFDFTextBuf(const CFX_PtrArray& fields,
2378 return TRUE; 2329 FX_BOOL bIncludeOrExclude,
2379 } 2330 CFX_ByteTextBuf& textBuf) {
2380 2331 ASSERT(m_pDocument != NULL);
2381 FX_BOOL CPDFSDK_InterForm::ExportFieldsToFDFFile(const CFX_WideString& sFDFFileN ame, 2332 ASSERT(m_pInterForm != NULL);
2382 const CFX_PtrArray& fields, FX_BOOL bIncludeOrExclude) 2333
2383 { 2334 CFDF_Document* pFDF = m_pInterForm->ExportToFDF(
2384 if (sFDFFileName.IsEmpty()) return FALSE; 2335 m_pDocument->GetPath(), (CFX_PtrArray&)fields, bIncludeOrExclude);
2385 ASSERT(m_pDocument != NULL); 2336 if (!pFDF)
2386 ASSERT(m_pInterForm != NULL); 2337 return FALSE;
2387 2338 FX_BOOL bRet = pFDF->WriteBuf(textBuf); // = FALSE;//
2388 CFDF_Document* pFDF = m_pInterForm->ExportToFDF(m_pDocument->GetPath(),( CFX_PtrArray&)fields, bIncludeOrExclude); 2339 delete pFDF;
2389 if (!pFDF) return FALSE; 2340
2390 FX_BOOL bRet = pFDF->WriteFile(sFDFFileName.UTF8Encode()); // = FALSE;// 2341 return bRet;
2391 delete pFDF; 2342 }
2392 2343
2393 return bRet; 2344 CFX_WideString CPDFSDK_InterForm::GetTemporaryFileName(
2394 } 2345 const CFX_WideString& sFileExt) {
2395 FX_BOOL CPDFSDK_InterForm::ExportFieldsToFDFTextBuf(const CFX_PtrArray& fields,F X_BOOL bIncludeOrExclude, CFX_ByteTextBuf& textBuf) 2346 CFX_WideString sFileName;
2396 { 2347 return L"";
2397 ASSERT(m_pDocument != NULL); 2348 }
2398 ASSERT(m_pInterForm != NULL); 2349
2399 2350 FX_BOOL CPDFSDK_InterForm::SubmitForm(const CFX_WideString& sDestination,
2400 CFDF_Document* pFDF = m_pInterForm->ExportToFDF(m_pDocument->GetPath(),( CFX_PtrArray&)fields, bIncludeOrExclude); 2351 FX_BOOL bUrlEncoded) {
2401 if (!pFDF) return FALSE; 2352 if (sDestination.IsEmpty())
2402 FX_BOOL bRet = pFDF->WriteBuf(textBuf); // = FALSE;// 2353 return FALSE;
2403 delete pFDF; 2354
2404 2355 CPDFDoc_Environment* pEnv = m_pDocument->GetEnv();
2405 return bRet; 2356 ASSERT(pEnv != NULL);
2406 } 2357
2407 2358 if (NULL == m_pDocument)
2408 CFX_WideString CPDFSDK_InterForm::GetTemporaryFileName(const CFX_WideString& sFi leExt) 2359 return FALSE;
2409 { 2360 CFX_WideString wsPDFFilePath = m_pDocument->GetPath();
2410 CFX_WideString sFileName; 2361
2411 return L""; 2362 if (NULL == m_pInterForm)
2412 } 2363 return FALSE;
2413 2364 CFDF_Document* pFDFDoc = m_pInterForm->ExportToFDF(wsPDFFilePath);
2414 FX_BOOL CPDFSDK_InterForm::SubmitForm(const CFX_WideString& sDestination, FX_BOO L bUrlEncoded) 2365 if (NULL == pFDFDoc)
2415 { 2366 return FALSE;
2416 if (sDestination.IsEmpty()) return FALSE; 2367
2417 2368 CFX_ByteTextBuf FdfBuffer;
2418 CPDFDoc_Environment* pEnv = m_pDocument->GetEnv(); 2369 FX_BOOL bRet = pFDFDoc->WriteBuf(FdfBuffer);
2419 ASSERT(pEnv != NULL); 2370 delete pFDFDoc;
2420 2371 if (!bRet)
2421 if(NULL == m_pDocument) return FALSE; 2372 return FALSE;
2422 CFX_WideString wsPDFFilePath = m_pDocument->GetPath(); 2373
2423 2374 FX_LPBYTE pBuffer = FdfBuffer.GetBuffer();
2424 if(NULL == m_pInterForm) return FALSE; 2375 FX_STRSIZE nBufSize = FdfBuffer.GetLength();
2425 CFDF_Document* pFDFDoc = m_pInterForm->ExportToFDF(wsPDFFilePath); 2376
2426 if (NULL == pFDFDoc) return FALSE; 2377 if (bUrlEncoded) {
2427 2378 if (!FDFToURLEncodedData(pBuffer, nBufSize))
2428 CFX_ByteTextBuf FdfBuffer; 2379 return FALSE;
2429 FX_BOOL bRet = pFDFDoc->WriteBuf(FdfBuffer); 2380 }
2430 delete pFDFDoc; 2381
2431 if (!bRet) return FALSE; 2382 pEnv->JS_docSubmitForm(pBuffer, nBufSize, (FX_LPCWSTR)sDestination);
2432 2383
2433 FX_LPBYTE pBuffer = FdfBuffer.GetBuffer(); 2384 if (bUrlEncoded && pBuffer) {
2434 FX_STRSIZE nBufSize = FdfBuffer.GetLength(); 2385 FX_Free(pBuffer);
2435 2386 pBuffer = NULL;
2436 if (bUrlEncoded) 2387 }
2437 { 2388
2438 if(!FDFToURLEncodedData(pBuffer, nBufSize)) 2389 return TRUE;
2439 return FALSE; 2390 }
2440 } 2391
2441 2392 FX_BOOL CPDFSDK_InterForm::ExportFormToFDFFile(
2442 pEnv->JS_docSubmitForm(pBuffer, nBufSize, (FX_LPCWSTR)sDestination); 2393 const CFX_WideString& sFDFFileName) {
2443 2394 if (sFDFFileName.IsEmpty())
2444 if (bUrlEncoded && pBuffer) 2395 return FALSE;
2445 { 2396
2446 FX_Free(pBuffer); 2397 ASSERT(m_pInterForm != NULL);
2447 pBuffer = NULL; 2398 ASSERT(m_pDocument != NULL);
2448 } 2399
2449 2400 CFDF_Document* pFDF = m_pInterForm->ExportToFDF(m_pDocument->GetPath());
2450 return TRUE; 2401 if (!pFDF)
2451 } 2402 return FALSE;
2452 2403
2453 FX_BOOL CPDFSDK_InterForm::ExportFormToFDFFile(const CFX_WideString& sFDFFileNam e) 2404 FX_BOOL bRet = pFDF->WriteFile(sFDFFileName.UTF8Encode());
2454 { 2405 delete pFDF;
2455 if (sFDFFileName.IsEmpty()) return FALSE; 2406
2456 2407 return bRet;
2457 ASSERT(m_pInterForm != NULL); 2408 }
2458 ASSERT(m_pDocument != NULL); 2409
2459 2410 FX_BOOL CPDFSDK_InterForm::ExportFormToFDFTextBuf(CFX_ByteTextBuf& textBuf) {
2460 CFDF_Document* pFDF = m_pInterForm->ExportToFDF(m_pDocument->GetPath()); 2411 ASSERT(m_pInterForm != NULL);
2461 if (!pFDF) return FALSE; 2412 ASSERT(m_pDocument != NULL);
2462 2413
2463 FX_BOOL bRet = pFDF->WriteFile(sFDFFileName.UTF8Encode()); 2414 CFDF_Document* pFDF = m_pInterForm->ExportToFDF(m_pDocument->GetPath());
2464 delete pFDF; 2415 if (!pFDF)
2465 2416 return FALSE;
2466 return bRet; 2417
2467 } 2418 FX_BOOL bRet = pFDF->WriteBuf(textBuf);
2468 2419 delete pFDF;
2469 FX_BOOL CPDFSDK_InterForm::ExportFormToFDFTextBuf(CFX_ByteTextBuf& textBuf) 2420
2470 { 2421 return bRet;
2471 2422 }
2472 ASSERT(m_pInterForm != NULL); 2423
2473 ASSERT(m_pDocument != NULL); 2424 FX_BOOL CPDFSDK_InterForm::ExportFormToTxtFile(
2474 2425 const CFX_WideString& sTxtFileName) {
2475 CFDF_Document* pFDF = m_pInterForm->ExportToFDF(m_pDocument->GetPath()); 2426 ASSERT(m_pInterForm != NULL);
2476 if (!pFDF) return FALSE; 2427
2477 2428 CFX_WideString sFieldNames;
2478 FX_BOOL bRet = pFDF->WriteBuf(textBuf); 2429 CFX_WideString sFieldValues;
2479 delete pFDF; 2430
2480 2431 int nSize = m_pInterForm->CountFields();
2481 return bRet; 2432
2482 } 2433 if (nSize > 0) {
2483 2434 for (int i = 0; i < nSize; i++) {
2484 FX_BOOL CPDFSDK_InterForm::ExportFormToTxtFile(const CFX_WideString& sTxtFileNam e) 2435 CPDF_FormField* pField = m_pInterForm->GetField(i);
2485 { 2436 ASSERT(pField != NULL);
2486 ASSERT(m_pInterForm != NULL); 2437
2487 2438 if (i != 0) {
2488 CFX_WideString sFieldNames; 2439 sFieldNames += L"\t";
2489 CFX_WideString sFieldValues; 2440 sFieldValues += L"\t";
2490 2441 }
2491 int nSize = m_pInterForm->CountFields(); 2442 sFieldNames += pField->GetFullName();
2492 2443 sFieldValues += pField->GetValue();
2493 if (nSize > 0) 2444 }
2494 { 2445
2495 for (int i=0; i<nSize; i++) 2446 return TRUE;
2496 { 2447 }
2497 CPDF_FormField* pField = m_pInterForm->GetField(i); 2448
2498 ASSERT(pField != NULL); 2449 return FALSE;
2499 2450 }
2500 if (i != 0) 2451
2501 { 2452 FX_BOOL CPDFSDK_InterForm::ImportFormFromTxtFile(
2502 sFieldNames += L"\t"; 2453 const CFX_WideString& sTxtFileName) {
2503 sFieldValues += L"\t"; 2454 ASSERT(m_pInterForm != NULL);
2504 } 2455
2505 sFieldNames += pField->GetFullName(); 2456 return TRUE;
2506 sFieldValues += pField->GetValue(); 2457 }
2507 } 2458
2508 2459 FX_BOOL CPDFSDK_InterForm::DoAction_ResetForm(const CPDF_Action& action) {
2509 return TRUE; 2460 ASSERT(action != NULL);
2510 } 2461
2511 2462 CPDF_Dictionary* pActionDict = action;
2512 return FALSE; 2463
2513 } 2464 if (pActionDict->KeyExist("Fields")) {
2514 2465 CPDF_ActionFields af = action.GetWidgets();
2515 FX_BOOL CPDFSDK_InterForm::ImportFormFromTxtFile(const CFX_WideString& sTxtFileN ame) 2466 FX_DWORD dwFlags = action.GetFlags();
2516 { 2467
2517 ASSERT(m_pInterForm != NULL); 2468 CFX_PtrArray fieldObjects;
2518 2469 af.GetAllFields(fieldObjects);
2519 return TRUE; 2470 CFX_PtrArray fields;
2520 } 2471 GetFieldFromObjects(fieldObjects, fields);
2521 2472
2522 FX_BOOL CPDFSDK_InterForm::DoAction_ResetForm(const CPDF_Action& action) 2473 ASSERT(m_pInterForm != NULL);
2523 { 2474
2524 ASSERT(action != NULL); 2475 return m_pInterForm->ResetForm(fields, !(dwFlags & 0x01), TRUE);
2525 2476 } else {
2526 CPDF_Dictionary* pActionDict = action; 2477 ASSERT(m_pInterForm != NULL);
2527 2478 return m_pInterForm->ResetForm(TRUE);
2528 if (pActionDict->KeyExist("Fields")) 2479 }
2529 { 2480 }
2530 CPDF_ActionFields af = action.GetWidgets(); 2481
2531 FX_DWORD dwFlags = action.GetFlags(); 2482 FX_BOOL CPDFSDK_InterForm::DoAction_ImportData(const CPDF_Action& action) {
2532 2483 ASSERT(action != NULL);
2533 CFX_PtrArray fieldObjects; 2484
2534 af.GetAllFields(fieldObjects); 2485 CFX_WideString sFilePath = action.GetFilePath();
2535 CFX_PtrArray fields; 2486 if (sFilePath.IsEmpty())
2536 GetFieldFromObjects(fieldObjects, fields); 2487 return FALSE;
2537 2488
2538 ASSERT(m_pInterForm != NULL); 2489 if (!ImportFormFromFDFFile(sFilePath, TRUE)) {
2539 2490 return FALSE;
2540 return m_pInterForm->ResetForm(fields, !(dwFlags & 0x01), TRUE); 2491 }
2541 } 2492
2542 else 2493 return TRUE;
2543 { 2494 }
2544 ASSERT(m_pInterForm != NULL); 2495
2545 return m_pInterForm->ResetForm(TRUE); 2496 FX_BOOL CPDFSDK_InterForm::ImportFormFromFDFFile(
2546 } 2497 const CFX_WideString& csFDFFileName,
2547 } 2498 FX_BOOL bNotify) {
2548 2499 return FALSE;
2549 FX_BOOL CPDFSDK_InterForm::DoAction_ImportData(const CPDF_Action& action) 2500 }
2550 { 2501
2551 ASSERT(action != NULL); 2502 void CPDFSDK_InterForm::GetFieldFromObjects(const CFX_PtrArray& objects,
2552 2503 CFX_PtrArray& fields) {
2553 CFX_WideString sFilePath = action.GetFilePath(); 2504 ASSERT(m_pInterForm != NULL);
2554 if (sFilePath.IsEmpty()) 2505
2555 return FALSE; 2506 int iCount = objects.GetSize();
2556 2507 for (int i = 0; i < iCount; i++) {
2557 if (!ImportFormFromFDFFile(sFilePath, TRUE)) 2508 CPDF_Object* pObject = (CPDF_Object*)objects[i];
2558 { 2509 if (pObject == NULL)
2559 return FALSE; 2510 continue;
2560 } 2511
2561 2512 int iType = pObject->GetType();
2562 return TRUE; 2513 if (iType == PDFOBJ_STRING) {
2563 } 2514 CFX_WideString csName = pObject->GetUnicodeText();
2564 2515 CPDF_FormField* pField = m_pInterForm->GetField(0, csName);
2565 FX_BOOL CPDFSDK_InterForm::ImportFormFromFDFFile(const CFX_WideString& csFDFFile Name, 2516 if (pField != NULL)
2566 FX_BOOL bNotify) 2517 fields.Add(pField);
2567 { 2518 } else if (iType == PDFOBJ_DICTIONARY) {
2568 return FALSE; 2519 if (m_pInterForm->IsValidFormField(pObject))
2569 } 2520 fields.Add(pObject);
2570 2521 }
2571 void CPDFSDK_InterForm::GetFieldFromObjects(const CFX_PtrArray& objects, CFX_Ptr Array& fields) 2522 }
2572 { 2523 }
2573 ASSERT(m_pInterForm != NULL); 2524
2574 2525 /* ----------------------------- CPDF_FormNotify -----------------------------
2575 int iCount = objects.GetSize(); 2526 */
2576 for (int i = 0; i < iCount; i ++) 2527
2577 { 2528 int CPDFSDK_InterForm::BeforeValueChange(const CPDF_FormField* pField,
2578 CPDF_Object* pObject = (CPDF_Object*)objects[i]; 2529 CFX_WideString& csValue) {
2579 if (pObject == NULL) continue; 2530 ASSERT(pField != NULL);
2580 2531
2581 int iType = pObject->GetType(); 2532 CPDF_FormField* pFormField = (CPDF_FormField*)pField;
2582 if (iType == PDFOBJ_STRING) 2533
2583 { 2534 int nType = pFormField->GetFieldType();
2584 CFX_WideString csName = pObject->GetUnicodeText(); 2535 if (nType == FIELDTYPE_COMBOBOX || nType == FIELDTYPE_TEXTFIELD) {
2585 CPDF_FormField* pField = m_pInterForm->GetField(0, csNam e); 2536 FX_BOOL bRC = TRUE;
2586 if (pField != NULL) 2537 OnKeyStrokeCommit(pFormField, csValue, bRC);
2587 fields.Add(pField); 2538 if (bRC) {
2588 } 2539 OnValidate(pFormField, csValue, bRC);
2589 else if (iType == PDFOBJ_DICTIONARY) 2540 if (bRC)
2590 { 2541 return 1;
2591 if (m_pInterForm->IsValidFormField(pObject)) 2542 else
2592 fields.Add(pObject); 2543 return -1;
2593 } 2544 } else
2594 } 2545 return -1;
2595 } 2546 } else
2596 2547 return 0;
2597 /* ----------------------------- CPDF_FormNotify ----------------------------- * / 2548 }
2598 2549
2599 int CPDFSDK_InterForm::BeforeValueChange(const CPDF_FormField* pField, CFX_W ideString& csValue) 2550 int CPDFSDK_InterForm::AfterValueChange(const CPDF_FormField* pField) {
2600 { 2551 ASSERT(pField != NULL);
2601 ASSERT(pField != NULL); 2552
2602 2553 CPDF_FormField* pFormField = (CPDF_FormField*)pField;
2603 CPDF_FormField* pFormField = (CPDF_FormField*)pField; 2554 int nType = pFormField->GetFieldType();
2604 2555
2605 int nType = pFormField->GetFieldType(); 2556 if (nType == FIELDTYPE_COMBOBOX || nType == FIELDTYPE_TEXTFIELD) {
2606 if (nType == FIELDTYPE_COMBOBOX || nType == FIELDTYPE_TEXTFIELD) 2557 this->OnCalculate(pFormField);
2607 { 2558 FX_BOOL bFormated = FALSE;
2608 FX_BOOL bRC = TRUE; 2559 CFX_WideString sValue = this->OnFormat(pFormField, 0, bFormated);
2609 OnKeyStrokeCommit(pFormField, csValue, bRC); 2560 if (bFormated)
2610 if (bRC) 2561 this->ResetFieldAppearance(pFormField, sValue, TRUE);
2611 { 2562 else
2612 OnValidate(pFormField, csValue, bRC); 2563 this->ResetFieldAppearance(pFormField, NULL, TRUE);
2613 if (bRC) 2564 this->UpdateField(pFormField);
2614 return 1; 2565 }
2615 else 2566
2616 return -1; 2567 return 0;
2617 } 2568 }
2618 else 2569
2619 return -1; 2570 int CPDFSDK_InterForm::BeforeSelectionChange(const CPDF_FormField* pField,
2620 } 2571 CFX_WideString& csValue) {
2621 else 2572 ASSERT(pField != NULL);
2622 return 0; 2573
2623 } 2574 CPDF_FormField* pFormField = (CPDF_FormField*)pField;
2624 2575
2625 int CPDFSDK_InterForm::AfterValueChange(const CPDF_FormField* pField) 2576 int nType = pFormField->GetFieldType();
2626 { 2577 if (nType == FIELDTYPE_LISTBOX) {
2627 ASSERT(pField != NULL); 2578 FX_BOOL bRC = TRUE;
2628 2579 OnKeyStrokeCommit(pFormField, csValue, bRC);
2629 CPDF_FormField* pFormField = (CPDF_FormField*)pField; 2580 if (bRC) {
2630 int nType = pFormField->GetFieldType(); 2581 OnValidate(pFormField, csValue, bRC);
2631 2582 if (bRC)
2632 if (nType == FIELDTYPE_COMBOBOX || nType == FIELDTYPE_TEXTFIELD) 2583 return 1;
2633 { 2584 else
2634 this->OnCalculate(pFormField); 2585 return -1;
2635 FX_BOOL bFormated = FALSE; 2586 } else
2636 CFX_WideString sValue = this->OnFormat(pFormField, 0, bFormated) ; 2587 return -1;
2637 if (bFormated) 2588 } else
2638 this->ResetFieldAppearance(pFormField, sValue, TRUE); 2589 return 0;
2639 else 2590 }
2640 this->ResetFieldAppearance(pFormField, NULL, TRUE); 2591
2641 this->UpdateField(pFormField); 2592 int CPDFSDK_InterForm::AfterSelectionChange(const CPDF_FormField* pField) {
2642 } 2593 ASSERT(pField != NULL);
2643 2594
2644 return 0; 2595 CPDF_FormField* pFormField = (CPDF_FormField*)pField;
2645 } 2596 int nType = pFormField->GetFieldType();
2646 2597
2647 int CPDFSDK_InterForm::BeforeSelectionChange(const CPDF_FormField* pField, C FX_WideString& csValue) 2598 if (nType == FIELDTYPE_LISTBOX) {
2648 { 2599 this->OnCalculate(pFormField);
2649 ASSERT(pField != NULL); 2600 this->ResetFieldAppearance(pFormField, NULL, TRUE);
2650 2601 this->UpdateField(pFormField);
2651 CPDF_FormField* pFormField = (CPDF_FormField*)pField; 2602 }
2652 2603
2653 int nType = pFormField->GetFieldType(); 2604 return 0;
2654 if (nType == FIELDTYPE_LISTBOX) 2605 }
2655 { 2606
2656 FX_BOOL bRC = TRUE; 2607 int CPDFSDK_InterForm::AfterCheckedStatusChange(
2657 OnKeyStrokeCommit(pFormField, csValue, bRC); 2608 const CPDF_FormField* pField,
2658 if (bRC) 2609 const CFX_ByteArray& statusArray) {
2659 { 2610 ASSERT(pField != NULL);
2660 OnValidate(pFormField, csValue, bRC); 2611
2661 if (bRC) 2612 CPDF_FormField* pFormField = (CPDF_FormField*)pField;
2662 return 1; 2613 int nType = pFormField->GetFieldType();
2663 else 2614
2664 return -1; 2615 if (nType == FIELDTYPE_CHECKBOX || nType == FIELDTYPE_RADIOBUTTON) {
2665 } 2616 this->OnCalculate(pFormField);
2666 else 2617 // this->ResetFieldAppearance(pFormField, NULL);
2667 return -1; 2618 this->UpdateField(pFormField);
2668 } 2619 }
2669 else 2620
2670 return 0; 2621 return 0;
2671 } 2622 }
2672 2623
2673 int CPDFSDK_InterForm::AfterSelectionChange(const CPDF_FormField* pField) 2624 int CPDFSDK_InterForm::BeforeFormReset(const CPDF_InterForm* pForm) {
2674 { 2625 return 0;
2675 ASSERT(pField != NULL); 2626 }
2676 2627
2677 CPDF_FormField* pFormField = (CPDF_FormField*)pField; 2628 int CPDFSDK_InterForm::AfterFormReset(const CPDF_InterForm* pForm) {
2678 int nType = pFormField->GetFieldType(); 2629 this->OnCalculate(NULL);
2679 2630
2680 if (nType == FIELDTYPE_LISTBOX) 2631 return 0;
2681 { 2632 }
2682 this->OnCalculate(pFormField); 2633
2683 this->ResetFieldAppearance(pFormField, NULL, TRUE); 2634 int CPDFSDK_InterForm::BeforeFormImportData(const CPDF_InterForm* pForm) {
2684 this->UpdateField(pFormField); 2635 return 0;
2685 } 2636 }
2686 2637
2687 return 0; 2638 int CPDFSDK_InterForm::AfterFormImportData(const CPDF_InterForm* pForm) {
2688 } 2639 this->OnCalculate(NULL);
2689 2640
2690 int CPDFSDK_InterForm::AfterCheckedStatusChange(const CPDF_FormField* pField , const CFX_ByteArray& statusArray) 2641 return 0;
2691 { 2642 }
2692 ASSERT(pField != NULL); 2643
2693 2644 FX_BOOL CPDFSDK_InterForm::IsNeedHighLight(int nFieldType) {
2694 CPDF_FormField* pFormField = (CPDF_FormField*)pField; 2645 if (nFieldType < 1 || nFieldType > 6)
2695 int nType = pFormField->GetFieldType(); 2646 return FALSE;
2696 2647 return m_bNeedHightlight[nFieldType - 1];
2697 if (nType == FIELDTYPE_CHECKBOX || nType == FIELDTYPE_RADIOBUTTON) 2648 }
2698 { 2649
2699 this->OnCalculate(pFormField); 2650 void CPDFSDK_InterForm::RemoveAllHighLight() {
2700 //this->ResetFieldAppearance(pFormField, NULL); 2651 memset((void*)m_bNeedHightlight, 0, 6 * sizeof(FX_BOOL));
2701 this->UpdateField(pFormField); 2652 }
2702 } 2653 void CPDFSDK_InterForm::SetHighlightColor(FX_COLORREF clr, int nFieldType) {
2703 2654 if (nFieldType < 0 || nFieldType > 6)
2704 return 0; 2655 return;
2705 } 2656 switch (nFieldType) {
2706 2657 case 0: {
2707 int CPDFSDK_InterForm::BeforeFormReset(const CPDF_InterForm* pForm) 2658 for (int i = 0; i < 6; i++) {
2708 { 2659 m_aHighlightColor[i] = clr;
2709 return 0; 2660 m_bNeedHightlight[i] = TRUE;
2710 } 2661 }
2711 2662 break;
2712 int CPDFSDK_InterForm::AfterFormReset(const CPDF_InterForm* pForm) 2663 }
2713 { 2664 default: {
2714 this->OnCalculate(NULL); 2665 m_aHighlightColor[nFieldType - 1] = clr;
2715 2666 m_bNeedHightlight[nFieldType - 1] = TRUE;
2716 return 0; 2667 break;
2717 } 2668 }
2718 2669 }
2719 int CPDFSDK_InterForm::BeforeFormImportData(const CPDF_InterForm* pForm) 2670 }
2720 { 2671
2721 return 0; 2672 FX_COLORREF CPDFSDK_InterForm::GetHighlightColor(int nFieldType) {
2722 } 2673 if (nFieldType < 0 || nFieldType > 6)
2723 2674 return FXSYS_RGB(255, 255, 255);
2724 int CPDFSDK_InterForm::AfterFormImportData(const CPDF_InterForm* pForm) 2675 if (nFieldType == 0)
2725 { 2676 return m_aHighlightColor[0];
2726 this->OnCalculate(NULL); 2677 else
2727 2678 return m_aHighlightColor[nFieldType - 1];
2728 return 0;
2729 }
2730
2731 FX_BOOL CPDFSDK_InterForm::IsNeedHighLight(int nFieldType)
2732 {
2733 if(nFieldType <1 || nFieldType > 6)
2734 return FALSE;
2735 return m_bNeedHightlight[nFieldType-1];
2736 }
2737
2738 void CPDFSDK_InterForm::RemoveAllHighLight()
2739 {
2740 memset((void*)m_bNeedHightlight, 0, 6*sizeof(FX_BOOL));
2741 }
2742 void CPDFSDK_InterForm::SetHighlightColor(FX_COLORREF clr, int nFieldType)
2743 {
2744 if(nFieldType <0 || nFieldType > 6) return;
2745 switch(nFieldType)
2746 {
2747 case 0:
2748 {
2749 for(int i=0; i<6; i++)
2750 {
2751 m_aHighlightColor[i] = clr;
2752 m_bNeedHightlight[i] = TRUE;
2753 }
2754 break;
2755 }
2756 default:
2757 {
2758 m_aHighlightColor[nFieldType-1] = clr;
2759 m_bNeedHightlight[nFieldType-1] = TRUE;
2760 break;
2761 }
2762 }
2763
2764 }
2765
2766 FX_COLORREF CPDFSDK_InterForm::GetHighlightColor(int nFieldType)
2767 {
2768 if(nFieldType <0 || nFieldType >6) return FXSYS_RGB(255,255,255);
2769 if(nFieldType == 0)
2770 return m_aHighlightColor[0];
2771 else
2772 return m_aHighlightColor[nFieldType-1];
2773 } 2679 }
2774 2680
2775 /* ------------------------- CBA_AnnotIterator ------------------------- */ 2681 /* ------------------------- CBA_AnnotIterator ------------------------- */
2776 2682
2777 CBA_AnnotIterator::CBA_AnnotIterator(CPDFSDK_PageView* pPageView, const CFX_Byte String& sType, const CFX_ByteString& sSubType) 2683 CBA_AnnotIterator::CBA_AnnotIterator(CPDFSDK_PageView* pPageView,
2778 :m_pPageView(pPageView), 2684 const CFX_ByteString& sType,
2779 m_sType(sType), 2685 const CFX_ByteString& sSubType)
2780 m_sSubType(sSubType), 2686 : m_pPageView(pPageView),
2781 m_nTabs(BAI_STRUCTURE) 2687 m_sType(sType),
2782 { 2688 m_sSubType(sSubType),
2783 ASSERT(m_pPageView != NULL); 2689 m_nTabs(BAI_STRUCTURE) {
2784 2690 ASSERT(m_pPageView != NULL);
2785 CPDF_Page* pPDFPage = m_pPageView->GetPDFPage(); 2691
2786 ASSERT(pPDFPage != NULL); 2692 CPDF_Page* pPDFPage = m_pPageView->GetPDFPage();
2787 ASSERT(pPDFPage->m_pFormDict != NULL); 2693 ASSERT(pPDFPage != NULL);
2788 2694 ASSERT(pPDFPage->m_pFormDict != NULL);
2789 CFX_ByteString sTabs = pPDFPage->m_pFormDict->GetString("Tabs"); 2695
2790 2696 CFX_ByteString sTabs = pPDFPage->m_pFormDict->GetString("Tabs");
2791 if (sTabs == "R") 2697
2792 { 2698 if (sTabs == "R") {
2793 m_nTabs = BAI_ROW; 2699 m_nTabs = BAI_ROW;
2794 } 2700 } else if (sTabs == "C") {
2795 else if (sTabs == "C") 2701 m_nTabs = BAI_COLUMN;
2796 { 2702 } else {
2797 m_nTabs = BAI_COLUMN; 2703 m_nTabs = BAI_STRUCTURE;
2798 } 2704 }
2799 else 2705
2800 { 2706 GenerateResults();
2801 m_nTabs = BAI_STRUCTURE; 2707 }
2802 } 2708
2803 2709 CBA_AnnotIterator::~CBA_AnnotIterator() {
2804 GenerateResults(); 2710 m_Annots.RemoveAll();
2805 } 2711 }
2806 2712
2807 CBA_AnnotIterator::~CBA_AnnotIterator() 2713 CPDFSDK_Annot* CBA_AnnotIterator::GetFirstAnnot() {
2808 { 2714 if (m_Annots.GetSize() > 0)
2809 m_Annots.RemoveAll(); 2715 return m_Annots[0];
2810 } 2716
2811 2717 return NULL;
2812 CPDFSDK_Annot* CBA_AnnotIterator::GetFirstAnnot() 2718 }
2813 { 2719
2814 if (m_Annots.GetSize() > 0) 2720 CPDFSDK_Annot* CBA_AnnotIterator::GetLastAnnot() {
2815 return m_Annots[0]; 2721 if (m_Annots.GetSize() > 0)
2816 2722 return m_Annots[m_Annots.GetSize() - 1];
2817 return NULL; 2723
2818 } 2724 return NULL;
2819 2725 }
2820 CPDFSDK_Annot* CBA_AnnotIterator::GetLastAnnot() 2726
2821 { 2727 CPDFSDK_Annot* CBA_AnnotIterator::GetNextAnnot(CPDFSDK_Annot* pAnnot) {
2822 if (m_Annots.GetSize() > 0) 2728 for (int i = 0, sz = m_Annots.GetSize(); i < sz; i++) {
2823 return m_Annots[m_Annots.GetSize() - 1]; 2729 if (m_Annots[i] == pAnnot) {
2824 2730 if (i + 1 < sz)
2825 return NULL; 2731 return m_Annots[i + 1];
2826 } 2732 else
2827 2733 return m_Annots[0];
2828 CPDFSDK_Annot* CBA_AnnotIterator::GetNextAnnot(CPDFSDK_Annot* pAnnot) 2734 }
2829 { 2735 }
2830 for (int i=0,sz=m_Annots.GetSize(); i<sz; i++) 2736
2831 { 2737 return NULL;
2832 if (m_Annots[i] == pAnnot) 2738 }
2833 { 2739
2834 if (i+1 < sz) 2740 CPDFSDK_Annot* CBA_AnnotIterator::GetPrevAnnot(CPDFSDK_Annot* pAnnot) {
2835 return m_Annots[i+1]; 2741 for (int i = 0, sz = m_Annots.GetSize(); i < sz; i++) {
2836 else 2742 if (m_Annots[i] == pAnnot) {
2837 return m_Annots[0]; 2743 if (i - 1 >= 0)
2838 } 2744 return m_Annots[i - 1];
2839 } 2745 else
2840 2746 return m_Annots[sz - 1];
2841 return NULL; 2747 }
2842 } 2748 }
2843 2749
2844 CPDFSDK_Annot* CBA_AnnotIterator::GetPrevAnnot(CPDFSDK_Annot* pAnnot) 2750 return NULL;
2845 { 2751 }
2846 for (int i=0,sz=m_Annots.GetSize(); i<sz; i++) 2752
2847 { 2753 int CBA_AnnotIterator::CompareByLeft(CPDFSDK_Annot* p1, CPDFSDK_Annot* p2) {
2848 if (m_Annots[i] == pAnnot) 2754 ASSERT(p1 != NULL);
2849 { 2755 ASSERT(p2 != NULL);
2850 if (i-1 >= 0) 2756
2851 return m_Annots[i-1]; 2757 CPDF_Rect rcAnnot1 = GetAnnotRect(p1);
2852 else 2758 CPDF_Rect rcAnnot2 = GetAnnotRect(p2);
2853 return m_Annots[sz-1]; 2759
2854 } 2760 if (rcAnnot1.left < rcAnnot2.left)
2855 } 2761 return -1;
2856 2762 if (rcAnnot1.left > rcAnnot2.left)
2857 return NULL; 2763 return 1;
2858 } 2764 return 0;
2859 2765 }
2860 int CBA_AnnotIterator::CompareByLeft(CPDFSDK_Annot* p1, CPDFSDK_Annot* p2) 2766
2861 { 2767 int CBA_AnnotIterator::CompareByTop(CPDFSDK_Annot* p1, CPDFSDK_Annot* p2) {
2862 ASSERT(p1 != NULL); 2768 ASSERT(p1 != NULL);
2863 ASSERT(p2 != NULL); 2769 ASSERT(p2 != NULL);
2864 2770
2865 CPDF_Rect rcAnnot1 = GetAnnotRect(p1); 2771 CPDF_Rect rcAnnot1 = GetAnnotRect(p1);
2866 CPDF_Rect rcAnnot2 = GetAnnotRect(p2); 2772 CPDF_Rect rcAnnot2 = GetAnnotRect(p2);
2867 2773
2868 if (rcAnnot1.left < rcAnnot2.left) 2774 if (rcAnnot1.top < rcAnnot2.top)
2869 return -1; 2775 return -1;
2870 if (rcAnnot1.left > rcAnnot2.left) 2776 if (rcAnnot1.top > rcAnnot2.top)
2871 return 1; 2777 return 1;
2872 return 0; 2778 return 0;
2873 } 2779 }
2874 2780
2875 2781 void CBA_AnnotIterator::GenerateResults() {
2876 int CBA_AnnotIterator::CompareByTop(CPDFSDK_Annot* p1, CPDFSDK_Annot* p2) 2782 ASSERT(m_pPageView != NULL);
2877 { 2783
2878 ASSERT(p1 != NULL); 2784 switch (m_nTabs) {
2879 ASSERT(p2 != NULL); 2785 case BAI_STRUCTURE: {
2880 2786 for (int i = 0, sz = m_pPageView->CountAnnots(); i < sz; i++) {
2881 CPDF_Rect rcAnnot1 = GetAnnotRect(p1); 2787 CPDFSDK_Annot* pAnnot = m_pPageView->GetAnnot(i);
2882 CPDF_Rect rcAnnot2 = GetAnnotRect(p2); 2788 ASSERT(pAnnot != NULL);
2883 2789
2884 if (rcAnnot1.top < rcAnnot2.top) 2790 if (pAnnot->GetType() == m_sType && pAnnot->GetSubType() == m_sSubType)
2885 return -1; 2791 m_Annots.Add(pAnnot);
2886 if (rcAnnot1.top > rcAnnot2.top) 2792 }
2887 return 1; 2793 } break;
2888 return 0; 2794 case BAI_ROW: {
2889 } 2795 CPDFSDK_SortAnnots sa;
2890 2796
2891 void CBA_AnnotIterator::GenerateResults() 2797 {
2892 { 2798 for (int i = 0, sz = m_pPageView->CountAnnots(); i < sz; i++) {
2893 ASSERT(m_pPageView != NULL); 2799 CPDFSDK_Annot* pAnnot = m_pPageView->GetAnnot(i);
2894 2800 ASSERT(pAnnot != NULL);
2895 switch (m_nTabs) 2801
2896 { 2802 if (pAnnot->GetType() == m_sType &&
2897 case BAI_STRUCTURE: 2803 pAnnot->GetSubType() == m_sSubType)
2898 { 2804 sa.Add(pAnnot);
2899 for (int i=0,sz=m_pPageView->CountAnnots(); i<sz; i++) 2805 }
2900 { 2806 }
2901 CPDFSDK_Annot* pAnnot = m_pPageView->GetAnnot(i) ; 2807
2902 ASSERT(pAnnot != NULL); 2808 if (sa.GetSize() > 0) {
2903 2809 sa.Sort(CBA_AnnotIterator::CompareByLeft);
2904 if (pAnnot->GetType() == m_sType 2810 }
2905 && pAnnot->GetSubType() == m_sSubType) 2811
2906 m_Annots.Add(pAnnot); 2812 while (sa.GetSize() > 0) {
2907 } 2813 int nLeftTopIndex = -1;
2908 } 2814
2909 break; 2815 {
2910 case BAI_ROW: 2816 FX_FLOAT fTop = 0.0f;
2911 { 2817
2912 CPDFSDK_SortAnnots sa; 2818 for (int i = sa.GetSize() - 1; i >= 0; i--) {
2913 2819 CPDFSDK_Annot* pAnnot = sa.GetAt(i);
2914 { 2820 ASSERT(pAnnot != NULL);
2915 2821
2916 for (int i=0,sz=m_pPageView->CountAnnots(); i<sz ; i++) 2822 CPDF_Rect rcAnnot = GetAnnotRect(pAnnot);
2917 { 2823
2918 CPDFSDK_Annot* pAnnot = m_pPageView->Get Annot(i); 2824 if (rcAnnot.top > fTop) {
2919 ASSERT(pAnnot != NULL); 2825 nLeftTopIndex = i;
2920 2826 fTop = rcAnnot.top;
2921 if (pAnnot->GetType() == m_sType 2827 }
2922 && pAnnot->GetSubType() == m_sSu bType) 2828 }
2923 sa.Add(pAnnot); 2829 }
2924 } 2830
2925 } 2831 if (nLeftTopIndex >= 0) {
2926 2832 CPDFSDK_Annot* pLeftTopAnnot = sa.GetAt(nLeftTopIndex);
2927 if (sa.GetSize() > 0) 2833 ASSERT(pLeftTopAnnot != NULL);
2928 { 2834
2929 sa.Sort(CBA_AnnotIterator::CompareByLeft); 2835 CPDF_Rect rcLeftTop = GetAnnotRect(pLeftTopAnnot);
2930 } 2836
2931 2837 m_Annots.Add(pLeftTopAnnot);
2932 while (sa.GetSize() > 0) 2838 sa.RemoveAt(nLeftTopIndex);
2933 { 2839
2934 int nLeftTopIndex = -1; 2840 CFX_ArrayTemplate<int> aSelect;
2935 2841
2936 { 2842 {
2937 FX_FLOAT fTop = 0.0f; 2843 for (int i = 0, sz = sa.GetSize(); i < sz; i++) {
2938 2844 CPDFSDK_Annot* pAnnot = sa.GetAt(i);
2939 for (int i=sa.GetSize()-1; i>=0; i--) 2845 ASSERT(pAnnot != NULL);
2940 { 2846
2941 CPDFSDK_Annot* pAnnot = sa.GetAt (i); 2847 CPDF_Rect rcAnnot = GetAnnotRect(pAnnot);
2942 ASSERT(pAnnot != NULL); 2848
2943 2849 FX_FLOAT fCenterY = (rcAnnot.top + rcAnnot.bottom) / 2.0f;
2944 CPDF_Rect rcAnnot = GetAnnotRect (pAnnot); 2850
2945 2851 if (fCenterY > rcLeftTop.bottom && fCenterY < rcLeftTop.top)
2946 if (rcAnnot.top > fTop) 2852 aSelect.Add(i);
2947 { 2853 }
2948 nLeftTopIndex = i; 2854 }
2949 fTop = rcAnnot.top; 2855
2950 } 2856 {
2951 } 2857 for (int i = 0, sz = aSelect.GetSize(); i < sz; i++) {
2952 } 2858 m_Annots.Add(sa[aSelect[i]]);
2953 2859 }
2954 if (nLeftTopIndex >= 0) 2860 }
2955 { 2861
2956 CPDFSDK_Annot* pLeftTopAnnot = sa.GetAt( nLeftTopIndex); 2862 {
2957 ASSERT(pLeftTopAnnot != NULL); 2863 for (int i = aSelect.GetSize() - 1; i >= 0; i--) {
2958 2864 sa.RemoveAt(aSelect[i]);
2959 CPDF_Rect rcLeftTop = GetAnnotRect(pLeft TopAnnot); 2865 }
2960 2866 }
2961 m_Annots.Add(pLeftTopAnnot); 2867
2962 sa.RemoveAt(nLeftTopIndex); 2868 aSelect.RemoveAll();
2963 2869 }
2964 CFX_ArrayTemplate<int> aSelect; 2870 }
2965 2871 sa.RemoveAll();
2966 { 2872 } break;
2967 for (int i=0,sz=sa.GetSize(); i< sz; i++) 2873 case BAI_COLUMN: {
2968 { 2874 CPDFSDK_SortAnnots sa;
2969 CPDFSDK_Annot* pAnnot = sa.GetAt(i); 2875
2970 ASSERT(pAnnot != NULL); 2876 {
2971 2877 for (int i = 0, sz = m_pPageView->CountAnnots(); i < sz; i++) {
2972 CPDF_Rect rcAnnot = GetA nnotRect(pAnnot); 2878 CPDFSDK_Annot* pAnnot = m_pPageView->GetAnnot(i);
2973 2879 ASSERT(pAnnot != NULL);
2974 FX_FLOAT fCenterY = (rcA nnot.top + rcAnnot.bottom) / 2.0f; 2880
2975 2881 if (pAnnot->GetType() == m_sType &&
2976 if (fCenterY > rcLeftTop .bottom && fCenterY < rcLeftTop.top) 2882 pAnnot->GetSubType() == m_sSubType)
2977 aSelect.Add(i); 2883 sa.Add(pAnnot);
2978 } 2884 }
2979 } 2885 }
2980 2886
2981 { 2887 if (sa.GetSize() > 0) {
2982 for (int i=0,sz=aSelect.GetSize( ); i<sz; i++) 2888 sa.Sort(CBA_AnnotIterator::CompareByTop, FALSE);
2983 { 2889 }
2984 m_Annots.Add(sa[aSelect[ i]]); 2890
2985 } 2891 while (sa.GetSize() > 0) {
2986 } 2892 int nLeftTopIndex = -1;
2987 2893
2988 { 2894 {
2989 for (int i=aSelect.GetSize()-1; i>=0; i--) 2895 FX_FLOAT fLeft = -1.0f;
2990 { 2896
2991 sa.RemoveAt(aSelect[i]); 2897 for (int i = sa.GetSize() - 1; i >= 0; i--) {
2992 } 2898 CPDFSDK_Annot* pAnnot = sa.GetAt(i);
2993 } 2899 ASSERT(pAnnot != NULL);
2994 2900
2995 aSelect.RemoveAll(); 2901 CPDF_Rect rcAnnot = GetAnnotRect(pAnnot);
2996 } 2902
2997 } 2903 if (fLeft < 0) {
2998 sa.RemoveAll(); 2904 nLeftTopIndex = 0;
2999 } 2905 fLeft = rcAnnot.left;
3000 break; 2906 } else if (rcAnnot.left < fLeft) {
3001 case BAI_COLUMN: 2907 nLeftTopIndex = i;
3002 { 2908 fLeft = rcAnnot.left;
3003 CPDFSDK_SortAnnots sa; 2909 }
3004 2910 }
3005 { 2911 }
3006 for (int i=0,sz=m_pPageView->CountAnnots(); i<sz ; i++) 2912
3007 { 2913 if (nLeftTopIndex >= 0) {
3008 CPDFSDK_Annot* pAnnot = m_pPageView->Get Annot(i); 2914 CPDFSDK_Annot* pLeftTopAnnot = sa.GetAt(nLeftTopIndex);
3009 ASSERT(pAnnot != NULL); 2915 ASSERT(pLeftTopAnnot != NULL);
3010 2916
3011 if (pAnnot->GetType() == m_sType 2917 CPDF_Rect rcLeftTop = GetAnnotRect(pLeftTopAnnot);
3012 && pAnnot->GetSubType() == m_sSu bType) 2918
3013 sa.Add(pAnnot); 2919 m_Annots.Add(pLeftTopAnnot);
3014 } 2920 sa.RemoveAt(nLeftTopIndex);
3015 } 2921
3016 2922 CFX_ArrayTemplate<int> aSelect;
3017 if (sa.GetSize() > 0) 2923
3018 { 2924 {
3019 sa.Sort(CBA_AnnotIterator::CompareByTop, FALSE); 2925 for (int i = 0, sz = sa.GetSize(); i < sz; i++) {
3020 } 2926 CPDFSDK_Annot* pAnnot = sa.GetAt(i);
3021 2927 ASSERT(pAnnot != NULL);
3022 while (sa.GetSize() > 0) 2928
3023 { 2929 CPDF_Rect rcAnnot = GetAnnotRect(pAnnot);
3024 int nLeftTopIndex = -1; 2930
3025 2931 FX_FLOAT fCenterX = (rcAnnot.left + rcAnnot.right) / 2.0f;
3026 { 2932
3027 FX_FLOAT fLeft = -1.0f; 2933 if (fCenterX > rcLeftTop.left && fCenterX < rcLeftTop.right)
3028 2934 aSelect.Add(i);
3029 for (int i=sa.GetSize()-1; i>=0; i--) 2935 }
3030 { 2936 }
3031 CPDFSDK_Annot* pAnnot = sa.GetAt (i); 2937
3032 ASSERT(pAnnot != NULL); 2938 {
3033 2939 for (int i = 0, sz = aSelect.GetSize(); i < sz; i++) {
3034 CPDF_Rect rcAnnot = GetAnnotRect (pAnnot); 2940 m_Annots.Add(sa[aSelect[i]]);
3035 2941 }
3036 if (fLeft < 0) 2942 }
3037 { 2943
3038 nLeftTopIndex = 0; 2944 {
3039 fLeft = rcAnnot.left; 2945 for (int i = aSelect.GetSize() - 1; i >= 0; i--) {
3040 } 2946 sa.RemoveAt(aSelect[i]);
3041 else if (rcAnnot.left < fLeft) 2947 }
3042 { 2948 }
3043 nLeftTopIndex = i; 2949
3044 fLeft = rcAnnot.left; 2950 aSelect.RemoveAll();
3045 } 2951 }
3046 } 2952 }
3047 } 2953 sa.RemoveAll();
3048 2954 } break;
3049 if (nLeftTopIndex >= 0) 2955 }
3050 { 2956 }
3051 CPDFSDK_Annot* pLeftTopAnnot = sa.GetAt( nLeftTopIndex); 2957
3052 ASSERT(pLeftTopAnnot != NULL); 2958 CPDF_Rect CBA_AnnotIterator::GetAnnotRect(CPDFSDK_Annot* pAnnot) {
3053 2959 ASSERT(pAnnot != NULL);
3054 CPDF_Rect rcLeftTop = GetAnnotRect(pLeft TopAnnot); 2960
3055 2961 CPDF_Annot* pPDFAnnot = pAnnot->GetPDFAnnot();
3056 m_Annots.Add(pLeftTopAnnot); 2962 ASSERT(pPDFAnnot != NULL);
3057 sa.RemoveAt(nLeftTopIndex); 2963
3058 2964 CPDF_Rect rcAnnot;
3059 CFX_ArrayTemplate<int> aSelect; 2965 pPDFAnnot->GetRect(rcAnnot);
3060 2966
3061 { 2967 return rcAnnot;
3062 for (int i=0,sz=sa.GetSize(); i< sz; i++) 2968 }
3063 {
3064 CPDFSDK_Annot* pAnnot = sa.GetAt(i);
3065 ASSERT(pAnnot != NULL);
3066
3067 CPDF_Rect rcAnnot = GetA nnotRect(pAnnot);
3068
3069 FX_FLOAT fCenterX = (rcA nnot.left + rcAnnot.right) / 2.0f;
3070
3071 if (fCenterX > rcLeftTop .left && fCenterX < rcLeftTop.right)
3072 aSelect.Add(i);
3073 }
3074 }
3075
3076 {
3077 for (int i=0,sz=aSelect.GetSize( ); i<sz; i++)
3078 {
3079 m_Annots.Add(sa[aSelect[ i]]);
3080 }
3081 }
3082
3083 {
3084 for (int i=aSelect.GetSize()-1; i>=0; i--)
3085 {
3086 sa.RemoveAt(aSelect[i]);
3087 }
3088 }
3089
3090 aSelect.RemoveAll();
3091 }
3092 }
3093 sa.RemoveAll();
3094 }
3095 break;
3096 }
3097 }
3098
3099 CPDF_Rect CBA_AnnotIterator::GetAnnotRect(CPDFSDK_Annot* pAnnot)
3100 {
3101 ASSERT(pAnnot != NULL);
3102
3103 CPDF_Annot* pPDFAnnot = pAnnot->GetPDFAnnot();
3104 ASSERT(pPDFAnnot != NULL);
3105
3106 CPDF_Rect rcAnnot;
3107 pPDFAnnot->GetRect(rcAnnot);
3108
3109 return rcAnnot;
3110 }
3111
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698