Introduce "underlying types" to abstract XFA differences.

fpdfsdk/src/fsdk_mgr.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 <algorithm>
 
 #include "fpdfsdk/include/fsdk_mgr.h"
 
@@ skipping 77 matching lines @@
  private:
   CPDFDoc_Environment* m_pEnv;
   int m_nCharSet;
 };
 
 void CFX_SystemHandler::SetCursor(int32_t nCursorType) {
   m_pEnv->FFI_SetCursor(nCursorType);
 }
 
 void CFX_SystemHandler::InvalidateRect(FX_HWND hWnd, FX_RECT rect) {
-  // g_pFormFillApp->FFI_Invalidate();
   CPDFSDK_Annot* pSDKAnnot = (CPDFSDK_Annot*)hWnd;
-  CPDFXFA_Page* pPage = NULL;
-  CPDFSDK_PageView* pPageView = NULL;
-  pPageView = pSDKAnnot->GetPageView();
-  pPage = pSDKAnnot->GetPDFXFAPage();
+  CPDFSDK_PageView* pPageView = pSDKAnnot->GetPageView();
+  UnderlyingPageType* pPage = pSDKAnnot->GetUnderlyingPage();
   if (!pPage || !pPageView)
     return;
   CPDF_Matrix page2device;
   pPageView->GetCurrentMatrix(page2device);
   CPDF_Matrix device2page;
   device2page.SetReverse(page2device);
   FX_FLOAT left, top, right, bottom;
   device2page.Transform((FX_FLOAT)rect.left, (FX_FLOAT)rect.top, left, top);
   device2page.Transform((FX_FLOAT)rect.right, (FX_FLOAT)rect.bottom, right,
                         bottom);
   CPDF_Rect rcPDF(left, bottom, right, top);
   rcPDF.Normalize();
 
   m_pEnv->FFI_Invalidate(pPage, rcPDF.left, rcPDF.top, rcPDF.right,
                          rcPDF.bottom);
 }
 void CFX_SystemHandler::OutputSelectedRect(void* pFormFiller, CPDF_Rect& rect) {
   CFFL_FormFiller* pFFL = (CFFL_FormFiller*)pFormFiller;
   if (pFFL) {
     CPDF_Point leftbottom = CPDF_Point(rect.left, rect.bottom);
     CPDF_Point righttop = CPDF_Point(rect.right, rect.top);
     CPDF_Point ptA = pFFL->PWLtoFFL(leftbottom);
     CPDF_Point ptB = pFFL->PWLtoFFL(righttop);
-
     CPDFSDK_Annot* pAnnot = pFFL->GetSDKAnnot();
-    ASSERT(pAnnot);
-    CPDFXFA_Page* pPage = pAnnot->GetPDFXFAPage();
+    UnderlyingPageType* pPage = pAnnot->GetUnderlyingPage();
     ASSERT(pPage);
     m_pEnv->FFI_OutputSelectedRect(pPage, ptA.x, ptB.y, ptB.x, ptA.y);
   }
 }
 
 FX_BOOL CFX_SystemHandler::IsSelectionImplemented() {
   if (m_pEnv) {
     FPDF_FORMFILLINFO* pInfo = m_pEnv->GetFormFillInfo();
     if (pInfo && pInfo->FFI_OutputSelectedRect)
       return TRUE;
@@ skipping 62 matching lines @@
   return m_pEnv->FFI_SetTimer(uElapse, lpTimerFunc);
 }
 void CFX_SystemHandler::KillTimer(int32_t nID) {
   m_pEnv->FFI_KillTimer(nID);
 }
 
 FX_SYSTEMTIME CFX_SystemHandler::GetLocalTime() {
   return m_pEnv->FFI_GetLocalTime();
 }
 
-CPDFDoc_Environment::CPDFDoc_Environment(CPDFXFA_Document* pDoc,
+CPDFDoc_Environment::CPDFDoc_Environment(UnderlyingDocumentType* pDoc,
                                          FPDF_FORMFILLINFO* pFFinfo)
-    : m_pInfo(pFFinfo), m_pSDKDoc(NULL), m_pXFADoc(pDoc) {
+    : m_pInfo(pFFinfo), m_pSDKDoc(NULL), m_pUnderlyingDoc(pDoc) {
   m_pSysHandler.reset(new CFX_SystemHandler(this));
 }
 
 CPDFDoc_Environment::~CPDFDoc_Environment() {
   CPDFXFA_App* pProvider = CPDFXFA_App::GetInstance();
   if (pProvider->m_pEnvList.GetSize() == 0)
     pProvider->SetJavaScriptInitialized(FALSE);
 }
 
 int CPDFDoc_Environment::JS_appAlert(const FX_WCHAR* Msg,
@@ skipping 157 matching lines @@
     m_pActionHandler.reset(new CPDFSDK_ActionHandler());
   return m_pActionHandler.get();
 }
 
 CFFL_IFormFiller* CPDFDoc_Environment::GetIFormFiller() {
   if (!m_pIFormFiller)
     m_pIFormFiller.reset(new CFFL_IFormFiller(this));
   return m_pIFormFiller.get();
 }
 
-CPDFSDK_Document::CPDFSDK_Document(CPDFXFA_Document* pDoc,
+CPDFSDK_Document::CPDFSDK_Document(UnderlyingDocumentType* pDoc,
                                    CPDFDoc_Environment* pEnv)
     : m_pDoc(pDoc),
       m_pFocusAnnot(nullptr),
       m_pEnv(pEnv),
       m_bChangeMask(FALSE),
-      m_bBeingDestroyed(FALSE) {
-}
+      m_bBeingDestroyed(FALSE) {}
 
 CPDFSDK_Document::~CPDFSDK_Document() {
   m_bBeingDestroyed = TRUE;
 
   for (auto& it : m_pageMap)
     it.second->KillFocusAnnotIfNeeded();
 
   for (auto& it : m_pageMap)
     delete it.second;
   m_pageMap.clear();
 }
 
-CPDFSDK_PageView* CPDFSDK_Document::GetPageView(CPDFXFA_Page* pPDFXFAPage,
-                                                FX_BOOL ReNew) {
-  auto it = m_pageMap.find(pPDFXFAPage);
+CPDFSDK_PageView* CPDFSDK_Document::GetPageView(
+    UnderlyingPageType* pUnderlyingPage,
+    FX_BOOL ReNew) {
+  auto it = m_pageMap.find(pUnderlyingPage);
   if (it != m_pageMap.end())
     return it->second;
 
   if (!ReNew)
     return nullptr;
 
-  CPDFSDK_PageView* pPageView = new CPDFSDK_PageView(this, pPDFXFAPage);
-  m_pageMap[pPDFXFAPage] = pPageView;
+  CPDFSDK_PageView* pPageView = new CPDFSDK_PageView(this, pUnderlyingPage);
+  m_pageMap[pUnderlyingPage] = pPageView;
   // Delay to load all the annotations, to avoid endless loop.
   pPageView->LoadFXAnnots();
   return pPageView;
 }
 
 CPDFSDK_PageView* CPDFSDK_Document::GetCurrentView() {
-  CPDFXFA_Page* pPage = (CPDFXFA_Page*)m_pEnv->FFI_GetCurrentPage(m_pDoc);
+  UnderlyingPageType* pPage =
+      UnderlyingFromFPDFPage(m_pEnv->FFI_GetCurrentPage(m_pDoc));
   return pPage ? GetPageView(pPage, TRUE) : nullptr;
 }
 
 CPDFSDK_PageView* CPDFSDK_Document::GetPageView(int nIndex) {
-  CPDFXFA_Page* pTempPage = (CPDFXFA_Page*)m_pEnv->FFI_GetPage(m_pDoc, nIndex);
+  UnderlyingPageType* pTempPage =
+      UnderlyingFromFPDFPage(m_pEnv->FFI_GetPage(m_pDoc, nIndex));
   if (!pTempPage)
     return nullptr;
 
   auto it = m_pageMap.find(pTempPage);
   return it->second;
 }
 
 void CPDFSDK_Document::ProcJavascriptFun() {
-  CPDFXFA_Document* pPDFDoc = GetDocument();
-  CPDF_DocJSActions docJS(pPDFDoc->GetPDFDoc());
+  CPDF_Document* pPDFDoc = GetPDFDocument();
+  CPDF_DocJSActions docJS(pPDFDoc);
   int iCount = docJS.CountJSActions();
   if (iCount < 1)
     return;
   for (int i = 0; i < iCount; i++) {
     CFX_ByteString csJSName;
     CPDF_Action jsAction = docJS.GetJSAction(i, csJSName);
     if (m_pEnv->GetActionHander())
       m_pEnv->GetActionHander()->DoAction_JavaScript(
           jsAction, CFX_WideString::FromLocal(csJSName), this);
   }
 }
 
 FX_BOOL CPDFSDK_Document::ProcOpenAction() {
   if (!m_pDoc)
     return FALSE;
 
-  CPDF_Dictionary* pRoot = m_pDoc->GetPDFDoc()->GetRoot();
+  CPDF_Dictionary* pRoot = GetPDFDocument()->GetRoot();
   if (!pRoot)
     return FALSE;
 
   CPDF_Object* pOpenAction = pRoot->GetDict("OpenAction");
   if (!pOpenAction)
     pOpenAction = pRoot->GetArray("OpenAction");
 
   if (!pOpenAction)
     return FALSE;
 
   if (pOpenAction->IsArray())
     return TRUE;
 
   if (CPDF_Dictionary* pDict = pOpenAction->AsDictionary()) {
     CPDF_Action action(pDict);
     if (m_pEnv->GetActionHander())
       m_pEnv->GetActionHander()->DoAction_DocOpen(action, this);
     return TRUE;
   }
   return FALSE;
 }
 
 CPDF_OCContext* CPDFSDK_Document::GetOCContext() {
   if (!m_pOccontent)
-    m_pOccontent.reset(new CPDF_OCContext(m_pDoc->GetPDFDoc()));
+    m_pOccontent.reset(new CPDF_OCContext(GetPDFDocument()));
   return m_pOccontent.get();
 }
 
-void CPDFSDK_Document::ReMovePageView(CPDFXFA_Page* pPDFXFAPage) {
-  auto it = m_pageMap.find(pPDFXFAPage);
+void CPDFSDK_Document::RemovePageView(UnderlyingPageType* pUnderlyingPage) {
+  auto it = m_pageMap.find(pUnderlyingPage);
   if (it == m_pageMap.end())
     return;
 
   CPDFSDK_PageView* pPageView = it->second;
   if (pPageView->IsLocked())
     return;
 
   pPageView->KillFocusAnnotIfNeeded();
   delete pPageView;
   m_pageMap.erase(it);
 }
 
-CPDFXFA_Page* CPDFSDK_Document::GetPage(int nIndex) {
-  CPDFXFA_Page* pTempPage = (CPDFXFA_Page*)m_pEnv->FFI_GetPage(m_pDoc, nIndex);
-  if (!pTempPage)
-    return NULL;
-  return pTempPage;
+UnderlyingPageType* CPDFSDK_Document::GetPage(int nIndex) {
+  return UnderlyingFromFPDFPage(m_pEnv->FFI_GetPage(m_pDoc, nIndex));
 }
 
 CPDFSDK_InterForm* CPDFSDK_Document::GetInterForm() {
   if (!m_pInterForm)
     m_pInterForm.reset(new CPDFSDK_InterForm(this));
   return m_pInterForm.get();
 }
 
 void CPDFSDK_Document::UpdateAllViews(CPDFSDK_PageView* pSender,
                                       CPDFSDK_Annot* pAnnot) {
@@ skipping 63 matching lines @@
 
       if (!m_pFocusAnnot)
         return TRUE;
     } else {
       m_pFocusAnnot = pFocusAnnot;
     }
   }
   return FALSE;
 }
 
-FX_BOOL CPDFSDK_Document::DeletePages(int nStart, int nCount) {
-  if (nStart < 0 || nStart >= GetPageCount() || nCount <= 0) {
-    return FALSE;
-  }
-
-  CPDFXFA_Page* pTempPage = NULL;
-  for (int i = nCount - 1; i >= 0; i--) {
-    pTempPage = GetPage(nStart + i);
-    if (pTempPage != NULL) {
-      ReMovePageView(pTempPage);
-    }
-  }
-  return TRUE;
-}
-
 void CPDFSDK_Document::OnCloseDocument() {
   KillFocusAnnot();
 }
 
 FX_BOOL CPDFSDK_Document::GetPermissions(int nFlag) {
   FX_DWORD dwPermissions = m_pDoc->GetPDFDoc()->GetUserPermissions();
   return dwPermissions & nFlag;
 }
 
 IJS_Runtime* CPDFSDK_Document::GetJsRuntime() {
@@ skipping 386 matching lines @@
 FX_BOOL CPDFSDK_PageView::OnKeyUp(int nKeyCode, int nFlag) {
   return FALSE;
 }
 
 void CPDFSDK_PageView::LoadFXAnnots() {
   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
   CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
 
   SetLock(TRUE);
   m_page->AddRef();
-  if (m_pSDKDoc->GetDocument()->GetDocType() == DOCTYPE_DYNIMIC_XFA) {
+  if (m_pSDKDoc->GetXFADocument()->GetDocType() == DOCTYPE_DYNIMIC_XFA) {
     IXFA_PageView* pageView = NULL;
     pageView = m_page->GetXFAPageView();
     ASSERT(pageView != NULL);
 
     IXFA_WidgetIterator* pWidgetHander = pageView->CreateWidgetIterator(
         XFA_TRAVERSEWAY_Form, XFA_WIDGETFILTER_Visible |
                                   XFA_WIDGETFILTER_Viewable |
                                   XFA_WIDGETFILTER_AllType);
     if (!pWidgetHander) {
       m_page->Release();
@@ skipping 49 matching lines @@
 void CPDFSDK_PageView::UpdateView(CPDFSDK_Annot* pAnnot) {
   CPDF_Rect rcWindow = pAnnot->GetRect();
   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
   pEnv->FFI_Invalidate(m_page, rcWindow.left, rcWindow.top, rcWindow.right,
                        rcWindow.bottom);
 }
 
 int CPDFSDK_PageView::GetPageIndex() {
   if (m_page) {
     CPDF_Dictionary* pDic = m_page->GetPDFPage()->m_pFormDict;
-    CPDFXFA_Document* pDoc = m_pSDKDoc->GetDocument();
+    CPDF_Document* pDoc = m_pSDKDoc->GetPDFDocument();
     if (pDoc && pDic) {
-      return pDoc->GetPDFDoc()->GetPageIndex(pDic->GetObjNum());
+      return pDoc->GetPageIndex(pDic->GetObjNum());
     }
   }
   return -1;
 }
 
 bool CPDFSDK_PageView::IsValidAnnot(const CPDF_Annot* p) const {
   if (!p)
     return false;
 
   const auto& annots = m_pAnnotList->All();
   return std::find(annots.begin(), annots.end(), p) != annots.end();
 }
 
 CPDFSDK_Annot* CPDFSDK_PageView::GetFocusAnnot() {
   CPDFSDK_Annot* pFocusAnnot = m_pSDKDoc->GetFocusAnnot();
   if (!pFocusAnnot)
     return nullptr;
 
   for (CPDFSDK_Annot* pAnnot : m_fxAnnotArray) {
     if (pAnnot == pFocusAnnot)
       return pAnnot;
   }
   return nullptr;
 }