Merge to XFA: Remove CFX_PtrArray usage in fpdfsdk.

fpdfsdk/src/javascript/Field.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "Field.h"
 
 #include "../../include/fsdk_mgr.h"  // For CPDFDoc_Environment.
 #include "../../include/javascript/IJavaScript.h"
@@ skipping 96 matching lines @@
 JS_STATIC_METHOD_ENTRY(signatureSign)
 JS_STATIC_METHOD_ENTRY(signatureValidate)
 END_JS_STATIC_METHOD()
 
 IMPLEMENT_JS_CLASS(CJS_Field, Field)
 
 void CJS_Field::InitInstance(IJS_Runtime* pIRuntime) {
   CJS_Runtime* pRuntime = static_cast<CJS_Runtime*>(pIRuntime);
   Field* pField = static_cast<Field*>(GetEmbedObject());
   pField->SetIsolate(pRuntime->GetIsolate());
-};
+}
 
 Field::Field(CJS_Object* pJSObject)
     : CJS_EmbedObj(pJSObject),
       m_pJSDoc(NULL),
       m_pDocument(NULL),
       m_nFormControlIndex(-1),
       m_bCanSet(FALSE),
       m_bDelay(FALSE),
       m_isolate(NULL) {}
 
@@ skipping 58 matching lines @@
     m_nFormControlIndex = iControlNo;
     return TRUE;
   }
 
   m_FieldName = swFieldNameTemp;
   m_nFormControlIndex = -1;
 
   return TRUE;
 }
 
-void Field::GetFormFields(CPDFSDK_Document* pDocument,
-                          const CFX_WideString& csFieldName,
-                          CFX_PtrArray& FieldArray) {
-  ASSERT(pDocument != NULL);
-
+std::vector<CPDF_FormField*> Field::GetFormFields(
+    CPDFSDK_Document* pDocument,
+    const CFX_WideString& csFieldName) {
+  std::vector<CPDF_FormField*> fields;
   CPDFSDK_InterForm* pReaderInterForm = pDocument->GetInterForm();
-  ASSERT(pReaderInterForm != NULL);
-
   CPDF_InterForm* pInterForm = pReaderInterForm->GetInterForm();
-  ASSERT(pInterForm != NULL);
-
-  ASSERT(FieldArray.GetSize() == 0);
-
-  for (int i = 0, sz = pInterForm->CountFields(csFieldName); i < sz; i++) {
+  for (int i = 0, sz = pInterForm->CountFields(csFieldName); i < sz; ++i) {
     if (CPDF_FormField* pFormField = pInterForm->GetField(i, csFieldName))
-      FieldArray.Add((void*)pFormField);
+      fields.push_back(pFormField);
   }
+  return fields;
 }
 
-void Field::GetFormFields(const CFX_WideString& csFieldName,
-                          CFX_PtrArray& FieldArray) {
-  ASSERT(m_pDocument != NULL);
-
-  Field::GetFormFields(m_pDocument, csFieldName, FieldArray);
+std::vector<CPDF_FormField*> Field::GetFormFields(
+    const CFX_WideString& csFieldName) const {
+  return Field::GetFormFields(m_pDocument, csFieldName);
 }
 
 void Field::UpdateFormField(CPDFSDK_Document* pDocument,
                             CPDF_FormField* pFormField,
                             FX_BOOL bChangeMark,
                             FX_BOOL bResetAP,
                             FX_BOOL bRefresh) {
-  ASSERT(pDocument != NULL);
-  ASSERT(pFormField != NULL);
-
+  std::vector<CPDFSDK_Widget*> widgets;
   CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)pDocument->GetInterForm();
-  ASSERT(pInterForm != NULL);
-
-  CFX_PtrArray widgets;
-  pInterForm->GetWidgets(pFormField, widgets);
+  pInterForm->GetWidgets(pFormField, &widgets);
 
   if (bResetAP) {
     int nFieldType = pFormField->GetFieldType();
     if (nFieldType == FIELDTYPE_COMBOBOX || nFieldType == FIELDTYPE_TEXTFIELD) {
-      for (int i = 0, sz = widgets.GetSize(); i < sz; i++) {
-        CPDFSDK_Widget* pWidget = (CPDFSDK_Widget*)widgets.GetAt(i);
-        ASSERT(pWidget != NULL);
-
-        FX_BOOL bFormated = FALSE;
-        CFX_WideString sValue = pWidget->OnFormat(bFormated);
-        if (bFormated)
-          pWidget->ResetAppearance(sValue.c_str(), FALSE);
-        else
-          pWidget->ResetAppearance(NULL, FALSE);
+      for (CPDFSDK_Widget* pWidget : widgets) {
+        FX_BOOL bFormatted = FALSE;
+        CFX_WideString sValue = pWidget->OnFormat(bFormatted);
+        pWidget->ResetAppearance(bFormatted ? sValue.c_str() : nullptr, FALSE);
       }
     } else {
-      for (int i = 0, sz = widgets.GetSize(); i < sz; i++) {
-        CPDFSDK_Widget* pWidget = (CPDFSDK_Widget*)widgets.GetAt(i);
-        ASSERT(pWidget != NULL);
-
-        pWidget->ResetAppearance(NULL, FALSE);
+      for (CPDFSDK_Widget* pWidget : widgets) {
+        pWidget->ResetAppearance(nullptr, FALSE);
       }
     }
   }
 
   if (bRefresh) {
-    for (int i = 0, sz = widgets.GetSize(); i < sz; i++) {
-      CPDFSDK_Widget* pWidget = (CPDFSDK_Widget*)widgets.GetAt(i);
-      ASSERT(pWidget != NULL);
-
-      CPDFSDK_InterForm* pInterForm = pWidget->GetInterForm();
-      CPDFSDK_Document* pDoc = pInterForm->GetDocument();
-      //          CReader_Page* pPage = pWidget->GetPage();
-      ASSERT(pDoc != NULL);
-      pDoc->UpdateAllViews(NULL, pWidget);
+    for (CPDFSDK_Widget* pWidget : widgets) {
+      CPDFSDK_Document* pDoc = pWidget->GetInterForm()->GetDocument();
+      pDoc->UpdateAllViews(nullptr, pWidget);
     }
   }
 
   if (bChangeMark)
     pDocument->SetChangeMark();
 }
 
 void Field::UpdateFormControl(CPDFSDK_Document* pDocument,
                               CPDF_FormControl* pFormControl,
                               FX_BOOL bChangeMark,
@@ skipping 84 matching lines @@
     CFX_ByteString alignStr;
     vp >> alignStr;
 
     if (m_bDelay) {
       AddDelay_String(FP_ALIGNMENT, alignStr);
     } else {
       Field::SetAlignment(m_pDocument, m_FieldName, m_nFormControlIndex,
                           alignStr);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
       return FALSE;
 
     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
     if (!pFormControl)
       return FALSE;
 
     switch (pFormControl->GetControlAlignment()) {
       case 1:
         vp << L"center";
@@ skipping 31 matching lines @@
     CFX_ByteString strType = "";
     vp >> strType;
 
     if (m_bDelay) {
       AddDelay_String(FP_BORDERSTYLE, strType);
     } else {
       Field::SetBorderStyle(m_pDocument, m_FieldName, m_nFormControlIndex,
                             strType);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
+    CPDF_FormField* pFormField = FieldArray[0];
     if (!pFormField)
       return FALSE;
 
     CPDFSDK_Widget* pWidget =
         GetWidget(m_pDocument, GetSmartFieldControl(pFormField));
     if (!pWidget)
       return FALSE;
 
     int nBorderstyle = pWidget->GetBorderStyle();
 
@@ skipping 36 matching lines @@
     nBorderStyle = BBS_BEVELED;
   else if (string == "dashed")
     nBorderStyle = BBS_DASH;
   else if (string == "inset")
     nBorderStyle = BBS_INSET;
   else if (string == "underline")
     nBorderStyle = BBS_UNDERLINE;
   else
     return;
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(pDocument, swFieldName, FieldArray);
-
-  for (int i = 0, isz = FieldArray.GetSize(); i < isz; i++) {
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
-    ASSERT(pFormField != NULL);
-
+  std::vector<CPDF_FormField*> FieldArray =
+      GetFormFields(pDocument, swFieldName);
+  for (CPDF_FormField* pFormField : FieldArray) {
     if (nControlIndex < 0) {
       FX_BOOL bSet = FALSE;
-      for (int j = 0, jsz = pFormField->CountControls(); j < jsz; j++) {
+      for (int i = 0, sz = pFormField->CountControls(); i < sz; ++i) {
         if (CPDFSDK_Widget* pWidget =
-                GetWidget(pDocument, pFormField->GetControl(j))) {
+                GetWidget(pDocument, pFormField->GetControl(i))) {
           if (pWidget->GetBorderStyle() != nBorderStyle) {
             pWidget->SetBorderStyle(nBorderStyle);
             bSet = TRUE;
           }
         }
       }
       if (bSet)
         UpdateFormField(pDocument, pFormField, TRUE, TRUE, TRUE);
     } else {
       if (nControlIndex >= pFormField->CountControls())
@@ skipping 23 matching lines @@
     int nVP;
     vp >> nVP;
 
     if (m_bDelay) {
       AddDelay_Int(FP_BUTTONALIGNX, nVP);
     } else {
       Field::SetButtonAlignX(m_pDocument, m_FieldName, m_nFormControlIndex,
                              nVP);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
       return FALSE;
 
     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
     if (!pFormControl)
       return FALSE;
 
     CPDF_IconFit IconFit = pFormControl->GetIconFit();
 
     FX_FLOAT fLeft, fBottom;
@@ skipping 24 matching lines @@
     int nVP;
     vp >> nVP;
 
     if (m_bDelay) {
       AddDelay_Int(FP_BUTTONALIGNY, nVP);
     } else {
       Field::SetButtonAlignY(m_pDocument, m_FieldName, m_nFormControlIndex,
                              nVP);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
       return FALSE;
 
     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
     if (!pFormControl)
       return FALSE;
 
     CPDF_IconFit IconFit = pFormControl->GetIconFit();
 
     FX_FLOAT fLeft, fBottom;
@@ skipping 24 matching lines @@
     bool bVP;
     vp >> bVP;
 
     if (m_bDelay) {
       AddDelay_Bool(FP_BUTTONFITBOUNDS, bVP);
     } else {
       Field::SetButtonFitBounds(m_pDocument, m_FieldName, m_nFormControlIndex,
                                 bVP);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
       return FALSE;
 
     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
     if (!pFormControl)
       return FALSE;
 
     CPDF_IconFit IconFit = pFormControl->GetIconFit();
     vp << IconFit.GetFittingBounds();
   }
@@ skipping 20 matching lines @@
     int nVP;
     vp >> nVP;
 
     if (m_bDelay) {
       AddDelay_Int(FP_BUTTONPOSITION, nVP);
     } else {
       Field::SetButtonPosition(m_pDocument, m_FieldName, m_nFormControlIndex,
                                nVP);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
       return FALSE;
 
     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
     if (!pFormControl)
       return FALSE;
 
     vp << pFormControl->GetTextPosition();
   }
   return TRUE;
@@ skipping 18 matching lines @@
     int nVP;
     vp >> nVP;
 
     if (m_bDelay) {
       AddDelay_Int(FP_BUTTONSCALEHOW, nVP);
     } else {
       Field::SetButtonScaleHow(m_pDocument, m_FieldName, m_nFormControlIndex,
                                nVP);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
       return FALSE;
 
     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
     if (!pFormControl)
       return FALSE;
 
     CPDF_IconFit IconFit = pFormControl->GetIconFit();
     if (IconFit.IsProportionalScale())
       vp << (int32_t)0;
@@ skipping 23 matching lines @@
     int nVP;
     vp >> nVP;
 
     if (m_bDelay) {
       AddDelay_Int(FP_BUTTONSCALEWHEN, nVP);
     } else {
       Field::SetButtonScaleWhen(m_pDocument, m_FieldName, m_nFormControlIndex,
                                 nVP);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
       return FALSE;
 
     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
     if (!pFormControl)
       return FALSE;
 
     CPDF_IconFit IconFit = pFormControl->GetIconFit();
     int ScaleM = IconFit.GetScaleMethod();
     switch (ScaleM) {
@@ skipping 34 matching lines @@
     int nVP;
     vp >> nVP;
 
     if (m_bDelay) {
       AddDelay_Int(FP_CALCORDERINDEX, nVP);
     } else {
       Field::SetCalcOrderIndex(m_pDocument, m_FieldName, m_nFormControlIndex,
                                nVP);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() != FIELDTYPE_COMBOBOX &&
-        pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
+        pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD) {
       return FALSE;
+    }
 
     CPDFSDK_InterForm* pRDInterForm = m_pDocument->GetInterForm();
     ASSERT(pRDInterForm != NULL);
 
     CPDF_InterForm* pInterForm = pRDInterForm->GetInterForm();
     ASSERT(pInterForm != NULL);
 
     vp << (int32_t)pInterForm->FindFieldInCalculationOrder(pFormField);
   }
 
@@ skipping 18 matching lines @@
 
     int nVP;
     vp >> nVP;
 
     if (m_bDelay) {
       AddDelay_Int(FP_CHARLIMIT, nVP);
     } else {
       Field::SetCharLimit(m_pDocument, m_FieldName, m_nFormControlIndex, nVP);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
       return FALSE;
 
     vp << (int32_t)pFormField->GetMaxLen();
   }
   return TRUE;
 }
 
 void Field::SetCharLimit(CPDFSDK_Document* pDocument,
                          const CFX_WideString& swFieldName,
@@ skipping 13 matching lines @@
 
     bool bVP;
     vp >> bVP;
 
     if (m_bDelay) {
       AddDelay_Bool(FP_COMB, bVP);
     } else {
       Field::SetComb(m_pDocument, m_FieldName, m_nFormControlIndex, bVP);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
       return FALSE;
 
     if (pFormField->GetFieldFlags() & FIELDFLAG_COMB)
       vp << true;
     else
       vp << false;
   }
 
   return TRUE;
@@ skipping 18 matching lines @@
     bool bVP;
     vp >> bVP;
 
     if (m_bDelay) {
       AddDelay_Bool(FP_COMMITONSELCHANGE, bVP);
     } else {
       Field::SetCommitOnSelChange(m_pDocument, m_FieldName, m_nFormControlIndex,
                                   bVP);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() != FIELDTYPE_COMBOBOX &&
-        pFormField->GetFieldType() != FIELDTYPE_LISTBOX)
+        pFormField->GetFieldType() != FIELDTYPE_LISTBOX) {
       return FALSE;
+    }
 
     if (pFormField->GetFieldFlags() & FIELDFLAG_COMMITONSELCHANGE)
       vp << true;
     else
       vp << false;
   }
 
   return TRUE;
 }
 
@@ skipping 31 matching lines @@
       }
     }
 
     if (m_bDelay) {
       AddDelay_WordArray(FP_CURRENTVALUEINDICES, array);
     } else {
       Field::SetCurrentValueIndices(m_pDocument, m_FieldName,
                                     m_nFormControlIndex, array);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
+    CPDF_FormField* pFormField = FieldArray[0];
+    if (pFormField->GetFieldType() != FIELDTYPE_COMBOBOX &&
+        pFormField->GetFieldType() != FIELDTYPE_LISTBOX) {
+      return FALSE;
+    }
 
-    if (pFormField->GetFieldType() != FIELDTYPE_COMBOBOX &&
-        pFormField->GetFieldType() != FIELDTYPE_LISTBOX)
-      return FALSE;
-
-    if (pFormField->CountSelectedItems() == 1)
+    if (pFormField->CountSelectedItems() == 1) {
       vp << pFormField->GetSelectedIndex(0);
-    else if (pFormField->CountSelectedItems() > 1) {
+    } else if (pFormField->CountSelectedItems() > 1) {
       CJS_Array SelArray(pRuntime);
       for (int i = 0, sz = pFormField->CountSelectedItems(); i < sz; i++) {
         SelArray.SetElement(
             i, CJS_Value(pRuntime, pFormField->GetSelectedIndex(i)));
       }
       vp << SelArray;
-    } else
+    } else {
       vp << -1;
+    }
   }
 
   return TRUE;
 }
 
 void Field::SetCurrentValueIndices(CPDFSDK_Document* pDocument,
                                    const CFX_WideString& swFieldName,
                                    int nControlIndex,
                                    const CFX_DWordArray& array) {
   ASSERT(pDocument != NULL);
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(pDocument, swFieldName, FieldArray);
-
-  for (int i = 0, isz = FieldArray.GetSize(); i < isz; i++) {
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
-    ASSERT(pFormField != NULL);
-
+  std::vector<CPDF_FormField*> FieldArray =
+      GetFormFields(pDocument, swFieldName);
+  for (CPDF_FormField* pFormField : FieldArray) {
     int nFieldType = pFormField->GetFieldType();
     if (nFieldType == FIELDTYPE_COMBOBOX || nFieldType == FIELDTYPE_LISTBOX) {
       FX_DWORD dwFieldFlags = pFormField->GetFieldFlags();
       pFormField->ClearSelection(TRUE);
 
       for (int i = 0, sz = array.GetSize(); i < sz; i++) {
         if (i > 0 && !(dwFieldFlags & (1 << 21))) {
           break;
         }
 
         int iSelecting = (int32_t)array.GetAt(i);
         if (iSelecting < pFormField->CountOptions() &&
             !pFormField->IsItemSelected(iSelecting))
           pFormField->SetItemSelection(iSelecting, TRUE);
       }
       UpdateFormField(pDocument, pFormField, TRUE, TRUE, TRUE);
     }
   }
 }
 
 FX_BOOL Field::defaultStyle(IJS_Context* cc,
                             CJS_PropValue& vp,
                             CFX_WideString& sError) {
-  // MQG sError = JSGetStringFromID(IDS_STRING_NOTSUPPORT);
   return FALSE;
-
-  if (vp.IsSetting()) {
-    if (!m_bCanSet)
-      return FALSE;
-
-    ;
-  } else {
-    ;
-  }
-  return TRUE;
 }
 
 void Field::SetDefaultStyle(CPDFSDK_Document* pDocument,
                             const CFX_WideString& swFieldName,
                             int nControlIndex) {
   // Not supported.
 }
 
 FX_BOOL Field::defaultValue(IJS_Context* cc,
                             CJS_PropValue& vp,
                             CFX_WideString& sError) {
   ASSERT(m_pDocument != NULL);
 
   if (vp.IsSetting()) {
     if (!m_bCanSet)
       return FALSE;
 
     CFX_WideString WideStr;
     vp >> WideStr;
 
     if (m_bDelay) {
       AddDelay_WideString(FP_DEFAULTVALUE, WideStr);
     } else {
       Field::SetDefaultValue(m_pDocument, m_FieldName, m_nFormControlIndex,
                              WideStr);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() == FIELDTYPE_PUSHBUTTON ||
-        pFormField->GetFieldType() == FIELDTYPE_SIGNATURE)
+        pFormField->GetFieldType() == FIELDTYPE_SIGNATURE) {
       return FALSE;
+    }
 
     vp << pFormField->GetDefaultValue();
   }
   return TRUE;
 }
 
 void Field::SetDefaultValue(CPDFSDK_Document* pDocument,
                             const CFX_WideString& swFieldName,
                             int nControlIndex,
                             const CFX_WideString& string) {
@@ skipping 11 matching lines @@
 
     bool bVP;
     vp >> bVP;
 
     if (m_bDelay) {
       AddDelay_Bool(FP_DONOTSCROLL, bVP);
     } else {
       Field::SetDoNotScroll(m_pDocument, m_FieldName, m_nFormControlIndex, bVP);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
       return FALSE;
 
     if (pFormField->GetFieldFlags() & FIELDFLAG_DONOTSCROLL)
       vp << true;
     else
       vp << false;
   }
 
   return TRUE;
@@ skipping 11 matching lines @@
                                CFX_WideString& sError) {
   ASSERT(m_pDocument != NULL);
 
   if (vp.IsSetting()) {
     if (!m_bCanSet)
       return FALSE;
 
     bool bVP;
     vp >> bVP;
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD &&
-        pFormField->GetFieldType() != FIELDTYPE_COMBOBOX)
+        pFormField->GetFieldType() != FIELDTYPE_COMBOBOX) {
       return FALSE;
+    }
 
     if (pFormField->GetFieldFlags() & FIELDFLAG_DONOTSPELLCHECK)
       vp << true;
     else
       vp << false;
   }
 
   return TRUE;
 }
 
@@ skipping 34 matching lines @@
 
     int nVP;
     vp >> nVP;
 
     if (m_bDelay) {
       AddDelay_Int(FP_DISPLAY, nVP);
     } else {
       Field::SetDisplay(m_pDocument, m_FieldName, m_nFormControlIndex, nVP);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
+    ASSERT(pFormField);
     CPDFSDK_InterForm* pInterForm =
         (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
-    ASSERT(pInterForm != NULL);
-
     CPDFSDK_Widget* pWidget =
         pInterForm->GetWidget(GetSmartFieldControl(pFormField));
     if (!pWidget)
       return FALSE;
 
     FX_DWORD dwFlag = pWidget->GetFlags();
 
     if (ANNOTFLAG_INVISIBLE & dwFlag || ANNOTFLAG_HIDDEN & dwFlag) {
       vp << (int32_t)1;
     } else {
@@ skipping 14 matching lines @@
 
 void Field::SetDisplay(CPDFSDK_Document* pDocument,
                        const CFX_WideString& swFieldName,
                        int nControlIndex,
                        int number) {
   ASSERT(pDocument != NULL);
 
   CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)pDocument->GetInterForm();
   ASSERT(pInterForm != NULL);
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(pDocument, swFieldName, FieldArray);
-
-  for (int i = 0, isz = FieldArray.GetSize(); i < isz; i++) {
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
-    ASSERT(pFormField != NULL);
-
+  std::vector<CPDF_FormField*> FieldArray =
+      GetFormFields(pDocument, swFieldName);
+  for (CPDF_FormField* pFormField : FieldArray) {
     if (nControlIndex < 0) {
       FX_BOOL bSet = FALSE;
-      for (int j = 0, jsz = pFormField->CountControls(); j < jsz; j++) {
-        CPDF_FormControl* pFormControl = pFormField->GetControl(j);
+      for (int i = 0, sz = pFormField->CountControls(); i < sz; ++i) {
+        CPDF_FormControl* pFormControl = pFormField->GetControl(i);
         ASSERT(pFormControl != NULL);
 
         if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl)) {
           FX_DWORD dwFlag = pWidget->GetFlags();
           switch (number) {
             case 0:
               dwFlag &= (~ANNOTFLAG_INVISIBLE);
               dwFlag &= (~ANNOTFLAG_HIDDEN);
               dwFlag &= (~ANNOTFLAG_NOVIEW);
               dwFlag |= ANNOTFLAG_PRINT;
@@ skipping 78 matching lines @@
                         CJS_PropValue& vp,
                         CFX_WideString& sError) {
   ASSERT(m_pDocument != NULL);
   if (vp.IsSetting()) {
     if (!m_bCanSet)
       return FALSE;
 
     bool bVP;
     vp >> bVP;
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() != FIELDTYPE_COMBOBOX)
       return FALSE;
 
     if (pFormField->GetFieldFlags() & FIELDFLAG_EDIT)
       vp << true;
     else
       vp << false;
   }
 
   return TRUE;
 }
 
 FX_BOOL Field::exportValues(IJS_Context* cc,
                             CJS_PropValue& vp,
                             CFX_WideString& sError) {
-  CFX_PtrArray FieldArray;
-  GetFormFields(m_FieldName, FieldArray);
-  if (FieldArray.GetSize() <= 0)
+  std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+  if (FieldArray.empty())
     return FALSE;
 
-  CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
+  CPDF_FormField* pFormField = FieldArray[0];
   if (pFormField->GetFieldType() != FIELDTYPE_CHECKBOX &&
-      pFormField->GetFieldType() != FIELDTYPE_RADIOBUTTON)
+      pFormField->GetFieldType() != FIELDTYPE_RADIOBUTTON) {
     return FALSE;
+  }
 
   if (vp.IsSetting()) {
     if (!m_bCanSet)
       return FALSE;
 
     if (!vp.IsArrayObject())
       return FALSE;
   } else {
     CJS_Runtime* pRuntime = CJS_Runtime::FromContext(cc);
     CJS_Array ExportValusArray(pRuntime);
@@ skipping 18 matching lines @@
     vp << ExportValusArray;
   }
   return TRUE;
 }
 
 FX_BOOL Field::fileSelect(IJS_Context* cc,
                           CJS_PropValue& vp,
                           CFX_WideString& sError) {
   ASSERT(m_pDocument != NULL);
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(m_FieldName, FieldArray);
-  if (FieldArray.GetSize() <= 0)
+  std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+  if (FieldArray.empty())
     return FALSE;
 
-  CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
+  CPDF_FormField* pFormField = FieldArray[0];
   if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
     return FALSE;
 
   if (vp.IsSetting()) {
     if (!m_bCanSet)
       return FALSE;
 
     bool bVP;
     vp >> bVP;
   } else {
     if (pFormField->GetFieldFlags() & FIELDFLAG_FILESELECT)
       vp << true;
     else
       vp << false;
   }
   return TRUE;
 }
 
 FX_BOOL Field::fillColor(IJS_Context* cc,
                          CJS_PropValue& vp,
                          CFX_WideString& sError) {
   CJS_Runtime* pRuntime = CJS_Runtime::FromContext(cc);
   CJS_Array crArray(pRuntime);
-  CFX_PtrArray FieldArray;
-  GetFormFields(m_FieldName, FieldArray);
-  if (FieldArray.GetSize() <= 0)
+  std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+  if (FieldArray.empty())
     return FALSE;
 
   if (vp.IsSetting()) {
     if (!m_bCanSet)
       return FALSE;
 
     if (!vp.IsArrayObject())
       return FALSE;
 
     vp >> crArray;
 
     CPWL_Color color;
     color::ConvertArrayToPWLColor(crArray, color);
     if (m_bDelay) {
       AddDelay_Color(FP_FILLCOLOR, color);
     } else {
       Field::SetFillColor(m_pDocument, m_FieldName, m_nFormControlIndex, color);
     }
   } else {
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
+    ASSERT(pFormField);
     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
     if (!pFormControl)
       return FALSE;
 
     int iColorType;
     pFormControl->GetBackgroundColor(iColorType);
 
     CPWL_Color color;
     if (iColorType == COLORTYPE_TRANSPARENT) {
       color = CPWL_Color(COLORTYPE_TRANSPARENT);
     } else if (iColorType == COLORTYPE_GRAY) {
       color = CPWL_Color(COLORTYPE_GRAY,
                          pFormControl->GetOriginalBackgroundColor(0));
     } else if (iColorType == COLORTYPE_RGB) {
       color =
           CPWL_Color(COLORTYPE_RGB, pFormControl->GetOriginalBackgroundColor(0),
                      pFormControl->GetOriginalBackgroundColor(1),
                      pFormControl->GetOriginalBackgroundColor(2));
     } else if (iColorType == COLORTYPE_CMYK) {
       color = CPWL_Color(COLORTYPE_CMYK,
                          pFormControl->GetOriginalBackgroundColor(0),
                          pFormControl->GetOriginalBackgroundColor(1),
                          pFormControl->GetOriginalBackgroundColor(2),
                          pFormControl->GetOriginalBackgroundColor(3));
-    } else
+    } else {
       return FALSE;
+    }
 
     color::ConvertPWLColorToArray(color, crArray);
     vp << crArray;
   }
 
   return TRUE;
 }
 
 void Field::SetFillColor(CPDFSDK_Document* pDocument,
                          const CFX_WideString& swFieldName,
@@ skipping 13 matching lines @@
 
     bool bVP;
     vp >> bVP;
 
     if (m_bDelay) {
       AddDelay_Bool(FP_HIDDEN, bVP);
     } else {
       Field::SetHidden(m_pDocument, m_FieldName, m_nFormControlIndex, bVP);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
+    ASSERT(pFormField);
     CPDFSDK_InterForm* pInterForm =
         (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
-    ASSERT(pInterForm != NULL);
-
     CPDFSDK_Widget* pWidget =
         pInterForm->GetWidget(GetSmartFieldControl(pFormField));
     if (!pWidget)
       return FALSE;
 
     FX_DWORD dwFlags = pWidget->GetFlags();
 
-    if (ANNOTFLAG_INVISIBLE & dwFlags || ANNOTFLAG_HIDDEN & dwFlags) {
+    if (ANNOTFLAG_INVISIBLE & dwFlags || ANNOTFLAG_HIDDEN & dwFlags)
       vp << true;
-    } else
+    else
       vp << false;
   }
 
   return TRUE;
 }
 
 void Field::SetHidden(CPDFSDK_Document* pDocument,
                       const CFX_WideString& swFieldName,
                       int nControlIndex,
                       bool b) {
   ASSERT(pDocument != NULL);
 
   CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)pDocument->GetInterForm();
   ASSERT(pInterForm != NULL);
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(pDocument, swFieldName, FieldArray);
-
-  for (int i = 0, isz = FieldArray.GetSize(); i < isz; i++) {
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
-    ASSERT(pFormField != NULL);
-
+  std::vector<CPDF_FormField*> FieldArray =
+      GetFormFields(pDocument, swFieldName);
+  for (CPDF_FormField* pFormField : FieldArray) {
     if (nControlIndex < 0) {
       FX_BOOL bSet = FALSE;
-      for (int j = 0, jsz = pFormField->CountControls(); j < jsz; j++) {
+      for (int i = 0, sz = pFormField->CountControls(); i < sz; ++i) {
         if (CPDFSDK_Widget* pWidget =
-                pInterForm->GetWidget(pFormField->GetControl(j))) {
+                pInterForm->GetWidget(pFormField->GetControl(i))) {
           FX_DWORD dwFlags = pWidget->GetFlags();
 
           if (b) {
             dwFlags &= (~ANNOTFLAG_INVISIBLE);
             dwFlags &= (~ANNOTFLAG_NOVIEW);
             dwFlags |= (ANNOTFLAG_HIDDEN | ANNOTFLAG_PRINT);
           } else {
             dwFlags &= (~ANNOTFLAG_INVISIBLE);
             dwFlags &= (~ANNOTFLAG_HIDDEN);
             dwFlags &= (~ANNOTFLAG_NOVIEW);
@@ skipping 50 matching lines @@
     CFX_ByteString strMode;
     vp >> strMode;
 
     if (m_bDelay) {
       AddDelay_String(FP_HIGHLIGHT, strMode);
     } else {
       Field::SetHighlight(m_pDocument, m_FieldName, m_nFormControlIndex,
                           strMode);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
       return FALSE;
 
     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
     if (!pFormControl)
       return FALSE;
 
     int eHM = pFormControl->GetHighlightingMode();
     switch (eHM) {
       case CPDF_FormControl::None:
@@ skipping 36 matching lines @@
     int iWidth;
     vp >> iWidth;
 
     if (m_bDelay) {
       AddDelay_Int(FP_LINEWIDTH, iWidth);
     } else {
       Field::SetLineWidth(m_pDocument, m_FieldName, m_nFormControlIndex,
                           iWidth);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
+    ASSERT(pFormField);
     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
     if (!pFormControl)
       return FALSE;
 
     CPDFSDK_InterForm* pInterForm =
         (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
     ASSERT(pInterForm != NULL);
 
     if (!pFormField->CountControls())
       return FALSE;
@@ skipping 10 matching lines @@
 
 void Field::SetLineWidth(CPDFSDK_Document* pDocument,
                          const CFX_WideString& swFieldName,
                          int nControlIndex,
                          int number) {
   ASSERT(pDocument != NULL);
 
   CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)pDocument->GetInterForm();
   ASSERT(pInterForm != NULL);
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(pDocument, swFieldName, FieldArray);
-
-  for (int i = 0, isz = FieldArray.GetSize(); i < isz; i++) {
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
-    ASSERT(pFormField != NULL);
-
+  std::vector<CPDF_FormField*> FieldArray =
+      GetFormFields(pDocument, swFieldName);
+  for (CPDF_FormField* pFormField : FieldArray) {
     if (nControlIndex < 0) {
       FX_BOOL bSet = FALSE;
-      for (int j = 0, jsz = pFormField->CountControls(); j < jsz; j++) {
-        CPDF_FormControl* pFormControl = pFormField->GetControl(j);
+      for (int i = 0, sz = pFormField->CountControls(); i < sz; ++i) {
+        CPDF_FormControl* pFormControl = pFormField->GetControl(i);
         ASSERT(pFormControl != NULL);
 
         if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl)) {
           if (number != pWidget->GetBorderWidth()) {
             pWidget->SetBorderWidth(number);
             bSet = TRUE;
           }
         }
       }
       if (bSet)
@@ skipping 25 matching lines @@
 
     bool bVP;
     vp >> bVP;
 
     if (m_bDelay) {
       AddDelay_Bool(FP_MULTILINE, bVP);
     } else {
       Field::SetMultiline(m_pDocument, m_FieldName, m_nFormControlIndex, bVP);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
       return FALSE;
 
     if (pFormField->GetFieldFlags() & FIELDFLAG_MULTILINE)
       vp << true;
     else
       vp << false;
   }
 
   return TRUE;
@@ skipping 18 matching lines @@
     bool bVP;
     vp >> bVP;
 
     if (m_bDelay) {
       AddDelay_Bool(FP_MULTIPLESELECTION, bVP);
     } else {
       Field::SetMultipleSelection(m_pDocument, m_FieldName, m_nFormControlIndex,
                                   bVP);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() != FIELDTYPE_LISTBOX)
       return FALSE;
 
     if (pFormField->GetFieldFlags() & FIELDFLAG_MULTISELECT)
       vp << true;
     else
       vp << false;
   }
 
   return TRUE;
 }
 
 void Field::SetMultipleSelection(CPDFSDK_Document* pDocument,
                                  const CFX_WideString& swFieldName,
                                  int nControlIndex,
                                  bool b) {
   // Not supported.
 }
 
 FX_BOOL Field::name(IJS_Context* cc,
                     CJS_PropValue& vp,
                     CFX_WideString& sError) {
   if (!vp.IsGetting())
     return FALSE;
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(m_FieldName, FieldArray);
-  if (FieldArray.GetSize() <= 0)
+  std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+  if (FieldArray.empty())
     return FALSE;
 
   vp << m_FieldName;
 
   return TRUE;
 }
 
 FX_BOOL Field::numItems(IJS_Context* cc,
                         CJS_PropValue& vp,
                         CFX_WideString& sError) {
   if (!vp.IsGetting())
     return FALSE;
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(m_FieldName, FieldArray);
-  if (FieldArray.GetSize() <= 0)
+  std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+  if (FieldArray.empty())
     return FALSE;
 
-  CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
+  CPDF_FormField* pFormField = FieldArray[0];
   if (pFormField->GetFieldType() != FIELDTYPE_COMBOBOX &&
-      pFormField->GetFieldType() != FIELDTYPE_LISTBOX)
+      pFormField->GetFieldType() != FIELDTYPE_LISTBOX) {
     return FALSE;
+  }
 
   vp << (int32_t)pFormField->CountOptions();
   return TRUE;
 }
 
 FX_BOOL Field::page(IJS_Context* cc,
                     CJS_PropValue& vp,
                     CFX_WideString& sError) {
   if (!vp.IsGetting())
     return FALSE;
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(m_FieldName, FieldArray);
-  if (FieldArray.GetSize() <= 0)
+  std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+  if (FieldArray.empty())
     return FALSE;
 
-  CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
+  CPDF_FormField* pFormField = FieldArray[0];
   if (!pFormField)
     return FALSE;
 
-  CFX_PtrArray widgetArray;
-  CPDFSDK_InterForm* pInterForm =
-      (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
-  pInterForm->GetWidgets(pFormField, widgetArray);
+  std::vector<CPDFSDK_Widget*> widgets;
+  m_pDocument->GetInterForm()->GetWidgets(pFormField, &widgets);
 
-  if (widgetArray.GetSize() > 0) {
-    CJS_Runtime* pRuntime = CJS_Runtime::FromContext(cc);
-    CJS_Array PageArray(pRuntime);
-    for (int i = 0, sz = widgetArray.GetSize(); i < sz; i++) {
-      CPDFSDK_Widget* pWidget = (CPDFSDK_Widget*)widgetArray.GetAt(i);
-      CPDFSDK_PageView* pPageView = pWidget->GetPageView();
-      if (!pPageView)
-        return FALSE;
-
-      PageArray.SetElement(
-          i, CJS_Value(pRuntime, (int32_t)pPageView->GetPageIndex()));
-    }
-
-    vp << PageArray;
-  } else {
+  if (widgets.empty()) {
     vp << (int32_t)-1;
+    return TRUE;
   }
 
+  CJS_Runtime* pRuntime = CJS_Runtime::FromContext(cc);
+  CJS_Array PageArray(pRuntime);
+  for (size_t i = 0; i < widgets.size(); ++i) {
+    CPDFSDK_PageView* pPageView = widgets[i]->GetPageView();
+    if (!pPageView)
+      return FALSE;
+
+    PageArray.SetElement(
+        i, CJS_Value(pRuntime, (int32_t)pPageView->GetPageIndex()));
+  }
+
+  vp << PageArray;
   return TRUE;
 }
 
 FX_BOOL Field::password(IJS_Context* cc,
                         CJS_PropValue& vp,
                         CFX_WideString& sError) {
   ASSERT(m_pDocument != NULL);
 
   if (vp.IsSetting()) {
     if (!m_bCanSet)
       return FALSE;
 
     bool bVP;
     vp >> bVP;
 
     if (m_bDelay) {
       AddDelay_Bool(FP_PASSWORD, bVP);
     } else {
       Field::SetPassword(m_pDocument, m_FieldName, m_nFormControlIndex, bVP);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
       return FALSE;
 
     if (pFormField->GetFieldFlags() & FIELDFLAG_PASSWORD)
       vp << true;
     else
       vp << false;
   }
 
   return TRUE;
 }
 
 void Field::SetPassword(CPDFSDK_Document* pDocument,
                         const CFX_WideString& swFieldName,
                         int nControlIndex,
                         bool b) {
   // Not supported.
 }
 
 FX_BOOL Field::print(IJS_Context* cc,
                      CJS_PropValue& vp,
                      CFX_WideString& sError) {
   ASSERT(m_pDocument != NULL);
 
   CPDFSDK_InterForm* pInterForm =
       (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
   ASSERT(pInterForm != NULL);
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(m_FieldName, FieldArray);
-  if (FieldArray.GetSize() <= 0)
+  std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+  if (FieldArray.empty())
     return FALSE;
 
   if (vp.IsSetting()) {
     if (!m_bCanSet)
       return FALSE;
 
     bool bVP;
     vp >> bVP;
 
-    for (int i = 0, isz = FieldArray.GetSize(); i < isz; i++) {
-      CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
-      ASSERT(pFormField != NULL);
-
+    for (CPDF_FormField* pFormField : FieldArray) {
       if (m_nFormControlIndex < 0) {
         FX_BOOL bSet = FALSE;
-        for (int j = 0, jsz = pFormField->CountControls(); j < jsz; j++) {
+        for (int i = 0, sz = pFormField->CountControls(); i < sz; ++i) {
           if (CPDFSDK_Widget* pWidget =
-                  pInterForm->GetWidget(pFormField->GetControl(j))) {
+                  pInterForm->GetWidget(pFormField->GetControl(i))) {
             FX_DWORD dwFlags = pWidget->GetFlags();
             if (bVP)
               dwFlags |= ANNOTFLAG_PRINT;
             else
               dwFlags &= ~ANNOTFLAG_PRINT;
 
             if (dwFlags != pWidget->GetFlags()) {
               pWidget->SetFlags(dwFlags);
               bSet = TRUE;
             }
@@ skipping 18 matching lines @@
               pWidget->SetFlags(dwFlags);
               UpdateFormControl(m_pDocument,
                                 pFormField->GetControl(m_nFormControlIndex),
                                 TRUE, FALSE, TRUE);
             }
           }
         }
       }
     }
   } else {
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     CPDFSDK_Widget* pWidget =
         pInterForm->GetWidget(GetSmartFieldControl(pFormField));
     if (!pWidget)
       return FALSE;
 
     if (pWidget->GetFlags() & ANNOTFLAG_PRINT)
       vp << true;
     else
       vp << false;
   }
 
   return TRUE;
 }
 
 FX_BOOL Field::radiosInUnison(IJS_Context* cc,
                               CJS_PropValue& vp,
                               CFX_WideString& sError) {
   ASSERT(m_pDocument != NULL);
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(m_FieldName, FieldArray);
-  if (FieldArray.GetSize() <= 0)
+  std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+  if (FieldArray.empty())
     return FALSE;
 
   if (vp.IsSetting()) {
     if (!m_bCanSet)
       return FALSE;
 
     bool bVP;
     vp >> bVP;
 
   } else {
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() != FIELDTYPE_RADIOBUTTON)
       return FALSE;
 
     if (pFormField->GetFieldFlags() & FIELDFLAG_RADIOSINUNISON)
       vp << true;
     else
       vp << false;
   }
 
   return TRUE;
 }
 
 FX_BOOL Field::readonly(IJS_Context* cc,
                         CJS_PropValue& vp,
                         CFX_WideString& sError) {
   ASSERT(m_pDocument != NULL);
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(m_FieldName, FieldArray);
-  if (FieldArray.GetSize() <= 0)
+  std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+  if (FieldArray.empty())
     return FALSE;
 
   if (vp.IsSetting()) {
     if (!m_bCanSet)
       return FALSE;
 
     bool bVP;
     vp >> bVP;
 
   } else {
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldFlags() & FIELDFLAG_READONLY)
       vp << true;
     else
       vp << false;
   }
 
   return TRUE;
 }
 
 FX_BOOL Field::rect(IJS_Context* cc,
@@ skipping 24 matching lines @@
     pArray[2] = (FX_FLOAT)Lower_Rightx.ToInt();
     pArray[3] = (FX_FLOAT)Upper_Lefty.ToInt();
 
     CPDF_Rect crRect(pArray);
     if (m_bDelay) {
       AddDelay_Rect(FP_RECT, crRect);
     } else {
       Field::SetRect(m_pDocument, m_FieldName, m_nFormControlIndex, crRect);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
+    CPDF_FormField* pFormField = FieldArray[0];
     CPDFSDK_InterForm* pInterForm =
         (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
     CPDFSDK_Widget* pWidget =
         pInterForm->GetWidget(GetSmartFieldControl(pFormField));
     if (!pWidget)
       return FALSE;
 
     CFX_FloatRect crRect = pWidget->GetRect();
     Upper_Leftx = (int32_t)crRect.left;
     Upper_Lefty = (int32_t)crRect.top;
@@ skipping 12 matching lines @@
 
 void Field::SetRect(CPDFSDK_Document* pDocument,
                     const CFX_WideString& swFieldName,
                     int nControlIndex,
                     const CPDF_Rect& rect) {
   ASSERT(pDocument != NULL);
 
   CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)pDocument->GetInterForm();
   ASSERT(pInterForm != NULL);
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(pDocument, swFieldName, FieldArray);
-
-  for (int i = 0, isz = FieldArray.GetSize(); i < isz; i++) {
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
-    ASSERT(pFormField != NULL);
-
+  std::vector<CPDF_FormField*> FieldArray =
+      GetFormFields(pDocument, swFieldName);
+  for (CPDF_FormField* pFormField : FieldArray) {
     if (nControlIndex < 0) {
       FX_BOOL bSet = FALSE;
-      for (int i = 0, sz = pFormField->CountControls(); i < sz; i++) {
+      for (int i = 0, sz = pFormField->CountControls(); i < sz; ++i) {
         CPDF_FormControl* pFormControl = pFormField->GetControl(i);
         ASSERT(pFormControl != NULL);
 
         if (CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl)) {
           CPDF_Rect crRect = rect;
 
           CPDF_Page* pPDFPage = pWidget->GetPDFPage();
-          ASSERT(pPDFPage != NULL);
-
-          //                  CPDF_Page* pPDFPage = pPage->GetPage();
-          //                  ASSERT(pPDFPage != NULL);
-
           crRect.Intersect(pPDFPage->GetPageBBox());
 
           if (!crRect.IsEmpty()) {
             CPDF_Rect rcOld = pWidget->GetRect();
             if (crRect.left != rcOld.left || crRect.right != rcOld.right ||
                 crRect.top != rcOld.top || crRect.bottom != rcOld.bottom) {
               pWidget->SetRect(crRect);
               bSet = TRUE;
             }
           }
@@ skipping 30 matching lines @@
       }
     }
   }
 }
 
 FX_BOOL Field::required(IJS_Context* cc,
                         CJS_PropValue& vp,
                         CFX_WideString& sError) {
   ASSERT(m_pDocument != NULL);
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(m_FieldName, FieldArray);
-  if (FieldArray.GetSize() <= 0)
+  std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+  if (FieldArray.empty())
     return FALSE;
 
   if (vp.IsSetting()) {
     if (!m_bCanSet)
       return FALSE;
 
     bool bVP;
     vp >> bVP;
 
   } else {
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() == FIELDTYPE_PUSHBUTTON)
       return FALSE;
 
     if (pFormField->GetFieldFlags() & FIELDFLAG_REQUIRED)
       vp << true;
     else
       vp << false;
   }
 
   return TRUE;
@@ skipping 10 matching lines @@
 
     bool bVP;
     vp >> bVP;
 
     if (m_bDelay) {
       AddDelay_Bool(FP_RICHTEXT, bVP);
     } else {
       Field::SetRichText(m_pDocument, m_FieldName, m_nFormControlIndex, bVP);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD)
       return FALSE;
 
     if (pFormField->GetFieldFlags() & FIELDFLAG_RICHTEXT)
       vp << true;
     else
       vp << false;
   }
 
   return TRUE;
 }
 
 void Field::SetRichText(CPDFSDK_Document* pDocument,
                         const CFX_WideString& swFieldName,
                         int nControlIndex,
                         bool b) {
   // Not supported.
 }
 
 FX_BOOL Field::richValue(IJS_Context* cc,
                          CJS_PropValue& vp,
                          CFX_WideString& sError) {
   return TRUE;
-  if (vp.IsSetting()) {
-    if (!m_bCanSet)
-      return FALSE;
-    ;
-  } else {
-    ;
-  }
-  return TRUE;
 }
 
 void Field::SetRichValue(CPDFSDK_Document* pDocument,
                          const CFX_WideString& swFieldName,
                          int nControlIndex) {
   // Not supported.
 }
 
 FX_BOOL Field::rotation(IJS_Context* cc,
                         CJS_PropValue& vp,
                         CFX_WideString& sError) {
   ASSERT(m_pDocument != NULL);
 
   if (vp.IsSetting()) {
     if (!m_bCanSet)
       return FALSE;
 
     int nVP;
     vp >> nVP;
 
     if (m_bDelay) {
       AddDelay_Int(FP_ROTATION, nVP);
     } else {
       Field::SetRotation(m_pDocument, m_FieldName, m_nFormControlIndex, nVP);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
     if (!pFormControl)
       return FALSE;
 
     vp << (int32_t)pFormControl->GetRotation();
   }
 
   return TRUE;
 }
 
@@ skipping 22 matching lines @@
     CPWL_Color color;
     color::ConvertArrayToPWLColor(crArray, color);
 
     if (m_bDelay) {
       AddDelay_Color(FP_STROKECOLOR, color);
     } else {
       Field::SetStrokeColor(m_pDocument, m_FieldName, m_nFormControlIndex,
                             color);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
+    CPDF_FormField* pFormField = FieldArray[0];
     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
     if (!pFormControl)
       return FALSE;
 
     int iColorType;
     pFormControl->GetBorderColor(iColorType);
 
     CPWL_Color color;
     if (iColorType == COLORTYPE_TRANSPARENT) {
       color = CPWL_Color(COLORTYPE_TRANSPARENT);
     } else if (iColorType == COLORTYPE_GRAY) {
       color =
           CPWL_Color(COLORTYPE_GRAY, pFormControl->GetOriginalBorderColor(0));
     } else if (iColorType == COLORTYPE_RGB) {
       color = CPWL_Color(COLORTYPE_RGB, pFormControl->GetOriginalBorderColor(0),
                          pFormControl->GetOriginalBorderColor(1),
                          pFormControl->GetOriginalBorderColor(2));
     } else if (iColorType == COLORTYPE_CMYK) {
       color =
           CPWL_Color(COLORTYPE_CMYK, pFormControl->GetOriginalBorderColor(0),
                      pFormControl->GetOriginalBorderColor(1),
                      pFormControl->GetOriginalBorderColor(2),
                      pFormControl->GetOriginalBorderColor(3));
-    } else
+    } else {
       return FALSE;
+    }
 
     color::ConvertPWLColorToArray(color, crArray);
     vp << crArray;
   }
   return TRUE;
 }
 
 void Field::SetStrokeColor(CPDFSDK_Document* pDocument,
                            const CFX_WideString& swFieldName,
                            int nControlIndex,
@@ skipping 13 matching lines @@
     CFX_ByteString csBCaption;
     vp >> csBCaption;
 
     if (m_bDelay) {
       AddDelay_String(FP_STYLE, csBCaption);
     } else {
       Field::SetStyle(m_pDocument, m_FieldName, m_nFormControlIndex,
                       csBCaption);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() != FIELDTYPE_RADIOBUTTON &&
-        pFormField->GetFieldType() != FIELDTYPE_CHECKBOX)
+        pFormField->GetFieldType() != FIELDTYPE_CHECKBOX) {
       return FALSE;
+    }
 
     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
     if (!pFormControl)
       return FALSE;
 
     CFX_WideString csWCaption = pFormControl->GetNormalCaption();
     CFX_ByteString csBCaption;
 
     switch (csWCaption[0]) {
       case L'l':
@@ skipping 51 matching lines @@
 
     CPWL_Color color;
     color::ConvertArrayToPWLColor(crArray, color);
 
     if (m_bDelay) {
       AddDelay_Color(FP_TEXTCOLOR, color);
     } else {
       Field::SetTextColor(m_pDocument, m_FieldName, m_nFormControlIndex, color);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
+    CPDF_FormField* pFormField = FieldArray[0];
     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
     if (!pFormControl)
       return FALSE;
 
     int iColorType;
     FX_ARGB color;
     CPDF_DefaultAppearance FieldAppearance =
         pFormControl->GetDefaultAppearance();
     FieldAppearance.GetColor(color, iColorType);
     int32_t a, r, g, b;
@@ skipping 32 matching lines @@
     if (csFontName.IsEmpty())
       return FALSE;
 
     if (m_bDelay) {
       AddDelay_String(FP_TEXTFONT, csFontName);
     } else {
       Field::SetTextFont(m_pDocument, m_FieldName, m_nFormControlIndex,
                          csFontName);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
+    ASSERT(pFormField);
     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
     if (!pFormControl)
       return FALSE;
 
     int nFieldType = pFormField->GetFieldType();
 
     if (nFieldType == FIELDTYPE_PUSHBUTTON ||
         nFieldType == FIELDTYPE_COMBOBOX || nFieldType == FIELDTYPE_LISTBOX ||
         nFieldType == FIELDTYPE_TEXTFIELD) {
       CPDF_Font* pFont = pFormControl->GetDefaultControlFont();
       if (!pFont)
         return FALSE;
 
       vp << pFont->GetBaseFont();
-    } else
+    } else {
       return FALSE;
+    }
   }
 
   return TRUE;
 }
 
 void Field::SetTextFont(CPDFSDK_Document* pDocument,
                         const CFX_WideString& swFieldName,
                         int nControlIndex,
                         const CFX_ByteString& string) {
   // Not supported.
@@ skipping 10 matching lines @@
 
     int nVP;
     vp >> nVP;
 
     if (m_bDelay) {
       AddDelay_Int(FP_TEXTSIZE, nVP);
     } else {
       Field::SetTextSize(m_pDocument, m_FieldName, m_nFormControlIndex, nVP);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
+    ASSERT(pFormField);
     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
     if (!pFormControl)
       return FALSE;
 
     CPDF_DefaultAppearance FieldAppearance =
         pFormControl->GetDefaultAppearance();
 
     CFX_ByteString csFontNameTag;
     FX_FLOAT fFontSize;
     FieldAppearance.GetFont(csFontNameTag, fFontSize);
@@ skipping 12 matching lines @@
 }
 
 FX_BOOL Field::type(IJS_Context* cc,
                     CJS_PropValue& vp,
                     CFX_WideString& sError) {
   ASSERT(m_pDocument != NULL);
 
   if (!vp.IsGetting())
     return FALSE;
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(m_FieldName, FieldArray);
-  if (FieldArray.GetSize() <= 0)
+  std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+  if (FieldArray.empty())
     return FALSE;
 
-  CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-  ASSERT(pFormField != NULL);
-
+  CPDF_FormField* pFormField = FieldArray[0];
   switch (pFormField->GetFieldType()) {
     case FIELDTYPE_UNKNOWN:
       vp << L"unknown";
       break;
     case FIELDTYPE_PUSHBUTTON:
       vp << L"button";
       break;
     case FIELDTYPE_CHECKBOX:
       vp << L"checkbox";
       break;
@@ skipping 31 matching lines @@
 
     CFX_WideString swName;
     vp >> swName;
 
     if (m_bDelay) {
       AddDelay_WideString(FP_USERNAME, swName);
     } else {
       Field::SetUserName(m_pDocument, m_FieldName, m_nFormControlIndex, swName);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    ASSERT(pFormField != NULL);
-
+    CPDF_FormField* pFormField = FieldArray[0];
     vp << (CFX_WideString)pFormField->GetAlternateName();
   }
 
   return TRUE;
 }
 
 void Field::SetUserName(CPDFSDK_Document* pDocument,
                         const CFX_WideString& swFieldName,
                         int nControlIndex,
                         const CFX_WideString& string) {
@@ skipping 24 matching lines @@
       vp >> swValue;
       strArray.Add(swValue);
     }
 
     if (m_bDelay) {
       AddDelay_WideStringArray(FP_VALUE, strArray);
     } else {
       Field::SetValue(m_pDocument, m_FieldName, m_nFormControlIndex, strArray);
     }
   } else {
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName, FieldArray);
-    if (FieldArray.GetSize() <= 0)
+    std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+    if (FieldArray.empty())
       return FALSE;
 
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
+    CPDF_FormField* pFormField = FieldArray[0];
     switch (pFormField->GetFieldType()) {
       case FIELDTYPE_PUSHBUTTON:
         return FALSE;
       case FIELDTYPE_COMBOBOX:
       case FIELDTYPE_TEXTFIELD: {
         CFX_WideString swValue = pFormField->GetValue();
 
         double dRet;
         FX_BOOL bDot;
         if (CJS_PublicMethods::ConvertStringToNumber(swValue.c_str(), dRet,
                                                      bDot)) {
           if (bDot)
             vp << dRet;
           else
             vp << dRet;
-        } else
+        } else {
           vp << swValue;
+        }
       } break;
       case FIELDTYPE_LISTBOX: {
         if (pFormField->CountSelectedItems() > 1) {
           CJS_Array ValueArray(pRuntime);
           CJS_Value ElementValue(pRuntime);
           int iIndex;
           for (int i = 0, sz = pFormField->CountSelectedItems(); i < sz; i++) {
             iIndex = pFormField->GetSelectedIndex(i);
             ElementValue = pFormField->GetOptionValue(iIndex).c_str();
             if (FXSYS_wcslen(ElementValue.ToCFXWideString().c_str()) == 0)
               ElementValue = pFormField->GetOptionLabel(iIndex).c_str();
             ValueArray.SetElement(i, ElementValue);
           }
           vp << ValueArray;
         } else {
           CFX_WideString swValue = pFormField->GetValue();
 
           double dRet;
           FX_BOOL bDot;
           if (CJS_PublicMethods::ConvertStringToNumber(swValue.c_str(), dRet,
                                                        bDot)) {
             if (bDot)
               vp << dRet;
             else
               vp << dRet;
-          } else
+          } else {
             vp << swValue;
+          }
         }
       } break;
       case FIELDTYPE_CHECKBOX:
       case FIELDTYPE_RADIOBUTTON: {
         FX_BOOL bFind = FALSE;
         for (int i = 0, sz = pFormField->CountControls(); i < sz; i++) {
-          if (pFormField->GetControl(i)->IsChecked()) {
-            CFX_WideString swValue =
-                pFormField->GetControl(i)->GetExportValue();
-            double dRet;
-            FX_BOOL bDot;
-            if (CJS_PublicMethods::ConvertStringToNumber(swValue.c_str(), dRet,
-                                                         bDot)) {
-              if (bDot)
-                vp << dRet;
-              else
-                vp << dRet;
-            } else
-              vp << swValue;
+          if (!pFormField->GetControl(i)->IsChecked())
+            continue;
 
-            bFind = TRUE;
-            break;
-          } else
-            continue;
+          CFX_WideString swValue = pFormField->GetControl(i)->GetExportValue();
+          double dRet;
+          FX_BOOL bDotDummy;
+          if (CJS_PublicMethods::ConvertStringToNumber(swValue.c_str(), dRet,
+                                                       bDotDummy)) {
+            vp << dRet;
+          } else {
+            vp << swValue;
+          }
+
+          bFind = TRUE;
+          break;
         }
         if (!bFind)
           vp << L"Off";
       } break;
       default:
         vp << pFormField->GetValue();
         break;
     }
   }
 
   return TRUE;
 }
 
 void Field::SetValue(CPDFSDK_Document* pDocument,
                      const CFX_WideString& swFieldName,
                      int nControlIndex,
                      const CJS_WideStringArray& strArray) {
   ASSERT(pDocument != NULL);
 
   if (strArray.GetSize() < 1)
     return;
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(pDocument, swFieldName, FieldArray);
+  std::vector<CPDF_FormField*> FieldArray =
+      GetFormFields(pDocument, swFieldName);
 
-  for (int i = 0, isz = FieldArray.GetSize(); i < isz; i++) {
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
-    ASSERT(pFormField != NULL);
-
+  for (CPDF_FormField* pFormField : FieldArray) {
     if (pFormField->GetFullName().Compare(swFieldName) != 0)
       continue;
 
     switch (pFormField->GetFieldType()) {
       case FIELDTYPE_TEXTFIELD:
       case FIELDTYPE_COMBOBOX:
         if (pFormField->GetValue() != strArray.GetAt(0)) {
           CFX_WideString WideString = strArray.GetAt(0);
           pFormField->SetValue(strArray.GetAt(0), TRUE);
           UpdateFormField(pDocument, pFormField, TRUE, FALSE, TRUE);
@@ skipping 35 matching lines @@
 }
 
 FX_BOOL Field::valueAsString(IJS_Context* cc,
                              CJS_PropValue& vp,
                              CFX_WideString& sError) {
   ASSERT(m_pDocument != NULL);
 
   if (!vp.IsGetting())
     return FALSE;
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(m_FieldName, FieldArray);
-  if (FieldArray.GetSize() <= 0)
+  std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+  if (FieldArray.empty())
     return FALSE;
 
-  CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-  ASSERT(pFormField != NULL);
-
+  CPDF_FormField* pFormField = FieldArray[0];
   if (pFormField->GetFieldType() == FIELDTYPE_PUSHBUTTON)
     return FALSE;
 
   if (pFormField->GetFieldType() == FIELDTYPE_CHECKBOX) {
     if (!pFormField->CountControls())
       return FALSE;
 
     if (pFormField->GetControl(0)->IsChecked())
       vp << L"Yes";
     else
       vp << L"Off";
   } else if (pFormField->GetFieldType() == FIELDTYPE_RADIOBUTTON &&
              !(pFormField->GetFieldFlags() & FIELDFLAG_RADIOSINUNISON)) {
     for (int i = 0, sz = pFormField->CountControls(); i < sz; i++) {
       if (pFormField->GetControl(i)->IsChecked()) {
         vp << pFormField->GetControl(i)->GetExportValue().c_str();
         break;
-      } else
+      } else {
         vp << L"Off";
+      }
     }
   } else if (pFormField->GetFieldType() == FIELDTYPE_LISTBOX &&
              (pFormField->CountSelectedItems() > 1)) {
     vp << L"";
-  } else
+  } else {
     vp << pFormField->GetValue().c_str();
+  }
 
   return TRUE;
 }
 
 /* --------------------------------- methods ---------------------------------
  */
 
 FX_BOOL Field::browseForFileToSubmit(IJS_Context* cc,
                                      const CJS_Parameters& params,
                                      CJS_Value& vRet,
                                      CFX_WideString& sError) {
   ASSERT(m_pDocument != NULL);
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(m_FieldName, FieldArray);
-  if (FieldArray.GetSize() <= 0)
+  std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+  if (FieldArray.empty())
     return FALSE;
 
-  CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-  ASSERT(pFormField != NULL);
-
+  CPDF_FormField* pFormField = FieldArray[0];
   CPDFDoc_Environment* pApp = m_pDocument->GetEnv();
-  ASSERT(pApp != NULL);
-
   if ((pFormField->GetFieldFlags() & FIELDFLAG_FILESELECT) &&
       (pFormField->GetFieldType() == FIELDTYPE_TEXTFIELD)) {
     CFX_WideString wsFileName = pApp->JS_fieldBrowse();
     if (!wsFileName.IsEmpty()) {
       pFormField->SetValue(wsFileName);
       UpdateFormField(m_pDocument, pFormField, TRUE, TRUE, TRUE);
     }
-  } else
-    return FALSE;
-
-  return TRUE;
+    return TRUE;
+  }
+  return FALSE;
 }
 
 FX_BOOL Field::buttonGetCaption(IJS_Context* cc,
                                 const CJS_Parameters& params,
                                 CJS_Value& vRet,
                                 CFX_WideString& sError) {
   ASSERT(m_pDocument != NULL);
 
   int nface = 0;
   int iSize = params.size();
   if (iSize >= 1)
     nface = params[0].ToInt();
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(m_FieldName, FieldArray);
-  if (FieldArray.GetSize() <= 0)
+  std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+  if (FieldArray.empty())
     return FALSE;
 
-  CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-  ASSERT(pFormField != NULL);
-
+  CPDF_FormField* pFormField = FieldArray[0];
   if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
     return FALSE;
 
   CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
   if (!pFormControl)
     return FALSE;
 
   if (nface == 0)
     vRet = pFormControl->GetNormalCaption().c_str();
   else if (nface == 1)
     vRet = pFormControl->GetDownCaption().c_str();
   else if (nface == 2)
     vRet = pFormControl->GetRolloverCaption().c_str();
   else
     return FALSE;
 
   return TRUE;
 }
 
-//#pragma warning(disable: 4800)
-
 FX_BOOL Field::buttonGetIcon(IJS_Context* cc,
                              const CJS_Parameters& params,
                              CJS_Value& vRet,
                              CFX_WideString& sError) {
   ASSERT(m_pDocument != NULL);
 
   int nface = 0;
   int iSize = params.size();
   if (iSize >= 1)
     nface = params[0].ToInt();
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(m_FieldName, FieldArray);
-  if (FieldArray.GetSize() <= 0)
+  std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+  if (FieldArray.empty())
     return FALSE;
 
-  CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
+  CPDF_FormField* pFormField = FieldArray[0];
   if (pFormField->GetFieldType() != FIELDTYPE_PUSHBUTTON)
     return FALSE;
 
   CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
   if (!pFormControl)
     return FALSE;
 
   CJS_Context* pContext = (CJS_Context*)cc;
   CJS_Runtime* pRuntime = pContext->GetJSRuntime();
   v8::Local<v8::Object> pObj = FXJS_NewFxDynamicObj(
@@ skipping 16 matching lines @@
   pIcon->SetStream(pIconStream);
   vRet = pJS_Icon;
 
   return TRUE;
 }
 
 FX_BOOL Field::buttonImportIcon(IJS_Context* cc,
                                 const CJS_Parameters& params,
                                 CJS_Value& vRet,
                                 CFX_WideString& sError) {
-#if 0
-    ASSERT(m_pDocument != NULL);
-
-    CFX_PtrArray FieldArray;
-    GetFormFields(m_FieldName,FieldArray);
-    if (FieldArray.GetSize() <= 0) return FALSE;
-
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-    if (!pFormField)return FALSE;
-
-    CPDFDoc_Environment* pEnv = m_pDocument->GetEnv();
-    ASSERT(pEnv);
-
-    CFX_WideString sIconFileName = pEnv->JS_fieldBrowse();
-    if (sIconFileName.IsEmpty())
-    {
-        vRet = 1;
-        return TRUE;
-    }
-
-    CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
-    ASSERT(pInterForm != NULL);
-
-    CPDF_Stream* pStream = pInterForm->LoadImageFromFile(sIconFileName);
-    if (!pStream)
-    {
-        vRet = -1;
-        return TRUE;
-    }
-
-    CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
-    if (!pFormControl)return FALSE;
-
-    pFormControl->SetNormalIcon(pStream);
-    UpdateFormControl(m_pDocument, pFormControl, TRUE, TRUE, TRUE);
-
-    vRet = 0;
-#endif  // 0
   return TRUE;
 }
 
 FX_BOOL Field::buttonSetCaption(IJS_Context* cc,
                                 const CJS_Parameters& params,
                                 CJS_Value& vRet,
                                 CFX_WideString& sError) {
   return FALSE;
 }
 
@@ skipping 16 matching lines @@
   int iSize = params.size();
   if (iSize < 1)
     return FALSE;
 
   int nWidget = params[0].ToInt();
 
   FX_BOOL bCheckit = TRUE;
   if (iSize >= 2)
     bCheckit = params[1].ToBool();
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(m_FieldName, FieldArray);
-  if (FieldArray.GetSize() <= 0)
+  std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+  if (FieldArray.empty())
     return FALSE;
 
-  CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-  ASSERT(pFormField != NULL);
-
+  CPDF_FormField* pFormField = FieldArray[0];
   if (pFormField->GetFieldType() != FIELDTYPE_CHECKBOX &&
       pFormField->GetFieldType() != FIELDTYPE_RADIOBUTTON)
     return FALSE;
   if (nWidget < 0 || nWidget >= pFormField->CountControls())
     return FALSE;
   if (pFormField->GetFieldType() == FIELDTYPE_RADIOBUTTON)
     pFormField->CheckControl(nWidget, bCheckit, TRUE);
   else
     pFormField->CheckControl(nWidget, bCheckit, TRUE);
 
@@ skipping 16 matching lines @@
 
   if (!m_bCanSet)
     return FALSE;
 
   int iSize = params.size();
   if (iSize < 1)
     return FALSE;
 
   int nWidget = params[0].ToInt();
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(m_FieldName, FieldArray);
-  if (FieldArray.GetSize() <= 0)
+  std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+  if (FieldArray.empty())
     return FALSE;
 
-  CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-  ASSERT(pFormField != NULL);
-
+  CPDF_FormField* pFormField = FieldArray[0];
   if (nWidget < 0 || nWidget >= pFormField->CountControls()) {
     vRet = FALSE;
     return FALSE;
   }
-  if ((pFormField->GetFieldType() == FIELDTYPE_CHECKBOX) ||
-      (pFormField->GetFieldType() == FIELDTYPE_RADIOBUTTON)) {
-    vRet = TRUE;
-  } else
-    vRet = FALSE;
+  vRet = pFormField->GetFieldType() == FIELDTYPE_CHECKBOX ||
+         pFormField->GetFieldType() == FIELDTYPE_RADIOBUTTON;
 
   return TRUE;
 }
 
 FX_BOOL Field::deleteItemAt(IJS_Context* cc,
                             const CJS_Parameters& params,
                             CJS_Value& vRet,
                             CFX_WideString& sError) {
   return TRUE;
 }
 
 int JS_COMPARESTRING(CFX_WideString* ps1, CFX_WideString* ps2) {
   ASSERT(ps1 != NULL);
   ASSERT(ps2 != NULL);
 
   return ps1->Compare(*ps2);
 }
 
 FX_BOOL Field::getArray(IJS_Context* cc,
                         const CJS_Parameters& params,
                         CJS_Value& vRet,
                         CFX_WideString& sError) {
   ASSERT(m_pDocument != NULL);
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(m_FieldName, FieldArray);
-  if (FieldArray.GetSize() <= 0)
+  std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+  if (FieldArray.empty())
     return FALSE;
 
   CGW_ArrayTemplate<CFX_WideString*> swSort;
 
-  for (int i = 0, sz = FieldArray.GetSize(); i < sz; i++) {
-    CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(i);
-    ASSERT(pFormField != NULL);
-
+  for (CPDF_FormField* pFormField : FieldArray)
     swSort.Add(new CFX_WideString(pFormField->GetFullName()));
-  }
   swSort.Sort(JS_COMPARESTRING);
 
   CJS_Context* pContext = (CJS_Context*)cc;
-  ASSERT(pContext != NULL);
   CJS_Runtime* pRuntime = pContext->GetJSRuntime();
-  ASSERT(pRuntime != NULL);
+  ASSERT(pRuntime);
 
   CJS_Array FormFieldArray(pRuntime);
   for (int j = 0, jsz = swSort.GetSize(); j < jsz; j++) {
     nonstd::unique_ptr<CFX_WideString> pStr(swSort.GetAt(j));
     v8::Local<v8::Object> pObj = FXJS_NewFxDynamicObj(
         pRuntime->GetIsolate(), pRuntime, CJS_Field::g_nObjDefnID);
     ASSERT(!pObj.IsEmpty());
 
     CJS_Field* pJSField =
         (CJS_Field*)FXJS_GetPrivate(pRuntime->GetIsolate(), pObj);
@@ skipping 18 matching lines @@
   int iSize = params.size();
 
   int nIdx = -1;
   if (iSize >= 1)
     nIdx = params[0].ToInt();
 
   FX_BOOL bExport = TRUE;
   if (iSize >= 2)
     bExport = params[1].ToBool();
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(m_FieldName, FieldArray);
-  if (FieldArray.GetSize() <= 0)
+  std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+  if (FieldArray.empty())
     return FALSE;
 
-  CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-  ASSERT(pFormField != NULL);
-
+  CPDF_FormField* pFormField = FieldArray[0];
   if ((pFormField->GetFieldType() == FIELDTYPE_LISTBOX) ||
       (pFormField->GetFieldType() == FIELDTYPE_COMBOBOX)) {
     if (nIdx == -1 || nIdx > pFormField->CountOptions())
       nIdx = pFormField->CountOptions() - 1;
     if (bExport) {
       CFX_WideString strval = pFormField->GetOptionValue(nIdx);
       if (strval.IsEmpty())
         vRet = pFormField->GetOptionLabel(nIdx).c_str();
       else
         vRet = strval.c_str();
-    } else
+    } else {
       vRet = pFormField->GetOptionLabel(nIdx).c_str();
-  } else
+    }
+  } else {
     return FALSE;
+  }
 
   return TRUE;
 }
 
 FX_BOOL Field::getLock(IJS_Context* cc,
                        const CJS_Parameters& params,
                        CJS_Value& vRet,
                        CFX_WideString& sError) {
   return FALSE;
 }
 
 FX_BOOL Field::insertItemAt(IJS_Context* cc,
                             const CJS_Parameters& params,
                             CJS_Value& vRet,
                             CFX_WideString& sError) {
   return TRUE;
 }
 
 FX_BOOL Field::isBoxChecked(IJS_Context* cc,
                             const CJS_Parameters& params,
                             CJS_Value& vRet,
                             CFX_WideString& sError) {
   ASSERT(m_pDocument != NULL);
 
   int nIndex = -1;
   if (params.size() >= 1)
     nIndex = params[0].ToInt();
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(m_FieldName, FieldArray);
-  if (FieldArray.GetSize() <= 0)
+  std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+  if (FieldArray.empty())
     return FALSE;
 
-  CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-  ASSERT(pFormField != NULL);
-
+  CPDF_FormField* pFormField = FieldArray[0];
   if (nIndex < 0 || nIndex >= pFormField->CountControls()) {
     vRet = FALSE;
     return FALSE;
   }
 
   if ((pFormField->GetFieldType() == FIELDTYPE_CHECKBOX) ||
       (pFormField->GetFieldType() == FIELDTYPE_RADIOBUTTON)) {
     if (pFormField->GetControl(nIndex)->IsChecked() != 0)
       vRet = TRUE;
     else
       vRet = FALSE;
-  } else
+  } else {
     vRet = FALSE;
+  }
 
   return TRUE;
 }
 
 FX_BOOL Field::isDefaultChecked(IJS_Context* cc,
                                 const CJS_Parameters& params,
                                 CJS_Value& vRet,
                                 CFX_WideString& sError) {
   ASSERT(m_pDocument != NULL);
 
   int nIndex = -1;
   if (params.size() >= 1)
     nIndex = params[0].ToInt();
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(m_FieldName, FieldArray);
-  if (FieldArray.GetSize() <= 0)
+  std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+  if (FieldArray.empty())
     return FALSE;
 
-  CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-  ASSERT(pFormField != NULL);
-
+  CPDF_FormField* pFormField = FieldArray[0];
   if (nIndex < 0 || nIndex >= pFormField->CountControls()) {
     vRet = FALSE;
     return FALSE;
   }
   if ((pFormField->GetFieldType() == FIELDTYPE_CHECKBOX) ||
       (pFormField->GetFieldType() == FIELDTYPE_RADIOBUTTON)) {
     if (pFormField->GetControl(nIndex)->IsDefaultChecked() != 0)
       vRet = TRUE;
     else
       vRet = FALSE;
-  } else
+  } else {
     vRet = FALSE;
+  }
 
   return TRUE;
 }
 
 FX_BOOL Field::setAction(IJS_Context* cc,
                          const CJS_Parameters& params,
                          CJS_Value& vRet,
                          CFX_WideString& sError) {
   return TRUE;
 }
 
 FX_BOOL Field::setFocus(IJS_Context* cc,
                         const CJS_Parameters& params,
                         CJS_Value& vRet,
                         CFX_WideString& sError) {
   ASSERT(m_pDocument != NULL);
 
-  CFX_PtrArray FieldArray;
-  GetFormFields(m_FieldName, FieldArray);
-  if (FieldArray.GetSize() <= 0)
+  std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
+  if (FieldArray.empty())
     return FALSE;
 
-  CPDF_FormField* pFormField = (CPDF_FormField*)FieldArray.ElementAt(0);
-  ASSERT(pFormField != NULL);
-
+  CPDF_FormField* pFormField = FieldArray[0];
   int32_t nCount = pFormField->CountControls();
-
   if (nCount < 1)
     return FALSE;
 
   CPDFSDK_InterForm* pInterForm =
       (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
   ASSERT(pInterForm != NULL);
 
   CPDFSDK_Widget* pWidget = NULL;
   if (nCount == 1) {
     pWidget = pInterForm->GetWidget(pFormField->GetControl(0));
@@ skipping 341 matching lines @@
 #define JS_FIELD_MINWIDTH 1
 #define JS_FIELD_MINHEIGHT 1
 
 void Field::AddField(CPDFSDK_Document* pDocument,
                      int nPageIndex,
                      int nFieldType,
                      const CFX_WideString& sName,
                      const CPDF_Rect& rcCoords) {
   // Not supported.
 }