blob: d7f5cb5e0a2c42bf763bab9f21c16698d8fead16 [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_dictionary.h"
#include "core/fpdfapi/parser/cpdf_document.h"
#include "core/fpdfapi/render/cpdf_renderoptions.h"
#include "core/fpdfdoc/cpdf_annotlist.h"
#include "core/fpdfdoc/cpdf_interactiveform.h"
#include "core/fxcrt/autorestorer.h"
#include "fpdfsdk/cpdfsdk_annot.h"
#include "fpdfsdk/cpdfsdk_annotiteration.h"
#include "fpdfsdk/cpdfsdk_formfillenvironment.h"
#include "fpdfsdk/cpdfsdk_helpers.h"
#include "fpdfsdk/cpdfsdk_interactiveform.h"
#include "third_party/base/ptr_util.h"
#include "third_party/base/stl_util.h"
#ifdef PDF_ENABLE_XFA
#include "fpdfsdk/fpdfxfa/cpdfxfa_page.h"
#include "fpdfsdk/fpdfxfa/cpdfxfa_widget.h"
#include "xfa/fxfa/cxfa_ffdocview.h"
#include "xfa/fxfa/cxfa_ffpageview.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_InteractiveForm* pForm = pFormFillEnv->GetInteractiveForm();
CPDF_InteractiveForm* pPDFForm = pForm->GetInteractiveForm();
pPDFForm->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(pdfium::WrapUnique(pAnnot));
m_SDKAnnotArray.clear();
m_pAnnotList.reset();
}
void CPDFSDK_PageView::PageView_OnDraw(CFX_RenderDevice* pDevice,
const CFX_Matrix& mtUser2Device,
CPDF_RenderOptions* pOptions,
const FX_RECT& pClip) {
m_curMatrix = mtUser2Device;
#ifdef PDF_ENABLE_XFA
IPDF_Page* pPage = GetXFAPage();
CPDF_Document::Extension* pContext =
pPage ? pPage->GetDocument()->GetExtension() : nullptr;
if (pContext && pContext->ContainsExtensionFullForm()) {
static_cast<CPDFXFA_Page*>(pPage)->DrawFocusAnnot(pDevice, GetFocusAnnot(),
mtUser2Device, pClip);
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, mtUser2Device,
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) {
CPDFSDK_Annot* pSDKAnnot = GetAnnotByXFAWidget(pPDFAnnot);
if (pSDKAnnot)
return pSDKAnnot;
CPDFSDK_AnnotHandlerMgr* pAnnotHandler = m_pFormFillEnv->GetAnnotHandlerMgr();
std::unique_ptr<CPDFSDK_Annot> pNewAnnot =
pAnnotHandler->NewXFAAnnot(pPDFAnnot, this);
ASSERT(pNewAnnot);
pSDKAnnot = pNewAnnot.get();
// TODO(thestig): See if |m_SDKAnnotArray|, which takes ownership of
// |pNewAnnot|, can hold std::unique_ptrs instead of raw pointers.
m_SDKAnnotArray.push_back(pNewAnnot.release());
return pSDKAnnot;
}
bool CPDFSDK_PageView::DeleteAnnot(CPDFSDK_Annot* pAnnot) {
IPDF_Page* pPage = pAnnot->GetXFAPage();
if (!pPage)
return false;
CPDF_Document::Extension* pContext = pPage->GetDocument()->GetExtension();
if (pContext && !pContext->ContainsExtensionForm())
return false;
ObservedPtr<CPDFSDK_Annot> 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(pdfium::WrapUnique(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* pWidget) {
if (!pWidget)
return nullptr;
for (CPDFSDK_Annot* pAnnot : m_SDKAnnotArray) {
CPDFXFA_Widget* pCurrentWidget = ToXFAWidget(pAnnot);
if (pCurrentWidget && pCurrentWidget->GetXFAFFWidget() == pWidget)
return pAnnot;
}
return nullptr;
}
IPDF_Page* CPDFSDK_PageView::GetXFAPage() {
return ToXFAPage(m_page);
}
#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::SelectAllText() {
CPDFSDK_Annot* annot = GetFocusAnnot();
if (!annot)
return false;
CPDFSDK_AnnotHandlerMgr* handler = m_pFormFillEnv->GetAnnotHandlerMgr();
return handler->Annot_SelectAllText(annot);
}
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(uint32_t nFlag, const CFX_PointF& point) {
ObservedPtr<CPDFSDK_Annot> pAnnot(GetFXWidgetAtPoint(point));
if (!pAnnot) {
m_pFormFillEnv->KillFocusAnnot(nFlag);
return false;
}
m_pFormFillEnv->SetFocusAnnot(&pAnnot);
return true;
}
bool CPDFSDK_PageView::OnLButtonDown(uint32_t nFlag, const CFX_PointF& point) {
ObservedPtr<CPDFSDK_Annot> 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;
}
bool CPDFSDK_PageView::OnLButtonUp(uint32_t nFlag, const CFX_PointF& point) {
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
ObservedPtr<CPDFSDK_Annot> pFXAnnot(GetFXWidgetAtPoint(point));
ObservedPtr<CPDFSDK_Annot> 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::OnLButtonDblClk(uint32_t nFlag,
const CFX_PointF& point) {
ObservedPtr<CPDFSDK_Annot> pAnnot(GetFXWidgetAtPoint(point));
if (!pAnnot) {
m_pFormFillEnv->KillFocusAnnot(nFlag);
return false;
}
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
if (!pAnnotHandlerMgr->Annot_OnLButtonDblClk(this, &pAnnot, nFlag, point))
return false;
if (!pAnnot)
return false;
m_pFormFillEnv->SetFocusAnnot(&pAnnot);
return true;
}
bool CPDFSDK_PageView::OnRButtonDown(uint32_t nFlag, const CFX_PointF& point) {
ObservedPtr<CPDFSDK_Annot> 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(uint32_t nFlag, const CFX_PointF& point) {
ObservedPtr<CPDFSDK_Annot> pAnnot(GetFXWidgetAtPoint(point));
if (!pAnnot)
return false;
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
bool ok = pAnnotHandlerMgr->Annot_OnRButtonUp(this, &pAnnot, nFlag, point);
if (!pAnnot)
return false;
if (ok)
m_pFormFillEnv->SetFocusAnnot(&pAnnot);
return true;
}
bool CPDFSDK_PageView::OnMouseMove(int nFlag, const CFX_PointF& point) {
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
ObservedPtr<CPDFSDK_Annot> pFXAnnot(GetFXAnnotAtPoint(point));
ObservedPtr<CPDFSDK_PageView> pThis(this);
if (m_bOnWidget && m_pCaptureWidget != pFXAnnot)
ExitWidget(pAnnotHandlerMgr, true, nFlag);
// ExitWidget() may have invalidated objects.
if (!pThis || !pFXAnnot)
return false;
if (!m_bOnWidget) {
EnterWidget(pAnnotHandlerMgr, &pFXAnnot, nFlag);
// EnterWidget() may have invalidated objects.
if (!pThis)
return false;
if (!pFXAnnot) {
ExitWidget(pAnnotHandlerMgr, false, nFlag);
return true;
}
}
pAnnotHandlerMgr->Annot_OnMouseMove(this, &pFXAnnot, nFlag, point);
return true;
}
void CPDFSDK_PageView::EnterWidget(CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr,
ObservedPtr<CPDFSDK_Annot>* 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)
return;
if (callExitCallback) {
ObservedPtr<CPDFSDK_PageView> pThis(this);
pAnnotHandlerMgr->Annot_OnMouseExit(this, &m_pCaptureWidget, nFlag);
// Annot_OnMouseExit() may have invalidated |this|.
if (!pThis)
return;
}
m_pCaptureWidget.Reset();
}
bool CPDFSDK_PageView::OnMouseWheel(int nFlag,
const CFX_PointF& point,
const CFX_Vector& delta) {
ObservedPtr<CPDFSDK_Annot> pAnnot(GetFXWidgetAtPoint(point));
if (!pAnnot)
return false;
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
return pAnnotHandlerMgr->Annot_OnMouseWheel(this, &pAnnot, nFlag, point,
delta);
}
bool CPDFSDK_PageView::SetIndexSelected(int index, bool selected) {
if (CPDFSDK_Annot* pAnnot = GetFocusAnnot()) {
ObservedPtr<CPDFSDK_Annot> pAnnotObserved(pAnnot);
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
return pAnnotHandlerMgr->Annot_SetIndexSelected(&pAnnotObserved, index,
selected);
}
return false;
}
bool CPDFSDK_PageView::IsIndexSelected(int index) {
if (CPDFSDK_Annot* pAnnot = GetFocusAnnot()) {
ObservedPtr<CPDFSDK_Annot> pAnnotObserved(pAnnot);
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
return pAnnotHandlerMgr->Annot_IsIndexSelected(&pAnnotObserved, index);
}
return false;
}
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) {
CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
m_pFormFillEnv->GetAnnotHandlerMgr();
return pAnnotHandlerMgr->Annot_OnKeyDown(this, GetFocusAnnot(), nKeyCode,
nFlag);
}
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));
CPDF_Document::Extension* pContext = m_pFormFillEnv->GetDocExtension();
if (pContext && pContext->ContainsExtensionFullForm()) {
CXFA_FFPageView* pageView = protector->GetXFAPageView();
IXFA_WidgetIterator* pWidgetHandler =
pageView->CreateGCedFormWidgetIterator(XFA_WidgetStatus_Visible |
XFA_WidgetStatus_Viewable);
while (CXFA_FFWidget* pXFAAnnot = pWidgetHandler->MoveToNext()) {
std::unique_ptr<CPDFSDK_Annot> pNewAnnot =
pAnnotHandlerMgr->NewXFAAnnot(pXFAAnnot, this);
ASSERT(pNewAnnot);
CPDFSDK_Annot* pAnnot = pNewAnnot.get();
m_SDKAnnotArray.push_back(pNewAnnot.release());
pAnnotHandlerMgr->Annot_OnLoad(pAnnot);
}
return;
}
#endif // PDF_ENABLE_XFA
CPDF_Page* pPage = GetPDFPage();
ASSERT(pPage);
bool bUpdateAP = CPDF_InteractiveForm::IsUpdateAPEnabled();
// Disable the default AP construction.
CPDF_InteractiveForm::SetUpdateAP(false);
m_pAnnotList = std::make_unique<CPDF_AnnotList>(pPage);
CPDF_InteractiveForm::SetUpdateAP(bUpdateAP);
const size_t nCount = m_pAnnotList->Count();
for (size_t i = 0; i < nCount; ++i) {
CPDF_Annot* pPDFAnnot = m_pAnnotList->GetAt(i);
CheckForUnsupportedAnnot(pPDFAnnot);
std::unique_ptr<CPDFSDK_Annot> pAnnot =
pAnnotHandlerMgr->NewAnnot(pPDFAnnot, this);
if (!pAnnot)
continue;
m_SDKAnnotArray.push_back(pAnnot.release());
pAnnotHandlerMgr->Annot_OnLoad(m_SDKAnnotArray.back());
}
}
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
CPDF_Document::Extension* pContext = m_page->GetDocument()->GetExtension();
if (pContext && pContext->ContainsExtensionFullForm()) {
CXFA_FFPageView* pPageView = m_page->AsXFAPage()->GetXFAPageView();
return pPageView ? pPageView->GetLayoutItem()->GetPageIndex() : -1;
}
#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::Contains(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->GetPageIndex(pDict->GetObjNum());
}