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