Merge CPDFSDK_Document into 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>
 #include <string>
 #include <vector>
 
 #include "core/fpdfapi/font/cpdf_font.h"
 #include "core/fpdfapi/page/cpdf_page.h"
 #include "core/fpdfapi/parser/cpdf_document.h"
 #include "core/fpdfdoc/cpdf_interform.h"
-#include "fpdfsdk/cpdfsdk_document.h"
 #include "fpdfsdk/cpdfsdk_formfillenvironment.h"
 #include "fpdfsdk/cpdfsdk_interform.h"
 #include "fpdfsdk/cpdfsdk_pageview.h"
 #include "fpdfsdk/cpdfsdk_widget.h"
 #include "fpdfsdk/javascript/Document.h"
 #include "fpdfsdk/javascript/Icon.h"
 #include "fpdfsdk/javascript/JS_Define.h"
 #include "fpdfsdk/javascript/JS_EventHandler.h"
 #include "fpdfsdk/javascript/JS_Object.h"
 #include "fpdfsdk/javascript/JS_Value.h"
@@ skipping 177 matching lines @@
       return;
     }
   }
   strFieldName = strFieldNameParsed.substr(0, iStart);
 }
 
 FX_BOOL Field::AttachField(Document* pDocument,
                            const CFX_WideString& csFieldName) {
   m_pJSDoc = pDocument;
   m_pFormFillEnv.Reset(pDocument->GetFormFillEnv());
-  m_bCanSet =
-      m_pFormFillEnv->GetSDKDocument()->GetPermissions(FPDFPERM_FILL_FORM) ||
-      m_pFormFillEnv->GetSDKDocument()->GetPermissions(FPDFPERM_ANNOT_FORM) ||
-      m_pFormFillEnv->GetSDKDocument()->GetPermissions(FPDFPERM_MODIFY);
+  m_bCanSet = m_pFormFillEnv->GetPermissions(FPDFPERM_FILL_FORM) ||
+              m_pFormFillEnv->GetPermissions(FPDFPERM_ANNOT_FORM) ||
+              m_pFormFillEnv->GetPermissions(FPDFPERM_MODIFY);
 
-  CPDFSDK_InterForm* pRDInterForm =
-      m_pFormFillEnv->GetSDKDocument()->GetInterForm();
+  CPDFSDK_InterForm* pRDInterForm = m_pFormFillEnv->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_FormFillEnvironment* pFormFillEnv,
     const CFX_WideString& csFieldName) {
   std::vector<CPDF_FormField*> fields;
-  CPDFSDK_InterForm* pReaderInterForm =
-      pFormFillEnv->GetSDKDocument()->GetInterForm();
+  CPDFSDK_InterForm* pReaderInterForm = pFormFillEnv->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_pFormFillEnv.Get(), csFieldName);
 }
 
 void Field::UpdateFormField(CPDFSDK_FormFillEnvironment* pFormFillEnv,
                             CPDF_FormField* pFormField,
                             FX_BOOL bChangeMark,
                             FX_BOOL bResetAP,
                             FX_BOOL bRefresh) {
-  CPDFSDK_InterForm* pInterForm =
-      pFormFillEnv->GetSDKDocument()->GetInterForm();
+  CPDFSDK_InterForm* pInterForm = pFormFillEnv->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 13 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);
 
     // TODO(dsinclair): Determine if all widgets share the same
     // CPDFSDK_InterForm. If that's the case, we can move the code to
-    // |GetSDKDocument| out of the loop.
+    // |GetFormFillEnv| out of the loop.
     for (CPDFSDK_Widget* pWidget : widgets) {
       pWidget->GetInterForm()
           ->GetFormFillEnv()
-          ->GetSDKDocument()
           ->UpdateAllViews(nullptr, pWidget);
     }
   }
 
   if (bChangeMark)
-    pFormFillEnv->GetSDKDocument()->SetChangeMark();
+    pFormFillEnv->SetChangeMark();
 }
 
 void Field::UpdateFormControl(CPDFSDK_FormFillEnvironment* pFormFillEnv,
                               CPDF_FormControl* pFormControl,
                               FX_BOOL bChangeMark,
                               FX_BOOL bResetAP,
                               FX_BOOL bRefresh) {
   ASSERT(pFormControl);
 
-  CPDFSDK_InterForm* pForm = pFormFillEnv->GetSDKDocument()->GetInterForm();
+  CPDFSDK_InterForm* pForm = pFormFillEnv->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();
-      pInterForm->GetFormFillEnv()->GetSDKDocument()->UpdateAllViews(nullptr,
-                                                                     pWidget);
+      pInterForm->GetFormFillEnv()->UpdateAllViews(nullptr, pWidget);
     }
   }
 
   if (bChangeMark)
-    pFormFillEnv->GetSDKDocument()->SetChangeMark();
+    pFormFillEnv->SetChangeMark();
 }
 
 CPDFSDK_Widget* Field::GetWidget(CPDFSDK_FormFillEnvironment* pFormFillEnv,
                                  CPDF_FormControl* pFormControl,
                                  bool createIfNeeded) {
-  CPDFSDK_InterForm* pInterForm = static_cast<CPDFSDK_InterForm*>(
-      pFormFillEnv->GetSDKDocument()->GetInterForm());
+  CPDFSDK_InterForm* pInterForm =
+      static_cast<CPDFSDK_InterForm*>(pFormFillEnv->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_pFormFillEnv->GetSDKDocument()->GetInterForm();
+    CPDFSDK_InterForm* pRDInterForm = m_pFormFillEnv->GetInterForm();
     CPDF_InterForm* pInterForm = pRDInterForm->GetInterForm();
     vp << (int32_t)pInterForm->FindFieldInCalculationOrder(pFormField);
   }
 
   return TRUE;
 }
 
 void Field::SetCalcOrderIndex(CPDFSDK_FormFillEnvironment* pFormFillEnv,
                               const CFX_WideString& swFieldName,
                               int nControlIndex,
@@ skipping 383 matching lines @@
       Field::SetDisplay(m_pFormFillEnv.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_pFormFillEnv->GetSDKDocument()->GetInterForm();
+    CPDFSDK_InterForm* pInterForm = m_pFormFillEnv->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_FormFillEnvironment* pFormFillEnv,
                        const CFX_WideString& swFieldName,
                        int nControlIndex,
                        int number) {
-  CPDFSDK_InterForm* pInterForm =
-      pFormFillEnv->GetSDKDocument()->GetInterForm();
+  CPDFSDK_InterForm* pInterForm = pFormFillEnv->GetInterForm();
   std::vector<CPDF_FormField*> FieldArray =
       GetFormFields(pFormFillEnv, 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_pFormFillEnv.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_pFormFillEnv->GetSDKDocument()->GetInterForm();
+    CPDFSDK_InterForm* pInterForm = m_pFormFillEnv->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_pFormFillEnv->GetSDKDocument()->GetInterForm();
+    CPDFSDK_InterForm* pInterForm = m_pFormFillEnv->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_FormFillEnvironment* pFormFillEnv,
                          const CFX_WideString& swFieldName,
                          int nControlIndex,
                          int number) {
-  CPDFSDK_InterForm* pInterForm =
-      pFormFillEnv->GetSDKDocument()->GetInterForm();
+  CPDFSDK_InterForm* pInterForm = pFormFillEnv->GetInterForm();
   std::vector<CPDF_FormField*> FieldArray =
       GetFormFields(pFormFillEnv, 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_pFormFillEnv->GetSDKDocument()->GetInterForm()->GetWidgets(pFormField,
-                                                               &widgets);
+  m_pFormFillEnv->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_FormFillEnvironment* pFormFillEnv,
                         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_pFormFillEnv->GetSDKDocument()->GetInterForm();
+  CPDFSDK_InterForm* pInterForm = m_pFormFillEnv->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_pFormFillEnv.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_pFormFillEnv->GetSDKDocument()->GetInterForm();
+    CPDFSDK_InterForm* pInterForm = m_pFormFillEnv->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_FormFillEnvironment* pFormFillEnv,
                     const CFX_WideString& swFieldName,
                     int nControlIndex,
                     const CFX_FloatRect& rect) {
-  CPDFSDK_InterForm* pInterForm =
-      pFormFillEnv->GetSDKDocument()->GetInterForm();
+  CPDFSDK_InterForm* pInterForm = pFormFillEnv->GetInterForm();
   std::vector<CPDF_FormField*> FieldArray =
       GetFormFields(pFormFillEnv, 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 1087 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_pFormFillEnv->GetSDKDocument()->GetInterForm();
+  CPDFSDK_InterForm* pInterForm = m_pFormFillEnv->GetInterForm();
   CPDFSDK_Widget* pWidget = nullptr;
   if (nCount == 1) {
     pWidget = pInterForm->GetWidget(pFormField->GetControl(0), false);
   } else {
     UnderlyingPageType* pPage =
         UnderlyingFromFPDFPage(m_pFormFillEnv->GetCurrentPage(
             m_pFormFillEnv->GetUnderlyingDocument()));
     if (!pPage)
       return FALSE;
     if (CPDFSDK_PageView* pCurPageView =
-            m_pFormFillEnv->GetSDKDocument()->GetPageView(pPage, true)) {
+            m_pFormFillEnv->GetPageView(pPage, true)) {
       for (int32_t i = 0; i < nCount; i++) {
         if (CPDFSDK_Widget* pTempWidget =
                 pInterForm->GetWidget(pFormField->GetControl(i), false)) {
           if (pTempWidget->GetPDFPage() == pCurPageView->GetPDFPage()) {
             pWidget = pTempWidget;
             break;
           }
         }
       }
     }
   }
 
   if (pWidget) {
     CPDFSDK_Annot::ObservedPtr pObserved(pWidget);
-    m_pFormFillEnv->GetSDKDocument()->SetFocusAnnot(&pObserved);
+    m_pFormFillEnv->SetFocusAnnot(&pObserved);
   }
 
   return TRUE;
 }
 
 FX_BOOL Field::setItems(IJS_Context* cc,
                         const std::vector<CJS_Value>& params,
                         CJS_Value& vRet,
                         CFX_WideString& sError) {
   return TRUE;
@@ skipping 256 matching lines @@
   }
 }
 
 void Field::AddField(CPDFSDK_FormFillEnvironment* pFormFillEnv,
                      int nPageIndex,
                      int nFieldType,
                      const CFX_WideString& sName,
                      const CFX_FloatRect& rcCoords) {
   // Not supported.
 }