Rip out the KillFocusAnnot call from CPDFSDK_PageView's destructor
[pdfium.git] / fpdfsdk / src / fsdk_mgr.cpp
1 // Copyright 2014 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 <algorithm>
8
9 #include "../../public/fpdf_ext.h"
10 #include "../../third_party/base/nonstd_unique_ptr.h"
11 #include "../include/formfiller/FFL_FormFiller.h"
12 #include "../include/fsdk_define.h"
13 #include "../include/fsdk_mgr.h"
14 #include "../include/javascript/IJavaScript.h"
15
16 #if _FX_OS_ == _FX_ANDROID_
17 #include "time.h"
18 #else
19 #include <ctime>
20 #endif
21
22 class CFX_SystemHandler : public IFX_SystemHandler {
23  public:
24   explicit CFX_SystemHandler(CPDFDoc_Environment* pEnv)
25       : m_pEnv(pEnv), m_nCharSet(-1) {}
26   ~CFX_SystemHandler() override {}
27
28  public:
29   // IFX_SystemHandler
30   void InvalidateRect(FX_HWND hWnd, FX_RECT rect) override;
31   void OutputSelectedRect(void* pFormFiller, CPDF_Rect& rect) override;
32   FX_BOOL IsSelectionImplemented() override;
33   CFX_WideString GetClipboardText(FX_HWND hWnd) override { return L""; }
34   FX_BOOL SetClipboardText(FX_HWND hWnd, CFX_WideString string) override {
35     return FALSE;
36   }
37   void ClientToScreen(FX_HWND hWnd, int32_t& x, int32_t& y) override {}
38   void ScreenToClient(FX_HWND hWnd, int32_t& x, int32_t& y) override {}
39   void SetCursor(int32_t nCursorType) override;
40   FX_HMENU CreatePopupMenu() override { return NULL; }
41   FX_BOOL AppendMenuItem(FX_HMENU hMenu,
42                          int32_t nIDNewItem,
43                          CFX_WideString string) override {
44     return FALSE;
45   }
46   FX_BOOL EnableMenuItem(FX_HMENU hMenu,
47                          int32_t nIDItem,
48                          FX_BOOL bEnabled) override {
49     return FALSE;
50   }
51   int32_t TrackPopupMenu(FX_HMENU hMenu,
52                          int32_t x,
53                          int32_t y,
54                          FX_HWND hParent) override {
55     return -1;
56   }
57   void DestroyMenu(FX_HMENU hMenu) override {}
58   CFX_ByteString GetNativeTrueTypeFont(int32_t nCharset) override;
59   FX_BOOL FindNativeTrueTypeFont(int32_t nCharset,
60                                  CFX_ByteString sFontFaceName) override;
61   CPDF_Font* AddNativeTrueTypeFontToPDF(CPDF_Document* pDoc,
62                                         CFX_ByteString sFontFaceName,
63                                         uint8_t nCharset) override;
64   int32_t SetTimer(int32_t uElapse, TimerCallback lpTimerFunc) override;
65   void KillTimer(int32_t nID) override;
66   FX_BOOL IsSHIFTKeyDown(FX_DWORD nFlag) override {
67     return m_pEnv->FFI_IsSHIFTKeyDown(nFlag);
68   }
69   FX_BOOL IsCTRLKeyDown(FX_DWORD nFlag) override {
70     return m_pEnv->FFI_IsCTRLKeyDown(nFlag);
71   }
72   FX_BOOL IsALTKeyDown(FX_DWORD nFlag) override {
73     return m_pEnv->FFI_IsALTKeyDown(nFlag);
74   }
75   FX_BOOL IsINSERTKeyDown(FX_DWORD nFlag) override {
76     return m_pEnv->FFI_IsINSERTKeyDown(nFlag);
77   }
78   FX_SYSTEMTIME GetLocalTime() override;
79   int32_t GetCharSet() override { return m_nCharSet; }
80   void SetCharSet(int32_t nCharSet) override { m_nCharSet = nCharSet; }
81
82  private:
83   CPDFDoc_Environment* m_pEnv;
84   int m_nCharSet;
85 };
86
87 void CFX_SystemHandler::SetCursor(int32_t nCursorType) {
88   m_pEnv->FFI_SetCursor(nCursorType);
89 }
90
91 void CFX_SystemHandler::InvalidateRect(FX_HWND hWnd, FX_RECT rect) {
92   // g_pFormFillApp->FFI_Invalidate();
93   CPDFSDK_Annot* pSDKAnnot = (CPDFSDK_Annot*)hWnd;
94   CPDF_Page* pPage = NULL;
95   CPDFSDK_PageView* pPageView = NULL;
96   pPageView = pSDKAnnot->GetPageView();
97   pPage = pSDKAnnot->GetPDFPage();
98   if (!pPage || !pPageView)
99     return;
100   CPDF_Matrix page2device;
101   pPageView->GetCurrentMatrix(page2device);
102   CPDF_Matrix device2page;
103   device2page.SetReverse(page2device);
104   FX_FLOAT left, top, right, bottom;
105   device2page.Transform((FX_FLOAT)rect.left, (FX_FLOAT)rect.top, left, top);
106   device2page.Transform((FX_FLOAT)rect.right, (FX_FLOAT)rect.bottom, right,
107                         bottom);
108   //  m_pEnv->FFI_DeviceToPage(pPage, rect.left, rect.top, (double*)&left,
109   //  (double*)&top);
110   //  m_pEnv->FFI_DeviceToPage(pPage, rect.right, rect.bottom, (double*)&right,
111   //  (double*)&bottom);
112   CPDF_Rect rcPDF(left, bottom, right, top);
113   rcPDF.Normalize();
114
115   m_pEnv->FFI_Invalidate(pPage, rcPDF.left, rcPDF.top, rcPDF.right,
116                          rcPDF.bottom);
117 }
118 void CFX_SystemHandler::OutputSelectedRect(void* pFormFiller, CPDF_Rect& rect) {
119   CFFL_FormFiller* pFFL = (CFFL_FormFiller*)pFormFiller;
120   if (pFFL) {
121     CPDF_Point leftbottom = CPDF_Point(rect.left, rect.bottom);
122     CPDF_Point righttop = CPDF_Point(rect.right, rect.top);
123     CPDF_Point ptA = pFFL->PWLtoFFL(leftbottom);
124     CPDF_Point ptB = pFFL->PWLtoFFL(righttop);
125
126     CPDFSDK_Annot* pAnnot = pFFL->GetSDKAnnot();
127     ASSERT(pAnnot);
128     CPDF_Page* pPage = pAnnot->GetPDFPage();
129     ASSERT(pPage);
130     m_pEnv->FFI_OutputSelectedRect(pPage, ptA.x, ptB.y, ptB.x, ptA.y);
131   }
132 }
133
134 FX_BOOL CFX_SystemHandler::IsSelectionImplemented() {
135   if (m_pEnv) {
136     FPDF_FORMFILLINFO* pInfo = m_pEnv->GetFormFillInfo();
137     if (pInfo && pInfo->FFI_OutputSelectedRect)
138       return TRUE;
139   }
140   return FALSE;
141 }
142
143 CFX_ByteString CFX_SystemHandler::GetNativeTrueTypeFont(int32_t nCharset) {
144   return "";
145 }
146
147 FX_BOOL CFX_SystemHandler::FindNativeTrueTypeFont(
148     int32_t nCharset,
149     CFX_ByteString sFontFaceName) {
150   CFX_FontMgr* pFontMgr = CFX_GEModule::Get()->GetFontMgr();
151   if (!pFontMgr)
152     return FALSE;
153
154   CFX_FontMapper* pFontMapper = pFontMgr->GetBuiltinMapper();
155   if (!pFontMapper)
156     return FALSE;
157
158   int nSize = pFontMapper->m_InstalledTTFonts.GetSize();
159   if (nSize == 0) {
160     pFontMapper->LoadInstalledFonts();
161     nSize = pFontMapper->m_InstalledTTFonts.GetSize();
162   }
163
164   for (int i = 0; i < nSize; ++i) {
165     if (pFontMapper->m_InstalledTTFonts[i].Compare(sFontFaceName))
166       return TRUE;
167   }
168
169   return FALSE;
170 }
171
172 static int CharSet2CP(int charset) {
173   if (charset == 128)
174     return 932;
175   if (charset == 134)
176     return 936;
177   if (charset == 129)
178     return 949;
179   if (charset == 136)
180     return 950;
181   return 0;
182 }
183 CPDF_Font* CFX_SystemHandler::AddNativeTrueTypeFontToPDF(
184     CPDF_Document* pDoc,
185     CFX_ByteString sFontFaceName,
186     uint8_t nCharset) {
187   if (pDoc) {
188     CFX_Font* pFXFont = new CFX_Font();
189     pFXFont->LoadSubst(sFontFaceName, TRUE, 0, 0, 0, CharSet2CP(nCharset),
190                        FALSE);
191     CPDF_Font* pFont = pDoc->AddFont(pFXFont, nCharset, FALSE);
192     delete pFXFont;
193     return pFont;
194   }
195
196   return NULL;
197 }
198
199 int32_t CFX_SystemHandler::SetTimer(int32_t uElapse,
200                                     TimerCallback lpTimerFunc) {
201   return m_pEnv->FFI_SetTimer(uElapse, lpTimerFunc);
202 }
203 void CFX_SystemHandler::KillTimer(int32_t nID) {
204   m_pEnv->FFI_KillTimer(nID);
205 }
206
207 FX_SYSTEMTIME CFX_SystemHandler::GetLocalTime() {
208   return m_pEnv->FFI_GetLocalTime();
209 }
210
211 CPDFDoc_Environment::CPDFDoc_Environment(CPDF_Document* pDoc,
212                                          FPDF_FORMFILLINFO* pFFinfo)
213     : m_pAnnotHandlerMgr(NULL),
214       m_pActionHandler(NULL),
215       m_pInfo(pFFinfo),
216       m_pSDKDoc(NULL),
217       m_pPDFDoc(pDoc),
218       m_pIFormFiller(NULL) {
219   m_pSysHandler = new CFX_SystemHandler(this);
220 }
221
222 CPDFDoc_Environment::~CPDFDoc_Environment() {
223   delete m_pIFormFiller;
224   m_pIFormFiller = NULL;
225
226   delete m_pSysHandler;
227   m_pSysHandler = NULL;
228
229   delete m_pAnnotHandlerMgr;
230   m_pAnnotHandlerMgr = NULL;
231
232   delete m_pActionHandler;
233   m_pActionHandler = NULL;
234 }
235
236 int CPDFDoc_Environment::JS_appAlert(const FX_WCHAR* Msg,
237                                      const FX_WCHAR* Title,
238                                      FX_UINT Type,
239                                      FX_UINT Icon) {
240   if (m_pInfo && m_pInfo->m_pJsPlatform && m_pInfo->m_pJsPlatform->app_alert) {
241     CFX_ByteString bsMsg = CFX_WideString(Msg).UTF16LE_Encode();
242     CFX_ByteString bsTitle = CFX_WideString(Title).UTF16LE_Encode();
243     FPDF_WIDESTRING pMsg = (FPDF_WIDESTRING)bsMsg.GetBuffer(bsMsg.GetLength());
244     FPDF_WIDESTRING pTitle =
245         (FPDF_WIDESTRING)bsTitle.GetBuffer(bsTitle.GetLength());
246     int ret = m_pInfo->m_pJsPlatform->app_alert(m_pInfo->m_pJsPlatform, pMsg,
247                                                 pTitle, Type, Icon);
248     bsMsg.ReleaseBuffer();
249     bsTitle.ReleaseBuffer();
250     return ret;
251   }
252   return -1;
253 }
254
255 int CPDFDoc_Environment::JS_appResponse(const FX_WCHAR* Question,
256                                         const FX_WCHAR* Title,
257                                         const FX_WCHAR* Default,
258                                         const FX_WCHAR* cLabel,
259                                         FPDF_BOOL bPassword,
260                                         void* response,
261                                         int length) {
262   if (m_pInfo && m_pInfo->m_pJsPlatform &&
263       m_pInfo->m_pJsPlatform->app_response) {
264     CFX_ByteString bsQuestion = CFX_WideString(Question).UTF16LE_Encode();
265     CFX_ByteString bsTitle = CFX_WideString(Title).UTF16LE_Encode();
266     CFX_ByteString bsDefault = CFX_WideString(Default).UTF16LE_Encode();
267     CFX_ByteString bsLabel = CFX_WideString(cLabel).UTF16LE_Encode();
268     FPDF_WIDESTRING pQuestion =
269         (FPDF_WIDESTRING)bsQuestion.GetBuffer(bsQuestion.GetLength());
270     FPDF_WIDESTRING pTitle =
271         (FPDF_WIDESTRING)bsTitle.GetBuffer(bsTitle.GetLength());
272     FPDF_WIDESTRING pDefault =
273         (FPDF_WIDESTRING)bsDefault.GetBuffer(bsDefault.GetLength());
274     FPDF_WIDESTRING pLabel =
275         (FPDF_WIDESTRING)bsLabel.GetBuffer(bsLabel.GetLength());
276     int ret = m_pInfo->m_pJsPlatform->app_response(
277         m_pInfo->m_pJsPlatform, pQuestion, pTitle, pDefault, pLabel, bPassword,
278         response, length);
279     bsQuestion.ReleaseBuffer();
280     bsTitle.ReleaseBuffer();
281     bsDefault.ReleaseBuffer();
282     bsLabel.ReleaseBuffer();
283     return ret;
284   }
285   return -1;
286 }
287
288 CFX_WideString CPDFDoc_Environment::JS_fieldBrowse() {
289   if (!m_pInfo || !m_pInfo->m_pJsPlatform ||
290       !m_pInfo->m_pJsPlatform->Field_browse) {
291     return L"";
292   }
293
294   const int nRequiredLen =
295       m_pInfo->m_pJsPlatform->Field_browse(m_pInfo->m_pJsPlatform, nullptr, 0);
296   if (nRequiredLen <= 0)
297     return L"";
298
299   nonstd::unique_ptr<char[]> pBuff(new char[nRequiredLen]);
300   memset(pBuff.get(), 0, nRequiredLen);
301   const int nActualLen = m_pInfo->m_pJsPlatform->Field_browse(
302       m_pInfo->m_pJsPlatform, pBuff.get(), nRequiredLen);
303   if (nActualLen <= 0 || nActualLen > nRequiredLen)
304     return L"";
305
306   CFX_ByteString bsRet = CFX_ByteString(pBuff.get(), nActualLen);
307   CFX_WideString wsRet = CFX_WideString::FromLocal(bsRet);
308   return wsRet;
309 }
310
311 CFX_WideString CPDFDoc_Environment::JS_docGetFilePath() {
312   if (!m_pInfo || !m_pInfo->m_pJsPlatform ||
313       !m_pInfo->m_pJsPlatform->Doc_getFilePath) {
314     return L"";
315   }
316
317   const int nRequiredLen = m_pInfo->m_pJsPlatform->Doc_getFilePath(
318       m_pInfo->m_pJsPlatform, nullptr, 0);
319   if (nRequiredLen <= 0)
320     return L"";
321
322   nonstd::unique_ptr<char[]> pBuff(new char[nRequiredLen]);
323   memset(pBuff.get(), 0, nRequiredLen);
324   const int nActualLen = m_pInfo->m_pJsPlatform->Doc_getFilePath(
325       m_pInfo->m_pJsPlatform, pBuff.get(), nRequiredLen);
326   if (nActualLen <= 0 || nActualLen > nRequiredLen)
327     return L"";
328
329   CFX_ByteString bsRet = CFX_ByteString(pBuff.get(), nActualLen);
330   CFX_WideString wsRet = CFX_WideString::FromLocal(bsRet);
331   return wsRet;
332 }
333
334 void CPDFDoc_Environment::JS_docSubmitForm(void* formData,
335                                            int length,
336                                            const FX_WCHAR* URL) {
337   if (m_pInfo && m_pInfo->m_pJsPlatform &&
338       m_pInfo->m_pJsPlatform->Doc_submitForm) {
339     CFX_ByteString bsDestination = CFX_WideString(URL).UTF16LE_Encode();
340     FPDF_WIDESTRING pDestination =
341         (FPDF_WIDESTRING)bsDestination.GetBuffer(bsDestination.GetLength());
342     m_pInfo->m_pJsPlatform->Doc_submitForm(m_pInfo->m_pJsPlatform, formData,
343                                            length, pDestination);
344     bsDestination.ReleaseBuffer();
345   }
346 }
347
348 void CPDFDoc_Environment::JS_docmailForm(void* mailData,
349                                          int length,
350                                          FPDF_BOOL bUI,
351                                          const FX_WCHAR* To,
352                                          const FX_WCHAR* Subject,
353                                          const FX_WCHAR* CC,
354                                          const FX_WCHAR* BCC,
355                                          const FX_WCHAR* Msg) {
356   if (m_pInfo && m_pInfo->m_pJsPlatform && m_pInfo->m_pJsPlatform->Doc_mail) {
357     CFX_ByteString bsTo = CFX_WideString(To).UTF16LE_Encode();
358     CFX_ByteString bsCC = CFX_WideString(Subject).UTF16LE_Encode();
359     CFX_ByteString bsBcc = CFX_WideString(BCC).UTF16LE_Encode();
360     CFX_ByteString bsSubject = CFX_WideString(Subject).UTF16LE_Encode();
361     CFX_ByteString bsMsg = CFX_WideString(Msg).UTF16LE_Encode();
362     FPDF_WIDESTRING pTo = (FPDF_WIDESTRING)bsTo.GetBuffer(bsTo.GetLength());
363     FPDF_WIDESTRING pCC = (FPDF_WIDESTRING)bsCC.GetBuffer(bsCC.GetLength());
364     FPDF_WIDESTRING pBcc = (FPDF_WIDESTRING)bsBcc.GetBuffer(bsBcc.GetLength());
365     FPDF_WIDESTRING pSubject =
366         (FPDF_WIDESTRING)bsSubject.GetBuffer(bsSubject.GetLength());
367     FPDF_WIDESTRING pMsg = (FPDF_WIDESTRING)bsMsg.GetBuffer(bsMsg.GetLength());
368     m_pInfo->m_pJsPlatform->Doc_mail(m_pInfo->m_pJsPlatform, mailData, length,
369                                      bUI, pTo, pSubject, pCC, pBcc, pMsg);
370     bsTo.ReleaseBuffer();
371     bsCC.ReleaseBuffer();
372     bsBcc.ReleaseBuffer();
373     bsSubject.ReleaseBuffer();
374     bsMsg.ReleaseBuffer();
375   }
376 }
377
378 IJS_Runtime* CPDFDoc_Environment::GetJSRuntime() {
379   if (!IsJSInitiated())
380     return NULL;
381   if (!m_pJSRuntime)
382     m_pJSRuntime.reset(IJS_Runtime::Create(this));
383   return m_pJSRuntime.get();
384 }
385
386 CPDFSDK_AnnotHandlerMgr* CPDFDoc_Environment::GetAnnotHandlerMgr() {
387   if (!m_pAnnotHandlerMgr)
388     m_pAnnotHandlerMgr = new CPDFSDK_AnnotHandlerMgr(this);
389   return m_pAnnotHandlerMgr;
390 }
391
392 CPDFSDK_ActionHandler* CPDFDoc_Environment::GetActionHander() {
393   if (!m_pActionHandler)
394     m_pActionHandler = new CPDFSDK_ActionHandler();
395   return m_pActionHandler;
396 }
397
398 CFFL_IFormFiller* CPDFDoc_Environment::GetIFormFiller() {
399   if (!m_pIFormFiller)
400     m_pIFormFiller = new CFFL_IFormFiller(this);
401   return m_pIFormFiller;
402 }
403
404 CPDFSDK_Document::CPDFSDK_Document(CPDF_Document* pDoc,
405                                    CPDFDoc_Environment* pEnv)
406     : m_pDoc(pDoc),
407       m_pInterForm(nullptr),
408       m_pFocusAnnot(nullptr),
409       m_pEnv(pEnv),
410       m_pOccontent(nullptr),
411       m_bChangeMask(FALSE),
412       m_bBeingDestroyed(FALSE) {
413 }
414
415 CPDFSDK_Document::~CPDFSDK_Document() {
416   m_bBeingDestroyed = TRUE;
417
418   for (auto& it : m_pageMap)
419     it.second->KillFocusAnnotIfNeeded();
420
421   for (auto& it : m_pageMap)
422     delete it.second;
423   m_pageMap.clear();
424
425   delete m_pInterForm;
426   m_pInterForm = nullptr;
427
428   delete m_pOccontent;
429   m_pOccontent = nullptr;
430 }
431
432 CPDFSDK_PageView* CPDFSDK_Document::GetPageView(CPDF_Page* pPDFPage,
433                                                 FX_BOOL ReNew) {
434   auto it = m_pageMap.find(pPDFPage);
435   if (it != m_pageMap.end())
436     return it->second;
437
438   if (!ReNew)
439     return nullptr;
440
441   CPDFSDK_PageView* pPageView = new CPDFSDK_PageView(this, pPDFPage);
442   m_pageMap[pPDFPage] = pPageView;
443   // Delay to load all the annotations, to avoid endless loop.
444   pPageView->LoadFXAnnots();
445   return pPageView;
446 }
447
448 CPDFSDK_PageView* CPDFSDK_Document::GetCurrentView() {
449   CPDF_Page* pPage = (CPDF_Page*)m_pEnv->FFI_GetCurrentPage(m_pDoc);
450   return pPage ? GetPageView(pPage, TRUE) : nullptr;
451 }
452
453 CPDFSDK_PageView* CPDFSDK_Document::GetPageView(int nIndex) {
454   CPDF_Page* pTempPage = (CPDF_Page*)m_pEnv->FFI_GetPage(m_pDoc, nIndex);
455   if (!pTempPage)
456     return nullptr;
457
458   auto it = m_pageMap.find(pTempPage);
459   return it->second;
460 }
461
462 void CPDFSDK_Document::ProcJavascriptFun() {
463   CPDF_Document* pPDFDoc = GetDocument();
464   CPDF_DocJSActions docJS(pPDFDoc);
465   int iCount = docJS.CountJSActions();
466   if (iCount < 1)
467     return;
468   for (int i = 0; i < iCount; i++) {
469     CFX_ByteString csJSName;
470     CPDF_Action jsAction = docJS.GetJSAction(i, csJSName);
471     if (m_pEnv->GetActionHander())
472       m_pEnv->GetActionHander()->DoAction_JavaScript(
473           jsAction, CFX_WideString::FromLocal(csJSName), this);
474   }
475 }
476
477 FX_BOOL CPDFSDK_Document::ProcOpenAction() {
478   if (!m_pDoc)
479     return FALSE;
480
481   CPDF_Dictionary* pRoot = m_pDoc->GetRoot();
482   if (!pRoot)
483     return FALSE;
484
485   CPDF_Object* pOpenAction = pRoot->GetDict("OpenAction");
486   if (!pOpenAction)
487     pOpenAction = pRoot->GetArray("OpenAction");
488
489   if (!pOpenAction)
490     return FALSE;
491
492   if (pOpenAction->IsArray())
493     return TRUE;
494
495   if (CPDF_Dictionary* pDict = pOpenAction->AsDictionary()) {
496     CPDF_Action action(pDict);
497     if (m_pEnv->GetActionHander())
498       m_pEnv->GetActionHander()->DoAction_DocOpen(action, this);
499     return TRUE;
500   }
501   return FALSE;
502 }
503
504 CPDF_OCContext* CPDFSDK_Document::GetOCContext() {
505   if (!m_pOccontent)
506     m_pOccontent = new CPDF_OCContext(m_pDoc);
507   return m_pOccontent;
508 }
509
510 void CPDFSDK_Document::ReMovePageView(CPDF_Page* pPDFPage) {
511   auto it = m_pageMap.find(pPDFPage);
512   if (it == m_pageMap.end())
513     return;
514
515   CPDFSDK_PageView* pPageView = it->second;
516   if (pPageView->IsLocked())
517     return;
518
519   pPageView->KillFocusAnnotIfNeeded();
520   delete pPageView;
521   m_pageMap.erase(it);
522 }
523
524 CPDF_Page* CPDFSDK_Document::GetPage(int nIndex) {
525   CPDF_Page* pTempPage = (CPDF_Page*)m_pEnv->FFI_GetPage(m_pDoc, nIndex);
526   if (!pTempPage)
527     return NULL;
528   return pTempPage;
529 }
530
531 CPDFSDK_InterForm* CPDFSDK_Document::GetInterForm() {
532   if (!m_pInterForm)
533     m_pInterForm = new CPDFSDK_InterForm(this);
534   return m_pInterForm;
535 }
536
537 void CPDFSDK_Document::UpdateAllViews(CPDFSDK_PageView* pSender,
538                                       CPDFSDK_Annot* pAnnot) {
539   for (const auto& it : m_pageMap) {
540     CPDFSDK_PageView* pPageView = it.second;
541     if (pPageView != pSender) {
542       pPageView->UpdateView(pAnnot);
543     }
544   }
545 }
546
547 CPDFSDK_Annot* CPDFSDK_Document::GetFocusAnnot() {
548   return m_pFocusAnnot;
549 }
550
551 FX_BOOL CPDFSDK_Document::SetFocusAnnot(CPDFSDK_Annot* pAnnot, FX_UINT nFlag) {
552   if (m_bBeingDestroyed)
553     return FALSE;
554
555   if (m_pFocusAnnot == pAnnot)
556     return TRUE;
557
558   if (m_pFocusAnnot) {
559     if (!KillFocusAnnot(nFlag))
560       return FALSE;
561   }
562   CPDFSDK_PageView* pPageView = pAnnot->GetPageView();
563   if (pAnnot && pPageView->IsValid()) {
564     CPDFSDK_AnnotHandlerMgr* pAnnotHandler = m_pEnv->GetAnnotHandlerMgr();
565
566     if (pAnnotHandler && !m_pFocusAnnot) {
567       if (!pAnnotHandler->Annot_OnSetFocus(pAnnot, nFlag))
568         return FALSE;
569       if (!m_pFocusAnnot) {
570         m_pFocusAnnot = pAnnot;
571         return TRUE;
572       }
573     }
574   }
575   return FALSE;
576 }
577
578 FX_BOOL CPDFSDK_Document::KillFocusAnnot(FX_UINT nFlag) {
579   if (m_pFocusAnnot) {
580     CPDFSDK_AnnotHandlerMgr* pAnnotHandler = m_pEnv->GetAnnotHandlerMgr();
581     if (pAnnotHandler) {
582       CPDFSDK_Annot* pFocusAnnot = m_pFocusAnnot;
583       m_pFocusAnnot = NULL;
584       if (pAnnotHandler->Annot_OnKillFocus(pFocusAnnot, nFlag)) {
585         if (pFocusAnnot->GetType() == FX_BSTRC("Widget")) {
586           CPDFSDK_Widget* pWidget = (CPDFSDK_Widget*)pFocusAnnot;
587           int nFieldType = pWidget->GetFieldType();
588           if (FIELDTYPE_TEXTFIELD == nFieldType ||
589               FIELDTYPE_COMBOBOX == nFieldType)
590             m_pEnv->FFI_OnSetFieldInputFocus(NULL, NULL, 0, FALSE);
591         }
592
593         if (!m_pFocusAnnot)
594           return TRUE;
595       } else {
596         m_pFocusAnnot = pFocusAnnot;
597       }
598     }
599   }
600   return FALSE;
601 }
602
603 void CPDFSDK_Document::OnCloseDocument() {
604   KillFocusAnnot();
605 }
606
607 FX_BOOL CPDFSDK_Document::GetPermissions(int nFlag) {
608   FX_DWORD dwPermissions = m_pDoc->GetUserPermissions();
609   return dwPermissions & nFlag;
610 }
611
612 IJS_Runtime* CPDFSDK_Document::GetJsRuntime() {
613   ASSERT(m_pEnv != NULL);
614   return m_pEnv->GetJSRuntime();
615 }
616
617 CFX_WideString CPDFSDK_Document::GetPath() {
618   ASSERT(m_pEnv != NULL);
619   return m_pEnv->JS_docGetFilePath();
620 }
621
622 CPDFSDK_PageView::CPDFSDK_PageView(CPDFSDK_Document* pSDKDoc, CPDF_Page* page)
623     : m_page(page),
624       m_pSDKDoc(pSDKDoc),
625       m_CaptureWidget(nullptr),
626       m_bEnterWidget(FALSE),
627       m_bExitWidget(FALSE),
628       m_bOnWidget(FALSE),
629       m_bValid(FALSE),
630       m_bLocked(FALSE),
631       m_bTakeOverPage(FALSE) {
632   CPDFSDK_InterForm* pInterForm = pSDKDoc->GetInterForm();
633   if (pInterForm) {
634     CPDF_InterForm* pPDFInterForm = pInterForm->GetInterForm();
635     pPDFInterForm->FixPageFields(page);
636   }
637   m_page->SetPrivateData((void*)m_page, (void*)this, nullptr);
638 }
639
640 CPDFSDK_PageView::~CPDFSDK_PageView() {
641   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
642   CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
643   for (CPDFSDK_Annot* pAnnot : m_fxAnnotArray)
644     pAnnotHandlerMgr->ReleaseAnnot(pAnnot);
645   m_fxAnnotArray.clear();
646
647   m_pAnnotList.reset();
648
649   m_page->RemovePrivateData((void*)m_page);
650   if (m_bTakeOverPage) {
651     delete m_page;
652   }
653 }
654
655 void CPDFSDK_PageView::PageView_OnDraw(CFX_RenderDevice* pDevice,
656                                        CPDF_Matrix* pUser2Device,
657                                        CPDF_RenderOptions* pOptions) {
658   m_curMatrix = *pUser2Device;
659
660   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
661   CPDFSDK_AnnotIterator annotIterator(this, true);
662   while (CPDFSDK_Annot* pSDKAnnot = annotIterator.Next()) {
663     CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
664     pAnnotHandlerMgr->Annot_OnDraw(this, pSDKAnnot, pDevice, pUser2Device, 0);
665   }
666 }
667
668 CPDF_Annot* CPDFSDK_PageView::GetPDFAnnotAtPoint(FX_FLOAT pageX,
669                                                  FX_FLOAT pageY) {
670   const int nCount = m_pAnnotList->Count();
671   for (int i = 0; i < nCount; ++i) {
672     CPDF_Annot* pAnnot = m_pAnnotList->GetAt(i);
673     CFX_FloatRect annotRect;
674     pAnnot->GetRect(annotRect);
675     if (annotRect.Contains(pageX, pageY))
676       return pAnnot;
677   }
678   return nullptr;
679 }
680
681 CPDF_Annot* CPDFSDK_PageView::GetPDFWidgetAtPoint(FX_FLOAT pageX,
682                                                   FX_FLOAT pageY) {
683   const int nCount = m_pAnnotList->Count();
684   for (int i = 0; i < nCount; ++i) {
685     CPDF_Annot* pAnnot = m_pAnnotList->GetAt(i);
686     if (pAnnot->GetSubType() == "Widget") {
687       CFX_FloatRect annotRect;
688       pAnnot->GetRect(annotRect);
689       if (annotRect.Contains(pageX, pageY))
690         return pAnnot;
691     }
692   }
693   return nullptr;
694 }
695
696 CPDFSDK_Annot* CPDFSDK_PageView::GetFXAnnotAtPoint(FX_FLOAT pageX,
697                                                    FX_FLOAT pageY) {
698   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
699   CPDFSDK_AnnotHandlerMgr* pAnnotMgr = pEnv->GetAnnotHandlerMgr();
700   CPDFSDK_AnnotIterator annotIterator(this, false);
701   while (CPDFSDK_Annot* pSDKAnnot = annotIterator.Next()) {
702     CPDF_Rect rc = pAnnotMgr->Annot_OnGetViewBBox(this, pSDKAnnot);
703     if (rc.Contains(pageX, pageY))
704       return pSDKAnnot;
705   }
706
707   return nullptr;
708 }
709
710 CPDFSDK_Annot* CPDFSDK_PageView::GetFXWidgetAtPoint(FX_FLOAT pageX,
711                                                     FX_FLOAT pageY) {
712   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
713   CPDFSDK_AnnotHandlerMgr* pAnnotMgr = pEnv->GetAnnotHandlerMgr();
714   CPDFSDK_AnnotIterator annotIterator(this, false);
715   while (CPDFSDK_Annot* pSDKAnnot = annotIterator.Next()) {
716     if (pSDKAnnot->GetType() == "Widget") {
717       pAnnotMgr->Annot_OnGetViewBBox(this, pSDKAnnot);
718       CPDF_Point point(pageX, pageY);
719       if (pAnnotMgr->Annot_OnHitTest(this, pSDKAnnot, point))
720         return pSDKAnnot;
721     }
722   }
723
724   return nullptr;
725 }
726
727 void CPDFSDK_PageView::KillFocusAnnotIfNeeded() {
728   // if there is a focused annot on the page, we should kill the focus first.
729   if (CPDFSDK_Annot* focusedAnnot = m_pSDKDoc->GetFocusAnnot()) {
730     auto it =
731         std::find(m_fxAnnotArray.begin(), m_fxAnnotArray.end(), focusedAnnot);
732     if (it != m_fxAnnotArray.end())
733       KillFocusAnnot();
734   }
735 }
736
737 FX_BOOL CPDFSDK_PageView::Annot_HasAppearance(CPDF_Annot* pAnnot) {
738   CPDF_Dictionary* pAnnotDic = pAnnot->GetAnnotDict();
739   if (pAnnotDic)
740     return pAnnotDic->KeyExist("AS");
741   return FALSE;
742 }
743
744 CPDFSDK_Annot* CPDFSDK_PageView::AddAnnot(CPDF_Annot* pPDFAnnot) {
745   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
746   ASSERT(pEnv);
747   CPDFSDK_AnnotHandlerMgr* pAnnotHandler = pEnv->GetAnnotHandlerMgr();
748   if (!pAnnotHandler)
749     return nullptr;
750
751   CPDFSDK_Annot* pSDKAnnot = pAnnotHandler->NewAnnot(pPDFAnnot, this);
752   if (!pSDKAnnot)
753     return nullptr;
754
755   m_fxAnnotArray.push_back(pSDKAnnot);
756   pAnnotHandler->Annot_OnCreate(pSDKAnnot);
757   return pSDKAnnot;
758 }
759
760 CPDFSDK_Annot* CPDFSDK_PageView::AddAnnot(CPDF_Dictionary* pDict) {
761   return pDict ? AddAnnot(pDict->GetString("Subtype"), pDict) : nullptr;
762 }
763
764 CPDFSDK_Annot* CPDFSDK_PageView::AddAnnot(const FX_CHAR* lpSubType,
765                                           CPDF_Dictionary* pDict) {
766   return NULL;
767 }
768
769 FX_BOOL CPDFSDK_PageView::DeleteAnnot(CPDFSDK_Annot* pAnnot) {
770   return FALSE;
771 }
772
773 CPDF_Document* CPDFSDK_PageView::GetPDFDocument() {
774   if (m_page) {
775     return m_page->m_pDocument;
776   }
777   return NULL;
778 }
779
780 size_t CPDFSDK_PageView::CountAnnots() const {
781   return m_fxAnnotArray.size();
782 }
783
784 CPDFSDK_Annot* CPDFSDK_PageView::GetAnnot(size_t nIndex) {
785   return nIndex < m_fxAnnotArray.size() ? m_fxAnnotArray[nIndex] : nullptr;
786 }
787
788 CPDFSDK_Annot* CPDFSDK_PageView::GetAnnotByDict(CPDF_Dictionary* pDict) {
789   for (CPDFSDK_Annot* pAnnot : m_fxAnnotArray) {
790     if (pAnnot->GetPDFAnnot()->GetAnnotDict() == pDict)
791       return pAnnot;
792   }
793   return nullptr;
794 }
795
796 FX_BOOL CPDFSDK_PageView::OnLButtonDown(const CPDF_Point& point,
797                                         FX_UINT nFlag) {
798   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
799   ASSERT(pEnv);
800   CPDFSDK_Annot* pFXAnnot = GetFXWidgetAtPoint(point.x, point.y);
801   if (!pFXAnnot) {
802     KillFocusAnnot(nFlag);
803   } else {
804     CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
805     ASSERT(pAnnotHandlerMgr);
806
807     FX_BOOL bRet =
808         pAnnotHandlerMgr->Annot_OnLButtonDown(this, pFXAnnot, nFlag, point);
809     if (bRet) {
810       SetFocusAnnot(pFXAnnot);
811     }
812     return bRet;
813   }
814   return FALSE;
815 }
816
817 FX_BOOL CPDFSDK_PageView::OnLButtonUp(const CPDF_Point& point, FX_UINT nFlag) {
818   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
819   ASSERT(pEnv);
820   CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
821   ASSERT(pAnnotHandlerMgr);
822   CPDFSDK_Annot* pFXAnnot = GetFXWidgetAtPoint(point.x, point.y);
823   CPDFSDK_Annot* pFocusAnnot = GetFocusAnnot();
824   FX_BOOL bRet = FALSE;
825   if (pFocusAnnot && pFocusAnnot != pFXAnnot) {
826     // Last focus Annot gets a chance to handle the event.
827     bRet = pAnnotHandlerMgr->Annot_OnLButtonUp(this, pFocusAnnot, nFlag, point);
828   }
829   if (pFXAnnot && !bRet) {
830     bRet = pAnnotHandlerMgr->Annot_OnLButtonUp(this, pFXAnnot, nFlag, point);
831     return bRet;
832   }
833   return bRet;
834 }
835
836 FX_BOOL CPDFSDK_PageView::OnMouseMove(const CPDF_Point& point, int nFlag) {
837   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
838   CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
839   ASSERT(pAnnotHandlerMgr);
840   if (CPDFSDK_Annot* pFXAnnot = GetFXWidgetAtPoint(point.x, point.y)) {
841     if (m_CaptureWidget && m_CaptureWidget != pFXAnnot) {
842       m_bExitWidget = TRUE;
843       m_bEnterWidget = FALSE;
844       pAnnotHandlerMgr->Annot_OnMouseExit(this, m_CaptureWidget, nFlag);
845     }
846     m_CaptureWidget = (CPDFSDK_Widget*)pFXAnnot;
847     m_bOnWidget = TRUE;
848     if (!m_bEnterWidget) {
849       m_bEnterWidget = TRUE;
850       m_bExitWidget = FALSE;
851       pAnnotHandlerMgr->Annot_OnMouseEnter(this, pFXAnnot, nFlag);
852     }
853     pAnnotHandlerMgr->Annot_OnMouseMove(this, pFXAnnot, nFlag, point);
854     return TRUE;
855   }
856   if (m_bOnWidget) {
857     m_bOnWidget = FALSE;
858     m_bExitWidget = TRUE;
859     m_bEnterWidget = FALSE;
860     if (m_CaptureWidget) {
861       pAnnotHandlerMgr->Annot_OnMouseExit(this, m_CaptureWidget, nFlag);
862       m_CaptureWidget = NULL;
863     }
864   }
865   return FALSE;
866 }
867
868 FX_BOOL CPDFSDK_PageView::OnMouseWheel(double deltaX,
869                                        double deltaY,
870                                        const CPDF_Point& point,
871                                        int nFlag) {
872   if (CPDFSDK_Annot* pAnnot = GetFXWidgetAtPoint(point.x, point.y)) {
873     CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
874     CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
875     ASSERT(pAnnotHandlerMgr);
876     return pAnnotHandlerMgr->Annot_OnMouseWheel(this, pAnnot, nFlag,
877                                                 (int)deltaY, point);
878   }
879   return FALSE;
880 }
881
882 FX_BOOL CPDFSDK_PageView::OnChar(int nChar, FX_UINT nFlag) {
883   if (CPDFSDK_Annot* pAnnot = GetFocusAnnot()) {
884     CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
885     CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
886     ASSERT(pAnnotHandlerMgr);
887     return pAnnotHandlerMgr->Annot_OnChar(pAnnot, nChar, nFlag);
888   }
889
890   return FALSE;
891 }
892
893 FX_BOOL CPDFSDK_PageView::OnKeyDown(int nKeyCode, int nFlag) {
894   if (CPDFSDK_Annot* pAnnot = GetFocusAnnot()) {
895     CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
896     CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
897     ASSERT(pAnnotHandlerMgr);
898     return pAnnotHandlerMgr->Annot_OnKeyDown(pAnnot, nKeyCode, nFlag);
899   }
900   return FALSE;
901 }
902
903 FX_BOOL CPDFSDK_PageView::OnKeyUp(int nKeyCode, int nFlag) {
904   return FALSE;
905 }
906
907 void CPDFSDK_PageView::LoadFXAnnots() {
908   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
909
910   FX_BOOL enableAPUpdate = CPDF_InterForm::UpdatingAPEnabled();
911   // Disable the default AP construction.
912   CPDF_InterForm::EnableUpdateAP(FALSE);
913   m_pAnnotList.reset(new CPDF_AnnotList(m_page));
914   CPDF_InterForm::EnableUpdateAP(enableAPUpdate);
915   const int nCount = m_pAnnotList->Count();
916   SetLock(TRUE);
917   for (int i = 0; i < nCount; ++i) {
918     CPDF_Annot* pPDFAnnot = m_pAnnotList->GetAt(i);
919     CPDF_Document* pDoc = GetPDFDocument();
920
921     CheckUnSupportAnnot(pDoc, pPDFAnnot);
922
923     CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
924     CPDFSDK_Annot* pAnnot = pAnnotHandlerMgr->NewAnnot(pPDFAnnot, this);
925     if (!pAnnot)
926       continue;
927     m_fxAnnotArray.push_back(pAnnot);
928
929     pAnnotHandlerMgr->Annot_OnLoad(pAnnot);
930   }
931   SetLock(FALSE);
932 }
933
934 void CPDFSDK_PageView::UpdateRects(CFX_RectArray& rects) {
935   for (int i = 0; i < rects.GetSize(); i++) {
936     CPDF_Rect rc = rects.GetAt(i);
937     CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
938     pEnv->FFI_Invalidate(m_page, rc.left, rc.top, rc.right, rc.bottom);
939   }
940 }
941
942 void CPDFSDK_PageView::UpdateView(CPDFSDK_Annot* pAnnot) {
943   CPDF_Rect rcWindow = pAnnot->GetRect();
944   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
945   pEnv->FFI_Invalidate(m_page, rcWindow.left, rcWindow.top, rcWindow.right,
946                        rcWindow.bottom);
947 }
948
949 int CPDFSDK_PageView::GetPageIndex() {
950   if (m_page) {
951     CPDF_Dictionary* pDic = m_page->m_pFormDict;
952     CPDF_Document* pDoc = m_pSDKDoc->GetDocument();
953     if (pDoc && pDic) {
954       return pDoc->GetPageIndex(pDic->GetObjNum());
955     }
956   }
957   return -1;
958 }
959
960 FX_BOOL CPDFSDK_PageView::IsValidAnnot(CPDF_Annot* p) const {
961   if (!p)
962     return FALSE;
963
964   const int nCount = m_pAnnotList->Count();
965   for (int i = 0; i < nCount; ++i) {
966     if (m_pAnnotList->GetAt(i) == p)
967       return TRUE;
968   }
969   return FALSE;
970 }
971
972 CPDFSDK_Annot* CPDFSDK_PageView::GetFocusAnnot() {
973   CPDFSDK_Annot* pFocusAnnot = m_pSDKDoc->GetFocusAnnot();
974   if (!pFocusAnnot)
975     return nullptr;
976
977   for (CPDFSDK_Annot* pAnnot : m_fxAnnotArray) {
978     if (pAnnot == pFocusAnnot)
979       return pAnnot;
980   }
981   return nullptr;
982 }