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