Start proxying CPDFSDK_Document methods through CPDFSDK_FormFillEnvironment

fpdfsdk/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 "fpdfsdk/javascript/Field.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 199 matching lines @@
 }
 
 FX_BOOL Field::AttachField(Document* pDocument,
                            const CFX_WideString& csFieldName) {
   m_pJSDoc = pDocument;
   m_pDocument.Reset(pDocument->GetReaderDoc());
   m_bCanSet = m_pDocument->GetPermissions(FPDFPERM_FILL_FORM) ||
               m_pDocument->GetPermissions(FPDFPERM_ANNOT_FORM) ||
               m_pDocument->GetPermissions(FPDFPERM_MODIFY);
 
-  CPDFSDK_InterForm* pRDInterForm = m_pDocument->GetInterForm();
+  CPDFSDK_InterForm* pRDInterForm = m_pDocument->GetEnv()->GetInterForm();
   CPDF_InterForm* pInterForm = pRDInterForm->GetInterForm();
   CFX_WideString swFieldNameTemp = csFieldName;
   swFieldNameTemp.Replace(L"..", L".");
 
   if (pInterForm->CountFields(swFieldNameTemp) <= 0) {
     std::wstring strFieldName;
     int iControlNo = -1;
     ParseFieldName(swFieldNameTemp.c_str(), strFieldName, iControlNo);
     if (iControlNo == -1)
       return FALSE;
 
     m_FieldName = strFieldName.c_str();
     m_nFormControlIndex = iControlNo;
     return TRUE;
   }
 
   m_FieldName = swFieldNameTemp;
   m_nFormControlIndex = -1;
 
   return TRUE;
 }
 
 std::vector<CPDF_FormField*> Field::GetFormFields(
     CPDFSDK_Document* pDocument,
     const CFX_WideString& csFieldName) {
   std::vector<CPDF_FormField*> fields;
-  CPDFSDK_InterForm* pReaderInterForm = pDocument->GetInterForm();
+  CPDFSDK_InterForm* pReaderInterForm = pDocument->GetEnv()->GetInterForm();
   CPDF_InterForm* pInterForm = pReaderInterForm->GetInterForm();
   for (int i = 0, sz = pInterForm->CountFields(csFieldName); i < sz; ++i) {
     if (CPDF_FormField* pFormField = pInterForm->GetField(i, csFieldName))
       fields.push_back(pFormField);
   }
   return fields;
 }
 
 std::vector<CPDF_FormField*> Field::GetFormFields(
     const CFX_WideString& csFieldName) const {
   return Field::GetFormFields(m_pDocument.Get(), csFieldName);
 }
 
 void Field::UpdateFormField(CPDFSDK_Document* pDocument,
                             CPDF_FormField* pFormField,
                             FX_BOOL bChangeMark,
                             FX_BOOL bResetAP,
                             FX_BOOL bRefresh) {
-  CPDFSDK_InterForm* pInterForm = pDocument->GetInterForm();
+  CPDFSDK_InterForm* pInterForm = pDocument->GetEnv()->GetInterForm();
 
   if (bResetAP) {
     std::vector<CPDFSDK_Widget*> widgets;
     pInterForm->GetWidgets(pFormField, &widgets);
 
     int nFieldType = pFormField->GetFieldType();
     if (nFieldType == FIELDTYPE_COMBOBOX || nFieldType == FIELDTYPE_TEXTFIELD) {
       for (CPDFSDK_Annot* pAnnot : widgets) {
         FX_BOOL bFormatted = FALSE;
         CPDFSDK_Annot::ObservedPtr pObserved(pAnnot);
@@ skipping 12 matching lines @@
   }
 
   if (bRefresh) {
     // Refresh the widget list. The calls in |bResetAP| may have caused widgets
     // to be removed from the list. We need to call |GetWidgets| again to be
     // sure none of the widgets have been deleted.
     std::vector<CPDFSDK_Widget*> widgets;
     pInterForm->GetWidgets(pFormField, &widgets);
 
     for (CPDFSDK_Widget* pWidget : widgets) {
-      CPDFSDK_Document* pDoc = pWidget->GetInterForm()->GetDocument();
+      CPDFSDK_Document* pDoc =
+          pWidget->GetInterForm()->GetFormFillEnv()->GetSDKDocument();
       pDoc->UpdateAllViews(nullptr, pWidget);
     }
   }
 
   if (bChangeMark)
     pDocument->SetChangeMark();
 }
 
 void Field::UpdateFormControl(CPDFSDK_Document* pDocument,
                               CPDF_FormControl* pFormControl,
                               FX_BOOL bChangeMark,
                               FX_BOOL bResetAP,
                               FX_BOOL bRefresh) {
   ASSERT(pFormControl);
 
-  CPDFSDK_InterForm* pForm = pDocument->GetInterForm();
+  CPDFSDK_InterForm* pForm = pDocument->GetEnv()->GetInterForm();
   CPDFSDK_Widget* pWidget = pForm->GetWidget(pFormControl, false);
 
   if (pWidget) {
     if (bResetAP) {
       int nFieldType = pWidget->GetFieldType();
       if (nFieldType == FIELDTYPE_COMBOBOX ||
           nFieldType == FIELDTYPE_TEXTFIELD) {
         FX_BOOL bFormatted = FALSE;
         CFX_WideString sValue = pWidget->OnFormat(bFormatted);
         pWidget->ResetAppearance(bFormatted ? &sValue : nullptr, FALSE);
       } else {
         pWidget->ResetAppearance(nullptr, FALSE);
       }
     }
 
     if (bRefresh) {
       CPDFSDK_InterForm* pInterForm = pWidget->GetInterForm();
-      CPDFSDK_Document* pDoc = pInterForm->GetDocument();
+      CPDFSDK_Document* pDoc = pInterForm->GetFormFillEnv()->GetSDKDocument();
       pDoc->UpdateAllViews(nullptr, pWidget);
     }
   }
 
   if (bChangeMark)
     pDocument->SetChangeMark();
 }
 
 CPDFSDK_Widget* Field::GetWidget(CPDFSDK_Document* pDocument,
                                  CPDF_FormControl* pFormControl,
                                  bool createIfNeeded) {
   CPDFSDK_InterForm* pInterForm =
-      static_cast<CPDFSDK_InterForm*>(pDocument->GetInterForm());
+      static_cast<CPDFSDK_InterForm*>(pDocument->GetEnv()->GetInterForm());
   return pInterForm ? pInterForm->GetWidget(pFormControl, createIfNeeded)
                     : nullptr;
 }
 
 FX_BOOL Field::ValueIsOccur(CPDF_FormField* pFormField,
                             CFX_WideString csOptLabel) {
   for (int i = 0, sz = pFormField->CountOptions(); i < sz; i++) {
     if (csOptLabel.Compare(pFormField->GetOptionLabel(i)) == 0)
       return TRUE;
   }
@@ skipping 492 matching lines @@
     std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
     if (FieldArray.empty())
       return FALSE;
 
     CPDF_FormField* pFormField = FieldArray[0];
     if (pFormField->GetFieldType() != FIELDTYPE_COMBOBOX &&
         pFormField->GetFieldType() != FIELDTYPE_TEXTFIELD) {
       return FALSE;
     }
 
-    CPDFSDK_InterForm* pRDInterForm = m_pDocument->GetInterForm();
+    CPDFSDK_InterForm* pRDInterForm = m_pDocument->GetEnv()->GetInterForm();
     CPDF_InterForm* pInterForm = pRDInterForm->GetInterForm();
     vp << (int32_t)pInterForm->FindFieldInCalculationOrder(pFormField);
   }
 
   return TRUE;
 }
 
 void Field::SetCalcOrderIndex(CPDFSDK_Document* pDocument,
                               const CFX_WideString& swFieldName,
                               int nControlIndex,
@@ skipping 382 matching lines @@
       Field::SetDisplay(m_pDocument.Get(), m_FieldName, m_nFormControlIndex,
                         nVP);
     }
   } else {
     std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
     if (FieldArray.empty())
       return FALSE;
 
     CPDF_FormField* pFormField = FieldArray[0];
     ASSERT(pFormField);
-    CPDFSDK_InterForm* pInterForm = m_pDocument->GetInterForm();
+    CPDFSDK_InterForm* pInterForm = m_pDocument->GetEnv()->GetInterForm();
     CPDFSDK_Widget* pWidget =
         pInterForm->GetWidget(GetSmartFieldControl(pFormField), true);
     if (!pWidget)
       return FALSE;
 
     uint32_t dwFlag = pWidget->GetFlags();
 
     if (ANNOTFLAG_INVISIBLE & dwFlag || ANNOTFLAG_HIDDEN & dwFlag) {
       vp << (int32_t)1;
     } else {
       if (ANNOTFLAG_PRINT & dwFlag) {
         if (ANNOTFLAG_NOVIEW & dwFlag) {
           vp << (int32_t)3;
         } else {
           vp << (int32_t)0;
         }
       } else {
         vp << (int32_t)2;
       }
     }
   }
 
   return TRUE;
 }
 
 void Field::SetDisplay(CPDFSDK_Document* pDocument,
                        const CFX_WideString& swFieldName,
                        int nControlIndex,
                        int number) {
-  CPDFSDK_InterForm* pInterForm = pDocument->GetInterForm();
+  CPDFSDK_InterForm* pInterForm = pDocument->GetEnv()->GetInterForm();
   std::vector<CPDF_FormField*> FieldArray =
       GetFormFields(pDocument, swFieldName);
   for (CPDF_FormField* pFormField : FieldArray) {
     if (nControlIndex < 0) {
       bool bAnySet = false;
       for (int i = 0, sz = pFormField->CountControls(); i < sz; ++i) {
         CPDF_FormControl* pFormControl = pFormField->GetControl(i);
         ASSERT(pFormControl);
 
         CPDFSDK_Widget* pWidget = pInterForm->GetWidget(pFormControl, true);
@@ skipping 213 matching lines @@
       Field::SetHidden(m_pDocument.Get(), m_FieldName, m_nFormControlIndex,
                        bVP);
     }
   } else {
     std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
     if (FieldArray.empty())
       return FALSE;
 
     CPDF_FormField* pFormField = FieldArray[0];
     ASSERT(pFormField);
-    CPDFSDK_InterForm* pInterForm = m_pDocument->GetInterForm();
+    CPDFSDK_InterForm* pInterForm = m_pDocument->GetEnv()->GetInterForm();
     CPDFSDK_Widget* pWidget =
         pInterForm->GetWidget(GetSmartFieldControl(pFormField), false);
     if (!pWidget)
       return FALSE;
 
     uint32_t dwFlags = pWidget->GetFlags();
 
     if (ANNOTFLAG_INVISIBLE & dwFlags || ANNOTFLAG_HIDDEN & dwFlags)
       vp << true;
     else
@@ skipping 92 matching lines @@
     std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
     if (FieldArray.empty())
       return FALSE;
 
     CPDF_FormField* pFormField = FieldArray[0];
     ASSERT(pFormField);
     CPDF_FormControl* pFormControl = GetSmartFieldControl(pFormField);
     if (!pFormControl)
       return FALSE;
 
-    CPDFSDK_InterForm* pInterForm = m_pDocument->GetInterForm();
+    CPDFSDK_InterForm* pInterForm = m_pDocument->GetEnv()->GetInterForm();
     if (!pFormField->CountControls())
       return FALSE;
 
     CPDFSDK_Widget* pWidget =
         pInterForm->GetWidget(pFormField->GetControl(0), false);
     if (!pWidget)
       return FALSE;
 
     vp << (int32_t)pWidget->GetBorderWidth();
   }
 
   return TRUE;
 }
 
 void Field::SetLineWidth(CPDFSDK_Document* pDocument,
                          const CFX_WideString& swFieldName,
                          int nControlIndex,
                          int number) {
-  CPDFSDK_InterForm* pInterForm = pDocument->GetInterForm();
+  CPDFSDK_InterForm* pInterForm = pDocument->GetEnv()->GetInterForm();
   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) {
         CPDF_FormControl* pFormControl = pFormField->GetControl(i);
         ASSERT(pFormControl);
 
         if (CPDFSDK_Widget* pWidget =
@@ skipping 152 matching lines @@
 
   std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
   if (FieldArray.empty())
     return FALSE;
 
   CPDF_FormField* pFormField = FieldArray[0];
   if (!pFormField)
     return FALSE;
 
   std::vector<CPDFSDK_Widget*> widgets;
-  m_pDocument->GetInterForm()->GetWidgets(pFormField, &widgets);
+  m_pDocument->GetEnv()->GetInterForm()->GetWidgets(pFormField, &widgets);
 
   if (widgets.empty()) {
     vp << (int32_t)-1;
     return TRUE;
   }
 
   CJS_Runtime* pRuntime = CJS_Runtime::FromContext(cc);
   CJS_Array PageArray;
   for (size_t i = 0; i < widgets.size(); ++i) {
     CPDFSDK_PageView* pPageView = widgets[i]->GetPageView();
@@ skipping 47 matching lines @@
 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) {
-  CPDFSDK_InterForm* pInterForm = m_pDocument->GetInterForm();
+  CPDFSDK_InterForm* pInterForm = m_pDocument->GetEnv()->GetInterForm();
   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;
@@ skipping 145 matching lines @@
     } else {
       Field::SetRect(m_pDocument.Get(), m_FieldName, m_nFormControlIndex,
                      crRect);
     }
   } else {
     std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
     if (FieldArray.empty())
       return FALSE;
 
     CPDF_FormField* pFormField = FieldArray[0];
-    CPDFSDK_InterForm* pInterForm = m_pDocument->GetInterForm();
+    CPDFSDK_InterForm* pInterForm = m_pDocument->GetEnv()->GetInterForm();
     CPDFSDK_Widget* pWidget =
         pInterForm->GetWidget(GetSmartFieldControl(pFormField), true);
     if (!pWidget)
       return FALSE;
 
     CFX_FloatRect crRect = pWidget->GetRect();
     Upper_Leftx = CJS_Value(pRuntime, static_cast<int32_t>(crRect.left));
     Upper_Lefty = CJS_Value(pRuntime, static_cast<int32_t>(crRect.top));
     Lower_Rightx = CJS_Value(pRuntime, static_cast<int32_t>(crRect.right));
     Lower_Righty = CJS_Value(pRuntime, static_cast<int32_t>(crRect.bottom));
 
     CJS_Array rcArray;
     rcArray.SetElement(pRuntime, 0, Upper_Leftx);
     rcArray.SetElement(pRuntime, 1, Upper_Lefty);
     rcArray.SetElement(pRuntime, 2, Lower_Rightx);
     rcArray.SetElement(pRuntime, 3, Lower_Righty);
     vp << rcArray;
   }
   return TRUE;
 }
 
 void Field::SetRect(CPDFSDK_Document* pDocument,
                     const CFX_WideString& swFieldName,
                     int nControlIndex,
                     const CFX_FloatRect& rect) {
-  CPDFSDK_InterForm* pInterForm = pDocument->GetInterForm();
+  CPDFSDK_InterForm* pInterForm = pDocument->GetEnv()->GetInterForm();
   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) {
         CPDF_FormControl* pFormControl = pFormField->GetControl(i);
         ASSERT(pFormControl);
 
         if (CPDFSDK_Widget* pWidget =
@@ skipping 1088 matching lines @@
                         CFX_WideString& sError) {
   std::vector<CPDF_FormField*> FieldArray = GetFormFields(m_FieldName);
   if (FieldArray.empty())
     return FALSE;
 
   CPDF_FormField* pFormField = FieldArray[0];
   int32_t nCount = pFormField->CountControls();
   if (nCount < 1)
     return FALSE;
 
-  CPDFSDK_InterForm* pInterForm = m_pDocument->GetInterForm();
+  CPDFSDK_InterForm* pInterForm = m_pDocument->GetEnv()->GetInterForm();
   CPDFSDK_Widget* pWidget = nullptr;
   if (nCount == 1) {
     pWidget = pInterForm->GetWidget(pFormField->GetControl(0), false);
   } else {
     CPDFSDK_FormFillEnvironment* pEnv = m_pDocument->GetEnv();
     UnderlyingPageType* pPage = UnderlyingFromFPDFPage(
         pEnv->GetCurrentPage(m_pDocument->GetUnderlyingDocument()));
     if (!pPage)
       return FALSE;
     if (CPDFSDK_PageView* pCurPageView =
@@ skipping 281 matching lines @@
   }
 }
 
 void Field::AddField(CPDFSDK_Document* pDocument,
                      int nPageIndex,
                      int nFieldType,
                      const CFX_WideString& sName,
                      const CFX_FloatRect& rcCoords) {
   // Not supported.
 }