OLD | NEW |
| (Empty) |
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 #ifndef FPDFSDK_INCLUDE_FSDK_MGR_H_ | |
8 #define FPDFSDK_INCLUDE_FSDK_MGR_H_ | |
9 | |
10 #include <map> | |
11 #include <memory> | |
12 #include <vector> | |
13 | |
14 #include "core/fpdfapi/fpdf_page/include/cpdf_page.h" | |
15 #include "core/fpdfapi/fpdf_parser/include/cpdf_document.h" | |
16 #include "core/fpdfdoc/include/cpdf_occontext.h" | |
17 #include "core/fxcrt/include/cfx_observable.h" | |
18 #include "fpdfsdk/cfx_systemhandler.h" | |
19 #include "fpdfsdk/include/cpdfsdk_annot.h" | |
20 #include "fpdfsdk/include/fsdk_actionhandler.h" | |
21 #include "fpdfsdk/include/fsdk_common.h" | |
22 #include "fpdfsdk/include/fsdk_define.h" | |
23 #include "public/fpdf_formfill.h" | |
24 #include "public/fpdf_fwlevent.h" | |
25 | |
26 class CFFL_IFormFiller; | |
27 class CFX_SystemHandler; | |
28 class CPDF_AnnotList; | |
29 class CPDFSDK_ActionHandler; | |
30 class CPDFSDK_Annot; | |
31 class CPDFSDK_AnnotHandlerMgr; | |
32 class CPDFSDK_InterForm; | |
33 class CPDFSDK_PageView; | |
34 class CPDFSDK_Widget; | |
35 class IJS_Runtime; | |
36 | |
37 class CPDFDoc_Environment final { | |
38 public: | |
39 CPDFDoc_Environment(UnderlyingDocumentType* pDoc, FPDF_FORMFILLINFO* pFFinfo); | |
40 ~CPDFDoc_Environment(); | |
41 | |
42 void FFI_Invalidate(FPDF_PAGE page, | |
43 double left, | |
44 double top, | |
45 double right, | |
46 double bottom) { | |
47 if (m_pInfo && m_pInfo->FFI_Invalidate) | |
48 m_pInfo->FFI_Invalidate(m_pInfo, page, left, top, right, bottom); | |
49 } | |
50 | |
51 void FFI_OutputSelectedRect(FPDF_PAGE page, | |
52 double left, | |
53 double top, | |
54 double right, | |
55 double bottom) { | |
56 if (m_pInfo && m_pInfo->FFI_OutputSelectedRect) | |
57 m_pInfo->FFI_OutputSelectedRect(m_pInfo, page, left, top, right, bottom); | |
58 } | |
59 | |
60 void FFI_SetCursor(int nCursorType) { | |
61 if (m_pInfo && m_pInfo->FFI_SetCursor) | |
62 m_pInfo->FFI_SetCursor(m_pInfo, nCursorType); | |
63 } | |
64 | |
65 int FFI_SetTimer(int uElapse, TimerCallback lpTimerFunc) { | |
66 if (m_pInfo && m_pInfo->FFI_SetTimer) | |
67 return m_pInfo->FFI_SetTimer(m_pInfo, uElapse, lpTimerFunc); | |
68 return -1; | |
69 } | |
70 | |
71 void FFI_KillTimer(int nTimerID) { | |
72 if (m_pInfo && m_pInfo->FFI_KillTimer) | |
73 m_pInfo->FFI_KillTimer(m_pInfo, nTimerID); | |
74 } | |
75 | |
76 FX_SYSTEMTIME FFI_GetLocalTime() const { | |
77 FX_SYSTEMTIME fxtime; | |
78 if (m_pInfo && m_pInfo->FFI_GetLocalTime) { | |
79 FPDF_SYSTEMTIME systime = m_pInfo->FFI_GetLocalTime(m_pInfo); | |
80 fxtime.wDay = systime.wDay; | |
81 fxtime.wDayOfWeek = systime.wDayOfWeek; | |
82 fxtime.wHour = systime.wHour; | |
83 fxtime.wMilliseconds = systime.wMilliseconds; | |
84 fxtime.wMinute = systime.wMinute; | |
85 fxtime.wMonth = systime.wMonth; | |
86 fxtime.wSecond = systime.wSecond; | |
87 fxtime.wYear = systime.wYear; | |
88 } | |
89 return fxtime; | |
90 } | |
91 | |
92 void FFI_OnChange() { | |
93 if (m_pInfo && m_pInfo->FFI_OnChange) | |
94 m_pInfo->FFI_OnChange(m_pInfo); | |
95 } | |
96 | |
97 FX_BOOL FFI_IsSHIFTKeyDown(uint32_t nFlag) const { | |
98 return (nFlag & FWL_EVENTFLAG_ShiftKey) != 0; | |
99 } | |
100 | |
101 FX_BOOL FFI_IsCTRLKeyDown(uint32_t nFlag) const { | |
102 return (nFlag & FWL_EVENTFLAG_ControlKey) != 0; | |
103 } | |
104 | |
105 FX_BOOL FFI_IsALTKeyDown(uint32_t nFlag) const { | |
106 return (nFlag & FWL_EVENTFLAG_AltKey) != 0; | |
107 } | |
108 | |
109 FPDF_PAGE FFI_GetPage(FPDF_DOCUMENT document, int nPageIndex) { | |
110 if (m_pInfo && m_pInfo->FFI_GetPage) | |
111 return m_pInfo->FFI_GetPage(m_pInfo, document, nPageIndex); | |
112 return nullptr; | |
113 } | |
114 | |
115 FPDF_PAGE FFI_GetCurrentPage(FPDF_DOCUMENT document) { | |
116 if (m_pInfo && m_pInfo->FFI_GetCurrentPage) | |
117 return m_pInfo->FFI_GetCurrentPage(m_pInfo, document); | |
118 return nullptr; | |
119 } | |
120 | |
121 int FFI_GetRotation(FPDF_PAGE page) { | |
122 if (m_pInfo && m_pInfo->FFI_GetRotation) | |
123 return m_pInfo->FFI_GetRotation(m_pInfo, page); | |
124 return 0; | |
125 } | |
126 | |
127 void FFI_ExecuteNamedAction(const FX_CHAR* namedAction) { | |
128 if (m_pInfo && m_pInfo->FFI_ExecuteNamedAction) | |
129 m_pInfo->FFI_ExecuteNamedAction(m_pInfo, namedAction); | |
130 } | |
131 | |
132 void FFI_OnSetFieldInputFocus(void* field, | |
133 FPDF_WIDESTRING focusText, | |
134 FPDF_DWORD nTextLen, | |
135 FX_BOOL bFocus) { | |
136 if (m_pInfo && m_pInfo->FFI_SetTextFieldFocus) | |
137 m_pInfo->FFI_SetTextFieldFocus(m_pInfo, focusText, nTextLen, bFocus); | |
138 } | |
139 | |
140 void FFI_DoURIAction(const FX_CHAR* bsURI) { | |
141 if (m_pInfo && m_pInfo->FFI_DoURIAction) | |
142 m_pInfo->FFI_DoURIAction(m_pInfo, bsURI); | |
143 } | |
144 | |
145 void FFI_DoGoToAction(int nPageIndex, | |
146 int zoomMode, | |
147 float* fPosArray, | |
148 int sizeOfArray) { | |
149 if (m_pInfo && m_pInfo->FFI_DoGoToAction) | |
150 m_pInfo->FFI_DoGoToAction(m_pInfo, nPageIndex, zoomMode, fPosArray, | |
151 sizeOfArray); | |
152 } | |
153 | |
154 #ifdef PDF_ENABLE_XFA | |
155 void FFI_DisplayCaret(FPDF_PAGE page, | |
156 FPDF_BOOL bVisible, | |
157 double left, | |
158 double top, | |
159 double right, | |
160 double bottom) { | |
161 if (m_pInfo && m_pInfo->FFI_DisplayCaret) | |
162 m_pInfo->FFI_DisplayCaret(m_pInfo, page, bVisible, left, top, right, | |
163 bottom); | |
164 } | |
165 | |
166 int FFI_GetCurrentPageIndex(FPDF_DOCUMENT document) { | |
167 if (!m_pInfo || !m_pInfo->FFI_GetCurrentPageIndex) { | |
168 return -1; | |
169 } | |
170 return m_pInfo->FFI_GetCurrentPageIndex(m_pInfo, document); | |
171 } | |
172 | |
173 void FFI_SetCurrentPage(FPDF_DOCUMENT document, int iCurPage) { | |
174 if (m_pInfo && m_pInfo->FFI_SetCurrentPage) | |
175 m_pInfo->FFI_SetCurrentPage(m_pInfo, document, iCurPage); | |
176 } | |
177 | |
178 CFX_WideString FFI_GetAppName() const { return CFX_WideString(L"Acrobat"); } | |
179 | |
180 CFX_WideString FFI_GetPlatform() { | |
181 if (m_pInfo && m_pInfo->FFI_GetPlatform) { | |
182 int nRequiredLen = m_pInfo->FFI_GetPlatform(m_pInfo, nullptr, 0); | |
183 if (nRequiredLen <= 0) | |
184 return L""; | |
185 | |
186 char* pbuff = new char[nRequiredLen]; | |
187 memset(pbuff, 0, nRequiredLen); | |
188 int nActualLen = m_pInfo->FFI_GetPlatform(m_pInfo, pbuff, nRequiredLen); | |
189 if (nActualLen <= 0 || nActualLen > nRequiredLen) { | |
190 delete[] pbuff; | |
191 return L""; | |
192 } | |
193 CFX_ByteString bsRet = CFX_ByteString(pbuff, nActualLen); | |
194 CFX_WideString wsRet = CFX_WideString::FromUTF16LE( | |
195 (unsigned short*)bsRet.GetBuffer(bsRet.GetLength()), | |
196 bsRet.GetLength() / sizeof(unsigned short)); | |
197 delete[] pbuff; | |
198 return wsRet; | |
199 } | |
200 return L""; | |
201 } | |
202 | |
203 void FFI_GotoURL(FPDF_DOCUMENT document, | |
204 const CFX_WideStringC& wsURL, | |
205 FX_BOOL bAppend) { | |
206 if (m_pInfo && m_pInfo->FFI_GotoURL) { | |
207 CFX_ByteString bsTo = CFX_WideString(wsURL).UTF16LE_Encode(); | |
208 FPDF_WIDESTRING pTo = (FPDF_WIDESTRING)bsTo.GetBuffer(wsURL.GetLength()); | |
209 m_pInfo->FFI_GotoURL(m_pInfo, document, pTo); | |
210 bsTo.ReleaseBuffer(); | |
211 } | |
212 } | |
213 | |
214 void FFI_GetURL(FPDF_DOCUMENT document, CFX_WideString& wsURL) { | |
215 wsURL = CFX_WideString(); | |
216 } | |
217 | |
218 void FFI_GetPageViewRect(FPDF_PAGE page, FS_RECTF& dstRect) { | |
219 if (m_pInfo && m_pInfo->FFI_GetPageViewRect) { | |
220 double left; | |
221 double top; | |
222 double right; | |
223 double bottom; | |
224 m_pInfo->FFI_GetPageViewRect(m_pInfo, page, &left, &top, &right, &bottom); | |
225 | |
226 dstRect.left = static_cast<float>(left); | |
227 dstRect.top = static_cast<float>(top < bottom ? bottom : top); | |
228 dstRect.bottom = static_cast<float>(top < bottom ? top : bottom); | |
229 dstRect.right = static_cast<float>(right); | |
230 } | |
231 } | |
232 | |
233 FX_BOOL FFI_PopupMenu(FPDF_PAGE page, | |
234 FPDF_WIDGET hWidget, | |
235 int menuFlag, | |
236 CFX_PointF ptPopup, | |
237 const CFX_PointF* pRectExclude) { | |
238 if (m_pInfo && m_pInfo->FFI_PopupMenu) | |
239 return m_pInfo->FFI_PopupMenu(m_pInfo, page, hWidget, menuFlag, ptPopup.x, | |
240 ptPopup.y); | |
241 return FALSE; | |
242 } | |
243 | |
244 void FFI_Alert(FPDF_WIDESTRING Msg, | |
245 FPDF_WIDESTRING Title, | |
246 int Type, | |
247 int Icon) { | |
248 if (m_pInfo && m_pInfo->m_pJsPlatform && m_pInfo->m_pJsPlatform->app_alert) | |
249 m_pInfo->m_pJsPlatform->app_alert(m_pInfo->m_pJsPlatform, Msg, Title, | |
250 Type, Icon); | |
251 } | |
252 | |
253 void FFI_EmailTo(FPDF_FILEHANDLER* fileHandler, | |
254 FPDF_WIDESTRING pTo, | |
255 FPDF_WIDESTRING pSubject, | |
256 FPDF_WIDESTRING pCC, | |
257 FPDF_WIDESTRING pBcc, | |
258 FPDF_WIDESTRING pMsg) { | |
259 if (m_pInfo && m_pInfo->FFI_EmailTo) | |
260 m_pInfo->FFI_EmailTo(m_pInfo, fileHandler, pTo, pSubject, pCC, pBcc, | |
261 pMsg); | |
262 } | |
263 | |
264 void FFI_UploadTo(FPDF_FILEHANDLER* fileHandler, | |
265 int fileFlag, | |
266 FPDF_WIDESTRING uploadTo) { | |
267 if (m_pInfo && m_pInfo->FFI_UploadTo) | |
268 m_pInfo->FFI_UploadTo(m_pInfo, fileHandler, fileFlag, uploadTo); | |
269 } | |
270 | |
271 FPDF_FILEHANDLER* FFI_OpenFile(int fileType, | |
272 FPDF_WIDESTRING wsURL, | |
273 const char* mode) { | |
274 if (m_pInfo && m_pInfo->FFI_OpenFile) | |
275 return m_pInfo->FFI_OpenFile(m_pInfo, fileType, wsURL, mode); | |
276 return nullptr; | |
277 } | |
278 | |
279 CFX_WideString FFI_GetFilePath(FPDF_FILEHANDLER* pFileHandler) const { | |
280 return L""; | |
281 } | |
282 | |
283 int FFI_GetDocumentCount() const { return 0; } | |
284 int FFI_GetCurDocument() const { return 0; } | |
285 | |
286 IFX_FileRead* FFI_DownloadFromURL(const FX_WCHAR* url) { | |
287 if (m_pInfo && m_pInfo->FFI_DownloadFromURL) { | |
288 CFX_ByteString bstrURL = CFX_WideString(url).UTF16LE_Encode(); | |
289 FPDF_WIDESTRING wsURL = | |
290 (FPDF_WIDESTRING)bstrURL.GetBuffer(bstrURL.GetLength()); | |
291 | |
292 FPDF_LPFILEHANDLER fileHandler = | |
293 m_pInfo->FFI_DownloadFromURL(m_pInfo, wsURL); | |
294 | |
295 return new CFPDF_FileStream(fileHandler); | |
296 } | |
297 return nullptr; | |
298 } | |
299 | |
300 CFX_WideString FFI_PostRequestURL(const FX_WCHAR* wsURL, | |
301 const FX_WCHAR* wsData, | |
302 const FX_WCHAR* wsContentType, | |
303 const FX_WCHAR* wsEncode, | |
304 const FX_WCHAR* wsHeader) { | |
305 if (m_pInfo && m_pInfo->FFI_PostRequestURL) { | |
306 CFX_ByteString bsURL = CFX_WideString(wsURL).UTF16LE_Encode(); | |
307 FPDF_WIDESTRING URL = (FPDF_WIDESTRING)bsURL.GetBuffer(bsURL.GetLength()); | |
308 | |
309 CFX_ByteString bsData = CFX_WideString(wsData).UTF16LE_Encode(); | |
310 FPDF_WIDESTRING data = | |
311 (FPDF_WIDESTRING)bsData.GetBuffer(bsData.GetLength()); | |
312 | |
313 CFX_ByteString bsContentType = | |
314 CFX_WideString(wsContentType).UTF16LE_Encode(); | |
315 FPDF_WIDESTRING contentType = | |
316 (FPDF_WIDESTRING)bsContentType.GetBuffer(bsContentType.GetLength()); | |
317 | |
318 CFX_ByteString bsEncode = CFX_WideString(wsEncode).UTF16LE_Encode(); | |
319 FPDF_WIDESTRING encode = | |
320 (FPDF_WIDESTRING)bsEncode.GetBuffer(bsEncode.GetLength()); | |
321 | |
322 CFX_ByteString bsHeader = CFX_WideString(wsHeader).UTF16LE_Encode(); | |
323 FPDF_WIDESTRING header = | |
324 (FPDF_WIDESTRING)bsHeader.GetBuffer(bsHeader.GetLength()); | |
325 | |
326 FPDF_BSTR response; | |
327 FPDF_BStr_Init(&response); | |
328 m_pInfo->FFI_PostRequestURL(m_pInfo, URL, data, contentType, encode, | |
329 header, &response); | |
330 | |
331 CFX_WideString wsRet = CFX_WideString::FromUTF16LE( | |
332 (unsigned short*)response.str, response.len / sizeof(unsigned short)); | |
333 FPDF_BStr_Clear(&response); | |
334 | |
335 return wsRet; | |
336 } | |
337 return L""; | |
338 } | |
339 | |
340 FPDF_BOOL FFI_PutRequestURL(const FX_WCHAR* wsURL, | |
341 const FX_WCHAR* wsData, | |
342 const FX_WCHAR* wsEncode) { | |
343 if (m_pInfo && m_pInfo->FFI_PutRequestURL) { | |
344 CFX_ByteString bsURL = CFX_WideString(wsURL).UTF16LE_Encode(); | |
345 FPDF_WIDESTRING URL = (FPDF_WIDESTRING)bsURL.GetBuffer(bsURL.GetLength()); | |
346 | |
347 CFX_ByteString bsData = CFX_WideString(wsData).UTF16LE_Encode(); | |
348 FPDF_WIDESTRING data = | |
349 (FPDF_WIDESTRING)bsData.GetBuffer(bsData.GetLength()); | |
350 | |
351 CFX_ByteString bsEncode = CFX_WideString(wsEncode).UTF16LE_Encode(); | |
352 FPDF_WIDESTRING encode = | |
353 (FPDF_WIDESTRING)bsEncode.GetBuffer(bsEncode.GetLength()); | |
354 | |
355 return m_pInfo->FFI_PutRequestURL(m_pInfo, URL, data, encode); | |
356 } | |
357 return FALSE; | |
358 } | |
359 | |
360 CFX_WideString FFI_GetLanguage() { | |
361 if (m_pInfo && m_pInfo->FFI_GetLanguage) { | |
362 int nRequiredLen = m_pInfo->FFI_GetLanguage(m_pInfo, nullptr, 0); | |
363 if (nRequiredLen <= 0) | |
364 return L""; | |
365 | |
366 char* pbuff = new char[nRequiredLen]; | |
367 memset(pbuff, 0, nRequiredLen); | |
368 int nActualLen = m_pInfo->FFI_GetLanguage(m_pInfo, pbuff, nRequiredLen); | |
369 if (nActualLen <= 0 || nActualLen > nRequiredLen) { | |
370 delete[] pbuff; | |
371 return L""; | |
372 } | |
373 CFX_ByteString bsRet = CFX_ByteString(pbuff, nActualLen); | |
374 CFX_WideString wsRet = CFX_WideString::FromUTF16LE( | |
375 (unsigned short*)bsRet.GetBuffer(bsRet.GetLength()), | |
376 bsRet.GetLength() / sizeof(unsigned short)); | |
377 delete[] pbuff; | |
378 return wsRet; | |
379 } | |
380 return L""; | |
381 } | |
382 | |
383 void FFI_PageEvent(int iPageCount, uint32_t dwEventType) const { | |
384 if (m_pInfo && m_pInfo->FFI_PageEvent) | |
385 m_pInfo->FFI_PageEvent(m_pInfo, iPageCount, dwEventType); | |
386 } | |
387 #endif // PDF_ENABLE_XFA | |
388 | |
389 int JS_appAlert(const FX_WCHAR* Msg, | |
390 const FX_WCHAR* Title, | |
391 FX_UINT Type, | |
392 FX_UINT Icon); | |
393 int JS_appResponse(const FX_WCHAR* Question, | |
394 const FX_WCHAR* Title, | |
395 const FX_WCHAR* Default, | |
396 const FX_WCHAR* cLabel, | |
397 FPDF_BOOL bPassword, | |
398 void* response, | |
399 int length); | |
400 void JS_appBeep(int nType); | |
401 CFX_WideString JS_fieldBrowse(); | |
402 CFX_WideString JS_docGetFilePath(); | |
403 void JS_docSubmitForm(void* formData, int length, const FX_WCHAR* URL); | |
404 void JS_docmailForm(void* mailData, | |
405 int length, | |
406 FPDF_BOOL bUI, | |
407 const FX_WCHAR* To, | |
408 const FX_WCHAR* Subject, | |
409 const FX_WCHAR* CC, | |
410 const FX_WCHAR* BCC, | |
411 const FX_WCHAR* Msg); | |
412 void JS_docprint(FPDF_BOOL bUI, | |
413 int nStart, | |
414 int nEnd, | |
415 FPDF_BOOL bSilent, | |
416 FPDF_BOOL bShrinkToFit, | |
417 FPDF_BOOL bPrintAsImage, | |
418 FPDF_BOOL bReverse, | |
419 FPDF_BOOL bAnnotations); | |
420 void JS_docgotoPage(int nPageNum); | |
421 | |
422 FX_BOOL IsJSInitiated() const { return m_pInfo && m_pInfo->m_pJsPlatform; } | |
423 void SetSDKDocument(CPDFSDK_Document* pFXDoc) { m_pSDKDoc = pFXDoc; } | |
424 CPDFSDK_Document* GetSDKDocument() const { return m_pSDKDoc; } | |
425 UnderlyingDocumentType* GetUnderlyingDocument() const { | |
426 return m_pUnderlyingDoc; | |
427 } | |
428 CFX_ByteString GetAppName() const { return ""; } | |
429 CFX_SystemHandler* GetSysHandler() const { return m_pSysHandler.get(); } | |
430 FPDF_FORMFILLINFO* GetFormFillInfo() const { return m_pInfo; } | |
431 | |
432 CFFL_IFormFiller* GetIFormFiller(); // Creates if not present. | |
433 CPDFSDK_AnnotHandlerMgr* GetAnnotHandlerMgr(); // Creates if not present. | |
434 IJS_Runtime* GetJSRuntime(); // Creates if not present. | |
435 CPDFSDK_ActionHandler* GetActionHander(); // Creates if not present. | |
436 | |
437 private: | |
438 std::unique_ptr<CPDFSDK_AnnotHandlerMgr> m_pAnnotHandlerMgr; | |
439 std::unique_ptr<CPDFSDK_ActionHandler> m_pActionHandler; | |
440 std::unique_ptr<IJS_Runtime> m_pJSRuntime; | |
441 FPDF_FORMFILLINFO* const m_pInfo; | |
442 CPDFSDK_Document* m_pSDKDoc; | |
443 UnderlyingDocumentType* const m_pUnderlyingDoc; | |
444 std::unique_ptr<CFFL_IFormFiller> m_pIFormFiller; | |
445 std::unique_ptr<CFX_SystemHandler> m_pSysHandler; | |
446 }; | |
447 | |
448 class CPDFSDK_Document : public CFX_Observable<CPDFSDK_Document> { | |
449 public: | |
450 static CPDFSDK_Document* FromFPDFFormHandle(FPDF_FORMHANDLE hHandle); | |
451 | |
452 CPDFSDK_Document(UnderlyingDocumentType* pDoc, CPDFDoc_Environment* pEnv); | |
453 ~CPDFSDK_Document(); | |
454 | |
455 CPDFSDK_InterForm* GetInterForm(); | |
456 | |
457 // Gets the document object for the next layer down; for master this is | |
458 // a CPDF_Document, but for XFA it is a CPDFXFA_Document. | |
459 UnderlyingDocumentType* GetUnderlyingDocument() const { | |
460 #ifdef PDF_ENABLE_XFA | |
461 return GetXFADocument(); | |
462 #else // PDF_ENABLE_XFA | |
463 return GetPDFDocument(); | |
464 #endif // PDF_ENABLE_XFA | |
465 } | |
466 | |
467 // Gets the CPDF_Document, either directly in master, or from the | |
468 // CPDFXFA_Document for XFA. | |
469 CPDF_Document* GetPDFDocument() const { | |
470 #ifdef PDF_ENABLE_XFA | |
471 return m_pDoc ? m_pDoc->GetPDFDoc() : nullptr; | |
472 #else // PDF_ENABLE_XFA | |
473 return m_pDoc; | |
474 #endif // PDF_ENABLE_XFA | |
475 } | |
476 | |
477 #ifdef PDF_ENABLE_XFA | |
478 // Gets the XFA document directly (XFA-only). | |
479 CPDFXFA_Document* GetXFADocument() const { return m_pDoc; } | |
480 | |
481 int GetPageViewCount() const { return m_pageMap.size(); } | |
482 #endif // PDF_ENABLE_XFA | |
483 | |
484 CPDFSDK_PageView* GetPageView(UnderlyingPageType* pPage, bool ReNew); | |
485 CPDFSDK_PageView* GetPageView(int nIndex); | |
486 CPDFSDK_PageView* GetCurrentView(); | |
487 void RemovePageView(UnderlyingPageType* pPage); | |
488 void UpdateAllViews(CPDFSDK_PageView* pSender, CPDFSDK_Annot* pAnnot); | |
489 | |
490 CPDFSDK_Annot* GetFocusAnnot(); | |
491 | |
492 IJS_Runtime* GetJsRuntime(); | |
493 | |
494 FX_BOOL SetFocusAnnot(CPDFSDK_Annot* pAnnot, FX_UINT nFlag = 0); | |
495 FX_BOOL KillFocusAnnot(FX_UINT nFlag = 0); | |
496 | |
497 FX_BOOL ExtractPages(const std::vector<uint16_t>& arrExtraPages, | |
498 CPDF_Document* pDstDoc); | |
499 FX_BOOL InsertPages(int nInsertAt, | |
500 const CPDF_Document* pSrcDoc, | |
501 const std::vector<uint16_t>& arrSrcPages); | |
502 FX_BOOL ReplacePages(int nPage, | |
503 const CPDF_Document* pSrcDoc, | |
504 const std::vector<uint16_t>& arrSrcPages); | |
505 | |
506 void OnCloseDocument(); | |
507 | |
508 int GetPageCount() { return m_pDoc->GetPageCount(); } | |
509 FX_BOOL GetPermissions(int nFlag); | |
510 FX_BOOL GetChangeMark() { return m_bChangeMask; } | |
511 void SetChangeMark() { m_bChangeMask = TRUE; } | |
512 void ClearChangeMark() { m_bChangeMask = FALSE; } | |
513 CFX_WideString GetPath(); | |
514 UnderlyingPageType* GetPage(int nIndex); | |
515 CPDFDoc_Environment* GetEnv() { return m_pEnv; } | |
516 void ProcJavascriptFun(); | |
517 FX_BOOL ProcOpenAction(); | |
518 CPDF_OCContext* GetOCContext(); | |
519 | |
520 private: | |
521 std::map<UnderlyingPageType*, CPDFSDK_PageView*> m_pageMap; | |
522 UnderlyingDocumentType* m_pDoc; | |
523 std::unique_ptr<CPDFSDK_InterForm> m_pInterForm; | |
524 CPDFSDK_Annot* m_pFocusAnnot; | |
525 CPDFDoc_Environment* m_pEnv; | |
526 std::unique_ptr<CPDF_OCContext> m_pOccontent; | |
527 FX_BOOL m_bChangeMask; | |
528 FX_BOOL m_bBeingDestroyed; | |
529 }; | |
530 | |
531 class CPDFSDK_PageView final : public CPDF_Page::View { | |
532 public: | |
533 CPDFSDK_PageView(CPDFSDK_Document* pSDKDoc, UnderlyingPageType* page); | |
534 ~CPDFSDK_PageView(); | |
535 | |
536 #ifdef PDF_ENABLE_XFA | |
537 void PageView_OnDraw(CFX_RenderDevice* pDevice, | |
538 CFX_Matrix* pUser2Device, | |
539 CPDF_RenderOptions* pOptions, | |
540 const FX_RECT& pClip); | |
541 #else // PDF_ENABLE_XFA | |
542 void PageView_OnDraw(CFX_RenderDevice* pDevice, | |
543 CFX_Matrix* pUser2Device, | |
544 CPDF_RenderOptions* pOptions); | |
545 #endif // PDF_ENABLE_XFA | |
546 | |
547 const CPDF_Annot* GetPDFAnnotAtPoint(FX_FLOAT pageX, FX_FLOAT pageY); | |
548 CPDFSDK_Annot* GetFXAnnotAtPoint(FX_FLOAT pageX, FX_FLOAT pageY); | |
549 const CPDF_Annot* GetPDFWidgetAtPoint(FX_FLOAT pageX, FX_FLOAT pageY); | |
550 CPDFSDK_Annot* GetFXWidgetAtPoint(FX_FLOAT pageX, FX_FLOAT pageY); | |
551 CPDFSDK_Annot* GetFocusAnnot(); | |
552 void SetFocusAnnot(CPDFSDK_Annot* pSDKAnnot, FX_UINT nFlag = 0) { | |
553 m_pSDKDoc->SetFocusAnnot(pSDKAnnot, nFlag); | |
554 } | |
555 FX_BOOL KillFocusAnnot(FX_UINT nFlag = 0) { | |
556 return m_pSDKDoc->KillFocusAnnot(nFlag); | |
557 } | |
558 void KillFocusAnnotIfNeeded(); | |
559 | |
560 CPDFSDK_Annot* AddAnnot(CPDF_Dictionary* pDict); | |
561 CPDFSDK_Annot* AddAnnot(const FX_CHAR* lpSubType, CPDF_Dictionary* pDict); | |
562 CPDFSDK_Annot* AddAnnot(CPDF_Annot* pPDFAnnot); | |
563 | |
564 FX_BOOL DeleteAnnot(CPDFSDK_Annot* pAnnot); | |
565 size_t CountAnnots() const; | |
566 CPDFSDK_Annot* GetAnnot(size_t nIndex); | |
567 CPDFSDK_Annot* GetAnnotByDict(CPDF_Dictionary* pDict); | |
568 | |
569 #ifdef PDF_ENABLE_XFA | |
570 CPDFSDK_Annot* AddAnnot(CXFA_FFWidget* pPDFAnnot); | |
571 CPDFSDK_Annot* GetAnnotByXFAWidget(CXFA_FFWidget* hWidget); | |
572 CPDFXFA_Page* GetPDFXFAPage() { return m_page; } | |
573 #endif // PDF_ENABLE_XFA | |
574 | |
575 CPDF_Page* GetPDFPage() const; | |
576 CPDF_Document* GetPDFDocument(); | |
577 CPDFSDK_Document* GetSDKDocument() { return m_pSDKDoc; } | |
578 FX_BOOL OnLButtonDown(const CFX_FloatPoint& point, FX_UINT nFlag); | |
579 FX_BOOL OnLButtonUp(const CFX_FloatPoint& point, FX_UINT nFlag); | |
580 #ifdef PDF_ENABLE_XFA | |
581 FX_BOOL OnRButtonDown(const CFX_FloatPoint& point, FX_UINT nFlag); | |
582 FX_BOOL OnRButtonUp(const CFX_FloatPoint& point, FX_UINT nFlag); | |
583 #endif // PDF_ENABLE_XFA | |
584 FX_BOOL OnChar(int nChar, FX_UINT nFlag); | |
585 FX_BOOL OnKeyDown(int nKeyCode, int nFlag); | |
586 FX_BOOL OnKeyUp(int nKeyCode, int nFlag); | |
587 | |
588 FX_BOOL OnMouseMove(const CFX_FloatPoint& point, int nFlag); | |
589 FX_BOOL OnMouseWheel(double deltaX, | |
590 double deltaY, | |
591 const CFX_FloatPoint& point, | |
592 int nFlag); | |
593 bool IsValidAnnot(const CPDF_Annot* p) const; | |
594 void GetCurrentMatrix(CFX_Matrix& matrix) { matrix = m_curMatrix; } | |
595 void UpdateRects(const std::vector<CFX_FloatRect>& rects); | |
596 void UpdateView(CPDFSDK_Annot* pAnnot); | |
597 const std::vector<CPDFSDK_Annot*>& GetAnnotList() const { | |
598 return m_fxAnnotArray; | |
599 } | |
600 | |
601 int GetPageIndex() const; | |
602 void LoadFXAnnots(); | |
603 void ClearFXAnnots(); | |
604 void SetValid(FX_BOOL bValid) { m_bValid = bValid; } | |
605 FX_BOOL IsValid() { return m_bValid; } | |
606 void SetLock(FX_BOOL bLocked) { m_bLocked = bLocked; } | |
607 FX_BOOL IsLocked() { return m_bLocked; } | |
608 #ifndef PDF_ENABLE_XFA | |
609 bool OwnsPage() const { return m_bOwnsPage; } | |
610 void TakePageOwnership() { m_bOwnsPage = true; } | |
611 #endif // PDF_ENABLE_XFA | |
612 | |
613 private: | |
614 int GetPageIndexForStaticPDF() const; | |
615 | |
616 CFX_Matrix m_curMatrix; | |
617 UnderlyingPageType* const m_page; | |
618 std::unique_ptr<CPDF_AnnotList> m_pAnnotList; | |
619 std::vector<CPDFSDK_Annot*> m_fxAnnotArray; | |
620 CPDFSDK_Document* const m_pSDKDoc; | |
621 CPDFSDK_Annot* m_CaptureWidget; | |
622 #ifndef PDF_ENABLE_XFA | |
623 bool m_bOwnsPage; | |
624 #endif // PDF_ENABLE_XFA | |
625 FX_BOOL m_bEnterWidget; | |
626 FX_BOOL m_bExitWidget; | |
627 FX_BOOL m_bOnWidget; | |
628 FX_BOOL m_bValid; | |
629 FX_BOOL m_bLocked; | |
630 }; | |
631 | |
632 #endif // FPDFSDK_INCLUDE_FSDK_MGR_H_ | |
OLD | NEW |