kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 1 | // Copyright 2017 The PDFium Authors |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com |
| 6 | |
| 7 | #include "fxjs/xfa/cjx_layoutpseudomodel.h" |
| 8 | |
| 9 | #include <set> |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 10 | #include <utility> |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 11 | |
| 12 | #include "core/fxcrt/fx_coordinates.h" |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 13 | #include "fxjs/fxv8.h" |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 14 | #include "fxjs/js_resources.h" |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 15 | #include "fxjs/xfa/cfxjse_class.h" |
| 16 | #include "fxjs/xfa/cfxjse_engine.h" |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 17 | #include "third_party/base/containers/contains.h" |
| 18 | #include "v8/include/cppgc/allocation.h" |
| 19 | #include "v8/include/v8-object.h" |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 20 | #include "xfa/fxfa/cxfa_ffnotify.h" |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 21 | #include "xfa/fxfa/layout/cxfa_contentlayoutitem.h" |
| 22 | #include "xfa/fxfa/layout/cxfa_layoutitem.h" |
| 23 | #include "xfa/fxfa/layout/cxfa_layoutprocessor.h" |
| 24 | #include "xfa/fxfa/layout/cxfa_traversestrategy_layoutitem.h" |
| 25 | #include "xfa/fxfa/layout/cxfa_viewlayoutitem.h" |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 26 | #include "xfa/fxfa/parser/cscript_layoutpseudomodel.h" |
| 27 | #include "xfa/fxfa/parser/cxfa_arraynodelist.h" |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 28 | #include "xfa/fxfa/parser/cxfa_document.h" |
| 29 | #include "xfa/fxfa/parser/cxfa_form.h" |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 30 | #include "xfa/fxfa/parser/cxfa_measurement.h" |
| 31 | #include "xfa/fxfa/parser/cxfa_node.h" |
| 32 | #include "xfa/fxfa/parser/cxfa_nodeiteratortemplate.h" |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 33 | |
| 34 | const CJX_MethodSpec CJX_LayoutPseudoModel::MethodSpecs[] = { |
| 35 | {"absPage", absPage_static}, |
| 36 | {"absPageCount", absPageCount_static}, |
| 37 | {"absPageCountInBatch", absPageCountInBatch_static}, |
| 38 | {"absPageInBatch", absPageInBatch_static}, |
| 39 | {"absPageSpan", absPageSpan_static}, |
| 40 | {"h", h_static}, |
| 41 | {"page", page_static}, |
| 42 | {"pageContent", pageContent_static}, |
| 43 | {"pageCount", pageCount_static}, |
| 44 | {"pageSpan", pageSpan_static}, |
| 45 | {"relayout", relayout_static}, |
| 46 | {"relayoutPageArea", relayoutPageArea_static}, |
| 47 | {"sheet", sheet_static}, |
| 48 | {"sheetCount", sheetCount_static}, |
| 49 | {"sheetCountInBatch", sheetCountInBatch_static}, |
| 50 | {"sheetInBatch", sheetInBatch_static}, |
| 51 | {"w", w_static}, |
| 52 | {"x", x_static}, |
| 53 | {"y", y_static}}; |
| 54 | |
| 55 | CJX_LayoutPseudoModel::CJX_LayoutPseudoModel(CScript_LayoutPseudoModel* model) |
| 56 | : CJX_Object(model) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 57 | DefineMethods(MethodSpecs); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 58 | } |
| 59 | |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 60 | CJX_LayoutPseudoModel::~CJX_LayoutPseudoModel() = default; |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 61 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 62 | bool CJX_LayoutPseudoModel::DynamicTypeIs(TypeTag eType) const { |
| 63 | return eType == static_type__ || ParentType__::DynamicTypeIs(eType); |
| 64 | } |
| 65 | |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 66 | void CJX_LayoutPseudoModel::ready(v8::Isolate* pIsolate, |
| 67 | v8::Local<v8::Value>* pValue, |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 68 | bool bSetting, |
| 69 | XFA_Attribute eAttribute) { |
| 70 | CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); |
| 71 | if (!pNotify) |
| 72 | return; |
| 73 | if (bSetting) { |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 74 | ThrowException(pIsolate, |
| 75 | WideString::FromASCII("Unable to set ready value.")); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 76 | return; |
| 77 | } |
| 78 | |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 79 | CXFA_FFDocView::LayoutStatus iStatus = pNotify->GetLayoutStatus(); |
| 80 | const bool bReady = iStatus != CXFA_FFDocView::LayoutStatus::kNone && |
| 81 | iStatus != CXFA_FFDocView::LayoutStatus::kStart; |
| 82 | *pValue = fxv8::NewBooleanHelper(pIsolate, bReady); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 83 | } |
| 84 | |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 85 | CJS_Result CJX_LayoutPseudoModel::DoHWXYInternal( |
| 86 | CFXJSE_Engine* runtime, |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 87 | const std::vector<v8::Local<v8::Value>>& params, |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 88 | HWXY layoutModel) { |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 89 | if (params.empty() || params.size() > 3) |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 90 | return CJS_Result::Failure(JSMessage::kParamError); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 91 | |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 92 | CXFA_Node* pNode = ToNode(runtime->ToXFAObject(params[0])); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 93 | if (!pNode) |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 94 | return CJS_Result::Success(); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 95 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 96 | WideString unit = WideString::FromASCII("pt"); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 97 | if (params.size() >= 2) { |
| 98 | WideString tmp_unit = runtime->ToWideString(params[1]); |
| 99 | if (!tmp_unit.IsEmpty()) |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 100 | unit = std::move(tmp_unit); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 101 | } |
| 102 | int32_t iIndex = params.size() >= 3 ? runtime->ToInt32(params[2]) : 0; |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 103 | auto* pDocLayout = CXFA_LayoutProcessor::FromDocument(GetDocument()); |
| 104 | CXFA_ContentLayoutItem* pLayoutItem = |
| 105 | ToContentLayoutItem(pDocLayout->GetLayoutItem(pNode)); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 106 | if (!pLayoutItem) |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 107 | return CJS_Result::Success(); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 108 | |
| 109 | while (iIndex > 0 && pLayoutItem) { |
| 110 | pLayoutItem = pLayoutItem->GetNext(); |
| 111 | --iIndex; |
| 112 | } |
| 113 | |
| 114 | if (!pLayoutItem) |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 115 | return CJS_Result::Success(runtime->NewNumber(0.0)); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 116 | |
| 117 | CXFA_Measurement measure; |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 118 | CFX_RectF rtRect = pLayoutItem->GetRelativeRect(); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 119 | switch (layoutModel) { |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 120 | case HWXY::kH: |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 121 | measure.Set(rtRect.height, XFA_Unit::Pt); |
| 122 | break; |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 123 | case HWXY::kW: |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 124 | measure.Set(rtRect.width, XFA_Unit::Pt); |
| 125 | break; |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 126 | case HWXY::kX: |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 127 | measure.Set(rtRect.left, XFA_Unit::Pt); |
| 128 | break; |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 129 | case HWXY::kY: |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 130 | measure.Set(rtRect.top, XFA_Unit::Pt); |
| 131 | break; |
| 132 | } |
| 133 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 134 | XFA_Unit eUnit = CXFA_Measurement::GetUnitFromString(unit.AsStringView()); |
| 135 | if (eUnit == XFA_Unit::Unknown) |
| 136 | return CJS_Result::Failure(JSMessage::kValueError); |
| 137 | |
| 138 | float fValue = measure.ToUnit(eUnit); |
| 139 | return CJS_Result::Success( |
| 140 | runtime->NewNumber(FXSYS_roundf(fValue * 1000) / 1000.0f)); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 141 | } |
| 142 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 143 | CJS_Result CJX_LayoutPseudoModel::h( |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 144 | CFXJSE_Engine* runtime, |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 145 | const std::vector<v8::Local<v8::Value>>& params) { |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 146 | return DoHWXYInternal(runtime, params, HWXY::kH); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 147 | } |
| 148 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 149 | CJS_Result CJX_LayoutPseudoModel::w( |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 150 | CFXJSE_Engine* runtime, |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 151 | const std::vector<v8::Local<v8::Value>>& params) { |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 152 | return DoHWXYInternal(runtime, params, HWXY::kW); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 153 | } |
| 154 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 155 | CJS_Result CJX_LayoutPseudoModel::x( |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 156 | CFXJSE_Engine* runtime, |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 157 | const std::vector<v8::Local<v8::Value>>& params) { |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 158 | return DoHWXYInternal(runtime, params, HWXY::kX); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 159 | } |
| 160 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 161 | CJS_Result CJX_LayoutPseudoModel::y( |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 162 | CFXJSE_Engine* runtime, |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 163 | const std::vector<v8::Local<v8::Value>>& params) { |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 164 | return DoHWXYInternal(runtime, params, HWXY::kY); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 165 | } |
| 166 | |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 167 | CJS_Result CJX_LayoutPseudoModel::AllPageCount(CFXJSE_Engine* runtime) { |
| 168 | auto* pDocLayout = CXFA_LayoutProcessor::FromDocument(GetDocument()); |
| 169 | return CJS_Result::Success(runtime->NewNumber(pDocLayout->CountPages())); |
| 170 | } |
| 171 | |
| 172 | CJS_Result CJX_LayoutPseudoModel::NumberedPageCount(CFXJSE_Engine* runtime) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 173 | auto* pDocLayout = CXFA_LayoutProcessor::FromDocument(GetDocument()); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 174 | int32_t iPageCount = 0; |
| 175 | int32_t iPageNum = pDocLayout->CountPages(); |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 176 | for (int32_t i = 0; i < iPageNum; i++) { |
| 177 | CXFA_ViewLayoutItem* pLayoutPage = pDocLayout->GetPage(i); |
| 178 | if (!pLayoutPage) |
| 179 | continue; |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 180 | |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 181 | CXFA_Node* pMasterPage = pLayoutPage->GetMasterPage(); |
| 182 | if (pMasterPage->JSObject()->GetInteger(XFA_Attribute::Numbered)) |
| 183 | iPageCount++; |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 184 | } |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 185 | return CJS_Result::Success(runtime->NewNumber(iPageCount)); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 186 | } |
| 187 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 188 | CJS_Result CJX_LayoutPseudoModel::pageCount( |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 189 | CFXJSE_Engine* runtime, |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 190 | const std::vector<v8::Local<v8::Value>>& params) { |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 191 | return NumberedPageCount(runtime); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 192 | } |
| 193 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 194 | CJS_Result CJX_LayoutPseudoModel::pageSpan( |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 195 | CFXJSE_Engine* runtime, |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 196 | const std::vector<v8::Local<v8::Value>>& params) { |
| 197 | if (params.size() != 1) |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 198 | return CJS_Result::Failure(JSMessage::kParamError); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 199 | |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 200 | CXFA_Node* pNode = ToNode(runtime->ToXFAObject(params[0])); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 201 | if (!pNode) |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 202 | return CJS_Result::Success(); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 203 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 204 | auto* pDocLayout = CXFA_LayoutProcessor::FromDocument(GetDocument()); |
| 205 | CXFA_ContentLayoutItem* pLayoutItem = |
| 206 | ToContentLayoutItem(pDocLayout->GetLayoutItem(pNode)); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 207 | if (!pLayoutItem) |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 208 | return CJS_Result::Success(runtime->NewNumber(-1)); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 209 | |
| 210 | int32_t iLast = pLayoutItem->GetLast()->GetPage()->GetPageIndex(); |
| 211 | int32_t iFirst = pLayoutItem->GetFirst()->GetPage()->GetPageIndex(); |
| 212 | int32_t iPageSpan = iLast - iFirst + 1; |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 213 | return CJS_Result::Success(runtime->NewNumber(iPageSpan)); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 214 | } |
| 215 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 216 | CJS_Result CJX_LayoutPseudoModel::page( |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 217 | CFXJSE_Engine* runtime, |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 218 | const std::vector<v8::Local<v8::Value>>& params) { |
| 219 | return PageInternals(runtime, params, false); |
| 220 | } |
| 221 | |
| 222 | std::vector<CXFA_Node*> CJX_LayoutPseudoModel::GetObjArray( |
| 223 | CXFA_LayoutProcessor* pDocLayout, |
| 224 | int32_t iPageNo, |
| 225 | const WideString& wsType, |
| 226 | bool bOnPageArea) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 227 | CXFA_ViewLayoutItem* pLayoutPage = pDocLayout->GetPage(iPageNo); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 228 | if (!pLayoutPage) |
| 229 | return std::vector<CXFA_Node*>(); |
| 230 | |
| 231 | std::vector<CXFA_Node*> retArray; |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 232 | if (wsType.EqualsASCII("pageArea")) { |
| 233 | if (pLayoutPage->GetFormNode()) |
| 234 | retArray.push_back(pLayoutPage->GetFormNode()); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 235 | return retArray; |
| 236 | } |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 237 | if (wsType.EqualsASCII("contentArea")) { |
| 238 | for (CXFA_LayoutItem* pItem = pLayoutPage->GetFirstChild(); pItem; |
| 239 | pItem = pItem->GetNextSibling()) { |
| 240 | if (pItem->GetFormNode()->GetElementType() == XFA_Element::ContentArea) |
| 241 | retArray.push_back(pItem->GetFormNode()); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 242 | } |
| 243 | return retArray; |
| 244 | } |
| 245 | std::set<CXFA_Node*> formItems; |
| 246 | if (wsType.IsEmpty()) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 247 | if (pLayoutPage->GetFormNode()) |
| 248 | retArray.push_back(pLayoutPage->GetFormNode()); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 249 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 250 | for (CXFA_LayoutItem* pItem = pLayoutPage->GetFirstChild(); pItem; |
| 251 | pItem = pItem->GetNextSibling()) { |
| 252 | if (pItem->GetFormNode()->GetElementType() == XFA_Element::ContentArea) { |
| 253 | retArray.push_back(pItem->GetFormNode()); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 254 | if (!bOnPageArea) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 255 | CXFA_LayoutItemIterator iterator(pItem->GetFirstChild()); |
| 256 | for (CXFA_LayoutItem* pChild = iterator.GetCurrent(); pChild; |
| 257 | pChild = iterator.MoveToNext()) { |
| 258 | CXFA_ContentLayoutItem* pItemChild = pChild->AsContentLayoutItem(); |
| 259 | if (!pItemChild) |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 260 | continue; |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 261 | |
| 262 | XFA_Element eType = pItemChild->GetFormNode()->GetElementType(); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 263 | if (eType != XFA_Element::Field && eType != XFA_Element::Draw && |
| 264 | eType != XFA_Element::Subform && eType != XFA_Element::Area) { |
| 265 | continue; |
| 266 | } |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 267 | if (pdfium::Contains(formItems, pItemChild->GetFormNode())) |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 268 | continue; |
| 269 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 270 | formItems.insert(pItemChild->GetFormNode()); |
| 271 | retArray.push_back(pItemChild->GetFormNode()); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 272 | } |
| 273 | } |
| 274 | } else { |
| 275 | if (bOnPageArea) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 276 | CXFA_LayoutItemIterator iterator(pItem); |
| 277 | for (CXFA_LayoutItem* pChild = iterator.GetCurrent(); pChild; |
| 278 | pChild = iterator.MoveToNext()) { |
| 279 | CXFA_ContentLayoutItem* pItemChild = pChild->AsContentLayoutItem(); |
| 280 | if (!pItemChild) |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 281 | continue; |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 282 | |
| 283 | XFA_Element eType = pItemChild->GetFormNode()->GetElementType(); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 284 | if (eType != XFA_Element::Field && eType != XFA_Element::Draw && |
| 285 | eType != XFA_Element::Subform && eType != XFA_Element::Area) { |
| 286 | continue; |
| 287 | } |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 288 | if (pdfium::Contains(formItems, pItemChild->GetFormNode())) |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 289 | continue; |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 290 | |
| 291 | formItems.insert(pItemChild->GetFormNode()); |
| 292 | retArray.push_back(pItemChild->GetFormNode()); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 293 | } |
| 294 | } |
| 295 | } |
| 296 | } |
| 297 | return retArray; |
| 298 | } |
| 299 | |
| 300 | XFA_Element eType = XFA_Element::Unknown; |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 301 | if (wsType.EqualsASCII("field")) |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 302 | eType = XFA_Element::Field; |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 303 | else if (wsType.EqualsASCII("draw")) |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 304 | eType = XFA_Element::Draw; |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 305 | else if (wsType.EqualsASCII("subform")) |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 306 | eType = XFA_Element::Subform; |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 307 | else if (wsType.EqualsASCII("area")) |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 308 | eType = XFA_Element::Area; |
| 309 | |
| 310 | if (eType != XFA_Element::Unknown) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 311 | for (CXFA_LayoutItem* pItem = pLayoutPage->GetFirstChild(); pItem; |
| 312 | pItem = pItem->GetNextSibling()) { |
| 313 | if (pItem->GetFormNode()->GetElementType() == XFA_Element::ContentArea) { |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 314 | if (!bOnPageArea) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 315 | CXFA_LayoutItemIterator iterator(pItem->GetFirstChild()); |
| 316 | for (CXFA_LayoutItem* pChild = iterator.GetCurrent(); pChild; |
| 317 | pChild = iterator.MoveToNext()) { |
| 318 | CXFA_ContentLayoutItem* pItemChild = pChild->AsContentLayoutItem(); |
| 319 | if (!pItemChild) |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 320 | continue; |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 321 | if (pItemChild->GetFormNode()->GetElementType() != eType) |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 322 | continue; |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 323 | if (pdfium::Contains(formItems, pItemChild->GetFormNode())) |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 324 | continue; |
| 325 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 326 | formItems.insert(pItemChild->GetFormNode()); |
| 327 | retArray.push_back(pItemChild->GetFormNode()); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 328 | } |
| 329 | } |
| 330 | } else { |
| 331 | if (bOnPageArea) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 332 | CXFA_LayoutItemIterator iterator(pItem); |
| 333 | for (CXFA_LayoutItem* pChild = iterator.GetCurrent(); pChild; |
| 334 | pChild = iterator.MoveToNext()) { |
| 335 | CXFA_ContentLayoutItem* pItemChild = pChild->AsContentLayoutItem(); |
| 336 | if (!pItemChild) |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 337 | continue; |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 338 | if (pItemChild->GetFormNode()->GetElementType() != eType) |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 339 | continue; |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 340 | if (pdfium::Contains(formItems, pItemChild->GetFormNode())) |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 341 | continue; |
| 342 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 343 | formItems.insert(pItemChild->GetFormNode()); |
| 344 | retArray.push_back(pItemChild->GetFormNode()); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 345 | } |
| 346 | } |
| 347 | } |
| 348 | } |
| 349 | } |
| 350 | return retArray; |
| 351 | } |
| 352 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 353 | CJS_Result CJX_LayoutPseudoModel::pageContent( |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 354 | CFXJSE_Engine* runtime, |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 355 | const std::vector<v8::Local<v8::Value>>& params) { |
| 356 | if (params.empty() || params.size() > 3) |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 357 | return CJS_Result::Failure(JSMessage::kParamError); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 358 | |
| 359 | int32_t iIndex = 0; |
| 360 | if (params.size() >= 1) |
| 361 | iIndex = runtime->ToInt32(params[0]); |
| 362 | |
| 363 | WideString wsType; |
| 364 | if (params.size() >= 2) |
| 365 | wsType = runtime->ToWideString(params[1]); |
| 366 | |
| 367 | bool bOnPageArea = false; |
| 368 | if (params.size() >= 3) |
| 369 | bOnPageArea = runtime->ToBoolean(params[2]); |
| 370 | |
| 371 | CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); |
| 372 | if (!pNotify) |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 373 | return CJS_Result::Success(); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 374 | |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 375 | CXFA_Document* pDoc = GetDocument(); |
| 376 | auto* pDocLayout = CXFA_LayoutProcessor::FromDocument(pDoc); |
| 377 | auto* pArrayNodeList = cppgc::MakeGarbageCollected<CXFA_ArrayNodeList>( |
| 378 | pDoc->GetHeap()->GetAllocationHandle(), pDoc); |
| 379 | pDoc->GetNodeOwner()->PersistList(pArrayNodeList); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 380 | pArrayNodeList->SetArrayNodeList( |
| 381 | GetObjArray(pDocLayout, iIndex, wsType, bOnPageArea)); |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 382 | return CJS_Result::Success(runtime->NewNormalXFAObject(pArrayNodeList)); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 383 | } |
| 384 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 385 | CJS_Result CJX_LayoutPseudoModel::absPageCount( |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 386 | CFXJSE_Engine* runtime, |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 387 | const std::vector<v8::Local<v8::Value>>& params) { |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 388 | return AllPageCount(runtime); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 389 | } |
| 390 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 391 | CJS_Result CJX_LayoutPseudoModel::absPageCountInBatch( |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 392 | CFXJSE_Engine* runtime, |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 393 | const std::vector<v8::Local<v8::Value>>& params) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 394 | return CJS_Result::Success(runtime->NewNumber(0)); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 395 | } |
| 396 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 397 | CJS_Result CJX_LayoutPseudoModel::sheetCountInBatch( |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 398 | CFXJSE_Engine* runtime, |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 399 | const std::vector<v8::Local<v8::Value>>& params) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 400 | return CJS_Result::Success(runtime->NewNumber(0)); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 401 | } |
| 402 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 403 | CJS_Result CJX_LayoutPseudoModel::relayout( |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 404 | CFXJSE_Engine* runtime, |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 405 | const std::vector<v8::Local<v8::Value>>& params) { |
| 406 | CXFA_Node* pRootNode = GetDocument()->GetRoot(); |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 407 | auto* pLayoutProcessor = GetDocument()->GetLayoutProcessor(); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 408 | CXFA_Form* pFormRoot = |
| 409 | pRootNode->GetFirstChildByClass<CXFA_Form>(XFA_Element::Form); |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 410 | if (pFormRoot) { |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 411 | if (pFormRoot->GetFirstChild()) |
| 412 | pLayoutProcessor->SetHasChangedContainer(); |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 413 | } |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 414 | pLayoutProcessor->SetForceRelayout(); |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 415 | return CJS_Result::Success(); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 416 | } |
| 417 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 418 | CJS_Result CJX_LayoutPseudoModel::absPageSpan( |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 419 | CFXJSE_Engine* runtime, |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 420 | const std::vector<v8::Local<v8::Value>>& params) { |
| 421 | return pageSpan(runtime, params); |
| 422 | } |
| 423 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 424 | CJS_Result CJX_LayoutPseudoModel::absPageInBatch( |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 425 | CFXJSE_Engine* runtime, |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 426 | const std::vector<v8::Local<v8::Value>>& params) { |
| 427 | if (params.size() != 1) |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 428 | return CJS_Result::Failure(JSMessage::kParamError); |
| 429 | |
| 430 | return CJS_Result::Success(runtime->NewNumber(0)); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 431 | } |
| 432 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 433 | CJS_Result CJX_LayoutPseudoModel::sheetInBatch( |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 434 | CFXJSE_Engine* runtime, |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 435 | const std::vector<v8::Local<v8::Value>>& params) { |
| 436 | if (params.size() != 1) |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 437 | return CJS_Result::Failure(JSMessage::kParamError); |
| 438 | |
| 439 | return CJS_Result::Success(runtime->NewNumber(0)); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 440 | } |
| 441 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 442 | CJS_Result CJX_LayoutPseudoModel::sheet( |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 443 | CFXJSE_Engine* runtime, |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 444 | const std::vector<v8::Local<v8::Value>>& params) { |
| 445 | return PageInternals(runtime, params, true); |
| 446 | } |
| 447 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 448 | CJS_Result CJX_LayoutPseudoModel::relayoutPageArea( |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 449 | CFXJSE_Engine* runtime, |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 450 | const std::vector<v8::Local<v8::Value>>& params) { |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 451 | return CJS_Result::Success(); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 452 | } |
| 453 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 454 | CJS_Result CJX_LayoutPseudoModel::sheetCount( |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 455 | CFXJSE_Engine* runtime, |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 456 | const std::vector<v8::Local<v8::Value>>& params) { |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 457 | return AllPageCount(runtime); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 458 | } |
| 459 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 460 | CJS_Result CJX_LayoutPseudoModel::absPage( |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 461 | CFXJSE_Engine* runtime, |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 462 | const std::vector<v8::Local<v8::Value>>& params) { |
| 463 | return PageInternals(runtime, params, true); |
| 464 | } |
| 465 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 466 | CJS_Result CJX_LayoutPseudoModel::PageInternals( |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 467 | CFXJSE_Engine* runtime, |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 468 | const std::vector<v8::Local<v8::Value>>& params, |
| 469 | bool bAbsPage) { |
| 470 | if (params.size() != 1) |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 471 | return CJS_Result::Failure(JSMessage::kParamError); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 472 | |
kumarashishg | 826308d | 2023-06-23 13:21:22 +0000 | [diff] [blame] | 473 | CXFA_Node* pNode = ToNode(runtime->ToXFAObject(params[0])); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 474 | if (!pNode) |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 475 | return CJS_Result::Success(runtime->NewNumber(0)); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 476 | |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 477 | auto* pDocLayout = CXFA_LayoutProcessor::FromDocument(GetDocument()); |
| 478 | CXFA_ContentLayoutItem* pLayoutItem = |
| 479 | ToContentLayoutItem(pDocLayout->GetLayoutItem(pNode)); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 480 | if (!pLayoutItem) |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 481 | return CJS_Result::Success(runtime->NewNumber(-1)); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 482 | |
| 483 | int32_t iPage = pLayoutItem->GetFirst()->GetPage()->GetPageIndex(); |
Haibo Huang | 49cc930 | 2020-04-27 16:14:24 -0700 | [diff] [blame] | 484 | return CJS_Result::Success(runtime->NewNumber(bAbsPage ? iPage : iPage + 1)); |
Philip P. Moltmann | d904c1e | 2018-03-19 09:26:45 -0700 | [diff] [blame] | 485 | } |