| 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 |
|---|
Chromium Code Reviews
Issue 2335243002:
Split fsdk_mgr files apart. (Closed)
