From 7cbe68e34257b460bfa3baf0ea68fd6d50e1bc77 Mon Sep 17 00:00:00 2001 From: dsinclair Date: Wed, 12 Oct 2016 11:56:23 -0700 Subject: Merge CPDFSDK_Document into CPDFSDK_FormFillEnvironment This CL merges the CPDFSDK_Document and CPDFSDK_FormFillEnvironment classes as they always existed and always pointed at each other. Review-Url: https://codereview.chromium.org/2410893002 --- fpdfsdk/cpdfsdk_formfillenvironment.cpp | 217 +++++++++++++++++++++++++++++++- 1 file changed, 214 insertions(+), 3 deletions(-) (limited to 'fpdfsdk/cpdfsdk_formfillenvironment.cpp') diff --git a/fpdfsdk/cpdfsdk_formfillenvironment.cpp b/fpdfsdk/cpdfsdk_formfillenvironment.cpp index 7b41ea148c..2beaadeb1a 100644 --- a/fpdfsdk/cpdfsdk_formfillenvironment.cpp +++ b/fpdfsdk/cpdfsdk_formfillenvironment.cpp @@ -8,8 +8,12 @@ #include +#include "core/fpdfapi/parser/cpdf_array.h" +#include "core/fpdfdoc/cpdf_docjsactions.h" #include "fpdfsdk/cpdfsdk_annothandlermgr.h" -#include "fpdfsdk/cpdfsdk_document.h" +#include "fpdfsdk/cpdfsdk_interform.h" +#include "fpdfsdk/cpdfsdk_pageview.h" +#include "fpdfsdk/cpdfsdk_widget.h" #include "fpdfsdk/formfiller/cffl_interactiveformfiller.h" #include "fpdfsdk/fsdk_actionhandler.h" #include "fpdfsdk/javascript/ijs_runtime.h" @@ -34,11 +38,19 @@ CPDFSDK_FormFillEnvironment::CPDFSDK_FormFillEnvironment( UnderlyingDocumentType* pDoc, FPDF_FORMFILLINFO* pFFinfo) : m_pInfo(pFFinfo), - m_pSDKDoc(new CPDFSDK_Document(pDoc, this)), m_pUnderlyingDoc(pDoc), - m_pSysHandler(new CFX_SystemHandler(this)) {} + m_pSysHandler(new CFX_SystemHandler(this)), + m_bChangeMask(FALSE), + m_bBeingDestroyed(FALSE) {} CPDFSDK_FormFillEnvironment::~CPDFSDK_FormFillEnvironment() { + m_bBeingDestroyed = TRUE; + + ClearAllFocusedAnnots(); + for (auto& it : m_pageMap) + delete it.second; + m_pageMap.clear(); + // |m_pAnnotHandlerMgr| will try to access |m_pFormFiller| // when it cleans up. So, we must make sure it is cleaned up before // |m_pFormFiller|. @@ -562,3 +574,202 @@ void CPDFSDK_FormFillEnvironment::PageEvent(int iPageCount, m_pInfo->FFI_PageEvent(m_pInfo, iPageCount, dwEventType); } #endif // PDF_ENABLE_XFA + +void CPDFSDK_FormFillEnvironment::ClearAllFocusedAnnots() { + for (auto& it : m_pageMap) { + if (it.second->IsValidSDKAnnot(GetFocusAnnot())) + KillFocusAnnot(0); + } +} + +CPDFSDK_PageView* CPDFSDK_FormFillEnvironment::GetPageView( + UnderlyingPageType* pUnderlyingPage, + 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, pUnderlyingPage); + m_pageMap[pUnderlyingPage] = pPageView; + // Delay to load all the annotations, to avoid endless loop. + pPageView->LoadFXAnnots(); + return pPageView; +} + +CPDFSDK_PageView* CPDFSDK_FormFillEnvironment::GetCurrentView() { + UnderlyingPageType* pPage = + UnderlyingFromFPDFPage(GetCurrentPage(m_pUnderlyingDoc)); + return pPage ? GetPageView(pPage, true) : nullptr; +} + +CPDFSDK_PageView* CPDFSDK_FormFillEnvironment::GetPageView(int nIndex) { + UnderlyingPageType* pTempPage = + UnderlyingFromFPDFPage(GetPage(m_pUnderlyingDoc, nIndex)); + if (!pTempPage) + return nullptr; + + auto it = m_pageMap.find(pTempPage); + return it != m_pageMap.end() ? it->second : nullptr; +} + +void CPDFSDK_FormFillEnvironment::ProcJavascriptFun() { + 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 (GetActionHander()) { + GetActionHander()->DoAction_JavaScript( + jsAction, CFX_WideString::FromLocal(csJSName.AsStringC()), this); + } + } +} + +FX_BOOL CPDFSDK_FormFillEnvironment::ProcOpenAction() { + if (!m_pUnderlyingDoc) + return FALSE; + + CPDF_Dictionary* pRoot = GetPDFDocument()->GetRoot(); + if (!pRoot) + return FALSE; + + CPDF_Object* pOpenAction = pRoot->GetDictFor("OpenAction"); + if (!pOpenAction) + pOpenAction = pRoot->GetArrayFor("OpenAction"); + + if (!pOpenAction) + return FALSE; + + if (pOpenAction->IsArray()) + return TRUE; + + if (CPDF_Dictionary* pDict = pOpenAction->AsDictionary()) { + CPDF_Action action(pDict); + if (GetActionHander()) + GetActionHander()->DoAction_DocOpen(action, this); + return TRUE; + } + return FALSE; +} + +void CPDFSDK_FormFillEnvironment::RemovePageView( + UnderlyingPageType* pUnderlyingPage) { + auto it = m_pageMap.find(pUnderlyingPage); + if (it == m_pageMap.end()) + return; + + CPDFSDK_PageView* pPageView = it->second; + if (pPageView->IsLocked() || pPageView->IsBeingDestroyed()) + return; + + // Mark the page view so we do not come into |RemovePageView| a second + // time while we're in the process of removing. + pPageView->SetBeingDestroyed(); + + // This must happen before we remove |pPageView| from the map because + // |KillFocusAnnot| can call into the |GetPage| method which will + // look for this page view in the map, if it doesn't find it a new one will + // be created. We then have two page views pointing to the same page and + // bad things happen. + if (pPageView->IsValidSDKAnnot(GetFocusAnnot())) + KillFocusAnnot(0); + + // Remove the page from the map to make sure we don't accidentally attempt + // to use the |pPageView| while we're cleaning it up. + m_pageMap.erase(it); + + delete pPageView; +} + +UnderlyingPageType* CPDFSDK_FormFillEnvironment::GetPage(int nIndex) { + return UnderlyingFromFPDFPage(GetPage(m_pUnderlyingDoc, nIndex)); +} + +CPDFSDK_InterForm* CPDFSDK_FormFillEnvironment::GetInterForm() { + if (!m_pInterForm) + m_pInterForm = pdfium::MakeUnique(this); + return m_pInterForm.get(); +} + +void CPDFSDK_FormFillEnvironment::UpdateAllViews(CPDFSDK_PageView* pSender, + CPDFSDK_Annot* pAnnot) { + for (const auto& it : m_pageMap) { + CPDFSDK_PageView* pPageView = it.second; + if (pPageView != pSender) + pPageView->UpdateView(pAnnot); + } +} + +FX_BOOL CPDFSDK_FormFillEnvironment::SetFocusAnnot( + CPDFSDK_Annot::ObservedPtr* pAnnot) { + if (m_bBeingDestroyed) + return FALSE; + if (m_pFocusAnnot == *pAnnot) + return TRUE; + if (m_pFocusAnnot && !KillFocusAnnot(0)) + return FALSE; + if (!*pAnnot) + return FALSE; + +#ifdef PDF_ENABLE_XFA + CPDFSDK_Annot::ObservedPtr pLastFocusAnnot(m_pFocusAnnot.Get()); +#endif // PDF_ENABLE_XFA + CPDFSDK_PageView* pPageView = (*pAnnot)->GetPageView(); + if (pPageView && pPageView->IsValid()) { + CPDFSDK_AnnotHandlerMgr* pAnnotHandler = GetAnnotHandlerMgr(); + if (!m_pFocusAnnot) { +#ifdef PDF_ENABLE_XFA + if (!pAnnotHandler->Annot_OnChangeFocus(pAnnot, &pLastFocusAnnot)) + return FALSE; +#endif // PDF_ENABLE_XFA + if (!pAnnotHandler->Annot_OnSetFocus(pAnnot, 0)) + return FALSE; + if (!m_pFocusAnnot) { + m_pFocusAnnot.Reset(pAnnot->Get()); + return TRUE; + } + } + } + return FALSE; +} + +FX_BOOL CPDFSDK_FormFillEnvironment::KillFocusAnnot(uint32_t nFlag) { + if (m_pFocusAnnot) { + CPDFSDK_AnnotHandlerMgr* pAnnotHandler = GetAnnotHandlerMgr(); + CPDFSDK_Annot::ObservedPtr pFocusAnnot(m_pFocusAnnot.Get()); + m_pFocusAnnot.Reset(); + +#ifdef PDF_ENABLE_XFA + CPDFSDK_Annot::ObservedPtr pNull; + if (!pAnnotHandler->Annot_OnChangeFocus(&pNull, &pFocusAnnot)) + return FALSE; +#endif // PDF_ENABLE_XFA + + if (pAnnotHandler->Annot_OnKillFocus(&pFocusAnnot, nFlag)) { + if (pFocusAnnot->GetAnnotSubtype() == CPDF_Annot::Subtype::WIDGET) { + CPDFSDK_Widget* pWidget = + static_cast(pFocusAnnot.Get()); + int nFieldType = pWidget->GetFieldType(); + if (FIELDTYPE_TEXTFIELD == nFieldType || + FIELDTYPE_COMBOBOX == nFieldType) { + OnSetFieldInputFocus(nullptr, 0, FALSE); + } + } + if (!m_pFocusAnnot) + return TRUE; + } else { + m_pFocusAnnot.Reset(pFocusAnnot.Get()); + } + } + return FALSE; +} + +FX_BOOL CPDFSDK_FormFillEnvironment::GetPermissions(int nFlag) { + return GetPDFDocument()->GetUserPermissions() & nFlag; +} -- cgit v1.2.3