Cleanup some CPDFSDK_PageView annotation code.

fpdfsdk/cpdfsdk_pageview.cpp

 // 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>
@@ skipping 49 matching lines @@
 CPDFSDK_PageView::~CPDFSDK_PageView() {
 #ifndef PDF_ENABLE_XFA
   // 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->SetView(nullptr);
 #endif  // PDF_ENABLE_XFA
 
   CPDFSDK_Environment* pEnv = m_pSDKDoc->GetEnv();
   CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
-  for (CPDFSDK_Annot* pAnnot : m_fxAnnotArray)
+  for (CPDFSDK_Annot* pAnnot : m_SDKAnnotArray)
     pAnnotHandlerMgr->ReleaseAnnot(pAnnot);
 
-  m_fxAnnotArray.clear();
+  m_SDKAnnotArray.clear();
   m_pAnnotList.reset();
 
 #ifndef PDF_ENABLE_XFA
   if (m_bOwnsPage)
     delete m_page;
 #endif  // PDF_ENABLE_XFA
 }
 
 void CPDFSDK_PageView::PageView_OnDraw(CFX_RenderDevice* pDevice,
                                        CFX_Matrix* pUser2Device,
@@ skipping 42 matching lines @@
 
   // for pdf/static xfa.
   CPDFSDK_AnnotIterator annotIterator(this, true);
   while (CPDFSDK_Annot* pSDKAnnot = annotIterator.Next()) {
     CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
     pAnnotHandlerMgr->Annot_OnDraw(this, pSDKAnnot, pDevice, pUser2Device,
                                    pOptions->m_bDrawAnnots);
   }
 }
 
-const CPDF_Annot* CPDFSDK_PageView::GetPDFAnnotAtPoint(FX_FLOAT pageX,
-                                                       FX_FLOAT pageY) {
-  for (const auto& pAnnot : m_pAnnotList->All()) {
-    CFX_FloatRect annotRect = pAnnot->GetRect();
-    if (annotRect.Contains(pageX, pageY))
-      return pAnnot.get();
-  }
-  return nullptr;
-}
-
-const CPDF_Annot* CPDFSDK_PageView::GetPDFWidgetAtPoint(FX_FLOAT pageX,
-                                                        FX_FLOAT pageY) {
-  for (const auto& pAnnot : m_pAnnotList->All()) {
-    if (pAnnot->GetSubtype() == CPDF_Annot::Subtype::WIDGET) {
-      CFX_FloatRect annotRect = pAnnot->GetRect();
-      if (annotRect.Contains(pageX, pageY))
-        return pAnnot.get();
-    }
-  }
-  return nullptr;
-}
-
 CPDFSDK_Annot* CPDFSDK_PageView::GetFXAnnotAtPoint(FX_FLOAT pageX,
                                                    FX_FLOAT pageY) {
   CPDFSDK_Environment* pEnv = m_pSDKDoc->GetEnv();
   CPDFSDK_AnnotHandlerMgr* pAnnotMgr = pEnv->GetAnnotHandlerMgr();
   CPDFSDK_AnnotIterator annotIterator(this, false);
   while (CPDFSDK_Annot* pSDKAnnot = annotIterator.Next()) {
     CFX_FloatRect rc = pAnnotMgr->Annot_OnGetViewBBox(this, pSDKAnnot);
     if (pSDKAnnot->GetAnnotSubtype() == CPDF_Annot::Subtype::POPUP)
       continue;
     if (rc.Contains(pageX, pageY))
@@ skipping 18 matching lines @@
       pAnnotMgr->Annot_OnGetViewBBox(this, pSDKAnnot);
       CFX_FloatPoint point(pageX, pageY);
       if (pAnnotMgr->Annot_OnHitTest(this, pSDKAnnot, point))
         return pSDKAnnot;
     }
   }
 
   return nullptr;
 }
 
-void CPDFSDK_PageView::KillFocusAnnotIfNeeded() {
-  // if there is a focused annot on the page, we should kill the focus first.
-  if (CPDFSDK_Annot* focusedAnnot = m_pSDKDoc->GetFocusAnnot()) {
-    if (pdfium::ContainsValue(m_fxAnnotArray, focusedAnnot))
-      KillFocusAnnot();
-  }
-}
-
-CPDFSDK_Annot* CPDFSDK_PageView::AddAnnot(CPDF_Annot* pPDFAnnot) {
-  CPDFSDK_Environment* pEnv = m_pSDKDoc->GetEnv();
-  ASSERT(pEnv);
-  CPDFSDK_AnnotHandlerMgr* pAnnotHandler = pEnv->GetAnnotHandlerMgr();
-  CPDFSDK_Annot* pSDKAnnot = pAnnotHandler->NewAnnot(pPDFAnnot, this);
-  if (!pSDKAnnot)
-    return nullptr;
-
-  m_fxAnnotArray.push_back(pSDKAnnot);
-  pAnnotHandler->Annot_OnCreate(pSDKAnnot);
-  return pSDKAnnot;
-}
-
 #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_Environment* pEnv = m_pSDKDoc->GetEnv();
   CPDFSDK_AnnotHandlerMgr* pAnnotHandler = pEnv->GetAnnotHandlerMgr();
   pSDKAnnot = pAnnotHandler->NewAnnot(pPDFAnnot, this);
   if (!pSDKAnnot)
     return nullptr;
 
-  m_fxAnnotArray.push_back(pSDKAnnot);
+  m_SDKAnnotArray.push_back(pSDKAnnot);
   return pSDKAnnot;
 }
-#endif  // PDF_ENABLE_XFA
-
-CPDFSDK_Annot* CPDFSDK_PageView::AddAnnot(CPDF_Dictionary* pDict) {
-  return pDict ? AddAnnot(pDict->GetStringFor("Subtype").c_str(), pDict)
-               : nullptr;
-}
-
-CPDFSDK_Annot* CPDFSDK_PageView::AddAnnot(const FX_CHAR* lpSubType,
-                                          CPDF_Dictionary* pDict) {
-  return nullptr;
-}
 
 FX_BOOL CPDFSDK_PageView::DeleteAnnot(CPDFSDK_Annot* pAnnot) {
-#ifdef PDF_ENABLE_XFA
   if (!pAnnot)
     return FALSE;
   CPDFXFA_Page* pPage = pAnnot->GetPDFXFAPage();
   if (!pPage || (pPage->GetDocument()->GetDocType() != DOCTYPE_STATIC_XFA &&
                  pPage->GetDocument()->GetDocType() != DOCTYPE_DYNAMIC_XFA))
     return FALSE;
 
   if (GetFocusAnnot() == pAnnot)
-    KillFocusAnnot();
+    m_pSDKDoc->KillFocusAnnot(0);
   CPDFSDK_Environment* pEnv = m_pSDKDoc->GetEnv();
   CPDFSDK_AnnotHandlerMgr* pAnnotHandler = pEnv->GetAnnotHandlerMgr();
   if (pAnnotHandler)
     pAnnotHandler->ReleaseAnnot(pAnnot);
 
-  auto it = std::find(m_fxAnnotArray.begin(), m_fxAnnotArray.end(), pAnnot);
-  if (it != m_fxAnnotArray.end())
-    m_fxAnnotArray.erase(it);
+  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;
-#else   // PDF_ENABLE_XFA
-  return FALSE;
+}
 #endif  // PDF_ENABLE_XFA
-}
 
 CPDF_Document* CPDFSDK_PageView::GetPDFDocument() {
   if (m_page) {
 #ifdef PDF_ENABLE_XFA
     return m_page->GetDocument()->GetPDFDoc();
 #else   // PDF_ENABLE_XFA
     return m_page->m_pDocument;
 #endif  // PDF_ENABLE_XFA
   }
   return nullptr;
 }
 
 CPDF_Page* CPDFSDK_PageView::GetPDFPage() const {
 #ifdef PDF_ENABLE_XFA
   return m_page ? m_page->GetPDFPage() : nullptr;
 #else   // PDF_ENABLE_XFA
   return m_page;
 #endif  // PDF_ENABLE_XFA
 }
 
-size_t CPDFSDK_PageView::CountAnnots() const {
-  return m_fxAnnotArray.size();
-}
-
-CPDFSDK_Annot* CPDFSDK_PageView::GetAnnot(size_t nIndex) {
-  return nIndex < m_fxAnnotArray.size() ? m_fxAnnotArray[nIndex] : nullptr;
-}
-
 CPDFSDK_Annot* CPDFSDK_PageView::GetAnnotByDict(CPDF_Dictionary* pDict) {
-  for (CPDFSDK_Annot* pAnnot : m_fxAnnotArray) {
+  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_fxAnnotArray) {
+  for (CPDFSDK_Annot* pAnnot : m_SDKAnnotArray) {
     if (pAnnot->GetXFAWidget() == hWidget)
       return pAnnot;
   }
   return nullptr;
 }
 #endif  // PDF_ENABLE_XFA
 
 FX_BOOL CPDFSDK_PageView::OnLButtonDown(const CFX_FloatPoint& point,
                                         uint32_t nFlag) {
   CPDFSDK_Annot::ObservedPtr pAnnot(GetFXWidgetAtPoint(point.x, point.y));
   if (!pAnnot) {
-    KillFocusAnnot(nFlag);
+    m_pSDKDoc->KillFocusAnnot(nFlag);
     return FALSE;
   }
 
   CPDFSDK_Environment* pEnv = m_pSDKDoc->GetEnv();
   CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
   if (!pAnnotHandlerMgr->Annot_OnLButtonDown(this, &pAnnot, nFlag, point))
     return FALSE;
 
   if (!pAnnot)
     return FALSE;
 
-  SetFocusAnnot(&pAnnot);
+  m_pSDKDoc->SetFocusAnnot(&pAnnot);
   return TRUE;
 }
 
 #ifdef PDF_ENABLE_XFA
 FX_BOOL CPDFSDK_PageView::OnRButtonDown(const CFX_FloatPoint& point,
                                         uint32_t nFlag) {
   CPDFSDK_Annot::ObservedPtr pAnnot(GetFXWidgetAtPoint(point.x, point.y));
   if (!pAnnot)
     return FALSE;
 
   CPDFSDK_Environment* pEnv = m_pSDKDoc->GetEnv();
   CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
   FX_BOOL ok =
       pAnnotHandlerMgr->Annot_OnRButtonDown(this, &pAnnot, nFlag, point);
   if (!pAnnot)
     return FALSE;
 
   if (ok)
-    SetFocusAnnot(&pAnnot);
+    m_pSDKDoc->SetFocusAnnot(&pAnnot);
 
   return TRUE;
 }
 
 FX_BOOL CPDFSDK_PageView::OnRButtonUp(const CFX_FloatPoint& point,
                                       uint32_t nFlag) {
   CPDFSDK_Environment* pEnv = m_pSDKDoc->GetEnv();
   CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
   CPDFSDK_Annot::ObservedPtr pFXAnnot(GetFXWidgetAtPoint(point.x, point.y));
   if (!pFXAnnot)
     return FALSE;
 
   if (pAnnotHandlerMgr->Annot_OnRButtonUp(this, &pFXAnnot, nFlag, point))
-    SetFocusAnnot(&pFXAnnot);
+    m_pSDKDoc->SetFocusAnnot(&pFXAnnot);
 
   return TRUE;
 }
 #endif  // PDF_ENABLE_XFA
 
 FX_BOOL CPDFSDK_PageView::OnLButtonUp(const CFX_FloatPoint& point,
                                       uint32_t nFlag) {
   CPDFSDK_Environment* pEnv = m_pSDKDoc->GetEnv();
   CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
   CPDFSDK_Annot::ObservedPtr pFXAnnot(GetFXWidgetAtPoint(point.x, point.y));
@@ skipping 92 matching lines @@
             XFA_WidgetStatus_Visible | XFA_WidgetStatus_Viewable));
     if (!pWidgetHander) {
       SetLock(FALSE);
       return;
     }
 
     while (CXFA_FFWidget* pXFAAnnot = pWidgetHander->MoveToNext()) {
       CPDFSDK_Annot* pAnnot = pAnnotHandlerMgr->NewAnnot(pXFAAnnot, this);
       if (!pAnnot)
         continue;
-      m_fxAnnotArray.push_back(pAnnot);
+      m_SDKAnnotArray.push_back(pAnnot);
       pAnnotHandlerMgr->Annot_OnLoad(pAnnot);
     }
 
     SetLock(FALSE);
     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_fxAnnotArray.push_back(pAnnot);
+    m_SDKAnnotArray.push_back(pAnnot);
     pAnnotHandlerMgr->Annot_OnLoad(pAnnot);
   }
 
   SetLock(FALSE);
 }
 
 void CPDFSDK_PageView::UpdateRects(const std::vector<CFX_FloatRect>& rects) {
   CPDFSDK_Environment* pEnv = m_pSDKDoc->GetEnv();
   for (const auto& rc : rects)
     pEnv->Invalidate(m_page, rc.left, rc.top, rc.right, rc.bottom);
@@ skipping 33 matching lines @@
     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_pSDKDoc->GetFocusAnnot();
-  if (!pFocusAnnot)
-    return nullptr;
-
-  for (CPDFSDK_Annot* pAnnot : m_fxAnnotArray) {
-    if (pAnnot == pFocusAnnot)
-      return pAnnot;
-  }
-  return nullptr;
+  return IsValidSDKAnnot(pFocusAnnot) ? pFocusAnnot : nullptr;
 }
 
 int CPDFSDK_PageView::GetPageIndexForStaticPDF() const {
   CPDF_Dictionary* pDict = GetPDFPage()->m_pFormDict;
   CPDF_Document* pDoc = m_pSDKDoc->GetPDFDocument();
   return (pDoc && pDict) ? pDoc->GetPageIndex(pDict->GetObjNum()) : -1;
 }