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     if (!pFormField->CountControls() || m_nFormControlIndex >= pFormField->CountControls())
 369         return NULL;
 370
 371     if (m_nFormControlIndex < 0)
 372         return pFormField->GetControl(0);
 373
 374     return pFormField->GetControl(m_nFormControlIndex);
 375 }
 376
 377 /* ---------------------------------------- property ---------------------------------------- */
 378
 379 FX_BOOL Field::alignment(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& 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)
1547         return FALSE;
1548
1549     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1550     if (pFormField->GetFieldType() != FIELDTYPE_CHECKBOX &&
1551         pFormField->GetFieldType() != FIELDTYPE_RADIOBUTTON)
1552         return FALSE;
1553
1554     if (vp.IsSetting())
1555     {
1556         if (!m_bCanSet)
1557             return FALSE;
1558
1559         if (!vp.IsArrayObject())
1560             return FALSE;
1561     }
1562     else
1563     {
1564         CJS_Array ExportValusArray(m_isolate);
1565         if (m_nFormControlIndex < 0)
1566         {
1567             for (int i=0,sz=pFormField->CountControls(); i<sz; i++)
1568             {
1569                 CPDF_FormControl* pFormControl = pFormField->GetControl(i);
1570                 ExportValusArray.SetElement(i, CJS_Value(m_isolate,pFormControl->GetExportValue().c_str()));
1571             }
1572         }
1573         else
1574         {
1575             if (m_nFormControlIndex >= pFormField->CountControls())
1576                 return FALSE;
1577
1578             CPDF_FormControl* pFormControl = pFormField->GetControl(m_nFormControlIndex);
1579             if (!pFormControl)
1580                 return FALSE;
1581
1582             ExportValusArray.SetElement(0, CJS_Value(m_isolate,pFormControl->GetExportValue().c_str()));
1583         }
1584         vp << ExportValusArray;
1585     }
1586     return TRUE;
1587 }
1588
1589 FX_BOOL Field::fileSelect(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
1590 {
1591     ASSERT(m_pDocument != NULL);
1592
1593     CFX_PtrArray FieldArray;
1594     GetFormFields(m_FieldName, FieldArray);
1595     if (FieldArray.GetSize() <= 0)
1596         return FALSE;
1597
1598     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1599     if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
1600         return FALSE;
1601
1602     if (vp.IsSetting())
1603     {
1604         if (!m_bCanSet)
1605             return FALSE;
1606
1607         bool bVP;
1608         vp >> bVP;
1609     }
1610     else
1611     {
1612         if (pFormField->GetFieldFlags() & FIELDFLAG_FILESELECT)
1613             vp << true;
1614         else
1615             vp << false;
1616     }
1617     return TRUE;
1618 }
1619
1620 FX_BOOL Field::fillColor(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
1621 {
1622     ASSERT(m_pDocument != NULL);
1623
1624     CJS_Array crArray(m_isolate);
1625
1626     CFX_PtrArray FieldArray;
1627     GetFormFields(m_FieldName, FieldArray);
1628     if (FieldArray.GetSize() <= 0)
1629         return FALSE;
1630
1631     if (vp.IsSetting())
1632     {
1633         if (!m_bCanSet)
1634             return FALSE;
1635
1636         if (!vp.IsArrayObject())
1637             return FALSE;
1638
1639         vp >> crArray;
1640
1641         CPWL_Color color;
1642         color::ConvertArrayToPWLColor(crArray, color);
1643         if (m_bDelay)
1644         {
1645             AddDelay_Color(FP_FILLCOLOR, color);
1646         }
1647         else
1648         {
1649             Field::SetFillColor(m_pDocument, m_FieldName, m_nFormControlIndex, color);
1650         }
1651     }
1652     else
1653     {
1654         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1655         ASSERT(pFormField != NULL);
1656
1657         CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
1658         if (!pFormControl)
1659             return FALSE;
1660
1661         int iColorType;
1662         pFormControl->GetBackgroundColor(iColorType);
1663
1664         CPWL_Color color;
1665         if (iColorType == COLORTYPE_TRANSPARENT)
1666         {
1667             color = CPWL_Color(COLORTYPE_TRANSPARENT);
1668         }
1669         else if (iColorType == COLORTYPE_GRAY)
1670         {
1671             color = CPWL_Color(COLORTYPE_GRAY, pFormControl->GetOriginalBackgroundColor(0));
1672         }
1673         else if (iColorType == COLORTYPE_RGB)
1674         {
1675             color = CPWL_Color(COLORTYPE_RGB, pFormControl->GetOriginalBackgroundColor(0),
1676                 pFormControl->GetOriginalBackgroundColor(1),
1677                 pFormControl->GetOriginalBackgroundColor(2));
1678         }
1679         else if (iColorType == COLORTYPE_CMYK)
1680         {
1681             color = CPWL_Color(COLORTYPE_CMYK, pFormControl->GetOriginalBackgroundColor(0),
1682                 pFormControl->GetOriginalBackgroundColor(1),
1683                 pFormControl->GetOriginalBackgroundColor(2),
1684                 pFormControl->GetOriginalBackgroundColor(3));
1685         }
1686         else
1687             return FALSE;
1688
1689         color::ConvertPWLColorToArray(color, crArray);
1690         vp  <<  crArray;
1691     }
1692
1693     return TRUE;
1694 }
1695
1696 void Field::SetFillColor(CPDFSDK_Document* pDocument, const CFX_WideString& swFieldName, int nControlIndex, const CPWL_Color& color)
1697 {
1698     //Not supported.
1699 }
1700
1701 FX_BOOL Field::hidden(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
1702 {
1703     ASSERT(m_pDocument != NULL);
1704
1705     if (vp.IsSetting())
1706     {
1707         if (!m_bCanSet) return FALSE;
1708
1709         bool bVP;
1710         vp >> bVP;
1711
1712         if (m_bDelay)
1713         {
1714             AddDelay_Bool(FP_HIDDEN, bVP);
1715         }
1716         else
1717         {
1718             Field::SetHidden(m_pDocument, m_FieldName, m_nFormControlIndex, bVP);
1719         }
1720     }
1721     else
1722     {
1723         CFX_PtrArray FieldArray;
1724         GetFormFields(m_FieldName,FieldArray);
1725         if (FieldArray.GetSize() <= 0) return FALSE;
1726
1727         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1728         ASSERT(pFormField != NULL);
1729
1730         CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
1731         ASSERT(pInterForm != NULL);
1732
1733         CPDFSDK_Widget* pWidget = pInterForm->GetWidget(GetSmartFieldControl(pFormField));
1734         if (!pWidget) return FALSE;
1735
1736         FX_DWORD dwFlags = pWidget->GetFlags();
1737
1738         if (ANNOTFLAG_INVISIBLE & dwFlags || ANNOTFLAG_HIDDEN & dwFlags)
1739         {
1740             vp << true;
1741         }
1742         else
1743             vp << false;
1744     }
1745
1746     return TRUE;
1747 }
1748
1749 void Field::SetHidden(CPDFSDK_Document* pDocument, const CFX_WideString& swFieldName, int nControlIndex, bool b)
1750 {
1751     ASSERT(pDocument != NULL);
1752
1753     CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)pDocument->GetInterForm();
1754     ASSERT(pInterForm != NULL);
1755
1756     CFX_PtrArray FieldArray;
1757     GetFormFields(pDocument, swFieldName, FieldArray);
1758
1759     for (int i=0,isz=FieldArray.GetSize(); i<isz; i++)
1760     {
1761         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
1762         ASSERT(pFormField != NULL);
1763
1764         if (nControlIndex < 0)
1765         {
1766             FX_BOOL bSet = FALSE;
1767             for (int j=0,jsz = pFormField->CountControls(); j<jsz; j++)
1768             {
1769                 if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormField->GetControl(j)))
1770                 {
1771                     FX_DWORD dwFlags = pWidget->GetFlags();
1772
1773                     if (b)
1774                     {
1775                         dwFlags &= (~ANNOTFLAG_INVISIBLE);
1776                         dwFlags &= (~ANNOTFLAG_NOVIEW);
1777                         dwFlags |= (ANNOTFLAG_HIDDEN | ANNOTFLAG_PRINT);
1778                     }
1779                     else
1780                     {
1781                         dwFlags &= (~ANNOTFLAG_INVISIBLE);
1782                         dwFlags &= (~ANNOTFLAG_HIDDEN);
1783                         dwFlags &= (~ANNOTFLAG_NOVIEW);
1784                         dwFlags |= ANNOTFLAG_PRINT;
1785                     }
1786
1787                     if (dwFlags != pWidget->GetFlags())
1788                     {
1789                         pWidget->SetFlags(dwFlags);
1790                         bSet = TRUE;
1791                     }
1792                 }
1793             }
1794
1795             if (bSet)
1796                 UpdateFormField(pDocument, pFormField, TRUE, FALSE, TRUE);
1797         }
1798         else
1799         {
1800             if(nControlIndex >= pFormField->CountControls()) return;
1801             if (CPDF_FormControl* pFormControl = pFormField->GetControl(nControlIndex))
1802             {
1803                 if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl))
1804                 {
1805                     FX_DWORD dwFlags = pWidget->GetFlags();
1806
1807                     if (b)
1808                     {
1809                         dwFlags &= (~ANNOTFLAG_INVISIBLE);
1810                         dwFlags &= (~ANNOTFLAG_NOVIEW);
1811                         dwFlags |= (ANNOTFLAG_HIDDEN | ANNOTFLAG_PRINT);
1812                     }
1813                     else
1814                     {
1815                         dwFlags &= (~ANNOTFLAG_INVISIBLE);
1816                         dwFlags &= (~ANNOTFLAG_HIDDEN);
1817                         dwFlags &= (~ANNOTFLAG_NOVIEW);
1818                         dwFlags |= ANNOTFLAG_PRINT;
1819                     }
1820
1821                     if (dwFlags != pWidget->GetFlags())
1822                     {
1823                         pWidget->SetFlags(dwFlags);
1824                         UpdateFormControl(pDocument, pFormControl, TRUE, FALSE, TRUE);
1825                     }
1826                 }
1827             }
1828         }
1829     }
1830 }
1831
1832 FX_BOOL Field::highlight(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
1833 {
1834     ASSERT(m_pDocument != NULL);
1835
1836     if (vp.IsSetting())
1837     {
1838         if (!m_bCanSet) return FALSE;
1839
1840         CFX_ByteString strMode;
1841         vp >> strMode;
1842
1843         if (m_bDelay)
1844         {
1845             AddDelay_String(FP_HIGHLIGHT, strMode);
1846         }
1847         else
1848         {
1849             Field::SetHighlight(m_pDocument, m_FieldName, m_nFormControlIndex, strMode);
1850         }
1851     }
1852     else
1853     {
1854         CFX_PtrArray FieldArray;
1855         GetFormFields(m_FieldName,FieldArray);
1856         if (FieldArray.GetSize() <= 0) return FALSE;
1857
1858         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1859         ASSERT(pFormField != NULL);
1860
1861         if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
1862             return FALSE;
1863
1864         CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
1865         if (!pFormControl) return FALSE;
1866
1867         int eHM = pFormControl->GetHighlightingMode();
1868         switch (eHM)
1869         {
1870         case CPDF_FormControl::None:
1871             vp  <<  L"none";
1872             break;
1873         case CPDF_FormControl::Push:
1874             vp  <<  L"push";
1875             break;
1876         case CPDF_FormControl::Invert:
1877             vp  <<  L"invert";
1878             break;
1879         case CPDF_FormControl::Outline:
1880             vp  <<  L"outline";
1881             break;
1882         case CPDF_FormControl::Toggle:
1883              vp  <<  L"toggle";
1884              break;
1885         }
1886     }
1887
1888     return TRUE;
1889 }
1890
1891 void Field::SetHighlight(CPDFSDK_Document* pDocument, const CFX_WideString& swFieldName, int nControlIndex, const CFX_ByteString& string)
1892 {
1893     //Not supported.
1894 }
1895
1896 FX_BOOL Field::lineWidth(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
1897 {
1898     ASSERT(m_pDocument != NULL);
1899
1900     if (vp.IsSetting())
1901     {
1902         if (!m_bCanSet) return FALSE;
1903
1904         int iWidth;
1905         vp >> iWidth;
1906
1907         if (m_bDelay)
1908         {
1909             AddDelay_Int(FP_LINEWIDTH, iWidth);
1910         }
1911         else
1912         {
1913             Field::SetLineWidth(m_pDocument, m_FieldName, m_nFormControlIndex, iWidth);
1914         }
1915     }
1916     else
1917     {
1918         CFX_PtrArray FieldArray;
1919         GetFormFields(m_FieldName,FieldArray);
1920         if (FieldArray.GetSize() <= 0) return FALSE;
1921
1922         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
1923         ASSERT(pFormField != NULL);
1924
1925         CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
1926         if (!pFormControl) return FALSE;
1927
1928         CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
1929         ASSERT(pInterForm != NULL);
1930
1931         if(!pFormField->CountControls()) return FALSE;
1932
1933         CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormField->GetControl(0));
1934         if (!pWidget) return FALSE;
1935
1936         vp << (int32_t)pWidget->GetBorderWidth();
1937     }
1938
1939     return TRUE;
1940 }
1941
1942 void Field::SetLineWidth(CPDFSDK_Document* pDocument, const CFX_WideString& swFieldName, int nControlIndex, int number)
1943 {
1944     ASSERT(pDocument != NULL);
1945
1946     CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)pDocument->GetInterForm();
1947     ASSERT(pInterForm != NULL);
1948
1949     CFX_PtrArray FieldArray;
1950     GetFormFields(pDocument, swFieldName, FieldArray);
1951
1952     for (int i=0,isz=FieldArray.GetSize(); i<isz; i++)
1953     {
1954         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
1955         ASSERT(pFormField != NULL);
1956
1957         if (nControlIndex < 0)
1958         {
1959             FX_BOOL bSet = FALSE;
1960             for (int j=0,jsz=pFormField->CountControls(); j<jsz; j++)
1961             {
1962                 CPDF_FormControl* pFormControl = pFormField->GetControl(j);
1963                 ASSERT(pFormControl != NULL);
1964
1965                 if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl))
1966                 {
1967                     if (number != pWidget->GetBorderWidth())
1968                     {
1969                         pWidget->SetBorderWidth(number);
1970                         bSet = TRUE;
1971                     }
1972                 }
1973             }
1974             if (bSet) UpdateFormField(pDocument, pFormField, TRUE, TRUE, TRUE);
1975         }
1976         else
1977         {
1978             if(nControlIndex >= pFormField->CountControls()) return;
1979             if (CPDF_FormControl* pFormControl = pFormField->GetControl(nControlIndex))
1980             {
1981                 if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl))
1982                 {
1983                     if (number != pWidget->GetBorderWidth())
1984                     {
1985                         pWidget->SetBorderWidth(number);
1986                         UpdateFormControl(pDocument, pFormControl, TRUE, TRUE, TRUE);
1987                     }
1988                 }
1989             }
1990         }
1991     }
1992 }
1993
1994 FX_BOOL Field::multiline(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
1995 {
1996     ASSERT(m_pDocument != NULL);
1997
1998     if (vp.IsSetting())
1999     {
2000         if (!m_bCanSet) return FALSE;
2001
2002         bool bVP;
2003         vp >> bVP;
2004
2005         if (m_bDelay)
2006         {
2007             AddDelay_Bool(FP_MULTILINE, bVP);
2008         }
2009         else
2010         {
2011             Field::SetMultiline(m_pDocument, m_FieldName, m_nFormControlIndex, bVP);
2012         }
2013     }
2014     else
2015     {
2016         CFX_PtrArray FieldArray;
2017         GetFormFields(m_FieldName, FieldArray);
2018         if (FieldArray.GetSize() <= 0) return FALSE;
2019
2020         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2021         ASSERT(pFormField != NULL);
2022
2023         if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
2024             return FALSE;
2025
2026         if (pFormField->GetFieldFlags() & FIELDFLAG_MULTILINE)
2027             vp << true;
2028         else
2029             vp << false;
2030     }
2031
2032     return TRUE;
2033 }
2034
2035 void Field::SetMultiline(CPDFSDK_Document* pDocument, const CFX_WideString& swFieldName, int nControlIndex, bool b)
2036 {
2037     //Not supported.
2038 }
2039
2040 FX_BOOL Field::multipleSelection(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
2041 {
2042     ASSERT(m_pDocument != NULL);
2043
2044     if (vp.IsSetting())
2045     {
2046         if (!m_bCanSet) return FALSE;
2047
2048         bool bVP;
2049         vp >> bVP;
2050
2051         if (m_bDelay)
2052         {
2053             AddDelay_Bool(FP_MULTIPLESELECTION, bVP);
2054         }
2055         else
2056         {
2057             Field::SetMultipleSelection(m_pDocument, m_FieldName, m_nFormControlIndex, bVP);
2058         }
2059     }
2060     else
2061     {
2062         CFX_PtrArray FieldArray;
2063         GetFormFields(m_FieldName,FieldArray);
2064         if (FieldArray.GetSize() <= 0) return FALSE;
2065
2066         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2067         ASSERT(pFormField != NULL);
2068
2069         if (pFormField->GetFieldType() != FIELDTYPE_LISTBOX)
2070             return FALSE;
2071
2072         if (pFormField->GetFieldFlags() & FIELDFLAG_MULTISELECT)
2073             vp << true;
2074         else
2075             vp << false;
2076     }
2077
2078     return TRUE;
2079 }
2080
2081 void Field::SetMultipleSelection(CPDFSDK_Document* pDocument, const CFX_WideString& swFieldName, int nControlIndex, bool b)
2082 {
2083     //Not supported.
2084 }
2085
2086 FX_BOOL Field::name(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
2087 {
2088     if (!vp.IsGetting()) return FALSE;
2089
2090     CFX_PtrArray FieldArray;
2091     GetFormFields(m_FieldName, FieldArray);
2092     if (FieldArray.GetSize() <= 0) return FALSE;
2093
2094     vp << m_FieldName;
2095
2096     return TRUE;
2097 }
2098
2099 FX_BOOL Field::numItems(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
2100 {
2101     CFX_PtrArray FieldArray;
2102     GetFormFields(m_FieldName, FieldArray);
2103     if (FieldArray.GetSize() <= 0) return FALSE;
2104
2105     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2106     ASSERT(pFormField != NULL);
2107
2108     if (pFormField->GetFieldType() != FIELDTYPE_COMBOBOX &&
2109         pFormField->GetFieldType() != FIELDTYPE_LISTBOX)
2110         return FALSE;
2111
2112     if (!vp.IsGetting()) return FALSE;
2113
2114     vp << (int32_t)pFormField->CountOptions();
2115
2116     return TRUE;
2117 }
2118
2119 FX_BOOL Field::page(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
2120 {
2121     if (!vp.IsGetting()) return FALSE;
2122
2123     CFX_PtrArray FieldArray;
2124     GetFormFields(m_FieldName, FieldArray);
2125     if (FieldArray.GetSize() <= 0) return FALSE;
2126
2127     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2128     if (!pFormField) return FALSE;
2129
2130     ASSERT(m_pDocument != NULL);
2131
2132     CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
2133     ASSERT(pInterForm != NULL);
2134
2135     CFX_PtrArray widgetArray;
2136     pInterForm->GetWidgets(pFormField, widgetArray);
2137
2138     if (widgetArray.GetSize() > 0)
2139     {
2140         CJS_Array PageArray(m_isolate);
2141
2142         for (int i=0,sz=widgetArray.GetSize(); i<sz; i++)
2143         {
2144             CPDFSDK_Widget* pWidget = (CPDFSDK_Widget*)widgetArray.GetAt(i);
2145             ASSERT(pWidget != NULL);
2146
2147             CPDFSDK_PageView* pPageView = pWidget->GetPageView();
2148             if(!pPageView)
2149                 return FALSE;
2150
2151             PageArray.SetElement(i, CJS_Value(m_isolate,(int32_t)pPageView->GetPageIndex()));
2152         }
2153
2154         vp << PageArray;
2155     }
2156     else
2157     {
2158         vp << (int32_t) -1;
2159     }
2160
2161     return TRUE;
2162 }
2163
2164 FX_BOOL Field::password(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
2165 {
2166     ASSERT(m_pDocument != NULL);
2167
2168     if (vp.IsSetting())
2169     {
2170         if (!m_bCanSet) return FALSE;
2171
2172         bool bVP;
2173         vp >> bVP;
2174
2175         if (m_bDelay)
2176         {
2177             AddDelay_Bool(FP_PASSWORD, bVP);
2178         }
2179         else
2180         {
2181             Field::SetPassword(m_pDocument, m_FieldName, m_nFormControlIndex, bVP);
2182         }
2183     }
2184     else
2185     {
2186         CFX_PtrArray FieldArray;
2187         GetFormFields(m_FieldName,FieldArray);
2188         if (FieldArray.GetSize() <= 0) return FALSE;
2189
2190         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2191         ASSERT(pFormField != NULL);
2192
2193         if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
2194             return FALSE;
2195
2196         if (pFormField->GetFieldFlags() & FIELDFLAG_PASSWORD)
2197             vp << true;
2198         else
2199             vp << false;
2200     }
2201
2202     return TRUE;
2203 }
2204
2205 void Field::SetPassword(CPDFSDK_Document* pDocument, const CFX_WideString& swFieldName, int nControlIndex, bool b)
2206 {
2207     //Not supported.
2208 }
2209
2210 FX_BOOL Field::print(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
2211 {
2212     ASSERT(m_pDocument != NULL);
2213
2214     CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
2215     ASSERT(pInterForm != NULL);
2216
2217     CFX_PtrArray FieldArray;
2218     GetFormFields(m_FieldName, FieldArray);
2219     if (FieldArray.GetSize() <= 0) return FALSE;
2220
2221     if (vp.IsSetting())
2222     {
2223         if (!m_bCanSet) return FALSE;
2224
2225         bool bVP;
2226         vp >> bVP;
2227
2228         for (int i=0,isz=FieldArray.GetSize(); i<isz; i++)
2229         {
2230             CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
2231             ASSERT(pFormField != NULL);
2232
2233             if (m_nFormControlIndex < 0)
2234             {
2235                 FX_BOOL bSet = FALSE;
2236                 for (int j=0,jsz = pFormField->CountControls(); j<jsz; j++)
2237                 {
2238                     if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormField->GetControl(j)))
2239                     {
2240                         FX_DWORD dwFlags = pWidget->GetFlags();
2241                         if (bVP)
2242                             dwFlags |= ANNOTFLAG_PRINT;
2243                         else
2244                             dwFlags &= ~ANNOTFLAG_PRINT;
2245
2246                         if (dwFlags != pWidget->GetFlags())
2247                         {
2248                             pWidget->SetFlags(dwFlags);
2249                             bSet = TRUE;
2250                         }
2251                     }
2252                 }
2253
2254                 if (bSet)
2255                     UpdateFormField(m_pDocument, pFormField, TRUE, FALSE, TRUE);
2256             }
2257             else
2258             {
2259                 if(m_nFormControlIndex >= pFormField->CountControls()) return FALSE;
2260                 if (CPDF_FormControl* pFormControl = pFormField->GetControl(m_nFormControlIndex))
2261                 {
2262                     if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl))
2263                     {
2264                         FX_DWORD dwFlags = pWidget->GetFlags();
2265                         if (bVP)
2266                             dwFlags |= ANNOTFLAG_PRINT;
2267                         else
2268                             dwFlags &= ~ANNOTFLAG_PRINT;
2269
2270                         if (dwFlags != pWidget->GetFlags())
2271                         {
2272                             pWidget->SetFlags(dwFlags);
2273                             UpdateFormControl(m_pDocument, pFormField->GetControl(m_nFormControlIndex), TRUE, FALSE, TRUE);
2274                         }
2275                     }
2276                 }
2277             }
2278         }
2279     }
2280     else
2281     {
2282         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2283         ASSERT(pFormField != NULL);
2284
2285         CPDFSDK_Widget* pWidget = pInterForm->GetWidget(GetSmartFieldControl(pFormField));
2286         if (!pWidget) return FALSE;
2287
2288         if (pWidget->GetFlags() & ANNOTFLAG_PRINT)
2289             vp << true;
2290         else
2291             vp << false;
2292     }
2293
2294     return TRUE;
2295 }
2296
2297 FX_BOOL Field::radiosInUnison(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
2298 {
2299     ASSERT(m_pDocument != NULL);
2300
2301     CFX_PtrArray FieldArray;
2302     GetFormFields(m_FieldName,FieldArray);
2303     if (FieldArray.GetSize() <= 0) return FALSE;
2304
2305     if (vp.IsSetting())
2306     {
2307         if (!m_bCanSet) return FALSE;
2308
2309         bool bVP;
2310         vp >> bVP;
2311
2312     }
2313     else
2314     {
2315         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2316         ASSERT(pFormField != NULL);
2317
2318         if (pFormField->GetFieldType() != FIELDTYPE_RADIOBUTTON)
2319             return FALSE;
2320
2321         if (pFormField->GetFieldFlags() & FIELDFLAG_RADIOSINUNISON)
2322             vp << true;
2323         else
2324             vp << false;
2325     }
2326
2327     return TRUE;
2328 }
2329
2330 FX_BOOL Field::readonly(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
2331 {
2332     ASSERT(m_pDocument != NULL);
2333
2334     CFX_PtrArray FieldArray;
2335     GetFormFields(m_FieldName,FieldArray);
2336     if (FieldArray.GetSize() <= 0) return FALSE;
2337
2338     if (vp.IsSetting())
2339     {
2340         if (!m_bCanSet) return FALSE;
2341
2342         bool bVP;
2343         vp >> bVP;
2344
2345     }
2346     else
2347     {
2348         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2349         ASSERT(pFormField != NULL);
2350
2351         if (pFormField->GetFieldFlags() & FIELDFLAG_READONLY)
2352             vp << true;
2353         else
2354             vp << false;
2355     }
2356
2357     return TRUE;
2358 }
2359
2360 FX_BOOL Field::rect(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
2361 {
2362     ASSERT(m_pDocument != NULL);
2363
2364     if (vp.IsSetting())
2365     {
2366         if (!m_bCanSet) return FALSE;
2367         if (!vp.IsArrayObject())return FALSE;
2368
2369         CJS_Array rcArray(m_isolate);
2370         vp >> rcArray;
2371         CJS_Value Upper_Leftx(m_isolate), Upper_Lefty(m_isolate), Lower_Rightx(m_isolate), Lower_Righty(m_isolate);
2372         rcArray.GetElement(0, Upper_Leftx);
2373         rcArray.GetElement(1, Upper_Lefty);
2374         rcArray.GetElement(2, Lower_Rightx);
2375         rcArray.GetElement(3, Lower_Righty);
2376
2377         FX_FLOAT pArray[4] = {0.0f,0.0f,0.0f,0.0f};
2378         pArray[0] = (FX_FLOAT)Upper_Leftx.ToInt();
2379         pArray[1] = (FX_FLOAT)Lower_Righty.ToInt();
2380         pArray[2] = (FX_FLOAT)Lower_Rightx.ToInt();
2381         pArray[3] = (FX_FLOAT)Upper_Lefty.ToInt();
2382
2383         CPDF_Rect crRect(pArray);
2384
2385         if (m_bDelay)
2386         {
2387             AddDelay_Rect(FP_RECT, crRect);
2388         }
2389         else
2390         {
2391             Field::SetRect(m_pDocument, m_FieldName, m_nFormControlIndex, crRect);
2392         }
2393     }
2394     else
2395     {
2396         CFX_PtrArray FieldArray;
2397         GetFormFields(m_FieldName,FieldArray);
2398         if (FieldArray.GetSize() <= 0) return FALSE;
2399
2400         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2401         ASSERT(pFormField != NULL);
2402
2403         CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
2404         ASSERT(pInterForm != NULL);
2405
2406         CPDFSDK_Widget* pWidget = pInterForm->GetWidget(GetSmartFieldControl(pFormField));
2407         if (!pWidget) return FALSE;
2408
2409         CFX_FloatRect crRect = pWidget->GetRect();
2410         CJS_Value Upper_Leftx(m_isolate),Upper_Lefty(m_isolate),Lower_Rightx(m_isolate),Lower_Righty(m_isolate);
2411         Upper_Leftx = (int32_t)crRect.left;
2412         Upper_Lefty = (int32_t)crRect.top;
2413         Lower_Rightx = (int32_t)crRect.right;
2414         Lower_Righty = (int32_t)crRect.bottom;
2415
2416         CJS_Array rcArray(m_isolate);
2417         rcArray.SetElement(0,Upper_Leftx);
2418         rcArray.SetElement(1,Upper_Lefty);
2419         rcArray.SetElement(2,Lower_Rightx);
2420         rcArray.SetElement(3,Lower_Righty);
2421
2422         vp  <<  rcArray;
2423     }
2424
2425     return TRUE;
2426 }
2427
2428 void Field::SetRect(CPDFSDK_Document* pDocument, const CFX_WideString& swFieldName, int nControlIndex, const CPDF_Rect& rect)
2429 {
2430     ASSERT(pDocument != NULL);
2431
2432     CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)pDocument->GetInterForm();
2433     ASSERT(pInterForm != NULL);
2434
2435     CFX_PtrArray FieldArray;
2436     GetFormFields(pDocument, swFieldName, FieldArray);
2437
2438     for (int i=0,isz=FieldArray.GetSize(); i<isz; i++)
2439     {
2440         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
2441         ASSERT(pFormField != NULL);
2442
2443         if (nControlIndex < 0)
2444         {
2445             FX_BOOL bSet = FALSE;
2446             for (int i=0, sz=pFormField->CountControls(); i<sz; i++)
2447             {
2448                 CPDF_FormControl* pFormControl = pFormField->GetControl(i);
2449                 ASSERT(pFormControl != NULL);
2450
2451                 if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl))
2452                 {
2453                     CPDF_Rect crRect = rect;
2454
2455                     CPDF_Page* pPDFPage = pWidget->GetPDFPage();
2456                     ASSERT(pPDFPage != NULL);
2457
2458 //                  CPDF_Page* pPDFPage = pPage->GetPage();
2459 //                  ASSERT(pPDFPage != NULL);
2460
2461                     crRect.Intersect(pPDFPage->GetPageBBox());
2462
2463                     if (!crRect.IsEmpty())
2464                     {
2465                         CPDF_Rect rcOld = pWidget->GetRect();
2466                         if (crRect.left != rcOld.left ||
2467                             crRect.right != rcOld.right ||
2468                             crRect.top != rcOld.top ||
2469                             crRect.bottom != rcOld.bottom)
2470                         {
2471                             pWidget->SetRect(crRect);
2472                             bSet = TRUE;
2473                         }
2474                     }
2475                 }
2476             }
2477
2478             if (bSet) UpdateFormField(pDocument, pFormField, TRUE, TRUE, TRUE);
2479         }
2480         else
2481         {
2482             if(nControlIndex >= pFormField->CountControls()) return;
2483             if (CPDF_FormControl* pFormControl = pFormField->GetControl(nControlIndex))
2484             {
2485                 if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl))
2486                 {
2487                     CPDF_Rect crRect = rect;
2488
2489                     CPDF_Page* pPDFPage = pWidget->GetPDFPage();
2490                     ASSERT(pPDFPage != NULL);
2491
2492 //                  CPDF_Page* pPDFPage = pPage->GetPage();
2493 //                  ASSERT(pPDFPage != NULL);
2494
2495                     crRect.Intersect(pPDFPage->GetPageBBox());
2496
2497                     if (!crRect.IsEmpty())
2498                     {
2499                         CPDF_Rect rcOld = pWidget->GetRect();
2500                         if (crRect.left != rcOld.left ||
2501                             crRect.right != rcOld.right ||
2502                             crRect.top != rcOld.top ||
2503                             crRect.bottom != rcOld.bottom)
2504                         {
2505                             pWidget->SetRect(crRect);
2506                             UpdateFormControl(pDocument, pFormControl, TRUE, TRUE, TRUE);
2507                         }
2508                     }
2509                 }
2510             }
2511         }
2512     }
2513 }
2514
2515 FX_BOOL Field::required(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
2516 {
2517     ASSERT(m_pDocument != NULL);
2518
2519     CFX_PtrArray FieldArray;
2520     GetFormFields(m_FieldName,FieldArray);
2521     if (FieldArray.GetSize() <= 0) return FALSE;
2522
2523     if (vp.IsSetting())
2524     {
2525         if (!m_bCanSet) return FALSE;
2526
2527
2528         bool bVP;
2529         vp >> bVP;
2530
2531     }
2532     else
2533     {
2534         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2535         ASSERT(pFormField != NULL);
2536
2537         if (pFormField->GetFieldType() == FIELDTYPE_PUSHBUTTON)
2538             return FALSE;
2539
2540         if (pFormField->GetFieldFlags() & FIELDFLAG_REQUIRED)
2541             vp << true;
2542         else
2543             vp << false;
2544     }
2545
2546     return TRUE;
2547 }
2548
2549 FX_BOOL Field::richText(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
2550 {
2551     ASSERT(m_pDocument != NULL);
2552
2553     if (vp.IsSetting())
2554     {
2555         if (!m_bCanSet) return FALSE;
2556
2557         bool bVP;
2558         vp >> bVP;
2559
2560         if (m_bDelay)
2561         {
2562             AddDelay_Bool(FP_RICHTEXT, bVP);
2563         }
2564         else
2565         {
2566             Field::SetRichText(m_pDocument, m_FieldName, m_nFormControlIndex, bVP);
2567         }
2568     }
2569     else
2570     {
2571         CFX_PtrArray FieldArray;
2572         GetFormFields(m_FieldName,FieldArray);
2573         if (FieldArray.GetSize() <= 0) return FALSE;
2574
2575         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2576         ASSERT(pFormField != NULL);
2577
2578         if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
2579             return FALSE;
2580
2581         if (pFormField->GetFieldFlags() & FIELDFLAG_RICHTEXT)
2582             vp << true;
2583         else
2584             vp << false;
2585     }
2586
2587     return TRUE;
2588 }
2589
2590 void Field::SetRichText(CPDFSDK_Document* pDocument, const CFX_WideString& swFieldName, int nControlIndex, bool b)
2591 {
2592     //Not supported.
2593 }
2594
2595 FX_BOOL Field::richValue(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
2596 {
2597     return TRUE;
2598     if (vp.IsSetting())
2599     {
2600         if (!m_bCanSet) return FALSE;
2601         ;
2602     }
2603     else
2604     {
2605         ;
2606     }
2607     return TRUE;
2608 }
2609
2610 void Field::SetRichValue(CPDFSDK_Document* pDocument, const CFX_WideString& swFieldName, int nControlIndex)
2611 {
2612     //Not supported.
2613 }
2614
2615 FX_BOOL Field::rotation(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
2616 {
2617     ASSERT(m_pDocument != NULL);
2618
2619     if (vp.IsSetting())
2620     {
2621         if (!m_bCanSet) return FALSE;
2622
2623         int nVP;
2624         vp >> nVP;
2625
2626         if (m_bDelay)
2627         {
2628             AddDelay_Int(FP_ROTATION, nVP);
2629         }
2630         else
2631         {
2632             Field::SetRotation(m_pDocument, m_FieldName, m_nFormControlIndex, nVP);
2633         }
2634     }
2635     else
2636     {
2637         CFX_PtrArray FieldArray;
2638         GetFormFields(m_FieldName,FieldArray);
2639         if (FieldArray.GetSize() <= 0) return FALSE;
2640
2641         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2642         ASSERT(pFormField != NULL);
2643
2644         CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
2645         if (!pFormControl)return FALSE;
2646
2647         vp << (int32_t)pFormControl->GetRotation();
2648     }
2649
2650     return TRUE;
2651 }
2652
2653 void Field::SetRotation(CPDFSDK_Document* pDocument, const CFX_WideString& swFieldName, int nControlIndex, int number)
2654 {
2655     //Not supported.
2656 }
2657
2658 FX_BOOL Field::strokeColor(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
2659 {
2660     ASSERT(m_pDocument != NULL);
2661
2662     if (vp.IsSetting())
2663     {
2664         if (!m_bCanSet) return FALSE;
2665
2666         if (!vp.IsArrayObject())return FALSE;
2667
2668         CJS_Array crArray(m_isolate);
2669         vp >> crArray;
2670
2671         CPWL_Color color;
2672         color::ConvertArrayToPWLColor(crArray, color);
2673
2674         if (m_bDelay)
2675         {
2676             AddDelay_Color(FP_STROKECOLOR, color);
2677         }
2678         else
2679         {
2680             Field::SetStrokeColor(m_pDocument, m_FieldName, m_nFormControlIndex, color);
2681         }
2682     }
2683     else
2684     {
2685         CFX_PtrArray FieldArray;
2686         GetFormFields(m_FieldName,FieldArray);
2687         if (FieldArray.GetSize() <= 0) return FALSE;
2688
2689         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2690         ASSERT(pFormField != NULL);
2691
2692         CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
2693         if (!pFormControl)return FALSE;
2694
2695         int iColorType;
2696         pFormControl->GetBorderColor(iColorType);
2697
2698         CPWL_Color color;
2699
2700         if (iColorType == COLORTYPE_TRANSPARENT)
2701         {
2702             color = CPWL_Color(COLORTYPE_TRANSPARENT);
2703         }
2704         else if (iColorType == COLORTYPE_GRAY)
2705         {
2706             color = CPWL_Color(COLORTYPE_GRAY, pFormControl->GetOriginalBorderColor(0));
2707         }
2708         else if (iColorType == COLORTYPE_RGB)
2709         {
2710             color = CPWL_Color(COLORTYPE_RGB, pFormControl->GetOriginalBorderColor(0),
2711                 pFormControl->GetOriginalBorderColor(1),
2712                 pFormControl->GetOriginalBorderColor(2));
2713         }
2714         else if (iColorType == COLORTYPE_CMYK)
2715         {
2716             color = CPWL_Color(COLORTYPE_CMYK, pFormControl->GetOriginalBorderColor(0),
2717                 pFormControl->GetOriginalBorderColor(1),
2718                 pFormControl->GetOriginalBorderColor(2),
2719                 pFormControl->GetOriginalBorderColor(3));
2720         }
2721         else
2722             return FALSE;
2723
2724         CJS_Array crArray(m_isolate);
2725         color::ConvertPWLColorToArray(color, crArray);
2726         vp  <<  crArray;
2727     }
2728
2729     return TRUE;
2730 }
2731
2732 void Field::SetStrokeColor(CPDFSDK_Document* pDocument, const CFX_WideString& swFieldName, int nControlIndex, const CPWL_Color& color)
2733 {
2734     //Not supported.
2735 }
2736
2737 FX_BOOL Field::style(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
2738 {
2739     ASSERT(m_pDocument != NULL);
2740
2741     if (vp.IsSetting())
2742     {
2743         if (!m_bCanSet) return FALSE;
2744
2745         CFX_ByteString csBCaption;
2746         vp >> csBCaption;
2747
2748         if (m_bDelay)
2749         {
2750             AddDelay_String(FP_STYLE, csBCaption);
2751         }
2752         else
2753         {
2754             Field::SetStyle(m_pDocument, m_FieldName, m_nFormControlIndex, csBCaption);
2755         }
2756     }
2757     else
2758     {
2759         CFX_PtrArray FieldArray;
2760         GetFormFields(m_FieldName,FieldArray);
2761         if (FieldArray.GetSize() <= 0) return FALSE;
2762
2763         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2764         ASSERT(pFormField != NULL);
2765
2766         if (pFormField->GetFieldType() != FIELDTYPE_RADIOBUTTON &&
2767             pFormField->GetFieldType() != FIELDTYPE_CHECKBOX)
2768             return FALSE;
2769
2770         CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
2771         if (!pFormControl) return FALSE;
2772
2773         CFX_WideString csWCaption = pFormControl->GetNormalCaption();
2774         CFX_ByteString csBCaption;
2775
2776         switch (csWCaption[0])
2777         {
2778             case L'l':
2779                 csBCaption = "circle";
2780                 break;
2781             case L'8':
2782                 csBCaption = "cross";
2783                 break;
2784             case L'u':
2785                 csBCaption = "diamond";
2786                 break;
2787             case L'n':
2788                 csBCaption = "square";
2789                 break;
2790             case L'H':
2791                 csBCaption = "star";
2792                 break;
2793             default: //L'4'
2794                 csBCaption = "check";
2795                 break;
2796         }
2797         vp << csBCaption;
2798     }
2799
2800     return TRUE;
2801 }
2802
2803 void Field::SetStyle(CPDFSDK_Document* pDocument, const CFX_WideString& swFieldName, int nControlIndex,
2804                      const CFX_ByteString& string)
2805 {
2806     //Not supported.
2807 }
2808
2809 FX_BOOL Field::submitName(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
2810 {
2811     return TRUE;
2812 }
2813
2814 FX_BOOL Field::textColor(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
2815 {
2816     ASSERT(m_pDocument != NULL);
2817
2818     if (vp.IsSetting())
2819     {
2820         if (!m_bCanSet) return FALSE;
2821
2822         CJS_Array crArray(m_isolate);
2823         if (!vp.IsArrayObject())return FALSE;
2824         vp >> crArray;
2825
2826         CPWL_Color color;
2827         color::ConvertArrayToPWLColor(crArray, color);
2828
2829         if (m_bDelay)
2830         {
2831             AddDelay_Color(FP_TEXTCOLOR, color);
2832         }
2833         else
2834         {
2835             Field::SetTextColor(m_pDocument, m_FieldName, m_nFormControlIndex, color);
2836         }
2837     }
2838     else
2839     {
2840         CFX_PtrArray FieldArray;
2841         GetFormFields(m_FieldName,FieldArray);
2842         if (FieldArray.GetSize() <= 0) return FALSE;
2843
2844         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2845         ASSERT(pFormField != NULL);
2846
2847         CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
2848         if (!pFormControl)return FALSE;
2849
2850         int iColorType;
2851         FX_ARGB color;
2852         CPDF_DefaultAppearance FieldAppearance = pFormControl->GetDefaultAppearance();
2853         FieldAppearance.GetColor(color, iColorType);
2854         int32_t a,r,g,b;
2855         ArgbDecode(color, a, r, g, b);
2856
2857         CPWL_Color crRet = CPWL_Color(COLORTYPE_RGB, r / 255.0f,
2858                 g / 255.0f,
2859                 b / 255.0f);
2860
2861         if (iColorType == COLORTYPE_TRANSPARENT)
2862             crRet = CPWL_Color(COLORTYPE_TRANSPARENT);
2863
2864         CJS_Array crArray(m_isolate);
2865         color::ConvertPWLColorToArray(crRet, crArray);
2866         vp  <<  crArray;
2867     }
2868
2869     return TRUE;
2870 }
2871
2872 void Field::SetTextColor(CPDFSDK_Document* pDocument, const CFX_WideString& swFieldName, int nControlIndex, const CPWL_Color& color)
2873 {
2874     //Not supported.
2875 }
2876
2877 FX_BOOL Field::textFont(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
2878 {
2879     ASSERT(m_pDocument != NULL);
2880
2881     if (vp.IsSetting())
2882     {
2883         if (!m_bCanSet) return FALSE;
2884
2885         CFX_ByteString csFontName;
2886         vp >> csFontName;
2887         if (csFontName.IsEmpty()) return FALSE;
2888
2889         if (m_bDelay)
2890         {
2891             AddDelay_String(FP_TEXTFONT, csFontName);
2892         }
2893         else
2894         {
2895             Field::SetTextFont(m_pDocument, m_FieldName, m_nFormControlIndex, csFontName);
2896         }
2897     }
2898     else
2899     {
2900         CFX_PtrArray FieldArray;
2901         GetFormFields(m_FieldName,FieldArray);
2902         if (FieldArray.GetSize() <= 0) return FALSE;
2903
2904         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2905         ASSERT(pFormField != NULL);
2906
2907         CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
2908         if (!pFormControl)return FALSE;
2909
2910         int nFieldType = pFormField->GetFieldType();
2911
2912         if (nFieldType == FIELDTYPE_PUSHBUTTON ||
2913             nFieldType == FIELDTYPE_COMBOBOX ||
2914             nFieldType == FIELDTYPE_LISTBOX ||
2915             nFieldType == FIELDTYPE_TEXTFIELD)
2916         {
2917             CPDF_Font * pFont = pFormControl->GetDefaultControlFont();
2918             if (!pFont) return FALSE;
2919
2920             vp << pFont->GetBaseFont();
2921         }
2922         else
2923             return FALSE;
2924     }
2925
2926     return TRUE;
2927 }
2928
2929 void Field::SetTextFont(CPDFSDK_Document* pDocument, const CFX_WideString& swFieldName, int nControlIndex, const CFX_ByteString& string)
2930 {
2931     //Not supported.
2932 }
2933
2934 FX_BOOL Field::textSize(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
2935 {
2936     ASSERT(m_pDocument != NULL);
2937
2938     if (vp.IsSetting())
2939     {
2940         if (!m_bCanSet) return FALSE;
2941
2942         int nVP;
2943         vp >> nVP;
2944
2945         if (m_bDelay)
2946         {
2947             AddDelay_Int(FP_TEXTSIZE, nVP);
2948         }
2949         else
2950         {
2951             Field::SetTextSize(m_pDocument, m_FieldName, m_nFormControlIndex, nVP);
2952         }
2953     }
2954     else
2955     {
2956         CFX_PtrArray FieldArray;
2957         GetFormFields(m_FieldName,FieldArray);
2958         if (FieldArray.GetSize() <= 0) return FALSE;
2959
2960         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2961         ASSERT(pFormField != NULL);
2962
2963         CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
2964         if (!pFormControl)return FALSE;
2965
2966         CPDF_DefaultAppearance FieldAppearance = pFormControl->GetDefaultAppearance();
2967
2968         CFX_ByteString csFontNameTag;
2969         FX_FLOAT fFontSize;
2970         FieldAppearance.GetFont(csFontNameTag,fFontSize);
2971
2972         vp << (int)fFontSize;
2973     }
2974
2975     return TRUE;
2976 }
2977
2978 void Field::SetTextSize(CPDFSDK_Document* pDocument, const CFX_WideString& swFieldName, int nControlIndex, int number)
2979 {
2980     //Not supported.
2981 }
2982
2983 FX_BOOL Field::type(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
2984 {
2985     ASSERT(m_pDocument != NULL);
2986
2987     if (!vp.IsGetting()) return FALSE;
2988
2989     CFX_PtrArray FieldArray;
2990     GetFormFields(m_FieldName,FieldArray);
2991     if (FieldArray.GetSize() <= 0) return FALSE;
2992
2993     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
2994     ASSERT(pFormField != NULL);
2995
2996     switch (pFormField->GetFieldType())
2997     {
2998         case FIELDTYPE_UNKNOWN:
2999             vp << L"unknown";
3000             break;
3001         case FIELDTYPE_PUSHBUTTON:
3002             vp << L"button";
3003             break;
3004         case FIELDTYPE_CHECKBOX:
3005             vp << L"checkbox";
3006             break;
3007         case FIELDTYPE_RADIOBUTTON:
3008             vp << L"radiobutton";
3009             break;
3010         case FIELDTYPE_COMBOBOX:
3011             vp << L"combobox";
3012             break;
3013         case FIELDTYPE_LISTBOX:
3014             vp << L"listbox";
3015             break;
3016         case FIELDTYPE_TEXTFIELD:
3017             vp << L"text";
3018             break;
3019         case FIELDTYPE_SIGNATURE:
3020             vp << L"signature";
3021             break;
3022         default :
3023             vp << L"unknown";
3024             break;
3025     }
3026
3027     return TRUE;
3028 }
3029
3030 FX_BOOL Field::userName(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
3031 {
3032     ASSERT(m_pDocument != NULL);
3033
3034     if (vp.IsSetting())
3035     {
3036         if (!m_bCanSet) return FALSE;
3037
3038         CFX_WideString swName;
3039         vp >> swName;
3040
3041         if (m_bDelay)
3042         {
3043             AddDelay_WideString(FP_USERNAME, swName);
3044         }
3045         else
3046         {
3047             Field::SetUserName(m_pDocument, m_FieldName, m_nFormControlIndex, swName);
3048         }
3049     }
3050     else
3051     {
3052         CFX_PtrArray FieldArray;
3053         GetFormFields(m_FieldName,FieldArray);
3054         if (FieldArray.GetSize() <= 0) return FALSE;
3055
3056         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3057         ASSERT(pFormField != NULL);
3058
3059         vp << (CFX_WideString)pFormField->GetAlternateName();
3060     }
3061
3062     return TRUE;
3063 }
3064
3065 void Field::SetUserName(CPDFSDK_Document* pDocument, const CFX_WideString& swFieldName, int nControlIndex, const CFX_WideString& string)
3066 {
3067     //Not supported.
3068 }
3069
3070 FX_BOOL Field::value(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
3071 {
3072     ASSERT(m_pDocument != NULL);
3073
3074     if (vp.IsSetting())
3075     {
3076         if (!m_bCanSet) return FALSE;
3077
3078         CJS_WideStringArray strArray;
3079
3080         if (vp.IsArrayObject())
3081         {
3082             CJS_Array ValueArray(m_isolate);
3083             vp.ConvertToArray(ValueArray);
3084             for (int i = 0,sz = ValueArray.GetLength(); i < sz; i++)
3085             {
3086                 CJS_Value ElementValue(m_isolate);
3087                 ValueArray.GetElement(i, ElementValue);
3088                 strArray.Add(ElementValue.ToCFXWideString());
3089             }
3090         }
3091         else
3092         {
3093             CFX_WideString swValue;
3094             vp >> swValue;
3095
3096             strArray.Add(swValue);
3097         }
3098
3099         if (m_bDelay)
3100         {
3101             AddDelay_WideStringArray(FP_VALUE, strArray);
3102         }
3103         else
3104         {
3105             Field::SetValue(m_pDocument, m_FieldName, m_nFormControlIndex, strArray);
3106         }
3107     }
3108     else
3109     {
3110         CFX_PtrArray FieldArray;
3111         GetFormFields(m_FieldName,FieldArray);
3112         if (FieldArray.GetSize() <= 0) return FALSE;
3113
3114         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3115         ASSERT(pFormField != NULL);
3116
3117
3118
3119         switch (pFormField->GetFieldType())
3120         {
3121         case FIELDTYPE_PUSHBUTTON:
3122             return FALSE;
3123         case FIELDTYPE_COMBOBOX:
3124         case FIELDTYPE_TEXTFIELD:
3125             {
3126                 CFX_WideString swValue = pFormField->GetValue();
3127
3128                 double dRet;
3129                 FX_BOOL bDot;
3130                 if (CJS_PublicMethods::ConvertStringToNumber(swValue.c_str(), dRet, bDot))
3131                 {
3132                     if (bDot)
3133                         vp << dRet;
3134                     else
3135                         vp << dRet;
3136                 }
3137                 else
3138                     vp << swValue;
3139             }
3140             break;
3141         case FIELDTYPE_LISTBOX:
3142             {
3143                 if (pFormField->CountSelectedItems() > 1)
3144                 {
3145                     CJS_Array ValueArray(m_isolate);
3146                     CJS_Value ElementValue(m_isolate);
3147                     int iIndex;
3148                     for (int i = 0, sz = pFormField->CountSelectedItems(); i < sz; i++)
3149                     {
3150                         iIndex = pFormField->GetSelectedIndex(i);
3151                         ElementValue = pFormField->GetOptionValue(iIndex).c_str();
3152                         if (FXSYS_wcslen(ElementValue.ToCFXWideString().c_str()) == 0)
3153                             ElementValue = pFormField->GetOptionLabel(iIndex).c_str();
3154                         ValueArray.SetElement(i, ElementValue);
3155                     }
3156                     vp << ValueArray;
3157                 }
3158                 else
3159                 {
3160                     CFX_WideString swValue = pFormField->GetValue();
3161
3162                     double dRet;
3163                     FX_BOOL bDot;
3164                     if (CJS_PublicMethods::ConvertStringToNumber(swValue.c_str(), dRet, bDot))
3165                     {
3166                         if (bDot)
3167                             vp << dRet;
3168                         else
3169                             vp << dRet;
3170                     }
3171                     else
3172                         vp << swValue;
3173                 }
3174             }
3175             break;
3176         case FIELDTYPE_CHECKBOX:
3177         case FIELDTYPE_RADIOBUTTON:
3178             {
3179                 FX_BOOL bFind = FALSE;
3180                 for (int i = 0 , sz = pFormField->CountControls(); i < sz; i++)
3181                 {
3182                     if (pFormField->GetControl(i)->IsChecked())
3183                     {
3184                         CFX_WideString swValue = pFormField->GetControl(i)->GetExportValue();
3185                         double dRet;
3186                         FX_BOOL bDot;
3187                         if (CJS_PublicMethods::ConvertStringToNumber(swValue.c_str(), dRet, bDot))
3188                         {
3189                             if (bDot)
3190                                 vp << dRet;
3191                             else
3192                                 vp << dRet;
3193                         }
3194                         else
3195                             vp << swValue;
3196
3197                         bFind = TRUE;
3198                         break;
3199                     }
3200                     else
3201                         continue;
3202                 }
3203                 if (!bFind)
3204                     vp << L"Off";
3205             }
3206             break;
3207         default:
3208             vp << pFormField->GetValue();
3209             break;
3210         }
3211     }
3212
3213     return TRUE;
3214 }
3215
3216 void Field::SetValue(CPDFSDK_Document* pDocument, const CFX_WideString& swFieldName,
3217                      int nControlIndex, const CJS_WideStringArray& strArray)
3218 {
3219     ASSERT(pDocument != NULL);
3220
3221     if (strArray.GetSize() < 1) return;
3222
3223     CFX_PtrArray FieldArray;
3224     GetFormFields(pDocument, swFieldName, FieldArray);
3225
3226     for (int i=0,isz=FieldArray.GetSize(); i<isz; i++)
3227     {
3228         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
3229         ASSERT(pFormField != NULL);
3230
3231         if (pFormField->GetFullName().Compare(swFieldName) != 0)
3232             continue;
3233
3234         switch (pFormField->GetFieldType())
3235         {
3236         case FIELDTYPE_TEXTFIELD:
3237         case FIELDTYPE_COMBOBOX:
3238             if (pFormField->GetValue() != strArray.GetAt(0))
3239             {
3240                 CFX_WideString WideString = strArray.GetAt(0);
3241                 pFormField->SetValue(strArray.GetAt(0), TRUE);
3242                 UpdateFormField(pDocument, pFormField, TRUE, FALSE, TRUE);
3243             }
3244             break;
3245         case FIELDTYPE_CHECKBOX: //mantis: 0004493
3246         case FIELDTYPE_RADIOBUTTON:
3247             {
3248                 if (pFormField->GetValue() != strArray.GetAt(0))
3249                 {
3250                     pFormField->SetValue(strArray.GetAt(0), TRUE);
3251                     UpdateFormField(pDocument, pFormField, TRUE, FALSE, TRUE);
3252                 }
3253             }
3254             break;
3255         case FIELDTYPE_LISTBOX:
3256             {
3257                 FX_BOOL bModified = FALSE;
3258
3259                 for (int i=0,sz=strArray.GetSize(); i<sz; i++)
3260                 {
3261                     int iIndex = pFormField->FindOption(strArray.GetAt(i));
3262
3263                     if (!pFormField->IsItemSelected(iIndex))
3264                     {
3265                         bModified = TRUE;
3266                         break;
3267                     }
3268                 }
3269
3270                 if (bModified)
3271                 {
3272                     pFormField->ClearSelection(TRUE);
3273                     for (int i=0,sz=strArray.GetSize(); i<sz; i++)
3274                     {
3275                         int iIndex = pFormField->FindOption(strArray.GetAt(i));
3276                         pFormField->SetItemSelection(iIndex, TRUE, TRUE);
3277                     }
3278
3279                     UpdateFormField(pDocument, pFormField, TRUE, FALSE, TRUE);
3280                 }
3281             }
3282             break;
3283         default:
3284             break;
3285         }
3286     }
3287 }
3288
3289 FX_BOOL Field::valueAsString(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
3290 {
3291     ASSERT(m_pDocument != NULL);
3292
3293     if (!vp.IsGetting()) return FALSE;
3294
3295     CFX_PtrArray FieldArray;
3296     GetFormFields(m_FieldName,FieldArray);
3297     if (FieldArray.GetSize() <= 0) return FALSE;
3298
3299     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3300     ASSERT(pFormField != NULL);
3301
3302     if (pFormField->GetFieldType() == FIELDTYPE_PUSHBUTTON)
3303         return FALSE;
3304
3305     if (pFormField->GetFieldType() == FIELDTYPE_CHECKBOX)
3306     {
3307         if(!pFormField->CountControls()) return FALSE;
3308
3309         if (pFormField->GetControl(0)->IsChecked())
3310             vp << L"Yes";
3311         else
3312             vp << L"Off";
3313     }
3314     else if (pFormField->GetFieldType() == FIELDTYPE_RADIOBUTTON && !(pFormField->GetFieldFlags() & FIELDFLAG_RADIOSINUNISON))
3315     {
3316         for (int i=0, sz=pFormField->CountControls(); i<sz; i++)
3317         {
3318             if (pFormField->GetControl(i)->IsChecked())
3319             {
3320                 vp << pFormField->GetControl(i)->GetExportValue().c_str();
3321                 break;
3322             }
3323             else
3324                 vp << L"Off";
3325         }
3326     }
3327     else if (pFormField->GetFieldType() == FIELDTYPE_LISTBOX && (pFormField->CountSelectedItems() > 1))
3328     {
3329         vp << L"";
3330     }
3331     else
3332         vp << pFormField->GetValue().c_str();
3333
3334     return TRUE;
3335 }
3336
3337 /* --------------------------------- methods --------------------------------- */
3338
3339 FX_BOOL Field::browseForFileToSubmit(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3340 {
3341     ASSERT(m_pDocument != NULL);
3342
3343     CFX_PtrArray FieldArray;
3344     GetFormFields(m_FieldName, FieldArray);
3345     if (FieldArray.GetSize() <= 0) return FALSE;
3346
3347     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3348     ASSERT(pFormField != NULL);
3349
3350     CPDFDoc_Environment* pApp = m_pDocument->GetEnv();
3351     ASSERT(pApp != NULL);
3352
3353     if ((pFormField->GetFieldFlags() & FIELDFLAG_FILESELECT) &&
3354         (pFormField->GetFieldType() == FIELDTYPE_TEXTFIELD))
3355     {
3356         CFX_WideString wsFileName = pApp->JS_fieldBrowse();
3357         if(!wsFileName.IsEmpty())
3358         {
3359             pFormField->SetValue(wsFileName);
3360             UpdateFormField(m_pDocument, pFormField, TRUE, TRUE, TRUE);
3361          }
3362     }
3363     else
3364         return FALSE;
3365
3366     return TRUE;
3367 }
3368
3369
3370 FX_BOOL Field::buttonGetCaption(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3371 {
3372     ASSERT(m_pDocument != NULL);
3373
3374     int nface = 0;
3375     int iSize = params.size();
3376     if (iSize >= 1)
3377         nface = params[0].ToInt();
3378
3379     CFX_PtrArray FieldArray;
3380     GetFormFields(m_FieldName,FieldArray);
3381     if (FieldArray.GetSize() <= 0) return FALSE;
3382
3383     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3384     ASSERT(pFormField != NULL);
3385
3386     if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
3387         return FALSE;
3388
3389     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
3390     if (!pFormControl)return FALSE;
3391
3392     if (nface == 0)
3393         vRet = pFormControl->GetNormalCaption().c_str();
3394     else if (nface == 1)
3395         vRet = pFormControl->GetDownCaption().c_str();
3396     else if (nface == 2)
3397         vRet = pFormControl->GetRolloverCaption().c_str();
3398     else
3399         return FALSE;
3400
3401     return TRUE;
3402 }
3403
3404 //#pragma warning(disable: 4800)
3405
3406 FX_BOOL Field::buttonGetIcon(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3407 {
3408     ASSERT(m_pDocument != NULL);
3409
3410     int nface = 0;
3411     int iSize = params.size();
3412     if (iSize >= 1)
3413         nface = params[0].ToInt();
3414
3415     CFX_PtrArray FieldArray;
3416     GetFormFields(m_FieldName,FieldArray);
3417     if (FieldArray.GetSize() <= 0) return FALSE;
3418
3419     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3420     ASSERT(pFormField != NULL);
3421
3422     if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
3423         return FALSE;
3424
3425     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
3426     if (!pFormControl)return FALSE;
3427
3428     CJS_Context* pContext = (CJS_Context*)cc;
3429     ASSERT(pContext != NULL);
3430
3431     CJS_Runtime* pRuntime = pContext->GetJSRuntime();
3432     ASSERT(pRuntime != NULL);
3433
3434     JSFXObject pObj = JS_NewFxDynamicObj(*pRuntime, pContext, JS_GetObjDefnID(*pRuntime, L"Icon"));
3435     ASSERT(pObj.IsEmpty() == FALSE);
3436
3437     CJS_Icon* pJS_Icon = (CJS_Icon*)JS_GetPrivate(pObj);
3438     ASSERT(pJS_Icon != NULL);
3439
3440     Icon* pIcon = (Icon*)pJS_Icon->GetEmbedObject();
3441     ASSERT(pIcon != NULL);
3442
3443     CPDF_Stream* pIconStream = NULL;
3444     if (nface == 0)
3445         pIconStream = pFormControl->GetNormalIcon();
3446     else if (nface == 1)
3447         pIconStream = pFormControl->GetDownIcon();
3448     else if (nface == 2)
3449         pIconStream = pFormControl->GetRolloverIcon();
3450     else
3451         return FALSE;
3452
3453     pIcon->SetStream(pIconStream);
3454     vRet = pJS_Icon;
3455
3456     return TRUE;
3457 }
3458
3459 //#pragma warning(default: 4800)
3460
3461 FX_BOOL Field::buttonImportIcon(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3462 {
3463 #if 0
3464     ASSERT(m_pDocument != NULL);
3465
3466     CFX_PtrArray FieldArray;
3467     GetFormFields(m_FieldName,FieldArray);
3468     if (FieldArray.GetSize() <= 0) return FALSE;
3469
3470     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3471     if (!pFormField)return FALSE;
3472
3473     CPDFDoc_Environment* pEnv = m_pDocument->GetEnv();
3474     ASSERT(pEnv);
3475
3476     CFX_WideString sIconFileName = pEnv->JS_fieldBrowse();
3477     if (sIconFileName.IsEmpty())
3478     {
3479         vRet = 1;
3480         return TRUE;
3481     }
3482
3483     CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
3484     ASSERT(pInterForm != NULL);
3485
3486     CPDF_Stream* pStream = pInterForm->LoadImageFromFile(sIconFileName);
3487     if (!pStream)
3488     {
3489         vRet = -1;
3490         return TRUE;
3491     }
3492
3493     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
3494     if (!pFormControl)return FALSE;
3495
3496     pFormControl->SetNormalIcon(pStream);
3497     UpdateFormControl(m_pDocument, pFormControl, TRUE, TRUE, TRUE);
3498
3499     vRet = 0;
3500 #endif // 0
3501     return TRUE;
3502 }
3503
3504 FX_BOOL Field::buttonSetCaption(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3505 {
3506     return FALSE;
3507 }
3508
3509 FX_BOOL Field::buttonSetIcon(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3510 {
3511     return FALSE;
3512 }
3513
3514 FX_BOOL Field::checkThisBox(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3515 {
3516     ASSERT(m_pDocument != NULL);
3517
3518     if (!m_bCanSet) return FALSE;
3519
3520     int iSize = params.size();
3521     if (iSize < 1)
3522         return FALSE;
3523
3524     int nWidget = params[0].ToInt();
3525
3526     FX_BOOL bCheckit = TRUE;
3527     if (iSize >= 2)
3528         bCheckit = params[1].ToBool();
3529
3530     CFX_PtrArray FieldArray;
3531     GetFormFields(m_FieldName,FieldArray);
3532     if (FieldArray.GetSize() <= 0) return FALSE;
3533
3534     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3535     ASSERT(pFormField != NULL);
3536
3537     if (pFormField->GetFieldType() != FIELDTYPE_CHECKBOX && pFormField->GetFieldType() != FIELDTYPE_RADIOBUTTON)
3538         return FALSE;
3539     if(nWidget <0 || nWidget >= pFormField->CountControls())
3540         return FALSE;
3541     if (pFormField->GetFieldType() == FIELDTYPE_RADIOBUTTON)
3542         pFormField->CheckControl(nWidget, bCheckit, TRUE);
3543     else
3544         pFormField->CheckControl(nWidget, bCheckit, TRUE);
3545
3546     UpdateFormField(m_pDocument, pFormField, TRUE, TRUE, TRUE);
3547     return TRUE;
3548 }
3549
3550 FX_BOOL Field::clearItems(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3551 {
3552     return TRUE;
3553 }
3554
3555 FX_BOOL Field::defaultIsChecked(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3556 {
3557     ASSERT(m_pDocument != NULL);
3558
3559     if (!m_bCanSet) return FALSE;
3560
3561     int iSize = params.size();
3562     if (iSize < 1)
3563         return FALSE;
3564
3565     int nWidget = params[0].ToInt();
3566
3567     CFX_PtrArray FieldArray;
3568     GetFormFields(m_FieldName,FieldArray);
3569     if (FieldArray.GetSize() <= 0) return FALSE;
3570
3571     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3572     ASSERT(pFormField != NULL);
3573
3574     if(nWidget <0 || nWidget >= pFormField->CountControls())
3575     {
3576         vRet = FALSE;
3577         return FALSE;
3578     }
3579     if ((pFormField->GetFieldType() == FIELDTYPE_CHECKBOX)
3580         || (pFormField->GetFieldType() == FIELDTYPE_RADIOBUTTON))
3581     {
3582
3583         vRet = TRUE;
3584     }
3585     else
3586         vRet = FALSE;
3587
3588     return TRUE;
3589 }
3590
3591 FX_BOOL Field::deleteItemAt(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3592 {
3593     return TRUE;
3594 }
3595
3596 int JS_COMPARESTRING(CFX_WideString* ps1, CFX_WideString* ps2)
3597 {
3598     ASSERT(ps1 != NULL);
3599     ASSERT(ps2 != NULL);
3600
3601     return ps1->Compare(*ps2);
3602 }
3603
3604
3605 FX_BOOL Field::getArray(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3606 {
3607     ASSERT(m_pDocument != NULL);
3608
3609     CFX_PtrArray FieldArray;
3610     GetFormFields(m_FieldName,FieldArray);
3611     if (FieldArray.GetSize() <= 0) return FALSE;
3612
3613     CGW_ArrayTemplate<CFX_WideString*> swSort;
3614
3615     for (int i=0,sz=FieldArray.GetSize(); i<sz; i++)
3616     {
3617         CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
3618         ASSERT(pFormField != NULL);
3619
3620         swSort.Add(new CFX_WideString(pFormField->GetFullName()));
3621
3622     }
3623     swSort.Sort(JS_COMPARESTRING);
3624
3625     CJS_Context* pContext = (CJS_Context*)cc;
3626     ASSERT(pContext != NULL);
3627     CJS_Runtime* pRuntime = pContext->GetJSRuntime();
3628     ASSERT(pRuntime != NULL);
3629
3630     CJS_Array FormFieldArray(m_isolate);
3631     for (int j=0,jsz = swSort.GetSize(); j<jsz; j++)
3632     {
3633         CFX_WideString* pStr = swSort.GetAt(j);
3634
3635         JSFXObject pObj = JS_NewFxDynamicObj(*pRuntime, pContext, JS_GetObjDefnID(*pRuntime, L"Field"));
3636         ASSERT(pObj.IsEmpty() == FALSE);
3637
3638         CJS_Field* pJSField = (CJS_Field*)JS_GetPrivate(pObj);
3639         ASSERT(pJSField != NULL);
3640
3641         Field* pField = (Field*)pJSField->GetEmbedObject();
3642         ASSERT(pField != NULL);
3643
3644         pField->AttachField(m_pJSDoc, *pStr);
3645
3646         CJS_Value FormFieldValue(m_isolate);
3647         FormFieldValue = pJSField;
3648         FormFieldArray.SetElement(j, FormFieldValue);
3649
3650         delete pStr;
3651     }
3652
3653     vRet = FormFieldArray;
3654     swSort.RemoveAll();
3655     return TRUE;
3656 }
3657
3658 FX_BOOL Field::getItemAt(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3659 {
3660     ASSERT(m_pDocument != NULL);
3661     int iSize = params.size();
3662
3663     int nIdx = -1;
3664     if (iSize >= 1)
3665         nIdx = params[0].ToInt();
3666
3667     FX_BOOL bExport = TRUE;
3668     if (iSize >= 2)
3669         bExport = params[1].ToBool();
3670
3671     CFX_PtrArray FieldArray;
3672     GetFormFields(m_FieldName,FieldArray);
3673     if (FieldArray.GetSize() <= 0) return FALSE;
3674
3675     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3676     ASSERT(pFormField != NULL);
3677
3678     if ((pFormField->GetFieldType() == FIELDTYPE_LISTBOX)
3679         || (pFormField->GetFieldType() == FIELDTYPE_COMBOBOX))
3680     {
3681         if (nIdx == -1 || nIdx > pFormField->CountOptions())
3682             nIdx = pFormField->CountOptions() -1;
3683         if (bExport)
3684         {
3685             CFX_WideString strval = pFormField->GetOptionValue(nIdx);
3686             if (strval.IsEmpty())
3687                 vRet = pFormField->GetOptionLabel(nIdx).c_str();
3688             else
3689                 vRet = strval.c_str();
3690         }
3691         else
3692             vRet = pFormField->GetOptionLabel(nIdx).c_str();
3693     }
3694     else
3695         return FALSE;
3696
3697     return TRUE;
3698 }
3699
3700 FX_BOOL Field::getLock(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3701 {
3702     return FALSE;
3703 }
3704
3705 FX_BOOL Field::insertItemAt(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3706 {
3707     return TRUE;
3708 }
3709
3710 FX_BOOL Field::isBoxChecked(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3711 {
3712     ASSERT(m_pDocument != NULL);
3713
3714     int nIndex = -1;
3715     if (params.size() >= 1)
3716         nIndex = params[0].ToInt();
3717
3718     CFX_PtrArray FieldArray;
3719     GetFormFields(m_FieldName,FieldArray);
3720     if (FieldArray.GetSize() <= 0) return FALSE;
3721
3722     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3723     ASSERT(pFormField != NULL);
3724
3725     if(nIndex <0 || nIndex >= pFormField->CountControls())
3726     {
3727         vRet = FALSE;
3728         return FALSE;
3729     }
3730
3731     if ((pFormField->GetFieldType() == FIELDTYPE_CHECKBOX)
3732         || (pFormField->GetFieldType() == FIELDTYPE_RADIOBUTTON))
3733     {
3734         if (pFormField->GetControl(nIndex)->IsChecked() !=0 )
3735             vRet = TRUE;
3736         else
3737             vRet = FALSE;
3738     }
3739     else
3740         vRet = FALSE;
3741
3742     return TRUE;
3743 }
3744
3745 FX_BOOL Field::isDefaultChecked(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3746 {
3747     ASSERT(m_pDocument != NULL);
3748
3749     int nIndex = -1;
3750     if (params.size() >= 1)
3751         nIndex = params[0].ToInt();
3752
3753     CFX_PtrArray FieldArray;
3754     GetFormFields(m_FieldName,FieldArray);
3755     if (FieldArray.GetSize() <= 0) return FALSE;
3756
3757     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3758     ASSERT(pFormField != NULL);
3759
3760     if(nIndex <0 || nIndex >= pFormField->CountControls())
3761     {
3762         vRet = FALSE;
3763         return FALSE;
3764     }
3765     if ((pFormField->GetFieldType() == FIELDTYPE_CHECKBOX)
3766         || (pFormField->GetFieldType() == FIELDTYPE_RADIOBUTTON))
3767     {
3768         if (pFormField->GetControl(nIndex)->IsDefaultChecked() != 0)
3769             vRet = TRUE;
3770         else
3771             vRet = FALSE;
3772     }
3773     else
3774         vRet = FALSE;
3775
3776     return TRUE;
3777 }
3778
3779 FX_BOOL Field::setAction(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3780 {
3781     return TRUE;
3782 }
3783
3784 FX_BOOL Field::setFocus(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3785 {
3786     ASSERT(m_pDocument != NULL);
3787
3788     CFX_PtrArray FieldArray;
3789     GetFormFields(m_FieldName,FieldArray);
3790     if (FieldArray.GetSize() <= 0) return FALSE;
3791
3792     CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
3793     ASSERT(pFormField != NULL);
3794
3795     int32_t nCount = pFormField->CountControls();
3796
3797     if (nCount < 1) return FALSE;
3798
3799     CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
3800     ASSERT(pInterForm != NULL);
3801
3802     CPDFSDK_Widget* pWidget = NULL;
3803     if (nCount == 1)
3804     {
3805         pWidget = pInterForm->GetWidget(pFormField->GetControl(0));
3806     }
3807     else
3808     {
3809         CPDFDoc_Environment* pEnv = m_pDocument->GetEnv();
3810         ASSERT(pEnv);
3811         CPDF_Page* pPage = (CPDF_Page*)pEnv->FFI_GetCurrentPage(m_pDocument->GetDocument());
3812         if(!pPage)
3813             return FALSE;
3814         if (CPDFSDK_PageView* pCurPageView = m_pDocument->GetPageView(pPage))
3815         {
3816             for (int32_t i=0; i<nCount; i++)
3817             {
3818                 if (CPDFSDK_Widget* pTempWidget =  pInterForm->GetWidget(pFormField->GetControl(i)))
3819                 {
3820                     if (pTempWidget->GetPDFPage() == pCurPageView->GetPDFPage())
3821                     {
3822                         pWidget = pTempWidget;
3823                         break;
3824                     }
3825                 }
3826             }
3827         }
3828     }
3829
3830     if (pWidget)
3831     {
3832         m_pDocument->SetFocusAnnot(pWidget);
3833     }
3834
3835     return TRUE;
3836 }
3837
3838 FX_BOOL Field::setItems(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3839 {
3840     return TRUE;
3841 }
3842
3843 FX_BOOL Field::setLock(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3844 {
3845     return FALSE;
3846 }
3847
3848 FX_BOOL Field::signatureGetModifications(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3849 {
3850     return FALSE;
3851 }
3852
3853 FX_BOOL Field::signatureGetSeedValue(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3854 {
3855     return FALSE;
3856 }
3857
3858 FX_BOOL Field::signatureInfo(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3859 {
3860     return FALSE;
3861 }
3862
3863 FX_BOOL Field::signatureSetSeedValue(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3864 {
3865     return FALSE;
3866 }
3867
3868 FX_BOOL Field::signatureSign(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3869 {
3870     return FALSE;
3871 }
3872
3873 FX_BOOL Field::signatureValidate(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
3874 {
3875     return FALSE;
3876 }
3877
3878 FX_BOOL Field::source(IFXJS_Context* cc, CJS_PropValue& vp, CFX_WideString& sError)
3879 {
3880     if (vp.IsGetting())
3881     {
3882         vp << (CJS_Object*)NULL;
3883     }
3884
3885     return TRUE;
3886 }
3887
3888 /////////////////////////////////////////// delay /////////////////////////////////////////////
3889
3890 void Field::AddDelay_Int(enum FIELD_PROP prop, int32_t n)
3891 {
3892     ASSERT(m_pJSDoc != NULL);
3893
3894     CJS_DelayData* pNewData = new CJS_DelayData;
3895     pNewData->sFieldName = m_FieldName;
3896     pNewData->nControlIndex = m_nFormControlIndex;
3897     pNewData->eProp = prop;
3898     pNewData->num = n;
3899
3900     m_pJSDoc->AddDelayData(pNewData);
3901 }
3902
3903 void Field::AddDelay_Bool(enum FIELD_PROP prop,bool b)
3904 {
3905     ASSERT(m_pJSDoc != NULL);
3906
3907     CJS_DelayData* pNewData = new CJS_DelayData;
3908     pNewData->sFieldName = m_FieldName;
3909     pNewData->nControlIndex = m_nFormControlIndex;
3910     pNewData->eProp = prop;
3911     pNewData->b = b;
3912
3913     m_pJSDoc->AddDelayData(pNewData);
3914 }
3915
3916 void Field::AddDelay_String(enum FIELD_PROP prop, const CFX_ByteString& string)
3917 {
3918     ASSERT(m_pJSDoc != NULL);
3919
3920     CJS_DelayData* pNewData = new CJS_DelayData;
3921     pNewData->sFieldName = m_FieldName;
3922     pNewData->nControlIndex = m_nFormControlIndex;
3923     pNewData->eProp = prop;
3924     pNewData->string = string;
3925
3926     m_pJSDoc->AddDelayData(pNewData);
3927 }
3928
3929 void Field::AddDelay_WideString(enum FIELD_PROP prop, const CFX_WideString& string)
3930 {
3931     ASSERT(m_pJSDoc != NULL);
3932
3933     CJS_DelayData* pNewData = new CJS_DelayData;
3934     pNewData->sFieldName = m_FieldName;
3935     pNewData->nControlIndex = m_nFormControlIndex;
3936     pNewData->eProp = prop;
3937     pNewData->widestring = string;
3938
3939     m_pJSDoc->AddDelayData(pNewData);
3940 }
3941
3942 void Field::AddDelay_Rect(enum FIELD_PROP prop, const CPDF_Rect& rect)
3943 {
3944     ASSERT(m_pJSDoc != NULL);
3945
3946     CJS_DelayData* pNewData = new CJS_DelayData;
3947     pNewData->sFieldName = m_FieldName;
3948     pNewData->nControlIndex = m_nFormControlIndex;
3949     pNewData->eProp = prop;
3950     pNewData->rect = rect;
3951
3952     m_pJSDoc->AddDelayData(pNewData);
3953 }
3954
3955 void Field::AddDelay_Color(enum FIELD_PROP prop, const CPWL_Color& color)
3956 {
3957     ASSERT(m_pJSDoc != NULL);
3958
3959     CJS_DelayData* pNewData = new CJS_DelayData;
3960     pNewData->sFieldName = m_FieldName;
3961     pNewData->nControlIndex = m_nFormControlIndex;
3962     pNewData->eProp = prop;
3963     pNewData->color = color;
3964
3965     m_pJSDoc->AddDelayData(pNewData);
3966 }
3967
3968 void Field::AddDelay_WordArray(enum FIELD_PROP prop, const CFX_DWordArray& array)
3969 {
3970     ASSERT(m_pJSDoc != NULL);
3971
3972     CJS_DelayData* pNewData = new CJS_DelayData;
3973     pNewData->sFieldName = m_FieldName;
3974     pNewData->nControlIndex = m_nFormControlIndex;
3975     pNewData->eProp = prop;
3976
3977     for (int i=0,sz=array.GetSize(); i<sz; i++)
3978         pNewData->wordarray.Add(array.GetAt(i));
3979
3980     m_pJSDoc->AddDelayData(pNewData);
3981 }
3982
3983 void Field::AddDelay_WideStringArray(enum FIELD_PROP prop, const CJS_WideStringArray& array)
3984 {
3985     ASSERT(m_pJSDoc != NULL);
3986
3987     CJS_DelayData* pNewData = new CJS_DelayData;
3988     pNewData->sFieldName = m_FieldName;
3989     pNewData->nControlIndex = m_nFormControlIndex;
3990     pNewData->eProp = prop;
3991     for (int i=0,sz=array.GetSize(); i<sz; i++)
3992         pNewData->widestringarray.Add(array.GetAt(i));
3993
3994     m_pJSDoc->AddDelayData(pNewData);
3995 }
3996
3997 void Field::DoDelay(CPDFSDK_Document* pDocument, CJS_DelayData* pData)
3998 {
3999     ASSERT(pDocument != NULL);
4000     ASSERT(pData != NULL);
4001
4002     switch (pData->eProp)
4003     {
4004     case FP_ALIGNMENT:
4005         Field::SetAlignment(pDocument, pData->sFieldName, pData->nControlIndex, pData->string);
4006         break;
4007     case FP_BORDERSTYLE:
4008         Field::SetBorderStyle(pDocument, pData->sFieldName, pData->nControlIndex, pData->string);
4009         break;
4010     case FP_BUTTONALIGNX:
4011         Field::SetButtonAlignX(pDocument, pData->sFieldName, pData->nControlIndex, pData->num);
4012         break;
4013     case FP_BUTTONALIGNY:
4014         Field::SetButtonAlignY(pDocument, pData->sFieldName, pData->nControlIndex, pData->num);
4015         break;
4016     case FP_BUTTONFITBOUNDS:
4017         Field::SetButtonFitBounds(pDocument, pData->sFieldName, pData->nControlIndex, pData->b);
4018         break;
4019     case FP_BUTTONPOSITION:
4020         Field::SetButtonPosition(pDocument, pData->sFieldName, pData->nControlIndex, pData->num);
4021         break;
4022     case FP_BUTTONSCALEHOW:
4023         Field::SetButtonScaleHow(pDocument, pData->sFieldName, pData->nControlIndex, pData->num);
4024         break;
4025     case FP_BUTTONSCALEWHEN:
4026         Field::SetButtonScaleWhen(pDocument, pData->sFieldName, pData->nControlIndex, pData->num);
4027         break;
4028     case FP_CALCORDERINDEX:
4029         Field::SetCalcOrderIndex(pDocument, pData->sFieldName, pData->nControlIndex, pData->num);
4030         break;
4031     case FP_CHARLIMIT:
4032         Field::SetCharLimit(pDocument, pData->sFieldName, pData->nControlIndex, pData->num);
4033         break;
4034     case FP_COMB:
4035         Field::SetComb(pDocument, pData->sFieldName, pData->nControlIndex, pData->b);
4036         break;
4037     case FP_COMMITONSELCHANGE:
4038         Field::SetCommitOnSelChange(pDocument, pData->sFieldName, pData->nControlIndex, pData->b);
4039         break;
4040     case FP_CURRENTVALUEINDICES:
4041         Field::SetCurrentValueIndices(pDocument, pData->sFieldName, pData->nControlIndex, pData->wordarray);
4042         break;
4043     case FP_DEFAULTVALUE:
4044         Field::SetDefaultValue(pDocument, pData->sFieldName, pData->nControlIndex, pData->widestring);
4045         break;
4046     case FP_DONOTSCROLL:
4047         Field::SetDoNotScroll(pDocument, pData->sFieldName, pData->nControlIndex, pData->b);
4048         break;
4049     case FP_DISPLAY:
4050         Field::SetDisplay(pDocument, pData->sFieldName, pData->nControlIndex, pData->num);
4051         break;
4052     case FP_FILLCOLOR:
4053         Field::SetFillColor(pDocument, pData->sFieldName, pData->nControlIndex, pData->color);
4054         break;
4055     case FP_HIDDEN:
4056         Field::SetHidden(pDocument, pData->sFieldName, pData->nControlIndex, pData->b);
4057         break;
4058     case FP_HIGHLIGHT:
4059         Field::SetHighlight(pDocument, pData->sFieldName, pData->nControlIndex, pData->string);
4060         break;
4061     case FP_LINEWIDTH:
4062         Field::SetLineWidth(pDocument, pData->sFieldName, pData->nControlIndex, pData->num);
4063         break;
4064     case FP_MULTILINE:
4065         Field::SetMultiline(pDocument, pData->sFieldName, pData->nControlIndex, pData->b);
4066         break;
4067     case FP_MULTIPLESELECTION:
4068         Field::SetMultipleSelection(pDocument, pData->sFieldName, pData->nControlIndex, pData->b);
4069         break;
4070     case FP_PASSWORD:
4071         Field::SetPassword(pDocument, pData->sFieldName, pData->nControlIndex, pData->b);
4072         break;
4073     case FP_RECT:
4074         Field::SetRect(pDocument, pData->sFieldName, pData->nControlIndex, pData->rect);
4075         break;
4076     case FP_RICHTEXT:
4077         Field::SetRichText(pDocument, pData->sFieldName, pData->nControlIndex, pData->b);
4078         break;
4079     case FP_RICHVALUE:
4080         break;
4081     case FP_ROTATION:
4082         Field::SetRotation(pDocument, pData->sFieldName, pData->nControlIndex, pData->num);
4083         break;
4084     case FP_STROKECOLOR:
4085         Field::SetStrokeColor(pDocument, pData->sFieldName, pData->nControlIndex, pData->color);
4086         break;
4087     case FP_STYLE:
4088         Field::SetStyle(pDocument, pData->sFieldName, pData->nControlIndex, pData->string);
4089         break;
4090     case FP_TEXTCOLOR:
4091         Field::SetTextColor(pDocument, pData->sFieldName, pData->nControlIndex, pData->color);
4092         break;
4093     case FP_TEXTFONT:
4094         Field::SetTextFont(pDocument, pData->sFieldName, pData->nControlIndex, pData->string);
4095         break;
4096     case FP_TEXTSIZE:
4097         Field::SetTextSize(pDocument, pData->sFieldName, pData->nControlIndex, pData->num);
4098         break;
4099     case FP_USERNAME:
4100         Field::SetUserName(pDocument, pData->sFieldName, pData->nControlIndex, pData->widestring);
4101         break;
4102     case FP_VALUE:
4103         Field::SetValue(pDocument, pData->sFieldName, pData->nControlIndex, pData->widestringarray);
4104         break;
4105     }
4106 }
4107
4108 #define JS_FIELD_MINWIDTH   1
4109 #define JS_FIELD_MINHEIGHT  1
4110
4111 void Field::AddField(CPDFSDK_Document* pDocument, int nPageIndex, int nFieldType,
4112                      const CFX_WideString& sName, const CPDF_Rect& rcCoords)
4113 {
4114     //Not supported.
4115 }
4116