John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 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. |
Lei Zhang | a6d9f0e | 2015-06-13 00:48:38 -0700 | [diff] [blame] | 4 | |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 5 | // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com |
| 6 | |
Lei Zhang | b4e7f30 | 2015-11-06 15:52:32 -0800 | [diff] [blame] | 7 | #include "public/fpdf_edit.h" |
| 8 | |
thestig | c54bb43 | 2016-07-29 19:34:20 -0700 | [diff] [blame] | 9 | #include <algorithm> |
| 10 | #include <memory> |
| 11 | #include <utility> |
Lei Zhang | 996c930 | 2018-04-13 15:44:36 +0000 | [diff] [blame] | 12 | #include <vector> |
thestig | c54bb43 | 2016-07-29 19:34:20 -0700 | [diff] [blame] | 13 | |
Lei Zhang | fc615c6 | 2018-06-08 20:40:15 +0000 | [diff] [blame] | 14 | #include "constants/page_object.h" |
dsinclair | 2415435 | 2016-10-04 11:01:48 -0700 | [diff] [blame] | 15 | #include "core/fpdfapi/edit/cpdf_pagecontentgenerator.h" |
Tom Sepez | e912b62 | 2019-05-22 19:57:35 +0000 | [diff] [blame] | 16 | #include "core/fpdfapi/page/cpdf_colorspace.h" |
Tom Sepez | 3c24e5c | 2019-06-06 21:29:05 +0000 | [diff] [blame] | 17 | #include "core/fpdfapi/page/cpdf_docpagedata.h" |
dsinclair | 41872fa | 2016-10-04 11:29:35 -0700 | [diff] [blame] | 18 | #include "core/fpdfapi/page/cpdf_form.h" |
| 19 | #include "core/fpdfapi/page/cpdf_formobject.h" |
| 20 | #include "core/fpdfapi/page/cpdf_imageobject.h" |
| 21 | #include "core/fpdfapi/page/cpdf_page.h" |
| 22 | #include "core/fpdfapi/page/cpdf_pageobject.h" |
| 23 | #include "core/fpdfapi/page/cpdf_pathobject.h" |
| 24 | #include "core/fpdfapi/page/cpdf_shadingobject.h" |
Lei Zhang | c8601bf | 2021-06-29 23:19:27 +0000 | [diff] [blame] | 25 | #include "core/fpdfapi/page/cpdf_textobject.h" |
dsinclair | 488b7ad | 2016-10-04 11:55:50 -0700 | [diff] [blame] | 26 | #include "core/fpdfapi/parser/cpdf_array.h" |
Lei Zhang | 8153561 | 2018-10-09 21:15:17 +0000 | [diff] [blame] | 27 | #include "core/fpdfapi/parser/cpdf_dictionary.h" |
dsinclair | 488b7ad | 2016-10-04 11:55:50 -0700 | [diff] [blame] | 28 | #include "core/fpdfapi/parser/cpdf_document.h" |
Lei Zhang | 34ee5db | 2021-04-24 02:05:31 +0000 | [diff] [blame] | 29 | #include "core/fpdfapi/parser/cpdf_name.h" |
dsinclair | 488b7ad | 2016-10-04 11:55:50 -0700 | [diff] [blame] | 30 | #include "core/fpdfapi/parser/cpdf_number.h" |
| 31 | #include "core/fpdfapi/parser/cpdf_string.h" |
Tom Sepez | 3c24e5c | 2019-06-06 21:29:05 +0000 | [diff] [blame] | 32 | #include "core/fpdfapi/render/cpdf_docrenderdata.h" |
Tom Sepez | 0208b0c | 2019-07-23 21:52:50 +0000 | [diff] [blame] | 33 | #include "core/fpdfapi/render/cpdf_pagerendercache.h" |
dsinclair | 1727aee | 2016-09-29 13:12:56 -0700 | [diff] [blame] | 34 | #include "core/fpdfdoc/cpdf_annot.h" |
| 35 | #include "core/fpdfdoc/cpdf_annotlist.h" |
Ryan Harrison | f36a464 | 2018-08-10 19:03:47 +0000 | [diff] [blame] | 36 | #include "core/fxcrt/fx_extension.h" |
Tom Sepez | 8ef63b9 | 2022-03-08 19:53:34 +0000 | [diff] [blame] | 37 | #include "core/fxcrt/stl_util.h" |
Dan Sinclair | 00d47a6 | 2018-03-28 18:39:04 +0000 | [diff] [blame] | 38 | #include "fpdfsdk/cpdfsdk_helpers.h" |
Tom Sepez | 40e9ff3 | 2015-11-30 12:39:54 -0800 | [diff] [blame] | 39 | #include "public/fpdf_formfill.h" |
Lei Zhang | efd4423 | 2021-07-30 17:04:57 +0000 | [diff] [blame] | 40 | #include "third_party/base/cxx17_backports.h" |
Tom Sepez | 8ef63b9 | 2022-03-08 19:53:34 +0000 | [diff] [blame] | 41 | #include "third_party/base/numerics/safe_conversions.h" |
Tom Sepez | 40e9ff3 | 2015-11-30 12:39:54 -0800 | [diff] [blame] | 42 | |
Tom Sepez | 51da093 | 2015-11-25 16:05:49 -0800 | [diff] [blame] | 43 | #ifdef PDF_ENABLE_XFA |
dsinclair | 521b750 | 2016-11-02 13:02:28 -0700 | [diff] [blame] | 44 | #include "fpdfsdk/fpdfxfa/cpdfxfa_context.h" |
dsinclair | 4d29e78 | 2016-10-04 14:02:47 -0700 | [diff] [blame] | 45 | #include "fpdfsdk/fpdfxfa/cpdfxfa_page.h" |
Tom Sepez | 40e9ff3 | 2015-11-30 12:39:54 -0800 | [diff] [blame] | 46 | #endif // PDF_ENABLE_XFA |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 47 | |
thestig | c54bb43 | 2016-07-29 19:34:20 -0700 | [diff] [blame] | 48 | namespace { |
| 49 | |
Lei Zhang | f3b5967 | 2022-02-22 18:48:42 +0000 | [diff] [blame] | 50 | static_assert(FPDF_PAGEOBJ_TEXT == |
| 51 | static_cast<int>(CPDF_PageObject::Type::kText), |
thestig | c54bb43 | 2016-07-29 19:34:20 -0700 | [diff] [blame] | 52 | "FPDF_PAGEOBJ_TEXT/CPDF_PageObject::TEXT mismatch"); |
Lei Zhang | f3b5967 | 2022-02-22 18:48:42 +0000 | [diff] [blame] | 53 | static_assert(FPDF_PAGEOBJ_PATH == |
| 54 | static_cast<int>(CPDF_PageObject::Type::kPath), |
thestig | c54bb43 | 2016-07-29 19:34:20 -0700 | [diff] [blame] | 55 | "FPDF_PAGEOBJ_PATH/CPDF_PageObject::PATH mismatch"); |
Lei Zhang | f3b5967 | 2022-02-22 18:48:42 +0000 | [diff] [blame] | 56 | static_assert(FPDF_PAGEOBJ_IMAGE == |
| 57 | static_cast<int>(CPDF_PageObject::Type::kImage), |
thestig | c54bb43 | 2016-07-29 19:34:20 -0700 | [diff] [blame] | 58 | "FPDF_PAGEOBJ_IMAGE/CPDF_PageObject::IMAGE mismatch"); |
Lei Zhang | f3b5967 | 2022-02-22 18:48:42 +0000 | [diff] [blame] | 59 | static_assert(FPDF_PAGEOBJ_SHADING == |
| 60 | static_cast<int>(CPDF_PageObject::Type::kShading), |
thestig | c54bb43 | 2016-07-29 19:34:20 -0700 | [diff] [blame] | 61 | "FPDF_PAGEOBJ_SHADING/CPDF_PageObject::SHADING mismatch"); |
Lei Zhang | f3b5967 | 2022-02-22 18:48:42 +0000 | [diff] [blame] | 62 | static_assert(FPDF_PAGEOBJ_FORM == |
| 63 | static_cast<int>(CPDF_PageObject::Type::kForm), |
thestig | c54bb43 | 2016-07-29 19:34:20 -0700 | [diff] [blame] | 64 | "FPDF_PAGEOBJ_FORM/CPDF_PageObject::FORM mismatch"); |
| 65 | |
| 66 | bool IsPageObject(CPDF_Page* pPage) { |
Lei Zhang | e5c0fa9 | 2018-05-08 00:00:16 +0000 | [diff] [blame] | 67 | if (!pPage) |
thestig | c54bb43 | 2016-07-29 19:34:20 -0700 | [diff] [blame] | 68 | return false; |
| 69 | |
Henrique Nakashima | 888af47 | 2018-06-07 19:43:42 +0000 | [diff] [blame] | 70 | const CPDF_Dictionary* pFormDict = pPage->GetDict(); |
Lei Zhang | 34ee5db | 2021-04-24 02:05:31 +0000 | [diff] [blame] | 71 | if (!pFormDict->KeyExist(pdfium::page_object::kType)) |
Lei Zhang | e5c0fa9 | 2018-05-08 00:00:16 +0000 | [diff] [blame] | 72 | return false; |
| 73 | |
Tom Sepez | e3e7fc0 | 2022-09-06 19:37:13 +0000 | [diff] [blame] | 74 | RetainPtr<const CPDF_Name> pName = |
Lei Zhang | 34ee5db | 2021-04-24 02:05:31 +0000 | [diff] [blame] | 75 | ToName(pFormDict->GetObjectFor(pdfium::page_object::kType)->GetDirect()); |
| 76 | return pName && pName->GetString() == "Page"; |
thestig | c54bb43 | 2016-07-29 19:34:20 -0700 | [diff] [blame] | 77 | } |
| 78 | |
wileyrya | e858aa4 | 2017-05-31 14:49:05 -0500 | [diff] [blame] | 79 | void CalcBoundingBox(CPDF_PageObject* pPageObj) { |
| 80 | switch (pPageObj->GetType()) { |
Lei Zhang | f3b5967 | 2022-02-22 18:48:42 +0000 | [diff] [blame] | 81 | case CPDF_PageObject::Type::kText: { |
wileyrya | e858aa4 | 2017-05-31 14:49:05 -0500 | [diff] [blame] | 82 | break; |
| 83 | } |
Lei Zhang | f3b5967 | 2022-02-22 18:48:42 +0000 | [diff] [blame] | 84 | case CPDF_PageObject::Type::kPath: { |
wileyrya | e858aa4 | 2017-05-31 14:49:05 -0500 | [diff] [blame] | 85 | CPDF_PathObject* pPathObj = pPageObj->AsPath(); |
| 86 | pPathObj->CalcBoundingBox(); |
| 87 | break; |
| 88 | } |
Lei Zhang | f3b5967 | 2022-02-22 18:48:42 +0000 | [diff] [blame] | 89 | case CPDF_PageObject::Type::kImage: { |
wileyrya | e858aa4 | 2017-05-31 14:49:05 -0500 | [diff] [blame] | 90 | CPDF_ImageObject* pImageObj = pPageObj->AsImage(); |
| 91 | pImageObj->CalcBoundingBox(); |
| 92 | break; |
| 93 | } |
Lei Zhang | f3b5967 | 2022-02-22 18:48:42 +0000 | [diff] [blame] | 94 | case CPDF_PageObject::Type::kShading: { |
wileyrya | e858aa4 | 2017-05-31 14:49:05 -0500 | [diff] [blame] | 95 | CPDF_ShadingObject* pShadingObj = pPageObj->AsShading(); |
| 96 | pShadingObj->CalcBoundingBox(); |
| 97 | break; |
| 98 | } |
Lei Zhang | f3b5967 | 2022-02-22 18:48:42 +0000 | [diff] [blame] | 99 | case CPDF_PageObject::Type::kForm: { |
wileyrya | e858aa4 | 2017-05-31 14:49:05 -0500 | [diff] [blame] | 100 | CPDF_FormObject* pFormObj = pPageObj->AsForm(); |
| 101 | pFormObj->CalcBoundingBox(); |
| 102 | break; |
| 103 | } |
wileyrya | e858aa4 | 2017-05-31 14:49:05 -0500 | [diff] [blame] | 104 | } |
| 105 | } |
| 106 | |
Tom Sepez | b7ee8d6 | 2022-09-26 19:31:53 +0000 | [diff] [blame] | 107 | RetainPtr<CPDF_Dictionary> GetMarkParamDict(FPDF_PAGEOBJECTMARK mark) { |
Henrique Nakashima | cf403ba | 2018-07-13 20:12:41 +0000 | [diff] [blame] | 108 | CPDF_ContentMarkItem* pMarkItem = |
Henrique Nakashima | 132c38e | 2018-04-23 16:35:56 +0000 | [diff] [blame] | 109 | CPDFContentMarkItemFromFPDFPageObjectMark(mark); |
Lei Zhang | bfeb934 | 2018-07-14 00:07:17 +0000 | [diff] [blame] | 110 | return pMarkItem ? pMarkItem->GetParam() : nullptr; |
Henrique Nakashima | 7007fd5 | 2018-07-05 18:04:19 +0000 | [diff] [blame] | 111 | } |
| 112 | |
Tom Sepez | b7ee8d6 | 2022-09-26 19:31:53 +0000 | [diff] [blame] | 113 | RetainPtr<CPDF_Dictionary> GetOrCreateMarkParamsDict(FPDF_DOCUMENT document, |
| 114 | FPDF_PAGEOBJECTMARK mark) { |
Henrique Nakashima | 144107d | 2018-07-10 21:04:05 +0000 | [diff] [blame] | 115 | CPDF_Document* pDoc = CPDFDocumentFromFPDFDocument(document); |
| 116 | if (!pDoc) |
| 117 | return nullptr; |
| 118 | |
| 119 | CPDF_ContentMarkItem* pMarkItem = |
| 120 | CPDFContentMarkItemFromFPDFPageObjectMark(mark); |
| 121 | if (!pMarkItem) |
| 122 | return nullptr; |
| 123 | |
Tom Sepez | b7ee8d6 | 2022-09-26 19:31:53 +0000 | [diff] [blame] | 124 | RetainPtr<CPDF_Dictionary> pParams = pMarkItem->GetParam(); |
Henrique Nakashima | 144107d | 2018-07-10 21:04:05 +0000 | [diff] [blame] | 125 | if (!pParams) { |
Tom Sepez | b7ee8d6 | 2022-09-26 19:31:53 +0000 | [diff] [blame] | 126 | pParams = pDoc->New<CPDF_Dictionary>(); |
| 127 | pMarkItem->SetDirectDict(pParams); |
Henrique Nakashima | 144107d | 2018-07-10 21:04:05 +0000 | [diff] [blame] | 128 | } |
Henrique Nakashima | 144107d | 2018-07-10 21:04:05 +0000 | [diff] [blame] | 129 | return pParams; |
| 130 | } |
| 131 | |
Henrique Nakashima | a340677 | 2018-07-13 19:10:53 +0000 | [diff] [blame] | 132 | bool PageObjectContainsMark(CPDF_PageObject* pPageObj, |
| 133 | FPDF_PAGEOBJECTMARK mark) { |
| 134 | const CPDF_ContentMarkItem* pMarkItem = |
| 135 | CPDFContentMarkItemFromFPDFPageObjectMark(mark); |
Tom Sepez | 6eb915b | 2021-04-30 00:11:34 +0000 | [diff] [blame] | 136 | return pMarkItem && pPageObj->GetContentMarks()->ContainsItem(pMarkItem); |
Henrique Nakashima | a340677 | 2018-07-13 19:10:53 +0000 | [diff] [blame] | 137 | } |
| 138 | |
Lei Zhang | 2237541 | 2018-10-24 17:26:50 +0000 | [diff] [blame] | 139 | CPDF_FormObject* CPDFFormObjectFromFPDFPageObject(FPDF_PAGEOBJECT page_object) { |
| 140 | auto* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
| 141 | return pPageObj ? pPageObj->AsForm() : nullptr; |
| 142 | } |
| 143 | |
Tom Sepez | a733d82 | 2019-05-06 19:43:33 +0000 | [diff] [blame] | 144 | const CPDF_PageObjectHolder* CPDFPageObjHolderFromFPDFFormObject( |
Miklos Vajna | 1d273f1 | 2018-07-16 19:20:36 +0000 | [diff] [blame] | 145 | FPDF_PAGEOBJECT page_object) { |
Lei Zhang | 2237541 | 2018-10-24 17:26:50 +0000 | [diff] [blame] | 146 | CPDF_FormObject* pFormObject = CPDFFormObjectFromFPDFPageObject(page_object); |
Tom Sepez | a733d82 | 2019-05-06 19:43:33 +0000 | [diff] [blame] | 147 | return pFormObject ? pFormObject->form() : nullptr; |
Miklos Vajna | 1d273f1 | 2018-07-16 19:20:36 +0000 | [diff] [blame] | 148 | } |
| 149 | |
thestig | c54bb43 | 2016-07-29 19:34:20 -0700 | [diff] [blame] | 150 | } // namespace |
| 151 | |
Dan Sinclair | 00d2ad1 | 2017-08-10 14:13:02 -0400 | [diff] [blame] | 152 | FPDF_EXPORT FPDF_DOCUMENT FPDF_CALLCONV FPDF_CreateNewDocument() { |
Tom Sepez | 5af9543 | 2020-05-15 22:55:16 +0000 | [diff] [blame] | 153 | auto pDoc = |
| 154 | std::make_unique<CPDF_Document>(std::make_unique<CPDF_DocRenderData>(), |
| 155 | std::make_unique<CPDF_DocPageData>()); |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 156 | pDoc->CreateNewDoc(); |
Tom Sepez | fe91c6c | 2017-05-16 15:33:20 -0700 | [diff] [blame] | 157 | |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 158 | time_t currentTime; |
Ryan Harrison | 275e260 | 2017-09-18 14:23:18 -0400 | [diff] [blame] | 159 | ByteString DateStr; |
Tom Sepez | 69a4a70 | 2019-07-31 17:59:49 +0000 | [diff] [blame] | 160 | if (IsPDFSandboxPolicyEnabled(FPDF_POLICY_MACHINETIME_ACCESS)) { |
Ryan Harrison | f36a464 | 2018-08-10 19:03:47 +0000 | [diff] [blame] | 161 | if (FXSYS_time(¤tTime) != -1) { |
Tom Sepez | 706e187 | 2018-10-22 19:34:53 +0000 | [diff] [blame] | 162 | tm* pTM = FXSYS_localtime(¤tTime); |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 163 | if (pTM) { |
Dan Sinclair | 1c4735a | 2017-11-16 22:08:07 +0000 | [diff] [blame] | 164 | DateStr = ByteString::Format( |
| 165 | "D:%04d%02d%02d%02d%02d%02d", pTM->tm_year + 1900, pTM->tm_mon + 1, |
| 166 | pTM->tm_mday, pTM->tm_hour, pTM->tm_min, pTM->tm_sec); |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 167 | } |
| 168 | } |
| 169 | } |
Tom Sepez | bdeeb8a | 2015-05-27 12:25:00 -0700 | [diff] [blame] | 170 | |
Tom Sepez | d9ccef4 | 2022-09-21 00:53:35 +0000 | [diff] [blame] | 171 | RetainPtr<CPDF_Dictionary> pInfoDict = pDoc->GetInfo(); |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 172 | if (pInfoDict) { |
Tom Sepez | 69a4a70 | 2019-07-31 17:59:49 +0000 | [diff] [blame] | 173 | if (IsPDFSandboxPolicyEnabled(FPDF_POLICY_MACHINETIME_ACCESS)) |
tsepez | 0e606b5 | 2016-11-18 16:22:41 -0800 | [diff] [blame] | 174 | pInfoDict->SetNewFor<CPDF_String>("CreationDate", DateStr, false); |
| 175 | pInfoDict->SetNewFor<CPDF_String>("Creator", L"PDFium"); |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 176 | } |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 177 | |
Tom Sepez | fe91c6c | 2017-05-16 15:33:20 -0700 | [diff] [blame] | 178 | // Caller takes ownership of pDoc. |
| 179 | return FPDFDocumentFromCPDFDocument(pDoc.release()); |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 180 | } |
| 181 | |
Dan Sinclair | 00d2ad1 | 2017-08-10 14:13:02 -0400 | [diff] [blame] | 182 | FPDF_EXPORT void FPDF_CALLCONV FPDFPage_Delete(FPDF_DOCUMENT document, |
| 183 | int page_index) { |
Tom Sepez | fe06d51 | 2018-05-01 17:25:25 +0000 | [diff] [blame] | 184 | auto* pDoc = CPDFDocumentFromFPDFDocument(document); |
| 185 | if (!pDoc) |
| 186 | return; |
Tom Sepez | 3f3c39d | 2018-05-01 17:46:34 +0000 | [diff] [blame] | 187 | |
Tom Sepez | 2e118e8 | 2018-05-01 21:24:14 +0000 | [diff] [blame] | 188 | CPDF_Document::Extension* pExtension = pDoc->GetExtension(); |
| 189 | if (pExtension) { |
| 190 | pExtension->DeletePage(page_index); |
Tom Sepez | 3f3c39d | 2018-05-01 17:46:34 +0000 | [diff] [blame] | 191 | return; |
| 192 | } |
Tom Sepez | 3f3c39d | 2018-05-01 17:46:34 +0000 | [diff] [blame] | 193 | |
Tom Sepez | fe06d51 | 2018-05-01 17:25:25 +0000 | [diff] [blame] | 194 | pDoc->DeletePage(page_index); |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 195 | } |
| 196 | |
Dan Sinclair | 00d2ad1 | 2017-08-10 14:13:02 -0400 | [diff] [blame] | 197 | FPDF_EXPORT FPDF_PAGE FPDF_CALLCONV FPDFPage_New(FPDF_DOCUMENT document, |
| 198 | int page_index, |
| 199 | double width, |
| 200 | double height) { |
Tom Sepez | 471a103 | 2015-10-15 16:17:18 -0700 | [diff] [blame] | 201 | CPDF_Document* pDoc = CPDFDocumentFromFPDFDocument(document); |
| 202 | if (!pDoc) |
| 203 | return nullptr; |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 204 | |
Lei Zhang | 85f019a | 2017-03-17 15:14:19 -0700 | [diff] [blame] | 205 | page_index = pdfium::clamp(page_index, 0, pDoc->GetPageCount()); |
Tom Sepez | 61d8ae8 | 2022-07-19 23:24:33 +0000 | [diff] [blame] | 206 | RetainPtr<CPDF_Dictionary> pPageDict(pDoc->CreateNewPage(page_index)); |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 207 | if (!pPageDict) |
thestig | 1cd352e | 2016-06-07 17:53:06 -0700 | [diff] [blame] | 208 | return nullptr; |
thestig | c54bb43 | 2016-07-29 19:34:20 -0700 | [diff] [blame] | 209 | |
Lei Zhang | fc615c6 | 2018-06-08 20:40:15 +0000 | [diff] [blame] | 210 | pPageDict->SetRectFor(pdfium::page_object::kMediaBox, |
| 211 | CFX_FloatRect(0, 0, width, height)); |
| 212 | pPageDict->SetNewFor<CPDF_Number>(pdfium::page_object::kRotate, 0); |
| 213 | pPageDict->SetNewFor<CPDF_Dictionary>(pdfium::page_object::kResources); |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 214 | |
Tom Sepez | 40e9ff3 | 2015-11-30 12:39:54 -0800 | [diff] [blame] | 215 | #ifdef PDF_ENABLE_XFA |
Tom Sepez | 9bf0181 | 2019-08-19 18:59:27 +0000 | [diff] [blame] | 216 | if (pDoc->GetExtension()) { |
| 217 | auto pXFAPage = pdfium::MakeRetain<CPDFXFA_Page>(pDoc, page_index); |
Lei Zhang | 30540a9 | 2018-10-04 22:31:12 +0000 | [diff] [blame] | 218 | pXFAPage->LoadPDFPageFromDict(pPageDict); |
Tom Sepez | 101535f | 2018-06-12 13:36:05 +0000 | [diff] [blame] | 219 | return FPDFPageFromIPDFPage(pXFAPage.Leak()); // Caller takes ownership. |
Tom Sepez | 3f3c39d | 2018-05-01 17:46:34 +0000 | [diff] [blame] | 220 | } |
Tom Sepez | ef9fe9e | 2018-06-12 20:26:56 +0000 | [diff] [blame] | 221 | #endif // PDF_ENABLE_XFA |
| 222 | |
Tom Sepez | 0208b0c | 2019-07-23 21:52:50 +0000 | [diff] [blame] | 223 | auto pPage = pdfium::MakeRetain<CPDF_Page>(pDoc, pPageDict); |
Tom Sepez | 5af9543 | 2020-05-15 22:55:16 +0000 | [diff] [blame] | 224 | pPage->SetRenderCache(std::make_unique<CPDF_PageRenderCache>(pPage.Get())); |
Tom Sepez | f06ed6d | 2018-06-04 18:26:07 +0000 | [diff] [blame] | 225 | pPage->ParseContent(); |
Tom Sepez | 0208b0c | 2019-07-23 21:52:50 +0000 | [diff] [blame] | 226 | |
Tom Sepez | 101535f | 2018-06-12 13:36:05 +0000 | [diff] [blame] | 227 | return FPDFPageFromIPDFPage(pPage.Leak()); // Caller takes ownership. |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 228 | } |
| 229 | |
Dan Sinclair | 00d2ad1 | 2017-08-10 14:13:02 -0400 | [diff] [blame] | 230 | FPDF_EXPORT int FPDF_CALLCONV FPDFPage_GetRotation(FPDF_PAGE page) { |
Tom Sepez | db0be96 | 2015-10-16 14:00:21 -0700 | [diff] [blame] | 231 | CPDF_Page* pPage = CPDFPageFromFPDFPage(page); |
Tom Sepez | fe91c6c | 2017-05-16 15:33:20 -0700 | [diff] [blame] | 232 | return IsPageObject(pPage) ? pPage->GetPageRotation() : -1; |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 233 | } |
| 234 | |
Dan Sinclair | 00d2ad1 | 2017-08-10 14:13:02 -0400 | [diff] [blame] | 235 | FPDF_EXPORT void FPDF_CALLCONV FPDFPage_InsertObject(FPDF_PAGE page, |
| 236 | FPDF_PAGEOBJECT page_obj) { |
Jane Liu | 1a08402 | 2017-06-29 19:47:12 -0400 | [diff] [blame] | 237 | CPDF_PageObject* pPageObj = CPDFPageObjectFromFPDFPageObject(page_obj); |
Lei Zhang | 997de61 | 2015-11-04 18:17:53 -0800 | [diff] [blame] | 238 | if (!pPageObj) |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 239 | return; |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 240 | |
thestig | c54bb43 | 2016-07-29 19:34:20 -0700 | [diff] [blame] | 241 | std::unique_ptr<CPDF_PageObject> pPageObjHolder(pPageObj); |
| 242 | CPDF_Page* pPage = CPDFPageFromFPDFPage(page); |
| 243 | if (!IsPageObject(pPage)) |
| 244 | return; |
Henrique Nakashima | 35841fa | 2018-03-15 15:25:16 +0000 | [diff] [blame] | 245 | |
Lei Zhang | 2237541 | 2018-10-24 17:26:50 +0000 | [diff] [blame] | 246 | pPageObj->SetDirty(true); |
Henrique Nakashima | 2c47fb2 | 2018-03-26 20:17:29 +0000 | [diff] [blame] | 247 | pPage->AppendPageObject(std::move(pPageObjHolder)); |
wileyrya | e858aa4 | 2017-05-31 14:49:05 -0500 | [diff] [blame] | 248 | CalcBoundingBox(pPageObj); |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 249 | } |
| 250 | |
Henrique Nakashima | 35841fa | 2018-03-15 15:25:16 +0000 | [diff] [blame] | 251 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
| 252 | FPDFPage_RemoveObject(FPDF_PAGE page, FPDF_PAGEOBJECT page_obj) { |
| 253 | CPDF_PageObject* pPageObj = CPDFPageObjectFromFPDFPageObject(page_obj); |
| 254 | if (!pPageObj) |
| 255 | return false; |
| 256 | |
| 257 | CPDF_Page* pPage = CPDFPageFromFPDFPage(page); |
| 258 | if (!IsPageObject(pPage)) |
| 259 | return false; |
| 260 | |
Henrique Nakashima | 2c47fb2 | 2018-03-26 20:17:29 +0000 | [diff] [blame] | 261 | return pPage->RemovePageObject(pPageObj); |
Henrique Nakashima | 35841fa | 2018-03-15 15:25:16 +0000 | [diff] [blame] | 262 | } |
| 263 | |
Miklos Vajna | 9262761 | 2017-09-25 12:59:29 +0200 | [diff] [blame] | 264 | FPDF_EXPORT int FPDF_CALLCONV FPDFPage_CountObjects(FPDF_PAGE page) { |
Tom Sepez | bf59a07 | 2015-10-21 14:07:23 -0700 | [diff] [blame] | 265 | CPDF_Page* pPage = CPDFPageFromFPDFPage(page); |
thestig | c54bb43 | 2016-07-29 19:34:20 -0700 | [diff] [blame] | 266 | if (!IsPageObject(pPage)) |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 267 | return -1; |
Henrique Nakashima | 35841fa | 2018-03-15 15:25:16 +0000 | [diff] [blame] | 268 | |
Tom Sepez | 8ef63b9 | 2022-03-08 19:53:34 +0000 | [diff] [blame] | 269 | return pdfium::base::checked_cast<int>(pPage->GetPageObjectCount()); |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 270 | } |
| 271 | |
Dan Sinclair | 00d2ad1 | 2017-08-10 14:13:02 -0400 | [diff] [blame] | 272 | FPDF_EXPORT FPDF_PAGEOBJECT FPDF_CALLCONV FPDFPage_GetObject(FPDF_PAGE page, |
| 273 | int index) { |
Tom Sepez | db0be96 | 2015-10-16 14:00:21 -0700 | [diff] [blame] | 274 | CPDF_Page* pPage = CPDFPageFromFPDFPage(page); |
thestig | c54bb43 | 2016-07-29 19:34:20 -0700 | [diff] [blame] | 275 | if (!IsPageObject(pPage)) |
Tom Sepez | 2398d89 | 2016-02-17 16:46:26 -0800 | [diff] [blame] | 276 | return nullptr; |
Henrique Nakashima | 35841fa | 2018-03-15 15:25:16 +0000 | [diff] [blame] | 277 | |
Tom Sepez | 525147a | 2018-05-03 17:19:53 +0000 | [diff] [blame] | 278 | return FPDFPageObjectFromCPDFPageObject(pPage->GetPageObjectByIndex(index)); |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 279 | } |
| 280 | |
Dan Sinclair | 00d2ad1 | 2017-08-10 14:13:02 -0400 | [diff] [blame] | 281 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFPage_HasTransparency(FPDF_PAGE page) { |
Tom Sepez | db0be96 | 2015-10-16 14:00:21 -0700 | [diff] [blame] | 282 | CPDF_Page* pPage = CPDFPageFromFPDFPage(page); |
| 283 | return pPage && pPage->BackgroundAlphaNeeded(); |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 284 | } |
| 285 | |
Dan Sinclair | 00d2ad1 | 2017-08-10 14:13:02 -0400 | [diff] [blame] | 286 | FPDF_EXPORT void FPDF_CALLCONV FPDFPageObj_Destroy(FPDF_PAGEOBJECT page_obj) { |
Jane Liu | 2e5f0ae | 2017-08-08 15:23:27 -0400 | [diff] [blame] | 287 | delete CPDFPageObjectFromFPDFPageObject(page_obj); |
| 288 | } |
| 289 | |
Henrique Nakashima | c90adc5 | 2018-03-27 16:26:44 +0000 | [diff] [blame] | 290 | FPDF_EXPORT int FPDF_CALLCONV |
| 291 | FPDFPageObj_CountMarks(FPDF_PAGEOBJECT page_object) { |
Lei Zhang | 2237541 | 2018-10-24 17:26:50 +0000 | [diff] [blame] | 292 | CPDF_PageObject* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
| 293 | if (!pPageObj) |
Henrique Nakashima | c90adc5 | 2018-03-27 16:26:44 +0000 | [diff] [blame] | 294 | return -1; |
| 295 | |
Tom Sepez | 8ef63b9 | 2022-03-08 19:53:34 +0000 | [diff] [blame] | 296 | return pdfium::base::checked_cast<int>( |
| 297 | pPageObj->GetContentMarks()->CountItems()); |
Henrique Nakashima | c90adc5 | 2018-03-27 16:26:44 +0000 | [diff] [blame] | 298 | } |
| 299 | |
| 300 | FPDF_EXPORT FPDF_PAGEOBJECTMARK FPDF_CALLCONV |
| 301 | FPDFPageObj_GetMark(FPDF_PAGEOBJECT page_object, unsigned long index) { |
Lei Zhang | 2237541 | 2018-10-24 17:26:50 +0000 | [diff] [blame] | 302 | CPDF_PageObject* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
| 303 | if (!pPageObj) |
Henrique Nakashima | c90adc5 | 2018-03-27 16:26:44 +0000 | [diff] [blame] | 304 | return nullptr; |
| 305 | |
Tom Sepez | 6eb915b | 2021-04-30 00:11:34 +0000 | [diff] [blame] | 306 | CPDF_ContentMarks* pMarks = pPageObj->GetContentMarks(); |
| 307 | if (index >= pMarks->CountItems()) |
Henrique Nakashima | c90adc5 | 2018-03-27 16:26:44 +0000 | [diff] [blame] | 308 | return nullptr; |
| 309 | |
Tom Sepez | 6eb915b | 2021-04-30 00:11:34 +0000 | [diff] [blame] | 310 | return FPDFPageObjectMarkFromCPDFContentMarkItem(pMarks->GetItem(index)); |
Henrique Nakashima | 144107d | 2018-07-10 21:04:05 +0000 | [diff] [blame] | 311 | } |
| 312 | |
| 313 | FPDF_EXPORT FPDF_PAGEOBJECTMARK FPDF_CALLCONV |
| 314 | FPDFPageObj_AddMark(FPDF_PAGEOBJECT page_object, FPDF_BYTESTRING name) { |
Henrique Nakashima | d8df8c3 | 2018-07-12 22:15:09 +0000 | [diff] [blame] | 315 | CPDF_PageObject* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
| 316 | if (!pPageObj) |
Henrique Nakashima | 144107d | 2018-07-10 21:04:05 +0000 | [diff] [blame] | 317 | return nullptr; |
| 318 | |
Tom Sepez | 6eb915b | 2021-04-30 00:11:34 +0000 | [diff] [blame] | 319 | CPDF_ContentMarks* pMarks = pPageObj->GetContentMarks(); |
| 320 | pMarks->AddMark(name); |
Henrique Nakashima | d8df8c3 | 2018-07-12 22:15:09 +0000 | [diff] [blame] | 321 | pPageObj->SetDirty(true); |
Tom Sepez | 6eb915b | 2021-04-30 00:11:34 +0000 | [diff] [blame] | 322 | |
Tom Sepez | 8ef63b9 | 2022-03-08 19:53:34 +0000 | [diff] [blame] | 323 | const size_t index = pMarks->CountItems() - 1; |
Tom Sepez | 6eb915b | 2021-04-30 00:11:34 +0000 | [diff] [blame] | 324 | return FPDFPageObjectMarkFromCPDFContentMarkItem(pMarks->GetItem(index)); |
Henrique Nakashima | c90adc5 | 2018-03-27 16:26:44 +0000 | [diff] [blame] | 325 | } |
| 326 | |
Henrique Nakashima | fed4adb | 2018-07-13 19:47:22 +0000 | [diff] [blame] | 327 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
| 328 | FPDFPageObj_RemoveMark(FPDF_PAGEOBJECT page_object, FPDF_PAGEOBJECTMARK mark) { |
| 329 | CPDF_PageObject* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
| 330 | CPDF_ContentMarkItem* pMarkItem = |
| 331 | CPDFContentMarkItemFromFPDFPageObjectMark(mark); |
| 332 | if (!pPageObj || !pMarkItem) |
| 333 | return false; |
| 334 | |
Tom Sepez | 6eb915b | 2021-04-30 00:11:34 +0000 | [diff] [blame] | 335 | if (!pPageObj->GetContentMarks()->RemoveMark(pMarkItem)) |
| 336 | return false; |
Henrique Nakashima | fed4adb | 2018-07-13 19:47:22 +0000 | [diff] [blame] | 337 | |
Tom Sepez | 6eb915b | 2021-04-30 00:11:34 +0000 | [diff] [blame] | 338 | pPageObj->SetDirty(true); |
| 339 | return true; |
Henrique Nakashima | fed4adb | 2018-07-13 19:47:22 +0000 | [diff] [blame] | 340 | } |
| 341 | |
Henrique Nakashima | c3099d1 | 2018-09-18 18:08:15 +0000 | [diff] [blame] | 342 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
Henrique Nakashima | c90adc5 | 2018-03-27 16:26:44 +0000 | [diff] [blame] | 343 | FPDFPageObjMark_GetName(FPDF_PAGEOBJECTMARK mark, |
| 344 | void* buffer, |
Henrique Nakashima | c3099d1 | 2018-09-18 18:08:15 +0000 | [diff] [blame] | 345 | unsigned long buflen, |
| 346 | unsigned long* out_buflen) { |
Henrique Nakashima | c90adc5 | 2018-03-27 16:26:44 +0000 | [diff] [blame] | 347 | const CPDF_ContentMarkItem* pMarkItem = |
| 348 | CPDFContentMarkItemFromFPDFPageObjectMark(mark); |
Lei Zhang | bc3d840 | 2020-06-18 17:17:28 +0000 | [diff] [blame] | 349 | if (!pMarkItem || !out_buflen) |
| 350 | return false; |
Henrique Nakashima | c90adc5 | 2018-03-27 16:26:44 +0000 | [diff] [blame] | 351 | |
Henrique Nakashima | c3099d1 | 2018-09-18 18:08:15 +0000 | [diff] [blame] | 352 | *out_buflen = Utf16EncodeMaybeCopyAndReturnLength( |
Henrique Nakashima | c90adc5 | 2018-03-27 16:26:44 +0000 | [diff] [blame] | 353 | WideString::FromUTF8(pMarkItem->GetName().AsStringView()), buffer, |
| 354 | buflen); |
Henrique Nakashima | c3099d1 | 2018-09-18 18:08:15 +0000 | [diff] [blame] | 355 | return true; |
Henrique Nakashima | c90adc5 | 2018-03-27 16:26:44 +0000 | [diff] [blame] | 356 | } |
| 357 | |
Henrique Nakashima | aed6253 | 2018-04-17 20:34:38 +0000 | [diff] [blame] | 358 | FPDF_EXPORT int FPDF_CALLCONV |
| 359 | FPDFPageObjMark_CountParams(FPDF_PAGEOBJECTMARK mark) { |
Henrique Nakashima | aed6253 | 2018-04-17 20:34:38 +0000 | [diff] [blame] | 360 | const CPDF_ContentMarkItem* pMarkItem = |
| 361 | CPDFContentMarkItemFromFPDFPageObjectMark(mark); |
Lei Zhang | bc3d840 | 2020-06-18 17:17:28 +0000 | [diff] [blame] | 362 | if (!pMarkItem) |
| 363 | return -1; |
Henrique Nakashima | aed6253 | 2018-04-17 20:34:38 +0000 | [diff] [blame] | 364 | |
Tom Sepez | b7ee8d6 | 2022-09-26 19:31:53 +0000 | [diff] [blame] | 365 | RetainPtr<const CPDF_Dictionary> pParams = pMarkItem->GetParam(); |
Tom Sepez | 8ef63b9 | 2022-03-08 19:53:34 +0000 | [diff] [blame] | 366 | return pParams ? fxcrt::CollectionSize<int>(*pParams) : 0; |
Henrique Nakashima | aed6253 | 2018-04-17 20:34:38 +0000 | [diff] [blame] | 367 | } |
| 368 | |
Henrique Nakashima | c3099d1 | 2018-09-18 18:08:15 +0000 | [diff] [blame] | 369 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
Henrique Nakashima | 132c38e | 2018-04-23 16:35:56 +0000 | [diff] [blame] | 370 | FPDFPageObjMark_GetParamKey(FPDF_PAGEOBJECTMARK mark, |
| 371 | unsigned long index, |
| 372 | void* buffer, |
Henrique Nakashima | c3099d1 | 2018-09-18 18:08:15 +0000 | [diff] [blame] | 373 | unsigned long buflen, |
| 374 | unsigned long* out_buflen) { |
| 375 | if (!out_buflen) |
| 376 | return false; |
| 377 | |
Tom Sepez | b7ee8d6 | 2022-09-26 19:31:53 +0000 | [diff] [blame] | 378 | RetainPtr<const CPDF_Dictionary> pParams = GetMarkParamDict(mark); |
Henrique Nakashima | d888219 | 2018-07-11 22:35:59 +0000 | [diff] [blame] | 379 | if (!pParams) |
Henrique Nakashima | c3099d1 | 2018-09-18 18:08:15 +0000 | [diff] [blame] | 380 | return false; |
Henrique Nakashima | 132c38e | 2018-04-23 16:35:56 +0000 | [diff] [blame] | 381 | |
Tom Sepez | 5ae6c56 | 2018-10-17 17:57:51 +0000 | [diff] [blame] | 382 | CPDF_DictionaryLocker locker(pParams); |
| 383 | for (auto& it : locker) { |
Henrique Nakashima | d888219 | 2018-07-11 22:35:59 +0000 | [diff] [blame] | 384 | if (index == 0) { |
Henrique Nakashima | c3099d1 | 2018-09-18 18:08:15 +0000 | [diff] [blame] | 385 | *out_buflen = Utf16EncodeMaybeCopyAndReturnLength( |
Henrique Nakashima | d888219 | 2018-07-11 22:35:59 +0000 | [diff] [blame] | 386 | WideString::FromUTF8(it.first.AsStringView()), buffer, buflen); |
Henrique Nakashima | c3099d1 | 2018-09-18 18:08:15 +0000 | [diff] [blame] | 387 | return true; |
Henrique Nakashima | d888219 | 2018-07-11 22:35:59 +0000 | [diff] [blame] | 388 | } |
| 389 | --index; |
| 390 | } |
| 391 | |
Henrique Nakashima | c3099d1 | 2018-09-18 18:08:15 +0000 | [diff] [blame] | 392 | return false; |
Henrique Nakashima | 132c38e | 2018-04-23 16:35:56 +0000 | [diff] [blame] | 393 | } |
| 394 | |
Henrique Nakashima | 7007fd5 | 2018-07-05 18:04:19 +0000 | [diff] [blame] | 395 | FPDF_EXPORT FPDF_OBJECT_TYPE FPDF_CALLCONV |
Henrique Nakashima | 94230e5 | 2018-07-11 22:02:02 +0000 | [diff] [blame] | 396 | FPDFPageObjMark_GetParamValueType(FPDF_PAGEOBJECTMARK mark, |
| 397 | FPDF_BYTESTRING key) { |
Tom Sepez | b7ee8d6 | 2022-09-26 19:31:53 +0000 | [diff] [blame] | 398 | RetainPtr<const CPDF_Dictionary> pParams = GetMarkParamDict(mark); |
Henrique Nakashima | 7007fd5 | 2018-07-05 18:04:19 +0000 | [diff] [blame] | 399 | if (!pParams) |
| 400 | return FPDF_OBJECT_UNKNOWN; |
| 401 | |
Tom Sepez | 3f90d43 | 2022-09-19 20:53:13 +0000 | [diff] [blame] | 402 | RetainPtr<const CPDF_Object> pObject = pParams->GetObjectFor(key); |
Lei Zhang | bfeb934 | 2018-07-14 00:07:17 +0000 | [diff] [blame] | 403 | return pObject ? pObject->GetType() : FPDF_OBJECT_UNKNOWN; |
Henrique Nakashima | 7007fd5 | 2018-07-05 18:04:19 +0000 | [diff] [blame] | 404 | } |
| 405 | |
Henrique Nakashima | 7007fd5 | 2018-07-05 18:04:19 +0000 | [diff] [blame] | 406 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
Henrique Nakashima | 94230e5 | 2018-07-11 22:02:02 +0000 | [diff] [blame] | 407 | FPDFPageObjMark_GetParamIntValue(FPDF_PAGEOBJECTMARK mark, |
| 408 | FPDF_BYTESTRING key, |
| 409 | int* out_value) { |
Henrique Nakashima | c3099d1 | 2018-09-18 18:08:15 +0000 | [diff] [blame] | 410 | if (!out_value) |
| 411 | return false; |
| 412 | |
Tom Sepez | b7ee8d6 | 2022-09-26 19:31:53 +0000 | [diff] [blame] | 413 | RetainPtr<const CPDF_Dictionary> pParams = GetMarkParamDict(mark); |
Henrique Nakashima | 7007fd5 | 2018-07-05 18:04:19 +0000 | [diff] [blame] | 414 | if (!pParams) |
| 415 | return false; |
| 416 | |
Tom Sepez | 3f90d43 | 2022-09-19 20:53:13 +0000 | [diff] [blame] | 417 | RetainPtr<const CPDF_Object> pObj = pParams->GetObjectFor(key); |
Henrique Nakashima | 7007fd5 | 2018-07-05 18:04:19 +0000 | [diff] [blame] | 418 | if (!pObj || !pObj->IsNumber()) |
| 419 | return false; |
| 420 | |
| 421 | *out_value = pObj->GetInteger(); |
| 422 | return true; |
| 423 | } |
| 424 | |
Dan Sinclair | 00d2ad1 | 2017-08-10 14:13:02 -0400 | [diff] [blame] | 425 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
Henrique Nakashima | 94230e5 | 2018-07-11 22:02:02 +0000 | [diff] [blame] | 426 | FPDFPageObjMark_GetParamStringValue(FPDF_PAGEOBJECTMARK mark, |
| 427 | FPDF_BYTESTRING key, |
| 428 | void* buffer, |
| 429 | unsigned long buflen, |
| 430 | unsigned long* out_buflen) { |
Henrique Nakashima | 07520f6 | 2018-07-12 19:45:29 +0000 | [diff] [blame] | 431 | if (!out_buflen) |
| 432 | return false; |
| 433 | |
Tom Sepez | b7ee8d6 | 2022-09-26 19:31:53 +0000 | [diff] [blame] | 434 | RetainPtr<const CPDF_Dictionary> pParams = GetMarkParamDict(mark); |
Henrique Nakashima | 7007fd5 | 2018-07-05 18:04:19 +0000 | [diff] [blame] | 435 | if (!pParams) |
| 436 | return false; |
| 437 | |
Tom Sepez | 3f90d43 | 2022-09-19 20:53:13 +0000 | [diff] [blame] | 438 | RetainPtr<const CPDF_Object> pObj = pParams->GetObjectFor(key); |
Henrique Nakashima | 7007fd5 | 2018-07-05 18:04:19 +0000 | [diff] [blame] | 439 | if (!pObj || !pObj->IsString()) |
| 440 | return false; |
| 441 | |
| 442 | *out_buflen = Utf16EncodeMaybeCopyAndReturnLength( |
| 443 | WideString::FromUTF8(pObj->GetString().AsStringView()), buffer, buflen); |
| 444 | return true; |
| 445 | } |
| 446 | |
| 447 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
Henrique Nakashima | 07520f6 | 2018-07-12 19:45:29 +0000 | [diff] [blame] | 448 | FPDFPageObjMark_GetParamBlobValue(FPDF_PAGEOBJECTMARK mark, |
| 449 | FPDF_BYTESTRING key, |
| 450 | void* buffer, |
| 451 | unsigned long buflen, |
| 452 | unsigned long* out_buflen) { |
| 453 | if (!out_buflen) |
| 454 | return false; |
| 455 | |
Tom Sepez | b7ee8d6 | 2022-09-26 19:31:53 +0000 | [diff] [blame] | 456 | RetainPtr<const CPDF_Dictionary> pParams = GetMarkParamDict(mark); |
Henrique Nakashima | 07520f6 | 2018-07-12 19:45:29 +0000 | [diff] [blame] | 457 | if (!pParams) |
| 458 | return false; |
| 459 | |
Tom Sepez | 3f90d43 | 2022-09-19 20:53:13 +0000 | [diff] [blame] | 460 | RetainPtr<const CPDF_Object> pObj = pParams->GetObjectFor(key); |
Henrique Nakashima | 07520f6 | 2018-07-12 19:45:29 +0000 | [diff] [blame] | 461 | if (!pObj || !pObj->IsString()) |
| 462 | return false; |
| 463 | |
| 464 | ByteString result = pObj->GetString(); |
Tom Sepez | 8ef63b9 | 2022-03-08 19:53:34 +0000 | [diff] [blame] | 465 | const unsigned long len = |
| 466 | pdfium::base::checked_cast<unsigned long>(result.GetLength()); |
Henrique Nakashima | 07520f6 | 2018-07-12 19:45:29 +0000 | [diff] [blame] | 467 | |
| 468 | if (buffer && len <= buflen) |
| 469 | memcpy(buffer, result.c_str(), len); |
| 470 | |
| 471 | *out_buflen = len; |
| 472 | return true; |
| 473 | } |
| 474 | |
| 475 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
Andrew Weintraub | fe111d9 | 2019-06-24 17:19:20 +0000 | [diff] [blame] | 476 | FPDFPageObj_HasTransparency(FPDF_PAGEOBJECT page_object) { |
| 477 | CPDF_PageObject* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
Lei Zhang | 2237541 | 2018-10-24 17:26:50 +0000 | [diff] [blame] | 478 | if (!pPageObj) |
tsepez | 4cf5515 | 2016-11-02 14:37:54 -0700 | [diff] [blame] | 479 | return false; |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 480 | |
Lei Zhang | 0c32765 | 2018-10-25 19:02:50 +0000 | [diff] [blame] | 481 | if (pPageObj->m_GeneralState.GetBlendType() != BlendMode::kNormal) |
tsepez | 4cf5515 | 2016-11-02 14:37:54 -0700 | [diff] [blame] | 482 | return true; |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 483 | |
Tom Sepez | dd844b8 | 2022-08-11 08:32:01 +0000 | [diff] [blame] | 484 | const CPDF_Dictionary* pSMaskDict = pPageObj->m_GeneralState.GetSoftMask(); |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 485 | if (pSMaskDict) |
tsepez | 4cf5515 | 2016-11-02 14:37:54 -0700 | [diff] [blame] | 486 | return true; |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 487 | |
tsepez | bbee445 | 2016-09-02 15:22:00 -0700 | [diff] [blame] | 488 | if (pPageObj->m_GeneralState.GetFillAlpha() != 1.0f) |
tsepez | 4cf5515 | 2016-11-02 14:37:54 -0700 | [diff] [blame] | 489 | return true; |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 490 | |
Lei Zhang | 0c32765 | 2018-10-25 19:02:50 +0000 | [diff] [blame] | 491 | if (pPageObj->IsPath() && pPageObj->m_GeneralState.GetStrokeAlpha() != 1.0f) |
tsepez | 4cf5515 | 2016-11-02 14:37:54 -0700 | [diff] [blame] | 492 | return true; |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 493 | |
Lei Zhang | 0c32765 | 2018-10-25 19:02:50 +0000 | [diff] [blame] | 494 | if (!pPageObj->IsForm()) |
| 495 | return false; |
thestig | c54bb43 | 2016-07-29 19:34:20 -0700 | [diff] [blame] | 496 | |
Lei Zhang | 0c32765 | 2018-10-25 19:02:50 +0000 | [diff] [blame] | 497 | const CPDF_Form* pForm = pPageObj->AsForm()->form(); |
| 498 | if (!pForm) |
| 499 | return false; |
| 500 | |
| 501 | const CPDF_Transparency& trans = pForm->GetTransparency(); |
| 502 | return trans.IsGroup() || trans.IsIsolated(); |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 503 | } |
| 504 | |
Henrique Nakashima | 144107d | 2018-07-10 21:04:05 +0000 | [diff] [blame] | 505 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
| 506 | FPDFPageObjMark_SetIntParam(FPDF_DOCUMENT document, |
Henrique Nakashima | a340677 | 2018-07-13 19:10:53 +0000 | [diff] [blame] | 507 | FPDF_PAGEOBJECT page_object, |
Henrique Nakashima | 144107d | 2018-07-10 21:04:05 +0000 | [diff] [blame] | 508 | FPDF_PAGEOBJECTMARK mark, |
| 509 | FPDF_BYTESTRING key, |
| 510 | int value) { |
Henrique Nakashima | a340677 | 2018-07-13 19:10:53 +0000 | [diff] [blame] | 511 | CPDF_PageObject* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
| 512 | if (!pPageObj || !PageObjectContainsMark(pPageObj, mark)) |
| 513 | return false; |
| 514 | |
Tom Sepez | b7ee8d6 | 2022-09-26 19:31:53 +0000 | [diff] [blame] | 515 | RetainPtr<CPDF_Dictionary> pParams = |
| 516 | GetOrCreateMarkParamsDict(document, mark); |
Henrique Nakashima | 144107d | 2018-07-10 21:04:05 +0000 | [diff] [blame] | 517 | if (!pParams) |
| 518 | return false; |
| 519 | |
| 520 | pParams->SetNewFor<CPDF_Number>(key, value); |
Henrique Nakashima | a340677 | 2018-07-13 19:10:53 +0000 | [diff] [blame] | 521 | pPageObj->SetDirty(true); |
Henrique Nakashima | 144107d | 2018-07-10 21:04:05 +0000 | [diff] [blame] | 522 | return true; |
| 523 | } |
| 524 | |
| 525 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
| 526 | FPDFPageObjMark_SetStringParam(FPDF_DOCUMENT document, |
Henrique Nakashima | a340677 | 2018-07-13 19:10:53 +0000 | [diff] [blame] | 527 | FPDF_PAGEOBJECT page_object, |
Henrique Nakashima | 144107d | 2018-07-10 21:04:05 +0000 | [diff] [blame] | 528 | FPDF_PAGEOBJECTMARK mark, |
| 529 | FPDF_BYTESTRING key, |
| 530 | FPDF_BYTESTRING value) { |
Henrique Nakashima | a340677 | 2018-07-13 19:10:53 +0000 | [diff] [blame] | 531 | CPDF_PageObject* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
| 532 | if (!pPageObj || !PageObjectContainsMark(pPageObj, mark)) |
| 533 | return false; |
| 534 | |
Tom Sepez | b7ee8d6 | 2022-09-26 19:31:53 +0000 | [diff] [blame] | 535 | RetainPtr<CPDF_Dictionary> pParams = |
| 536 | GetOrCreateMarkParamsDict(document, mark); |
Henrique Nakashima | 144107d | 2018-07-10 21:04:05 +0000 | [diff] [blame] | 537 | if (!pParams) |
| 538 | return false; |
| 539 | |
| 540 | pParams->SetNewFor<CPDF_String>(key, value, false); |
Henrique Nakashima | a340677 | 2018-07-13 19:10:53 +0000 | [diff] [blame] | 541 | pPageObj->SetDirty(true); |
Henrique Nakashima | 144107d | 2018-07-10 21:04:05 +0000 | [diff] [blame] | 542 | return true; |
| 543 | } |
| 544 | |
Henrique Nakashima | 07520f6 | 2018-07-12 19:45:29 +0000 | [diff] [blame] | 545 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
| 546 | FPDFPageObjMark_SetBlobParam(FPDF_DOCUMENT document, |
Henrique Nakashima | a340677 | 2018-07-13 19:10:53 +0000 | [diff] [blame] | 547 | FPDF_PAGEOBJECT page_object, |
Henrique Nakashima | 07520f6 | 2018-07-12 19:45:29 +0000 | [diff] [blame] | 548 | FPDF_PAGEOBJECTMARK mark, |
| 549 | FPDF_BYTESTRING key, |
| 550 | void* value, |
| 551 | unsigned long value_len) { |
Henrique Nakashima | a340677 | 2018-07-13 19:10:53 +0000 | [diff] [blame] | 552 | CPDF_PageObject* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
| 553 | if (!pPageObj || !PageObjectContainsMark(pPageObj, mark)) |
| 554 | return false; |
| 555 | |
Tom Sepez | b7ee8d6 | 2022-09-26 19:31:53 +0000 | [diff] [blame] | 556 | RetainPtr<CPDF_Dictionary> pParams = |
| 557 | GetOrCreateMarkParamsDict(document, mark); |
Henrique Nakashima | 07520f6 | 2018-07-12 19:45:29 +0000 | [diff] [blame] | 558 | if (!pParams) |
| 559 | return false; |
| 560 | |
| 561 | if (!value && value_len > 0) |
| 562 | return false; |
| 563 | |
| 564 | pParams->SetNewFor<CPDF_String>( |
| 565 | key, ByteString(static_cast<const char*>(value), value_len), true); |
Henrique Nakashima | a340677 | 2018-07-13 19:10:53 +0000 | [diff] [blame] | 566 | pPageObj->SetDirty(true); |
Henrique Nakashima | 07520f6 | 2018-07-12 19:45:29 +0000 | [diff] [blame] | 567 | return true; |
| 568 | } |
| 569 | |
Henrique Nakashima | cf403ba | 2018-07-13 20:12:41 +0000 | [diff] [blame] | 570 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
| 571 | FPDFPageObjMark_RemoveParam(FPDF_PAGEOBJECT page_object, |
| 572 | FPDF_PAGEOBJECTMARK mark, |
| 573 | FPDF_BYTESTRING key) { |
| 574 | CPDF_PageObject* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
| 575 | if (!pPageObj) |
| 576 | return false; |
| 577 | |
Tom Sepez | b7ee8d6 | 2022-09-26 19:31:53 +0000 | [diff] [blame] | 578 | RetainPtr<CPDF_Dictionary> pParams = GetMarkParamDict(mark); |
Henrique Nakashima | cf403ba | 2018-07-13 20:12:41 +0000 | [diff] [blame] | 579 | if (!pParams) |
| 580 | return false; |
| 581 | |
| 582 | auto removed = pParams->RemoveFor(key); |
| 583 | if (!removed) |
| 584 | return false; |
| 585 | |
| 586 | pPageObj->SetDirty(true); |
| 587 | return true; |
| 588 | } |
| 589 | |
Andrew Weintraub | fe111d9 | 2019-06-24 17:19:20 +0000 | [diff] [blame] | 590 | FPDF_EXPORT int FPDF_CALLCONV FPDFPageObj_GetType(FPDF_PAGEOBJECT page_object) { |
| 591 | CPDF_PageObject* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
Lei Zhang | f3b5967 | 2022-02-22 18:48:42 +0000 | [diff] [blame] | 592 | return pPageObj ? static_cast<int>(pPageObj->GetType()) |
| 593 | : FPDF_PAGEOBJ_UNKNOWN; |
Miklos Vajna | 1423319 | 2017-04-03 16:02:39 +0200 | [diff] [blame] | 594 | } |
| 595 | |
Dan Sinclair | 00d2ad1 | 2017-08-10 14:13:02 -0400 | [diff] [blame] | 596 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFPage_GenerateContent(FPDF_PAGE page) { |
Tom Sepez | db0be96 | 2015-10-16 14:00:21 -0700 | [diff] [blame] | 597 | CPDF_Page* pPage = CPDFPageFromFPDFPage(page); |
thestig | c54bb43 | 2016-07-29 19:34:20 -0700 | [diff] [blame] | 598 | if (!IsPageObject(pPage)) |
tsepez | 4cf5515 | 2016-11-02 14:37:54 -0700 | [diff] [blame] | 599 | return false; |
thestig | c54bb43 | 2016-07-29 19:34:20 -0700 | [diff] [blame] | 600 | |
Tom Sepez | e19e06e | 2016-01-21 10:49:56 -0800 | [diff] [blame] | 601 | CPDF_PageContentGenerator CG(pPage); |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 602 | CG.GenerateContent(); |
tsepez | 4cf5515 | 2016-11-02 14:37:54 -0700 | [diff] [blame] | 603 | return true; |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 604 | } |
| 605 | |
Dan Sinclair | 00d2ad1 | 2017-08-10 14:13:02 -0400 | [diff] [blame] | 606 | FPDF_EXPORT void FPDF_CALLCONV |
| 607 | FPDFPageObj_Transform(FPDF_PAGEOBJECT page_object, |
| 608 | double a, |
| 609 | double b, |
| 610 | double c, |
| 611 | double d, |
| 612 | double e, |
| 613 | double f) { |
Jane Liu | 1a08402 | 2017-06-29 19:47:12 -0400 | [diff] [blame] | 614 | CPDF_PageObject* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
Lei Zhang | 997de61 | 2015-11-04 18:17:53 -0800 | [diff] [blame] | 615 | if (!pPageObj) |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 616 | return; |
Lei Zhang | cb78ef5 | 2015-10-02 10:10:49 -0700 | [diff] [blame] | 617 | |
Dan Sinclair | 05df075 | 2017-03-14 14:43:42 -0400 | [diff] [blame] | 618 | CFX_Matrix matrix((float)a, (float)b, (float)c, (float)d, (float)e, (float)f); |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 619 | pPageObj->Transform(matrix); |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 620 | } |
thestig | c54bb43 | 2016-07-29 19:34:20 -0700 | [diff] [blame] | 621 | |
Lei Zhang | c8601bf | 2021-06-29 23:19:27 +0000 | [diff] [blame] | 622 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
| 623 | FPDFPageObj_GetMatrix(FPDF_PAGEOBJECT page_object, FS_MATRIX* matrix) { |
| 624 | CPDF_PageObject* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
| 625 | if (!pPageObj || !matrix) |
| 626 | return false; |
| 627 | |
| 628 | switch (pPageObj->GetType()) { |
Lei Zhang | f3b5967 | 2022-02-22 18:48:42 +0000 | [diff] [blame] | 629 | case CPDF_PageObject::Type::kText: |
Lei Zhang | c8601bf | 2021-06-29 23:19:27 +0000 | [diff] [blame] | 630 | *matrix = FSMatrixFromCFXMatrix(pPageObj->AsText()->GetTextMatrix()); |
| 631 | return true; |
Lei Zhang | f3b5967 | 2022-02-22 18:48:42 +0000 | [diff] [blame] | 632 | case CPDF_PageObject::Type::kPath: |
Lei Zhang | c8601bf | 2021-06-29 23:19:27 +0000 | [diff] [blame] | 633 | *matrix = FSMatrixFromCFXMatrix(pPageObj->AsPath()->matrix()); |
| 634 | return true; |
Lei Zhang | f3b5967 | 2022-02-22 18:48:42 +0000 | [diff] [blame] | 635 | case CPDF_PageObject::Type::kImage: |
Lei Zhang | c8601bf | 2021-06-29 23:19:27 +0000 | [diff] [blame] | 636 | *matrix = FSMatrixFromCFXMatrix(pPageObj->AsImage()->matrix()); |
| 637 | return true; |
Lei Zhang | f3b5967 | 2022-02-22 18:48:42 +0000 | [diff] [blame] | 638 | case CPDF_PageObject::Type::kShading: |
Lei Zhang | c8601bf | 2021-06-29 23:19:27 +0000 | [diff] [blame] | 639 | return false; |
Lei Zhang | f3b5967 | 2022-02-22 18:48:42 +0000 | [diff] [blame] | 640 | case CPDF_PageObject::Type::kForm: |
Lei Zhang | c8601bf | 2021-06-29 23:19:27 +0000 | [diff] [blame] | 641 | *matrix = FSMatrixFromCFXMatrix(pPageObj->AsForm()->form_matrix()); |
| 642 | return true; |
Lei Zhang | c8601bf | 2021-06-29 23:19:27 +0000 | [diff] [blame] | 643 | } |
| 644 | } |
| 645 | |
| 646 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
| 647 | FPDFPageObj_SetMatrix(FPDF_PAGEOBJECT page_object, const FS_MATRIX* matrix) { |
| 648 | CPDF_PageObject* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
| 649 | if (!pPageObj || !matrix) |
| 650 | return false; |
| 651 | |
| 652 | CFX_Matrix cmatrix = CFXMatrixFromFSMatrix(*matrix); |
| 653 | switch (pPageObj->GetType()) { |
Lei Zhang | f3b5967 | 2022-02-22 18:48:42 +0000 | [diff] [blame] | 654 | case CPDF_PageObject::Type::kText: |
Lei Zhang | cfd0817 | 2021-06-30 04:11:21 +0000 | [diff] [blame] | 655 | pPageObj->AsText()->SetTextMatrix(cmatrix); |
| 656 | break; |
Lei Zhang | f3b5967 | 2022-02-22 18:48:42 +0000 | [diff] [blame] | 657 | case CPDF_PageObject::Type::kPath: |
Lei Zhang | f36132a | 2021-06-30 04:45:57 +0000 | [diff] [blame] | 658 | pPageObj->AsPath()->SetPathMatrix(cmatrix); |
Lei Zhang | c8601bf | 2021-06-29 23:19:27 +0000 | [diff] [blame] | 659 | break; |
Lei Zhang | f3b5967 | 2022-02-22 18:48:42 +0000 | [diff] [blame] | 660 | case CPDF_PageObject::Type::kImage: |
Lei Zhang | c8601bf | 2021-06-29 23:19:27 +0000 | [diff] [blame] | 661 | pPageObj->AsImage()->SetImageMatrix(cmatrix); |
| 662 | break; |
Lei Zhang | f3b5967 | 2022-02-22 18:48:42 +0000 | [diff] [blame] | 663 | case CPDF_PageObject::Type::kShading: |
Lei Zhang | c8601bf | 2021-06-29 23:19:27 +0000 | [diff] [blame] | 664 | return false; |
Lei Zhang | f3b5967 | 2022-02-22 18:48:42 +0000 | [diff] [blame] | 665 | case CPDF_PageObject::Type::kForm: |
Lei Zhang | 2193da9 | 2021-06-30 01:03:07 +0000 | [diff] [blame] | 666 | pPageObj->AsForm()->SetFormMatrix(cmatrix); |
| 667 | break; |
Lei Zhang | c8601bf | 2021-06-29 23:19:27 +0000 | [diff] [blame] | 668 | } |
| 669 | pPageObj->SetDirty(true); |
| 670 | return true; |
| 671 | } |
| 672 | |
Dan Sinclair | 00d2ad1 | 2017-08-10 14:13:02 -0400 | [diff] [blame] | 673 | FPDF_EXPORT void FPDF_CALLCONV |
| 674 | FPDFPageObj_SetBlendMode(FPDF_PAGEOBJECT page_object, |
| 675 | FPDF_BYTESTRING blend_mode) { |
Jane Liu | 1a08402 | 2017-06-29 19:47:12 -0400 | [diff] [blame] | 676 | CPDF_PageObject* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
wileyrya | 06bbdef | 2017-05-26 15:20:23 -0500 | [diff] [blame] | 677 | if (!pPageObj) |
| 678 | return; |
| 679 | |
| 680 | pPageObj->m_GeneralState.SetBlendMode(blend_mode); |
wileyrya | e858aa4 | 2017-05-31 14:49:05 -0500 | [diff] [blame] | 681 | pPageObj->SetDirty(true); |
wileyrya | 06bbdef | 2017-05-26 15:20:23 -0500 | [diff] [blame] | 682 | } |
| 683 | |
Dan Sinclair | 00d2ad1 | 2017-08-10 14:13:02 -0400 | [diff] [blame] | 684 | FPDF_EXPORT void FPDF_CALLCONV FPDFPage_TransformAnnots(FPDF_PAGE page, |
| 685 | double a, |
| 686 | double b, |
| 687 | double c, |
| 688 | double d, |
| 689 | double e, |
| 690 | double f) { |
Tom Sepez | db0be96 | 2015-10-16 14:00:21 -0700 | [diff] [blame] | 691 | CPDF_Page* pPage = CPDFPageFromFPDFPage(page); |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 692 | if (!pPage) |
| 693 | return; |
thestig | c54bb43 | 2016-07-29 19:34:20 -0700 | [diff] [blame] | 694 | |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 695 | CPDF_AnnotList AnnotList(pPage); |
Lei Zhang | 1b700c3 | 2015-10-30 23:55:35 -0700 | [diff] [blame] | 696 | for (size_t i = 0; i < AnnotList.Count(); ++i) { |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 697 | CPDF_Annot* pAnnot = AnnotList.GetAt(i); |
Dan Sinclair | 05df075 | 2017-03-14 14:43:42 -0400 | [diff] [blame] | 698 | CFX_Matrix matrix((float)a, (float)b, (float)c, (float)d, (float)e, |
| 699 | (float)f); |
Jane Liu | 878b27d | 2017-08-22 10:50:06 -0400 | [diff] [blame] | 700 | CFX_FloatRect rect = matrix.TransformRect(pAnnot->GetRect()); |
tsepez | 8021a64 | 2016-10-17 16:13:21 -0700 | [diff] [blame] | 701 | |
Tom Sepez | b5649d9 | 2022-07-19 00:45:22 +0000 | [diff] [blame] | 702 | RetainPtr<CPDF_Dictionary> pAnnotDict = pAnnot->GetMutableAnnotDict(); |
Tom Sepez | 3d64afa | 2022-06-24 16:40:17 +0000 | [diff] [blame] | 703 | RetainPtr<CPDF_Array> pRectArray = pAnnotDict->GetMutableArrayFor("Rect"); |
Jane Liu | eda6525 | 2017-06-07 11:31:27 -0400 | [diff] [blame] | 704 | if (pRectArray) |
Lei Zhang | 59c1ac0 | 2017-06-09 11:04:41 -0700 | [diff] [blame] | 705 | pRectArray->Clear(); |
Jane Liu | eda6525 | 2017-06-07 11:31:27 -0400 | [diff] [blame] | 706 | else |
Tom Sepez | 8aad22a | 2022-09-22 18:56:16 +0000 | [diff] [blame] | 707 | pRectArray = pAnnotDict->SetNewFor<CPDF_Array>("Rect"); |
tsepez | 0e606b5 | 2016-11-18 16:22:41 -0800 | [diff] [blame] | 708 | |
Lei Zhang | 61ce22a | 2020-03-31 19:18:32 +0000 | [diff] [blame] | 709 | pRectArray->AppendNew<CPDF_Number>(rect.left); |
| 710 | pRectArray->AppendNew<CPDF_Number>(rect.bottom); |
| 711 | pRectArray->AppendNew<CPDF_Number>(rect.right); |
| 712 | pRectArray->AppendNew<CPDF_Number>(rect.top); |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 713 | |
Dan Sinclair | 85c8e7f | 2016-11-21 13:50:32 -0500 | [diff] [blame] | 714 | // TODO(unknown): Transform AP's rectangle |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 715 | } |
John Abd-El-Malek | 3f3b45c | 2014-05-23 17:28:10 -0700 | [diff] [blame] | 716 | } |
Bo Xu | 394010d | 2014-06-12 13:41:50 -0700 | [diff] [blame] | 717 | |
Dan Sinclair | 00d2ad1 | 2017-08-10 14:13:02 -0400 | [diff] [blame] | 718 | FPDF_EXPORT void FPDF_CALLCONV FPDFPage_SetRotation(FPDF_PAGE page, |
| 719 | int rotate) { |
Tom Sepez | db0be96 | 2015-10-16 14:00:21 -0700 | [diff] [blame] | 720 | CPDF_Page* pPage = CPDFPageFromFPDFPage(page); |
thestig | c54bb43 | 2016-07-29 19:34:20 -0700 | [diff] [blame] | 721 | if (!IsPageObject(pPage)) |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 722 | return; |
thestig | c54bb43 | 2016-07-29 19:34:20 -0700 | [diff] [blame] | 723 | |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 724 | rotate %= 4; |
Tom Sepez | a22da90 | 2022-06-30 18:08:32 +0000 | [diff] [blame] | 725 | pPage->GetMutableDict()->SetNewFor<CPDF_Number>(pdfium::page_object::kRotate, |
| 726 | rotate * 90); |
Lei Zhang | ae3945f | 2018-12-21 19:12:45 +0000 | [diff] [blame] | 727 | pPage->UpdateDimensions(); |
Nico Weber | 0ce77e3 | 2014-07-16 13:19:08 -0700 | [diff] [blame] | 728 | } |
wileyrya | 864e9fb | 2017-05-26 11:38:14 -0500 | [diff] [blame] | 729 | |
| 730 | FPDF_BOOL FPDFPageObj_SetFillColor(FPDF_PAGEOBJECT page_object, |
| 731 | unsigned int R, |
| 732 | unsigned int G, |
| 733 | unsigned int B, |
| 734 | unsigned int A) { |
Lei Zhang | 2237541 | 2018-10-24 17:26:50 +0000 | [diff] [blame] | 735 | CPDF_PageObject* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
| 736 | if (!pPageObj || R > 255 || G > 255 || B > 255 || A > 255) |
wileyrya | 864e9fb | 2017-05-26 11:38:14 -0500 | [diff] [blame] | 737 | return false; |
| 738 | |
Lei Zhang | 996c930 | 2018-04-13 15:44:36 +0000 | [diff] [blame] | 739 | std::vector<float> rgb = {R / 255.f, G / 255.f, B / 255.f}; |
wileyrya | 864e9fb | 2017-05-26 11:38:14 -0500 | [diff] [blame] | 740 | pPageObj->m_GeneralState.SetFillAlpha(A / 255.f); |
| 741 | pPageObj->m_ColorState.SetFillColor( |
Tom Sepez | d30786c | 2021-05-18 23:05:54 +0000 | [diff] [blame] | 742 | CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kDeviceRGB), rgb); |
wileyrya | e858aa4 | 2017-05-31 14:49:05 -0500 | [diff] [blame] | 743 | pPageObj->SetDirty(true); |
wileyrya | 864e9fb | 2017-05-26 11:38:14 -0500 | [diff] [blame] | 744 | return true; |
| 745 | } |
wileyrya | f1697fa | 2017-05-26 12:27:40 -0500 | [diff] [blame] | 746 | |
Dan Sinclair | 00d2ad1 | 2017-08-10 14:13:02 -0400 | [diff] [blame] | 747 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
Nicolas Pena | df1298a | 2018-05-08 22:22:41 +0000 | [diff] [blame] | 748 | FPDFPageObj_GetFillColor(FPDF_PAGEOBJECT page_object, |
| 749 | unsigned int* R, |
| 750 | unsigned int* G, |
| 751 | unsigned int* B, |
| 752 | unsigned int* A) { |
| 753 | auto* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
| 754 | if (!pPageObj || !R || !G || !B || !A) |
| 755 | return false; |
| 756 | |
Lei Zhang | b6aa074 | 2019-11-12 23:15:31 +0000 | [diff] [blame] | 757 | if (!pPageObj->m_ColorState.HasRef()) |
| 758 | return false; |
| 759 | |
| 760 | FX_COLORREF fill_color = pPageObj->m_ColorState.GetFillColorRef(); |
| 761 | *R = FXSYS_GetRValue(fill_color); |
| 762 | *G = FXSYS_GetGValue(fill_color); |
| 763 | *B = FXSYS_GetBValue(fill_color); |
Benjamin Beaudry | f5ad5c1 | 2019-09-13 17:37:58 +0000 | [diff] [blame] | 764 | *A = FXSYS_GetUnsignedAlpha(pPageObj->m_GeneralState.GetFillAlpha()); |
Nicolas Pena | df1298a | 2018-05-08 22:22:41 +0000 | [diff] [blame] | 765 | return true; |
| 766 | } |
| 767 | |
| 768 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
Andrew Weintraub | fe111d9 | 2019-06-24 17:19:20 +0000 | [diff] [blame] | 769 | FPDFPageObj_GetBounds(FPDF_PAGEOBJECT page_object, |
Dan Sinclair | 00d2ad1 | 2017-08-10 14:13:02 -0400 | [diff] [blame] | 770 | float* left, |
| 771 | float* bottom, |
| 772 | float* right, |
| 773 | float* top) { |
Andrew Weintraub | fe111d9 | 2019-06-24 17:19:20 +0000 | [diff] [blame] | 774 | CPDF_PageObject* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
Lei Zhang | 2237541 | 2018-10-24 17:26:50 +0000 | [diff] [blame] | 775 | if (!pPageObj) |
wileyrya | f1697fa | 2017-05-26 12:27:40 -0500 | [diff] [blame] | 776 | return false; |
| 777 | |
Lei Zhang | d982649 | 2018-10-06 00:32:16 +0000 | [diff] [blame] | 778 | const CFX_FloatRect& bbox = pPageObj->GetRect(); |
wileyrya | f1697fa | 2017-05-26 12:27:40 -0500 | [diff] [blame] | 779 | *left = bbox.left; |
| 780 | *bottom = bbox.bottom; |
| 781 | *right = bbox.right; |
| 782 | *top = bbox.top; |
| 783 | return true; |
| 784 | } |
Nicolas Pena | df1298a | 2018-05-08 22:22:41 +0000 | [diff] [blame] | 785 | |
| 786 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
Lei Zhang | ce72527 | 2022-06-21 21:32:16 +0000 | [diff] [blame] | 787 | FPDFPageObj_GetRotatedBounds(FPDF_PAGEOBJECT page_object, |
| 788 | FS_QUADPOINTSF* quad_points) { |
| 789 | CPDF_PageObject* cpage_object = CPDFPageObjectFromFPDFPageObject(page_object); |
| 790 | if (!cpage_object || !quad_points) |
| 791 | return false; |
| 792 | |
| 793 | CFX_Matrix matrix; |
| 794 | switch (cpage_object->GetType()) { |
| 795 | case CPDF_PageObject::Type::kText: |
| 796 | matrix = cpage_object->AsText()->GetTextMatrix(); |
| 797 | break; |
| 798 | case CPDF_PageObject::Type::kImage: |
| 799 | matrix = cpage_object->AsImage()->matrix(); |
| 800 | break; |
| 801 | default: |
| 802 | // TODO(crbug.com/pdfium/1840): Support more object types. |
| 803 | return false; |
| 804 | } |
| 805 | |
| 806 | const CFX_FloatRect& bbox = cpage_object->GetOriginalRect(); |
| 807 | const CFX_PointF bottom_left = matrix.Transform({bbox.left, bbox.bottom}); |
| 808 | const CFX_PointF bottom_right = matrix.Transform({bbox.right, bbox.bottom}); |
| 809 | const CFX_PointF top_right = matrix.Transform({bbox.right, bbox.top}); |
| 810 | const CFX_PointF top_left = matrix.Transform({bbox.left, bbox.top}); |
| 811 | |
| 812 | // See PDF 32000-1:2008, figure 64 for the QuadPoints ordering. |
| 813 | quad_points->x1 = bottom_left.x; |
| 814 | quad_points->y1 = bottom_left.y; |
| 815 | quad_points->x2 = bottom_right.x; |
| 816 | quad_points->y2 = bottom_right.y; |
| 817 | quad_points->x3 = top_right.x; |
| 818 | quad_points->y3 = top_right.y; |
| 819 | quad_points->x4 = top_left.x; |
| 820 | quad_points->y4 = top_left.y; |
| 821 | return true; |
| 822 | } |
| 823 | |
| 824 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
Nicolas Pena | df1298a | 2018-05-08 22:22:41 +0000 | [diff] [blame] | 825 | FPDFPageObj_SetStrokeColor(FPDF_PAGEOBJECT page_object, |
| 826 | unsigned int R, |
| 827 | unsigned int G, |
| 828 | unsigned int B, |
| 829 | unsigned int A) { |
| 830 | auto* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
| 831 | if (!pPageObj || R > 255 || G > 255 || B > 255 || A > 255) |
| 832 | return false; |
| 833 | |
| 834 | std::vector<float> rgb = {R / 255.f, G / 255.f, B / 255.f}; |
| 835 | pPageObj->m_GeneralState.SetStrokeAlpha(A / 255.f); |
| 836 | pPageObj->m_ColorState.SetStrokeColor( |
Tom Sepez | d30786c | 2021-05-18 23:05:54 +0000 | [diff] [blame] | 837 | CPDF_ColorSpace::GetStockCS(CPDF_ColorSpace::Family::kDeviceRGB), rgb); |
Nicolas Pena | df1298a | 2018-05-08 22:22:41 +0000 | [diff] [blame] | 838 | pPageObj->SetDirty(true); |
| 839 | return true; |
| 840 | } |
| 841 | |
| 842 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
| 843 | FPDFPageObj_GetStrokeColor(FPDF_PAGEOBJECT page_object, |
| 844 | unsigned int* R, |
| 845 | unsigned int* G, |
| 846 | unsigned int* B, |
| 847 | unsigned int* A) { |
| 848 | auto* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
| 849 | if (!pPageObj || !R || !G || !B || !A) |
| 850 | return false; |
| 851 | |
Lei Zhang | b6aa074 | 2019-11-12 23:15:31 +0000 | [diff] [blame] | 852 | if (!pPageObj->m_ColorState.HasRef()) |
| 853 | return false; |
| 854 | |
| 855 | FX_COLORREF stroke_color = pPageObj->m_ColorState.GetStrokeColorRef(); |
| 856 | *R = FXSYS_GetRValue(stroke_color); |
| 857 | *G = FXSYS_GetGValue(stroke_color); |
| 858 | *B = FXSYS_GetBValue(stroke_color); |
Benjamin Beaudry | f5ad5c1 | 2019-09-13 17:37:58 +0000 | [diff] [blame] | 859 | *A = FXSYS_GetUnsignedAlpha(pPageObj->m_GeneralState.GetStrokeAlpha()); |
Nicolas Pena | df1298a | 2018-05-08 22:22:41 +0000 | [diff] [blame] | 860 | return true; |
| 861 | } |
| 862 | |
| 863 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
| 864 | FPDFPageObj_SetStrokeWidth(FPDF_PAGEOBJECT page_object, float width) { |
| 865 | auto* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
| 866 | if (!pPageObj || width < 0.0f) |
| 867 | return false; |
| 868 | |
| 869 | pPageObj->m_GraphState.SetLineWidth(width); |
| 870 | pPageObj->SetDirty(true); |
| 871 | return true; |
| 872 | } |
| 873 | |
| 874 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
Miklos Vajna | 366df7f | 2018-05-22 14:27:29 +0000 | [diff] [blame] | 875 | FPDFPageObj_GetStrokeWidth(FPDF_PAGEOBJECT page_object, float* width) { |
| 876 | auto* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
| 877 | if (!pPageObj || !width) |
| 878 | return false; |
| 879 | |
| 880 | *width = pPageObj->m_GraphState.GetLineWidth(); |
| 881 | return true; |
| 882 | } |
| 883 | |
Lei Zhang | 5736083 | 2018-10-24 17:27:39 +0000 | [diff] [blame] | 884 | FPDF_EXPORT int FPDF_CALLCONV |
| 885 | FPDFPageObj_GetLineJoin(FPDF_PAGEOBJECT page_object) { |
| 886 | auto* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
Tom Sepez | a7a7c92 | 2021-08-26 20:36:04 +0000 | [diff] [blame] | 887 | return pPageObj ? static_cast<int>(pPageObj->m_GraphState.GetLineJoin()) : -1; |
Lei Zhang | 5736083 | 2018-10-24 17:27:39 +0000 | [diff] [blame] | 888 | } |
| 889 | |
Miklos Vajna | 366df7f | 2018-05-22 14:27:29 +0000 | [diff] [blame] | 890 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
Nicolas Pena | df1298a | 2018-05-08 22:22:41 +0000 | [diff] [blame] | 891 | FPDFPageObj_SetLineJoin(FPDF_PAGEOBJECT page_object, int line_join) { |
Nicolas Pena | df1298a | 2018-05-08 22:22:41 +0000 | [diff] [blame] | 892 | auto* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
Lei Zhang | 2237541 | 2018-10-24 17:26:50 +0000 | [diff] [blame] | 893 | if (!pPageObj) |
| 894 | return false; |
| 895 | |
Tom Sepez | a7a7c92 | 2021-08-26 20:36:04 +0000 | [diff] [blame] | 896 | if (line_join < FPDF_LINEJOIN_MITER || line_join > FPDF_LINEJOIN_BEVEL) |
Lei Zhang | 2237541 | 2018-10-24 17:26:50 +0000 | [diff] [blame] | 897 | return false; |
| 898 | |
| 899 | pPageObj->m_GraphState.SetLineJoin( |
| 900 | static_cast<CFX_GraphStateData::LineJoin>(line_join)); |
Nicolas Pena | df1298a | 2018-05-08 22:22:41 +0000 | [diff] [blame] | 901 | pPageObj->SetDirty(true); |
| 902 | return true; |
| 903 | } |
| 904 | |
Lei Zhang | cd11df6 | 2018-10-24 17:30:11 +0000 | [diff] [blame] | 905 | FPDF_EXPORT int FPDF_CALLCONV |
| 906 | FPDFPageObj_GetLineCap(FPDF_PAGEOBJECT page_object) { |
| 907 | auto* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
Tom Sepez | a7a7c92 | 2021-08-26 20:36:04 +0000 | [diff] [blame] | 908 | return pPageObj ? static_cast<int>(pPageObj->m_GraphState.GetLineCap()) : -1; |
Lei Zhang | cd11df6 | 2018-10-24 17:30:11 +0000 | [diff] [blame] | 909 | } |
| 910 | |
Nicolas Pena | df1298a | 2018-05-08 22:22:41 +0000 | [diff] [blame] | 911 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
| 912 | FPDFPageObj_SetLineCap(FPDF_PAGEOBJECT page_object, int line_cap) { |
Nicolas Pena | df1298a | 2018-05-08 22:22:41 +0000 | [diff] [blame] | 913 | auto* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
Lei Zhang | 2237541 | 2018-10-24 17:26:50 +0000 | [diff] [blame] | 914 | if (!pPageObj) |
| 915 | return false; |
| 916 | |
Tom Sepez | a7a7c92 | 2021-08-26 20:36:04 +0000 | [diff] [blame] | 917 | if (line_cap < FPDF_LINECAP_BUTT || |
| 918 | line_cap > FPDF_LINECAP_PROJECTING_SQUARE) { |
Lei Zhang | 2237541 | 2018-10-24 17:26:50 +0000 | [diff] [blame] | 919 | return false; |
Tom Sepez | a7a7c92 | 2021-08-26 20:36:04 +0000 | [diff] [blame] | 920 | } |
Lei Zhang | 2237541 | 2018-10-24 17:26:50 +0000 | [diff] [blame] | 921 | pPageObj->m_GraphState.SetLineCap( |
| 922 | static_cast<CFX_GraphStateData::LineCap>(line_cap)); |
Nicolas Pena | df1298a | 2018-05-08 22:22:41 +0000 | [diff] [blame] | 923 | pPageObj->SetDirty(true); |
| 924 | return true; |
| 925 | } |
Miklos Vajna | b66077d | 2018-07-11 13:25:02 +0000 | [diff] [blame] | 926 | |
Robert Collyer | 5c4111b | 2021-06-24 23:18:28 +0000 | [diff] [blame] | 927 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
| 928 | FPDFPageObj_GetDashPhase(FPDF_PAGEOBJECT page_object, float* phase) { |
| 929 | auto* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
| 930 | if (!pPageObj || !phase) |
| 931 | return false; |
| 932 | |
| 933 | *phase = pPageObj->m_GraphState.GetLineDashPhase(); |
| 934 | return true; |
| 935 | } |
| 936 | |
| 937 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
| 938 | FPDFPageObj_SetDashPhase(FPDF_PAGEOBJECT page_object, float phase) { |
| 939 | auto* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
| 940 | if (!pPageObj) |
| 941 | return false; |
| 942 | |
| 943 | pPageObj->m_GraphState.SetLineDashPhase(phase); |
| 944 | pPageObj->SetDirty(true); |
| 945 | return true; |
| 946 | } |
| 947 | |
| 948 | FPDF_EXPORT int FPDF_CALLCONV |
| 949 | FPDFPageObj_GetDashCount(FPDF_PAGEOBJECT page_object) { |
| 950 | auto* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
Tom Sepez | 8ef63b9 | 2022-03-08 19:53:34 +0000 | [diff] [blame] | 951 | return pPageObj ? pdfium::base::checked_cast<int>( |
| 952 | pPageObj->m_GraphState.GetLineDashSize()) |
| 953 | : -1; |
Robert Collyer | 5c4111b | 2021-06-24 23:18:28 +0000 | [diff] [blame] | 954 | } |
| 955 | |
| 956 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
| 957 | FPDFPageObj_GetDashArray(FPDF_PAGEOBJECT page_object, |
| 958 | float* dash_array, |
| 959 | size_t dash_count) { |
| 960 | auto* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
| 961 | if (!pPageObj || !dash_array) |
| 962 | return false; |
| 963 | |
| 964 | auto dash_vector = pPageObj->m_GraphState.GetLineDashArray(); |
| 965 | if (dash_vector.size() > dash_count) |
| 966 | return false; |
| 967 | |
| 968 | memcpy(dash_array, dash_vector.data(), dash_vector.size() * sizeof(float)); |
| 969 | return true; |
| 970 | } |
| 971 | |
| 972 | FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV |
| 973 | FPDFPageObj_SetDashArray(FPDF_PAGEOBJECT page_object, |
| 974 | const float* dash_array, |
| 975 | size_t dash_count, |
| 976 | float phase) { |
| 977 | if (dash_count > 0 && !dash_array) |
| 978 | return false; |
| 979 | |
| 980 | auto* pPageObj = CPDFPageObjectFromFPDFPageObject(page_object); |
| 981 | if (!pPageObj) |
| 982 | return false; |
| 983 | |
| 984 | std::vector<float> dashes; |
| 985 | if (dash_count > 0) { |
| 986 | dashes.reserve(dash_count); |
| 987 | dashes.assign(dash_array, dash_array + dash_count); |
| 988 | } |
| 989 | |
| 990 | pPageObj->m_GraphState.SetLineDash(dashes, phase, 1.0f); |
| 991 | |
| 992 | pPageObj->SetDirty(true); |
| 993 | return true; |
| 994 | } |
| 995 | |
Miklos Vajna | b66077d | 2018-07-11 13:25:02 +0000 | [diff] [blame] | 996 | FPDF_EXPORT int FPDF_CALLCONV |
Andrew Weintraub | fe111d9 | 2019-06-24 17:19:20 +0000 | [diff] [blame] | 997 | FPDFFormObj_CountObjects(FPDF_PAGEOBJECT form_object) { |
| 998 | const auto* pObjectList = CPDFPageObjHolderFromFPDFFormObject(form_object); |
Tom Sepez | 8ef63b9 | 2022-03-08 19:53:34 +0000 | [diff] [blame] | 999 | return pObjectList ? pdfium::base::checked_cast<int>( |
| 1000 | pObjectList->GetPageObjectCount()) |
| 1001 | : -1; |
Miklos Vajna | b66077d | 2018-07-11 13:25:02 +0000 | [diff] [blame] | 1002 | } |
Miklos Vajna | 1d273f1 | 2018-07-16 19:20:36 +0000 | [diff] [blame] | 1003 | |
| 1004 | FPDF_EXPORT FPDF_PAGEOBJECT FPDF_CALLCONV |
| 1005 | FPDFFormObj_GetObject(FPDF_PAGEOBJECT form_object, unsigned long index) { |
Tom Sepez | a733d82 | 2019-05-06 19:43:33 +0000 | [diff] [blame] | 1006 | const auto* pObjectList = CPDFPageObjHolderFromFPDFFormObject(form_object); |
Miklos Vajna | 1d273f1 | 2018-07-16 19:20:36 +0000 | [diff] [blame] | 1007 | if (!pObjectList) |
| 1008 | return nullptr; |
| 1009 | |
| 1010 | return FPDFPageObjectFromCPDFPageObject( |
| 1011 | pObjectList->GetPageObjectByIndex(index)); |
| 1012 | } |