diff --git a/fpdfsdk/cpdfsdk_annothandlermgr.cpp b/fpdfsdk/cpdfsdk_annothandlermgr.cpp
index d79b9ff..e5e0313 100644
--- a/fpdfsdk/cpdfsdk_annothandlermgr.cpp
+++ b/fpdfsdk/cpdfsdk_annothandlermgr.cpp
@@ -325,9 +325,11 @@
     return static_cast<CPDFXFA_Page*>(pPage)->GetNextXFAAnnot(pSDKAnnot, bNext);
   }
 #endif  // PDF_ENABLE_XFA
+  CPDFSDK_FormFillEnvironment* pFormFillEnv =
+      pSDKAnnot->GetPageView()->GetFormFillEnv();
 
   // For PDF annots.
-  CPDFSDK_Widget* pWidget = ToCPDFSDKWidget(pSDKAnnot);
-  CPDFSDK_AnnotIterator ai(pWidget->GetPageView(), pWidget->GetAnnotSubtype());
-  return bNext ? ai.GetNextAnnot(pWidget) : ai.GetPrevAnnot(pWidget);
+  CPDFSDK_AnnotIterator ai(pSDKAnnot->GetPageView(),
+                           pFormFillEnv->GetFocusableAnnotSubtypes());
+  return bNext ? ai.GetNextAnnot(pSDKAnnot) : ai.GetPrevAnnot(pSDKAnnot);
 }
diff --git a/fpdfsdk/cpdfsdk_annotiterator.cpp b/fpdfsdk/cpdfsdk_annotiterator.cpp
index f1919ab..c1db6bb 100644
--- a/fpdfsdk/cpdfsdk_annotiterator.cpp
+++ b/fpdfsdk/cpdfsdk_annotiterator.cpp
@@ -41,8 +41,15 @@
 
 CPDFSDK_AnnotIterator::CPDFSDK_AnnotIterator(CPDFSDK_PageView* pPageView,
                                              CPDF_Annot::Subtype nAnnotSubtype)
+    : CPDFSDK_AnnotIterator(
+          pPageView,
+          std::vector<CPDF_Annot::Subtype>(1, nAnnotSubtype)) {}
+
+CPDFSDK_AnnotIterator::CPDFSDK_AnnotIterator(
+    CPDFSDK_PageView* pPageView,
+    const std::vector<CPDF_Annot::Subtype>& subtypes_to_iterate)
     : m_pPageView(pPageView),
-      m_nAnnotSubtype(nAnnotSubtype),
+      m_subtypes(subtypes_to_iterate),
       m_eTabOrder(GetTabOrder(pPageView)) {
   GenerateResults();
 }
@@ -78,7 +85,7 @@
 
 void CPDFSDK_AnnotIterator::CollectAnnots(std::vector<CPDFSDK_Annot*>* pArray) {
   for (auto* pAnnot : m_pPageView->GetAnnotList()) {
-    if (pAnnot->GetAnnotSubtype() == m_nAnnotSubtype &&
+    if (pdfium::ContainsValue(m_subtypes, pAnnot->GetAnnotSubtype()) &&
         !pAnnot->IsSignatureWidget()) {
       pArray->push_back(pAnnot);
     }
diff --git a/fpdfsdk/cpdfsdk_annotiterator.h b/fpdfsdk/cpdfsdk_annotiterator.h
index fd7cbdc..5a0ca8a 100644
--- a/fpdfsdk/cpdfsdk_annotiterator.h
+++ b/fpdfsdk/cpdfsdk_annotiterator.h
@@ -23,6 +23,11 @@
 
   CPDFSDK_AnnotIterator(CPDFSDK_PageView* pPageView,
                         CPDF_Annot::Subtype nAnnotSubtype);
+
+  CPDFSDK_AnnotIterator(
+      CPDFSDK_PageView* pPageView,
+      const std::vector<CPDF_Annot::Subtype>& subtypes_to_iterate);
+
   ~CPDFSDK_AnnotIterator();
 
   CPDFSDK_Annot* GetFirstAnnot();
@@ -38,7 +43,7 @@
                            std::vector<size_t>* aSelect);
 
   UnownedPtr<CPDFSDK_PageView> const m_pPageView;
-  CPDF_Annot::Subtype m_nAnnotSubtype;
+  const std::vector<CPDF_Annot::Subtype> m_subtypes;
   const TabOrder m_eTabOrder;
   std::vector<CPDFSDK_Annot*> m_Annots;
 };
diff --git a/fpdfsdk/cpdfsdk_baannothandler.cpp b/fpdfsdk/cpdfsdk_baannothandler.cpp
index d83dfba..42a0704 100644
--- a/fpdfsdk/cpdfsdk_baannothandler.cpp
+++ b/fpdfsdk/cpdfsdk_baannothandler.cpp
@@ -7,13 +7,14 @@
 #include "fpdfsdk/cpdfsdk_baannothandler.h"
 
 #include <memory>
-#include <vector>
 
 #include "core/fpdfapi/page/cpdf_page.h"
 #include "core/fpdfapi/parser/cpdf_document.h"
 #include "core/fpdfdoc/cpdf_interactiveform.h"
+#include "core/fxge/cfx_drawutils.h"
 #include "fpdfsdk/cpdfsdk_annot.h"
 #include "fpdfsdk/cpdfsdk_baannot.h"
+#include "fpdfsdk/cpdfsdk_formfillenvironment.h"
 #include "fpdfsdk/cpdfsdk_pageview.h"
 #include "fpdfsdk/formfiller/cffl_formfiller.h"
 
@@ -40,7 +41,7 @@
 
 void CPDFSDK_BAAnnotHandler::SetFormFillEnvironment(
     CPDFSDK_FormFillEnvironment* pFormFillEnv) {
-  // CPDFSDK_BAAnnotHandler does not need it.
+  form_fill_environment_ = pFormFillEnv;
 }
 
 bool CPDFSDK_BAAnnotHandler::CanAnswer(CPDFSDK_Annot* pAnnot) {
@@ -66,9 +67,26 @@
   if (pAnnot->AsXFAWidget())
     return;
 
-  if (bDrawAnnots && pAnnot->GetAnnotSubtype() == CPDF_Annot::Subtype::POPUP) {
+  if (!pAnnot->AsBAAnnot()->IsVisible())
+    return;
+
+  const CPDF_Annot::Subtype annot_type = pAnnot->GetAnnotSubtype();
+  if (bDrawAnnots && annot_type == CPDF_Annot::Subtype::POPUP) {
     pAnnot->AsBAAnnot()->DrawAppearance(pDevice, mtUser2Device,
                                         CPDF_Annot::Normal, nullptr);
+    return;
+  }
+
+  if (is_annotation_focused_ && IsFocusableAnnot(annot_type) &&
+      pAnnot == form_fill_environment_->GetFocusAnnot()) {
+    CFX_FloatRect view_bounding_box =
+        GetViewBBox(pPageView, pAnnot->AsBAAnnot());
+    if (view_bounding_box.IsEmpty())
+      return;
+
+    view_bounding_box.Normalize();
+
+    CFX_DrawUtils::DrawFocusRect(pDevice, mtUser2Device, view_bounding_box);
   }
 }
 
@@ -165,14 +183,44 @@
 
 void CPDFSDK_BAAnnotHandler::OnLoad(CPDFSDK_Annot* pAnnot) {}
 
+bool CPDFSDK_BAAnnotHandler::IsFocusableAnnot(
+    const CPDF_Annot::Subtype& annot_type) const {
+  ASSERT(annot_type != CPDF_Annot::Subtype::WIDGET);
+
+  return pdfium::ContainsValue(
+      form_fill_environment_->GetFocusableAnnotSubtypes(), annot_type);
+}
+
+void CPDFSDK_BAAnnotHandler::InvalidateRect(CPDFSDK_Annot* annot) {
+  CPDFSDK_BAAnnot* ba_annot = annot->AsBAAnnot();
+  CPDFSDK_PageView* page_view = ba_annot->GetPageView();
+  CFX_FloatRect view_bounding_box = GetViewBBox(page_view, ba_annot);
+  if (!view_bounding_box.IsEmpty()) {
+    view_bounding_box.Inflate(1, 1);
+    view_bounding_box.Normalize();
+    FX_RECT rect = view_bounding_box.GetOuterRect();
+    form_fill_environment_->Invalidate(ba_annot->GetPage(), rect);
+  }
+}
+
 bool CPDFSDK_BAAnnotHandler::OnSetFocus(ObservedPtr<CPDFSDK_Annot>* pAnnot,
                                         uint32_t nFlag) {
-  return false;
+  if (!IsFocusableAnnot(pAnnot->Get()->GetAnnotSubtype()))
+    return false;
+
+  is_annotation_focused_ = true;
+  InvalidateRect(pAnnot->Get());
+  return true;
 }
 
 bool CPDFSDK_BAAnnotHandler::OnKillFocus(ObservedPtr<CPDFSDK_Annot>* pAnnot,
                                          uint32_t nFlag) {
-  return false;
+  if (!IsFocusableAnnot(pAnnot->Get()->GetAnnotSubtype()))
+    return false;
+
+  is_annotation_focused_ = false;
+  InvalidateRect(pAnnot->Get());
+  return true;
 }
 
 bool CPDFSDK_BAAnnotHandler::SetIndexSelected(
diff --git a/fpdfsdk/cpdfsdk_baannothandler.h b/fpdfsdk/cpdfsdk_baannothandler.h
index 22607bf..03a6b9f 100644
--- a/fpdfsdk/cpdfsdk_baannothandler.h
+++ b/fpdfsdk/cpdfsdk_baannothandler.h
@@ -99,6 +99,13 @@
                         int index,
                         bool selected) override;
   bool IsIndexSelected(ObservedPtr<CPDFSDK_Annot>* pAnnot, int index) override;
+
+ private:
+  void InvalidateRect(CPDFSDK_Annot* annot);
+  bool IsFocusableAnnot(const CPDF_Annot::Subtype& annot_type) const;
+
+  UnownedPtr<CPDFSDK_FormFillEnvironment> form_fill_environment_;
+  bool is_annotation_focused_ = false;
 };
 
 #endif  // FPDFSDK_CPDFSDK_BAANNOTHANDLER_H_
diff --git a/fpdfsdk/cpdfsdk_baannothandler_embeddertest.cpp b/fpdfsdk/cpdfsdk_baannothandler_embeddertest.cpp
index 9a26e83..6d7fd2e 100644
--- a/fpdfsdk/cpdfsdk_baannothandler_embeddertest.cpp
+++ b/fpdfsdk/cpdfsdk_baannothandler_embeddertest.cpp
@@ -70,19 +70,3 @@
 
   EXPECT_FALSE(GetBAAnnotHandler()->OnKillFocus(&pNonWidgetAnnot, 0));
 }
-
-TEST_F(CPDFSDK_BAAnnotHandlerTest, TabToInvalidAnnot) {
-  // TODO(crbug.com/994500): Create annot iterator with list of supported
-  // focusable subtypes as provided by host.
-  CPDFSDK_AnnotIterator ai(GetPageView(), CPDF_Annot::Subtype::WIDGET);
-  CPDFSDK_Annot* pAnnot = ai.GetFirstAnnot();
-  ASSERT_TRUE(pAnnot);
-  EXPECT_EQ(pAnnot->GetAnnotSubtype(), CPDF_Annot::Subtype::WIDGET);
-
-  ObservedPtr<CPDFSDK_Annot> pWidgetAnnot(pAnnot);
-
-  // Passing wrong subtype to BAAnnotHandler, API should return false.
-  EXPECT_FALSE(GetBAAnnotHandler()->OnSetFocus(&pWidgetAnnot, 0));
-
-  EXPECT_FALSE(GetBAAnnotHandler()->OnKillFocus(&pWidgetAnnot, 0));
-}
diff --git a/fpdfsdk/cpdfsdk_formfillenvironment.h b/fpdfsdk/cpdfsdk_formfillenvironment.h
index d7ccc23..b3dbdb1 100644
--- a/fpdfsdk/cpdfsdk_formfillenvironment.h
+++ b/fpdfsdk/cpdfsdk_formfillenvironment.h
@@ -201,6 +201,14 @@
 
   CPDFSDK_AnnotHandlerMgr* GetAnnotHandlerMgr();  // Always present.
 
+  void SetFocusableAnnotSubtypes(
+      const std::vector<CPDF_Annot::Subtype>& focusableAnnotTypes) {
+    m_FocusableAnnotTypes = focusableAnnotTypes;
+  }
+  const std::vector<CPDF_Annot::Subtype>& GetFocusableAnnotSubtypes() const {
+    return m_FocusableAnnotTypes;
+  }
+
   // Creates if not present.
   CFFL_InteractiveFormFiller* GetInteractiveFormFiller();
   IJS_Runtime* GetIJSRuntime();                   // Creates if not present.
@@ -222,6 +230,11 @@
   std::unique_ptr<CFFL_InteractiveFormFiller> m_pFormFiller;
   bool m_bChangeMask = false;
   bool m_bBeingDestroyed = false;
+
+  // Holds the list of focusable annot types.
+  // Annotations of type WIDGET are by default focusable.
+  std::vector<CPDF_Annot::Subtype> m_FocusableAnnotTypes = {
+      CPDF_Annot::Subtype::WIDGET};
 };
 
 #endif  // FPDFSDK_CPDFSDK_FORMFILLENVIRONMENT_H_
diff --git a/fpdfsdk/fpdf_annot.cpp b/fpdfsdk/fpdf_annot.cpp
index c08ba5a..20ac0e6 100644
--- a/fpdfsdk/fpdf_annot.cpp
+++ b/fpdfsdk/fpdf_annot.cpp
@@ -28,6 +28,7 @@
 #include "core/fpdfdoc/cpdf_interactiveform.h"
 #include "core/fpdfdoc/cpvt_generateap.h"
 #include "core/fxge/cfx_color.h"
+#include "fpdfsdk/cpdfsdk_formfillenvironment.h"
 #include "fpdfsdk/cpdfsdk_helpers.h"
 #include "fpdfsdk/cpdfsdk_interactiveform.h"
 #include "third_party/base/ptr_util.h"
@@ -1065,3 +1066,64 @@
   CPDFSDK_Widget* pWidget = pForm->GetWidget(pFormControl);
   return pWidget && pWidget->IsChecked();
 }
+
+FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV
+FPDFAnnot_SetFocusableSubtypes(FPDF_FORMHANDLE hHandle,
+                               const FPDF_ANNOTATION_SUBTYPE* subtypes,
+                               size_t count) {
+  CPDFSDK_FormFillEnvironment* pFormFillEnv =
+      CPDFSDKFormFillEnvironmentFromFPDFFormHandle(hHandle);
+  if (!pFormFillEnv)
+    return false;
+
+  if (count > 0 && !subtypes)
+    return false;
+
+  std::vector<CPDF_Annot::Subtype> focusable_annot_types;
+  focusable_annot_types.reserve(count);
+  for (size_t i = 0; i < count; ++i) {
+    focusable_annot_types.push_back(
+        static_cast<CPDF_Annot::Subtype>(subtypes[i]));
+  }
+
+  pFormFillEnv->SetFocusableAnnotSubtypes(focusable_annot_types);
+  return true;
+}
+
+FPDF_EXPORT int FPDF_CALLCONV
+FPDFAnnot_GetFocusableSubtypesCount(FPDF_FORMHANDLE hHandle) {
+  CPDFSDK_FormFillEnvironment* pFormFillEnv =
+      CPDFSDKFormFillEnvironmentFromFPDFFormHandle(hHandle);
+  if (!pFormFillEnv)
+    return -1;
+
+  return pdfium::CollectionSize<int>(pFormFillEnv->GetFocusableAnnotSubtypes());
+}
+
+FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV
+FPDFAnnot_GetFocusableSubtypes(FPDF_FORMHANDLE hHandle,
+                               FPDF_ANNOTATION_SUBTYPE* subtypes,
+                               size_t count) {
+  CPDFSDK_FormFillEnvironment* pFormFillEnv =
+      CPDFSDKFormFillEnvironmentFromFPDFFormHandle(hHandle);
+  if (!pFormFillEnv)
+    return false;
+
+  if (!subtypes)
+    return false;
+
+  const std::vector<CPDF_Annot::Subtype>& focusable_annot_types =
+      pFormFillEnv->GetFocusableAnnotSubtypes();
+
+  // Host should allocate enough memory to get the list of currently supported
+  // focusable subtypes.
+  if (count < focusable_annot_types.size())
+    return false;
+
+  for (size_t i = 0; i < focusable_annot_types.size(); ++i) {
+    subtypes[i] =
+        static_cast<FPDF_ANNOTATION_SUBTYPE>(focusable_annot_types[i]);
+  }
+
+  return true;
+}
diff --git a/fpdfsdk/fpdf_annot_embeddertest.cpp b/fpdfsdk/fpdf_annot_embeddertest.cpp
index 3cdf20e..c45ab50 100644
--- a/fpdfsdk/fpdf_annot_embeddertest.cpp
+++ b/fpdfsdk/fpdf_annot_embeddertest.cpp
@@ -2382,3 +2382,87 @@
   }
   UnloadPage(page);
 }
+
+TEST_F(FPDFAnnotEmbedderTest, SetFocusableAnnotSubtypes) {
+  ASSERT_TRUE(OpenDocument("text_form.pdf"));
+  FPDF_PAGE page = LoadPage(0);
+  ASSERT_TRUE(page);
+
+  // Annotations of type FPDF_ANNOT_WIDGET are by default focusable.
+  EXPECT_EQ(1, FPDFAnnot_GetFocusableSubtypesCount(form_handle()));
+
+  EXPECT_TRUE(FPDFAnnot_SetFocusableSubtypes(form_handle(), nullptr, 0));
+  EXPECT_EQ(0, FPDFAnnot_GetFocusableSubtypesCount(form_handle()));
+
+  constexpr FPDF_ANNOTATION_SUBTYPE kFocusableSubtypes[] = {FPDF_ANNOT_WIDGET};
+  constexpr size_t kSubtypeCount = FX_ArraySize(kFocusableSubtypes);
+
+  EXPECT_FALSE(FPDFAnnot_SetFocusableSubtypes(nullptr, kFocusableSubtypes,
+                                              kSubtypeCount));
+  EXPECT_FALSE(
+      FPDFAnnot_SetFocusableSubtypes(form_handle(), nullptr, kSubtypeCount));
+
+  EXPECT_TRUE(FPDFAnnot_SetFocusableSubtypes(form_handle(), kFocusableSubtypes,
+                                             kSubtypeCount));
+  EXPECT_EQ(static_cast<int>(kSubtypeCount),
+            FPDFAnnot_GetFocusableSubtypesCount(form_handle()));
+
+  EXPECT_TRUE(
+      FPDFAnnot_SetFocusableSubtypes(form_handle(), kFocusableSubtypes, 0));
+  EXPECT_EQ(0, FPDFAnnot_GetFocusableSubtypesCount(form_handle()));
+
+  UnloadPage(page);
+}
+
+TEST_F(FPDFAnnotEmbedderTest, GetFocusableAnnotSubtypesCount) {
+  ASSERT_TRUE(OpenDocument("text_form.pdf"));
+  FPDF_PAGE page = LoadPage(0);
+  ASSERT_TRUE(page);
+
+  EXPECT_EQ(-1, FPDFAnnot_GetFocusableSubtypesCount(nullptr));
+
+  // FPDF_ANNOT_WIDGET is default annot subtype which is focusable,
+  // hence 1 is default count.
+  EXPECT_EQ(1, FPDFAnnot_GetFocusableSubtypesCount(form_handle()));
+
+  constexpr FPDF_ANNOTATION_SUBTYPE kFocusableSubtypes[] = {FPDF_ANNOT_WIDGET,
+                                                            FPDF_ANNOT_LINK};
+  constexpr size_t kSubtypeCount = FX_ArraySize(kFocusableSubtypes);
+
+  FPDFAnnot_SetFocusableSubtypes(form_handle(), kFocusableSubtypes,
+                                 kSubtypeCount);
+
+  EXPECT_EQ(static_cast<int>(kSubtypeCount),
+            FPDFAnnot_GetFocusableSubtypesCount(form_handle()));
+
+  UnloadPage(page);
+}
+
+TEST_F(FPDFAnnotEmbedderTest, GetFocusableAnnotSubtypes) {
+  ASSERT_TRUE(OpenDocument("text_form.pdf"));
+  FPDF_PAGE page = LoadPage(0);
+  ASSERT_TRUE(page);
+
+  constexpr FPDF_ANNOTATION_SUBTYPE kFocusableSubtypes[] = {FPDF_ANNOT_WIDGET};
+  constexpr size_t kSubtypeCount = FX_ArraySize(kFocusableSubtypes);
+
+  FPDFAnnot_SetFocusableSubtypes(form_handle(), kFocusableSubtypes,
+                                 kSubtypeCount);
+
+  int count = FPDFAnnot_GetFocusableSubtypesCount(form_handle());
+  ASSERT_EQ(1, count);
+  EXPECT_FALSE(FPDFAnnot_GetFocusableSubtypes(form_handle(), nullptr, count));
+
+  std::vector<FPDF_ANNOTATION_SUBTYPE> subtypes(count, FPDF_ANNOT_UNKNOWN);
+  EXPECT_FALSE(FPDFAnnot_GetFocusableSubtypes(form_handle(), subtypes.data(),
+                                              count - 1));
+
+  EXPECT_TRUE(
+      FPDFAnnot_GetFocusableSubtypes(form_handle(), subtypes.data(), count));
+
+  for (int i = 0; i < count; ++i) {
+    EXPECT_EQ(kFocusableSubtypes[i], subtypes[i]);
+  }
+
+  UnloadPage(page);
+}
diff --git a/fpdfsdk/fpdf_view_c_api_test.c b/fpdfsdk/fpdf_view_c_api_test.c
index 60bd6fd..0cf0e1c 100644
--- a/fpdfsdk/fpdf_view_c_api_test.c
+++ b/fpdfsdk/fpdf_view_c_api_test.c
@@ -46,6 +46,8 @@
     CHK(FPDFAnnot_GetAttachmentPoints);
     CHK(FPDFAnnot_GetColor);
     CHK(FPDFAnnot_GetFlags);
+    CHK(FPDFAnnot_GetFocusableSubtypes);
+    CHK(FPDFAnnot_GetFocusableSubtypesCount);
     CHK(FPDFAnnot_GetFontSize);
     CHK(FPDFAnnot_GetFormFieldAtPoint);
     CHK(FPDFAnnot_GetFormFieldFlags);
@@ -72,6 +74,7 @@
     CHK(FPDFAnnot_SetAttachmentPoints);
     CHK(FPDFAnnot_SetColor);
     CHK(FPDFAnnot_SetFlags);
+    CHK(FPDFAnnot_SetFocusableSubtypes);
     CHK(FPDFAnnot_SetRect);
     CHK(FPDFAnnot_SetStringValue);
     CHK(FPDFAnnot_UpdateObject);
diff --git a/public/fpdf_annot.h b/public/fpdf_annot.h
index 58da809..b10f249 100644
--- a/public/fpdf_annot.h
+++ b/public/fpdf_annot.h
@@ -656,6 +656,51 @@
 FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_IsChecked(FPDF_FORMHANDLE hHandle,
                                                         FPDF_ANNOTATION annot);
 
+// Experimental API.
+// Set the list of focusable annotation subtypes. Annotations of subtype
+// FPDF_ANNOT_WIDGET are by default focusable. New subtypes set using this API
+// will override the existing subtypes.
+//
+//   hHandle  - handle to the form fill module, returned by
+//              FPDFDOC_InitFormFillEnvironment.
+//   subtypes - list of annotation subtype which can be tabbed over.
+//   count    - total number of annotation subtype in list.
+// Returns true if list of annotation subtype is set successfully, false
+// otherwise.
+FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV
+FPDFAnnot_SetFocusableSubtypes(FPDF_FORMHANDLE hHandle,
+                               const FPDF_ANNOTATION_SUBTYPE* subtypes,
+                               size_t count);
+
+// Experimental API.
+// Get the count of focusable annotation subtypes as set by host
+// for a |hHandle|.
+//
+//   hHandle  - handle to the form fill module, returned by
+//              FPDFDOC_InitFormFillEnvironment.
+// Returns the count of focusable annotation subtypes or -1 on error.
+// Note : Annotations of type FPDF_ANNOT_WIDGET are by default focusable.
+FPDF_EXPORT int FPDF_CALLCONV
+FPDFAnnot_GetFocusableSubtypesCount(FPDF_FORMHANDLE hHandle);
+
+// Experimental API.
+// Get the list of focusable annotation subtype as set by host.
+//
+//   hHandle  - handle to the form fill module, returned by
+//              FPDFDOC_InitFormFillEnvironment.
+//   subtypes - receives the list of annotation subtype which can be tabbed
+//              over. Caller must have allocated |subtypes| more than or
+//              equal to the count obtained from
+//              FPDFAnnot_GetFocusableSubtypesCount() API.
+//   count    - size of |subtypes|.
+// Returns true on success and set list of annotation subtype to |subtypes|,
+// false otherwise.
+// Note : Annotations of type FPDF_ANNOT_WIDGET are by default focusable.
+FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV
+FPDFAnnot_GetFocusableSubtypes(FPDF_FORMHANDLE hHandle,
+                               FPDF_ANNOTATION_SUBTYPE* subtypes,
+                               size_t count);
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif  // __cplusplus