2797bc8f9a7f186f31adca1fe0a18a56b328b5cf
[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_pInfo(pFFinfo), m_pSDKDoc(NULL), m_pPDFDoc(pDoc) {
214   m_pSysHandler.reset(new CFX_SystemHandler(this));
215 }
216
217 CPDFDoc_Environment::~CPDFDoc_Environment() {
218 }
219
220 int CPDFDoc_Environment::JS_appAlert(const FX_WCHAR* Msg,
221                                      const FX_WCHAR* Title,
222                                      FX_UINT Type,
223                                      FX_UINT Icon) {
224   if (m_pInfo && m_pInfo->m_pJsPlatform && m_pInfo->m_pJsPlatform->app_alert) {
225     CFX_ByteString bsMsg = CFX_WideString(Msg).UTF16LE_Encode();
226     CFX_ByteString bsTitle = CFX_WideString(Title).UTF16LE_Encode();
227     FPDF_WIDESTRING pMsg = (FPDF_WIDESTRING)bsMsg.GetBuffer(bsMsg.GetLength());
228     FPDF_WIDESTRING pTitle =
229         (FPDF_WIDESTRING)bsTitle.GetBuffer(bsTitle.GetLength());
230     int ret = m_pInfo->m_pJsPlatform->app_alert(m_pInfo->m_pJsPlatform, pMsg,
231                                                 pTitle, Type, Icon);
232     bsMsg.ReleaseBuffer();
233     bsTitle.ReleaseBuffer();
234     return ret;
235   }
236   return -1;
237 }
238
239 int CPDFDoc_Environment::JS_appResponse(const FX_WCHAR* Question,
240                                         const FX_WCHAR* Title,
241                                         const FX_WCHAR* Default,
242                                         const FX_WCHAR* cLabel,
243                                         FPDF_BOOL bPassword,
244                                         void* response,
245                                         int length) {
246   if (m_pInfo && m_pInfo->m_pJsPlatform &&
247       m_pInfo->m_pJsPlatform->app_response) {
248     CFX_ByteString bsQuestion = CFX_WideString(Question).UTF16LE_Encode();
249     CFX_ByteString bsTitle = CFX_WideString(Title).UTF16LE_Encode();
250     CFX_ByteString bsDefault = CFX_WideString(Default).UTF16LE_Encode();
251     CFX_ByteString bsLabel = CFX_WideString(cLabel).UTF16LE_Encode();
252     FPDF_WIDESTRING pQuestion =
253         (FPDF_WIDESTRING)bsQuestion.GetBuffer(bsQuestion.GetLength());
254     FPDF_WIDESTRING pTitle =
255         (FPDF_WIDESTRING)bsTitle.GetBuffer(bsTitle.GetLength());
256     FPDF_WIDESTRING pDefault =
257         (FPDF_WIDESTRING)bsDefault.GetBuffer(bsDefault.GetLength());
258     FPDF_WIDESTRING pLabel =
259         (FPDF_WIDESTRING)bsLabel.GetBuffer(bsLabel.GetLength());
260     int ret = m_pInfo->m_pJsPlatform->app_response(
261         m_pInfo->m_pJsPlatform, pQuestion, pTitle, pDefault, pLabel, bPassword,
262         response, length);
263     bsQuestion.ReleaseBuffer();
264     bsTitle.ReleaseBuffer();
265     bsDefault.ReleaseBuffer();
266     bsLabel.ReleaseBuffer();
267     return ret;
268   }
269   return -1;
270 }
271
272 CFX_WideString CPDFDoc_Environment::JS_fieldBrowse() {
273   if (!m_pInfo || !m_pInfo->m_pJsPlatform ||
274       !m_pInfo->m_pJsPlatform->Field_browse) {
275     return L"";
276   }
277
278   const int nRequiredLen =
279       m_pInfo->m_pJsPlatform->Field_browse(m_pInfo->m_pJsPlatform, nullptr, 0);
280   if (nRequiredLen <= 0)
281     return L"";
282
283   nonstd::unique_ptr<char[]> pBuff(new char[nRequiredLen]);
284   memset(pBuff.get(), 0, nRequiredLen);
285   const int nActualLen = m_pInfo->m_pJsPlatform->Field_browse(
286       m_pInfo->m_pJsPlatform, pBuff.get(), nRequiredLen);
287   if (nActualLen <= 0 || nActualLen > nRequiredLen)
288     return L"";
289
290   CFX_ByteString bsRet = CFX_ByteString(pBuff.get(), nActualLen);
291   CFX_WideString wsRet = CFX_WideString::FromLocal(bsRet);
292   return wsRet;
293 }
294
295 CFX_WideString CPDFDoc_Environment::JS_docGetFilePath() {
296   if (!m_pInfo || !m_pInfo->m_pJsPlatform ||
297       !m_pInfo->m_pJsPlatform->Doc_getFilePath) {
298     return L"";
299   }
300
301   const int nRequiredLen = m_pInfo->m_pJsPlatform->Doc_getFilePath(
302       m_pInfo->m_pJsPlatform, nullptr, 0);
303   if (nRequiredLen <= 0)
304     return L"";
305
306   nonstd::unique_ptr<char[]> pBuff(new char[nRequiredLen]);
307   memset(pBuff.get(), 0, nRequiredLen);
308   const int nActualLen = m_pInfo->m_pJsPlatform->Doc_getFilePath(
309       m_pInfo->m_pJsPlatform, pBuff.get(), nRequiredLen);
310   if (nActualLen <= 0 || nActualLen > nRequiredLen)
311     return L"";
312
313   CFX_ByteString bsRet = CFX_ByteString(pBuff.get(), nActualLen);
314   CFX_WideString wsRet = CFX_WideString::FromLocal(bsRet);
315   return wsRet;
316 }
317
318 void CPDFDoc_Environment::JS_docSubmitForm(void* formData,
319                                            int length,
320                                            const FX_WCHAR* URL) {
321   if (m_pInfo && m_pInfo->m_pJsPlatform &&
322       m_pInfo->m_pJsPlatform->Doc_submitForm) {
323     CFX_ByteString bsDestination = CFX_WideString(URL).UTF16LE_Encode();
324     FPDF_WIDESTRING pDestination =
325         (FPDF_WIDESTRING)bsDestination.GetBuffer(bsDestination.GetLength());
326     m_pInfo->m_pJsPlatform->Doc_submitForm(m_pInfo->m_pJsPlatform, formData,
327                                            length, pDestination);
328     bsDestination.ReleaseBuffer();
329   }
330 }
331
332 void CPDFDoc_Environment::JS_docmailForm(void* mailData,
333                                          int length,
334                                          FPDF_BOOL bUI,
335                                          const FX_WCHAR* To,
336                                          const FX_WCHAR* Subject,
337                                          const FX_WCHAR* CC,
338                                          const FX_WCHAR* BCC,
339                                          const FX_WCHAR* Msg) {
340   if (m_pInfo && m_pInfo->m_pJsPlatform && m_pInfo->m_pJsPlatform->Doc_mail) {
341     CFX_ByteString bsTo = CFX_WideString(To).UTF16LE_Encode();
342     CFX_ByteString bsCC = CFX_WideString(Subject).UTF16LE_Encode();
343     CFX_ByteString bsBcc = CFX_WideString(BCC).UTF16LE_Encode();
344     CFX_ByteString bsSubject = CFX_WideString(Subject).UTF16LE_Encode();
345     CFX_ByteString bsMsg = CFX_WideString(Msg).UTF16LE_Encode();
346     FPDF_WIDESTRING pTo = (FPDF_WIDESTRING)bsTo.GetBuffer(bsTo.GetLength());
347     FPDF_WIDESTRING pCC = (FPDF_WIDESTRING)bsCC.GetBuffer(bsCC.GetLength());
348     FPDF_WIDESTRING pBcc = (FPDF_WIDESTRING)bsBcc.GetBuffer(bsBcc.GetLength());
349     FPDF_WIDESTRING pSubject =
350         (FPDF_WIDESTRING)bsSubject.GetBuffer(bsSubject.GetLength());
351     FPDF_WIDESTRING pMsg = (FPDF_WIDESTRING)bsMsg.GetBuffer(bsMsg.GetLength());
352     m_pInfo->m_pJsPlatform->Doc_mail(m_pInfo->m_pJsPlatform, mailData, length,
353                                      bUI, pTo, pSubject, pCC, pBcc, pMsg);
354     bsTo.ReleaseBuffer();
355     bsCC.ReleaseBuffer();
356     bsBcc.ReleaseBuffer();
357     bsSubject.ReleaseBuffer();
358     bsMsg.ReleaseBuffer();
359   }
360 }
361
362 IJS_Runtime* CPDFDoc_Environment::GetJSRuntime() {
363   if (!IsJSInitiated())
364     return NULL;
365   if (!m_pJSRuntime)
366     m_pJSRuntime.reset(IJS_Runtime::Create(this));
367   return m_pJSRuntime.get();
368 }
369
370 CPDFSDK_AnnotHandlerMgr* CPDFDoc_Environment::GetAnnotHandlerMgr() {
371   if (!m_pAnnotHandlerMgr)
372     m_pAnnotHandlerMgr.reset(new CPDFSDK_AnnotHandlerMgr(this));
373   return m_pAnnotHandlerMgr.get();
374 }
375
376 CPDFSDK_ActionHandler* CPDFDoc_Environment::GetActionHander() {
377   if (!m_pActionHandler)
378     m_pActionHandler.reset(new CPDFSDK_ActionHandler());
379   return m_pActionHandler.get();
380 }
381
382 CFFL_IFormFiller* CPDFDoc_Environment::GetIFormFiller() {
383   if (!m_pIFormFiller)
384     m_pIFormFiller.reset(new CFFL_IFormFiller(this));
385   return m_pIFormFiller.get();
386 }
387
388 CPDFSDK_Document::CPDFSDK_Document(CPDF_Document* pDoc,
389                                    CPDFDoc_Environment* pEnv)
390     : m_pDoc(pDoc), m_pFocusAnnot(nullptr), m_pEnv(pEnv), m_bChangeMask(FALSE) {
391 }
392
393 CPDFSDK_Document::~CPDFSDK_Document() {
394   m_bBeingDestroyed = TRUE;
395
396   for (auto& it : m_pageMap)
397     it.second->KillFocusAnnotIfNeeded();
398
399   for (auto& it : m_pageMap)
400     delete it.second;
401   m_pageMap.clear();
402 }
403
404 CPDFSDK_PageView* CPDFSDK_Document::GetPageView(CPDF_Page* pPDFPage,
405                                                 FX_BOOL ReNew) {
406   auto it = m_pageMap.find(pPDFPage);
407   if (it != m_pageMap.end())
408     return it->second;
409
410   if (!ReNew)
411     return nullptr;
412
413   CPDFSDK_PageView* pPageView = new CPDFSDK_PageView(this, pPDFPage);
414   m_pageMap[pPDFPage] = pPageView;
415   // Delay to load all the annotations, to avoid endless loop.
416   pPageView->LoadFXAnnots();
417   return pPageView;
418 }
419
420 CPDFSDK_PageView* CPDFSDK_Document::GetCurrentView() {
421   CPDF_Page* pPage = (CPDF_Page*)m_pEnv->FFI_GetCurrentPage(m_pDoc);
422   return pPage ? GetPageView(pPage, TRUE) : nullptr;
423 }
424
425 CPDFSDK_PageView* CPDFSDK_Document::GetPageView(int nIndex) {
426   CPDF_Page* pTempPage = (CPDF_Page*)m_pEnv->FFI_GetPage(m_pDoc, nIndex);
427   if (!pTempPage)
428     return nullptr;
429
430   auto it = m_pageMap.find(pTempPage);
431   return it->second;
432 }
433
434 void CPDFSDK_Document::ProcJavascriptFun() {
435   CPDF_Document* pPDFDoc = GetDocument();
436   CPDF_DocJSActions docJS(pPDFDoc);
437   int iCount = docJS.CountJSActions();
438   if (iCount < 1)
439     return;
440   for (int i = 0; i < iCount; i++) {
441     CFX_ByteString csJSName;
442     CPDF_Action jsAction = docJS.GetJSAction(i, csJSName);
443     if (m_pEnv->GetActionHander())
444       m_pEnv->GetActionHander()->DoAction_JavaScript(
445           jsAction, CFX_WideString::FromLocal(csJSName), this);
446   }
447 }
448
449 FX_BOOL CPDFSDK_Document::ProcOpenAction() {
450   if (!m_pDoc)
451     return FALSE;
452
453   CPDF_Dictionary* pRoot = m_pDoc->GetRoot();
454   if (!pRoot)
455     return FALSE;
456
457   CPDF_Object* pOpenAction = pRoot->GetDict("OpenAction");
458   if (!pOpenAction)
459     pOpenAction = pRoot->GetArray("OpenAction");
460
461   if (!pOpenAction)
462     return FALSE;
463
464   if (pOpenAction->IsArray())
465     return TRUE;
466
467   if (CPDF_Dictionary* pDict = pOpenAction->AsDictionary()) {
468     CPDF_Action action(pDict);
469     if (m_pEnv->GetActionHander())
470       m_pEnv->GetActionHander()->DoAction_DocOpen(action, this);
471     return TRUE;
472   }
473   return FALSE;
474 }
475
476 CPDF_OCContext* CPDFSDK_Document::GetOCContext() {
477   if (!m_pOccontent)
478     m_pOccontent.reset(new CPDF_OCContext(m_pDoc));
479   return m_pOccontent.get();
480 }
481
482 void CPDFSDK_Document::ReMovePageView(CPDF_Page* pPDFPage) {
483   auto it = m_pageMap.find(pPDFPage);
484   if (it == m_pageMap.end())
485     return;
486
487   CPDFSDK_PageView* pPageView = it->second;
488   if (pPageView->IsLocked())
489     return;
490
491   pPageView->KillFocusAnnotIfNeeded();
492   delete pPageView;
493   m_pageMap.erase(it);
494 }
495
496 CPDF_Page* CPDFSDK_Document::GetPage(int nIndex) {
497   CPDF_Page* pTempPage = (CPDF_Page*)m_pEnv->FFI_GetPage(m_pDoc, nIndex);
498   if (!pTempPage)
499     return NULL;
500   return pTempPage;
501 }
502
503 CPDFSDK_InterForm* CPDFSDK_Document::GetInterForm() {
504   if (!m_pInterForm)
505     m_pInterForm.reset(new CPDFSDK_InterForm(this));
506   return m_pInterForm.get();
507 }
508
509 void CPDFSDK_Document::UpdateAllViews(CPDFSDK_PageView* pSender,
510                                       CPDFSDK_Annot* pAnnot) {
511   for (const auto& it : m_pageMap) {
512     CPDFSDK_PageView* pPageView = it.second;
513     if (pPageView != pSender) {
514       pPageView->UpdateView(pAnnot);
515     }
516   }
517 }
518
519 CPDFSDK_Annot* CPDFSDK_Document::GetFocusAnnot() {
520   return m_pFocusAnnot;
521 }
522
523 FX_BOOL CPDFSDK_Document::SetFocusAnnot(CPDFSDK_Annot* pAnnot, FX_UINT nFlag) {
524   if (m_bBeingDestroyed)
525     return FALSE;
526
527   if (m_pFocusAnnot == pAnnot)
528     return TRUE;
529
530   if (m_pFocusAnnot) {
531     if (!KillFocusAnnot(nFlag))
532       return FALSE;
533   }
534   CPDFSDK_PageView* pPageView = pAnnot->GetPageView();
535   if (pAnnot && pPageView->IsValid()) {
536     CPDFSDK_AnnotHandlerMgr* pAnnotHandler = m_pEnv->GetAnnotHandlerMgr();
537     if (!m_pFocusAnnot) {
538       if (!pAnnotHandler->Annot_OnSetFocus(pAnnot, nFlag))
539         return FALSE;
540       if (!m_pFocusAnnot) {
541         m_pFocusAnnot = pAnnot;
542         return TRUE;
543       }
544     }
545   }
546   return FALSE;
547 }
548
549 FX_BOOL CPDFSDK_Document::KillFocusAnnot(FX_UINT nFlag) {
550   if (m_pFocusAnnot) {
551     CPDFSDK_AnnotHandlerMgr* pAnnotHandler = m_pEnv->GetAnnotHandlerMgr();
552     CPDFSDK_Annot* pFocusAnnot = m_pFocusAnnot;
553     m_pFocusAnnot = nullptr;
554     if (pAnnotHandler->Annot_OnKillFocus(pFocusAnnot, nFlag)) {
555       if (pFocusAnnot->GetType() == FX_BSTRC("Widget")) {
556         CPDFSDK_Widget* pWidget = (CPDFSDK_Widget*)pFocusAnnot;
557         int nFieldType = pWidget->GetFieldType();
558         if (FIELDTYPE_TEXTFIELD == nFieldType ||
559             FIELDTYPE_COMBOBOX == nFieldType) {
560           m_pEnv->FFI_OnSetFieldInputFocus(NULL, NULL, 0, FALSE);
561         }
562       }
563
564       if (!m_pFocusAnnot)
565         return TRUE;
566     } else {
567       m_pFocusAnnot = pFocusAnnot;
568     }
569   }
570   return FALSE;
571 }
572
573 void CPDFSDK_Document::OnCloseDocument() {
574   KillFocusAnnot();
575 }
576
577 FX_BOOL CPDFSDK_Document::GetPermissions(int nFlag) {
578   FX_DWORD dwPermissions = m_pDoc->GetUserPermissions();
579   return dwPermissions & nFlag;
580 }
581
582 IJS_Runtime* CPDFSDK_Document::GetJsRuntime() {
583   ASSERT(m_pEnv != NULL);
584   return m_pEnv->GetJSRuntime();
585 }
586
587 CFX_WideString CPDFSDK_Document::GetPath() {
588   ASSERT(m_pEnv != NULL);
589   return m_pEnv->JS_docGetFilePath();
590 }
591
592 CPDFSDK_PageView::CPDFSDK_PageView(CPDFSDK_Document* pSDKDoc, CPDF_Page* page)
593     : m_page(page),
594       m_pSDKDoc(pSDKDoc),
595       m_CaptureWidget(nullptr),
596       m_bEnterWidget(FALSE),
597       m_bExitWidget(FALSE),
598       m_bOnWidget(FALSE),
599       m_bValid(FALSE),
600       m_bLocked(FALSE),
601       m_bTakeOverPage(FALSE) {
602   CPDFSDK_InterForm* pInterForm = pSDKDoc->GetInterForm();
603   if (pInterForm) {
604     CPDF_InterForm* pPDFInterForm = pInterForm->GetInterForm();
605     pPDFInterForm->FixPageFields(page);
606   }
607   m_page->SetPrivateData((void*)m_page, (void*)this, nullptr);
608 }
609
610 CPDFSDK_PageView::~CPDFSDK_PageView() {
611   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
612   CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
613   for (CPDFSDK_Annot* pAnnot : m_fxAnnotArray)
614     pAnnotHandlerMgr->ReleaseAnnot(pAnnot);
615   m_fxAnnotArray.clear();
616
617   m_pAnnotList.reset();
618
619   m_page->RemovePrivateData((void*)m_page);
620   if (m_bTakeOverPage) {
621     delete m_page;
622   }
623 }
624
625 void CPDFSDK_PageView::PageView_OnDraw(CFX_RenderDevice* pDevice,
626                                        CPDF_Matrix* pUser2Device,
627                                        CPDF_RenderOptions* pOptions) {
628   m_curMatrix = *pUser2Device;
629
630   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
631   CPDFSDK_AnnotIterator annotIterator(this, true);
632   while (CPDFSDK_Annot* pSDKAnnot = annotIterator.Next()) {
633     CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
634     pAnnotHandlerMgr->Annot_OnDraw(this, pSDKAnnot, pDevice, pUser2Device, 0);
635   }
636 }
637
638 CPDF_Annot* CPDFSDK_PageView::GetPDFAnnotAtPoint(FX_FLOAT pageX,
639                                                  FX_FLOAT pageY) {
640   const int nCount = m_pAnnotList->Count();
641   for (int i = 0; i < nCount; ++i) {
642     CPDF_Annot* pAnnot = m_pAnnotList->GetAt(i);
643     CFX_FloatRect annotRect;
644     pAnnot->GetRect(annotRect);
645     if (annotRect.Contains(pageX, pageY))
646       return pAnnot;
647   }
648   return nullptr;
649 }
650
651 CPDF_Annot* CPDFSDK_PageView::GetPDFWidgetAtPoint(FX_FLOAT pageX,
652                                                   FX_FLOAT pageY) {
653   const int nCount = m_pAnnotList->Count();
654   for (int i = 0; i < nCount; ++i) {
655     CPDF_Annot* pAnnot = m_pAnnotList->GetAt(i);
656     if (pAnnot->GetSubType() == "Widget") {
657       CFX_FloatRect annotRect;
658       pAnnot->GetRect(annotRect);
659       if (annotRect.Contains(pageX, pageY))
660         return pAnnot;
661     }
662   }
663   return nullptr;
664 }
665
666 CPDFSDK_Annot* CPDFSDK_PageView::GetFXAnnotAtPoint(FX_FLOAT pageX,
667                                                    FX_FLOAT pageY) {
668   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
669   CPDFSDK_AnnotHandlerMgr* pAnnotMgr = pEnv->GetAnnotHandlerMgr();
670   CPDFSDK_AnnotIterator annotIterator(this, false);
671   while (CPDFSDK_Annot* pSDKAnnot = annotIterator.Next()) {
672     CPDF_Rect rc = pAnnotMgr->Annot_OnGetViewBBox(this, pSDKAnnot);
673     if (rc.Contains(pageX, pageY))
674       return pSDKAnnot;
675   }
676
677   return nullptr;
678 }
679
680 CPDFSDK_Annot* CPDFSDK_PageView::GetFXWidgetAtPoint(FX_FLOAT pageX,
681                                                     FX_FLOAT pageY) {
682   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
683   CPDFSDK_AnnotHandlerMgr* pAnnotMgr = pEnv->GetAnnotHandlerMgr();
684   CPDFSDK_AnnotIterator annotIterator(this, false);
685   while (CPDFSDK_Annot* pSDKAnnot = annotIterator.Next()) {
686     if (pSDKAnnot->GetType() == "Widget") {
687       pAnnotMgr->Annot_OnGetViewBBox(this, pSDKAnnot);
688       CPDF_Point point(pageX, pageY);
689       if (pAnnotMgr->Annot_OnHitTest(this, pSDKAnnot, point))
690         return pSDKAnnot;
691     }
692   }
693
694   return nullptr;
695 }
696
697 void CPDFSDK_PageView::KillFocusAnnotIfNeeded() {
698   // if there is a focused annot on the page, we should kill the focus first.
699   if (CPDFSDK_Annot* focusedAnnot = m_pSDKDoc->GetFocusAnnot()) {
700     auto it =
701         std::find(m_fxAnnotArray.begin(), m_fxAnnotArray.end(), focusedAnnot);
702     if (it != m_fxAnnotArray.end())
703       KillFocusAnnot();
704   }
705 }
706
707 FX_BOOL CPDFSDK_PageView::Annot_HasAppearance(CPDF_Annot* pAnnot) {
708   CPDF_Dictionary* pAnnotDic = pAnnot->GetAnnotDict();
709   if (pAnnotDic)
710     return pAnnotDic->KeyExist("AS");
711   return FALSE;
712 }
713
714 CPDFSDK_Annot* CPDFSDK_PageView::AddAnnot(CPDF_Annot* pPDFAnnot) {
715   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
716   ASSERT(pEnv);
717   CPDFSDK_AnnotHandlerMgr* pAnnotHandler = pEnv->GetAnnotHandlerMgr();
718   CPDFSDK_Annot* pSDKAnnot = pAnnotHandler->NewAnnot(pPDFAnnot, this);
719   if (!pSDKAnnot)
720     return nullptr;
721
722   m_fxAnnotArray.push_back(pSDKAnnot);
723   pAnnotHandler->Annot_OnCreate(pSDKAnnot);
724   return pSDKAnnot;
725 }
726
727 CPDFSDK_Annot* CPDFSDK_PageView::AddAnnot(CPDF_Dictionary* pDict) {
728   return pDict ? AddAnnot(pDict->GetString("Subtype"), pDict) : nullptr;
729 }
730
731 CPDFSDK_Annot* CPDFSDK_PageView::AddAnnot(const FX_CHAR* lpSubType,
732                                           CPDF_Dictionary* pDict) {
733   return NULL;
734 }
735
736 FX_BOOL CPDFSDK_PageView::DeleteAnnot(CPDFSDK_Annot* pAnnot) {
737   return FALSE;
738 }
739
740 CPDF_Document* CPDFSDK_PageView::GetPDFDocument() {
741   if (m_page) {
742     return m_page->m_pDocument;
743   }
744   return NULL;
745 }
746
747 size_t CPDFSDK_PageView::CountAnnots() const {
748   return m_fxAnnotArray.size();
749 }
750
751 CPDFSDK_Annot* CPDFSDK_PageView::GetAnnot(size_t nIndex) {
752   return nIndex < m_fxAnnotArray.size() ? m_fxAnnotArray[nIndex] : nullptr;
753 }
754
755 CPDFSDK_Annot* CPDFSDK_PageView::GetAnnotByDict(CPDF_Dictionary* pDict) {
756   for (CPDFSDK_Annot* pAnnot : m_fxAnnotArray) {
757     if (pAnnot->GetPDFAnnot()->GetAnnotDict() == pDict)
758       return pAnnot;
759   }
760   return nullptr;
761 }
762
763 FX_BOOL CPDFSDK_PageView::OnLButtonDown(const CPDF_Point& point,
764                                         FX_UINT nFlag) {
765   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
766   ASSERT(pEnv);
767   CPDFSDK_Annot* pFXAnnot = GetFXWidgetAtPoint(point.x, point.y);
768   if (!pFXAnnot) {
769     KillFocusAnnot(nFlag);
770     return FALSE;
771   }
772
773   CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
774   FX_BOOL bRet =
775       pAnnotHandlerMgr->Annot_OnLButtonDown(this, pFXAnnot, nFlag, point);
776   if (bRet)
777     SetFocusAnnot(pFXAnnot);
778   return bRet;
779 }
780
781 FX_BOOL CPDFSDK_PageView::OnLButtonUp(const CPDF_Point& point, FX_UINT nFlag) {
782   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
783   ASSERT(pEnv);
784   CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
785   CPDFSDK_Annot* pFXAnnot = GetFXWidgetAtPoint(point.x, point.y);
786   CPDFSDK_Annot* pFocusAnnot = GetFocusAnnot();
787   FX_BOOL bRet = FALSE;
788   if (pFocusAnnot && pFocusAnnot != pFXAnnot) {
789     // Last focus Annot gets a chance to handle the event.
790     bRet = pAnnotHandlerMgr->Annot_OnLButtonUp(this, pFocusAnnot, nFlag, point);
791   }
792   if (pFXAnnot && !bRet)
793     bRet = pAnnotHandlerMgr->Annot_OnLButtonUp(this, pFXAnnot, nFlag, point);
794   return bRet;
795 }
796
797 FX_BOOL CPDFSDK_PageView::OnMouseMove(const CPDF_Point& point, int nFlag) {
798   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
799   CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
800   if (CPDFSDK_Annot* pFXAnnot = GetFXWidgetAtPoint(point.x, point.y)) {
801     if (m_CaptureWidget && m_CaptureWidget != pFXAnnot) {
802       m_bExitWidget = TRUE;
803       m_bEnterWidget = FALSE;
804       pAnnotHandlerMgr->Annot_OnMouseExit(this, m_CaptureWidget, nFlag);
805     }
806     m_CaptureWidget = (CPDFSDK_Widget*)pFXAnnot;
807     m_bOnWidget = TRUE;
808     if (!m_bEnterWidget) {
809       m_bEnterWidget = TRUE;
810       m_bExitWidget = FALSE;
811       pAnnotHandlerMgr->Annot_OnMouseEnter(this, pFXAnnot, nFlag);
812     }
813     pAnnotHandlerMgr->Annot_OnMouseMove(this, pFXAnnot, nFlag, point);
814     return TRUE;
815   }
816   if (m_bOnWidget) {
817     m_bOnWidget = FALSE;
818     m_bExitWidget = TRUE;
819     m_bEnterWidget = FALSE;
820     if (m_CaptureWidget) {
821       pAnnotHandlerMgr->Annot_OnMouseExit(this, m_CaptureWidget, nFlag);
822       m_CaptureWidget = NULL;
823     }
824   }
825   return FALSE;
826 }
827
828 FX_BOOL CPDFSDK_PageView::OnMouseWheel(double deltaX,
829                                        double deltaY,
830                                        const CPDF_Point& point,
831                                        int nFlag) {
832   if (CPDFSDK_Annot* pAnnot = GetFXWidgetAtPoint(point.x, point.y)) {
833     CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
834     CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
835     return pAnnotHandlerMgr->Annot_OnMouseWheel(this, pAnnot, nFlag,
836                                                 (int)deltaY, point);
837   }
838   return FALSE;
839 }
840
841 FX_BOOL CPDFSDK_PageView::OnChar(int nChar, FX_UINT nFlag) {
842   if (CPDFSDK_Annot* pAnnot = GetFocusAnnot()) {
843     CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
844     CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
845     return pAnnotHandlerMgr->Annot_OnChar(pAnnot, nChar, nFlag);
846   }
847
848   return FALSE;
849 }
850
851 FX_BOOL CPDFSDK_PageView::OnKeyDown(int nKeyCode, int nFlag) {
852   if (CPDFSDK_Annot* pAnnot = GetFocusAnnot()) {
853     CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
854     CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
855     return pAnnotHandlerMgr->Annot_OnKeyDown(pAnnot, nKeyCode, nFlag);
856   }
857   return FALSE;
858 }
859
860 FX_BOOL CPDFSDK_PageView::OnKeyUp(int nKeyCode, int nFlag) {
861   return FALSE;
862 }
863
864 void CPDFSDK_PageView::LoadFXAnnots() {
865   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
866
867   FX_BOOL enableAPUpdate = CPDF_InterForm::UpdatingAPEnabled();
868   // Disable the default AP construction.
869   CPDF_InterForm::EnableUpdateAP(FALSE);
870   m_pAnnotList.reset(new CPDF_AnnotList(m_page));
871   CPDF_InterForm::EnableUpdateAP(enableAPUpdate);
872   const int nCount = m_pAnnotList->Count();
873   SetLock(TRUE);
874   for (int i = 0; i < nCount; ++i) {
875     CPDF_Annot* pPDFAnnot = m_pAnnotList->GetAt(i);
876     CPDF_Document* pDoc = GetPDFDocument();
877
878     CheckUnSupportAnnot(pDoc, pPDFAnnot);
879
880     CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
881     CPDFSDK_Annot* pAnnot = pAnnotHandlerMgr->NewAnnot(pPDFAnnot, this);
882     if (!pAnnot)
883       continue;
884     m_fxAnnotArray.push_back(pAnnot);
885
886     pAnnotHandlerMgr->Annot_OnLoad(pAnnot);
887   }
888   SetLock(FALSE);
889 }
890
891 void CPDFSDK_PageView::UpdateRects(CFX_RectArray& rects) {
892   for (int i = 0; i < rects.GetSize(); i++) {
893     CPDF_Rect rc = rects.GetAt(i);
894     CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
895     pEnv->FFI_Invalidate(m_page, rc.left, rc.top, rc.right, rc.bottom);
896   }
897 }
898
899 void CPDFSDK_PageView::UpdateView(CPDFSDK_Annot* pAnnot) {
900   CPDF_Rect rcWindow = pAnnot->GetRect();
901   CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
902   pEnv->FFI_Invalidate(m_page, rcWindow.left, rcWindow.top, rcWindow.right,
903                        rcWindow.bottom);
904 }
905
906 int CPDFSDK_PageView::GetPageIndex() {
907   if (m_page) {
908     CPDF_Dictionary* pDic = m_page->m_pFormDict;
909     CPDF_Document* pDoc = m_pSDKDoc->GetDocument();
910     if (pDoc && pDic) {
911       return pDoc->GetPageIndex(pDic->GetObjNum());
912     }
913   }
914   return -1;
915 }
916
917 FX_BOOL CPDFSDK_PageView::IsValidAnnot(CPDF_Annot* p) const {
918   if (!p)
919     return FALSE;
920
921   const int nCount = m_pAnnotList->Count();
922   for (int i = 0; i < nCount; ++i) {
923     if (m_pAnnotList->GetAt(i) == p)
924       return TRUE;
925   }
926   return FALSE;
927 }
928
929 CPDFSDK_Annot* CPDFSDK_PageView::GetFocusAnnot() {
930   CPDFSDK_Annot* pFocusAnnot = m_pSDKDoc->GetFocusAnnot();
931   if (!pFocusAnnot)
932     return nullptr;
933
934   for (CPDFSDK_Annot* pAnnot : m_fxAnnotArray) {
935     if (pAnnot == pFocusAnnot)
936       return pAnnot;
937   }
938   return nullptr;
939 }