diff options
Diffstat (limited to 'fxjs/xfa')
30 files changed, 4989 insertions, 14 deletions
diff --git a/fxjs/xfa/cjx_container.h b/fxjs/xfa/cjx_container.h index 41d11cfd69..0e2170fa2a 100644 --- a/fxjs/xfa/cjx_container.h +++ b/fxjs/xfa/cjx_container.h @@ -8,7 +8,7 @@ #define FXJS_XFA_CJX_CONTAINER_H_ #include "fxjs/CJX_Define.h" -#include "fxjs/cjx_node.h" +#include "fxjs/xfa/cjx_node.h" class CXFA_Node; diff --git a/fxjs/xfa/cjx_content.h b/fxjs/xfa/cjx_content.h index cd2e71a776..983a75005d 100644 --- a/fxjs/xfa/cjx_content.h +++ b/fxjs/xfa/cjx_content.h @@ -8,7 +8,7 @@ #define FXJS_XFA_CJX_CONTENT_H_ #include "fxjs/CJX_Define.h" -#include "fxjs/cjx_object.h" +#include "fxjs/xfa/cjx_object.h" class CXFA_Content; diff --git a/fxjs/xfa/cjx_datawindow.cpp b/fxjs/xfa/cjx_datawindow.cpp new file mode 100644 index 0000000000..54f32047fc --- /dev/null +++ b/fxjs/xfa/cjx_datawindow.cpp @@ -0,0 +1,66 @@ +// Copyright 2017 PDFium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com + +#include "fxjs/xfa/cjx_datawindow.h" + +#include <vector> + +#include "fxjs/cfxjse_value.h" +#include "xfa/fxfa/parser/cscript_datawindow.h" + +const CJX_MethodSpec CJX_DataWindow::MethodSpecs[] = { + {"gotoRecord", gotoRecord_static}, + {"isRecordGroup", isRecordGroup_static}, + {"moveCurrentRecord", moveCurrentRecord_static}, + {"record", record_static}, + {"", nullptr}}; + +CJX_DataWindow::CJX_DataWindow(CScript_DataWindow* window) + : CJX_Object(window) { + DefineMethods(MethodSpecs); +} + +CJX_DataWindow::~CJX_DataWindow() {} + +CJS_Return CJX_DataWindow::moveCurrentRecord( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return CJS_Return(true); +} + +CJS_Return CJX_DataWindow::record( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return CJS_Return(true); +} + +CJS_Return CJX_DataWindow::gotoRecord( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return CJS_Return(true); +} + +CJS_Return CJX_DataWindow::isRecordGroup( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return CJS_Return(true); +} + +void CJX_DataWindow::RecordsBefore(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) {} + +void CJX_DataWindow::CurrentRecordNumber(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) {} + +void CJX_DataWindow::RecordsAfter(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) {} + +void CJX_DataWindow::IsDefined(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) {} diff --git a/fxjs/xfa/cjx_datawindow.h b/fxjs/xfa/cjx_datawindow.h new file mode 100644 index 0000000000..82c5b1a9d1 --- /dev/null +++ b/fxjs/xfa/cjx_datawindow.h @@ -0,0 +1,42 @@ +// Copyright 2017 PDFium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com + +#ifndef FXJS_XFA_CJX_DATAWINDOW_H_ +#define FXJS_XFA_CJX_DATAWINDOW_H_ + +#include "fxjs/CJX_Define.h" +#include "fxjs/xfa/cjx_object.h" +#include "xfa/fxfa/fxfa_basic.h" + +class CFXJSE_Value; +class CScript_DataWindow; + +class CJX_DataWindow : public CJX_Object { + public: + explicit CJX_DataWindow(CScript_DataWindow* window); + ~CJX_DataWindow() override; + + void RecordsBefore(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void CurrentRecordNumber(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void RecordsAfter(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void IsDefined(CFXJSE_Value* pValue, bool bSetting, XFA_Attribute eAttribute); + + JS_METHOD(gotoRecord, CJX_DataWindow); + JS_METHOD(isRecordGroup, CJX_DataWindow); + JS_METHOD(moveCurrentRecord, CJX_DataWindow); + JS_METHOD(record, CJX_DataWindow); + + private: + static const CJX_MethodSpec MethodSpecs[]; +}; + +#endif // FXJS_XFA_CJX_DATAWINDOW_H_ diff --git a/fxjs/xfa/cjx_delta.h b/fxjs/xfa/cjx_delta.h index d9a2c6290e..29d3e8e788 100644 --- a/fxjs/xfa/cjx_delta.h +++ b/fxjs/xfa/cjx_delta.h @@ -8,7 +8,7 @@ #define FXJS_XFA_CJX_DELTA_H_ #include "fxjs/CJX_Define.h" -#include "fxjs/cjx_object.h" +#include "fxjs/xfa/cjx_object.h" class CXFA_Delta; diff --git a/fxjs/xfa/cjx_desc.h b/fxjs/xfa/cjx_desc.h index 602633d482..f3c9f46b4c 100644 --- a/fxjs/xfa/cjx_desc.h +++ b/fxjs/xfa/cjx_desc.h @@ -8,7 +8,7 @@ #define FXJS_XFA_CJX_DESC_H_ #include "fxjs/CJX_Define.h" -#include "fxjs/cjx_node.h" +#include "fxjs/xfa/cjx_node.h" class CXFA_Desc; diff --git a/fxjs/xfa/cjx_eventpseudomodel.cpp b/fxjs/xfa/cjx_eventpseudomodel.cpp new file mode 100644 index 0000000000..a109d1cb70 --- /dev/null +++ b/fxjs/xfa/cjx_eventpseudomodel.cpp @@ -0,0 +1,257 @@ +// Copyright 2017 PDFium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com + +#include "fxjs/xfa/cjx_eventpseudomodel.h" + +#include <vector> + +#include "fxjs/cfxjse_engine.h" +#include "fxjs/cfxjse_value.h" +#include "xfa/fxfa/cxfa_eventparam.h" +#include "xfa/fxfa/cxfa_ffnotify.h" +#include "xfa/fxfa/cxfa_ffwidgethandler.h" +#include "xfa/fxfa/parser/cscript_eventpseudomodel.h" + +namespace { + +void StringProperty(CFXJSE_Value* pValue, WideString& wsValue, bool bSetting) { + if (bSetting) { + wsValue = pValue->ToWideString(); + return; + } + pValue->SetString(wsValue.UTF8Encode().AsStringView()); +} + +void InterProperty(CFXJSE_Value* pValue, int32_t& iValue, bool bSetting) { + if (bSetting) { + iValue = pValue->ToInteger(); + return; + } + pValue->SetInteger(iValue); +} + +void BooleanProperty(CFXJSE_Value* pValue, bool& bValue, bool bSetting) { + if (bSetting) { + bValue = pValue->ToBoolean(); + return; + } + pValue->SetBoolean(bValue); +} + +} // namespace + +const CJX_MethodSpec CJX_EventPseudoModel::MethodSpecs[] = { + {"emit", emit_static}, + {"reset", reset_static}, + {"", nullptr}}; + +CJX_EventPseudoModel::CJX_EventPseudoModel(CScript_EventPseudoModel* model) + : CJX_Object(model) { + DefineMethods(MethodSpecs); +} + +CJX_EventPseudoModel::~CJX_EventPseudoModel() {} + +void CJX_EventPseudoModel::Change(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + Property(pValue, XFA_Event::Change, bSetting); +} + +void CJX_EventPseudoModel::CommitKey(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + Property(pValue, XFA_Event::CommitKey, bSetting); +} + +void CJX_EventPseudoModel::FullText(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + Property(pValue, XFA_Event::FullText, bSetting); +} + +void CJX_EventPseudoModel::KeyDown(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + Property(pValue, XFA_Event::Keydown, bSetting); +} + +void CJX_EventPseudoModel::Modifier(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + Property(pValue, XFA_Event::Modifier, bSetting); +} + +void CJX_EventPseudoModel::NewContentType(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + Property(pValue, XFA_Event::NewContentType, bSetting); +} + +void CJX_EventPseudoModel::NewText(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + Property(pValue, XFA_Event::NewText, bSetting); +} + +void CJX_EventPseudoModel::PrevContentType(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + Property(pValue, XFA_Event::PreviousContentType, bSetting); +} + +void CJX_EventPseudoModel::PrevText(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + Property(pValue, XFA_Event::PreviousText, bSetting); +} + +void CJX_EventPseudoModel::Reenter(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + Property(pValue, XFA_Event::Reenter, bSetting); +} + +void CJX_EventPseudoModel::SelEnd(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + Property(pValue, XFA_Event::SelectionEnd, bSetting); +} + +void CJX_EventPseudoModel::SelStart(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + Property(pValue, XFA_Event::SelectionStart, bSetting); +} + +void CJX_EventPseudoModel::Shift(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + Property(pValue, XFA_Event::Shift, bSetting); +} + +void CJX_EventPseudoModel::SoapFaultCode(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + Property(pValue, XFA_Event::SoapFaultCode, bSetting); +} + +void CJX_EventPseudoModel::SoapFaultString(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + Property(pValue, XFA_Event::SoapFaultString, bSetting); +} + +void CJX_EventPseudoModel::Target(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + Property(pValue, XFA_Event::Target, bSetting); +} + +CJS_Return CJX_EventPseudoModel::emit( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + CFXJSE_Engine* pScriptContext = GetDocument()->GetScriptContext(); + if (!pScriptContext) + return CJS_Return(true); + + CXFA_EventParam* pEventParam = pScriptContext->GetEventParam(); + if (!pEventParam) + return CJS_Return(true); + + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return CJS_Return(true); + + CXFA_FFWidgetHandler* pWidgetHandler = pNotify->GetWidgetHandler(); + if (!pWidgetHandler) + return CJS_Return(true); + + pWidgetHandler->ProcessEvent(pEventParam->m_pTarget, pEventParam); + return CJS_Return(true); +} + +CJS_Return CJX_EventPseudoModel::reset( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + CFXJSE_Engine* pScriptContext = GetDocument()->GetScriptContext(); + if (!pScriptContext) + return CJS_Return(true); + + CXFA_EventParam* pEventParam = pScriptContext->GetEventParam(); + if (!pEventParam) + return CJS_Return(true); + + pEventParam->Reset(); + return CJS_Return(true); +} + +void CJX_EventPseudoModel::Property(CFXJSE_Value* pValue, + XFA_Event dwFlag, + bool bSetting) { + CFXJSE_Engine* pScriptContext = GetDocument()->GetScriptContext(); + if (!pScriptContext) + return; + + CXFA_EventParam* pEventParam = pScriptContext->GetEventParam(); + if (!pEventParam) + return; + + switch (dwFlag) { + case XFA_Event::CancelAction: + BooleanProperty(pValue, pEventParam->m_bCancelAction, bSetting); + break; + case XFA_Event::Change: + StringProperty(pValue, pEventParam->m_wsChange, bSetting); + break; + case XFA_Event::CommitKey: + InterProperty(pValue, pEventParam->m_iCommitKey, bSetting); + break; + case XFA_Event::FullText: + StringProperty(pValue, pEventParam->m_wsFullText, bSetting); + break; + case XFA_Event::Keydown: + BooleanProperty(pValue, pEventParam->m_bKeyDown, bSetting); + break; + case XFA_Event::Modifier: + BooleanProperty(pValue, pEventParam->m_bModifier, bSetting); + break; + case XFA_Event::NewContentType: + StringProperty(pValue, pEventParam->m_wsNewContentType, bSetting); + break; + case XFA_Event::NewText: + StringProperty(pValue, pEventParam->m_wsNewText, bSetting); + break; + case XFA_Event::PreviousContentType: + StringProperty(pValue, pEventParam->m_wsPrevContentType, bSetting); + break; + case XFA_Event::PreviousText: + StringProperty(pValue, pEventParam->m_wsPrevText, bSetting); + break; + case XFA_Event::Reenter: + BooleanProperty(pValue, pEventParam->m_bReenter, bSetting); + break; + case XFA_Event::SelectionEnd: + InterProperty(pValue, pEventParam->m_iSelEnd, bSetting); + break; + case XFA_Event::SelectionStart: + InterProperty(pValue, pEventParam->m_iSelStart, bSetting); + break; + case XFA_Event::Shift: + BooleanProperty(pValue, pEventParam->m_bShift, bSetting); + break; + case XFA_Event::SoapFaultCode: + StringProperty(pValue, pEventParam->m_wsSoapFaultCode, bSetting); + break; + case XFA_Event::SoapFaultString: + StringProperty(pValue, pEventParam->m_wsSoapFaultString, bSetting); + break; + case XFA_Event::Target: + break; + default: + break; + } +} diff --git a/fxjs/xfa/cjx_eventpseudomodel.h b/fxjs/xfa/cjx_eventpseudomodel.h new file mode 100644 index 0000000000..d9615c3269 --- /dev/null +++ b/fxjs/xfa/cjx_eventpseudomodel.h @@ -0,0 +1,75 @@ +// Copyright 2017 PDFium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com + +#ifndef FXJS_XFA_CJX_EVENTPSEUDOMODEL_H_ +#define FXJS_XFA_CJX_EVENTPSEUDOMODEL_H_ + +#include "fxjs/CJX_Define.h" +#include "fxjs/xfa/cjx_object.h" + +class CFXJSE_Value; +class CScript_EventPseudoModel; + +enum class XFA_Event { + Change = 0, + CommitKey, + FullText, + Keydown, + Modifier, + NewContentType, + NewText, + PreviousContentType, + PreviousText, + Reenter, + SelectionEnd, + SelectionStart, + Shift, + SoapFaultCode, + SoapFaultString, + Target, + CancelAction +}; + +class CJX_EventPseudoModel : public CJX_Object { + public: + explicit CJX_EventPseudoModel(CScript_EventPseudoModel* model); + ~CJX_EventPseudoModel() override; + + void Change(CFXJSE_Value* pValue, bool bSetting, XFA_Attribute eAttribute); + void CommitKey(CFXJSE_Value* pValue, bool bSetting, XFA_Attribute eAttribute); + void FullText(CFXJSE_Value* pValue, bool bSetting, XFA_Attribute eAttribute); + void KeyDown(CFXJSE_Value* pValue, bool bSetting, XFA_Attribute eAttribute); + void Modifier(CFXJSE_Value* pValue, bool bSetting, XFA_Attribute eAttribute); + void NewContentType(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void NewText(CFXJSE_Value* pValue, bool bSetting, XFA_Attribute eAttribute); + void PrevContentType(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void PrevText(CFXJSE_Value* pValue, bool bSetting, XFA_Attribute eAttribute); + void Reenter(CFXJSE_Value* pValue, bool bSetting, XFA_Attribute eAttribute); + void SelEnd(CFXJSE_Value* pValue, bool bSetting, XFA_Attribute eAttribute); + void SelStart(CFXJSE_Value* pValue, bool bSetting, XFA_Attribute eAttribute); + void Shift(CFXJSE_Value* pValue, bool bSetting, XFA_Attribute eAttribute); + void SoapFaultCode(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void SoapFaultString(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Target(CFXJSE_Value* pValue, bool bSetting, XFA_Attribute eAttribute); + + JS_METHOD(emit, CJX_EventPseudoModel); + JS_METHOD(reset, CJX_EventPseudoModel); + + private: + void Property(CFXJSE_Value* pValue, XFA_Event dwFlag, bool bSetting); + + static const CJX_MethodSpec MethodSpecs[]; +}; + +#endif // FXJS_XFA_CJX_EVENTPSEUDOMODEL_H_ diff --git a/fxjs/xfa/cjx_exclgroup.h b/fxjs/xfa/cjx_exclgroup.h index 2ef280e17a..f44446762f 100644 --- a/fxjs/xfa/cjx_exclgroup.h +++ b/fxjs/xfa/cjx_exclgroup.h @@ -8,7 +8,7 @@ #define FXJS_XFA_CJX_EXCLGROUP_H_ #include "fxjs/CJX_Define.h" -#include "fxjs/cjx_node.h" +#include "fxjs/xfa/cjx_node.h" class CXFA_ExclGroup; diff --git a/fxjs/xfa/cjx_hostpseudomodel.cpp b/fxjs/xfa/cjx_hostpseudomodel.cpp new file mode 100644 index 0000000000..20e3bfe496 --- /dev/null +++ b/fxjs/xfa/cjx_hostpseudomodel.cpp @@ -0,0 +1,639 @@ +// Copyright 2017 PDFium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com + +#include "fxjs/xfa/cjx_hostpseudomodel.h" + +#include <memory> +#include <vector> + +#include "fxjs/cfxjse_engine.h" +#include "fxjs/cfxjse_value.h" +#include "fxjs/js_resources.h" +#include "xfa/fxfa/cxfa_ffnotify.h" +#include "xfa/fxfa/parser/cscript_hostpseudomodel.h" +#include "xfa/fxfa/parser/cxfa_layoutprocessor.h" +#include "xfa/fxfa/parser/cxfa_node.h" +#include "xfa/fxfa/parser/xfa_resolvenode_rs.h" + +namespace { + +int32_t FilterName(const WideStringView& wsExpression, + int32_t nStart, + WideString& wsFilter) { + ASSERT(nStart > -1); + int32_t iLength = wsExpression.GetLength(); + if (nStart >= iLength) + return iLength; + + wchar_t* pBuf = wsFilter.GetBuffer(iLength - nStart); + int32_t nCount = 0; + const wchar_t* pSrc = wsExpression.unterminated_c_str(); + wchar_t wCur; + while (nStart < iLength) { + wCur = pSrc[nStart++]; + if (wCur == ',') + break; + + pBuf[nCount++] = wCur; + } + wsFilter.ReleaseBuffer(nCount); + wsFilter.Trim(); + return nStart; +} + +} // namespace + +const CJX_MethodSpec CJX_HostPseudoModel::MethodSpecs[] = { + {"beep", beep_static}, + {"documentCountInBatch", documentCountInBatch_static}, + {"documentInBatch", documentInBatch_static}, + {"exportData", exportData_static}, + {"getFocus", getFocus_static}, + {"gotoURL", gotoURL_static}, + {"importData", importData_static}, + {"messageBox", messageBox_static}, + {"openList", openList_static}, + {"pageDown", pageDown_static}, + {"pageUp", pageUp_static}, + {"print", print_static}, + {"resetData", resetData_static}, + {"response", response_static}, + {"setFocus", setFocus_static}, + {"", nullptr}}; + +CJX_HostPseudoModel::CJX_HostPseudoModel(CScript_HostPseudoModel* model) + : CJX_Object(model) { + DefineMethods(MethodSpecs); +} + +CJX_HostPseudoModel::~CJX_HostPseudoModel() {} + +void CJX_HostPseudoModel::AppType(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return; + + if (bSetting) { + ThrowInvalidPropertyException(); + return; + } + pValue->SetString("Exchange"); +} + +void CJX_HostPseudoModel::CalculationsEnabled(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return; + + CXFA_FFDoc* hDoc = pNotify->GetHDOC(); + if (bSetting) { + pNotify->GetDocEnvironment()->SetCalculationsEnabled(hDoc, + pValue->ToBoolean()); + return; + } + pValue->SetBoolean(pNotify->GetDocEnvironment()->IsCalculationsEnabled(hDoc)); +} + +void CJX_HostPseudoModel::CurrentPage(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return; + + CXFA_FFDoc* hDoc = pNotify->GetHDOC(); + if (bSetting) { + pNotify->GetDocEnvironment()->SetCurrentPage(hDoc, pValue->ToInteger()); + return; + } + pValue->SetInteger(pNotify->GetDocEnvironment()->GetCurrentPage(hDoc)); +} + +void CJX_HostPseudoModel::Language(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return; + + if (bSetting) { + ThrowException(L"Unable to set language value."); + return; + } + pValue->SetString( + pNotify->GetAppProvider()->GetLanguage().UTF8Encode().AsStringView()); +} + +void CJX_HostPseudoModel::NumPages(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return; + + CXFA_FFDoc* hDoc = pNotify->GetHDOC(); + if (bSetting) { + ThrowException(L"Unable to set numPages value."); + return; + } + pValue->SetInteger(pNotify->GetDocEnvironment()->CountPages(hDoc)); +} + +void CJX_HostPseudoModel::Platform(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return; + + if (bSetting) { + ThrowException(L"Unable to set platform value."); + return; + } + pValue->SetString( + pNotify->GetAppProvider()->GetPlatform().UTF8Encode().AsStringView()); +} + +void CJX_HostPseudoModel::Title(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (!GetDocument()->GetScriptContext()->IsRunAtClient()) + return; + + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return; + + CXFA_FFDoc* hDoc = pNotify->GetHDOC(); + if (bSetting) { + pNotify->GetDocEnvironment()->SetTitle(hDoc, pValue->ToWideString()); + return; + } + + WideString wsTitle; + pNotify->GetDocEnvironment()->GetTitle(hDoc, wsTitle); + pValue->SetString(wsTitle.UTF8Encode().AsStringView()); +} + +void CJX_HostPseudoModel::ValidationsEnabled(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return; + + CXFA_FFDoc* hDoc = pNotify->GetHDOC(); + if (bSetting) { + pNotify->GetDocEnvironment()->SetValidationsEnabled(hDoc, + pValue->ToBoolean()); + return; + } + + bool bEnabled = pNotify->GetDocEnvironment()->IsValidationsEnabled(hDoc); + pValue->SetBoolean(bEnabled); +} + +void CJX_HostPseudoModel::Variation(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (!GetDocument()->GetScriptContext()->IsRunAtClient()) + return; + + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return; + + if (bSetting) { + ThrowException(L"Unable to set variation value."); + return; + } + pValue->SetString("Full"); +} + +void CJX_HostPseudoModel::Version(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return; + + if (bSetting) { + ThrowException(L"Unable to set version value."); + return; + } + pValue->SetString("11"); +} + +void CJX_HostPseudoModel::Name(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return; + + if (bSetting) { + ThrowInvalidPropertyException(); + return; + } + pValue->SetString( + pNotify->GetAppProvider()->GetAppName().UTF8Encode().AsStringView()); +} + +CJS_Return CJX_HostPseudoModel::gotoURL( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (!GetDocument()->GetScriptContext()->IsRunAtClient()) + return CJS_Return(true); + + if (params.size() != 1) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return CJS_Return(true); + + CXFA_FFDoc* hDoc = pNotify->GetHDOC(); + WideString URL = runtime->ToWideString(params[0]); + pNotify->GetDocEnvironment()->GotoURL(hDoc, URL); + return CJS_Return(true); +} + +CJS_Return CJX_HostPseudoModel::openList( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (!GetDocument()->GetScriptContext()->IsRunAtClient()) + return CJS_Return(true); + + if (params.size() != 1) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return CJS_Return(true); + + CXFA_Node* pNode = nullptr; + if (params[0]->IsObject()) { + pNode = ToNode(runtime->ToXFAObject(params[0])); + } else if (params[0]->IsString()) { + CFXJSE_Engine* pScriptContext = GetDocument()->GetScriptContext(); + if (!pScriptContext) + return CJS_Return(true); + + CXFA_Object* pObject = pScriptContext->GetThisObject(); + if (!pObject) + return CJS_Return(true); + + uint32_t dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Parent | + XFA_RESOLVENODE_Siblings; + XFA_RESOLVENODE_RS resolveNodeRS; + bool iRet = pScriptContext->ResolveObjects( + pObject, runtime->ToWideString(params[0]).AsStringView(), + &resolveNodeRS, dwFlag, nullptr); + if (!iRet || !resolveNodeRS.objects.front()->IsNode()) + return CJS_Return(true); + + pNode = resolveNodeRS.objects.front()->AsNode(); + } + + CXFA_LayoutProcessor* pDocLayout = GetDocument()->GetDocLayout(); + if (!pDocLayout) + return CJS_Return(true); + + CXFA_FFWidget* hWidget = + pNotify->GetHWidget(pDocLayout->GetLayoutItem(pNode)); + if (!hWidget) + return CJS_Return(true); + + pNotify->GetDocEnvironment()->SetFocusWidget(pNotify->GetHDOC(), hWidget); + pNotify->OpenDropDownList(hWidget); + return CJS_Return(true); +} + +CJS_Return CJX_HostPseudoModel::response( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (params.empty() || params.size() > 4) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return CJS_Return(true); + + WideString question; + if (params.size() >= 1) + question = runtime->ToWideString(params[0]); + + WideString title; + if (params.size() >= 2) + title = runtime->ToWideString(params[1]); + + WideString defaultAnswer; + if (params.size() >= 3) + defaultAnswer = runtime->ToWideString(params[2]); + + bool mark = false; + if (params.size() >= 4) + mark = runtime->ToInt32(params[3]) != 0; + + WideString answer = + pNotify->GetAppProvider()->Response(question, title, defaultAnswer, mark); + return CJS_Return(runtime->NewString(answer.UTF8Encode().AsStringView())); +} + +CJS_Return CJX_HostPseudoModel::documentInBatch( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return CJS_Return(runtime->NewNumber(0)); +} + +CJS_Return CJX_HostPseudoModel::resetData( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (params.size() > 1) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return CJS_Return(true); + + WideString expression; + if (params.size() >= 1) + expression = runtime->ToWideString(params[0]); + + if (expression.IsEmpty()) { + pNotify->ResetData(); + return CJS_Return(true); + } + + int32_t iStart = 0; + WideString wsName; + CXFA_Node* pNode = nullptr; + int32_t iExpLength = expression.GetLength(); + while (iStart < iExpLength) { + iStart = FilterName(expression.AsStringView(), iStart, wsName); + CFXJSE_Engine* pScriptContext = GetDocument()->GetScriptContext(); + if (!pScriptContext) + return CJS_Return(true); + + CXFA_Object* pObject = pScriptContext->GetThisObject(); + if (!pObject) + return CJS_Return(true); + + uint32_t dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Parent | + XFA_RESOLVENODE_Siblings; + XFA_RESOLVENODE_RS resolveNodeRS; + bool iRet = pScriptContext->ResolveObjects(pObject, wsName.AsStringView(), + &resolveNodeRS, dwFlag, nullptr); + if (!iRet || !resolveNodeRS.objects.front()->IsNode()) + continue; + + pNode = resolveNodeRS.objects.front()->AsNode(); + pNotify->ResetData(pNode->GetWidgetData()); + } + if (!pNode) + pNotify->ResetData(); + + return CJS_Return(true); +} + +CJS_Return CJX_HostPseudoModel::beep( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (!GetDocument()->GetScriptContext()->IsRunAtClient()) + return CJS_Return(true); + + if (params.size() > 1) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return CJS_Return(true); + + uint32_t dwType = 4; + if (params.size() >= 1) + dwType = runtime->ToInt32(params[0]); + + pNotify->GetAppProvider()->Beep(dwType); + return CJS_Return(true); +} + +CJS_Return CJX_HostPseudoModel::setFocus( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (!GetDocument()->GetScriptContext()->IsRunAtClient()) + return CJS_Return(true); + + if (params.size() != 1) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return CJS_Return(true); + + CXFA_Node* pNode = nullptr; + if (params.size() >= 1) { + if (params[0]->IsObject()) { + pNode = ToNode(runtime->ToXFAObject(params[0])); + } else if (params[0]->IsString()) { + CFXJSE_Engine* pScriptContext = GetDocument()->GetScriptContext(); + if (!pScriptContext) + return CJS_Return(true); + + CXFA_Object* pObject = pScriptContext->GetThisObject(); + if (!pObject) + return CJS_Return(true); + + uint32_t dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Parent | + XFA_RESOLVENODE_Siblings; + XFA_RESOLVENODE_RS resolveNodeRS; + bool iRet = pScriptContext->ResolveObjects( + pObject, runtime->ToWideString(params[0]).AsStringView(), + &resolveNodeRS, dwFlag, nullptr); + if (!iRet || !resolveNodeRS.objects.front()->IsNode()) + return CJS_Return(true); + + pNode = resolveNodeRS.objects.front()->AsNode(); + } + } + pNotify->SetFocusWidgetNode(pNode); + return CJS_Return(true); +} + +CJS_Return CJX_HostPseudoModel::getFocus( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return CJS_Return(true); + + CXFA_Node* pNode = pNotify->GetFocusWidgetNode(); + if (!pNode) + return CJS_Return(true); + + CFXJSE_Value* value = + GetDocument()->GetScriptContext()->GetJSValueFromMap(pNode); + if (!value) + return CJS_Return(runtime->NewNull()); + + return CJS_Return(value->DirectGetValue().Get(runtime->GetIsolate())); +} + +CJS_Return CJX_HostPseudoModel::messageBox( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (!GetDocument()->GetScriptContext()->IsRunAtClient()) + return CJS_Return(true); + + if (params.empty() || params.size() > 4) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return CJS_Return(true); + + WideString message; + if (params.size() >= 1) + message = runtime->ToWideString(params[0]); + + WideString title; + if (params.size() >= 2) + title = runtime->ToWideString(params[1]); + + uint32_t messageType = XFA_MBICON_Error; + if (params.size() >= 3) { + messageType = runtime->ToInt32(params[2]); + if (messageType > XFA_MBICON_Status) + messageType = XFA_MBICON_Error; + } + + uint32_t buttonType = XFA_MB_OK; + if (params.size() >= 4) { + buttonType = runtime->ToInt32(params[3]); + if (buttonType > XFA_MB_YesNoCancel) + buttonType = XFA_MB_OK; + } + + int32_t iValue = pNotify->GetAppProvider()->MsgBox(message, title, + messageType, buttonType); + return CJS_Return(runtime->NewNumber(iValue)); +} + +CJS_Return CJX_HostPseudoModel::documentCountInBatch( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return CJS_Return(runtime->NewNumber(0)); +} + +CJS_Return CJX_HostPseudoModel::print( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (!GetDocument()->GetScriptContext()->IsRunAtClient()) + return CJS_Return(true); + + if (params.size() != 8) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return CJS_Return(true); + + uint32_t dwOptions = 0; + if (runtime->ToBoolean(params[0])) + dwOptions |= XFA_PRINTOPT_ShowDialog; + if (runtime->ToBoolean(params[3])) + dwOptions |= XFA_PRINTOPT_CanCancel; + if (runtime->ToBoolean(params[4])) + dwOptions |= XFA_PRINTOPT_ShrinkPage; + if (runtime->ToBoolean(params[5])) + dwOptions |= XFA_PRINTOPT_AsImage; + if (runtime->ToBoolean(params[6])) + dwOptions |= XFA_PRINTOPT_ReverseOrder; + if (runtime->ToBoolean(params[7])) + dwOptions |= XFA_PRINTOPT_PrintAnnot; + + int32_t nStartPage = runtime->ToInt32(params[1]); + int32_t nEndPage = runtime->ToInt32(params[2]); + + pNotify->GetDocEnvironment()->Print(pNotify->GetHDOC(), nStartPage, nEndPage, + dwOptions); + return CJS_Return(true); +} + +CJS_Return CJX_HostPseudoModel::importData( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (params.empty() || params.size() > 1) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + + return CJS_Return(true); +} + +CJS_Return CJX_HostPseudoModel::exportData( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (params.empty() || params.size() > 2) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return CJS_Return(true); + + WideString filePath; + if (params.size() >= 1) + filePath = runtime->ToWideString(params[0]); + + bool XDP = true; + if (params.size() >= 2) + XDP = runtime->ToBoolean(params[1]); + + pNotify->GetDocEnvironment()->ExportData(pNotify->GetHDOC(), filePath, XDP); + return CJS_Return(true); +} + +CJS_Return CJX_HostPseudoModel::pageUp( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return CJS_Return(true); + + CXFA_FFDoc* hDoc = pNotify->GetHDOC(); + int32_t nCurPage = pNotify->GetDocEnvironment()->GetCurrentPage(hDoc); + int32_t nNewPage = 0; + if (nCurPage <= 1) + return CJS_Return(true); + + nNewPage = nCurPage - 1; + pNotify->GetDocEnvironment()->SetCurrentPage(hDoc, nNewPage); + return CJS_Return(true); +} + +CJS_Return CJX_HostPseudoModel::pageDown( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return CJS_Return(true); + + CXFA_FFDoc* hDoc = pNotify->GetHDOC(); + int32_t nCurPage = pNotify->GetDocEnvironment()->GetCurrentPage(hDoc); + int32_t nPageCount = pNotify->GetDocEnvironment()->CountPages(hDoc); + if (!nPageCount || nCurPage == nPageCount) + return CJS_Return(true); + + int32_t nNewPage = 0; + if (nCurPage >= nPageCount) + nNewPage = nPageCount - 1; + else + nNewPage = nCurPage + 1; + + pNotify->GetDocEnvironment()->SetCurrentPage(hDoc, nNewPage); + return CJS_Return(true); +} diff --git a/fxjs/xfa/cjx_hostpseudomodel.h b/fxjs/xfa/cjx_hostpseudomodel.h new file mode 100644 index 0000000000..fa3277a2c9 --- /dev/null +++ b/fxjs/xfa/cjx_hostpseudomodel.h @@ -0,0 +1,60 @@ +// Copyright 2017 PDFium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com + +#ifndef FXJS_XFA_CJX_HOSTPSEUDOMODEL_H_ +#define FXJS_XFA_CJX_HOSTPSEUDOMODEL_H_ + +#include "fxjs/CJX_Define.h" +#include "fxjs/xfa/cjx_object.h" +#include "xfa/fxfa/fxfa_basic.h" + +class CFXJSE_Value; +class CScript_HostPseudoModel; + +class CJX_HostPseudoModel : public CJX_Object { + public: + explicit CJX_HostPseudoModel(CScript_HostPseudoModel* model); + ~CJX_HostPseudoModel() override; + + void AppType(CFXJSE_Value* pValue, bool bSetting, XFA_Attribute eAttribute); + void CalculationsEnabled(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void CurrentPage(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Language(CFXJSE_Value* pValue, bool bSetting, XFA_Attribute eAttribute); + void NumPages(CFXJSE_Value* pValue, bool bSetting, XFA_Attribute eAttribute); + void Platform(CFXJSE_Value* pValue, bool bSetting, XFA_Attribute eAttribute); + void Title(CFXJSE_Value* pValue, bool bSetting, XFA_Attribute eAttribute); + void ValidationsEnabled(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Variation(CFXJSE_Value* pValue, bool bSetting, XFA_Attribute eAttribute); + void Version(CFXJSE_Value* pValue, bool bSetting, XFA_Attribute eAttribute); + void Name(CFXJSE_Value* pValue, bool bSetting, XFA_Attribute eAttribute); + + JS_METHOD(beep, CJX_HostPseudoModel); + JS_METHOD(documentCountInBatch, CJX_HostPseudoModel); + JS_METHOD(documentInBatch, CJX_HostPseudoModel); + JS_METHOD(exportData, CJX_HostPseudoModel); + JS_METHOD(getFocus, CJX_HostPseudoModel); + JS_METHOD(gotoURL, CJX_HostPseudoModel); + JS_METHOD(importData, CJX_HostPseudoModel); + JS_METHOD(messageBox, CJX_HostPseudoModel); + JS_METHOD(openList, CJX_HostPseudoModel); + JS_METHOD(pageDown, CJX_HostPseudoModel); + JS_METHOD(pageUp, CJX_HostPseudoModel); + JS_METHOD(print, CJX_HostPseudoModel); + JS_METHOD(resetData, CJX_HostPseudoModel); + JS_METHOD(response, CJX_HostPseudoModel); + JS_METHOD(setFocus, CJX_HostPseudoModel); + + private: + static const CJX_MethodSpec MethodSpecs[]; +}; + +#endif // FXJS_XFA_CJX_HOSTPSEUDOMODEL_H_ diff --git a/fxjs/xfa/cjx_instancemanager.h b/fxjs/xfa/cjx_instancemanager.h index a312366b3b..1fd41a6402 100644 --- a/fxjs/xfa/cjx_instancemanager.h +++ b/fxjs/xfa/cjx_instancemanager.h @@ -8,7 +8,7 @@ #define FXJS_XFA_CJX_INSTANCEMANAGER_H_ #include "fxjs/CJX_Define.h" -#include "fxjs/cjx_node.h" +#include "fxjs/xfa/cjx_node.h" class CXFA_InstanceManager; diff --git a/fxjs/xfa/cjx_layoutpseudomodel.cpp b/fxjs/xfa/cjx_layoutpseudomodel.cpp new file mode 100644 index 0000000000..b80000a0e2 --- /dev/null +++ b/fxjs/xfa/cjx_layoutpseudomodel.cpp @@ -0,0 +1,481 @@ +// Copyright 2017 PDFium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com + +#include "fxjs/xfa/cjx_layoutpseudomodel.h" + +#include <set> + +#include "core/fxcrt/fx_coordinates.h" +#include "fxjs/cfxjse_engine.h" +#include "fxjs/cfxjse_value.h" +#include "fxjs/js_resources.h" +#include "xfa/fxfa/cxfa_ffnotify.h" +#include "xfa/fxfa/parser/cscript_layoutpseudomodel.h" +#include "xfa/fxfa/parser/cxfa_arraynodelist.h" +#include "xfa/fxfa/parser/cxfa_containerlayoutitem.h" +#include "xfa/fxfa/parser/cxfa_document.h" +#include "xfa/fxfa/parser/cxfa_layoutitem.h" +#include "xfa/fxfa/parser/cxfa_layoutprocessor.h" +#include "xfa/fxfa/parser/cxfa_measurement.h" +#include "xfa/fxfa/parser/cxfa_node.h" +#include "xfa/fxfa/parser/cxfa_nodeiteratortemplate.h" +#include "xfa/fxfa/parser/cxfa_traversestrategy_contentlayoutitem.h" + +const CJX_MethodSpec CJX_LayoutPseudoModel::MethodSpecs[] = { + {"absPage", absPage_static}, + {"absPageCount", absPageCount_static}, + {"absPageCountInBatch", absPageCountInBatch_static}, + {"absPageInBatch", absPageInBatch_static}, + {"absPageSpan", absPageSpan_static}, + {"h", h_static}, + {"page", page_static}, + {"pageContent", pageContent_static}, + {"pageCount", pageCount_static}, + {"pageSpan", pageSpan_static}, + {"relayout", relayout_static}, + {"relayoutPageArea", relayoutPageArea_static}, + {"sheet", sheet_static}, + {"sheetCount", sheetCount_static}, + {"sheetCountInBatch", sheetCountInBatch_static}, + {"sheetInBatch", sheetInBatch_static}, + {"w", w_static}, + {"x", x_static}, + {"y", y_static}, + {"", nullptr}}; + +CJX_LayoutPseudoModel::CJX_LayoutPseudoModel(CScript_LayoutPseudoModel* model) + : CJX_Object(model) { + DefineMethods(MethodSpecs); +} + +CJX_LayoutPseudoModel::~CJX_LayoutPseudoModel() {} + +void CJX_LayoutPseudoModel::Ready(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return; + if (bSetting) { + ThrowException(L"Unable to set ready value."); + return; + } + + int32_t iStatus = pNotify->GetLayoutStatus(); + pValue->SetBoolean(iStatus >= 2); +} + +CJS_Return CJX_LayoutPseudoModel::HWXY( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params, + XFA_LAYOUTMODEL_HWXY layoutModel) { + if (params.empty() || params.size() > 3) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + + CXFA_Node* pNode = ToNode(runtime->ToXFAObject(params[0])); + if (!pNode) + return CJS_Return(true); + + WideString unit(L"pt"); + if (params.size() >= 2) { + WideString tmp_unit = runtime->ToWideString(params[1]); + if (!tmp_unit.IsEmpty()) + unit = tmp_unit; + } + int32_t iIndex = params.size() >= 3 ? runtime->ToInt32(params[2]) : 0; + + CXFA_LayoutProcessor* pDocLayout = GetDocument()->GetDocLayout(); + if (!pDocLayout) + return CJS_Return(true); + + CXFA_LayoutItem* pLayoutItem = pDocLayout->GetLayoutItem(pNode); + if (!pLayoutItem) + return CJS_Return(true); + + while (iIndex > 0 && pLayoutItem) { + pLayoutItem = pLayoutItem->GetNext(); + --iIndex; + } + + if (!pLayoutItem) + return CJS_Return(runtime->NewNumber(0.0)); + + CXFA_Measurement measure; + CFX_RectF rtRect = pLayoutItem->GetRect(true); + switch (layoutModel) { + case XFA_LAYOUTMODEL_H: + measure.Set(rtRect.height, XFA_Unit::Pt); + break; + case XFA_LAYOUTMODEL_W: + measure.Set(rtRect.width, XFA_Unit::Pt); + break; + case XFA_LAYOUTMODEL_X: + measure.Set(rtRect.left, XFA_Unit::Pt); + break; + case XFA_LAYOUTMODEL_Y: + measure.Set(rtRect.top, XFA_Unit::Pt); + break; + } + + float fValue = + measure.ToUnit(CXFA_Measurement::GetUnitFromString(unit.AsStringView())); + return CJS_Return(runtime->NewNumber(FXSYS_round(fValue * 1000) / 1000.0f)); +} + +CJS_Return CJX_LayoutPseudoModel::h( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return HWXY(runtime, params, XFA_LAYOUTMODEL_H); +} + +CJS_Return CJX_LayoutPseudoModel::w( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return HWXY(runtime, params, XFA_LAYOUTMODEL_W); +} + +CJS_Return CJX_LayoutPseudoModel::x( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return HWXY(runtime, params, XFA_LAYOUTMODEL_X); +} + +CJS_Return CJX_LayoutPseudoModel::y( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return HWXY(runtime, params, XFA_LAYOUTMODEL_Y); +} + +CJS_Return CJX_LayoutPseudoModel::NumberedPageCount(CJS_V8* runtime, + bool bNumbered) { + CXFA_LayoutProcessor* pDocLayout = GetDocument()->GetDocLayout(); + if (!pDocLayout) + return CJS_Return(true); + + int32_t iPageCount = 0; + int32_t iPageNum = pDocLayout->CountPages(); + if (bNumbered) { + for (int32_t i = 0; i < iPageNum; i++) { + CXFA_ContainerLayoutItem* pLayoutPage = pDocLayout->GetPage(i); + if (!pLayoutPage) + continue; + + CXFA_Node* pMasterPage = pLayoutPage->GetMasterPage(); + if (pMasterPage->JSNode()->GetInteger(XFA_Attribute::Numbered)) + iPageCount++; + } + } else { + iPageCount = iPageNum; + } + return CJS_Return(runtime->NewNumber(iPageCount)); +} + +CJS_Return CJX_LayoutPseudoModel::pageCount( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return NumberedPageCount(runtime, true); +} + +CJS_Return CJX_LayoutPseudoModel::pageSpan( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (params.size() != 1) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + + CXFA_Node* pNode = ToNode(runtime->ToXFAObject(params[0])); + if (!pNode) + return CJS_Return(true); + + CXFA_LayoutProcessor* pDocLayout = GetDocument()->GetDocLayout(); + if (!pDocLayout) + return CJS_Return(true); + + CXFA_LayoutItem* pLayoutItem = pDocLayout->GetLayoutItem(pNode); + if (!pLayoutItem) + return CJS_Return(runtime->NewNumber(-1)); + + int32_t iLast = pLayoutItem->GetLast()->GetPage()->GetPageIndex(); + int32_t iFirst = pLayoutItem->GetFirst()->GetPage()->GetPageIndex(); + int32_t iPageSpan = iLast - iFirst + 1; + return CJS_Return(runtime->NewNumber(iPageSpan)); +} + +CJS_Return CJX_LayoutPseudoModel::page( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return PageInternals(runtime, params, false); +} + +std::vector<CXFA_Node*> CJX_LayoutPseudoModel::GetObjArray( + CXFA_LayoutProcessor* pDocLayout, + int32_t iPageNo, + const WideString& wsType, + bool bOnPageArea) { + CXFA_ContainerLayoutItem* pLayoutPage = pDocLayout->GetPage(iPageNo); + if (!pLayoutPage) + return std::vector<CXFA_Node*>(); + + std::vector<CXFA_Node*> retArray; + if (wsType == L"pageArea") { + if (pLayoutPage->m_pFormNode) + retArray.push_back(pLayoutPage->m_pFormNode); + return retArray; + } + if (wsType == L"contentArea") { + for (CXFA_LayoutItem* pItem = pLayoutPage->m_pFirstChild; pItem; + pItem = pItem->m_pNextSibling) { + if (pItem->m_pFormNode->GetElementType() == XFA_Element::ContentArea) + retArray.push_back(pItem->m_pFormNode); + } + return retArray; + } + std::set<CXFA_Node*> formItems; + if (wsType.IsEmpty()) { + if (pLayoutPage->m_pFormNode) + retArray.push_back(pLayoutPage->m_pFormNode); + + for (CXFA_LayoutItem* pItem = pLayoutPage->m_pFirstChild; pItem; + pItem = pItem->m_pNextSibling) { + if (pItem->m_pFormNode->GetElementType() == XFA_Element::ContentArea) { + retArray.push_back(pItem->m_pFormNode); + if (!bOnPageArea) { + CXFA_NodeIteratorTemplate<CXFA_ContentLayoutItem, + CXFA_TraverseStrategy_ContentLayoutItem> + iterator(static_cast<CXFA_ContentLayoutItem*>(pItem->m_pFirstChild)); + for (CXFA_ContentLayoutItem* pItemChild = iterator.GetCurrent(); + pItemChild; pItemChild = iterator.MoveToNext()) { + if (!pItemChild->IsContentLayoutItem()) { + continue; + } + XFA_Element eType = pItemChild->m_pFormNode->GetElementType(); + if (eType != XFA_Element::Field && eType != XFA_Element::Draw && + eType != XFA_Element::Subform && eType != XFA_Element::Area) { + continue; + } + if (pdfium::ContainsValue(formItems, pItemChild->m_pFormNode)) + continue; + + formItems.insert(pItemChild->m_pFormNode); + retArray.push_back(pItemChild->m_pFormNode); + } + } + } else { + if (bOnPageArea) { + CXFA_NodeIteratorTemplate<CXFA_ContentLayoutItem, + CXFA_TraverseStrategy_ContentLayoutItem> + iterator(static_cast<CXFA_ContentLayoutItem*>(pItem)); + for (CXFA_ContentLayoutItem* pItemChild = iterator.GetCurrent(); + pItemChild; pItemChild = iterator.MoveToNext()) { + if (!pItemChild->IsContentLayoutItem()) { + continue; + } + XFA_Element eType = pItemChild->m_pFormNode->GetElementType(); + if (eType != XFA_Element::Field && eType != XFA_Element::Draw && + eType != XFA_Element::Subform && eType != XFA_Element::Area) { + continue; + } + if (pdfium::ContainsValue(formItems, pItemChild->m_pFormNode)) + continue; + formItems.insert(pItemChild->m_pFormNode); + retArray.push_back(pItemChild->m_pFormNode); + } + } + } + } + return retArray; + } + + XFA_Element eType = XFA_Element::Unknown; + if (wsType == L"field") + eType = XFA_Element::Field; + else if (wsType == L"draw") + eType = XFA_Element::Draw; + else if (wsType == L"subform") + eType = XFA_Element::Subform; + else if (wsType == L"area") + eType = XFA_Element::Area; + + if (eType != XFA_Element::Unknown) { + for (CXFA_LayoutItem* pItem = pLayoutPage->m_pFirstChild; pItem; + pItem = pItem->m_pNextSibling) { + if (pItem->m_pFormNode->GetElementType() == XFA_Element::ContentArea) { + if (!bOnPageArea) { + CXFA_NodeIteratorTemplate<CXFA_ContentLayoutItem, + CXFA_TraverseStrategy_ContentLayoutItem> + iterator(static_cast<CXFA_ContentLayoutItem*>(pItem->m_pFirstChild)); + for (CXFA_ContentLayoutItem* pItemChild = iterator.GetCurrent(); + pItemChild; pItemChild = iterator.MoveToNext()) { + if (!pItemChild->IsContentLayoutItem()) + continue; + if (pItemChild->m_pFormNode->GetElementType() != eType) + continue; + if (pdfium::ContainsValue(formItems, pItemChild->m_pFormNode)) + continue; + + formItems.insert(pItemChild->m_pFormNode); + retArray.push_back(pItemChild->m_pFormNode); + } + } + } else { + if (bOnPageArea) { + CXFA_NodeIteratorTemplate<CXFA_ContentLayoutItem, + CXFA_TraverseStrategy_ContentLayoutItem> + iterator(static_cast<CXFA_ContentLayoutItem*>(pItem)); + for (CXFA_ContentLayoutItem* pItemChild = iterator.GetCurrent(); + pItemChild; pItemChild = iterator.MoveToNext()) { + if (!pItemChild->IsContentLayoutItem()) + continue; + if (pItemChild->m_pFormNode->GetElementType() != eType) + continue; + if (pdfium::ContainsValue(formItems, pItemChild->m_pFormNode)) + continue; + + formItems.insert(pItemChild->m_pFormNode); + retArray.push_back(pItemChild->m_pFormNode); + } + } + } + } + } + return retArray; +} + +CJS_Return CJX_LayoutPseudoModel::pageContent( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (params.empty() || params.size() > 3) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + + int32_t iIndex = 0; + if (params.size() >= 1) + iIndex = runtime->ToInt32(params[0]); + + WideString wsType; + if (params.size() >= 2) + wsType = runtime->ToWideString(params[1]); + + bool bOnPageArea = false; + if (params.size() >= 3) + bOnPageArea = runtime->ToBoolean(params[2]); + + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return CJS_Return(true); + + CXFA_LayoutProcessor* pDocLayout = GetDocument()->GetDocLayout(); + if (!pDocLayout) + return CJS_Return(true); + + auto pArrayNodeList = pdfium::MakeUnique<CXFA_ArrayNodeList>(GetDocument()); + pArrayNodeList->SetArrayNodeList( + GetObjArray(pDocLayout, iIndex, wsType, bOnPageArea)); + + // TODO(dsinclair): Who owns the array once we release it? Won't this leak? + return CJS_Return(runtime->NewXFAObject( + pArrayNodeList.release(), + GetDocument()->GetScriptContext()->GetJseNormalClass()->GetTemplate())); +} + +CJS_Return CJX_LayoutPseudoModel::absPageCount( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return NumberedPageCount(runtime, false); +} + +CJS_Return CJX_LayoutPseudoModel::absPageCountInBatch( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return CJS_Return(runtime->NewNumber(0)); +} + +CJS_Return CJX_LayoutPseudoModel::sheetCountInBatch( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return CJS_Return(runtime->NewNumber(0)); +} + +CJS_Return CJX_LayoutPseudoModel::relayout( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + CXFA_Node* pRootNode = GetDocument()->GetRoot(); + CXFA_Node* pFormRoot = pRootNode->GetFirstChildByClass(XFA_Element::Form); + CXFA_Node* pContentRootNode = pFormRoot->GetNodeItem(XFA_NODEITEM_FirstChild); + CXFA_LayoutProcessor* pLayoutProcessor = GetDocument()->GetLayoutProcessor(); + if (pContentRootNode) + pLayoutProcessor->AddChangedContainer(pContentRootNode); + + pLayoutProcessor->SetForceReLayout(true); + return CJS_Return(true); +} + +CJS_Return CJX_LayoutPseudoModel::absPageSpan( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return pageSpan(runtime, params); +} + +CJS_Return CJX_LayoutPseudoModel::absPageInBatch( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (params.size() != 1) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + return CJS_Return(runtime->NewNumber(0)); +} + +CJS_Return CJX_LayoutPseudoModel::sheetInBatch( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (params.size() != 1) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + return CJS_Return(runtime->NewNumber(0)); +} + +CJS_Return CJX_LayoutPseudoModel::sheet( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return PageInternals(runtime, params, true); +} + +CJS_Return CJX_LayoutPseudoModel::relayoutPageArea( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return CJS_Return(true); +} + +CJS_Return CJX_LayoutPseudoModel::sheetCount( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return NumberedPageCount(runtime, false); +} + +CJS_Return CJX_LayoutPseudoModel::absPage( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return PageInternals(runtime, params, true); +} + +CJS_Return CJX_LayoutPseudoModel::PageInternals( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params, + bool bAbsPage) { + if (params.size() != 1) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + + CXFA_Node* pNode = ToNode(runtime->ToXFAObject(params[0])); + if (!pNode) + return CJS_Return(runtime->NewNumber(0)); + + CXFA_LayoutProcessor* pDocLayout = GetDocument()->GetDocLayout(); + if (!pDocLayout) + return CJS_Return(true); + + CXFA_LayoutItem* pLayoutItem = pDocLayout->GetLayoutItem(pNode); + if (!pLayoutItem) + return CJS_Return(runtime->NewNumber(-1)); + + int32_t iPage = pLayoutItem->GetFirst()->GetPage()->GetPageIndex(); + return CJS_Return(runtime->NewNumber(bAbsPage ? iPage : iPage + 1)); +} diff --git a/fxjs/xfa/cjx_layoutpseudomodel.h b/fxjs/xfa/cjx_layoutpseudomodel.h new file mode 100644 index 0000000000..63dc789190 --- /dev/null +++ b/fxjs/xfa/cjx_layoutpseudomodel.h @@ -0,0 +1,70 @@ +// Copyright 2017 PDFium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com + +#ifndef FXJS_XFA_CJX_LAYOUTPSEUDOMODEL_H_ +#define FXJS_XFA_CJX_LAYOUTPSEUDOMODEL_H_ + +#include <vector> + +#include "fxjs/CJX_Define.h" +#include "fxjs/xfa/cjx_object.h" + +enum XFA_LAYOUTMODEL_HWXY { + XFA_LAYOUTMODEL_H, + XFA_LAYOUTMODEL_W, + XFA_LAYOUTMODEL_X, + XFA_LAYOUTMODEL_Y +}; + +class CFXJSE_Value; +class CScript_LayoutPseudoModel; +class CXFA_LayoutProcessor; +class CXFA_Node; + +class CJX_LayoutPseudoModel : public CJX_Object { + public: + explicit CJX_LayoutPseudoModel(CScript_LayoutPseudoModel* model); + ~CJX_LayoutPseudoModel() override; + + void Ready(CFXJSE_Value* pValue, bool bSetting, XFA_Attribute eAttribute); + + JS_METHOD(absPage, CJX_LayoutPseudoModel); + JS_METHOD(absPageCount, CJX_LayoutPseudoModel); + JS_METHOD(absPageCountInBatch, CJX_LayoutPseudoModel); + JS_METHOD(absPageInBatch, CJX_LayoutPseudoModel); + JS_METHOD(absPageSpan, CJX_LayoutPseudoModel); + JS_METHOD(h, CJX_LayoutPseudoModel); + JS_METHOD(page, CJX_LayoutPseudoModel); + JS_METHOD(pageContent, CJX_LayoutPseudoModel); + JS_METHOD(pageCount, CJX_LayoutPseudoModel); + JS_METHOD(pageSpan, CJX_LayoutPseudoModel); + JS_METHOD(relayout, CJX_LayoutPseudoModel); + JS_METHOD(relayoutPageArea, CJX_LayoutPseudoModel); + JS_METHOD(sheet, CJX_LayoutPseudoModel); + JS_METHOD(sheetCount, CJX_LayoutPseudoModel); + JS_METHOD(sheetCountInBatch, CJX_LayoutPseudoModel); + JS_METHOD(sheetInBatch, CJX_LayoutPseudoModel); + JS_METHOD(w, CJX_LayoutPseudoModel); + JS_METHOD(x, CJX_LayoutPseudoModel); + JS_METHOD(y, CJX_LayoutPseudoModel); + + private: + CJS_Return NumberedPageCount(CJS_V8* runtime, bool bNumbered); + CJS_Return HWXY(CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params, + XFA_LAYOUTMODEL_HWXY layoutModel); + std::vector<CXFA_Node*> GetObjArray(CXFA_LayoutProcessor* pDocLayout, + int32_t iPageNo, + const WideString& wsType, + bool bOnPageArea); + CJS_Return PageInternals(CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params, + bool bAbsPage); + + static const CJX_MethodSpec MethodSpecs[]; +}; + +#endif // FXJS_XFA_CJX_LAYOUTPSEUDOMODEL_H_ diff --git a/fxjs/xfa/cjx_list.h b/fxjs/xfa/cjx_list.h index b4a002551a..45d827c21e 100644 --- a/fxjs/xfa/cjx_list.h +++ b/fxjs/xfa/cjx_list.h @@ -8,7 +8,7 @@ #define FXJS_XFA_CJX_LIST_H_ #include "fxjs/CJX_Define.h" -#include "fxjs/cjx_object.h" +#include "fxjs/xfa/cjx_object.h" class CXFA_List; diff --git a/fxjs/xfa/cjx_logpseudomodel.cpp b/fxjs/xfa/cjx_logpseudomodel.cpp new file mode 100644 index 0000000000..e0ed05d0d1 --- /dev/null +++ b/fxjs/xfa/cjx_logpseudomodel.cpp @@ -0,0 +1,57 @@ +// Copyright 2017 PDFium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com + +#include "fxjs/xfa/cjx_logpseudomodel.h" + +#include <vector> + +#include "fxjs/cfxjse_value.h" +#include "xfa/fxfa/parser/cscript_logpseudomodel.h" + +const CJX_MethodSpec CJX_LogPseudoModel::MethodSpecs[] = { + {"message", message_static}, + {"traceEnabled", traceEnabled_static}, + {"traceActivate", traceActivate_static}, + {"traceDeactivate", traceDeactivate_static}, + {"trace", trace_static}, + {"", nullptr}}; + +CJX_LogPseudoModel::CJX_LogPseudoModel(CScript_LogPseudoModel* model) + : CJX_Object(model) { + DefineMethods(MethodSpecs); +} + +CJX_LogPseudoModel::~CJX_LogPseudoModel() {} + +CJS_Return CJX_LogPseudoModel::message( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return CJS_Return(true); +} + +CJS_Return CJX_LogPseudoModel::traceEnabled( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return CJS_Return(true); +} + +CJS_Return CJX_LogPseudoModel::traceActivate( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return CJS_Return(true); +} + +CJS_Return CJX_LogPseudoModel::traceDeactivate( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return CJS_Return(true); +} + +CJS_Return CJX_LogPseudoModel::trace( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + return CJS_Return(true); +} diff --git a/fxjs/xfa/cjx_logpseudomodel.h b/fxjs/xfa/cjx_logpseudomodel.h new file mode 100644 index 0000000000..2d98241c5a --- /dev/null +++ b/fxjs/xfa/cjx_logpseudomodel.h @@ -0,0 +1,30 @@ +// Copyright 2017 PDFium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com + +#ifndef FXJS_XFA_CJX_LOGPSEUDOMODEL_H_ +#define FXJS_XFA_CJX_LOGPSEUDOMODEL_H_ + +#include "fxjs/CJX_Define.h" +#include "fxjs/xfa/cjx_object.h" + +class CScript_LogPseudoModel; + +class CJX_LogPseudoModel : public CJX_Object { + public: + explicit CJX_LogPseudoModel(CScript_LogPseudoModel* model); + ~CJX_LogPseudoModel() override; + + JS_METHOD(message, CJX_LogPseudoModel); + JS_METHOD(traceEnabled, CJX_LogPseudoModel); + JS_METHOD(traceActivate, CJX_LogPseudoModel); + JS_METHOD(traceDeactivate, CJX_LogPseudoModel); + JS_METHOD(trace, CJX_LogPseudoModel); + + private: + static const CJX_MethodSpec MethodSpecs[]; +}; + +#endif // FXJS_XFA_CJX_LOGPSEUDOMODEL_H_ diff --git a/fxjs/xfa/cjx_manifest.h b/fxjs/xfa/cjx_manifest.h index 167ef46b6e..fd28e4065a 100644 --- a/fxjs/xfa/cjx_manifest.h +++ b/fxjs/xfa/cjx_manifest.h @@ -8,7 +8,7 @@ #define FXJS_XFA_CJX_MANIFEST_H_ #include "fxjs/CJX_Define.h" -#include "fxjs/cjx_node.h" +#include "fxjs/xfa/cjx_node.h" class CXFA_Manifest; diff --git a/fxjs/xfa/cjx_model.h b/fxjs/xfa/cjx_model.h index f4e6ac9406..17b8d3d6f5 100644 --- a/fxjs/xfa/cjx_model.h +++ b/fxjs/xfa/cjx_model.h @@ -8,7 +8,7 @@ #define FXJS_XFA_CJX_MODEL_H_ #include "fxjs/CJX_Define.h" -#include "fxjs/cjx_node.h" +#include "fxjs/xfa/cjx_node.h" class CXFA_Node; diff --git a/fxjs/xfa/cjx_node.cpp b/fxjs/xfa/cjx_node.cpp new file mode 100644 index 0000000000..dd22fb4ca3 --- /dev/null +++ b/fxjs/xfa/cjx_node.cpp @@ -0,0 +1,1874 @@ +// Copyright 2017 PDFium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com + +#include "fxjs/xfa/cjx_node.h" + +#include <map> +#include <tuple> +#include <vector> + +#include "core/fxcrt/cfx_decimal.h" +#include "core/fxcrt/cfx_memorystream.h" +#include "core/fxcrt/fx_codepage.h" +#include "core/fxcrt/fx_extension.h" +#include "core/fxcrt/xml/cfx_xmlelement.h" +#include "core/fxcrt/xml/cfx_xmlnode.h" +#include "core/fxcrt/xml/cfx_xmltext.h" +#include "fxjs/cfxjse_engine.h" +#include "fxjs/js_resources.h" +#include "xfa/fxfa/cxfa_ffnotify.h" +#include "xfa/fxfa/cxfa_ffwidget.h" +#include "xfa/fxfa/parser/cxfa_arraynodelist.h" +#include "xfa/fxfa/parser/cxfa_attachnodelist.h" +#include "xfa/fxfa/parser/cxfa_layoutprocessor.h" +#include "xfa/fxfa/parser/cxfa_measurement.h" +#include "xfa/fxfa/parser/cxfa_node.h" +#include "xfa/fxfa/parser/cxfa_occurdata.h" +#include "xfa/fxfa/parser/cxfa_simple_parser.h" +#include "xfa/fxfa/parser/xfa_utils.h" + +namespace { + +std::tuple<int32_t, int32_t, int32_t> StrToRGB(const WideString& strRGB) { + int32_t r = 0; + int32_t g = 0; + int32_t b = 0; + + size_t iIndex = 0; + for (size_t i = 0; i < strRGB.GetLength(); ++i) { + wchar_t ch = strRGB[i]; + if (ch == L',') + ++iIndex; + if (iIndex > 2) + break; + + int32_t iValue = ch - L'0'; + if (iValue >= 0 && iValue <= 9) { + switch (iIndex) { + case 0: + r = r * 10 + iValue; + break; + case 1: + g = g * 10 + iValue; + break; + default: + b = b * 10 + iValue; + break; + } + } + } + return {r, g, b}; +} + +enum class EventAppliesToo { + kNone = 0, + kAll = 1, + kAllNonRecursive = 2, + kSubform = 3, + kFieldOrExclusion = 4, + kField = 5, + kSignature = 6, + kChoiceList = 7 +}; + +struct XFA_ExecEventParaInfo { + public: + uint32_t m_uHash; + const wchar_t* m_lpcEventName; + XFA_EVENTTYPE m_eventType; + EventAppliesToo m_validFlags; +}; + +const XFA_ExecEventParaInfo gs_eventParaInfos[] = { + {0x109d7ce7, L"mouseEnter", XFA_EVENT_MouseEnter, EventAppliesToo::kField}, + {0x1bfc72d9, L"preOpen", XFA_EVENT_PreOpen, EventAppliesToo::kChoiceList}, + {0x2196a452, L"initialize", XFA_EVENT_Initialize, EventAppliesToo::kAll}, + {0x27410f03, L"mouseExit", XFA_EVENT_MouseExit, EventAppliesToo::kField}, + {0x36f1c6d8, L"preSign", XFA_EVENT_PreSign, EventAppliesToo::kSignature}, + {0x4731d6ba, L"exit", XFA_EVENT_Exit, EventAppliesToo::kAllNonRecursive}, + {0x7233018a, L"validate", XFA_EVENT_Validate, EventAppliesToo::kAll}, + {0x8808385e, L"indexChange", XFA_EVENT_IndexChange, + EventAppliesToo::kSubform}, + {0x891f4606, L"change", XFA_EVENT_Change, + EventAppliesToo::kFieldOrExclusion}, + {0x9f693b21, L"mouseDown", XFA_EVENT_MouseDown, EventAppliesToo::kField}, + {0xcdce56b3, L"full", XFA_EVENT_Full, EventAppliesToo::kFieldOrExclusion}, + {0xd576d08e, L"mouseUp", XFA_EVENT_MouseUp, EventAppliesToo::kField}, + {0xd95657a6, L"click", XFA_EVENT_Click, EventAppliesToo::kFieldOrExclusion}, + {0xdbfbe02e, L"calculate", XFA_EVENT_Calculate, EventAppliesToo::kAll}, + {0xe25fa7b8, L"postOpen", XFA_EVENT_PostOpen, EventAppliesToo::kChoiceList}, + {0xe28dce7e, L"enter", XFA_EVENT_Enter, EventAppliesToo::kAllNonRecursive}, + {0xfd54fbb7, L"postSign", XFA_EVENT_PostSign, EventAppliesToo::kSignature}, +}; + +const XFA_ExecEventParaInfo* GetEventParaInfoByName( + const WideStringView& wsEventName) { + uint32_t uHash = FX_HashCode_GetW(wsEventName, false); + int32_t iStart = 0; + int32_t iEnd = (sizeof(gs_eventParaInfos) / sizeof(gs_eventParaInfos[0])) - 1; + do { + int32_t iMid = (iStart + iEnd) / 2; + const XFA_ExecEventParaInfo* eventParaInfo = &gs_eventParaInfos[iMid]; + if (uHash == eventParaInfo->m_uHash) + return eventParaInfo; + if (uHash < eventParaInfo->m_uHash) + iEnd = iMid - 1; + else + iStart = iMid + 1; + } while (iStart <= iEnd); + return nullptr; +} + +} // namespace + +const CJX_MethodSpec CJX_Node::MethodSpecs[] = { + {"applyXSL", applyXSL_static}, + {"assignNode", assignNode_static}, + {"clone", clone_static}, + {"getAttribute", getAttribute_static}, + {"getElement", getElement_static}, + {"isPropertySpecified", isPropertySpecified_static}, + {"loadXML", loadXML_static}, + {"saveFilteredXML", saveFilteredXML_static}, + {"saveXML", saveXML_static}, + {"setAttribute", setAttribute_static}, + {"setElement", setElement_static}, + {"", nullptr}}; + +CJX_Node::CJX_Node(CXFA_Node* node) : CJX_Tree(node) { + DefineMethods(MethodSpecs); +} + +CJX_Node::~CJX_Node() = default; + +CXFA_Node* CJX_Node::GetXFANode() { + return static_cast<CXFA_Node*>(GetXFAObject()); +} + +const CXFA_Node* CJX_Node::GetXFANode() const { + return static_cast<const CXFA_Node*>(GetXFAObject()); +} + +int32_t CJX_Node::Subform_and_SubformSet_InstanceIndex() { + int32_t index = 0; + for (CXFA_Node* pNode = GetXFANode()->GetNodeItem(XFA_NODEITEM_PrevSibling); + pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) { + if ((pNode->GetElementType() != XFA_Element::Subform) && + (pNode->GetElementType() != XFA_Element::SubformSet)) { + break; + } + index++; + } + return index; +} + +int32_t CJX_Node::InstanceManager_SetInstances(int32_t iDesired) { + CXFA_OccurData occurData(GetXFANode()->GetOccurNode()); + if (iDesired < occurData.GetMin()) { + ThrowTooManyOccurancesException(L"min"); + return 1; + } + + int32_t iMax = occurData.GetMax(); + if (iMax >= 0 && iDesired > iMax) { + ThrowTooManyOccurancesException(L"max"); + return 2; + } + + int32_t iCount = GetXFANode()->GetCount(); + if (iDesired == iCount) + return 0; + + if (iDesired < iCount) { + WideString wsInstManagerName = GetCData(XFA_Attribute::Name); + WideString wsInstanceName = WideString( + wsInstManagerName.IsEmpty() + ? wsInstManagerName + : wsInstManagerName.Right(wsInstManagerName.GetLength() - 1)); + uint32_t dInstanceNameHash = + FX_HashCode_GetW(wsInstanceName.AsStringView(), false); + CXFA_Node* pPrevSibling = + iDesired == 0 ? GetXFANode() : GetXFANode()->GetItem(iDesired - 1); + while (iCount > iDesired) { + CXFA_Node* pRemoveInstance = + pPrevSibling->GetNodeItem(XFA_NODEITEM_NextSibling); + if (pRemoveInstance->GetElementType() != XFA_Element::Subform && + pRemoveInstance->GetElementType() != XFA_Element::SubformSet) { + continue; + } + if (pRemoveInstance->GetElementType() == XFA_Element::InstanceManager) { + NOTREACHED(); + break; + } + if (pRemoveInstance->GetNameHash() == dInstanceNameHash) { + GetXFANode()->RemoveItem(pRemoveInstance, true); + iCount--; + } + } + } else { + while (iCount < iDesired) { + CXFA_Node* pNewInstance = GetXFANode()->CreateInstance(true); + GetXFANode()->InsertItem(pNewInstance, iCount, iCount, false); + iCount++; + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return 0; + + pNotify->RunNodeInitialize(pNewInstance); + } + } + + CXFA_LayoutProcessor* pLayoutPro = GetDocument()->GetLayoutProcessor(); + if (pLayoutPro) { + pLayoutPro->AddChangedContainer( + ToNode(GetDocument()->GetXFAObject(XFA_HASHCODE_Form))); + } + return 0; +} + +int32_t CJX_Node::InstanceManager_MoveInstance(int32_t iTo, int32_t iFrom) { + int32_t iCount = GetXFANode()->GetCount(); + if (iFrom > iCount || iTo > iCount - 1) { + ThrowIndexOutOfBoundsException(); + return 1; + } + if (iFrom < 0 || iTo < 0 || iFrom == iTo) + return 0; + + CXFA_Node* pMoveInstance = GetXFANode()->GetItem(iFrom); + GetXFANode()->RemoveItem(pMoveInstance, false); + GetXFANode()->InsertItem(pMoveInstance, iTo, iCount - 1, true); + CXFA_LayoutProcessor* pLayoutPro = GetDocument()->GetLayoutProcessor(); + if (pLayoutPro) { + pLayoutPro->AddChangedContainer( + ToNode(GetDocument()->GetXFAObject(XFA_HASHCODE_Form))); + } + return 0; +} + +CJS_Return CJX_Node::applyXSL(CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (params.size() != 1) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + + // TODO(weili): check whether we need to implement this, pdfium:501. + return CJS_Return(true); +} + +CJS_Return CJX_Node::assignNode( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (params.empty() || params.size() > 3) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + + // TODO(weili): check whether we need to implement this, pdfium:501. + return CJS_Return(true); +} + +CJS_Return CJX_Node::clone(CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (params.size() != 1) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + + CXFA_Node* pCloneNode = GetXFANode()->Clone(runtime->ToBoolean(params[0])); + CFXJSE_Value* value = + GetDocument()->GetScriptContext()->GetJSValueFromMap(pCloneNode); + if (!value) + return CJS_Return(runtime->NewNull()); + return CJS_Return(value->DirectGetValue().Get(runtime->GetIsolate())); +} + +CJS_Return CJX_Node::getAttribute( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (params.size() != 1) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + + WideString expression = runtime->ToWideString(params[0]); + return CJS_Return(runtime->NewString( + GetAttribute(expression.AsStringView()).UTF8Encode().AsStringView())); +} + +CJS_Return CJX_Node::getElement( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (params.empty() || params.size() > 2) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + + WideString expression = runtime->ToWideString(params[0]); + int32_t iValue = params.size() >= 2 ? runtime->ToInt32(params[1]) : 0; + + CXFA_Node* pNode = + GetProperty(iValue, CXFA_Node::NameToElement(expression), true); + CFXJSE_Value* value = + GetDocument()->GetScriptContext()->GetJSValueFromMap(pNode); + if (!value) + return CJS_Return(runtime->NewNull()); + return CJS_Return(value->DirectGetValue().Get(runtime->GetIsolate())); +} + +CJS_Return CJX_Node::isPropertySpecified( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (params.empty() || params.size() > 3) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + + WideString expression = runtime->ToWideString(params[0]); + XFA_Attribute attr = CXFA_Node::NameToAttribute(expression.AsStringView()); + if (attr != XFA_Attribute::Unknown && HasAttribute(attr)) + return CJS_Return(runtime->NewBoolean(true)); + + bool bParent = params.size() < 2 || runtime->ToBoolean(params[1]); + int32_t iIndex = params.size() == 3 ? runtime->ToInt32(params[2]) : 0; + XFA_Element eType = CXFA_Node::NameToElement(expression); + bool bHas = !!GetProperty(iIndex, eType, true); + if (!bHas && bParent && GetXFANode()->GetParent()) { + // Also check on the parent. + auto* jsnode = GetXFANode()->GetParent()->JSNode(); + bHas = jsnode->HasAttribute(attr) || + !!jsnode->GetProperty(iIndex, eType, true); + } + return CJS_Return(runtime->NewBoolean(bHas)); +} + +CJS_Return CJX_Node::loadXML(CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (params.empty() || params.size() > 3) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + + ByteString expression = runtime->ToByteString(params[0]); + if (expression.IsEmpty()) + return CJS_Return(true); + + bool bIgnoreRoot = true; + if (params.size() >= 2) + bIgnoreRoot = runtime->ToBoolean(params[1]); + + bool bOverwrite = 0; + if (params.size() >= 3) + bOverwrite = runtime->ToBoolean(params[2]); + + auto pParser = pdfium::MakeUnique<CXFA_SimpleParser>(GetDocument()); + if (!pParser) + return CJS_Return(true); + + CFX_XMLNode* pXMLNode = pParser->ParseXMLData(expression); + if (!pXMLNode) + return CJS_Return(true); + + if (bIgnoreRoot && + (pXMLNode->GetType() != FX_XMLNODE_Element || + XFA_RecognizeRichText(static_cast<CFX_XMLElement*>(pXMLNode)))) { + bIgnoreRoot = false; + } + + CXFA_Node* pFakeRoot = GetXFANode()->Clone(false); + WideString wsContentType = GetCData(XFA_Attribute::ContentType); + if (!wsContentType.IsEmpty()) { + pFakeRoot->JSNode()->SetCData(XFA_Attribute::ContentType, + WideString(wsContentType), false, false); + } + + std::unique_ptr<CFX_XMLNode> pFakeXMLRoot(pFakeRoot->GetXMLMappingNode()); + if (!pFakeXMLRoot) { + CFX_XMLNode* pThisXMLRoot = GetXFANode()->GetXMLMappingNode(); + pFakeXMLRoot = pThisXMLRoot ? pThisXMLRoot->Clone() : nullptr; + } + if (!pFakeXMLRoot) { + pFakeXMLRoot = pdfium::MakeUnique<CFX_XMLElement>( + WideString(GetXFANode()->GetClassName())); + } + + if (bIgnoreRoot) { + CFX_XMLNode* pXMLChild = pXMLNode->GetNodeItem(CFX_XMLNode::FirstChild); + while (pXMLChild) { + CFX_XMLNode* pXMLSibling = + pXMLChild->GetNodeItem(CFX_XMLNode::NextSibling); + pXMLNode->RemoveChildNode(pXMLChild); + pFakeXMLRoot->InsertChildNode(pXMLChild); + pXMLChild = pXMLSibling; + } + } else { + CFX_XMLNode* pXMLParent = pXMLNode->GetNodeItem(CFX_XMLNode::Parent); + if (pXMLParent) + pXMLParent->RemoveChildNode(pXMLNode); + + pFakeXMLRoot->InsertChildNode(pXMLNode); + } + + pParser->ConstructXFANode(pFakeRoot, pFakeXMLRoot.get()); + pFakeRoot = pParser->GetRootNode(); + if (!pFakeRoot) + return CJS_Return(true); + + if (bOverwrite) { + CXFA_Node* pChild = GetXFANode()->GetNodeItem(XFA_NODEITEM_FirstChild); + CXFA_Node* pNewChild = pFakeRoot->GetNodeItem(XFA_NODEITEM_FirstChild); + int32_t index = 0; + while (pNewChild) { + CXFA_Node* pItem = pNewChild->GetNodeItem(XFA_NODEITEM_NextSibling); + pFakeRoot->RemoveChild(pNewChild, true); + GetXFANode()->InsertChild(index++, pNewChild); + pNewChild->SetFlag(XFA_NodeFlag_Initialized, true); + pNewChild = pItem; + } + + while (pChild) { + CXFA_Node* pItem = pChild->GetNodeItem(XFA_NODEITEM_NextSibling); + GetXFANode()->RemoveChild(pChild, true); + pFakeRoot->InsertChild(pChild, nullptr); + pChild = pItem; + } + + if (GetXFANode()->GetPacketType() == XFA_PacketType::Form && + GetXFANode()->GetElementType() == XFA_Element::ExData) { + CFX_XMLNode* pTempXMLNode = GetXFANode()->GetXMLMappingNode(); + GetXFANode()->SetXMLMappingNode(pFakeXMLRoot.release()); + GetXFANode()->SetFlag(XFA_NodeFlag_OwnXMLNode, false); + if (pTempXMLNode && !pTempXMLNode->GetNodeItem(CFX_XMLNode::Parent)) + pFakeXMLRoot.reset(pTempXMLNode); + else + pFakeXMLRoot = nullptr; + } + MoveBufferMapData(pFakeRoot, GetXFANode()); + } else { + CXFA_Node* pChild = pFakeRoot->GetNodeItem(XFA_NODEITEM_FirstChild); + while (pChild) { + CXFA_Node* pItem = pChild->GetNodeItem(XFA_NODEITEM_NextSibling); + pFakeRoot->RemoveChild(pChild, true); + GetXFANode()->InsertChild(pChild, nullptr); + pChild->SetFlag(XFA_NodeFlag_Initialized, true); + pChild = pItem; + } + } + + if (pFakeXMLRoot) { + pFakeRoot->SetXMLMappingNode(pFakeXMLRoot.release()); + pFakeRoot->SetFlag(XFA_NodeFlag_OwnXMLNode, false); + } + pFakeRoot->SetFlag(XFA_NodeFlag_HasRemovedChildren, false); + + return CJS_Return(true); +} + +CJS_Return CJX_Node::saveFilteredXML( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + // TODO(weili): Check whether we need to implement this, pdfium:501. + return CJS_Return(true); +} + +CJS_Return CJX_Node::saveXML(CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (params.size() > 1) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + if (params.size() == 1 && runtime->ToWideString(params[0]) != L"pretty") + return CJS_Return(JSGetStringFromID(JSMessage::kValueError)); + + // TODO(weili): Check whether we need to save pretty print XML, pdfium:501. + + WideString bsXMLHeader = L"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"; + if (GetXFANode()->GetPacketType() != XFA_PacketType::Form && + GetXFANode()->GetPacketType() != XFA_PacketType::Datasets) { + return CJS_Return(runtime->NewString("")); + } + + CFX_XMLNode* pElement = nullptr; + if (GetXFANode()->GetPacketType() == XFA_PacketType::Datasets) { + pElement = GetXFANode()->GetXMLMappingNode(); + if (!pElement || pElement->GetType() != FX_XMLNODE_Element) { + return CJS_Return( + runtime->NewString(bsXMLHeader.UTF8Encode().AsStringView())); + } + + XFA_DataExporter_DealWithDataGroupNode(GetXFANode()); + } + + auto pMemoryStream = pdfium::MakeRetain<CFX_MemoryStream>(true); + auto pStream = + pdfium::MakeRetain<CFX_SeekableStreamProxy>(pMemoryStream, true); + pStream->SetCodePage(FX_CODEPAGE_UTF8); + pStream->WriteString(bsXMLHeader.AsStringView()); + + if (GetXFANode()->GetPacketType() == XFA_PacketType::Form) + XFA_DataExporter_RegenerateFormFile(GetXFANode(), pStream, nullptr, true); + else + pElement->SaveXMLNode(pStream); + + return CJS_Return(runtime->NewString( + ByteStringView(pMemoryStream->GetBuffer(), pMemoryStream->GetSize()))); +} + +CJS_Return CJX_Node::setAttribute( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (params.size() != 2) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + + WideString attributeValue = runtime->ToWideString(params[0]); + WideString attribute = runtime->ToWideString(params[1]); + SetAttribute(attribute.AsStringView(), attributeValue.AsStringView(), true); + return CJS_Return(true); +} + +CJS_Return CJX_Node::setElement( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (params.size() != 1 && params.size() != 2) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + + // TODO(weili): check whether we need to implement this, pdfium:501. + return CJS_Return(true); +} + +void CJX_Node::Script_NodeClass_Ns(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) { + ThrowInvalidPropertyException(); + return; + } + pValue->SetString( + TryNamespace().value_or(WideString()).UTF8Encode().AsStringView()); +} + +void CJX_Node::Script_NodeClass_Model(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) { + ThrowInvalidPropertyException(); + return; + } + + pValue->Assign(GetDocument()->GetScriptContext()->GetJSValueFromMap( + GetXFANode()->GetModelNode())); +} + +void CJX_Node::Script_NodeClass_IsContainer(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) { + ThrowInvalidPropertyException(); + return; + } + + pValue->SetBoolean(GetXFANode()->IsContainerNode()); +} + +void CJX_Node::Script_NodeClass_IsNull(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) { + ThrowInvalidPropertyException(); + return; + } + if (GetXFANode()->GetElementType() == XFA_Element::Subform) { + pValue->SetBoolean(false); + return; + } + pValue->SetBoolean(GetContent(false).IsEmpty()); +} + +void CJX_Node::Script_NodeClass_OneOfChild(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) { + ThrowInvalidPropertyException(); + return; + } + + std::vector<CXFA_Node*> properties = GetXFANode()->GetNodeList( + XFA_NODEFILTER_OneOfProperty, XFA_Element::Unknown); + if (!properties.empty()) { + pValue->Assign(GetDocument()->GetScriptContext()->GetJSValueFromMap( + properties.front())); + } +} + +void CJX_Node::Script_ModelClass_Context(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) {} + +void CJX_Node::Script_ModelClass_AliasNode(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) {} + +void CJX_Node::Script_Attribute_Integer(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) { + SetInteger(eAttribute, pValue->ToInteger(), true); + return; + } + pValue->SetInteger(GetInteger(eAttribute)); +} + +void CJX_Node::Script_Attribute_IntegerRead(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) { + ThrowInvalidPropertyException(); + return; + } + pValue->SetInteger(GetInteger(eAttribute)); +} + +void CJX_Node::Script_Attribute_BOOL(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) { + SetBoolean(eAttribute, pValue->ToBoolean(), true); + return; + } + pValue->SetString(GetBoolean(eAttribute) ? "1" : "0"); +} + +void CJX_Node::Script_Attribute_BOOLRead(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) { + ThrowInvalidPropertyException(); + return; + } + pValue->SetString(GetBoolean(eAttribute) ? "1" : "0"); +} + +void CJX_Node::Script_Attribute_String(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (!bSetting) { + pValue->SetString(GetAttribute(eAttribute).UTF8Encode().AsStringView()); + return; + } + + WideString wsValue = pValue->ToWideString(); + SetAttribute(eAttribute, wsValue.AsStringView(), true); + if (eAttribute != XFA_Attribute::Use || + GetXFANode()->GetElementType() != XFA_Element::Desc) { + return; + } + + CXFA_Node* pTemplateNode = + ToNode(GetDocument()->GetXFAObject(XFA_HASHCODE_Template)); + CXFA_Node* pProtoRoot = + pTemplateNode->GetFirstChildByClass(XFA_Element::Subform) + ->GetFirstChildByClass(XFA_Element::Proto); + + WideString wsID; + WideString wsSOM; + if (!wsValue.IsEmpty()) { + if (wsValue[0] == '#') + wsID = WideString(wsValue.c_str() + 1, wsValue.GetLength() - 1); + else + wsSOM = wsValue; + } + + CXFA_Node* pProtoNode = nullptr; + if (!wsSOM.IsEmpty()) { + XFA_RESOLVENODE_RS resolveNodeRS; + bool iRet = GetDocument()->GetScriptContext()->ResolveObjects( + pProtoRoot, wsSOM.AsStringView(), &resolveNodeRS, + XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes | + XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent | + XFA_RESOLVENODE_Siblings, + nullptr); + if (iRet && resolveNodeRS.objects.front()->IsNode()) + pProtoNode = resolveNodeRS.objects.front()->AsNode(); + + } else if (!wsID.IsEmpty()) { + pProtoNode = GetDocument()->GetNodeByID(pProtoRoot, wsID.AsStringView()); + } + if (!pProtoNode) + return; + + CXFA_Node* pHeadChild = GetXFANode()->GetNodeItem(XFA_NODEITEM_FirstChild); + while (pHeadChild) { + CXFA_Node* pSibling = pHeadChild->GetNodeItem(XFA_NODEITEM_NextSibling); + GetXFANode()->RemoveChild(pHeadChild, true); + pHeadChild = pSibling; + } + + std::unique_ptr<CXFA_Node> pProtoForm(pProtoNode->CloneTemplateToForm(true)); + pHeadChild = pProtoForm->GetNodeItem(XFA_NODEITEM_FirstChild); + while (pHeadChild) { + CXFA_Node* pSibling = pHeadChild->GetNodeItem(XFA_NODEITEM_NextSibling); + pProtoForm->RemoveChild(pHeadChild, true); + GetXFANode()->InsertChild(pHeadChild, nullptr); + pHeadChild = pSibling; + } + + GetDocument()->RemovePurgeNode(pProtoForm.get()); +} + +void CJX_Node::Script_Attribute_StringRead(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) { + ThrowInvalidPropertyException(); + return; + } + pValue->SetString(GetAttribute(eAttribute).UTF8Encode().AsStringView()); +} + +void CJX_Node::Script_Delta_CurrentValue(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) {} + +void CJX_Node::Script_Delta_SavedValue(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) {} + +void CJX_Node::Script_Delta_Target(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) {} + +void CJX_Node::Script_Som_Message(CFXJSE_Value* pValue, + bool bSetting, + XFA_SOM_MESSAGETYPE iMessageType) { + CXFA_WidgetData* pWidgetData = GetXFANode()->GetWidgetData(); + if (!pWidgetData) + return; + + bool bNew = false; + CXFA_ValidateData validateData = pWidgetData->GetValidateData(false); + if (!validateData.HasValidNode()) { + validateData = pWidgetData->GetValidateData(true); + bNew = true; + } + + if (bSetting) { + switch (iMessageType) { + case XFA_SOM_ValidationMessage: + validateData.SetScriptMessageText(pValue->ToWideString()); + break; + case XFA_SOM_FormatMessage: + validateData.SetFormatMessageText(pValue->ToWideString()); + break; + case XFA_SOM_MandatoryMessage: + validateData.SetNullMessageText(pValue->ToWideString()); + break; + default: + break; + } + if (!bNew) { + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) { + return; + } + pNotify->AddCalcValidate(GetXFANode()); + } + return; + } + + WideString wsMessage; + switch (iMessageType) { + case XFA_SOM_ValidationMessage: + wsMessage = validateData.GetScriptMessageText(); + break; + case XFA_SOM_FormatMessage: + wsMessage = validateData.GetFormatMessageText(); + break; + case XFA_SOM_MandatoryMessage: + wsMessage = validateData.GetNullMessageText(); + break; + default: + break; + } + pValue->SetString(wsMessage.UTF8Encode().AsStringView()); +} + +void CJX_Node::Script_Som_ValidationMessage(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + Script_Som_Message(pValue, bSetting, XFA_SOM_ValidationMessage); +} + +void CJX_Node::Script_Field_Length(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) { + ThrowInvalidPropertyException(); + return; + } + + CXFA_WidgetData* pWidgetData = GetXFANode()->GetWidgetData(); + if (!pWidgetData) { + pValue->SetInteger(0); + return; + } + pValue->SetInteger(pWidgetData->CountChoiceListItems(true)); +} + +void CJX_Node::Script_Som_DefaultValue(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute /* unused */) { + XFA_Element eType = GetXFANode()->GetElementType(); + if (eType == XFA_Element::Field) { + Script_Field_DefaultValue(pValue, bSetting, XFA_Attribute::Unknown); + return; + } + if (eType == XFA_Element::Draw) { + Script_Draw_DefaultValue(pValue, bSetting, XFA_Attribute::Unknown); + return; + } + if (eType == XFA_Element::Boolean) { + Script_Boolean_Value(pValue, bSetting, XFA_Attribute::Unknown); + return; + } + + if (bSetting) { + WideString wsNewValue; + if (pValue && !(pValue->IsNull() || pValue->IsUndefined())) + wsNewValue = pValue->ToWideString(); + + WideString wsFormatValue(wsNewValue); + CXFA_WidgetData* pContainerWidgetData = nullptr; + if (GetXFANode()->GetPacketType() == XFA_PacketType::Datasets) { + WideString wsPicture; + for (const auto& pFormNode : *(GetXFANode()->GetBindItems())) { + if (!pFormNode || pFormNode->HasRemovedChildren()) + continue; + + pContainerWidgetData = pFormNode->GetContainerWidgetData(); + if (pContainerWidgetData) { + wsPicture = pContainerWidgetData->GetPictureContent( + XFA_VALUEPICTURE_DataBind); + } + if (!wsPicture.IsEmpty()) + break; + + pContainerWidgetData = nullptr; + } + } else if (GetXFANode()->GetPacketType() == XFA_PacketType::Form) { + pContainerWidgetData = GetXFANode()->GetContainerWidgetData(); + } + + if (pContainerWidgetData) + wsFormatValue = pContainerWidgetData->GetFormatDataValue(wsNewValue); + + SetContent(wsNewValue, wsFormatValue, true, true, true); + return; + } + + WideString content = GetContent(true); + if (content.IsEmpty() && eType != XFA_Element::Text && + eType != XFA_Element::SubmitUrl) { + pValue->SetNull(); + } else if (eType == XFA_Element::Integer) { + pValue->SetInteger(FXSYS_wtoi(content.c_str())); + } else if (eType == XFA_Element::Float || eType == XFA_Element::Decimal) { + CFX_Decimal decimal(content.AsStringView()); + pValue->SetFloat((float)(double)decimal); + } else { + pValue->SetString(content.UTF8Encode().AsStringView()); + } +} + +void CJX_Node::Script_Som_DefaultValue_Read(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) { + ThrowInvalidPropertyException(); + return; + } + + WideString content = GetContent(true); + if (content.IsEmpty()) { + pValue->SetNull(); + return; + } + pValue->SetString(content.UTF8Encode().AsStringView()); +} + +void CJX_Node::Script_Boolean_Value(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (!bSetting) { + WideString wsValue = GetContent(true); + pValue->SetBoolean(wsValue == L"1"); + return; + } + + ByteString newValue; + if (pValue && !(pValue->IsNull() || pValue->IsUndefined())) + newValue = pValue->ToString(); + + int32_t iValue = FXSYS_atoi(newValue.c_str()); + WideString wsNewValue(iValue == 0 ? L"0" : L"1"); + WideString wsFormatValue(wsNewValue); + CXFA_WidgetData* pContainerWidgetData = + GetXFANode()->GetContainerWidgetData(); + if (pContainerWidgetData) + wsFormatValue = pContainerWidgetData->GetFormatDataValue(wsNewValue); + + SetContent(wsNewValue, wsFormatValue, true, true, true); +} + +void CJX_Node::Script_Som_BorderColor(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + CXFA_WidgetData* pWidgetData = GetXFANode()->GetWidgetData(); + if (!pWidgetData) + return; + + CXFA_BorderData borderData = pWidgetData->GetBorderData(true); + int32_t iSize = borderData.CountEdges(); + if (bSetting) { + int32_t r = 0; + int32_t g = 0; + int32_t b = 0; + std::tie(r, g, b) = StrToRGB(pValue->ToWideString()); + FX_ARGB rgb = ArgbEncode(100, r, g, b); + for (int32_t i = 0; i < iSize; ++i) + borderData.GetEdgeData(i).SetColor(rgb); + + return; + } + + FX_ARGB color = borderData.GetEdgeData(0).GetColor(); + int32_t a; + int32_t r; + int32_t g; + int32_t b; + std::tie(a, r, g, b) = ArgbDecode(color); + pValue->SetString( + WideString::Format(L"%d,%d,%d", r, g, b).UTF8Encode().AsStringView()); +} + +void CJX_Node::Script_Som_BorderWidth(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + CXFA_WidgetData* pWidgetData = GetXFANode()->GetWidgetData(); + if (!pWidgetData) + return; + + CXFA_BorderData borderData = pWidgetData->GetBorderData(true); + if (bSetting) { + CXFA_Measurement thickness = borderData.GetEdgeData(0).GetMSThickness(); + pValue->SetString(thickness.ToString().UTF8Encode().AsStringView()); + return; + } + + WideString wsThickness = pValue->ToWideString(); + for (int32_t i = 0; i < borderData.CountEdges(); ++i) { + borderData.GetEdgeData(i).SetMSThickness( + CXFA_Measurement(wsThickness.AsStringView())); + } +} + +void CJX_Node::Script_Som_FillColor(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + CXFA_WidgetData* pWidgetData = GetXFANode()->GetWidgetData(); + if (!pWidgetData) + return; + + CXFA_BorderData borderData = pWidgetData->GetBorderData(true); + CXFA_FillData borderfillData = borderData.GetFillData(true); + CXFA_Node* pNode = borderfillData.GetNode(); + if (!pNode) + return; + + if (bSetting) { + int32_t r; + int32_t g; + int32_t b; + std::tie(r, g, b) = StrToRGB(pValue->ToWideString()); + FX_ARGB color = ArgbEncode(0xff, r, g, b); + borderfillData.SetColor(color); + return; + } + + FX_ARGB color = borderfillData.GetColor(false); + int32_t a; + int32_t r; + int32_t g; + int32_t b; + std::tie(a, r, g, b) = ArgbDecode(color); + pValue->SetString( + WideString::Format(L"%d,%d,%d", r, g, b).UTF8Encode().AsStringView()); +} + +void CJX_Node::Script_Som_DataNode(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) { + ThrowInvalidPropertyException(); + return; + } + + CXFA_Node* pDataNode = GetXFANode()->GetBindData(); + if (!pDataNode) { + pValue->SetNull(); + return; + } + + pValue->Assign( + GetDocument()->GetScriptContext()->GetJSValueFromMap(pDataNode)); +} + +void CJX_Node::Script_Draw_DefaultValue(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (!bSetting) { + WideString content = GetContent(true); + if (content.IsEmpty()) + pValue->SetNull(); + else + pValue->SetString(content.UTF8Encode().AsStringView()); + + return; + } + + if (!pValue || !pValue->IsString()) + return; + + CXFA_WidgetData* pWidgetData = GetXFANode()->GetWidgetData(); + XFA_Element uiType = pWidgetData->GetUIType(); + if (uiType != XFA_Element::Text) + return; + + WideString wsNewValue = pValue->ToWideString(); + SetContent(wsNewValue, wsNewValue, true, true, true); +} + +void CJX_Node::Script_Field_DefaultValue(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + CXFA_WidgetData* pWidgetData = GetXFANode()->GetWidgetData(); + if (!pWidgetData) + return; + + if (bSetting) { + if (pValue) { + pWidgetData->SetPreNull(pWidgetData->IsNull()); + pWidgetData->SetIsNull(pValue->IsNull()); + } + + WideString wsNewText; + if (pValue && !(pValue->IsNull() || pValue->IsUndefined())) + wsNewText = pValue->ToWideString(); + + CXFA_Node* pUIChild = pWidgetData->GetUIChild(); + if (pUIChild->GetElementType() == XFA_Element::NumericEdit) { + wsNewText = + pWidgetData->NumericLimit(wsNewText, pWidgetData->GetLeadDigits(), + pWidgetData->GetFracDigits()); + } + + CXFA_WidgetData* pContainerWidgetData = + GetXFANode()->GetContainerWidgetData(); + WideString wsFormatText(wsNewText); + if (pContainerWidgetData) + wsFormatText = pContainerWidgetData->GetFormatDataValue(wsNewText); + + SetContent(wsNewText, wsFormatText, true, true, true); + return; + } + + WideString content = GetContent(true); + if (content.IsEmpty()) { + pValue->SetNull(); + return; + } + + CXFA_Node* pUIChild = pWidgetData->GetUIChild(); + CXFA_Node* pNode = pWidgetData->GetFormValueData().GetNode()->GetNodeItem( + XFA_NODEITEM_FirstChild); + if (pNode && pNode->GetElementType() == XFA_Element::Decimal) { + if (pUIChild->GetElementType() == XFA_Element::NumericEdit && + (pNode->JSNode()->GetInteger(XFA_Attribute::FracDigits) == -1)) { + pValue->SetString(content.UTF8Encode().AsStringView()); + } else { + CFX_Decimal decimal(content.AsStringView()); + pValue->SetFloat((float)(double)decimal); + } + } else if (pNode && pNode->GetElementType() == XFA_Element::Integer) { + pValue->SetInteger(FXSYS_wtoi(content.c_str())); + } else if (pNode && pNode->GetElementType() == XFA_Element::Boolean) { + pValue->SetBoolean(FXSYS_wtoi(content.c_str()) == 0 ? false : true); + } else if (pNode && pNode->GetElementType() == XFA_Element::Float) { + CFX_Decimal decimal(content.AsStringView()); + pValue->SetFloat((float)(double)decimal); + } else { + pValue->SetString(content.UTF8Encode().AsStringView()); + } +} + +void CJX_Node::Script_Field_EditValue(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + CXFA_WidgetData* pWidgetData = GetXFANode()->GetWidgetData(); + if (!pWidgetData) + return; + + if (bSetting) { + pWidgetData->SetValue(XFA_VALUEPICTURE_Edit, pValue->ToWideString()); + return; + } + pValue->SetString( + pWidgetData->GetValue(XFA_VALUEPICTURE_Edit).UTF8Encode().AsStringView()); +} + +void CJX_Node::Script_Som_FontColor(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + CXFA_WidgetData* pWidgetData = GetXFANode()->GetWidgetData(); + if (!pWidgetData) + return; + + CXFA_FontData fontData = pWidgetData->GetFontData(true); + CXFA_Node* pNode = fontData.GetNode(); + if (!pNode) + return; + + if (bSetting) { + int32_t r; + int32_t g; + int32_t b; + std::tie(r, g, b) = StrToRGB(pValue->ToWideString()); + FX_ARGB color = ArgbEncode(0xff, r, g, b); + fontData.SetColor(color); + return; + } + + int32_t a; + int32_t r; + int32_t g; + int32_t b; + std::tie(a, r, g, b) = ArgbDecode(fontData.GetColor()); + pValue->SetString(ByteString::Format("%d,%d,%d", r, g, b).AsStringView()); +} + +void CJX_Node::Script_Field_FormatMessage(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + Script_Som_Message(pValue, bSetting, XFA_SOM_FormatMessage); +} + +void CJX_Node::Script_Field_FormattedValue(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + CXFA_WidgetData* pWidgetData = GetXFANode()->GetWidgetData(); + if (!pWidgetData) + return; + + if (bSetting) { + pWidgetData->SetValue(XFA_VALUEPICTURE_Display, pValue->ToWideString()); + return; + } + pValue->SetString(pWidgetData->GetValue(XFA_VALUEPICTURE_Display) + .UTF8Encode() + .AsStringView()); +} + +void CJX_Node::Script_Som_Mandatory(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + CXFA_WidgetData* pWidgetData = GetXFANode()->GetWidgetData(); + if (!pWidgetData) + return; + + CXFA_ValidateData validateData = pWidgetData->GetValidateData(true); + if (bSetting) { + validateData.SetNullTest(pValue->ToWideString()); + return; + } + + WideString str = CXFA_Node::AttributeEnumToName(validateData.GetNullTest()); + pValue->SetString(str.UTF8Encode().AsStringView()); +} + +void CJX_Node::Script_Som_MandatoryMessage(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + Script_Som_Message(pValue, bSetting, XFA_SOM_MandatoryMessage); +} + +void CJX_Node::Script_Field_ParentSubform(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) { + ThrowInvalidPropertyException(); + return; + } + pValue->SetNull(); +} + +void CJX_Node::Script_Field_SelectedIndex(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + CXFA_WidgetData* pWidgetData = GetXFANode()->GetWidgetData(); + if (!pWidgetData) + return; + + if (!bSetting) { + pValue->SetInteger(pWidgetData->GetSelectedItem(0)); + return; + } + + int32_t iIndex = pValue->ToInteger(); + if (iIndex == -1) { + pWidgetData->ClearAllSelections(); + return; + } + + pWidgetData->SetItemState(iIndex, true, true, true, true); +} + +void CJX_Node::Script_ExclGroup_ErrorText(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) + ThrowInvalidPropertyException(); +} + +void CJX_Node::Script_ExclGroup_DefaultAndRawValue(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + CXFA_WidgetData* pWidgetData = GetXFANode()->GetWidgetData(); + if (!pWidgetData) + return; + + if (bSetting) { + pWidgetData->SetSelectedMemberByValue(pValue->ToWideString().AsStringView(), + true, true, true); + return; + } + + WideString wsValue = GetContent(true); + XFA_VERSION curVersion = GetDocument()->GetCurVersionMode(); + if (wsValue.IsEmpty() && curVersion >= XFA_VERSION_300) { + pValue->SetNull(); + return; + } + pValue->SetString(wsValue.UTF8Encode().AsStringView()); +} + +void CJX_Node::Script_ExclGroup_Transient(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) {} + +void CJX_Node::Script_Som_InstanceIndex(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (!bSetting) { + pValue->SetInteger(Subform_and_SubformSet_InstanceIndex()); + return; + } + + int32_t iTo = pValue->ToInteger(); + int32_t iFrom = Subform_and_SubformSet_InstanceIndex(); + CXFA_Node* pManagerNode = nullptr; + for (CXFA_Node* pNode = GetXFANode()->GetNodeItem(XFA_NODEITEM_PrevSibling); + pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) { + if (pNode->GetElementType() == XFA_Element::InstanceManager) { + pManagerNode = pNode; + break; + } + } + if (!pManagerNode) + return; + + pManagerNode->JSNode()->InstanceManager_MoveInstance(iTo, iFrom); + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return; + + CXFA_Node* pToInstance = pManagerNode->GetItem(iTo); + if (pToInstance && pToInstance->GetElementType() == XFA_Element::Subform) { + pNotify->RunSubformIndexChange(pToInstance); + } + + CXFA_Node* pFromInstance = pManagerNode->GetItem(iFrom); + if (pFromInstance && + pFromInstance->GetElementType() == XFA_Element::Subform) { + pNotify->RunSubformIndexChange(pFromInstance); + } +} + +void CJX_Node::Script_Subform_InstanceManager(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) { + ThrowInvalidPropertyException(); + return; + } + + WideString wsName = GetCData(XFA_Attribute::Name); + CXFA_Node* pInstanceMgr = nullptr; + for (CXFA_Node* pNode = GetXFANode()->GetNodeItem(XFA_NODEITEM_PrevSibling); + pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) { + if (pNode->GetElementType() == XFA_Element::InstanceManager) { + WideString wsInstMgrName = pNode->JSNode()->GetCData(XFA_Attribute::Name); + if (wsInstMgrName.GetLength() >= 1 && wsInstMgrName[0] == '_' && + wsInstMgrName.Right(wsInstMgrName.GetLength() - 1) == wsName) { + pInstanceMgr = pNode; + } + break; + } + } + if (!pInstanceMgr) { + pValue->SetNull(); + return; + } + + pValue->Assign( + GetDocument()->GetScriptContext()->GetJSValueFromMap(pInstanceMgr)); +} + +void CJX_Node::Script_Subform_Locale(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) { + SetCData(XFA_Attribute::Locale, pValue->ToWideString(), true, true); + return; + } + + WideString wsLocaleName; + GetXFANode()->GetLocaleName(wsLocaleName); + pValue->SetString(wsLocaleName.UTF8Encode().AsStringView()); +} + +void CJX_Node::Script_InstanceManager_Max(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) { + ThrowInvalidPropertyException(); + return; + } + pValue->SetInteger(CXFA_OccurData(GetXFANode()->GetOccurNode()).GetMax()); +} + +void CJX_Node::Script_InstanceManager_Min(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) { + ThrowInvalidPropertyException(); + return; + } + pValue->SetInteger(CXFA_OccurData(GetXFANode()->GetOccurNode()).GetMin()); +} + +void CJX_Node::Script_InstanceManager_Count(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) { + pValue->SetInteger(GetXFANode()->GetCount()); + return; + } + InstanceManager_SetInstances(pValue->ToInteger()); +} + +void CJX_Node::Script_Occur_Max(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + CXFA_OccurData occurData(GetXFANode()); + if (!bSetting) { + pValue->SetInteger(occurData.GetMax()); + return; + } + occurData.SetMax(pValue->ToInteger()); +} + +void CJX_Node::Script_Occur_Min(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + CXFA_OccurData occurData(GetXFANode()); + if (!bSetting) { + pValue->SetInteger(occurData.GetMin()); + return; + } + occurData.SetMin(pValue->ToInteger()); +} + +void CJX_Node::Script_Form_Checksum(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) { + SetAttribute(XFA_Attribute::Checksum, pValue->ToWideString().AsStringView(), + false); + return; + } + + pdfium::Optional<WideString> checksum = + TryAttribute(XFA_Attribute::Checksum, false); + pValue->SetString(checksum ? checksum->UTF8Encode().AsStringView() : ""); +} + +void CJX_Node::Script_Packet_Content(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + CFX_XMLNode* pXMLNode = GetXFANode()->GetXMLMappingNode(); + if (bSetting) { + if (pXMLNode && pXMLNode->GetType() == FX_XMLNODE_Element) { + CFX_XMLElement* pXMLElement = static_cast<CFX_XMLElement*>(pXMLNode); + pXMLElement->SetTextData(pValue->ToWideString()); + } + return; + } + + WideString wsTextData; + if (pXMLNode && pXMLNode->GetType() == FX_XMLNODE_Element) { + CFX_XMLElement* pXMLElement = static_cast<CFX_XMLElement*>(pXMLNode); + wsTextData = pXMLElement->GetTextData(); + } + + pValue->SetString(wsTextData.UTF8Encode().AsStringView()); +} + +void CJX_Node::Script_Source_Db(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) {} + +void CJX_Node::Script_Xfa_This(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) + return; + + CXFA_Object* pThis = GetDocument()->GetScriptContext()->GetThisObject(); + ASSERT(pThis); + pValue->Assign(GetDocument()->GetScriptContext()->GetJSValueFromMap(pThis)); +} + +void CJX_Node::Script_Handler_Version(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) {} + +void CJX_Node::Script_SubmitFormat_Mode(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) {} + +void CJX_Node::Script_Extras_Type(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) {} + +void CJX_Node::Script_Script_Stateless(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) { + ThrowInvalidPropertyException(); + return; + } + pValue->SetString(FX_UTF8Encode(WideStringView(L"0", 1)).AsStringView()); +} + +void CJX_Node::Script_Encrypt_Format(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) {} + +void CJX_Node::SetWidgetData(std::unique_ptr<CXFA_WidgetData> data) { + widget_data_ = std::move(data); +} + +pdfium::Optional<WideString> CJX_Node::TryNamespace() { + if (GetXFANode()->IsModelNode() || + GetXFANode()->GetElementType() == XFA_Element::Packet) { + CFX_XMLNode* pXMLNode = GetXFANode()->GetXMLMappingNode(); + if (!pXMLNode || pXMLNode->GetType() != FX_XMLNODE_Element) + return {}; + + return {static_cast<CFX_XMLElement*>(pXMLNode)->GetNamespaceURI()}; + } + + if (GetXFANode()->GetPacketType() != XFA_PacketType::Datasets) + return GetXFANode()->GetModelNode()->JSNode()->TryNamespace(); + + CFX_XMLNode* pXMLNode = GetXFANode()->GetXMLMappingNode(); + if (!pXMLNode || pXMLNode->GetType() != FX_XMLNODE_Element) + return {}; + + if (GetXFANode()->GetElementType() == XFA_Element::DataValue && + GetEnum(XFA_Attribute::Contains) == XFA_AttributeEnum::MetaData) { + WideString wsNamespace; + bool ret = XFA_FDEExtension_ResolveNamespaceQualifier( + static_cast<CFX_XMLElement*>(pXMLNode), + GetCData(XFA_Attribute::QualifiedName), &wsNamespace); + if (!ret) + return {}; + return {wsNamespace}; + } + return {static_cast<CFX_XMLElement*>(pXMLNode)->GetNamespaceURI()}; +} + +CXFA_Node* CJX_Node::GetProperty(int32_t index, + XFA_Element eProperty, + bool bCreateProperty) { + if (index < 0 || index >= GetXFANode()->PropertyOccuranceCount(eProperty)) + return nullptr; + + int32_t iCount = 0; + for (CXFA_Node* pNode = GetXFANode()->GetChildNode(); pNode; + pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { + if (pNode->GetElementType() == eProperty) { + iCount++; + if (iCount > index) + return pNode; + } + } + if (!bCreateProperty) + return nullptr; + + if (GetXFANode()->HasPropertyFlags(eProperty, XFA_PROPERTYFLAG_OneOf)) { + for (CXFA_Node* pNode = GetXFANode()->GetChildNode(); pNode; + pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { + if (GetXFANode()->HasPropertyFlags(pNode->GetElementType(), + XFA_PROPERTYFLAG_OneOf)) { + return nullptr; + } + } + } + + CXFA_Node* pNewNode = nullptr; + for (; iCount <= index; ++iCount) { + pNewNode = + GetDocument()->CreateNode(GetXFANode()->GetPacketType(), eProperty); + if (!pNewNode) + return nullptr; + GetXFANode()->InsertChild(pNewNode, nullptr); + pNewNode->SetFlag(XFA_NodeFlag_Initialized, true); + } + return pNewNode; +} + +int32_t CJX_Node::execSingleEventByName(const WideStringView& wsEventName, + XFA_Element eType) { + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (!pNotify) + return XFA_EVENTERROR_NotExist; + + const XFA_ExecEventParaInfo* eventParaInfo = + GetEventParaInfoByName(wsEventName); + if (!eventParaInfo) + return XFA_EVENTERROR_NotExist; + + switch (eventParaInfo->m_validFlags) { + case EventAppliesToo::kNone: + return XFA_EVENTERROR_NotExist; + case EventAppliesToo::kAll: + case EventAppliesToo::kAllNonRecursive: + return pNotify->ExecEventByDeepFirst( + GetXFANode(), eventParaInfo->m_eventType, false, + eventParaInfo->m_validFlags == EventAppliesToo::kAll); + case EventAppliesToo::kSubform: + if (eType != XFA_Element::Subform) + return XFA_EVENTERROR_NotExist; + + return pNotify->ExecEventByDeepFirst( + GetXFANode(), eventParaInfo->m_eventType, false, false); + case EventAppliesToo::kFieldOrExclusion: { + if (eType != XFA_Element::ExclGroup && eType != XFA_Element::Field) + return XFA_EVENTERROR_NotExist; + + CXFA_Node* pParentNode = GetXFANode()->GetNodeItem(XFA_NODEITEM_Parent); + if (pParentNode && + pParentNode->GetElementType() == XFA_Element::ExclGroup) { + // TODO(dsinclair): This seems like a bug, we do the same work twice? + pNotify->ExecEventByDeepFirst(GetXFANode(), eventParaInfo->m_eventType, + false, false); + } + return pNotify->ExecEventByDeepFirst( + GetXFANode(), eventParaInfo->m_eventType, false, false); + } + case EventAppliesToo::kField: + if (eType != XFA_Element::Field) + return XFA_EVENTERROR_NotExist; + + return pNotify->ExecEventByDeepFirst( + GetXFANode(), eventParaInfo->m_eventType, false, false); + case EventAppliesToo::kSignature: { + CXFA_WidgetData* pWidgetData = GetXFANode()->GetWidgetData(); + if (!pWidgetData) + return XFA_EVENTERROR_NotExist; + + CXFA_Node* pUINode = pWidgetData->GetUIChild(); + if (pUINode->GetElementType() != XFA_Element::Signature) + return XFA_EVENTERROR_NotExist; + + return pNotify->ExecEventByDeepFirst( + GetXFANode(), eventParaInfo->m_eventType, false, false); + } + case EventAppliesToo::kChoiceList: { + CXFA_WidgetData* pWidgetData = GetXFANode()->GetWidgetData(); + if (!pWidgetData) + return XFA_EVENTERROR_NotExist; + + CXFA_Node* pUINode = pWidgetData->GetUIChild(); + if (pUINode->GetElementType() != XFA_Element::ChoiceList || + pWidgetData->IsListBox()) { + return XFA_EVENTERROR_NotExist; + } + return pNotify->ExecEventByDeepFirst( + GetXFANode(), eventParaInfo->m_eventType, false, false); + } + } + return XFA_EVENTERROR_NotExist; +} + +void CJX_Node::ThrowMissingPropertyException(const WideString& obj, + const WideString& prop) const { + ThrowException(L"'%ls' doesn't have property '%ls'.", obj.c_str(), + prop.c_str()); +} + +void CJX_Node::ThrowTooManyOccurancesException(const WideString& obj) const { + ThrowException( + L"The element [%ls] has violated its allowable number of occurrences.", + obj.c_str()); +} + +bool CJX_Node::SetContent(const WideString& wsContent, + const WideString& wsXMLValue, + bool bNotify, + bool bScriptModify, + bool bSyncData) { + CXFA_Node* pNode = nullptr; + CXFA_Node* pBindNode = nullptr; + switch (GetXFANode()->GetObjectType()) { + case XFA_ObjectType::ContainerNode: { + if (XFA_FieldIsMultiListBox(GetXFANode())) { + CXFA_Node* pValue = GetProperty(0, XFA_Element::Value, true); + if (!pValue) + break; + + CXFA_Node* pChildValue = pValue->GetNodeItem(XFA_NODEITEM_FirstChild); + ASSERT(pChildValue); + pChildValue->JSNode()->SetCData(XFA_Attribute::ContentType, L"text/xml", + false, false); + pChildValue->JSNode()->SetContent(wsContent, wsContent, bNotify, + bScriptModify, false); + CXFA_Node* pBind = GetXFANode()->GetBindData(); + if (bSyncData && pBind) { + std::vector<WideString> wsSaveTextArray; + size_t iSize = 0; + if (!wsContent.IsEmpty()) { + size_t iStart = 0; + size_t iLength = wsContent.GetLength(); + auto iEnd = wsContent.Find(L'\n', iStart); + iEnd = !iEnd.has_value() ? iLength : iEnd; + while (iEnd.value() >= iStart) { + wsSaveTextArray.push_back( + wsContent.Mid(iStart, iEnd.value() - iStart)); + iStart = iEnd.value() + 1; + if (iStart >= iLength) + break; + + iEnd = wsContent.Find(L'\n', iStart); + if (!iEnd.has_value()) { + wsSaveTextArray.push_back( + wsContent.Mid(iStart, iLength - iStart)); + } + } + iSize = wsSaveTextArray.size(); + } + if (iSize == 0) { + while (CXFA_Node* pChildNode = + pBind->GetNodeItem(XFA_NODEITEM_FirstChild)) { + pBind->RemoveChild(pChildNode, true); + } + } else { + std::vector<CXFA_Node*> valueNodes = pBind->GetNodeList( + XFA_NODEFILTER_Children, XFA_Element::DataValue); + size_t iDatas = valueNodes.size(); + if (iDatas < iSize) { + size_t iAddNodes = iSize - iDatas; + CXFA_Node* pValueNodes = nullptr; + while (iAddNodes-- > 0) { + pValueNodes = + pBind->CreateSamePacketNode(XFA_Element::DataValue); + pValueNodes->JSNode()->SetCData(XFA_Attribute::Name, L"value", + false, false); + pValueNodes->CreateXMLMappingNode(); + pBind->InsertChild(pValueNodes, nullptr); + } + pValueNodes = nullptr; + } else if (iDatas > iSize) { + size_t iDelNodes = iDatas - iSize; + while (iDelNodes-- > 0) { + pBind->RemoveChild(pBind->GetNodeItem(XFA_NODEITEM_FirstChild), + true); + } + } + int32_t i = 0; + for (CXFA_Node* pValueNode = + pBind->GetNodeItem(XFA_NODEITEM_FirstChild); + pValueNode; pValueNode = pValueNode->GetNodeItem( + XFA_NODEITEM_NextSibling)) { + pValueNode->JSNode()->SetAttributeValue( + wsSaveTextArray[i], wsSaveTextArray[i], false, false); + i++; + } + } + for (const auto& pArrayNode : *(pBind->GetBindItems())) { + if (pArrayNode.Get() != GetXFANode()) { + pArrayNode->JSNode()->SetContent(wsContent, wsContent, bNotify, + bScriptModify, false); + } + } + } + break; + } + if (GetXFANode()->GetElementType() == XFA_Element::ExclGroup) { + pNode = GetXFANode(); + } else { + CXFA_Node* pValue = GetProperty(0, XFA_Element::Value, true); + if (!pValue) + break; + + CXFA_Node* pChildValue = pValue->GetNodeItem(XFA_NODEITEM_FirstChild); + ASSERT(pChildValue); + pChildValue->JSNode()->SetContent(wsContent, wsContent, bNotify, + bScriptModify, false); + } + pBindNode = GetXFANode()->GetBindData(); + if (pBindNode && bSyncData) { + pBindNode->JSNode()->SetContent(wsContent, wsXMLValue, bNotify, + bScriptModify, false); + for (const auto& pArrayNode : *(pBindNode->GetBindItems())) { + if (pArrayNode.Get() != GetXFANode()) { + pArrayNode->JSNode()->SetContent(wsContent, wsContent, bNotify, + true, false); + } + } + } + pBindNode = nullptr; + break; + } + case XFA_ObjectType::ContentNode: { + WideString wsContentType; + if (GetXFANode()->GetElementType() == XFA_Element::ExData) { + pdfium::Optional<WideString> ret = + TryAttribute(XFA_Attribute::ContentType, false); + if (ret) + wsContentType = *ret; + if (wsContentType == L"text/html") { + wsContentType = L""; + SetAttribute(XFA_Attribute::ContentType, wsContentType.AsStringView(), + false); + } + } + + CXFA_Node* pContentRawDataNode = + GetXFANode()->GetNodeItem(XFA_NODEITEM_FirstChild); + if (!pContentRawDataNode) { + pContentRawDataNode = GetXFANode()->CreateSamePacketNode( + (wsContentType == L"text/xml") ? XFA_Element::Sharpxml + : XFA_Element::Sharptext); + GetXFANode()->InsertChild(pContentRawDataNode, nullptr); + } + return pContentRawDataNode->JSNode()->SetContent( + wsContent, wsXMLValue, bNotify, bScriptModify, bSyncData); + } + case XFA_ObjectType::NodeC: + case XFA_ObjectType::TextNode: + pNode = GetXFANode(); + break; + case XFA_ObjectType::NodeV: + pNode = GetXFANode(); + if (bSyncData && GetXFANode()->GetPacketType() == XFA_PacketType::Form) { + CXFA_Node* pParent = GetXFANode()->GetNodeItem(XFA_NODEITEM_Parent); + if (pParent) { + pParent = pParent->GetNodeItem(XFA_NODEITEM_Parent); + } + if (pParent && pParent->GetElementType() == XFA_Element::Value) { + pParent = pParent->GetNodeItem(XFA_NODEITEM_Parent); + if (pParent && pParent->IsContainerNode()) { + pBindNode = pParent->GetBindData(); + if (pBindNode) { + pBindNode->JSNode()->SetContent(wsContent, wsXMLValue, bNotify, + bScriptModify, false); + } + } + } + } + break; + default: + if (GetXFANode()->GetElementType() == XFA_Element::DataValue) { + pNode = GetXFANode(); + pBindNode = GetXFANode(); + } + break; + } + if (!pNode) + return false; + + SetAttributeValue(wsContent, wsXMLValue, bNotify, bScriptModify); + if (pBindNode && bSyncData) { + for (const auto& pArrayNode : *(pBindNode->GetBindItems())) { + pArrayNode->JSNode()->SetContent(wsContent, wsContent, bNotify, + bScriptModify, false); + } + } + return true; +} + +WideString CJX_Node::GetContent(bool bScriptModify) { + return TryContent(bScriptModify, true).value_or(WideString()); +} + +pdfium::Optional<WideString> CJX_Node::TryContent(bool bScriptModify, + bool bProto) { + CXFA_Node* pNode = nullptr; + switch (GetXFANode()->GetObjectType()) { + case XFA_ObjectType::ContainerNode: + if (GetXFANode()->GetElementType() == XFA_Element::ExclGroup) { + pNode = GetXFANode(); + } else { + CXFA_Node* pValue = + GetXFANode()->GetChild(0, XFA_Element::Value, false); + if (!pValue) + return {}; + + CXFA_Node* pChildValue = pValue->GetNodeItem(XFA_NODEITEM_FirstChild); + if (pChildValue && XFA_FieldIsMultiListBox(GetXFANode())) { + pChildValue->JSNode()->SetAttribute(XFA_Attribute::ContentType, + L"text/xml", false); + } + if (pChildValue) + return pChildValue->JSNode()->TryContent(bScriptModify, bProto); + return {}; + } + break; + case XFA_ObjectType::ContentNode: { + CXFA_Node* pContentRawDataNode = + GetXFANode()->GetNodeItem(XFA_NODEITEM_FirstChild); + if (!pContentRawDataNode) { + XFA_Element element = XFA_Element::Sharptext; + if (GetXFANode()->GetElementType() == XFA_Element::ExData) { + pdfium::Optional<WideString> contentType = + TryAttribute(XFA_Attribute::ContentType, false); + if (contentType) { + if (*contentType == L"text/html") + element = XFA_Element::SharpxHTML; + else if (*contentType == L"text/xml") + element = XFA_Element::Sharpxml; + } + } + pContentRawDataNode = GetXFANode()->CreateSamePacketNode(element); + GetXFANode()->InsertChild(pContentRawDataNode, nullptr); + } + return pContentRawDataNode->JSNode()->TryContent(bScriptModify, true); + } + case XFA_ObjectType::NodeC: + case XFA_ObjectType::NodeV: + case XFA_ObjectType::TextNode: + pNode = GetXFANode(); + default: + if (GetXFANode()->GetElementType() == XFA_Element::DataValue) + pNode = GetXFANode(); + break; + } + if (pNode) { + if (bScriptModify) { + CFXJSE_Engine* pScriptContext = GetDocument()->GetScriptContext(); + if (pScriptContext) + GetDocument()->GetScriptContext()->AddNodesOfRunScript(GetXFANode()); + } + return TryCData(XFA_Attribute::Value, false); + } + return {}; +} diff --git a/fxjs/xfa/cjx_node.h b/fxjs/xfa/cjx_node.h new file mode 100644 index 0000000000..a18166fbc9 --- /dev/null +++ b/fxjs/xfa/cjx_node.h @@ -0,0 +1,266 @@ +// Copyright 2017 PDFium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com + +#ifndef FXJS_XFA_CJX_NODE_H_ +#define FXJS_XFA_CJX_NODE_H_ + +#include <memory> +#include <utility> +#include <vector> + +#include "core/fxcrt/unowned_ptr.h" +#include "fxjs/CJX_Define.h" +#include "fxjs/xfa/cjx_object.h" +#include "fxjs/xfa/cjx_tree.h" +#include "xfa/fxfa/fxfa_basic.h" + +enum XFA_SOM_MESSAGETYPE { + XFA_SOM_ValidationMessage, + XFA_SOM_FormatMessage, + XFA_SOM_MandatoryMessage +}; + +class CXFA_LayoutItem; +class CXFA_Node; +class CXFA_WidgetData; + +class CJX_Node : public CJX_Tree { + public: + explicit CJX_Node(CXFA_Node* node); + ~CJX_Node() override; + + CXFA_Node* GetXFANode(); + const CXFA_Node* GetXFANode() const; + + CXFA_Node* GetProperty(int32_t index, + XFA_Element eType, + bool bCreateProperty); + + pdfium::Optional<WideString> TryContent(bool bScriptModify, bool bProto); + bool SetContent(const WideString& wsContent, + const WideString& wsXMLValue, + bool bNotify, + bool bScriptModify, + bool bSyncData); + WideString GetContent(bool bScriptModify); + + void SetWidgetData(std::unique_ptr<CXFA_WidgetData> data); + CXFA_WidgetData* GetWidgetData() const { return widget_data_.get(); } + + void SetLayoutItem(CXFA_LayoutItem* item) { layout_item_ = item; } + CXFA_LayoutItem* GetLayoutItem() const { return layout_item_.Get(); } + + void SetCalcRecursionCount(size_t count) { calc_recursion_count_ = count; } + size_t GetCalcRecursionCount() const { return calc_recursion_count_; } + + pdfium::Optional<WideString> TryNamespace(); + + void ThrowMissingPropertyException(const WideString& obj, + const WideString& prop) const; + void ThrowTooManyOccurancesException(const WideString& obj) const; + + int32_t Subform_and_SubformSet_InstanceIndex(); + int32_t InstanceManager_SetInstances(int32_t iDesired); + int32_t InstanceManager_MoveInstance(int32_t iTo, int32_t iFrom); + + JS_METHOD(applyXSL, CJX_Node); + JS_METHOD(assignNode, CJX_Node); + JS_METHOD(clone, CJX_Node); + JS_METHOD(getAttribute, CJX_Node); + JS_METHOD(getElement, CJX_Node); + JS_METHOD(isPropertySpecified, CJX_Node); + JS_METHOD(loadXML, CJX_Node); + JS_METHOD(saveFilteredXML, CJX_Node); + JS_METHOD(saveXML, CJX_Node); + JS_METHOD(setAttribute, CJX_Node); + JS_METHOD(setElement, CJX_Node); + + void Script_NodeClass_Ns(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_NodeClass_Model(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_NodeClass_IsContainer(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_NodeClass_IsNull(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_NodeClass_OneOfChild(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_ModelClass_Context(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_ModelClass_AliasNode(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Delta_CurrentValue(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Delta_SavedValue(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Delta_Target(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Attribute_Integer(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Attribute_IntegerRead(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Attribute_BOOL(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Attribute_BOOLRead(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Attribute_String(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Attribute_StringRead(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Som_ValidationMessage(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Field_Length(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Som_DefaultValue(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Som_DefaultValue_Read(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Boolean_Value(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Som_Message(CFXJSE_Value* pValue, + bool bSetting, + XFA_SOM_MESSAGETYPE iMessageType); + void Script_Som_BorderColor(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Som_BorderWidth(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Som_FillColor(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Som_DataNode(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Som_FontColor(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Som_Mandatory(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Som_MandatoryMessage(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Som_InstanceIndex(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Draw_DefaultValue(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Field_DefaultValue(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Field_EditValue(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Field_FormatMessage(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Field_FormattedValue(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Field_ParentSubform(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Field_SelectedIndex(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_ExclGroup_DefaultAndRawValue(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_ExclGroup_ErrorText(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_ExclGroup_Transient(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + + void Script_Subform_InstanceManager(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Subform_Locale(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_InstanceManager_Count(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_InstanceManager_Max(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_InstanceManager_Min(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + + void Script_Occur_Max(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Occur_Min(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + + void Script_Form_Checksum(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + + void Script_Packet_Content(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + + void Script_Source_Db(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Xfa_This(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Handler_Version(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_SubmitFormat_Mode(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Extras_Type(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Encrypt_Format(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + void Script_Script_Stateless(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + + protected: + int32_t execSingleEventByName(const WideStringView& wsEventName, + XFA_Element eType); + + private: + std::unique_ptr<CXFA_WidgetData> widget_data_; + UnownedPtr<CXFA_LayoutItem> layout_item_; + size_t calc_recursion_count_ = 0; + static const CJX_MethodSpec MethodSpecs[]; +}; + +#endif // FXJS_XFA_CJX_NODE_H_ diff --git a/fxjs/xfa/cjx_object.cpp b/fxjs/xfa/cjx_object.cpp new file mode 100644 index 0000000000..81ba1ac3d2 --- /dev/null +++ b/fxjs/xfa/cjx_object.cpp @@ -0,0 +1,806 @@ +// Copyright 2017 PDFium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com + +#include "fxjs/xfa/cjx_object.h" + +#include <utility> + +#include "core/fxcrt/fx_extension.h" +#include "core/fxcrt/xml/cfx_xmltext.h" +#include "fxjs/cfxjse_engine.h" +#include "fxjs/cfxjse_value.h" +#include "fxjs/cjs_return.h" +#include "third_party/base/ptr_util.h" +#include "xfa/fxfa/cxfa_ffnotify.h" +#include "xfa/fxfa/cxfa_ffwidget.h" +#include "xfa/fxfa/parser/cxfa_document.h" +#include "xfa/fxfa/parser/cxfa_measurement.h" +#include "xfa/fxfa/parser/cxfa_node.h" +#include "xfa/fxfa/parser/cxfa_object.h" + +namespace { + +void XFA_DeleteWideString(void* pData) { + delete static_cast<WideString*>(pData); +} + +void XFA_CopyWideString(void*& pData) { + if (!pData) + return; + pData = new WideString(*reinterpret_cast<WideString*>(pData)); +} + +XFA_MAPDATABLOCKCALLBACKINFO deleteWideStringCallBack = {XFA_DeleteWideString, + XFA_CopyWideString}; + +enum XFA_KEYTYPE { + XFA_KEYTYPE_Custom, + XFA_KEYTYPE_Element, +}; + +void* GetMapKey_Custom(const WideStringView& wsKey) { + uint32_t dwKey = FX_HashCode_GetW(wsKey, false); + return (void*)(uintptr_t)((dwKey << 1) | XFA_KEYTYPE_Custom); +} + +void* GetMapKey_Element(XFA_Element eType, XFA_Attribute eAttribute) { + return (void*)(uintptr_t)((static_cast<uint32_t>(eType) << 16) | + (static_cast<uint32_t>(eAttribute) << 8) | + XFA_KEYTYPE_Element); +} + +void XFA_DefaultFreeData(void* pData) {} + +XFA_MAPDATABLOCKCALLBACKINFO gs_XFADefaultFreeData = {XFA_DefaultFreeData, + nullptr}; + +} // namespace + +struct XFA_MAPDATABLOCK { + uint8_t* GetData() const { return (uint8_t*)this + sizeof(XFA_MAPDATABLOCK); } + + XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo; + int32_t iBytes; +}; + +struct XFA_MAPMODULEDATA { + XFA_MAPMODULEDATA() {} + ~XFA_MAPMODULEDATA() {} + + std::map<void*, void*> m_ValueMap; + std::map<void*, XFA_MAPDATABLOCK*> m_BufferMap; +}; + +CJX_Object::CJX_Object(CXFA_Object* obj) : object_(obj) {} + +CJX_Object::~CJX_Object() { + ClearMapModuleBuffer(); +} + +void CJX_Object::DefineMethods(const CJX_MethodSpec method_specs[]) { + for (size_t i = 0; method_specs[i].pMethodCall != nullptr; ++i) + method_specs_[method_specs[i].pName] = method_specs[i].pMethodCall; +} + +CXFA_Document* CJX_Object::GetDocument() const { + return object_->GetDocument(); +} + +void CJX_Object::Script_ObjectClass_ClassName(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute) { + if (bSetting) { + ThrowInvalidPropertyException(); + return; + } + pValue->SetString( + FX_UTF8Encode(GetXFAObject()->GetClassName()).AsStringView()); +} + +bool CJX_Object::HasMethod(const WideString& func) const { + return pdfium::ContainsKey(method_specs_, func.UTF8Encode()); +} + +CJS_Return CJX_Object::RunMethod( + const WideString& func, + const std::vector<v8::Local<v8::Value>>& params) { + auto it = method_specs_.find(func.UTF8Encode()); + if (it == method_specs_.end()) + return CJS_Return(false); + return it->second(this, GetXFAObject()->GetDocument()->GetScriptContext(), + params); +} + +void CJX_Object::ThrowInvalidPropertyException() const { + ThrowException(L"Invalid property set operation."); +} + +void CJX_Object::ThrowIndexOutOfBoundsException() const { + ThrowException(L"Index value is out of bounds."); +} + +void CJX_Object::ThrowParamCountMismatchException( + const WideString& method) const { + ThrowException(L"Incorrect number of parameters calling method '%.16s'.", + method.c_str()); +} + +void CJX_Object::ThrowArgumentMismatchException() const { + ThrowException(L"Argument mismatch in property or function argument."); +} + +void CJX_Object::ThrowException(const wchar_t* str, ...) const { + va_list arg_ptr; + va_start(arg_ptr, str); + WideString wsMessage = WideString::FormatV(str, arg_ptr); + va_end(arg_ptr); + + ASSERT(!wsMessage.IsEmpty()); + FXJSE_ThrowMessage(wsMessage.UTF8Encode().AsStringView()); +} + +bool CJX_Object::HasAttribute(XFA_Attribute eAttr) { + void* pKey = GetMapKey_Element(GetXFAObject()->GetElementType(), eAttr); + return HasMapModuleKey(pKey); +} + +bool CJX_Object::SetAttribute(XFA_Attribute eAttr, + const WideStringView& wsValue, + bool bNotify) { + switch (ToNode(GetXFAObject())->GetAttributeType(eAttr)) { + case XFA_AttributeType::Enum: { + pdfium::Optional<XFA_AttributeEnum> item = + CXFA_Node::NameToAttributeEnum(wsValue); + return SetEnum( + eAttr, + item ? *item : *(ToNode(GetXFAObject())->GetDefaultEnum(eAttr)), + bNotify); + } + case XFA_AttributeType::CData: + return SetCData(eAttr, WideString(wsValue), bNotify, false); + case XFA_AttributeType::Boolean: + return SetBoolean(eAttr, wsValue != L"0", bNotify); + case XFA_AttributeType::Integer: + return SetInteger(eAttr, + FXSYS_round(FXSYS_wcstof(wsValue.unterminated_c_str(), + wsValue.GetLength(), nullptr)), + bNotify); + case XFA_AttributeType::Measure: + return SetMeasure(eAttr, CXFA_Measurement(wsValue), bNotify); + default: + break; + } + return false; +} + +void CJX_Object::SetMapModuleString(void* pKey, const WideStringView& wsValue) { + SetMapModuleBuffer(pKey, (void*)wsValue.unterminated_c_str(), + wsValue.GetLength() * sizeof(wchar_t), nullptr); +} + +bool CJX_Object::SetAttribute(const WideStringView& wsAttr, + const WideStringView& wsValue, + bool bNotify) { + XFA_Attribute attr = CXFA_Node::NameToAttribute(wsValue); + if (attr != XFA_Attribute::Unknown) + return SetAttribute(attr, wsValue, bNotify); + + void* pKey = GetMapKey_Custom(wsAttr); + SetMapModuleString(pKey, wsValue); + return true; +} + +WideString CJX_Object::GetAttribute(const WideStringView& attr) { + return TryAttribute(attr, true).value_or(WideString()); +} + +WideString CJX_Object::GetAttribute(XFA_Attribute attr) { + return TryAttribute(attr, true).value_or(WideString()); +} + +pdfium::Optional<WideString> CJX_Object::TryAttribute(XFA_Attribute eAttr, + bool bUseDefault) { + switch (ToNode(GetXFAObject())->GetAttributeType(eAttr)) { + case XFA_AttributeType::Enum: { + pdfium::Optional<XFA_AttributeEnum> value = TryEnum(eAttr, bUseDefault); + if (!value) + return {}; + + return {CXFA_Node::AttributeEnumToName(*value)}; + } + case XFA_AttributeType::CData: + return TryCData(eAttr, bUseDefault); + + case XFA_AttributeType::Boolean: { + pdfium::Optional<bool> value = TryBoolean(eAttr, bUseDefault); + if (!value) + return {}; + return {*value ? L"1" : L"0"}; + } + case XFA_AttributeType::Integer: { + pdfium::Optional<int32_t> iValue = TryInteger(eAttr, bUseDefault); + if (!iValue) + return {}; + return {WideString::Format(L"%d", *iValue)}; + } + case XFA_AttributeType::Measure: { + pdfium::Optional<CXFA_Measurement> value = TryMeasure(eAttr, bUseDefault); + if (!value) + return {}; + + return {value->ToString()}; + } + default: + break; + } + return {}; +} + +pdfium::Optional<WideString> CJX_Object::TryAttribute( + const WideStringView& wsAttr, + bool bUseDefault) { + XFA_Attribute attr = CXFA_Node::NameToAttribute(wsAttr); + if (attr != XFA_Attribute::Unknown) + return TryAttribute(attr, bUseDefault); + + void* pKey = GetMapKey_Custom(wsAttr); + WideStringView wsValueC; + if (!GetMapModuleString(pKey, wsValueC)) + return {}; + + return {WideString(wsValueC)}; +} + +void CJX_Object::RemoveAttribute(const WideStringView& wsAttr) { + void* pKey = GetMapKey_Custom(wsAttr); + if (pKey) + RemoveMapModuleKey(pKey); +} + +pdfium::Optional<bool> CJX_Object::TryBoolean(XFA_Attribute eAttr, + bool bUseDefault) { + void* pValue = nullptr; + void* pKey = GetMapKey_Element(GetXFAObject()->GetElementType(), eAttr); + if (GetMapModuleValue(pKey, pValue)) + return {!!pValue}; + if (!bUseDefault) + return {}; + + return ToNode(GetXFAObject())->GetDefaultBoolean(eAttr); +} + +bool CJX_Object::SetBoolean(XFA_Attribute eAttr, bool bValue, bool bNotify) { + CFX_XMLElement* elem = SetValue(eAttr, XFA_AttributeType::Boolean, + (void*)(uintptr_t)bValue, bNotify); + if (elem) + elem->SetString(CXFA_Node::AttributeToName(eAttr), bValue ? L"1" : L"0"); + return true; +} + +bool CJX_Object::GetBoolean(XFA_Attribute eAttr) { + return TryBoolean(eAttr, true).value_or(false); +} + +bool CJX_Object::SetInteger(XFA_Attribute eAttr, int32_t iValue, bool bNotify) { + CFX_XMLElement* elem = SetValue(eAttr, XFA_AttributeType::Integer, + (void*)(uintptr_t)iValue, bNotify); + if (elem) { + elem->SetString(CXFA_Node::AttributeToName(eAttr), + WideString::Format(L"%d", iValue)); + } + return true; +} + +int32_t CJX_Object::GetInteger(XFA_Attribute eAttr) { + return TryInteger(eAttr, true).value_or(0); +} + +pdfium::Optional<int32_t> CJX_Object::TryInteger(XFA_Attribute eAttr, + bool bUseDefault) { + void* pKey = GetMapKey_Element(GetXFAObject()->GetElementType(), eAttr); + void* pValue = nullptr; + if (GetMapModuleValue(pKey, pValue)) + return {static_cast<int32_t>(reinterpret_cast<uintptr_t>(pValue))}; + if (!bUseDefault) + return {}; + + return ToNode(GetXFAObject())->GetDefaultInteger(eAttr); +} + +pdfium::Optional<XFA_AttributeEnum> CJX_Object::TryEnum(XFA_Attribute eAttr, + bool bUseDefault) { + void* pKey = GetMapKey_Element(GetXFAObject()->GetElementType(), eAttr); + void* pValue = nullptr; + if (GetMapModuleValue(pKey, pValue)) { + return { + static_cast<XFA_AttributeEnum>(reinterpret_cast<uintptr_t>(pValue))}; + } + if (!bUseDefault) + return {}; + + return ToNode(GetXFAObject())->GetDefaultEnum(eAttr); +} + +bool CJX_Object::SetEnum(XFA_Attribute eAttr, + XFA_AttributeEnum eValue, + bool bNotify) { + CFX_XMLElement* elem = SetValue(eAttr, XFA_AttributeType::Enum, + (void*)(uintptr_t)eValue, bNotify); + if (elem) { + elem->SetString(CXFA_Node::AttributeToName(eAttr), + CXFA_Node::AttributeEnumToName(eValue)); + } + return true; +} + +XFA_AttributeEnum CJX_Object::GetEnum(XFA_Attribute eAttr) { + return TryEnum(eAttr, true).value_or(XFA_AttributeEnum::Unknown); +} + +bool CJX_Object::SetMeasure(XFA_Attribute eAttr, + CXFA_Measurement mValue, + bool bNotify) { + void* pKey = GetMapKey_Element(GetXFAObject()->GetElementType(), eAttr); + OnChanging(eAttr, bNotify); + SetMapModuleBuffer(pKey, &mValue, sizeof(CXFA_Measurement), nullptr); + OnChanged(eAttr, bNotify, false); + return true; +} + +pdfium::Optional<CXFA_Measurement> CJX_Object::TryMeasure( + XFA_Attribute eAttr, + bool bUseDefault) const { + void* pKey = GetMapKey_Element(GetXFAObject()->GetElementType(), eAttr); + void* pValue; + int32_t iBytes; + if (GetMapModuleBuffer(pKey, pValue, iBytes, true) && + iBytes == sizeof(CXFA_Measurement)) { + return {*reinterpret_cast<CXFA_Measurement*>(pValue)}; + } + if (!bUseDefault) + return {}; + + return ToNode(GetXFAObject())->GetDefaultMeasurement(eAttr); +} + +CXFA_Measurement CJX_Object::GetMeasure(XFA_Attribute eAttr) const { + return TryMeasure(eAttr, true).value_or(CXFA_Measurement()); +} + +WideString CJX_Object::GetCData(XFA_Attribute eAttr) { + return TryCData(eAttr, true).value_or(WideString()); +} + +bool CJX_Object::SetCData(XFA_Attribute eAttr, + const WideString& wsValue, + bool bNotify, + bool bScriptModify) { + void* pKey = GetMapKey_Element(GetXFAObject()->GetElementType(), eAttr); + OnChanging(eAttr, bNotify); + if (eAttr == XFA_Attribute::Value) { + WideString* pClone = new WideString(wsValue); + SetUserData(pKey, pClone, &deleteWideStringCallBack); + } else { + SetMapModuleString(pKey, wsValue.AsStringView()); + if (eAttr == XFA_Attribute::Name) + ToNode(GetXFAObject())->UpdateNameHash(); + } + OnChanged(eAttr, bNotify, bScriptModify); + + if (!ToNode(GetXFAObject())->IsNeedSavingXMLNode() || + eAttr == XFA_Attribute::QualifiedName || + eAttr == XFA_Attribute::BindingNode) { + return true; + } + + if (eAttr == XFA_Attribute::Name && + (GetXFAObject()->GetElementType() == XFA_Element::DataValue || + GetXFAObject()->GetElementType() == XFA_Element::DataGroup)) { + return true; + } + + auto* elem = + static_cast<CFX_XMLElement*>(ToNode(GetXFAObject())->GetXMLMappingNode()); + if (eAttr == XFA_Attribute::Value) { + FX_XMLNODETYPE eXMLType = elem->GetType(); + switch (eXMLType) { + case FX_XMLNODE_Element: + if (ToNode(GetXFAObject())->IsAttributeInXML()) { + elem->SetString(WideString(GetCData(XFA_Attribute::QualifiedName)), + wsValue); + } else { + bool bDeleteChildren = true; + if (ToNode(GetXFAObject())->GetPacketType() == + XFA_PacketType::Datasets) { + for (CXFA_Node* pChildDataNode = + ToNode(GetXFAObject()) + ->GetNodeItem(XFA_NODEITEM_FirstChild); + pChildDataNode; pChildDataNode = pChildDataNode->GetNodeItem( + XFA_NODEITEM_NextSibling)) { + if (!pChildDataNode->GetBindItems()->empty()) { + bDeleteChildren = false; + break; + } + } + } + if (bDeleteChildren) + elem->DeleteChildren(); + + elem->SetTextData(wsValue); + } + break; + case FX_XMLNODE_Text: + static_cast<CFX_XMLText*>(ToNode(GetXFAObject())->GetXMLMappingNode()) + ->SetText(wsValue); + break; + default: + NOTREACHED(); + } + return true; + } + ASSERT(elem->GetType() == FX_XMLNODE_Element); + + WideString wsAttrName = CXFA_Node::AttributeToName(eAttr); + if (eAttr == XFA_Attribute::ContentType) + wsAttrName = L"xfa:" + wsAttrName; + + elem->SetString(wsAttrName, wsValue); + return true; +} + +void CJX_Object::SetAttributeValue(const WideString& wsValue, + const WideString& wsXMLValue, + bool bNotify, + bool bScriptModify) { + void* pKey = + GetMapKey_Element(GetXFAObject()->GetElementType(), XFA_Attribute::Value); + OnChanging(XFA_Attribute::Value, bNotify); + WideString* pClone = new WideString(wsValue); + SetUserData(pKey, pClone, &deleteWideStringCallBack); + OnChanged(XFA_Attribute::Value, bNotify, bScriptModify); + if (!ToNode(GetXFAObject())->IsNeedSavingXMLNode()) + return; + + auto* elem = + static_cast<CFX_XMLElement*>(ToNode(GetXFAObject())->GetXMLMappingNode()); + FX_XMLNODETYPE eXMLType = elem->GetType(); + switch (eXMLType) { + case FX_XMLNODE_Element: + if (ToNode(GetXFAObject())->IsAttributeInXML()) { + elem->SetString(WideString(GetCData(XFA_Attribute::QualifiedName)), + wsXMLValue); + } else { + bool bDeleteChildren = true; + if (ToNode(GetXFAObject())->GetPacketType() == + XFA_PacketType::Datasets) { + for (CXFA_Node* pChildDataNode = + ToNode(GetXFAObject())->GetNodeItem(XFA_NODEITEM_FirstChild); + pChildDataNode; pChildDataNode = pChildDataNode->GetNodeItem( + XFA_NODEITEM_NextSibling)) { + if (!pChildDataNode->GetBindItems()->empty()) { + bDeleteChildren = false; + break; + } + } + } + if (bDeleteChildren) + elem->DeleteChildren(); + + elem->SetTextData(wsXMLValue); + } + break; + case FX_XMLNODE_Text: + static_cast<CFX_XMLText*>(ToNode(GetXFAObject())->GetXMLMappingNode()) + ->SetText(wsXMLValue); + break; + default: + ASSERT(0); + } +} + +pdfium::Optional<WideString> CJX_Object::TryCData(XFA_Attribute eAttr, + bool bUseDefault) { + void* pKey = GetMapKey_Element(GetXFAObject()->GetElementType(), eAttr); + if (eAttr == XFA_Attribute::Value) { + void* pData; + int32_t iBytes = 0; + WideString* pStr = nullptr; + if (GetMapModuleBuffer(pKey, pData, iBytes, true) && + iBytes == sizeof(void*)) { + memcpy(&pData, pData, iBytes); + pStr = reinterpret_cast<WideString*>(pData); + } + if (pStr) + return {*pStr}; + } else { + WideStringView wsValueC; + if (GetMapModuleString(pKey, wsValueC)) + return {WideString(wsValueC)}; + } + if (!bUseDefault) + return {}; + + return ToNode(GetXFAObject())->GetDefaultCData(eAttr); +} + +CFX_XMLElement* CJX_Object::SetValue(XFA_Attribute eAttr, + XFA_AttributeType eType, + void* pValue, + bool bNotify) { + void* pKey = GetMapKey_Element(GetXFAObject()->GetElementType(), eAttr); + OnChanging(eAttr, bNotify); + SetMapModuleValue(pKey, pValue); + OnChanged(eAttr, bNotify, false); + if (!ToNode(GetXFAObject())->IsNeedSavingXMLNode()) + return nullptr; + + auto* elem = + static_cast<CFX_XMLElement*>(ToNode(GetXFAObject())->GetXMLMappingNode()); + ASSERT(elem->GetType() == FX_XMLNODE_Element); + + return elem; +} + +bool CJX_Object::SetUserData(void* pKey, + void* pData, + XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) { + SetMapModuleBuffer(pKey, &pData, sizeof(void*), + pCallbackInfo ? pCallbackInfo : &gs_XFADefaultFreeData); + return true; +} + +XFA_MAPMODULEDATA* CJX_Object::CreateMapModuleData() { + if (!map_module_data_) + map_module_data_ = pdfium::MakeUnique<XFA_MAPMODULEDATA>(); + return map_module_data_.get(); +} + +XFA_MAPMODULEDATA* CJX_Object::GetMapModuleData() const { + return map_module_data_.get(); +} + +void CJX_Object::SetMapModuleValue(void* pKey, void* pValue) { + CreateMapModuleData()->m_ValueMap[pKey] = pValue; +} + +bool CJX_Object::GetMapModuleValue(void* pKey, void*& pValue) { + for (CXFA_Node* pNode = ToNode(GetXFAObject()); pNode; + pNode = pNode->GetTemplateNode()) { + XFA_MAPMODULEDATA* pModule = pNode->JSNode()->GetMapModuleData(); + if (pModule) { + auto it = pModule->m_ValueMap.find(pKey); + if (it != pModule->m_ValueMap.end()) { + pValue = it->second; + return true; + } + } + if (pNode->GetPacketType() == XFA_PacketType::Datasets) + break; + } + return false; +} + +bool CJX_Object::GetMapModuleString(void* pKey, WideStringView& wsValue) { + void* pValue; + int32_t iBytes; + if (!GetMapModuleBuffer(pKey, pValue, iBytes, true)) + return false; + + // Defensive measure: no out-of-bounds pointers even if zero length. + int32_t iChars = iBytes / sizeof(wchar_t); + wsValue = WideStringView(iChars ? (const wchar_t*)pValue : nullptr, iChars); + return true; +} + +void CJX_Object::SetMapModuleBuffer( + void* pKey, + void* pValue, + int32_t iBytes, + XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) { + XFA_MAPDATABLOCK*& pBuffer = CreateMapModuleData()->m_BufferMap[pKey]; + if (!pBuffer) { + pBuffer = reinterpret_cast<XFA_MAPDATABLOCK*>( + FX_Alloc(uint8_t, sizeof(XFA_MAPDATABLOCK) + iBytes)); + } else if (pBuffer->iBytes != iBytes) { + if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) + pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData()); + + pBuffer = reinterpret_cast<XFA_MAPDATABLOCK*>( + FX_Realloc(uint8_t, pBuffer, sizeof(XFA_MAPDATABLOCK) + iBytes)); + } else if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) { + pBuffer->pCallbackInfo->pFree( + *reinterpret_cast<void**>(pBuffer->GetData())); + } + if (!pBuffer) + return; + + pBuffer->pCallbackInfo = pCallbackInfo; + pBuffer->iBytes = iBytes; + memcpy(pBuffer->GetData(), pValue, iBytes); +} + +bool CJX_Object::GetMapModuleBuffer(void* pKey, + void*& pValue, + int32_t& iBytes, + bool bProtoAlso) const { + XFA_MAPDATABLOCK* pBuffer = nullptr; + for (const CXFA_Node* pNode = ToNode(GetXFAObject()); pNode; + pNode = pNode->GetTemplateNode()) { + XFA_MAPMODULEDATA* pModule = pNode->JSNode()->GetMapModuleData(); + if (pModule) { + auto it = pModule->m_BufferMap.find(pKey); + if (it != pModule->m_BufferMap.end()) { + pBuffer = it->second; + break; + } + } + if (!bProtoAlso || pNode->GetPacketType() == XFA_PacketType::Datasets) + break; + } + if (!pBuffer) + return false; + + pValue = pBuffer->GetData(); + iBytes = pBuffer->iBytes; + return true; +} + +bool CJX_Object::HasMapModuleKey(void* pKey) { + XFA_MAPMODULEDATA* pModule = GetMapModuleData(); + return pModule && (pdfium::ContainsKey(pModule->m_ValueMap, pKey) || + pdfium::ContainsKey(pModule->m_BufferMap, pKey)); +} + +void CJX_Object::ClearMapModuleBuffer() { + XFA_MAPMODULEDATA* pModule = GetMapModuleData(); + if (!pModule) + return; + + for (auto& pair : pModule->m_BufferMap) { + XFA_MAPDATABLOCK* pBuffer = pair.second; + if (pBuffer) { + if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) + pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData()); + + FX_Free(pBuffer); + } + } + pModule->m_BufferMap.clear(); + pModule->m_ValueMap.clear(); +} + +void CJX_Object::RemoveMapModuleKey(void* pKey) { + ASSERT(pKey); + + XFA_MAPMODULEDATA* pModule = GetMapModuleData(); + if (!pModule) + return; + + auto it = pModule->m_BufferMap.find(pKey); + if (it != pModule->m_BufferMap.end()) { + XFA_MAPDATABLOCK* pBuffer = it->second; + if (pBuffer) { + if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) + pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData()); + + FX_Free(pBuffer); + } + pModule->m_BufferMap.erase(it); + } + pModule->m_ValueMap.erase(pKey); + return; +} + +void CJX_Object::MergeAllData(CXFA_Object* pDstModule) { + XFA_MAPMODULEDATA* pDstModuleData = + ToNode(pDstModule)->JSNode()->CreateMapModuleData(); + XFA_MAPMODULEDATA* pSrcModuleData = GetMapModuleData(); + if (!pSrcModuleData) + return; + + for (const auto& pair : pSrcModuleData->m_ValueMap) + pDstModuleData->m_ValueMap[pair.first] = pair.second; + + for (const auto& pair : pSrcModuleData->m_BufferMap) { + XFA_MAPDATABLOCK* pSrcBuffer = pair.second; + XFA_MAPDATABLOCK*& pDstBuffer = pDstModuleData->m_BufferMap[pair.first]; + if (pSrcBuffer->pCallbackInfo && pSrcBuffer->pCallbackInfo->pFree && + !pSrcBuffer->pCallbackInfo->pCopy) { + if (pDstBuffer) { + pDstBuffer->pCallbackInfo->pFree(*(void**)pDstBuffer->GetData()); + pDstModuleData->m_BufferMap.erase(pair.first); + } + continue; + } + if (!pDstBuffer) { + pDstBuffer = (XFA_MAPDATABLOCK*)FX_Alloc( + uint8_t, sizeof(XFA_MAPDATABLOCK) + pSrcBuffer->iBytes); + } else if (pDstBuffer->iBytes != pSrcBuffer->iBytes) { + if (pDstBuffer->pCallbackInfo && pDstBuffer->pCallbackInfo->pFree) { + pDstBuffer->pCallbackInfo->pFree(*(void**)pDstBuffer->GetData()); + } + pDstBuffer = (XFA_MAPDATABLOCK*)FX_Realloc( + uint8_t, pDstBuffer, sizeof(XFA_MAPDATABLOCK) + pSrcBuffer->iBytes); + } else if (pDstBuffer->pCallbackInfo && pDstBuffer->pCallbackInfo->pFree) { + pDstBuffer->pCallbackInfo->pFree(*(void**)pDstBuffer->GetData()); + } + if (!pDstBuffer) + continue; + + pDstBuffer->pCallbackInfo = pSrcBuffer->pCallbackInfo; + pDstBuffer->iBytes = pSrcBuffer->iBytes; + memcpy(pDstBuffer->GetData(), pSrcBuffer->GetData(), pSrcBuffer->iBytes); + if (pDstBuffer->pCallbackInfo && pDstBuffer->pCallbackInfo->pCopy) { + pDstBuffer->pCallbackInfo->pCopy(*(void**)pDstBuffer->GetData()); + } + } +} + +void CJX_Object::MoveBufferMapData(CXFA_Object* pDstModule) { + if (!pDstModule) + return; + + bool bNeedMove = true; + if (pDstModule->GetElementType() != GetXFAObject()->GetElementType()) + bNeedMove = false; + + if (bNeedMove) + ToNode(pDstModule)->JSNode()->SetCalcData(ReleaseCalcData()); + if (!pDstModule->IsNodeV()) + return; + + WideString wsValue = ToNode(pDstModule)->JSNode()->GetContent(false); + WideString wsFormatValue(wsValue); + CXFA_WidgetData* pWidgetData = ToNode(pDstModule)->GetContainerWidgetData(); + if (pWidgetData) + wsFormatValue = pWidgetData->GetFormatDataValue(wsValue); + + ToNode(pDstModule) + ->JSNode() + ->SetContent(wsValue, wsFormatValue, true, true, true); +} + +void CJX_Object::MoveBufferMapData(CXFA_Object* pSrcModule, + CXFA_Object* pDstModule) { + if (!pSrcModule || !pDstModule) + return; + + CXFA_Node* pSrcChild = + ToNode(pSrcModule)->GetNodeItem(XFA_NODEITEM_FirstChild); + CXFA_Node* pDstChild = + ToNode(pDstModule)->GetNodeItem(XFA_NODEITEM_FirstChild); + while (pSrcChild && pDstChild) { + MoveBufferMapData(pSrcChild, pDstChild); + + pSrcChild = pSrcChild->GetNodeItem(XFA_NODEITEM_NextSibling); + pDstChild = pDstChild->GetNodeItem(XFA_NODEITEM_NextSibling); + } + ToNode(pSrcModule)->JSNode()->MoveBufferMapData(pDstModule); +} + +void CJX_Object::OnChanging(XFA_Attribute eAttr, bool bNotify) { + if (!bNotify || !ToNode(GetXFAObject())->IsInitialized()) + return; + + CXFA_FFNotify* pNotify = GetDocument()->GetNotify(); + if (pNotify) + pNotify->OnValueChanging(ToNode(GetXFAObject()), eAttr); +} + +void CJX_Object::OnChanged(XFA_Attribute eAttr, + bool bNotify, + bool bScriptModify) { + if (bNotify && ToNode(GetXFAObject())->IsInitialized()) + ToNode(GetXFAObject())->SendAttributeChangeMessage(eAttr, bScriptModify); +} + +void CJX_Object::SetCalcData(std::unique_ptr<CXFA_CalcData> data) { + calc_data_ = std::move(data); +} + +std::unique_ptr<CXFA_CalcData> CJX_Object::ReleaseCalcData() { + return std::move(calc_data_); +} diff --git a/fxjs/xfa/cjx_object.h b/fxjs/xfa/cjx_object.h new file mode 100644 index 0000000000..cb8350d2b1 --- /dev/null +++ b/fxjs/xfa/cjx_object.h @@ -0,0 +1,163 @@ +// Copyright 2017 PDFium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com + +#ifndef FXJS_XFA_CJX_OBJECT_H_ +#define FXJS_XFA_CJX_OBJECT_H_ + +#include <map> +#include <memory> +#include <vector> + +#include "core/fxcrt/unowned_ptr.h" +#include "core/fxcrt/widestring.h" +#include "core/fxcrt/xml/cfx_xmlelement.h" +#include "third_party/base/optional.h" +#include "xfa/fxfa/fxfa_basic.h" + +class CFXJSE_Value; +class CJS_V8; +class CXFA_CalcData; +class CXFA_Document; +class CXFA_Object; +struct XFA_MAPMODULEDATA; + +typedef CJS_Return (*CJX_MethodCall)( + CJX_Object* obj, + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params); +struct CJX_MethodSpec { + const char* pName; + CJX_MethodCall pMethodCall; +}; + +typedef void (*PD_CALLBACK_FREEDATA)(void* pData); +typedef void (*PD_CALLBACK_DUPLICATEDATA)(void*& pData); + +struct XFA_MAPDATABLOCKCALLBACKINFO { + PD_CALLBACK_FREEDATA pFree; + PD_CALLBACK_DUPLICATEDATA pCopy; +}; + +class CJX_Object { + public: + explicit CJX_Object(CXFA_Object* obj); + virtual ~CJX_Object(); + + CXFA_Object* GetXFAObject() { return object_.Get(); } + const CXFA_Object* GetXFAObject() const { return object_.Get(); } + + CXFA_Document* GetDocument() const; + + bool HasMethod(const WideString& func) const; + CJS_Return RunMethod(const WideString& func, + const std::vector<v8::Local<v8::Value>>& params); + + bool HasAttribute(XFA_Attribute eAttr); + bool SetAttribute(XFA_Attribute eAttr, + const WideStringView& wsValue, + bool bNotify); + bool SetAttribute(const WideStringView& wsAttr, + const WideStringView& wsValue, + bool bNotify); + void RemoveAttribute(const WideStringView& wsAttr); + WideString GetAttribute(const WideStringView& attr); + WideString GetAttribute(XFA_Attribute attr); + pdfium::Optional<WideString> TryAttribute(const WideStringView& wsAttr, + bool bUseDefault); + pdfium::Optional<WideString> TryAttribute(XFA_Attribute eAttr, + bool bUseDefault); + + void SetAttributeValue(const WideString& wsValue, + const WideString& wsXMLValue, + bool bNotify, + bool bScriptModify); + + pdfium::Optional<int32_t> TryInteger(XFA_Attribute eAttr, bool bUseDefault); + bool SetInteger(XFA_Attribute eAttr, int32_t iValue, bool bNotify); + int32_t GetInteger(XFA_Attribute eAttr); + + pdfium::Optional<WideString> TryCData(XFA_Attribute eAttr, bool bUseDefault); + bool SetCData(XFA_Attribute eAttr, + const WideString& wsValue, + bool bNotify, + bool bScriptModify); + WideString GetCData(XFA_Attribute eAttr); + + pdfium::Optional<XFA_AttributeEnum> TryEnum(XFA_Attribute eAttr, + bool bUseDefault); + bool SetEnum(XFA_Attribute eAttr, XFA_AttributeEnum eValue, bool bNotify); + XFA_AttributeEnum GetEnum(XFA_Attribute eAttr); + + pdfium::Optional<bool> TryBoolean(XFA_Attribute eAttr, bool bUseDefault); + bool SetBoolean(XFA_Attribute eAttr, bool bValue, bool bNotify); + bool GetBoolean(XFA_Attribute eAttr); + + pdfium::Optional<CXFA_Measurement> TryMeasure(XFA_Attribute eAttr, + bool bUseDefault) const; + bool SetMeasure(XFA_Attribute eAttr, CXFA_Measurement mValue, bool bNotify); + CXFA_Measurement GetMeasure(XFA_Attribute eAttr) const; + + void Script_ObjectClass_ClassName(CFXJSE_Value* pValue, + bool bSetting, + XFA_Attribute eAttribute); + + void MergeAllData(CXFA_Object* pDstModule); + + void SetCalcData(std::unique_ptr<CXFA_CalcData> data); + CXFA_CalcData* GetCalcData() const { return calc_data_.get(); } + std::unique_ptr<CXFA_CalcData> ReleaseCalcData(); + + void ThrowInvalidPropertyException() const; + void ThrowArgumentMismatchException() const; + void ThrowIndexOutOfBoundsException() const; + void ThrowParamCountMismatchException(const WideString& method) const; + + protected: + void DefineMethods(const CJX_MethodSpec method_specs[]); + + void MoveBufferMapData(CXFA_Object* pSrcModule, CXFA_Object* pDstModule); + void SetMapModuleString(void* pKey, const WideStringView& wsValue); + void ThrowException(const wchar_t* str, ...) const; + + private: + void OnChanged(XFA_Attribute eAttr, bool bNotify, bool bScriptModify); + void OnChanging(XFA_Attribute eAttr, bool bNotify); + bool SetUserData(void* pKey, + void* pData, + XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo); + + // Returns a pointer to the XML node that needs to be updated with the new + // attribute value. |nullptr| if no update is needed. + CFX_XMLElement* SetValue(XFA_Attribute eAttr, + XFA_AttributeType eType, + void* pValue, + bool bNotify); + + XFA_MAPMODULEDATA* CreateMapModuleData(); + XFA_MAPMODULEDATA* GetMapModuleData() const; + void SetMapModuleValue(void* pKey, void* pValue); + bool GetMapModuleValue(void* pKey, void*& pValue); + bool GetMapModuleString(void* pKey, WideStringView& wsValue); + void SetMapModuleBuffer(void* pKey, + void* pValue, + int32_t iBytes, + XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo); + bool GetMapModuleBuffer(void* pKey, + void*& pValue, + int32_t& iBytes, + bool bProtoAlso) const; + bool HasMapModuleKey(void* pKey); + void ClearMapModuleBuffer(); + void RemoveMapModuleKey(void* pKey); + void MoveBufferMapData(CXFA_Object* pDstModule); + + UnownedPtr<CXFA_Object> object_; + std::unique_ptr<XFA_MAPMODULEDATA> map_module_data_; + std::unique_ptr<CXFA_CalcData> calc_data_; + std::map<ByteString, CJX_MethodCall> method_specs_; +}; + +#endif // FXJS_XFA_CJX_OBJECT_H_ diff --git a/fxjs/xfa/cjx_packet.h b/fxjs/xfa/cjx_packet.h index 80520e2751..b014a9d9ac 100644 --- a/fxjs/xfa/cjx_packet.h +++ b/fxjs/xfa/cjx_packet.h @@ -8,7 +8,7 @@ #define FXJS_XFA_CJX_PACKET_H_ #include "fxjs/CJX_Define.h" -#include "fxjs/cjx_node.h" +#include "fxjs/xfa/cjx_node.h" class CXFA_Packet; diff --git a/fxjs/xfa/cjx_signaturepseudomodel.cpp b/fxjs/xfa/cjx_signaturepseudomodel.cpp new file mode 100644 index 0000000000..6b39ac2488 --- /dev/null +++ b/fxjs/xfa/cjx_signaturepseudomodel.cpp @@ -0,0 +1,60 @@ +// Copyright 2017 PDFium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com + +#include "fxjs/xfa/cjx_signaturepseudomodel.h" + +#include <vector> + +#include "fxjs/cfxjse_value.h" +#include "fxjs/js_resources.h" +#include "xfa/fxfa/parser/cscript_signaturepseudomodel.h" + +const CJX_MethodSpec CJX_SignaturePseudoModel::MethodSpecs[] = { + {"verify", verifySignature_static}, + {"sign", sign_static}, + {"enumerate", enumerate_static}, + {"clear", clear_static}, + {"", nullptr}}; + +CJX_SignaturePseudoModel::CJX_SignaturePseudoModel( + CScript_SignaturePseudoModel* model) + : CJX_Object(model) { + DefineMethods(MethodSpecs); +} + +CJX_SignaturePseudoModel::~CJX_SignaturePseudoModel() {} + +CJS_Return CJX_SignaturePseudoModel::verifySignature( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (params.empty() || params.size() > 4) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + return CJS_Return(runtime->NewNumber(0)); +} + +CJS_Return CJX_SignaturePseudoModel::sign( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (params.size() < 3 || params.size() > 7) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + return CJS_Return(runtime->NewBoolean(false)); +} + +CJS_Return CJX_SignaturePseudoModel::enumerate( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (!params.empty()) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + return CJS_Return(true); +} + +CJS_Return CJX_SignaturePseudoModel::clear( + CJS_V8* runtime, + const std::vector<v8::Local<v8::Value>>& params) { + if (params.empty() || params.size() > 2) + return CJS_Return(JSGetStringFromID(JSMessage::kParamError)); + return CJS_Return(runtime->NewBoolean(false)); +} diff --git a/fxjs/xfa/cjx_signaturepseudomodel.h b/fxjs/xfa/cjx_signaturepseudomodel.h new file mode 100644 index 0000000000..88f90fb33a --- /dev/null +++ b/fxjs/xfa/cjx_signaturepseudomodel.h @@ -0,0 +1,29 @@ +// Copyright 2017 PDFium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com + +#ifndef FXJS_XFA_CJX_SIGNATUREPSEUDOMODEL_H_ +#define FXJS_XFA_CJX_SIGNATUREPSEUDOMODEL_H_ + +#include "fxjs/CJX_Define.h" +#include "fxjs/xfa/cjx_object.h" + +class CScript_SignaturePseudoModel; + +class CJX_SignaturePseudoModel : public CJX_Object { + public: + explicit CJX_SignaturePseudoModel(CScript_SignaturePseudoModel* model); + ~CJX_SignaturePseudoModel() override; + + JS_METHOD(verifySignature /*verify*/, CJX_SignaturePseudoModel); + JS_METHOD(sign, CJX_SignaturePseudoModel); + JS_METHOD(enumerate, CJX_SignaturePseudoModel); + JS_METHOD(clear, CJX_SignaturePseudoModel); + + private: + static const CJX_MethodSpec MethodSpecs[]; +}; + +#endif // FXJS_XFA_CJX_SIGNATUREPSEUDOMODEL_H_ diff --git a/fxjs/xfa/cjx_source.h b/fxjs/xfa/cjx_source.h index 1502e0e807..8b35fac428 100644 --- a/fxjs/xfa/cjx_source.h +++ b/fxjs/xfa/cjx_source.h @@ -8,7 +8,7 @@ #define FXJS_XFA_CJX_SOURCE_H_ #include "fxjs/CJX_Define.h" -#include "fxjs/cjx_node.h" +#include "fxjs/xfa/cjx_node.h" class CXFA_Source; diff --git a/fxjs/xfa/cjx_textnode.h b/fxjs/xfa/cjx_textnode.h index 1fa84d8d52..c0a01d651e 100644 --- a/fxjs/xfa/cjx_textnode.h +++ b/fxjs/xfa/cjx_textnode.h @@ -8,7 +8,7 @@ #define FXJS_XFA_CJX_TEXTNODE_H_ #include "fxjs/CJX_Define.h" -#include "fxjs/cjx_node.h" +#include "fxjs/xfa/cjx_node.h" class CXFA_Node; diff --git a/fxjs/xfa/cjx_tree.h b/fxjs/xfa/cjx_tree.h index 30081122a5..72468d6c75 100644 --- a/fxjs/xfa/cjx_tree.h +++ b/fxjs/xfa/cjx_tree.h @@ -8,7 +8,7 @@ #define FXJS_XFA_CJX_TREE_H_ #include "fxjs/CJX_Define.h" -#include "fxjs/cjx_object.h" +#include "fxjs/xfa/cjx_object.h" class CXFA_Object; class CXFA_Node; diff --git a/fxjs/xfa/cjx_wsdlconnection.h b/fxjs/xfa/cjx_wsdlconnection.h index 76533ce658..82760170a7 100644 --- a/fxjs/xfa/cjx_wsdlconnection.h +++ b/fxjs/xfa/cjx_wsdlconnection.h @@ -8,7 +8,7 @@ #define FXJS_XFA_CJX_WSDLCONNECTION_H_ #include "fxjs/CJX_Define.h" -#include "fxjs/cjx_node.h" +#include "fxjs/xfa/cjx_node.h" class CXFA_WsdlConnection; |