blob: 0713d29a5f673112efe99d81d009b3c15a71e124 [file] [log] [blame]
// Copyright 2016 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/cpdfsdk_pageview.h"
#include <memory>
#include <vector>
#include "core/fpdfapi/parser/cpdf_document.h"
#include "core/fpdfapi/render/cpdf_renderoptions.h"
#include "core/fpdfdoc/cpdf_annotlist.h"
#include "core/fpdfdoc/cpdf_interform.h"
#include "core/fxcrt/autorestorer.h"
#include "fpdfsdk/cpdfsdk_annot.h"
#include "fpdfsdk/cpdfsdk_annotiteration.h"
#include "fpdfsdk/cpdfsdk_formfillenvironment.h"
#include "fpdfsdk/cpdfsdk_interform.h"
#include "third_party/base/ptr_util.h"
#ifdef PDF_ENABLE_XFA
#include "fpdfsdk/fpdfxfa/cpdfxfa_context.h"
#include "fpdfsdk/fpdfxfa/cpdfxfa_page.h"
#include "xfa/fxfa/cxfa_ffdocview.h"
#include "xfa/fxfa/cxfa_ffpageview.h"
#include "xfa/fxfa/cxfa_ffwidgethandler.h"
#include "xfa/fxfa/cxfa_rendercontext.h"
#include "xfa/fxgraphics/cxfa_graphics.h"
#endif // PDF_ENABLE_XFA
CPDFSDK_PageView::CPDFSDK_PageView(CPDFSDK_FormFillEnvironment* pFormFillEnv,
IPDF_Page* page)
: m_page(page), m_pFormFillEnv(pFormFillEnv) {
ASSERT(m_page);
CPDF_Page* pPDFPage = ToPDFPage(page);
if (pPDFPage) {
CPDFSDK_InterForm* pInterForm = pFormFillEnv->GetInterForm();
CPDF_InterForm* pPDFInterForm = pInterForm->GetInterForm();
pPDFInterForm->FixPageFields(pPDFPage);
if (!page->AsXFAPage())
pPDFPage->SetView(this);
}
}
CPDFSDK_PageView::~CPDFSDK_PageView() {
if (!m_page->AsXFAPage()) {
// The call to |ReleaseAnnot| can cause the page pointed to by |m_page| to
// be freed, which will cause issues if we try to cleanup the pageview
// pointer in |m_page|. So, reset the pageview pointer before doing anything
// else.
m_page->AsPDFPage()->SetView(nullptr);
}
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
for (CPDFSDK_Annot* pAnnot : m_SDKAnnotArray)
pAnnotHandlerMgr->ReleaseAnnot(pAnnot);
m_SDKAnnotArray.clear();
m_pAnnotList.reset();
}
void CPDFSDK_PageView::PageView_OnDraw(CFX_RenderDevice* pDevice,
CFX_Matrix* pUser2Device,
CPDF_RenderOptions* pOptions,
const FX_RECT& pClip) {
m_curMatrix = *pUser2Device;
#ifdef PDF_ENABLE_XFA
CPDFXFA_Page* pPage = GetPDFXFAPage();
if (!pPage)
return;
auto* pContext = static_cast<CPDFXFA_Context*>(pPage->GetDocumentExtension());
if (pContext->GetFormType() == FormType::kXFAFull) {
CFX_RectF rectClip(
static_cast<float>(pClip.left), static_cast<float>(pClip.top),
static_cast<float>(pClip.Width()), static_cast<float>(pClip.Height()));
CXFA_Graphics gs(pDevice);
gs.SetClipRect(rectClip);
CXFA_FFPageView* xfaView = pPage->GetXFAPageView();
CXFA_RenderContext renderContext(xfaView, rectClip, *pUser2Device);
renderContext.DoRender(&gs);
CXFA_FFDocView* docView = xfaView->GetDocView();
if (!docView)
return;
CPDFSDK_Annot* annot = GetFocusAnnot();
if (!annot)
return;
// Render the focus widget
docView->GetWidgetHandler()->RenderWidget(annot->GetXFAWidget(), &gs,
*pUser2Device, false);
return;
}
#endif // PDF_ENABLE_XFA
// for pdf/static xfa.
CPDFSDK_AnnotIteration annotIteration(this, true);
for (const auto& pSDKAnnot : annotIteration) {
m_pFormFillEnv->GetAnnotHandlerMgr()->Annot_OnDraw(
this, pSDKAnnot.Get(), pDevice, pUser2Device,
pOptions->GetDrawAnnots());
}
}
CPDFSDK_Annot* CPDFSDK_PageView::GetFXAnnotAtPoint(const CFX_PointF& point) {
CPDFSDK_AnnotHandlerMgr* pAnnotMgr = m_pFormFillEnv->GetAnnotHandlerMgr();
CPDFSDK_AnnotIteration annotIteration(this, false);
for (const auto& pSDKAnnot : annotIteration) {
CFX_FloatRect rc = pAnnotMgr->Annot_OnGetViewBBox(this, pSDKAnnot.Get());
if (pSDKAnnot->GetAnnotSubtype() == CPDF_Annot::Subtype::POPUP)
continue;
if (rc.Contains(point))
return pSDKAnnot.Get();
}
return nullptr;
}
CPDFSDK_Annot* CPDFSDK_PageView::GetFXWidgetAtPoint(const CFX_PointF& point) {
CPDFSDK_AnnotHandlerMgr* pAnnotMgr = m_pFormFillEnv->GetAnnotHandlerMgr();
CPDFSDK_AnnotIteration annotIteration(this, false);
for (const auto& pSDKAnnot : annotIteration) {
bool bHitTest = pSDKAnnot->GetAnnotSubtype() == CPDF_Annot::Subtype::WIDGET;
#ifdef PDF_ENABLE_XFA
bHitTest = bHitTest ||
pSDKAnnot->GetAnnotSubtype() == CPDF_Annot::Subtype::XFAWIDGET;
#endif // PDF_ENABLE_XFA
if (bHitTest) {
pAnnotMgr->Annot_OnGetViewBBox(this, pSDKAnnot.Get());
if (pAnnotMgr->Annot_OnHitTest(this, pSDKAnnot.Get(), point))
return pSDKAnnot.Get();
}
}
return nullptr;
}
#ifdef PDF_ENABLE_XFA
CPDFSDK_Annot* CPDFSDK_PageView::AddAnnot(CXFA_FFWidget* pPDFAnnot) {
if (!pPDFAnnot)
return nullptr;
CPDFSDK_Annot* pSDKAnnot = GetAnnotByXFAWidget(pPDFAnnot);
if (pSDKAnnot)
return pSDKAnnot;
CPDFSDK_AnnotHandlerMgr* pAnnotHandler = m_pFormFillEnv->GetAnnotHandlerMgr();
pSDKAnnot = pAnnotHandler->NewAnnot(pPDFAnnot, this);
if (!pSDKAnnot)
return nullptr;
m_SDKAnnotArray.push_back(pSDKAnnot);
return pSDKAnnot;
}
bool CPDFSDK_PageView::DeleteAnnot(CPDFSDK_Annot* pAnnot) {
if (!pAnnot)
return false;
CPDFXFA_Page* pPage = pAnnot->GetPDFXFAPage();
if (!pPage)
return false;
auto* pContext = static_cast<CPDFXFA_Context*>(pPage->GetDocumentExtension());
if (!pContext->ContainsXFAForm())
return false;
CPDFSDK_Annot::ObservedPtr pObserved(pAnnot);
if (GetFocusAnnot() == pAnnot)
m_pFormFillEnv->KillFocusAnnot(0); // May invoke JS, invalidating pAnnot.
if (pObserved) {
CPDFSDK_AnnotHandlerMgr* pAnnotHandler =
m_pFormFillEnv->GetAnnotHandlerMgr();
if (pAnnotHandler)
pAnnotHandler->ReleaseAnnot(pObserved.Get());
}
auto it = std::find(m_SDKAnnotArray.begin(), m_SDKAnnotArray.end(), pAnnot);
if (it != m_SDKAnnotArray.end())
m_SDKAnnotArray.erase(it);
if (m_pCaptureWidget.Get() == pAnnot)
m_pCaptureWidget.Reset();
return true;
}
#endif // PDF_ENABLE_XFA
CPDF_Document* CPDFSDK_PageView::GetPDFDocument() {
return m_page->GetDocument();
}
CPDF_Page* CPDFSDK_PageView::GetPDFPage() const {
return ToPDFPage(m_page);
}
CPDFSDK_Annot* CPDFSDK_PageView::GetAnnotByDict(CPDF_Dictionary* pDict) {
for (CPDFSDK_Annot* pAnnot : m_SDKAnnotArray) {
if (pAnnot->GetPDFAnnot()->GetAnnotDict() == pDict)
return pAnnot;
}
return nullptr;
}
#ifdef PDF_ENABLE_XFA
CPDFSDK_Annot* CPDFSDK_PageView::GetAnnotByXFAWidget(CXFA_FFWidget* hWidget) {
if (!hWidget)
return nullptr;
for (CPDFSDK_Annot* pAnnot : m_SDKAnnotArray) {
if (pAnnot->GetXFAWidget() == hWidget)
return pAnnot;
}
return nullptr;
}
#endif // PDF_ENABLE_XFA
WideString CPDFSDK_PageView::GetFocusedFormText() {
if (CPDFSDK_Annot* pAnnot = GetFocusAnnot()) {
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
return pAnnotHandlerMgr->Annot_GetText(pAnnot);
}
return WideString();
}
WideString CPDFSDK_PageView::GetSelectedText() {
if (CPDFSDK_Annot* pAnnot = GetFocusAnnot()) {
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
return pAnnotHandlerMgr->Annot_GetSelectedText(pAnnot);
}
return WideString();
}
void CPDFSDK_PageView::ReplaceSelection(const WideString& text) {
if (CPDFSDK_Annot* pAnnot = GetFocusAnnot()) {
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
pAnnotHandlerMgr->Annot_ReplaceSelection(pAnnot, text);
}
}
bool CPDFSDK_PageView::CanUndo() {
if (CPDFSDK_Annot* pAnnot = GetFocusAnnot()) {
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
return pAnnotHandlerMgr->Annot_CanUndo(pAnnot);
}
return false;
}
bool CPDFSDK_PageView::CanRedo() {
if (CPDFSDK_Annot* pAnnot = GetFocusAnnot()) {
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
return pAnnotHandlerMgr->Annot_CanRedo(pAnnot);
}
return false;
}
bool CPDFSDK_PageView::Undo() {
if (CPDFSDK_Annot* pAnnot = GetFocusAnnot()) {
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
return pAnnotHandlerMgr->Annot_Undo(pAnnot);
}
return false;
}
bool CPDFSDK_PageView::Redo() {
if (CPDFSDK_Annot* pAnnot = GetFocusAnnot()) {
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
return pAnnotHandlerMgr->Annot_Redo(pAnnot);
}
return false;
}
bool CPDFSDK_PageView::OnFocus(const CFX_PointF& point, uint32_t nFlag) {
CPDFSDK_Annot::ObservedPtr pAnnot(GetFXWidgetAtPoint(point));
if (!pAnnot) {
m_pFormFillEnv->KillFocusAnnot(nFlag);
return false;
}
m_pFormFillEnv->SetFocusAnnot(&pAnnot);
return true;
}
bool CPDFSDK_PageView::OnLButtonDown(const CFX_PointF& point, uint32_t nFlag) {
CPDFSDK_Annot::ObservedPtr pAnnot(GetFXWidgetAtPoint(point));
if (!pAnnot) {
m_pFormFillEnv->KillFocusAnnot(nFlag);
return false;
}
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
if (!pAnnotHandlerMgr->Annot_OnLButtonDown(this, &pAnnot, nFlag, point))
return false;
if (!pAnnot)
return false;
m_pFormFillEnv->SetFocusAnnot(&pAnnot);
return true;
}
#ifdef PDF_ENABLE_XFA
bool CPDFSDK_PageView::OnRButtonDown(const CFX_PointF& point, uint32_t nFlag) {
CPDFSDK_Annot::ObservedPtr pAnnot(GetFXWidgetAtPoint(point));
if (!pAnnot)
return false;
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
bool ok = pAnnotHandlerMgr->Annot_OnRButtonDown(this, &pAnnot, nFlag, point);
if (!pAnnot)
return false;
if (ok)
m_pFormFillEnv->SetFocusAnnot(&pAnnot);
return true;
}
bool CPDFSDK_PageView::OnRButtonUp(const CFX_PointF& point, uint32_t nFlag) {
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
CPDFSDK_Annot::ObservedPtr pFXAnnot(GetFXWidgetAtPoint(point));
if (!pFXAnnot)
return false;
if (pAnnotHandlerMgr->Annot_OnRButtonUp(this, &pFXAnnot, nFlag, point))
m_pFormFillEnv->SetFocusAnnot(&pFXAnnot);
return true;
}
#endif // PDF_ENABLE_XFA
bool CPDFSDK_PageView::OnLButtonUp(const CFX_PointF& point, uint32_t nFlag) {
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
CPDFSDK_Annot::ObservedPtr pFXAnnot(GetFXWidgetAtPoint(point));
CPDFSDK_Annot::ObservedPtr pFocusAnnot(GetFocusAnnot());
if (pFocusAnnot && pFocusAnnot != pFXAnnot) {
// Last focus Annot gets a chance to handle the event.
if (pAnnotHandlerMgr->Annot_OnLButtonUp(this, &pFocusAnnot, nFlag, point))
return true;
}
return pFXAnnot &&
pAnnotHandlerMgr->Annot_OnLButtonUp(this, &pFXAnnot, nFlag, point);
}
bool CPDFSDK_PageView::OnMouseMove(const CFX_PointF& point, int nFlag) {
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
CPDFSDK_Annot::ObservedPtr pFXAnnot(GetFXAnnotAtPoint(point));
if (m_bOnWidget && m_pCaptureWidget != pFXAnnot)
ExitWidget(pAnnotHandlerMgr, true, nFlag);
if (pFXAnnot) {
if (!m_bOnWidget) {
EnterWidget(pAnnotHandlerMgr, &pFXAnnot, nFlag);
// Annot_OnMouseEnter may have invalidated pFXAnnot.
if (!pFXAnnot) {
ExitWidget(pAnnotHandlerMgr, false, nFlag);
return true;
}
}
pAnnotHandlerMgr->Annot_OnMouseMove(this, &pFXAnnot, nFlag, point);
return true;
}
return false;
}
void CPDFSDK_PageView::EnterWidget(CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr,
CPDFSDK_Annot::ObservedPtr* pAnnot,
uint32_t nFlag) {
m_bOnWidget = true;
m_pCaptureWidget.Reset(pAnnot->Get());
pAnnotHandlerMgr->Annot_OnMouseEnter(this, pAnnot, nFlag);
}
void CPDFSDK_PageView::ExitWidget(CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr,
bool callExitCallback,
uint32_t nFlag) {
m_bOnWidget = false;
if (m_pCaptureWidget) {
if (callExitCallback)
pAnnotHandlerMgr->Annot_OnMouseExit(this, &m_pCaptureWidget, nFlag);
m_pCaptureWidget.Reset();
}
}
bool CPDFSDK_PageView::OnMouseWheel(double deltaX,
double deltaY,
const CFX_PointF& point,
int nFlag) {
CPDFSDK_Annot::ObservedPtr pAnnot(GetFXWidgetAtPoint(point));
if (!pAnnot)
return false;
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
return pAnnotHandlerMgr->Annot_OnMouseWheel(this, &pAnnot, nFlag,
static_cast<int>(deltaY), point);
}
bool CPDFSDK_PageView::OnChar(int nChar, uint32_t nFlag) {
if (CPDFSDK_Annot* pAnnot = GetFocusAnnot()) {
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
return pAnnotHandlerMgr->Annot_OnChar(pAnnot, nChar, nFlag);
}
return false;
}
bool CPDFSDK_PageView::OnKeyDown(int nKeyCode, int nFlag) {
if (CPDFSDK_Annot* pAnnot = GetFocusAnnot()) {
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
return pAnnotHandlerMgr->Annot_OnKeyDown(pAnnot, nKeyCode, nFlag);
}
return false;
}
bool CPDFSDK_PageView::OnKeyUp(int nKeyCode, int nFlag) {
return false;
}
void CPDFSDK_PageView::LoadFXAnnots() {
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
AutoRestorer<bool> lock(&m_bLocked);
m_bLocked = true;
#ifdef PDF_ENABLE_XFA
RetainPtr<CPDFXFA_Page> protector(ToXFAPage(m_page));
if (m_pFormFillEnv->GetXFAContext()->GetFormType() == FormType::kXFAFull) {
CXFA_FFPageView* pageView = protector->GetXFAPageView();
std::unique_ptr<IXFA_WidgetIterator> pWidgetHandler(
pageView->CreateWidgetIterator(
XFA_TRAVERSEWAY_Form,
XFA_WidgetStatus_Visible | XFA_WidgetStatus_Viewable));
if (!pWidgetHandler) {
return;
}
while (CXFA_FFWidget* pXFAAnnot = pWidgetHandler->MoveToNext()) {
CPDFSDK_Annot* pAnnot = pAnnotHandlerMgr->NewAnnot(pXFAAnnot, this);
if (!pAnnot)
continue;
m_SDKAnnotArray.push_back(pAnnot);
pAnnotHandlerMgr->Annot_OnLoad(pAnnot);
}
return;
}
#endif // PDF_ENABLE_XFA
CPDF_Page* pPage = GetPDFPage();
ASSERT(pPage);
bool bUpdateAP = CPDF_InterForm::IsUpdateAPEnabled();
// Disable the default AP construction.
CPDF_InterForm::SetUpdateAP(false);
m_pAnnotList = pdfium::MakeUnique<CPDF_AnnotList>(pPage);
CPDF_InterForm::SetUpdateAP(bUpdateAP);
const size_t nCount = m_pAnnotList->Count();
for (size_t i = 0; i < nCount; ++i) {
CPDF_Annot* pPDFAnnot = m_pAnnotList->GetAt(i);
CheckUnSupportAnnot(GetPDFDocument(), pPDFAnnot);
CPDFSDK_Annot* pAnnot = pAnnotHandlerMgr->NewAnnot(pPDFAnnot, this);
if (!pAnnot)
continue;
m_SDKAnnotArray.push_back(pAnnot);
pAnnotHandlerMgr->Annot_OnLoad(pAnnot);
}
}
void CPDFSDK_PageView::UpdateRects(const std::vector<CFX_FloatRect>& rects) {
for (const auto& rc : rects)
m_pFormFillEnv->Invalidate(m_page, rc.GetOuterRect());
}
void CPDFSDK_PageView::UpdateView(CPDFSDK_Annot* pAnnot) {
CFX_FloatRect rcWindow = pAnnot->GetRect();
m_pFormFillEnv->Invalidate(m_page, rcWindow.GetOuterRect());
}
int CPDFSDK_PageView::GetPageIndex() const {
#ifdef PDF_ENABLE_XFA
auto* pContext = static_cast<CPDFXFA_Context*>(
m_page->AsXFAPage()->GetDocumentExtension());
switch (pContext->GetFormType()) {
case FormType::kXFAFull: {
CXFA_FFPageView* pPageView = m_page->AsXFAPage()->GetXFAPageView();
return pPageView ? pPageView->GetPageIndex() : -1;
}
case FormType::kNone:
case FormType::kAcroForm:
case FormType::kXFAForeground:
break;
}
#endif // PDF_ENABLE_XFA
return GetPageIndexForStaticPDF();
}
bool CPDFSDK_PageView::IsValidAnnot(const CPDF_Annot* p) const {
if (!p)
return false;
const auto& annots = m_pAnnotList->All();
auto it = std::find_if(annots.begin(), annots.end(),
[p](const std::unique_ptr<CPDF_Annot>& annot) {
return annot.get() == p;
});
return it != annots.end();
}
bool CPDFSDK_PageView::IsValidSDKAnnot(const CPDFSDK_Annot* p) const {
if (!p)
return false;
return pdfium::ContainsValue(m_SDKAnnotArray, p);
}
CPDFSDK_Annot* CPDFSDK_PageView::GetFocusAnnot() {
CPDFSDK_Annot* pFocusAnnot = m_pFormFillEnv->GetFocusAnnot();
return IsValidSDKAnnot(pFocusAnnot) ? pFocusAnnot : nullptr;
}
int CPDFSDK_PageView::GetPageIndexForStaticPDF() const {
const CPDF_Dictionary* pDict = GetPDFPage()->GetDict();
CPDF_Document* pDoc = m_pFormFillEnv->GetPDFDocument();
return (pDoc && pDict) ? pDoc->GetPageIndex(pDict->GetObjNum()) : -1;
}