fpdfsdk/ differences with XFA (for didactic purposes only).

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"
 
 #include "fpdfsdk/include/formfiller/FFL_FormFiller.h"
 #include "fpdfsdk/include/fsdk_define.h"
 #include "fpdfsdk/include/javascript/IJavaScript.h"
 #include "public/fpdf_ext.h"
 #include "third_party/base/nonstd_unique_ptr.h"
 
+#ifdef PDF_ENABLE_XFA
+#include "../include/fpdfxfa/fpdfxfa_app.h"
+#include "../include/fpdfxfa/fpdfxfa_doc.h"
+#include "../include/fpdfxfa/fpdfxfa_page.h"
+#include "../include/fpdfxfa/fpdfxfa_util.h"
+
+#endif
 #if _FX_OS_ == _FX_ANDROID_
 #include "time.h"
 #else
 #include <ctime>
 #endif
 
 class CFX_SystemHandler : public IFX_SystemHandler {
  public:
   explicit CFX_SystemHandler(CPDFDoc_Environment* pEnv)
       : m_pEnv(pEnv), m_nCharSet(-1) {}
@@ skipping 173 matching lines @@
   return m_pEnv->FFI_GetLocalTime();
 }
 
 CPDFDoc_Environment::CPDFDoc_Environment(UnderlyingDocumentType* pDoc,
                                          FPDF_FORMFILLINFO* pFFinfo)
     : m_pInfo(pFFinfo), m_pSDKDoc(NULL), m_pUnderlyingDoc(pDoc) {
   m_pSysHandler.reset(new CFX_SystemHandler(this));
 }
 
 CPDFDoc_Environment::~CPDFDoc_Environment() {
+#ifdef PDF_ENABLE_XFA
+  CPDFXFA_App* pProvider = CPDFXFA_App::GetInstance();
+  if (pProvider->m_pEnvList.GetSize() == 0)
+    pProvider->SetJavaScriptInitialized(FALSE);
+#endif
 }
 
 int CPDFDoc_Environment::JS_appAlert(const FX_WCHAR* Msg,
                                      const FX_WCHAR* Title,
                                      FX_UINT Type,
                                      FX_UINT Icon) {
   if (m_pInfo && m_pInfo->m_pJsPlatform && m_pInfo->m_pJsPlatform->app_alert) {
     CFX_ByteString bsMsg = CFX_WideString(Msg).UTF16LE_Encode();
     CFX_ByteString bsTitle = CFX_WideString(Title).UTF16LE_Encode();
     FPDF_WIDESTRING pMsg = (FPDF_WIDESTRING)bsMsg.GetBuffer(bsMsg.GetLength());
@@ skipping 303 matching lines @@
     return TRUE;
 
   if (m_pFocusAnnot) {
     if (!KillFocusAnnot(nFlag))
       return FALSE;
   }
 
   if (!pAnnot)
     return FALSE;
 
+#ifdef PDF_ENABLE_XFA
+  CPDFSDK_Annot* pLastFocusAnnot = m_pFocusAnnot;
+#endif
   CPDFSDK_PageView* pPageView = pAnnot->GetPageView();
   if (pPageView && pPageView->IsValid()) {
     CPDFSDK_AnnotHandlerMgr* pAnnotHandler = m_pEnv->GetAnnotHandlerMgr();
     if (!m_pFocusAnnot) {
+#ifdef PDF_ENABLE_XFA
+      if (!pAnnotHandler->Annot_OnChangeFocus(pAnnot, pLastFocusAnnot))
+        return FALSE;
+
+#endif
       if (!pAnnotHandler->Annot_OnSetFocus(pAnnot, nFlag))
         return FALSE;
       if (!m_pFocusAnnot) {
         m_pFocusAnnot = pAnnot;
         return TRUE;
       }
     }
   }
   return FALSE;
 }
 
 FX_BOOL CPDFSDK_Document::KillFocusAnnot(FX_UINT nFlag) {
   if (m_pFocusAnnot) {
     CPDFSDK_AnnotHandlerMgr* pAnnotHandler = m_pEnv->GetAnnotHandlerMgr();
     CPDFSDK_Annot* pFocusAnnot = m_pFocusAnnot;
     m_pFocusAnnot = nullptr;
+#ifdef PDF_ENABLE_XFA
+
+    if (!pAnnotHandler->Annot_OnChangeFocus(nullptr, pFocusAnnot))
+      return FALSE;
+
+#endif
     if (pAnnotHandler->Annot_OnKillFocus(pFocusAnnot, nFlag)) {
       if (pFocusAnnot->GetType() == FX_BSTRC("Widget")) {
         CPDFSDK_Widget* pWidget = (CPDFSDK_Widget*)pFocusAnnot;
         int nFieldType = pWidget->GetFieldType();
         if (FIELDTYPE_TEXTFIELD == nFieldType ||
             FIELDTYPE_COMBOBOX == nFieldType) {
           m_pEnv->FFI_OnSetFieldInputFocus(NULL, NULL, 0, FALSE);
         }
       }
 
@@ skipping 26 matching lines @@
 
 CPDFSDK_PageView::CPDFSDK_PageView(CPDFSDK_Document* pSDKDoc,
                                    UnderlyingPageType* page)
     : m_page(page),
       m_pSDKDoc(pSDKDoc),
       m_CaptureWidget(nullptr),
       m_bEnterWidget(FALSE),
       m_bExitWidget(FALSE),
       m_bOnWidget(FALSE),
       m_bValid(FALSE),
+#ifndef PDF_ENABLE_XFA
       m_bLocked(FALSE),
       m_bTakeOverPage(FALSE) {
+#else
+      m_bLocked(FALSE) {
+#endif
   CPDFSDK_InterForm* pInterForm = pSDKDoc->GetInterForm();
   if (pInterForm) {
     CPDF_InterForm* pPDFInterForm = pInterForm->GetInterForm();
+#ifndef PDF_ENABLE_XFA
     pPDFInterForm->FixPageFields(page);
+#else
+    if (page->GetPDFPage())
+      pPDFInterForm->FixPageFields(page->GetPDFPage());
+#endif
   }
+#ifndef PDF_ENABLE_XFA
   m_page->SetPrivateData((void*)m_page, (void*)this, nullptr);
+#endif
 }
 
 CPDFSDK_PageView::~CPDFSDK_PageView() {
   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
   CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
   for (CPDFSDK_Annot* pAnnot : m_fxAnnotArray)
     pAnnotHandlerMgr->ReleaseAnnot(pAnnot);
   m_fxAnnotArray.clear();
 
   m_pAnnotList.reset();
+#ifndef PDF_ENABLE_XFA
 
   m_page->RemovePrivateData((void*)m_page);
   if (m_bTakeOverPage) {
     delete m_page;
   }
+#endif
 }
 
 void CPDFSDK_PageView::PageView_OnDraw(CFX_RenderDevice* pDevice,
                                        CPDF_Matrix* pUser2Device,
+#ifndef PDF_ENABLE_XFA
                                        CPDF_RenderOptions* pOptions) {
+#else
+                                       CPDF_RenderOptions* pOptions,
+                                       const FX_RECT& pClip) {
+#endif
   m_curMatrix = *pUser2Device;
   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
+#ifdef PDF_ENABLE_XFA
+  CPDFXFA_Page* pPage = GetPDFXFAPage();
+  if (pPage == NULL)
+    return;
+
+#ifdef PDF_ENABLE_XFA
+  if (pPage->GetDocument()->GetDocType() == DOCTYPE_DYNAMIC_XFA) {
+    CFX_Graphics gs;
+    gs.Create(pDevice);
+    CFX_RectF rectClip;
+    rectClip.Set(static_cast<FX_FLOAT>(pClip.left),
+                 static_cast<FX_FLOAT>(pClip.top),
+                 static_cast<FX_FLOAT>(pClip.Width()),
+                 static_cast<FX_FLOAT>(pClip.Height()));
+    gs.SetClipRect(rectClip);
+    IXFA_RenderContext* pRenderContext = XFA_RenderContext_Create();
+    if (!pRenderContext)
+      return;
+    CXFA_RenderOptions renderOptions;
+    renderOptions.m_bHighlight = TRUE;
+    pRenderContext->StartRender(pPage->GetXFAPageView(), &gs, *pUser2Device,
+                                renderOptions);
+    pRenderContext->DoRender();
+    pRenderContext->StopRender();
+    pRenderContext->Release();
+    return;
+  }
+#endif  // PDF_ENABLE_XFA
+
+  // for pdf/static xfa.
+#endif
   CPDFSDK_AnnotIterator annotIterator(this, true);
   while (CPDFSDK_Annot* pSDKAnnot = annotIterator.Next()) {
     CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
     pAnnotHandlerMgr->Annot_OnDraw(this, pSDKAnnot, pDevice, pUser2Device, 0);
   }
 }
 
 const CPDF_Annot* CPDFSDK_PageView::GetPDFAnnotAtPoint(FX_FLOAT pageX,
                                                        FX_FLOAT pageY) {
   for (const CPDF_Annot* pAnnot : m_pAnnotList->All()) {
@@ skipping 31 matching lines @@
 
   return nullptr;
 }
 
 CPDFSDK_Annot* CPDFSDK_PageView::GetFXWidgetAtPoint(FX_FLOAT pageX,
                                                     FX_FLOAT pageY) {
   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
   CPDFSDK_AnnotHandlerMgr* pAnnotMgr = pEnv->GetAnnotHandlerMgr();
   CPDFSDK_AnnotIterator annotIterator(this, false);
   while (CPDFSDK_Annot* pSDKAnnot = annotIterator.Next()) {
+#ifndef PDF_ENABLE_XFA
     if (pSDKAnnot->GetType() == "Widget") {
+#else
+    bool bHitTest = pSDKAnnot->GetType() == "Widget";
+    bHitTest = bHitTest || pSDKAnnot->GetType() == FSDK_XFAWIDGET_TYPENAME;
+    if (bHitTest) {
+#endif
       pAnnotMgr->Annot_OnGetViewBBox(this, pSDKAnnot);
       CPDF_Point point(pageX, pageY);
       if (pAnnotMgr->Annot_OnHitTest(this, pSDKAnnot, point))
         return pSDKAnnot;
     }
   }
 
   return nullptr;
 }
 
@@ skipping 20 matching lines @@
   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(IXFA_Widget* pPDFAnnot) {
+  if (!pPDFAnnot)
+    return nullptr;
+
+  CPDFSDK_Annot* pSDKAnnot = GetAnnotByXFAWidget(pPDFAnnot);
+  if (pSDKAnnot)
+    return pSDKAnnot;
+
+  CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
+  CPDFSDK_AnnotHandlerMgr* pAnnotHandler = pEnv->GetAnnotHandlerMgr();
+  pSDKAnnot = pAnnotHandler->NewAnnot(pPDFAnnot, this);
+  if (!pSDKAnnot)
+    return nullptr;
+
+  m_fxAnnotArray.push_back(pSDKAnnot);
+  return pSDKAnnot;
+}
+
+#endif
 CPDFSDK_Annot* CPDFSDK_PageView::AddAnnot(CPDF_Dictionary* pDict) {
   return pDict ? AddAnnot(pDict->GetString("Subtype"), pDict) : nullptr;
 }
 
 CPDFSDK_Annot* CPDFSDK_PageView::AddAnnot(const FX_CHAR* lpSubType,
                                           CPDF_Dictionary* pDict) {
   return NULL;
 }
 
 FX_BOOL CPDFSDK_PageView::DeleteAnnot(CPDFSDK_Annot* pAnnot) {
+#ifndef PDF_ENABLE_XFA
   return FALSE;
+#else
+  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;
+
+  auto it = std::find(m_fxAnnotArray.begin(), m_fxAnnotArray.end(), pAnnot);
+  if (it != m_fxAnnotArray.end())
+    m_fxAnnotArray.erase(it);
+  if (m_CaptureWidget == pAnnot)
+    m_CaptureWidget = nullptr;
+
+  return TRUE;
+#endif
 }
 
 CPDF_Document* CPDFSDK_PageView::GetPDFDocument() {
   if (m_page) {
+#ifndef PDF_ENABLE_XFA
     return m_page->m_pDocument;
+#else
+    return m_page->GetDocument()->GetPDFDoc();
   }
   return NULL;
 }
+
+CPDF_Page* CPDFSDK_PageView::GetPDFPage() {
+  if (m_page) {
+    return m_page->GetPDFPage();
+#endif
+  }
+  return NULL;
+}
 
 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) {
     if (pAnnot->GetPDFAnnot()->GetAnnotDict() == pDict)
       return pAnnot;
   }
   return nullptr;
 }
+#ifdef PDF_ENABLE_XFA
+CPDFSDK_Annot* CPDFSDK_PageView::GetAnnotByXFAWidget(IXFA_Widget* hWidget) {
+  if (!hWidget)
+    return nullptr;
+
+  for (CPDFSDK_Annot* pAnnot : m_fxAnnotArray) {
+    if (pAnnot->GetXFAWidget() == hWidget)
+      return pAnnot;
+  }
+  return nullptr;
+}
+#endif
 
 FX_BOOL CPDFSDK_PageView::OnLButtonDown(const CPDF_Point& point,
                                         FX_UINT nFlag) {
   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
   ASSERT(pEnv);
   CPDFSDK_Annot* pFXAnnot = GetFXWidgetAtPoint(point.x, point.y);
   if (!pFXAnnot) {
     KillFocusAnnot(nFlag);
     return FALSE;
   }
 
   CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
   FX_BOOL bRet =
       pAnnotHandlerMgr->Annot_OnLButtonDown(this, pFXAnnot, nFlag, point);
   if (bRet)
     SetFocusAnnot(pFXAnnot);
   return bRet;
 }
 
+#ifdef PDF_ENABLE_XFA
+FX_BOOL CPDFSDK_PageView::OnRButtonDown(const CPDF_Point& point,
+                                        FX_UINT nFlag) {
+  CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
+  ASSERT(pEnv);
+  CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
+  ASSERT(pAnnotHandlerMgr);
+
+  CPDFSDK_Annot* pFXAnnot = GetFXWidgetAtPoint(point.x, point.y);
+
+  if (pFXAnnot == NULL)
+    return FALSE;
+
+  FX_BOOL bRet =
+      pAnnotHandlerMgr->Annot_OnRButtonDown(this, pFXAnnot, nFlag, point);
+  if (bRet) {
+    SetFocusAnnot(pFXAnnot);
+  }
+  return TRUE;
+}
+
+FX_BOOL CPDFSDK_PageView::OnRButtonUp(const CPDF_Point& point, FX_UINT nFlag) {
+  CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
+  ASSERT(pEnv);
+  CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
+
+  CPDFSDK_Annot* pFXAnnot = GetFXWidgetAtPoint(point.x, point.y);
+
+  if (pFXAnnot == NULL)
+    return FALSE;
+
+  FX_BOOL bRet =
+      pAnnotHandlerMgr->Annot_OnRButtonUp(this, pFXAnnot, nFlag, point);
+  if (bRet) {
+    SetFocusAnnot(pFXAnnot);
+  }
+  return TRUE;
+}
+
+#endif
 FX_BOOL CPDFSDK_PageView::OnLButtonUp(const CPDF_Point& point, FX_UINT nFlag) {
   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
   ASSERT(pEnv);
   CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
   CPDFSDK_Annot* pFXAnnot = GetFXWidgetAtPoint(point.x, point.y);
   CPDFSDK_Annot* pFocusAnnot = GetFocusAnnot();
   FX_BOOL bRet = FALSE;
   if (pFocusAnnot && pFocusAnnot != pFXAnnot) {
     // Last focus Annot gets a chance to handle the event.
     bRet = pAnnotHandlerMgr->Annot_OnLButtonUp(this, pFocusAnnot, nFlag, point);
@@ skipping 65 matching lines @@
   }
   return FALSE;
 }
 
 FX_BOOL CPDFSDK_PageView::OnKeyUp(int nKeyCode, int nFlag) {
   return FALSE;
 }
 
 void CPDFSDK_PageView::LoadFXAnnots() {
   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
+#ifdef PDF_ENABLE_XFA
+  CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
+#endif
 
+#ifndef PDF_ENABLE_XFA
   FX_BOOL enableAPUpdate = CPDF_InterForm::UpdatingAPEnabled();
   // Disable the default AP construction.
   CPDF_InterForm::EnableUpdateAP(FALSE);
   m_pAnnotList.reset(new CPDF_AnnotList(m_page));
   CPDF_InterForm::EnableUpdateAP(enableAPUpdate);
   const size_t nCount = m_pAnnotList->Count();
+#endif
   SetLock(TRUE);
+#ifndef PDF_ENABLE_XFA
   for (size_t i = 0; i < nCount; ++i) {
     CPDF_Annot* pPDFAnnot = m_pAnnotList->GetAt(i);
     CPDF_Document* pDoc = GetPDFDocument();
+#else
+  m_page->AddRef();
+  if (m_pSDKDoc->GetXFADocument()->GetDocType() == DOCTYPE_DYNAMIC_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();
+      SetLock(FALSE);
+      return;
+    }
+
+    while (IXFA_Widget* pXFAAnnot = pWidgetHander->MoveToNext()) {
+      CPDFSDK_Annot* pAnnot = pAnnotHandlerMgr->NewAnnot(pXFAAnnot, this);
+      if (!pAnnot)
+        continue;
+
+      m_fxAnnotArray.push_back(pAnnot);
+      pAnnotHandlerMgr->Annot_OnLoad(pAnnot);
+    }
+#endif
+
+#ifndef PDF_ENABLE_XFA
     CheckUnSupportAnnot(pDoc, pPDFAnnot);
+#else
+    pWidgetHander->Release();
+  } else {
+    CPDF_Page* pPage = m_page->GetPDFPage();
+    ASSERT(pPage != NULL);
+#endif
 
+#ifndef PDF_ENABLE_XFA
     CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
     CPDFSDK_Annot* pAnnot = pAnnotHandlerMgr->NewAnnot(pPDFAnnot, this);
     if (!pAnnot)
       continue;
     m_fxAnnotArray.push_back(pAnnot);
+#else
+    FX_BOOL enableAPUpdate = CPDF_InterForm::UpdatingAPEnabled();
+    // Disable the default AP construction.
+    CPDF_InterForm::EnableUpdateAP(FALSE);
+    m_pAnnotList.reset(new CPDF_AnnotList(pPage));
+    CPDF_InterForm::EnableUpdateAP(enableAPUpdate);
 
+    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);
+#endif
+
+#ifndef PDF_ENABLE_XFA
     pAnnotHandlerMgr->Annot_OnLoad(pAnnot);
+#else
+      pAnnotHandlerMgr->Annot_OnLoad(pAnnot);
+    }
+#endif
   }
+#ifdef PDF_ENABLE_XFA
+  m_page->Release();
+#endif
   SetLock(FALSE);
 }
 
 void CPDFSDK_PageView::UpdateRects(CFX_RectArray& rects) {
   for (int i = 0; i < rects.GetSize(); i++) {
     CPDF_Rect rc = rects.GetAt(i);
     CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
     pEnv->FFI_Invalidate(m_page, rc.left, rc.top, rc.right, rc.bottom);
   }
 }
 
 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) {
+#ifndef PDF_ENABLE_XFA
     CPDF_Dictionary* pDic = m_page->m_pFormDict;
+#else
+    CPDF_Dictionary* pDic = m_page->GetPDFPage()->m_pFormDict;
+#endif
     CPDF_Document* pDoc = m_pSDKDoc->GetPDFDocument();
     if (pDoc && pDic) {
       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;
 }