Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 1 | // Copyright 2016 PDFium Authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com |
| 6 | |
| 7 | #include "fpdfsdk/cpdfsdk_annothandlermgr.h" |
| 8 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 9 | #include <utility> |
| 10 | |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 11 | #include "core/fpdfapi/parser/cpdf_number.h" |
| 12 | #include "core/fpdfapi/parser/cpdf_string.h" |
| 13 | #include "core/fpdfdoc/cpdf_annot.h" |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 14 | #include "fpdfsdk/cpdfsdk_annot.h" |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 15 | #include "fpdfsdk/cpdfsdk_annotiterator.h" |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 16 | #include "fpdfsdk/cpdfsdk_baannot.h" |
| 17 | #include "fpdfsdk/cpdfsdk_baannothandler.h" |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 18 | #include "fpdfsdk/cpdfsdk_formfillenvironment.h" |
| 19 | #include "fpdfsdk/cpdfsdk_pageview.h" |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 20 | #include "fpdfsdk/cpdfsdk_widget.h" |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 21 | #include "fpdfsdk/cpdfsdk_widgethandler.h" |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 22 | #include "fpdfsdk/pwl/cpwl_wnd.h" |
| 23 | #include "public/fpdf_fwlevent.h" |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 24 | #include "third_party/base/ptr_util.h" |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 25 | |
| 26 | #ifdef PDF_ENABLE_XFA |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 27 | #include "fpdfsdk/fpdfxfa/cpdfxfa_page.h" |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 28 | #include "fpdfsdk/fpdfxfa/cpdfxfa_widget.h" |
| 29 | #include "fpdfsdk/fpdfxfa/cpdfxfa_widgethandler.h" |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 30 | #endif // PDF_ENABLE_XFA |
| 31 | |
| 32 | CPDFSDK_AnnotHandlerMgr::CPDFSDK_AnnotHandlerMgr( |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 33 | std::unique_ptr<CPDFSDK_BAAnnotHandler> pBAAnnotHandler, |
| 34 | std::unique_ptr<CPDFSDK_WidgetHandler> pWidgetHandler, |
| 35 | std::unique_ptr<IPDFSDK_AnnotHandler> pXFAWidgetHandler) |
| 36 | : m_pBAAnnotHandler(std::move(pBAAnnotHandler)), |
| 37 | m_pWidgetHandler(std::move(pWidgetHandler)), |
| 38 | m_pXFAWidgetHandler(std::move(pXFAWidgetHandler)) { |
| 39 | ASSERT(m_pBAAnnotHandler); |
| 40 | ASSERT(m_pWidgetHandler); |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 41 | } |
| 42 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 43 | CPDFSDK_AnnotHandlerMgr::~CPDFSDK_AnnotHandlerMgr() = default; |
| 44 | |
| 45 | void CPDFSDK_AnnotHandlerMgr::SetFormFillEnv( |
| 46 | CPDFSDK_FormFillEnvironment* pFormFillEnv) { |
| 47 | m_pBAAnnotHandler->SetFormFillEnvironment(pFormFillEnv); |
| 48 | m_pWidgetHandler->SetFormFillEnvironment(pFormFillEnv); |
| 49 | if (m_pXFAWidgetHandler) |
| 50 | m_pXFAWidgetHandler->SetFormFillEnvironment(pFormFillEnv); |
| 51 | } |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 52 | |
| 53 | CPDFSDK_Annot* CPDFSDK_AnnotHandlerMgr::NewAnnot(CPDF_Annot* pAnnot, |
| 54 | CPDFSDK_PageView* pPageView) { |
| 55 | ASSERT(pPageView); |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 56 | return GetAnnotHandlerOfType(pAnnot->GetSubtype()) |
| 57 | ->NewAnnot(pAnnot, pPageView); |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 58 | } |
| 59 | |
| 60 | #ifdef PDF_ENABLE_XFA |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 61 | std::unique_ptr<CPDFSDK_Annot> CPDFSDK_AnnotHandlerMgr::NewXFAAnnot( |
| 62 | CXFA_FFWidget* pAnnot, |
| 63 | CPDFSDK_PageView* pPageView) { |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 64 | ASSERT(pAnnot); |
| 65 | ASSERT(pPageView); |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 66 | return static_cast<CPDFXFA_WidgetHandler*>(m_pXFAWidgetHandler.get()) |
| 67 | ->NewAnnotForXFA(pAnnot, pPageView); |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 68 | } |
| 69 | #endif // PDF_ENABLE_XFA |
| 70 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 71 | void CPDFSDK_AnnotHandlerMgr::ReleaseAnnot( |
| 72 | std::unique_ptr<CPDFSDK_Annot> pAnnot) { |
| 73 | IPDFSDK_AnnotHandler* pAnnotHandler = GetAnnotHandler(pAnnot.get()); |
| 74 | pAnnotHandler->ReleaseAnnot(std::move(pAnnot)); |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 75 | } |
| 76 | |
| 77 | void CPDFSDK_AnnotHandlerMgr::Annot_OnLoad(CPDFSDK_Annot* pAnnot) { |
| 78 | ASSERT(pAnnot); |
| 79 | GetAnnotHandler(pAnnot)->OnLoad(pAnnot); |
| 80 | } |
| 81 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 82 | WideString CPDFSDK_AnnotHandlerMgr::Annot_GetText(CPDFSDK_Annot* pAnnot) { |
| 83 | return GetAnnotHandler(pAnnot)->GetText(pAnnot); |
| 84 | } |
| 85 | |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 86 | WideString CPDFSDK_AnnotHandlerMgr::Annot_GetSelectedText( |
| 87 | CPDFSDK_Annot* pAnnot) { |
| 88 | return GetAnnotHandler(pAnnot)->GetSelectedText(pAnnot); |
| 89 | } |
| 90 | |
| 91 | void CPDFSDK_AnnotHandlerMgr::Annot_ReplaceSelection(CPDFSDK_Annot* pAnnot, |
| 92 | const WideString& text) { |
| 93 | GetAnnotHandler(pAnnot)->ReplaceSelection(pAnnot, text); |
| 94 | } |
| 95 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 96 | bool CPDFSDK_AnnotHandlerMgr::Annot_CanUndo(CPDFSDK_Annot* pAnnot) { |
| 97 | return GetAnnotHandler(pAnnot)->CanUndo(pAnnot); |
| 98 | } |
| 99 | |
| 100 | bool CPDFSDK_AnnotHandlerMgr::Annot_CanRedo(CPDFSDK_Annot* pAnnot) { |
| 101 | return GetAnnotHandler(pAnnot)->CanRedo(pAnnot); |
| 102 | } |
| 103 | |
| 104 | bool CPDFSDK_AnnotHandlerMgr::Annot_Undo(CPDFSDK_Annot* pAnnot) { |
| 105 | return GetAnnotHandler(pAnnot)->Undo(pAnnot); |
| 106 | } |
| 107 | |
| 108 | bool CPDFSDK_AnnotHandlerMgr::Annot_Redo(CPDFSDK_Annot* pAnnot) { |
| 109 | return GetAnnotHandler(pAnnot)->Redo(pAnnot); |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 110 | } |
| 111 | |
| 112 | IPDFSDK_AnnotHandler* CPDFSDK_AnnotHandlerMgr::GetAnnotHandler( |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 113 | CPDFSDK_Annot* pAnnot) const { |
| 114 | return GetAnnotHandlerOfType(pAnnot->GetAnnotSubtype()); |
| 115 | } |
| 116 | |
| 117 | IPDFSDK_AnnotHandler* CPDFSDK_AnnotHandlerMgr::GetAnnotHandlerOfType( |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 118 | CPDF_Annot::Subtype nAnnotSubtype) const { |
| 119 | if (nAnnotSubtype == CPDF_Annot::Subtype::WIDGET) |
| 120 | return m_pWidgetHandler.get(); |
| 121 | |
| 122 | #ifdef PDF_ENABLE_XFA |
| 123 | if (nAnnotSubtype == CPDF_Annot::Subtype::XFAWIDGET) |
| 124 | return m_pXFAWidgetHandler.get(); |
| 125 | #endif // PDF_ENABLE_XFA |
| 126 | |
| 127 | return m_pBAAnnotHandler.get(); |
| 128 | } |
| 129 | |
| 130 | void CPDFSDK_AnnotHandlerMgr::Annot_OnDraw(CPDFSDK_PageView* pPageView, |
| 131 | CPDFSDK_Annot* pAnnot, |
| 132 | CFX_RenderDevice* pDevice, |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 133 | const CFX_Matrix& mtUser2Device, |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 134 | bool bDrawAnnots) { |
| 135 | ASSERT(pAnnot); |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 136 | GetAnnotHandler(pAnnot)->OnDraw(pPageView, pAnnot, pDevice, mtUser2Device, |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 137 | bDrawAnnots); |
| 138 | } |
| 139 | |
| 140 | bool CPDFSDK_AnnotHandlerMgr::Annot_OnLButtonDown( |
| 141 | CPDFSDK_PageView* pPageView, |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 142 | ObservedPtr<CPDFSDK_Annot>* pAnnot, |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 143 | uint32_t nFlags, |
Philip P. Moltmann | 33357ca | 2017-05-11 09:25:13 -0700 | [diff] [blame] | 144 | const CFX_PointF& point) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 145 | ASSERT(pAnnot->HasObservable()); |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 146 | return GetAnnotHandler(pAnnot->Get()) |
| 147 | ->OnLButtonDown(pPageView, pAnnot, nFlags, point); |
| 148 | } |
| 149 | |
| 150 | bool CPDFSDK_AnnotHandlerMgr::Annot_OnLButtonUp( |
| 151 | CPDFSDK_PageView* pPageView, |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 152 | ObservedPtr<CPDFSDK_Annot>* pAnnot, |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 153 | uint32_t nFlags, |
Philip P. Moltmann | 33357ca | 2017-05-11 09:25:13 -0700 | [diff] [blame] | 154 | const CFX_PointF& point) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 155 | ASSERT(pAnnot->HasObservable()); |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 156 | return GetAnnotHandler(pAnnot->Get()) |
| 157 | ->OnLButtonUp(pPageView, pAnnot, nFlags, point); |
| 158 | } |
| 159 | |
| 160 | bool CPDFSDK_AnnotHandlerMgr::Annot_OnLButtonDblClk( |
| 161 | CPDFSDK_PageView* pPageView, |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 162 | ObservedPtr<CPDFSDK_Annot>* pAnnot, |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 163 | uint32_t nFlags, |
Philip P. Moltmann | 33357ca | 2017-05-11 09:25:13 -0700 | [diff] [blame] | 164 | const CFX_PointF& point) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 165 | ASSERT(pAnnot->HasObservable()); |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 166 | return GetAnnotHandler(pAnnot->Get()) |
| 167 | ->OnLButtonDblClk(pPageView, pAnnot, nFlags, point); |
| 168 | } |
| 169 | |
| 170 | bool CPDFSDK_AnnotHandlerMgr::Annot_OnMouseMove( |
| 171 | CPDFSDK_PageView* pPageView, |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 172 | ObservedPtr<CPDFSDK_Annot>* pAnnot, |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 173 | uint32_t nFlags, |
Philip P. Moltmann | 33357ca | 2017-05-11 09:25:13 -0700 | [diff] [blame] | 174 | const CFX_PointF& point) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 175 | ASSERT(pAnnot->HasObservable()); |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 176 | return GetAnnotHandler(pAnnot->Get()) |
| 177 | ->OnMouseMove(pPageView, pAnnot, nFlags, point); |
| 178 | } |
| 179 | |
| 180 | bool CPDFSDK_AnnotHandlerMgr::Annot_OnMouseWheel( |
| 181 | CPDFSDK_PageView* pPageView, |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 182 | ObservedPtr<CPDFSDK_Annot>* pAnnot, |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 183 | uint32_t nFlags, |
| 184 | short zDelta, |
Philip P. Moltmann | 33357ca | 2017-05-11 09:25:13 -0700 | [diff] [blame] | 185 | const CFX_PointF& point) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 186 | ASSERT(pAnnot->HasObservable()); |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 187 | return GetAnnotHandler(pAnnot->Get()) |
| 188 | ->OnMouseWheel(pPageView, pAnnot, nFlags, zDelta, point); |
| 189 | } |
| 190 | |
| 191 | bool CPDFSDK_AnnotHandlerMgr::Annot_OnRButtonDown( |
| 192 | CPDFSDK_PageView* pPageView, |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 193 | ObservedPtr<CPDFSDK_Annot>* pAnnot, |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 194 | uint32_t nFlags, |
Philip P. Moltmann | 33357ca | 2017-05-11 09:25:13 -0700 | [diff] [blame] | 195 | const CFX_PointF& point) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 196 | ASSERT(pAnnot->HasObservable()); |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 197 | return GetAnnotHandler(pAnnot->Get()) |
| 198 | ->OnRButtonDown(pPageView, pAnnot, nFlags, point); |
| 199 | } |
| 200 | |
| 201 | bool CPDFSDK_AnnotHandlerMgr::Annot_OnRButtonUp( |
| 202 | CPDFSDK_PageView* pPageView, |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 203 | ObservedPtr<CPDFSDK_Annot>* pAnnot, |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 204 | uint32_t nFlags, |
Philip P. Moltmann | 33357ca | 2017-05-11 09:25:13 -0700 | [diff] [blame] | 205 | const CFX_PointF& point) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 206 | ASSERT(pAnnot->HasObservable()); |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 207 | return GetAnnotHandler(pAnnot->Get()) |
| 208 | ->OnRButtonUp(pPageView, pAnnot, nFlags, point); |
| 209 | } |
| 210 | |
| 211 | void CPDFSDK_AnnotHandlerMgr::Annot_OnMouseEnter( |
| 212 | CPDFSDK_PageView* pPageView, |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 213 | ObservedPtr<CPDFSDK_Annot>* pAnnot, |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 214 | uint32_t nFlag) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 215 | ASSERT(pAnnot->HasObservable()); |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 216 | GetAnnotHandler(pAnnot->Get())->OnMouseEnter(pPageView, pAnnot, nFlag); |
| 217 | } |
| 218 | |
| 219 | void CPDFSDK_AnnotHandlerMgr::Annot_OnMouseExit( |
| 220 | CPDFSDK_PageView* pPageView, |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 221 | ObservedPtr<CPDFSDK_Annot>* pAnnot, |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 222 | uint32_t nFlag) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 223 | ASSERT(pAnnot->HasObservable()); |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 224 | GetAnnotHandler(pAnnot->Get())->OnMouseExit(pPageView, pAnnot, nFlag); |
| 225 | } |
| 226 | |
| 227 | bool CPDFSDK_AnnotHandlerMgr::Annot_OnChar(CPDFSDK_Annot* pAnnot, |
| 228 | uint32_t nChar, |
| 229 | uint32_t nFlags) { |
| 230 | return GetAnnotHandler(pAnnot)->OnChar(pAnnot, nChar, nFlags); |
| 231 | } |
| 232 | |
| 233 | bool CPDFSDK_AnnotHandlerMgr::Annot_OnKeyDown(CPDFSDK_Annot* pAnnot, |
| 234 | int nKeyCode, |
| 235 | int nFlag) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 236 | if (CPWL_Wnd::IsCTRLKeyDown(nFlag) || CPWL_Wnd::IsALTKeyDown(nFlag)) { |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 237 | return GetAnnotHandler(pAnnot)->OnKeyDown(pAnnot, nKeyCode, nFlag); |
| 238 | } |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 239 | ObservedPtr<CPDFSDK_Annot> pObservedAnnot(pAnnot); |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 240 | CPDFSDK_PageView* pPage = pAnnot->GetPageView(); |
| 241 | CPDFSDK_Annot* pFocusAnnot = pPage->GetFocusAnnot(); |
| 242 | if (pFocusAnnot && (nKeyCode == FWL_VKEY_Tab)) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 243 | ObservedPtr<CPDFSDK_Annot> pNext( |
| 244 | GetNextAnnot(pFocusAnnot, !CPWL_Wnd::IsSHIFTKeyDown(nFlag))); |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 245 | if (pNext && pNext.Get() != pFocusAnnot) { |
| 246 | pPage->GetFormFillEnv()->SetFocusAnnot(&pNext); |
| 247 | return true; |
| 248 | } |
| 249 | } |
| 250 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 251 | // Check |pAnnot| again because JS may have destroyed it in |GetNextAnnot| |
| 252 | if (!pObservedAnnot) |
| 253 | return false; |
| 254 | |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 255 | return GetAnnotHandler(pAnnot)->OnKeyDown(pAnnot, nKeyCode, nFlag); |
| 256 | } |
| 257 | |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 258 | bool CPDFSDK_AnnotHandlerMgr::Annot_OnSetFocus( |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 259 | ObservedPtr<CPDFSDK_Annot>* pAnnot, |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 260 | uint32_t nFlag) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 261 | ASSERT(pAnnot->HasObservable()); |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 262 | return GetAnnotHandler(pAnnot->Get())->OnSetFocus(pAnnot, nFlag); |
| 263 | } |
| 264 | |
| 265 | bool CPDFSDK_AnnotHandlerMgr::Annot_OnKillFocus( |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 266 | ObservedPtr<CPDFSDK_Annot>* pAnnot, |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 267 | uint32_t nFlag) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 268 | ASSERT(pAnnot->HasObservable()); |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 269 | return GetAnnotHandler(pAnnot->Get())->OnKillFocus(pAnnot, nFlag); |
| 270 | } |
| 271 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 272 | bool CPDFSDK_AnnotHandlerMgr::Annot_SetIndexSelected( |
| 273 | ObservedPtr<CPDFSDK_Annot>* pAnnot, |
| 274 | int index, |
| 275 | bool selected) { |
| 276 | return GetAnnotHandler(pAnnot->Get()) |
| 277 | ->SetIndexSelected(pAnnot, index, selected); |
| 278 | } |
| 279 | |
| 280 | bool CPDFSDK_AnnotHandlerMgr::Annot_IsIndexSelected( |
| 281 | ObservedPtr<CPDFSDK_Annot>* pAnnot, |
| 282 | int index) { |
| 283 | return GetAnnotHandler(pAnnot->Get())->IsIndexSelected(pAnnot, index); |
| 284 | } |
| 285 | |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 286 | #ifdef PDF_ENABLE_XFA |
| 287 | bool CPDFSDK_AnnotHandlerMgr::Annot_OnChangeFocus( |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 288 | ObservedPtr<CPDFSDK_Annot>* pSetAnnot, |
| 289 | ObservedPtr<CPDFSDK_Annot>* pKillAnnot) { |
| 290 | CPDFXFA_Widget* pSetXFAWidget = ToXFAWidget(pSetAnnot->Get()); |
| 291 | CPDFXFA_Widget* pKillXFAWidget = ToXFAWidget(pKillAnnot->Get()); |
| 292 | bool bXFA = (pSetXFAWidget && pSetXFAWidget->GetXFAFFWidget()) || |
| 293 | (pKillXFAWidget && pKillXFAWidget->GetXFAFFWidget()); |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 294 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 295 | return !bXFA || static_cast<CPDFXFA_WidgetHandler*>(m_pXFAWidgetHandler.get()) |
| 296 | ->OnXFAChangedFocus(pKillAnnot, pSetAnnot); |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 297 | } |
| 298 | #endif // PDF_ENABLE_XFA |
| 299 | |
| 300 | CFX_FloatRect CPDFSDK_AnnotHandlerMgr::Annot_OnGetViewBBox( |
| 301 | CPDFSDK_PageView* pPageView, |
| 302 | CPDFSDK_Annot* pAnnot) { |
| 303 | ASSERT(pAnnot); |
| 304 | return GetAnnotHandler(pAnnot)->GetViewBBox(pPageView, pAnnot); |
| 305 | } |
| 306 | |
| 307 | bool CPDFSDK_AnnotHandlerMgr::Annot_OnHitTest(CPDFSDK_PageView* pPageView, |
| 308 | CPDFSDK_Annot* pAnnot, |
Philip P. Moltmann | 33357ca | 2017-05-11 09:25:13 -0700 | [diff] [blame] | 309 | const CFX_PointF& point) { |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 310 | ASSERT(pAnnot); |
| 311 | IPDFSDK_AnnotHandler* pAnnotHandler = GetAnnotHandler(pAnnot); |
| 312 | if (pAnnotHandler->CanAnswer(pAnnot)) |
| 313 | return pAnnotHandler->HitTest(pPageView, pAnnot, point); |
| 314 | |
| 315 | return false; |
| 316 | } |
| 317 | |
| 318 | CPDFSDK_Annot* CPDFSDK_AnnotHandlerMgr::GetNextAnnot(CPDFSDK_Annot* pSDKAnnot, |
| 319 | bool bNext) { |
| 320 | #ifdef PDF_ENABLE_XFA |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 321 | IPDF_Page* pPage = pSDKAnnot->GetPageView()->GetXFAPage(); |
| 322 | if (pPage && !pPage->AsPDFPage()) { |
| 323 | // For xfa annots in XFA pages not backed by PDF pages. |
| 324 | return static_cast<CPDFXFA_Page*>(pPage)->GetNextXFAAnnot(pSDKAnnot, bNext); |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 325 | } |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 326 | #endif // PDF_ENABLE_XFA |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 327 | |
| 328 | // For PDF annots. |
| 329 | CPDFSDK_Widget* pWidget = ToCPDFSDKWidget(pSDKAnnot); |
| 330 | CPDFSDK_AnnotIterator ai(pWidget->GetPageView(), pWidget->GetAnnotSubtype()); |
| 331 | return bNext ? ai.GetNextAnnot(pWidget) : ai.GetPrevAnnot(pWidget); |
Philip P. Moltmann | 4d3acf4 | 2017-03-20 11:05:52 -0700 | [diff] [blame] | 332 | } |