From 5b36f0a0eff7f3666a0e642640db3c89e4bb6748 Mon Sep 17 00:00:00 2001 From: dsinclair Date: Tue, 19 Jul 2016 10:56:23 -0700 Subject: Split xfa_object_imp into individual class files. This CL splits the CXFA_Object, CXFA_NodeList, CXFA_ThisProxy, CXFA_ArrayNodeList and CXFA_AttachNodeList out of xfa_object_imp. xfa_object_imp is then renamed to CXFA_Node. Review-Url: https://codereview.chromium.org/2159973003 --- BUILD.gn | 7 +- xfa.gyp | 7 +- xfa/fxfa/parser/cxfa_arraynodelist.cpp | 62 + xfa/fxfa/parser/cxfa_attachnodelist.cpp | 46 + xfa/fxfa/parser/cxfa_node.cpp | 5172 ++++++++++++++++++++++++++++++ xfa/fxfa/parser/cxfa_nodelist.cpp | 118 + xfa/fxfa/parser/cxfa_object.cpp | 62 + xfa/fxfa/parser/cxfa_thisproxy.cpp | 28 + xfa/fxfa/parser/xfa_object_imp.cpp | 5272 ------------------------------- 9 files changed, 5500 insertions(+), 5274 deletions(-) create mode 100644 xfa/fxfa/parser/cxfa_arraynodelist.cpp create mode 100644 xfa/fxfa/parser/cxfa_attachnodelist.cpp create mode 100644 xfa/fxfa/parser/cxfa_node.cpp create mode 100644 xfa/fxfa/parser/cxfa_nodelist.cpp create mode 100644 xfa/fxfa/parser/cxfa_object.cpp create mode 100644 xfa/fxfa/parser/cxfa_thisproxy.cpp delete mode 100644 xfa/fxfa/parser/xfa_object_imp.cpp diff --git a/BUILD.gn b/BUILD.gn index c9a5fdd659..562036ad23 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -1328,8 +1328,10 @@ if (pdf_enable_xfa) { "xfa/fxfa/include/xfa_fontmgr.h", "xfa/fxfa/include/xfa_rendercontext.h", "xfa/fxfa/parser/cxfa_arc.h", + "xfa/fxfa/parser/cxfa_arraynodelist.cpp", "xfa/fxfa/parser/cxfa_assist.cpp", "xfa/fxfa/parser/cxfa_assist.h", + "xfa/fxfa/parser/cxfa_attachnodelist.cpp", "xfa/fxfa/parser/cxfa_bind.cpp", "xfa/fxfa/parser/cxfa_bind.h", "xfa/fxfa/parser/cxfa_binditems.cpp", @@ -1361,6 +1363,9 @@ if (pdf_enable_xfa) { "xfa/fxfa/parser/cxfa_line.h", "xfa/fxfa/parser/cxfa_margin.cpp", "xfa/fxfa/parser/cxfa_margin.h", + "xfa/fxfa/parser/cxfa_node.cpp", + "xfa/fxfa/parser/cxfa_nodelist.cpp", + "xfa/fxfa/parser/cxfa_object.cpp", "xfa/fxfa/parser/cxfa_occur.cpp", "xfa/fxfa/parser/cxfa_occur.h", "xfa/fxfa/parser/cxfa_para.cpp", @@ -1376,6 +1381,7 @@ if (pdf_enable_xfa) { "xfa/fxfa/parser/cxfa_submit.h", "xfa/fxfa/parser/cxfa_text.cpp", "xfa/fxfa/parser/cxfa_text.h", + "xfa/fxfa/parser/cxfa_thisproxy.cpp", "xfa/fxfa/parser/cxfa_tooltip.cpp", "xfa/fxfa/parser/cxfa_tooltip.h", "xfa/fxfa/parser/cxfa_validate.cpp", @@ -1420,7 +1426,6 @@ if (pdf_enable_xfa) { "xfa/fxfa/parser/xfa_localevalue.cpp", "xfa/fxfa/parser/xfa_localevalue.h", "xfa/fxfa/parser/xfa_object.h", - "xfa/fxfa/parser/xfa_object_imp.cpp", "xfa/fxfa/parser/xfa_script.h", "xfa/fxfa/parser/xfa_script_datawindow.cpp", "xfa/fxfa/parser/xfa_script_datawindow.h", diff --git a/xfa.gyp b/xfa.gyp index e21f905ed5..999be123e9 100644 --- a/xfa.gyp +++ b/xfa.gyp @@ -438,8 +438,10 @@ "xfa/fxfa/include/xfa_fontmgr.h", "xfa/fxfa/include/xfa_rendercontext.h", "xfa/fxfa/parser/cxfa_arc.h", + "xfa/fxfa/parser/cxfa_arraynodelist.cpp", "xfa/fxfa/parser/cxfa_assist.cpp", "xfa/fxfa/parser/cxfa_assist.h", + "xfa/fxfa/parser/cxfa_attachnodelist.cpp", "xfa/fxfa/parser/cxfa_bind.cpp", "xfa/fxfa/parser/cxfa_bind.h", "xfa/fxfa/parser/cxfa_binditems.cpp", @@ -471,6 +473,9 @@ "xfa/fxfa/parser/cxfa_line.h", "xfa/fxfa/parser/cxfa_margin.cpp", "xfa/fxfa/parser/cxfa_margin.h", + "xfa/fxfa/parser/cxfa_node.cpp", + "xfa/fxfa/parser/cxfa_nodelist.cpp", + "xfa/fxfa/parser/cxfa_object.cpp", "xfa/fxfa/parser/cxfa_occur.cpp", "xfa/fxfa/parser/cxfa_occur.h", "xfa/fxfa/parser/cxfa_para.cpp", @@ -486,6 +491,7 @@ "xfa/fxfa/parser/cxfa_submit.h", "xfa/fxfa/parser/cxfa_text.cpp", "xfa/fxfa/parser/cxfa_text.h", + "xfa/fxfa/parser/cxfa_thisproxy.cpp", "xfa/fxfa/parser/cxfa_tooltip.cpp", "xfa/fxfa/parser/cxfa_tooltip.h", "xfa/fxfa/parser/cxfa_validate.cpp", @@ -530,7 +536,6 @@ "xfa/fxfa/parser/xfa_localevalue.cpp", "xfa/fxfa/parser/xfa_localevalue.h", "xfa/fxfa/parser/xfa_object.h", - "xfa/fxfa/parser/xfa_object_imp.cpp", "xfa/fxfa/parser/xfa_script.h", "xfa/fxfa/parser/xfa_script_datawindow.cpp", "xfa/fxfa/parser/xfa_script_datawindow.h", diff --git a/xfa/fxfa/parser/cxfa_arraynodelist.cpp b/xfa/fxfa/parser/cxfa_arraynodelist.cpp new file mode 100644 index 0000000000..06aab400f1 --- /dev/null +++ b/xfa/fxfa/parser/cxfa_arraynodelist.cpp @@ -0,0 +1,62 @@ +// Copyright 2016 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 "xfa/fxfa/parser/xfa_object.h" + +CXFA_ArrayNodeList::CXFA_ArrayNodeList(CXFA_Document* pDocument) + : CXFA_NodeList(pDocument) {} + +CXFA_ArrayNodeList::~CXFA_ArrayNodeList() {} + +void CXFA_ArrayNodeList::SetArrayNodeList(const CXFA_NodeArray& srcArray) { + if (srcArray.GetSize() > 0) { + m_array.Copy(srcArray); + } +} + +int32_t CXFA_ArrayNodeList::GetLength() { + return m_array.GetSize(); +} + +FX_BOOL CXFA_ArrayNodeList::Append(CXFA_Node* pNode) { + m_array.Add(pNode); + return TRUE; +} + +FX_BOOL CXFA_ArrayNodeList::Insert(CXFA_Node* pNewNode, + CXFA_Node* pBeforeNode) { + if (!pBeforeNode) { + m_array.Add(pNewNode); + } else { + int32_t iSize = m_array.GetSize(); + for (int32_t i = 0; i < iSize; ++i) { + if (m_array[i] == pBeforeNode) { + m_array.InsertAt(i, pNewNode); + break; + } + } + } + return TRUE; +} + +FX_BOOL CXFA_ArrayNodeList::Remove(CXFA_Node* pNode) { + int32_t iSize = m_array.GetSize(); + for (int32_t i = 0; i < iSize; ++i) { + if (m_array[i] == pNode) { + m_array.RemoveAt(i); + break; + } + } + return TRUE; +} + +CXFA_Node* CXFA_ArrayNodeList::Item(int32_t iIndex) { + int32_t iSize = m_array.GetSize(); + if (iIndex >= 0 && iIndex < iSize) { + return m_array[iIndex]; + } + return nullptr; +} diff --git a/xfa/fxfa/parser/cxfa_attachnodelist.cpp b/xfa/fxfa/parser/cxfa_attachnodelist.cpp new file mode 100644 index 0000000000..fb8d026698 --- /dev/null +++ b/xfa/fxfa/parser/cxfa_attachnodelist.cpp @@ -0,0 +1,46 @@ +// Copyright 2016 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 "xfa/fxfa/parser/xfa_object.h" + +CXFA_AttachNodeList::CXFA_AttachNodeList(CXFA_Document* pDocument, + CXFA_Node* pAttachNode) + : CXFA_NodeList(pDocument) { + m_pAttachNode = pAttachNode; +} + +int32_t CXFA_AttachNodeList::GetLength() { + return m_pAttachNode->CountChildren( + XFA_Element::Unknown, + m_pAttachNode->GetElementType() == XFA_Element::Subform); +} + +FX_BOOL CXFA_AttachNodeList::Append(CXFA_Node* pNode) { + CXFA_Node* pParent = pNode->GetNodeItem(XFA_NODEITEM_Parent); + if (pParent) { + pParent->RemoveChild(pNode); + } + return m_pAttachNode->InsertChild(pNode); +} + +FX_BOOL CXFA_AttachNodeList::Insert(CXFA_Node* pNewNode, + CXFA_Node* pBeforeNode) { + CXFA_Node* pParent = pNewNode->GetNodeItem(XFA_NODEITEM_Parent); + if (pParent) { + pParent->RemoveChild(pNewNode); + } + return m_pAttachNode->InsertChild(pNewNode, pBeforeNode); +} + +FX_BOOL CXFA_AttachNodeList::Remove(CXFA_Node* pNode) { + return m_pAttachNode->RemoveChild(pNode); +} + +CXFA_Node* CXFA_AttachNodeList::Item(int32_t iIndex) { + return m_pAttachNode->GetChild( + iIndex, XFA_Element::Unknown, + m_pAttachNode->GetElementType() == XFA_Element::Subform); +} diff --git a/xfa/fxfa/parser/cxfa_node.cpp b/xfa/fxfa/parser/cxfa_node.cpp new file mode 100644 index 0000000000..fffd24e1d5 --- /dev/null +++ b/xfa/fxfa/parser/cxfa_node.cpp @@ -0,0 +1,5172 @@ +// Copyright 2016 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 "xfa/fxfa/parser/xfa_object.h" + +#include +#include + +#include "core/fxcrt/include/fx_ext.h" +#include "fxjs/include/cfxjse_value.h" +#include "third_party/base/stl_util.h" +#include "xfa/fde/xml/fde_xml_imp.h" +#include "xfa/fgas/crt/fgas_codepage.h" +#include "xfa/fgas/crt/fgas_system.h" +#include "xfa/fxfa/app/xfa_ffnotify.h" +#include "xfa/fxfa/include/cxfa_eventparam.h" +#include "xfa/fxfa/parser/cxfa_occur.h" +#include "xfa/fxfa/parser/cxfa_simple_parser.h" +#include "xfa/fxfa/parser/xfa_basic_data.h" +#include "xfa/fxfa/parser/xfa_document.h" +#include "xfa/fxfa/parser/xfa_document_layout_imp.h" +#include "xfa/fxfa/parser/xfa_script_imp.h" + +namespace { + +void XFA_DeleteWideString(void* pData) { + delete static_cast(pData); +} + +void XFA_CopyWideString(void*& pData) { + if (pData) { + CFX_WideString* pNewData = new CFX_WideString(*(CFX_WideString*)pData); + pData = pNewData; + } +} + +XFA_MAPDATABLOCKCALLBACKINFO deleteWideStringCallBack = {XFA_DeleteWideString, + XFA_CopyWideString}; + +void XFA_DataNodeDeleteBindItem(void* pData) { + delete static_cast(pData); +} + +XFA_MAPDATABLOCKCALLBACKINFO deleteBindItemCallBack = { + XFA_DataNodeDeleteBindItem, nullptr}; + +int32_t GetCount(CXFA_Node* pInstMgrNode) { + ASSERT(pInstMgrNode); + int32_t iCount = 0; + uint32_t dwNameHash = 0; + for (CXFA_Node* pNode = pInstMgrNode->GetNodeItem(XFA_NODEITEM_NextSibling); + pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { + XFA_Element eCurType = pNode->GetElementType(); + if (eCurType == XFA_Element::InstanceManager) + break; + if ((eCurType != XFA_Element::Subform) && + (eCurType != XFA_Element::SubformSet)) { + continue; + } + if (iCount == 0) { + CFX_WideStringC wsName = pNode->GetCData(XFA_ATTRIBUTE_Name); + CFX_WideStringC wsInstName = pInstMgrNode->GetCData(XFA_ATTRIBUTE_Name); + if (wsInstName.GetLength() < 1 || wsInstName.GetAt(0) != '_' || + wsInstName.Mid(1) != wsName) { + return iCount; + } + dwNameHash = pNode->GetNameHash(); + } + if (dwNameHash != pNode->GetNameHash()) + break; + + iCount++; + } + return iCount; +} + +void SortNodeArrayByDocumentIdx(const CXFA_NodeSet& rgNodeSet, + CXFA_NodeArray& rgNodeArray, + CFX_ArrayTemplate& rgIdxArray) { + int32_t iCount = pdfium::CollectionSize(rgNodeSet); + rgNodeArray.SetSize(iCount); + rgIdxArray.SetSize(iCount); + if (iCount == 0) + return; + + int32_t iIndex = -1; + int32_t iTotalIndex = -1; + CXFA_Node* pCommonParent = + (*rgNodeSet.begin())->GetNodeItem(XFA_NODEITEM_Parent); + for (CXFA_Node* pNode = pCommonParent->GetNodeItem(XFA_NODEITEM_FirstChild); + pNode && iIndex < iCount; + pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { + iTotalIndex++; + if (pdfium::ContainsValue(rgNodeSet, pNode)) { + iIndex++; + rgNodeArray[iIndex] = pNode; + rgIdxArray[iIndex] = iTotalIndex; + } + } +} + +using CXFA_NodeSetPair = std::pair; +using CXFA_NodeSetPairMap = + std::map>; +using CXFA_NodeSetPairMapMap = + std::map>; + +CXFA_NodeSetPair* NodeSetPairForNode(CXFA_Node* pNode, + CXFA_NodeSetPairMapMap* pMap) { + CXFA_Node* pParentNode = pNode->GetNodeItem(XFA_NODEITEM_Parent); + uint32_t dwNameHash = pNode->GetNameHash(); + if (!pParentNode || !dwNameHash) + return nullptr; + + if (!(*pMap)[pParentNode]) + (*pMap)[pParentNode].reset(new CXFA_NodeSetPairMap); + + CXFA_NodeSetPairMap* pNodeSetPairMap = (*pMap)[pParentNode].get(); + if (!(*pNodeSetPairMap)[dwNameHash]) + (*pNodeSetPairMap)[dwNameHash].reset(new CXFA_NodeSetPair); + + return (*pNodeSetPairMap)[dwNameHash].get(); +} + +void ReorderDataNodes(const CXFA_NodeSet& sSet1, + const CXFA_NodeSet& sSet2, + FX_BOOL bInsertBefore) { + CXFA_NodeSetPairMapMap rgMap; + for (CXFA_Node* pNode : sSet1) { + CXFA_NodeSetPair* pNodeSetPair = NodeSetPairForNode(pNode, &rgMap); + if (pNodeSetPair) + pNodeSetPair->first.insert(pNode); + } + for (CXFA_Node* pNode : sSet2) { + CXFA_NodeSetPair* pNodeSetPair = NodeSetPairForNode(pNode, &rgMap); + if (pNodeSetPair) { + if (pdfium::ContainsValue(pNodeSetPair->first, pNode)) + pNodeSetPair->first.erase(pNode); + else + pNodeSetPair->second.insert(pNode); + } + } + for (const auto& iter1 : rgMap) { + CXFA_NodeSetPairMap* pNodeSetPairMap = iter1.second.get(); + if (!pNodeSetPairMap) + continue; + + for (const auto& iter2 : *pNodeSetPairMap) { + CXFA_NodeSetPair* pNodeSetPair = iter2.second.get(); + if (!pNodeSetPair) + continue; + if (!pNodeSetPair->first.empty() && !pNodeSetPair->second.empty()) { + CXFA_NodeArray rgNodeArray1; + CXFA_NodeArray rgNodeArray2; + CFX_ArrayTemplate rgIdxArray1; + CFX_ArrayTemplate rgIdxArray2; + SortNodeArrayByDocumentIdx(pNodeSetPair->first, rgNodeArray1, + rgIdxArray1); + SortNodeArrayByDocumentIdx(pNodeSetPair->second, rgNodeArray2, + rgIdxArray2); + CXFA_Node* pParentNode = nullptr; + CXFA_Node* pBeforeNode = nullptr; + if (bInsertBefore) { + pBeforeNode = rgNodeArray2[0]; + pParentNode = pBeforeNode->GetNodeItem(XFA_NODEITEM_Parent); + } else { + CXFA_Node* pLastNode = rgNodeArray2[rgIdxArray2.GetSize() - 1]; + pParentNode = pLastNode->GetNodeItem(XFA_NODEITEM_Parent); + pBeforeNode = pLastNode->GetNodeItem(XFA_NODEITEM_NextSibling); + } + for (int32_t iIdx = 0; iIdx < rgIdxArray1.GetSize(); iIdx++) { + CXFA_Node* pCurNode = rgNodeArray1[iIdx]; + pParentNode->RemoveChild(pCurNode); + pParentNode->InsertChild(pCurNode, pBeforeNode); + } + } + } + pNodeSetPairMap->clear(); + } +} + +CXFA_Node* GetItem(CXFA_Node* pInstMgrNode, int32_t iIndex) { + ASSERT(pInstMgrNode); + int32_t iCount = 0; + uint32_t dwNameHash = 0; + for (CXFA_Node* pNode = pInstMgrNode->GetNodeItem(XFA_NODEITEM_NextSibling); + pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { + XFA_Element eCurType = pNode->GetElementType(); + if (eCurType == XFA_Element::InstanceManager) + break; + if ((eCurType != XFA_Element::Subform) && + (eCurType != XFA_Element::SubformSet)) { + continue; + } + if (iCount == 0) { + CFX_WideStringC wsName = pNode->GetCData(XFA_ATTRIBUTE_Name); + CFX_WideStringC wsInstName = pInstMgrNode->GetCData(XFA_ATTRIBUTE_Name); + if (wsInstName.GetLength() < 1 || wsInstName.GetAt(0) != '_' || + wsInstName.Mid(1) != wsName) { + return nullptr; + } + dwNameHash = pNode->GetNameHash(); + } + if (dwNameHash != pNode->GetNameHash()) + break; + + iCount++; + if (iCount > iIndex) + return pNode; + } + return nullptr; +} + +void InsertItem(CXFA_Node* pInstMgrNode, + CXFA_Node* pNewInstance, + int32_t iPos, + int32_t iCount = -1, + FX_BOOL bMoveDataBindingNodes = TRUE) { + if (iCount < 0) + iCount = GetCount(pInstMgrNode); + if (iPos < 0) + iPos = iCount; + if (iPos == iCount) { + CXFA_Node* pNextSibling = + iCount > 0 + ? GetItem(pInstMgrNode, iCount - 1) + ->GetNodeItem(XFA_NODEITEM_NextSibling) + : pInstMgrNode->GetNodeItem(XFA_NODEITEM_NextSibling); + pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent) + ->InsertChild(pNewInstance, pNextSibling); + if (bMoveDataBindingNodes) { + CXFA_NodeSet sNew; + CXFA_NodeSet sAfter; + CXFA_NodeIteratorTemplate + sIteratorNew(pNewInstance); + for (CXFA_Node* pNode = sIteratorNew.GetCurrent(); pNode; + pNode = sIteratorNew.MoveToNext()) { + CXFA_Node* pDataNode = pNode->GetBindData(); + if (!pDataNode) + continue; + + sNew.insert(pDataNode); + } + CXFA_NodeIteratorTemplate + sIteratorAfter(pNextSibling); + for (CXFA_Node* pNode = sIteratorAfter.GetCurrent(); pNode; + pNode = sIteratorAfter.MoveToNext()) { + CXFA_Node* pDataNode = pNode->GetBindData(); + if (!pDataNode) + continue; + + sAfter.insert(pDataNode); + } + ReorderDataNodes(sNew, sAfter, FALSE); + } + } else { + CXFA_Node* pBeforeInstance = GetItem(pInstMgrNode, iPos); + pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent) + ->InsertChild(pNewInstance, pBeforeInstance); + if (bMoveDataBindingNodes) { + CXFA_NodeSet sNew; + CXFA_NodeSet sBefore; + CXFA_NodeIteratorTemplate + sIteratorNew(pNewInstance); + for (CXFA_Node* pNode = sIteratorNew.GetCurrent(); pNode; + pNode = sIteratorNew.MoveToNext()) { + CXFA_Node* pDataNode = pNode->GetBindData(); + if (!pDataNode) + continue; + + sNew.insert(pDataNode); + } + CXFA_NodeIteratorTemplate + sIteratorBefore(pBeforeInstance); + for (CXFA_Node* pNode = sIteratorBefore.GetCurrent(); pNode; + pNode = sIteratorBefore.MoveToNext()) { + CXFA_Node* pDataNode = pNode->GetBindData(); + if (!pDataNode) + continue; + + sBefore.insert(pDataNode); + } + ReorderDataNodes(sNew, sBefore, TRUE); + } + } +} + +void RemoveItem(CXFA_Node* pInstMgrNode, + CXFA_Node* pRemoveInstance, + FX_BOOL bRemoveDataBinding = TRUE) { + pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent)->RemoveChild(pRemoveInstance); + if (!bRemoveDataBinding) + return; + + CXFA_NodeIteratorTemplate + sIterator(pRemoveInstance); + for (CXFA_Node* pFormNode = sIterator.GetCurrent(); pFormNode; + pFormNode = sIterator.MoveToNext()) { + CXFA_Node* pDataNode = pFormNode->GetBindData(); + if (!pDataNode) + continue; + + if (pDataNode->RemoveBindItem(pFormNode) == 0) { + if (CXFA_Node* pDataParent = + pDataNode->GetNodeItem(XFA_NODEITEM_Parent)) { + pDataParent->RemoveChild(pDataNode); + } + } + pFormNode->SetObject(XFA_ATTRIBUTE_BindingNode, nullptr); + } +} + +CXFA_Node* CreateInstance(CXFA_Node* pInstMgrNode, FX_BOOL bDataMerge) { + CXFA_Document* pDocument = pInstMgrNode->GetDocument(); + CXFA_Node* pTemplateNode = pInstMgrNode->GetTemplateNode(); + CXFA_Node* pFormParent = pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent); + CXFA_Node* pDataScope = nullptr; + for (CXFA_Node* pRootBoundNode = pFormParent; + pRootBoundNode && pRootBoundNode->IsContainerNode(); + pRootBoundNode = pRootBoundNode->GetNodeItem(XFA_NODEITEM_Parent)) { + pDataScope = pRootBoundNode->GetBindData(); + if (pDataScope) + break; + } + if (!pDataScope) { + pDataScope = ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Record)); + ASSERT(pDataScope); + } + CXFA_Node* pInstance = pDocument->DataMerge_CopyContainer( + pTemplateNode, pFormParent, pDataScope, TRUE, bDataMerge, TRUE); + if (pInstance) { + pDocument->DataMerge_UpdateBindingRelations(pInstance); + pFormParent->RemoveChild(pInstance); + } + return pInstance; +} + +struct XFA_ExecEventParaInfo { + public: + uint32_t m_uHash; + const FX_WCHAR* m_lpcEventName; + XFA_EVENTTYPE m_eventType; + uint32_t m_validFlags; +}; +static const XFA_ExecEventParaInfo gs_eventParaInfos[] = { + {0x02a6c55a, L"postSubmit", XFA_EVENT_PostSubmit, 0}, + {0x0ab466bb, L"preSubmit", XFA_EVENT_PreSubmit, 0}, + {0x109d7ce7, L"mouseEnter", XFA_EVENT_MouseEnter, 5}, + {0x17fad373, L"postPrint", XFA_EVENT_PostPrint, 0}, + {0x1bfc72d9, L"preOpen", XFA_EVENT_PreOpen, 7}, + {0x2196a452, L"initialize", XFA_EVENT_Initialize, 1}, + {0x27410f03, L"mouseExit", XFA_EVENT_MouseExit, 5}, + {0x33c43dec, L"docClose", XFA_EVENT_DocClose, 0}, + {0x361fa1b6, L"preSave", XFA_EVENT_PreSave, 0}, + {0x36f1c6d8, L"preSign", XFA_EVENT_PreSign, 6}, + {0x4731d6ba, L"exit", XFA_EVENT_Exit, 2}, + {0x56bf456b, L"docReady", XFA_EVENT_DocReady, 0}, + {0x7233018a, L"validate", XFA_EVENT_Validate, 1}, + {0x8808385e, L"indexChange", XFA_EVENT_IndexChange, 3}, + {0x891f4606, L"change", XFA_EVENT_Change, 4}, + {0x9528a7b4, L"prePrint", XFA_EVENT_PrePrint, 0}, + {0x9f693b21, L"mouseDown", XFA_EVENT_MouseDown, 5}, + {0xcdce56b3, L"full", XFA_EVENT_Full, 4}, + {0xd576d08e, L"mouseUp", XFA_EVENT_MouseUp, 5}, + {0xd95657a6, L"click", XFA_EVENT_Click, 4}, + {0xdbfbe02e, L"calculate", XFA_EVENT_Calculate, 1}, + {0xe25fa7b8, L"postOpen", XFA_EVENT_PostOpen, 7}, + {0xe28dce7e, L"enter", XFA_EVENT_Enter, 2}, + {0xfc82d695, L"postSave", XFA_EVENT_PostSave, 0}, + {0xfd54fbb7, L"postSign", XFA_EVENT_PostSign, 6}, +}; + +const XFA_ExecEventParaInfo* GetEventParaInfoByName( + const CFX_WideStringC& 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; +} + +void StrToRGB(const CFX_WideString& strRGB, + int32_t& r, + int32_t& g, + int32_t& b) { + r = 0; + g = 0; + b = 0; + + FX_WCHAR zero = '0'; + int32_t iIndex = 0; + int32_t iLen = strRGB.GetLength(); + for (int32_t i = 0; i < iLen; ++i) { + FX_WCHAR ch = strRGB.GetAt(i); + if (ch == L',') + ++iIndex; + if (iIndex > 2) + break; + + int32_t iValue = ch - zero; + 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; + } + } + } +} + +enum XFA_KEYTYPE { + XFA_KEYTYPE_Custom, + XFA_KEYTYPE_Element, +}; + +void* GetMapKey_Custom(const CFX_WideStringC& 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(eType) << 16) | + (eAttribute << 8) | XFA_KEYTYPE_Element); +} + +} // namespace + +static void XFA_DefaultFreeData(void* pData) {} + +static XFA_MAPDATABLOCKCALLBACKINFO gs_XFADefaultFreeData = { + XFA_DefaultFreeData, nullptr}; + +XFA_MAPMODULEDATA::XFA_MAPMODULEDATA() {} + +XFA_MAPMODULEDATA::~XFA_MAPMODULEDATA() {} + +CXFA_Node::CXFA_Node(CXFA_Document* pDoc, + uint16_t ePacket, + XFA_ObjectType oType, + XFA_Element eType, + const CFX_WideStringC& elementName) + : CXFA_Object(pDoc, oType, eType, elementName), + m_pNext(nullptr), + m_pChild(nullptr), + m_pLastChild(nullptr), + m_pParent(nullptr), + m_pXMLNode(nullptr), + m_ePacket(ePacket), + m_uNodeFlags(XFA_NodeFlag_None), + m_dwNameHash(0), + m_pAuxNode(nullptr), + m_pMapModuleData(nullptr) { + ASSERT(m_pDocument); +} + +CXFA_Node::~CXFA_Node() { + ASSERT(!m_pParent); + RemoveMapModuleKey(); + CXFA_Node* pNode = m_pChild; + while (pNode) { + CXFA_Node* pNext = pNode->m_pNext; + pNode->m_pParent = nullptr; + delete pNode; + pNode = pNext; + } + if (m_pXMLNode && IsOwnXMLNode()) + m_pXMLNode->Release(); +} + +CXFA_Node* CXFA_Node::Clone(FX_BOOL bRecursive) { + CXFA_Node* pClone = m_pDocument->CreateNode(m_ePacket, m_elementType); + if (!pClone) + return nullptr; + + MergeAllData(pClone); + pClone->UpdateNameHash(); + if (IsNeedSavingXMLNode()) { + CFDE_XMLNode* pCloneXML = nullptr; + if (IsAttributeInXML()) { + CFX_WideString wsName; + GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE); + CFDE_XMLElement* pCloneXMLElement = new CFDE_XMLElement(wsName); + CFX_WideStringC wsValue = GetCData(XFA_ATTRIBUTE_Value); + if (!wsValue.IsEmpty()) { + pCloneXMLElement->SetTextData(CFX_WideString(wsValue)); + } + pCloneXML = pCloneXMLElement; + pCloneXMLElement = nullptr; + pClone->SetEnum(XFA_ATTRIBUTE_Contains, XFA_ATTRIBUTEENUM_Unknown); + } else { + pCloneXML = m_pXMLNode->Clone(FALSE); + } + pClone->SetXMLMappingNode(pCloneXML); + pClone->SetFlag(XFA_NodeFlag_OwnXMLNode, false); + } + if (bRecursive) { + for (CXFA_Node* pChild = GetNodeItem(XFA_NODEITEM_FirstChild); pChild; + pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) { + pClone->InsertChild(pChild->Clone(bRecursive)); + } + } + pClone->SetFlag(XFA_NodeFlag_Initialized, true); + pClone->SetObject(XFA_ATTRIBUTE_BindingNode, nullptr); + return pClone; +} + +CXFA_Node* CXFA_Node::GetNodeItem(XFA_NODEITEM eItem) const { + switch (eItem) { + case XFA_NODEITEM_NextSibling: + return m_pNext; + case XFA_NODEITEM_FirstChild: + return m_pChild; + case XFA_NODEITEM_Parent: + return m_pParent; + case XFA_NODEITEM_PrevSibling: + if (m_pParent) { + CXFA_Node* pSibling = m_pParent->m_pChild; + CXFA_Node* pPrev = nullptr; + while (pSibling && pSibling != this) { + pPrev = pSibling; + pSibling = pSibling->m_pNext; + } + return pPrev; + } + return nullptr; + default: + break; + } + return nullptr; +} + +CXFA_Node* CXFA_Node::GetNodeItem(XFA_NODEITEM eItem, + XFA_ObjectType eType) const { + CXFA_Node* pNode = nullptr; + switch (eItem) { + case XFA_NODEITEM_NextSibling: + pNode = m_pNext; + while (pNode && pNode->GetObjectType() != eType) + pNode = pNode->m_pNext; + break; + case XFA_NODEITEM_FirstChild: + pNode = m_pChild; + while (pNode && pNode->GetObjectType() != eType) + pNode = pNode->m_pNext; + break; + case XFA_NODEITEM_Parent: + pNode = m_pParent; + while (pNode && pNode->GetObjectType() != eType) + pNode = pNode->m_pParent; + break; + case XFA_NODEITEM_PrevSibling: + if (m_pParent) { + CXFA_Node* pSibling = m_pParent->m_pChild; + while (pSibling && pSibling != this) { + if (eType == pSibling->GetObjectType()) + pNode = pSibling; + + pSibling = pSibling->m_pNext; + } + } + break; + default: + break; + } + return pNode; +} + +int32_t CXFA_Node::GetNodeList(CXFA_NodeArray& nodes, + uint32_t dwTypeFilter, + XFA_Element eTypeFilter, + int32_t iLevel) { + if (--iLevel < 0) { + return nodes.GetSize(); + } + if (eTypeFilter != XFA_Element::Unknown) { + CXFA_Node* pChild = m_pChild; + while (pChild) { + if (pChild->GetElementType() == eTypeFilter) { + nodes.Add(pChild); + if (iLevel > 0) { + GetNodeList(nodes, dwTypeFilter, eTypeFilter, iLevel); + } + } + pChild = pChild->m_pNext; + } + } else if (dwTypeFilter == + (XFA_NODEFILTER_Children | XFA_NODEFILTER_Properties)) { + CXFA_Node* pChild = m_pChild; + while (pChild) { + nodes.Add(pChild); + if (iLevel > 0) { + GetNodeList(nodes, dwTypeFilter, eTypeFilter, iLevel); + } + pChild = pChild->m_pNext; + } + } else if (dwTypeFilter != 0) { + bool bFilterChildren = !!(dwTypeFilter & XFA_NODEFILTER_Children); + bool bFilterProperties = !!(dwTypeFilter & XFA_NODEFILTER_Properties); + bool bFilterOneOfProperties = + !!(dwTypeFilter & XFA_NODEFILTER_OneOfProperty); + CXFA_Node* pChild = m_pChild; + while (pChild) { + const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement( + GetElementType(), pChild->GetElementType(), XFA_XDPPACKET_UNKNOWN); + if (pProperty) { + if (bFilterProperties) { + nodes.Add(pChild); + } else if (bFilterOneOfProperties && + (pProperty->uFlags & XFA_PROPERTYFLAG_OneOf)) { + nodes.Add(pChild); + } else if (bFilterChildren && + (pChild->GetElementType() == XFA_Element::Variables || + pChild->GetElementType() == XFA_Element::PageSet)) { + nodes.Add(pChild); + } + } else if (bFilterChildren) { + nodes.Add(pChild); + } + pChild = pChild->m_pNext; + } + if (bFilterOneOfProperties && nodes.GetSize() < 1) { + int32_t iProperties = 0; + const XFA_PROPERTY* pProperty = + XFA_GetElementProperties(GetElementType(), iProperties); + if (!pProperty || iProperties < 1) + return 0; + for (int32_t i = 0; i < iProperties; i++) { + if (pProperty[i].uFlags & XFA_PROPERTYFLAG_DefaultOneOf) { + const XFA_PACKETINFO* pPacket = XFA_GetPacketByID(GetPacketID()); + CXFA_Node* pNewNode = + m_pDocument->CreateNode(pPacket, pProperty[i].eName); + if (!pNewNode) + break; + InsertChild(pNewNode, nullptr); + pNewNode->SetFlag(XFA_NodeFlag_Initialized, true); + nodes.Add(pNewNode); + break; + } + } + } + } + return nodes.GetSize(); +} + +CXFA_Node* CXFA_Node::CreateSamePacketNode(XFA_Element eType, + uint32_t dwFlags) { + CXFA_Node* pNode = m_pDocument->CreateNode(m_ePacket, eType); + pNode->SetFlag(dwFlags, true); + return pNode; +} + +CXFA_Node* CXFA_Node::CloneTemplateToForm(FX_BOOL bRecursive) { + ASSERT(m_ePacket == XFA_XDPPACKET_Template); + CXFA_Node* pClone = + m_pDocument->CreateNode(XFA_XDPPACKET_Form, m_elementType); + if (!pClone) + return nullptr; + + pClone->SetTemplateNode(this); + pClone->UpdateNameHash(); + pClone->SetXMLMappingNode(GetXMLMappingNode()); + if (bRecursive) { + for (CXFA_Node* pChild = GetNodeItem(XFA_NODEITEM_FirstChild); pChild; + pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) { + pClone->InsertChild(pChild->CloneTemplateToForm(bRecursive)); + } + } + pClone->SetFlag(XFA_NodeFlag_Initialized, true); + return pClone; +} + +CXFA_Node* CXFA_Node::GetTemplateNode() const { + return m_pAuxNode; +} + +void CXFA_Node::SetTemplateNode(CXFA_Node* pTemplateNode) { + m_pAuxNode = pTemplateNode; +} + +CXFA_Node* CXFA_Node::GetBindData() { + ASSERT(GetPacketID() == XFA_XDPPACKET_Form); + return static_cast(GetObject(XFA_ATTRIBUTE_BindingNode)); +} + +int32_t CXFA_Node::GetBindItems(CXFA_NodeArray& formItems) { + if (BindsFormItems()) { + CXFA_NodeArray* pItems = nullptr; + TryObject(XFA_ATTRIBUTE_BindingNode, (void*&)pItems); + formItems.Copy(*pItems); + return formItems.GetSize(); + } + CXFA_Node* pFormNode = + static_cast(GetObject(XFA_ATTRIBUTE_BindingNode)); + if (pFormNode) + formItems.Add(pFormNode); + return formItems.GetSize(); +} + +int32_t CXFA_Node::AddBindItem(CXFA_Node* pFormNode) { + ASSERT(pFormNode); + if (BindsFormItems()) { + CXFA_NodeArray* pItems = nullptr; + TryObject(XFA_ATTRIBUTE_BindingNode, (void*&)pItems); + ASSERT(pItems); + if (pItems->Find(pFormNode) < 0) { + pItems->Add(pFormNode); + } + return pItems->GetSize(); + } + CXFA_Node* pOldFormItem = + static_cast(GetObject(XFA_ATTRIBUTE_BindingNode)); + if (!pOldFormItem) { + SetObject(XFA_ATTRIBUTE_BindingNode, pFormNode); + return 1; + } else if (pOldFormItem == pFormNode) { + return 1; + } + CXFA_NodeArray* pItems = new CXFA_NodeArray; + SetObject(XFA_ATTRIBUTE_BindingNode, pItems, &deleteBindItemCallBack); + pItems->Add(pOldFormItem); + pItems->Add(pFormNode); + m_uNodeFlags |= XFA_NodeFlag_BindFormItems; + return 2; +} + +int32_t CXFA_Node::RemoveBindItem(CXFA_Node* pFormNode) { + if (BindsFormItems()) { + CXFA_NodeArray* pItems = nullptr; + TryObject(XFA_ATTRIBUTE_BindingNode, (void*&)pItems); + ASSERT(pItems); + int32_t iIndex = pItems->Find(pFormNode); + int32_t iCount = pItems->GetSize(); + if (iIndex >= 0) { + if (iIndex != iCount - 1) + pItems->SetAt(iIndex, pItems->GetAt(iCount - 1)); + pItems->RemoveAt(iCount - 1); + if (iCount == 2) { + CXFA_Node* pLastFormNode = pItems->GetAt(0); + SetObject(XFA_ATTRIBUTE_BindingNode, pLastFormNode); + m_uNodeFlags &= ~XFA_NodeFlag_BindFormItems; + } + iCount--; + } + return iCount; + } + CXFA_Node* pOldFormItem = + static_cast(GetObject(XFA_ATTRIBUTE_BindingNode)); + if (pOldFormItem == pFormNode) { + SetObject(XFA_ATTRIBUTE_BindingNode, nullptr); + pOldFormItem = nullptr; + } + return pOldFormItem ? 1 : 0; +} + +FX_BOOL CXFA_Node::HasBindItem() { + return GetPacketID() == XFA_XDPPACKET_Datasets && + GetObject(XFA_ATTRIBUTE_BindingNode); +} + +CXFA_WidgetData* CXFA_Node::GetWidgetData() { + return (CXFA_WidgetData*)GetObject(XFA_ATTRIBUTE_WidgetData); +} + +CXFA_WidgetData* CXFA_Node::GetContainerWidgetData() { + if (GetPacketID() != XFA_XDPPACKET_Form) + return nullptr; + XFA_Element eType = GetElementType(); + if (eType == XFA_Element::ExclGroup) + return nullptr; + CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent); + if (pParentNode && pParentNode->GetElementType() == XFA_Element::ExclGroup) + return nullptr; + + if (eType == XFA_Element::Field) { + CXFA_WidgetData* pFieldWidgetData = GetWidgetData(); + if (pFieldWidgetData && + pFieldWidgetData->GetChoiceListOpen() == + XFA_ATTRIBUTEENUM_MultiSelect) { + return nullptr; + } else { + CFX_WideString wsPicture; + if (pFieldWidgetData) { + pFieldWidgetData->GetPictureContent(wsPicture, + XFA_VALUEPICTURE_DataBind); + } + if (!wsPicture.IsEmpty()) + return pFieldWidgetData; + CXFA_Node* pDataNode = GetBindData(); + if (!pDataNode) + return nullptr; + pFieldWidgetData = nullptr; + CXFA_NodeArray formNodes; + pDataNode->GetBindItems(formNodes); + for (int32_t i = 0; i < formNodes.GetSize(); i++) { + CXFA_Node* pFormNode = formNodes.GetAt(i); + if (!pFormNode || pFormNode->HasRemovedChildren()) + continue; + pFieldWidgetData = pFormNode->GetWidgetData(); + if (pFieldWidgetData) { + pFieldWidgetData->GetPictureContent(wsPicture, + XFA_VALUEPICTURE_DataBind); + } + if (!wsPicture.IsEmpty()) + break; + pFieldWidgetData = nullptr; + } + return pFieldWidgetData; + } + } + CXFA_Node* pGrandNode = + pParentNode ? pParentNode->GetNodeItem(XFA_NODEITEM_Parent) : nullptr; + CXFA_Node* pValueNode = + (pParentNode && pParentNode->GetElementType() == XFA_Element::Value) + ? pParentNode + : nullptr; + if (!pValueNode) { + pValueNode = + (pGrandNode && pGrandNode->GetElementType() == XFA_Element::Value) + ? pGrandNode + : nullptr; + } + CXFA_Node* pParentOfValueNode = + pValueNode ? pValueNode->GetNodeItem(XFA_NODEITEM_Parent) : nullptr; + return pParentOfValueNode ? pParentOfValueNode->GetContainerWidgetData() + : nullptr; +} + +FX_BOOL CXFA_Node::GetLocaleName(CFX_WideString& wsLocaleName) { + CXFA_Node* pForm = GetDocument()->GetXFAObject(XFA_HASHCODE_Form)->AsNode(); + CXFA_Node* pTopSubform = pForm->GetFirstChildByClass(XFA_Element::Subform); + ASSERT(pTopSubform); + CXFA_Node* pLocaleNode = this; + FX_BOOL bLocale = FALSE; + do { + bLocale = pLocaleNode->TryCData(XFA_ATTRIBUTE_Locale, wsLocaleName, FALSE); + if (!bLocale) { + pLocaleNode = pLocaleNode->GetNodeItem(XFA_NODEITEM_Parent); + } + } while (pLocaleNode && pLocaleNode != pTopSubform && !bLocale); + if (bLocale) + return TRUE; + CXFA_Node* pConfig = ToNode(GetDocument()->GetXFAObject(XFA_HASHCODE_Config)); + wsLocaleName = GetDocument()->GetLocalMgr()->GetConfigLocaleName(pConfig); + if (!wsLocaleName.IsEmpty()) + return TRUE; + if (pTopSubform && + pTopSubform->TryCData(XFA_ATTRIBUTE_Locale, wsLocaleName, FALSE)) { + return TRUE; + } + IFX_Locale* pLocale = GetDocument()->GetLocalMgr()->GetDefLocale(); + if (pLocale) { + wsLocaleName = pLocale->GetName(); + return TRUE; + } + return FALSE; +} + +XFA_ATTRIBUTEENUM CXFA_Node::GetIntact() { + CXFA_Node* pKeep = GetFirstChildByClass(XFA_Element::Keep); + XFA_ATTRIBUTEENUM eLayoutType = GetEnum(XFA_ATTRIBUTE_Layout); + if (pKeep) { + XFA_ATTRIBUTEENUM eIntact; + if (pKeep->TryEnum(XFA_ATTRIBUTE_Intact, eIntact, FALSE)) { + if (eIntact == XFA_ATTRIBUTEENUM_None && + eLayoutType == XFA_ATTRIBUTEENUM_Row && + m_pDocument->GetCurVersionMode() < XFA_VERSION_208) { + CXFA_Node* pPreviewRow = GetNodeItem(XFA_NODEITEM_PrevSibling, + XFA_ObjectType::ContainerNode); + if (pPreviewRow && + pPreviewRow->GetEnum(XFA_ATTRIBUTE_Layout) == + XFA_ATTRIBUTEENUM_Row) { + XFA_ATTRIBUTEENUM eValue; + if (pKeep->TryEnum(XFA_ATTRIBUTE_Previous, eValue, FALSE) && + (eValue == XFA_ATTRIBUTEENUM_ContentArea || + eValue == XFA_ATTRIBUTEENUM_PageArea)) { + return XFA_ATTRIBUTEENUM_ContentArea; + } + CXFA_Node* pNode = + pPreviewRow->GetFirstChildByClass(XFA_Element::Keep); + if (pNode && pNode->TryEnum(XFA_ATTRIBUTE_Next, eValue, FALSE) && + (eValue == XFA_ATTRIBUTEENUM_ContentArea || + eValue == XFA_ATTRIBUTEENUM_PageArea)) { + return XFA_ATTRIBUTEENUM_ContentArea; + } + } + } + return eIntact; + } + } + switch (GetElementType()) { + case XFA_Element::Subform: + switch (eLayoutType) { + case XFA_ATTRIBUTEENUM_Position: + case XFA_ATTRIBUTEENUM_Row: + return XFA_ATTRIBUTEENUM_ContentArea; + case XFA_ATTRIBUTEENUM_Tb: + case XFA_ATTRIBUTEENUM_Table: + case XFA_ATTRIBUTEENUM_Lr_tb: + case XFA_ATTRIBUTEENUM_Rl_tb: + return XFA_ATTRIBUTEENUM_None; + default: + break; + } + break; + case XFA_Element::Field: { + CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent); + if (!pParentNode || + pParentNode->GetElementType() == XFA_Element::PageArea) + return XFA_ATTRIBUTEENUM_ContentArea; + if (pParentNode->GetIntact() == XFA_ATTRIBUTEENUM_None) { + XFA_ATTRIBUTEENUM eParLayout = + pParentNode->GetEnum(XFA_ATTRIBUTE_Layout); + if (eParLayout == XFA_ATTRIBUTEENUM_Position || + eParLayout == XFA_ATTRIBUTEENUM_Row || + eParLayout == XFA_ATTRIBUTEENUM_Table) { + return XFA_ATTRIBUTEENUM_None; + } + XFA_VERSION version = m_pDocument->GetCurVersionMode(); + if (eParLayout == XFA_ATTRIBUTEENUM_Tb && version < XFA_VERSION_208) { + CXFA_Measurement measureH; + if (TryMeasure(XFA_ATTRIBUTE_H, measureH, FALSE)) + return XFA_ATTRIBUTEENUM_ContentArea; + } + return XFA_ATTRIBUTEENUM_None; + } + return XFA_ATTRIBUTEENUM_ContentArea; + } + case XFA_Element::Draw: + return XFA_ATTRIBUTEENUM_ContentArea; + default: + break; + } + return XFA_ATTRIBUTEENUM_None; +} + +CXFA_Node* CXFA_Node::GetDataDescriptionNode() { + if (m_ePacket == XFA_XDPPACKET_Datasets) + return m_pAuxNode; + return nullptr; +} + +void CXFA_Node::SetDataDescriptionNode(CXFA_Node* pDataDescriptionNode) { + ASSERT(m_ePacket == XFA_XDPPACKET_Datasets); + m_pAuxNode = pDataDescriptionNode; +} + +void CXFA_Node::Script_TreeClass_ResolveNode(CFXJSE_Arguments* pArguments) { + int32_t iLength = pArguments->GetLength(); + if (iLength != 1) { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"resolveNode"); + return; + } + CFX_WideString wsExpression = + CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC()); + CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext(); + if (!pScriptContext) + return; + CXFA_Node* refNode = this; + if (refNode->GetElementType() == XFA_Element::Xfa) + refNode = ToNode(pScriptContext->GetThisObject()); + uint32_t dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes | + XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent | + XFA_RESOLVENODE_Siblings; + XFA_RESOLVENODE_RS resoveNodeRS; + int32_t iRet = pScriptContext->ResolveObjects( + refNode, wsExpression.AsStringC(), resoveNodeRS, dwFlag); + if (iRet < 1) { + pArguments->GetReturnValue()->SetNull(); + return; + } + if (resoveNodeRS.dwFlags == XFA_RESOVENODE_RSTYPE_Nodes) { + CXFA_Object* pNode = resoveNodeRS.nodes[0]; + pArguments->GetReturnValue()->Assign( + pScriptContext->GetJSValueFromMap(pNode)); + } else { + const XFA_SCRIPTATTRIBUTEINFO* lpAttributeInfo = + resoveNodeRS.pScriptAttribute; + if (lpAttributeInfo && lpAttributeInfo->eValueType == XFA_SCRIPT_Object) { + std::unique_ptr pValue( + new CFXJSE_Value(pScriptContext->GetRuntime())); + (resoveNodeRS.nodes[0]->*(lpAttributeInfo->lpfnCallback))( + pValue.get(), FALSE, (XFA_ATTRIBUTE)lpAttributeInfo->eAttribute); + pArguments->GetReturnValue()->Assign(pValue.get()); + } else { + pArguments->GetReturnValue()->SetNull(); + } + } +} + +void CXFA_Node::Script_TreeClass_ResolveNodes(CFXJSE_Arguments* pArguments) { + int32_t iLength = pArguments->GetLength(); + if (iLength != 1) { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"resolveNodes"); + return; + } + CFX_WideString wsExpression = + CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC()); + CFXJSE_Value* pValue = pArguments->GetReturnValue(); + if (!pValue) + return; + uint32_t dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes | + XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent | + XFA_RESOLVENODE_Siblings; + CXFA_Node* refNode = this; + if (refNode->GetElementType() == XFA_Element::Xfa) + refNode = ToNode(m_pDocument->GetScriptContext()->GetThisObject()); + Script_Som_ResolveNodeList(pValue, wsExpression, dwFlag, refNode); +} + +void CXFA_Node::Script_Som_ResolveNodeList(CFXJSE_Value* pValue, + CFX_WideString wsExpression, + uint32_t dwFlag, + CXFA_Node* refNode) { + CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext(); + if (!pScriptContext) + return; + XFA_RESOLVENODE_RS resoveNodeRS; + if (!refNode) + refNode = this; + pScriptContext->ResolveObjects(refNode, wsExpression.AsStringC(), + resoveNodeRS, dwFlag); + CXFA_ArrayNodeList* pNodeList = new CXFA_ArrayNodeList(m_pDocument); + if (resoveNodeRS.dwFlags == XFA_RESOVENODE_RSTYPE_Nodes) { + for (int32_t i = 0; i < resoveNodeRS.nodes.GetSize(); i++) { + if (resoveNodeRS.nodes[i]->IsNode()) + pNodeList->Append(resoveNodeRS.nodes[i]->AsNode()); + } + } else { + CXFA_ValueArray valueArray(pScriptContext->GetRuntime()); + if (resoveNodeRS.GetAttributeResult(valueArray) > 0) { + CXFA_ObjArray objectArray; + valueArray.GetAttributeObject(objectArray); + for (int32_t i = 0; i < objectArray.GetSize(); i++) { + if (objectArray[i]->IsNode()) + pNodeList->Append(objectArray[i]->AsNode()); + } + } + } + pValue->SetObject(pNodeList, pScriptContext->GetJseNormalClass()); +} + +void CXFA_Node::Script_TreeClass_All(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + ThrowException(XFA_IDS_INVAlID_PROP_SET); + } else { + uint32_t dwFlag = XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_ALL; + CFX_WideString wsName; + GetAttribute(XFA_ATTRIBUTE_Name, wsName); + CFX_WideString wsExpression = wsName + FX_WSTRC(L"[*]"); + Script_Som_ResolveNodeList(pValue, wsExpression, dwFlag); + } +} + +void CXFA_Node::Script_TreeClass_Nodes(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext(); + if (!pScriptContext) + return; + if (bSetting) { + IXFA_AppProvider* pAppProvider = m_pDocument->GetNotify()->GetAppProvider(); + ASSERT(pAppProvider); + CFX_WideString wsMessage; + pAppProvider->LoadString(XFA_IDS_Unable_TO_SET, wsMessage); + FXJSE_ThrowMessage( + FX_UTF8Encode(wsMessage.c_str(), wsMessage.GetLength()).AsStringC()); + } else { + CXFA_AttachNodeList* pNodeList = new CXFA_AttachNodeList(m_pDocument, this); + pValue->SetObject(pNodeList, pScriptContext->GetJseNormalClass()); + } +} + +void CXFA_Node::Script_TreeClass_ClassAll(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + ThrowException(XFA_IDS_INVAlID_PROP_SET); + } else { + uint32_t dwFlag = XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_ALL; + CFX_WideString wsExpression = + FX_WSTRC(L"#") + GetClassName() + FX_WSTRC(L"[*]"); + Script_Som_ResolveNodeList(pValue, wsExpression, dwFlag); + } +} + +void CXFA_Node::Script_TreeClass_Parent(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + ThrowException(XFA_IDS_INVAlID_PROP_SET); + } else { + CXFA_Node* pParent = GetNodeItem(XFA_NODEITEM_Parent); + if (pParent) { + pValue->Assign( + m_pDocument->GetScriptContext()->GetJSValueFromMap(pParent)); + } else { + pValue->SetNull(); + } + } +} + +void CXFA_Node::Script_TreeClass_Index(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) + ThrowException(XFA_IDS_INVAlID_PROP_SET); + else + pValue->SetInteger(GetNodeSameNameIndex()); +} + +void CXFA_Node::Script_TreeClass_ClassIndex(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) + ThrowException(XFA_IDS_INVAlID_PROP_SET); + else + pValue->SetInteger(GetNodeSameClassIndex()); +} + +void CXFA_Node::Script_TreeClass_SomExpression(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + ThrowException(XFA_IDS_INVAlID_PROP_SET); + } else { + CFX_WideString wsSOMExpression; + GetSOMExpression(wsSOMExpression); + pValue->SetString(FX_UTF8Encode(wsSOMExpression).AsStringC()); + } +} + +void CXFA_Node::Script_NodeClass_ApplyXSL(CFXJSE_Arguments* pArguments) { + int32_t iLength = pArguments->GetLength(); + if (iLength != 1) { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"applyXSL"); + return; + } + CFX_WideString wsExpression = + CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC()); + // TODO(weili): check whether we need to implement this, pdfium:501. + // For now, just put the variables here to avoid unused variable warning. + (void)wsExpression; +} + +void CXFA_Node::Script_NodeClass_AssignNode(CFXJSE_Arguments* pArguments) { + int32_t iLength = pArguments->GetLength(); + if (iLength < 1 || iLength > 3) { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"assignNode"); + return; + } + CFX_WideString wsExpression; + CFX_WideString wsValue; + int32_t iAction = 0; + wsExpression = + CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC()); + if (iLength >= 2) { + wsValue = + CFX_WideString::FromUTF8(pArguments->GetUTF8String(1).AsStringC()); + } + if (iLength >= 3) + iAction = pArguments->GetInt32(2); + // TODO(weili): check whether we need to implement this, pdfium:501. + // For now, just put the variables here to avoid unused variable warning. + (void)wsExpression; + (void)wsValue; + (void)iAction; +} + +void CXFA_Node::Script_NodeClass_Clone(CFXJSE_Arguments* pArguments) { + int32_t iLength = pArguments->GetLength(); + if (iLength != 1) { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"clone"); + return; + } + bool bClone = !!pArguments->GetInt32(0); + CXFA_Node* pCloneNode = Clone(bClone); + pArguments->GetReturnValue()->Assign( + m_pDocument->GetScriptContext()->GetJSValueFromMap(pCloneNode)); +} + +void CXFA_Node::Script_NodeClass_GetAttribute(CFXJSE_Arguments* pArguments) { + int32_t iLength = pArguments->GetLength(); + if (iLength != 1) { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getAttribute"); + return; + } + CFX_WideString wsExpression = + CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC()); + CFX_WideString wsValue; + GetAttribute(wsExpression.AsStringC(), wsValue); + CFXJSE_Value* pValue = pArguments->GetReturnValue(); + if (pValue) + pValue->SetString(FX_UTF8Encode(wsValue).AsStringC()); +} + +void CXFA_Node::Script_NodeClass_GetElement(CFXJSE_Arguments* pArguments) { + int32_t iLength = pArguments->GetLength(); + if (iLength < 1 || iLength > 2) { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getElement"); + return; + } + CFX_WideString wsExpression; + int32_t iValue = 0; + wsExpression = + CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC()); + if (iLength >= 2) + iValue = pArguments->GetInt32(1); + CXFA_Node* pNode = + GetProperty(iValue, XFA_GetElementTypeForName(wsExpression.AsStringC())); + pArguments->GetReturnValue()->Assign( + m_pDocument->GetScriptContext()->GetJSValueFromMap(pNode)); +} + +void CXFA_Node::Script_NodeClass_IsPropertySpecified( + CFXJSE_Arguments* pArguments) { + int32_t iLength = pArguments->GetLength(); + if (iLength < 1 || iLength > 3) { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"isPropertySpecified"); + return; + } + CFX_WideString wsExpression; + bool bParent = true; + int32_t iIndex = 0; + wsExpression = + CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC()); + if (iLength >= 2) + bParent = !!pArguments->GetInt32(1); + if (iLength >= 3) + iIndex = pArguments->GetInt32(2); + FX_BOOL bHas = FALSE; + const XFA_ATTRIBUTEINFO* pAttributeInfo = + XFA_GetAttributeByName(wsExpression.AsStringC()); + CFX_WideString wsValue; + if (pAttributeInfo) + bHas = HasAttribute(pAttributeInfo->eName); + if (!bHas) { + XFA_Element eType = XFA_GetElementTypeForName(wsExpression.AsStringC()); + bHas = !!GetProperty(iIndex, eType); + if (!bHas && bParent && m_pParent) { + // Also check on the parent. + bHas = m_pParent->HasAttribute(pAttributeInfo->eName); + if (!bHas) + bHas = !!m_pParent->GetProperty(iIndex, eType); + } + } + CFXJSE_Value* pValue = pArguments->GetReturnValue(); + if (pValue) + pValue->SetBoolean(bHas); +} + +void CXFA_Node::Script_NodeClass_LoadXML(CFXJSE_Arguments* pArguments) { + int32_t iLength = pArguments->GetLength(); + if (iLength < 1 || iLength > 3) { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"loadXML"); + return; + } + CFX_WideString wsExpression; + bool bIgnoreRoot = true; + bool bOverwrite = 0; + wsExpression = + CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC()); + if (wsExpression.IsEmpty()) + return; + if (iLength >= 2) + bIgnoreRoot = !!pArguments->GetInt32(1); + if (iLength >= 3) + bOverwrite = !!pArguments->GetInt32(2); + std::unique_ptr pParser( + new CXFA_SimpleParser(m_pDocument, false)); + if (!pParser) + return; + CFDE_XMLNode* pXMLNode = nullptr; + int32_t iParserStatus = + pParser->ParseXMLData(wsExpression, pXMLNode, nullptr); + if (iParserStatus != XFA_PARSESTATUS_Done || !pXMLNode) + return; + if (bIgnoreRoot && + (pXMLNode->GetType() != FDE_XMLNODE_Element || + XFA_RecognizeRichText(static_cast(pXMLNode)))) { + bIgnoreRoot = false; + } + CXFA_Node* pFakeRoot = Clone(FALSE); + CFX_WideStringC wsContentType = GetCData(XFA_ATTRIBUTE_ContentType); + if (!wsContentType.IsEmpty()) { + pFakeRoot->SetCData(XFA_ATTRIBUTE_ContentType, + CFX_WideString(wsContentType)); + } + CFDE_XMLNode* pFakeXMLRoot = pFakeRoot->GetXMLMappingNode(); + if (!pFakeXMLRoot) { + CFDE_XMLNode* pThisXMLRoot = GetXMLMappingNode(); + pFakeXMLRoot = pThisXMLRoot ? pThisXMLRoot->Clone(FALSE) : nullptr; + } + if (!pFakeXMLRoot) + pFakeXMLRoot = new CFDE_XMLElement(CFX_WideString(GetClassName())); + + if (bIgnoreRoot) { + CFDE_XMLNode* pXMLChild = pXMLNode->GetNodeItem(CFDE_XMLNode::FirstChild); + while (pXMLChild) { + CFDE_XMLNode* pXMLSibling = + pXMLChild->GetNodeItem(CFDE_XMLNode::NextSibling); + pXMLNode->RemoveChildNode(pXMLChild); + pFakeXMLRoot->InsertChildNode(pXMLChild); + pXMLChild = pXMLSibling; + } + } else { + CFDE_XMLNode* pXMLParent = pXMLNode->GetNodeItem(CFDE_XMLNode::Parent); + if (pXMLParent) { + pXMLParent->RemoveChildNode(pXMLNode); + } + pFakeXMLRoot->InsertChildNode(pXMLNode); + } + pParser->ConstructXFANode(pFakeRoot, pFakeXMLRoot); + pFakeRoot = pParser->GetRootNode(); + if (pFakeRoot) { + if (bOverwrite) { + CXFA_Node* pChild = 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); + InsertChild(index++, pNewChild); + pNewChild->SetFlag(XFA_NodeFlag_Initialized, true); + pNewChild = pItem; + } + while (pChild) { + CXFA_Node* pItem = pChild->GetNodeItem(XFA_NODEITEM_NextSibling); + RemoveChild(pChild); + pFakeRoot->InsertChild(pChild); + pChild = pItem; + } + if (GetPacketID() == XFA_XDPPACKET_Form && + GetElementType() == XFA_Element::ExData) { + CFDE_XMLNode* pTempXMLNode = GetXMLMappingNode(); + SetXMLMappingNode(pFakeXMLRoot); + SetFlag(XFA_NodeFlag_OwnXMLNode, false); + if (pTempXMLNode && !pTempXMLNode->GetNodeItem(CFDE_XMLNode::Parent)) { + pFakeXMLRoot = pTempXMLNode; + } else { + pFakeXMLRoot = nullptr; + } + } + MoveBufferMapData(pFakeRoot, this, XFA_CalcData, TRUE); + } else { + CXFA_Node* pChild = pFakeRoot->GetNodeItem(XFA_NODEITEM_FirstChild); + while (pChild) { + CXFA_Node* pItem = pChild->GetNodeItem(XFA_NODEITEM_NextSibling); + pFakeRoot->RemoveChild(pChild); + InsertChild(pChild); + pChild->SetFlag(XFA_NodeFlag_Initialized, true); + pChild = pItem; + } + } + if (pFakeXMLRoot) { + pFakeRoot->SetXMLMappingNode(pFakeXMLRoot); + pFakeRoot->SetFlag(XFA_NodeFlag_OwnXMLNode, false); + } + pFakeRoot->SetFlag(XFA_NodeFlag_HasRemovedChildren, false); + } else { + if (pFakeXMLRoot) { + pFakeXMLRoot->Release(); + pFakeXMLRoot = nullptr; + } + } +} + +void CXFA_Node::Script_NodeClass_SaveFilteredXML(CFXJSE_Arguments* pArguments) { + // TODO(weili): Check whether we need to implement this, pdfium:501. +} + +void CXFA_Node::Script_NodeClass_SaveXML(CFXJSE_Arguments* pArguments) { + int32_t iLength = pArguments->GetLength(); + if (iLength < 0 || iLength > 1) { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"saveXML"); + return; + } + bool bPrettyMode = false; + if (iLength == 1) { + if (pArguments->GetUTF8String(0) != "pretty") { + ThrowException(XFA_IDS_ARGUMENT_MISMATCH); + return; + } + bPrettyMode = true; + } + CFX_ByteStringC bsXMLHeader = "\n"; + if (GetPacketID() == XFA_XDPPACKET_Form || + GetPacketID() == XFA_XDPPACKET_Datasets) { + CFDE_XMLNode* pElement = nullptr; + if (GetPacketID() == XFA_XDPPACKET_Datasets) { + pElement = GetXMLMappingNode(); + if (!pElement || pElement->GetType() != FDE_XMLNODE_Element) { + pArguments->GetReturnValue()->SetString(bsXMLHeader); + return; + } + XFA_DataExporter_DealWithDataGroupNode(this); + } + std::unique_ptr> + pMemoryStream(FX_CreateMemoryStream(TRUE)); + std::unique_ptr> pStream( + IFX_Stream::CreateStream( + static_cast(pMemoryStream.get()), + FX_STREAMACCESS_Text | FX_STREAMACCESS_Write | + FX_STREAMACCESS_Append)); + if (!pStream) { + pArguments->GetReturnValue()->SetString(bsXMLHeader); + return; + } + pStream->SetCodePage(FX_CODEPAGE_UTF8); + pStream->WriteData(bsXMLHeader.raw_str(), bsXMLHeader.GetLength()); + if (GetPacketID() == XFA_XDPPACKET_Form) + XFA_DataExporter_RegenerateFormFile(this, pStream.get(), nullptr, TRUE); + else + pElement->SaveXMLNode(pStream.get()); + // TODO(weili): Check whether we need to save pretty print XML, pdfium:501. + // For now, just put it here to avoid unused variable warning. + (void)bPrettyMode; + pArguments->GetReturnValue()->SetString( + CFX_ByteStringC(pMemoryStream->GetBuffer(), pMemoryStream->GetSize())); + return; + } + pArguments->GetReturnValue()->SetString(""); +} + +void CXFA_Node::Script_NodeClass_SetAttribute(CFXJSE_Arguments* pArguments) { + int32_t iLength = pArguments->GetLength(); + if (iLength != 2) { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"setAttribute"); + return; + } + CFX_WideString wsAttributeValue = + CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC()); + CFX_WideString wsAttribute = + CFX_WideString::FromUTF8(pArguments->GetUTF8String(1).AsStringC()); + SetAttribute(wsAttribute.AsStringC(), wsAttributeValue.AsStringC(), true); +} + +void CXFA_Node::Script_NodeClass_SetElement(CFXJSE_Arguments* pArguments) { + int32_t iLength = pArguments->GetLength(); + if (iLength != 1 && iLength != 2) { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"setElement"); + return; + } + CXFA_Node* pNode = nullptr; + CFX_WideString wsName; + pNode = static_cast(pArguments->GetObject(0)); + if (iLength == 2) + wsName = CFX_WideString::FromUTF8(pArguments->GetUTF8String(1).AsStringC()); + // TODO(weili): check whether we need to implement this, pdfium:501. + // For now, just put the variables here to avoid unused variable warning. + (void)pNode; + (void)wsName; +} + +void CXFA_Node::Script_NodeClass_Ns(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + ThrowException(XFA_IDS_INVAlID_PROP_SET); + } else { + CFX_WideString wsNameSpace; + TryNamespace(wsNameSpace); + pValue->SetString(FX_UTF8Encode(wsNameSpace).AsStringC()); + } +} + +void CXFA_Node::Script_NodeClass_Model(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + ThrowException(XFA_IDS_INVAlID_PROP_SET); + } else { + pValue->Assign( + m_pDocument->GetScriptContext()->GetJSValueFromMap(GetModelNode())); + } +} + +void CXFA_Node::Script_NodeClass_IsContainer(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) + ThrowException(XFA_IDS_INVAlID_PROP_SET); + else + pValue->SetBoolean(IsContainerNode()); +} + +void CXFA_Node::Script_NodeClass_IsNull(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + ThrowException(XFA_IDS_INVAlID_PROP_SET); + } else { + if (GetElementType() == XFA_Element::Subform) { + pValue->SetBoolean(FALSE); + return; + } + CFX_WideString strValue; + pValue->SetBoolean(!TryContent(strValue) || strValue.IsEmpty()); + } +} + +void CXFA_Node::Script_NodeClass_OneOfChild(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + ThrowException(XFA_IDS_INVAlID_PROP_SET); + } else { + CXFA_NodeArray properts; + int32_t iSize = GetNodeList(properts, XFA_NODEFILTER_OneOfProperty); + if (iSize > 0) { + pValue->Assign( + m_pDocument->GetScriptContext()->GetJSValueFromMap(properts[0])); + } + } +} + +void CXFA_Node::Script_ContainerClass_GetDelta(CFXJSE_Arguments* pArguments) {} + +void CXFA_Node::Script_ContainerClass_GetDeltas(CFXJSE_Arguments* pArguments) { + CXFA_ArrayNodeList* pFormNodes = new CXFA_ArrayNodeList(m_pDocument); + pArguments->GetReturnValue()->SetObject( + pFormNodes, m_pDocument->GetScriptContext()->GetJseNormalClass()); +} +void CXFA_Node::Script_ModelClass_ClearErrorList(CFXJSE_Arguments* pArguments) { +} + +void CXFA_Node::Script_ModelClass_CreateNode(CFXJSE_Arguments* pArguments) { + Script_Template_CreateNode(pArguments); +} + +void CXFA_Node::Script_ModelClass_IsCompatibleNS(CFXJSE_Arguments* pArguments) { + int32_t iLength = pArguments->GetLength(); + if (iLength < 1) { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"isCompatibleNS"); + return; + } + CFX_WideString wsNameSpace; + if (iLength >= 1) { + CFX_ByteString bsNameSpace = pArguments->GetUTF8String(0); + wsNameSpace = CFX_WideString::FromUTF8(bsNameSpace.AsStringC()); + } + CFX_WideString wsNodeNameSpace; + TryNamespace(wsNodeNameSpace); + CFXJSE_Value* pValue = pArguments->GetReturnValue(); + if (pValue) + pValue->SetBoolean(wsNodeNameSpace == wsNameSpace); +} + +void CXFA_Node::Script_ModelClass_Context(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) {} + +void CXFA_Node::Script_ModelClass_AliasNode(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) {} + +void CXFA_Node::Script_Attribute_Integer(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + SetInteger(eAttribute, pValue->ToInteger(), true); + } else { + pValue->SetInteger(GetInteger(eAttribute)); + } +} + +void CXFA_Node::Script_Attribute_IntegerRead(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (!bSetting) { + pValue->SetInteger(GetInteger(eAttribute)); + } else { + ThrowException(XFA_IDS_INVAlID_PROP_SET); + } +} + +void CXFA_Node::Script_Attribute_BOOL(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + SetBoolean(eAttribute, pValue->ToBoolean(), true); + } else { + pValue->SetString(GetBoolean(eAttribute) ? "1" : "0"); + } +} + +void CXFA_Node::Script_Attribute_BOOLRead(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (!bSetting) { + pValue->SetString(GetBoolean(eAttribute) ? "1" : "0"); + } else { + ThrowException(XFA_IDS_INVAlID_PROP_SET); + } +} + +void CXFA_Node::Script_Attribute_SendAttributeChangeMessage( + XFA_ATTRIBUTE eAttribute, + FX_BOOL bScriptModify) { + CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor(); + if (!pLayoutPro) + return; + + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (!pNotify) + return; + + uint32_t dwPacket = GetPacketID(); + if (!(dwPacket & XFA_XDPPACKET_Form)) { + pNotify->OnValueChanged(this, eAttribute, this, this); + return; + } + + bool bNeedFindContainer = false; + switch (GetElementType()) { + case XFA_Element::Caption: + bNeedFindContainer = true; + pNotify->OnValueChanged(this, eAttribute, this, + GetNodeItem(XFA_NODEITEM_Parent)); + break; + case XFA_Element::Font: + case XFA_Element::Para: { + bNeedFindContainer = true; + CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent); + if (pParentNode->GetElementType() == XFA_Element::Caption) { + pNotify->OnValueChanged(this, eAttribute, pParentNode, + pParentNode->GetNodeItem(XFA_NODEITEM_Parent)); + } else { + pNotify->OnValueChanged(this, eAttribute, this, pParentNode); + } + } break; + case XFA_Element::Margin: { + bNeedFindContainer = true; + CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent); + XFA_Element eParentType = pParentNode->GetElementType(); + if (pParentNode->IsContainerNode()) { + pNotify->OnValueChanged(this, eAttribute, this, pParentNode); + } else if (eParentType == XFA_Element::Caption) { + pNotify->OnValueChanged(this, eAttribute, pParentNode, + pParentNode->GetNodeItem(XFA_NODEITEM_Parent)); + } else { + CXFA_Node* pNode = pParentNode->GetNodeItem(XFA_NODEITEM_Parent); + if (pNode && pNode->GetElementType() == XFA_Element::Ui) { + pNotify->OnValueChanged(this, eAttribute, pNode, + pNode->GetNodeItem(XFA_NODEITEM_Parent)); + } + } + } break; + case XFA_Element::Comb: { + CXFA_Node* pEditNode = GetNodeItem(XFA_NODEITEM_Parent); + XFA_Element eUIType = pEditNode->GetElementType(); + if (pEditNode && (eUIType == XFA_Element::DateTimeEdit || + eUIType == XFA_Element::NumericEdit || + eUIType == XFA_Element::TextEdit)) { + CXFA_Node* pUINode = pEditNode->GetNodeItem(XFA_NODEITEM_Parent); + if (pUINode) { + pNotify->OnValueChanged(this, eAttribute, pUINode, + pUINode->GetNodeItem(XFA_NODEITEM_Parent)); + } + } + } break; + case XFA_Element::Button: + case XFA_Element::Barcode: + case XFA_Element::ChoiceList: + case XFA_Element::DateTimeEdit: + case XFA_Element::NumericEdit: + case XFA_Element::PasswordEdit: + case XFA_Element::TextEdit: { + CXFA_Node* pUINode = GetNodeItem(XFA_NODEITEM_Parent); + if (pUINode) { + pNotify->OnValueChanged(this, eAttribute, pUINode, + pUINode->GetNodeItem(XFA_NODEITEM_Parent)); + } + } break; + case XFA_Element::CheckButton: { + bNeedFindContainer = true; + CXFA_Node* pUINode = GetNodeItem(XFA_NODEITEM_Parent); + if (pUINode) { + pNotify->OnValueChanged(this, eAttribute, pUINode, + pUINode->GetNodeItem(XFA_NODEITEM_Parent)); + } + } break; + case XFA_Element::Keep: + case XFA_Element::Bookend: + case XFA_Element::Break: + case XFA_Element::BreakAfter: + case XFA_Element::BreakBefore: + case XFA_Element::Overflow: + bNeedFindContainer = true; + break; + case XFA_Element::Area: + case XFA_Element::Draw: + case XFA_Element::ExclGroup: + case XFA_Element::Field: + case XFA_Element::Subform: + case XFA_Element::SubformSet: + pLayoutPro->AddChangedContainer(this); + pNotify->OnValueChanged(this, eAttribute, this, this); + break; + case XFA_Element::Sharptext: + case XFA_Element::Sharpxml: + case XFA_Element::SharpxHTML: { + CXFA_Node* pTextNode = GetNodeItem(XFA_NODEITEM_Parent); + if (!pTextNode) { + return; + } + CXFA_Node* pValueNode = pTextNode->GetNodeItem(XFA_NODEITEM_Parent); + if (!pValueNode) { + return; + } + XFA_Element eType = pValueNode->GetElementType(); + if (eType == XFA_Element::Value) { + bNeedFindContainer = true; + CXFA_Node* pNode = pValueNode->GetNodeItem(XFA_NODEITEM_Parent); + if (pNode && pNode->IsContainerNode()) { + if (bScriptModify) { + pValueNode = pNode; + } + pNotify->OnValueChanged(this, eAttribute, pValueNode, pNode); + } else { + pNotify->OnValueChanged(this, eAttribute, pNode, + pNode->GetNodeItem(XFA_NODEITEM_Parent)); + } + } else { + if (eType == XFA_Element::Items) { + CXFA_Node* pNode = pValueNode->GetNodeItem(XFA_NODEITEM_Parent); + if (pNode && pNode->IsContainerNode()) { + pNotify->OnValueChanged(this, eAttribute, pValueNode, pNode); + } + } + } + } break; + default: + break; + } + if (bNeedFindContainer) { + CXFA_Node* pParent = this; + while (pParent) { + if (pParent->IsContainerNode()) + break; + + pParent = pParent->GetNodeItem(XFA_NODEITEM_Parent); + } + if (pParent) { + pLayoutPro->AddChangedContainer(pParent); + } + } +} + +void CXFA_Node::Script_Attribute_String(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + CFX_WideString wsValue = pValue->ToWideString(); + SetAttribute(eAttribute, wsValue.AsStringC(), true); + if (eAttribute == XFA_ATTRIBUTE_Use && + GetElementType() == XFA_Element::Desc) { + CXFA_Node* pTemplateNode = + ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Template)); + CXFA_Node* pProtoRoot = + pTemplateNode->GetFirstChildByClass(XFA_Element::Subform) + ->GetFirstChildByClass(XFA_Element::Proto); + + CFX_WideString wsID; + CFX_WideString wsSOM; + if (!wsValue.IsEmpty()) { + if (wsValue[0] == '#') { + wsID = CFX_WideString(wsValue.c_str() + 1, wsValue.GetLength() - 1); + } else { + wsSOM = wsValue; + } + } + CXFA_Node* pProtoNode = nullptr; + if (!wsSOM.IsEmpty()) { + uint32_t dwFlag = XFA_RESOLVENODE_Children | + XFA_RESOLVENODE_Attributes | + XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent | + XFA_RESOLVENODE_Siblings; + XFA_RESOLVENODE_RS resoveNodeRS; + int32_t iRet = m_pDocument->GetScriptContext()->ResolveObjects( + pProtoRoot, wsSOM.AsStringC(), resoveNodeRS, dwFlag); + if (iRet > 0 && resoveNodeRS.nodes[0]->IsNode()) { + pProtoNode = resoveNodeRS.nodes[0]->AsNode(); + } + } else if (!wsID.IsEmpty()) { + pProtoNode = m_pDocument->GetNodeByID(pProtoRoot, wsID.AsStringC()); + } + if (pProtoNode) { + CXFA_Node* pHeadChild = GetNodeItem(XFA_NODEITEM_FirstChild); + while (pHeadChild) { + CXFA_Node* pSibling = + pHeadChild->GetNodeItem(XFA_NODEITEM_NextSibling); + RemoveChild(pHeadChild); + pHeadChild = pSibling; + } + 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); + InsertChild(pHeadChild); + pHeadChild = pSibling; + } + m_pDocument->RemovePurgeNode(pProtoForm); + delete pProtoForm; + } + } + } else { + CFX_WideString wsValue; + GetAttribute(eAttribute, wsValue); + pValue->SetString( + FX_UTF8Encode(wsValue.c_str(), wsValue.GetLength()).AsStringC()); + } +} + +void CXFA_Node::Script_Attribute_StringRead(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (!bSetting) { + CFX_WideString wsValue; + GetAttribute(eAttribute, wsValue); + pValue->SetString( + FX_UTF8Encode(wsValue.c_str(), wsValue.GetLength()).AsStringC()); + } else { + ThrowException(XFA_IDS_INVAlID_PROP_SET); + } +} + +void CXFA_Node::Script_WsdlConnection_Execute(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if ((argc == 0) || (argc == 1)) { + pArguments->GetReturnValue()->SetBoolean(FALSE); + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execute"); + } +} + +void CXFA_Node::Script_Delta_Restore(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"restore"); + } +} + +void CXFA_Node::Script_Delta_CurrentValue(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) {} + +void CXFA_Node::Script_Delta_SavedValue(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) {} + +void CXFA_Node::Script_Delta_Target(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) {} + +void CXFA_Node::Script_Som_Message(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_SOM_MESSAGETYPE iMessageType) { + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + return; + } + FX_BOOL bNew = FALSE; + CXFA_Validate validate = pWidgetData->GetValidate(); + if (!validate) { + validate = pWidgetData->GetValidate(TRUE); + bNew = TRUE; + } + if (bSetting) { + switch (iMessageType) { + case XFA_SOM_ValidationMessage: + validate.SetScriptMessageText(pValue->ToWideString()); + break; + case XFA_SOM_FormatMessage: + validate.SetFormatMessageText(pValue->ToWideString()); + break; + case XFA_SOM_MandatoryMessage: + validate.SetNullMessageText(pValue->ToWideString()); + break; + default: + break; + } + if (!bNew) { + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (!pNotify) { + return; + } + pNotify->AddCalcValidate(this); + } + } else { + CFX_WideString wsMessage; + switch (iMessageType) { + case XFA_SOM_ValidationMessage: + validate.GetScriptMessageText(wsMessage); + break; + case XFA_SOM_FormatMessage: + validate.GetFormatMessageText(wsMessage); + break; + case XFA_SOM_MandatoryMessage: + validate.GetNullMessageText(wsMessage); + break; + default: + break; + } + pValue->SetString(FX_UTF8Encode(wsMessage).AsStringC()); + } +} + +void CXFA_Node::Script_Som_ValidationMessage(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + Script_Som_Message(pValue, bSetting, XFA_SOM_ValidationMessage); +} + +void CXFA_Node::Script_Field_Length(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + ThrowException(XFA_IDS_INVAlID_PROP_SET); + } else { + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + pValue->SetInteger(0); + return; + } + pValue->SetInteger(pWidgetData->CountChoiceListItems(TRUE)); + } +} + +void CXFA_Node::Script_Som_DefaultValue(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + XFA_Element eType = GetElementType(); + if (eType == XFA_Element::Field) { + Script_Field_DefaultValue(pValue, bSetting, eAttribute); + return; + } + if (eType == XFA_Element::Draw) { + Script_Draw_DefaultValue(pValue, bSetting, eAttribute); + return; + } + if (eType == XFA_Element::Boolean) { + Script_Boolean_Value(pValue, bSetting, eAttribute); + return; + } + if (bSetting) { + CFX_WideString wsNewValue; + if (!(pValue && (pValue->IsNull() || pValue->IsUndefined()))) + wsNewValue = pValue->ToWideString(); + + CFX_WideString wsFormatValue(wsNewValue); + CXFA_WidgetData* pContainerWidgetData = nullptr; + if (GetPacketID() == XFA_XDPPACKET_Datasets) { + CXFA_NodeArray formNodes; + GetBindItems(formNodes); + CFX_WideString wsPicture; + for (int32_t i = 0; i < formNodes.GetSize(); i++) { + CXFA_Node* pFormNode = formNodes.GetAt(i); + if (!pFormNode || pFormNode->HasRemovedChildren()) { + continue; + } + pContainerWidgetData = pFormNode->GetContainerWidgetData(); + if (pContainerWidgetData) { + pContainerWidgetData->GetPictureContent(wsPicture, + XFA_VALUEPICTURE_DataBind); + } + if (!wsPicture.IsEmpty()) { + break; + } + pContainerWidgetData = nullptr; + } + } else if (GetPacketID() == XFA_XDPPACKET_Form) { + pContainerWidgetData = GetContainerWidgetData(); + } + if (pContainerWidgetData) { + pContainerWidgetData->GetFormatDataValue(wsNewValue, wsFormatValue); + } + SetScriptContent(wsNewValue, wsFormatValue, true, TRUE); + } else { + CFX_WideString content = GetScriptContent(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.AsStringC()); + pValue->SetFloat((FX_FLOAT)(double)decimal); + } else { + pValue->SetString( + FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC()); + } + } +} + +void CXFA_Node::Script_Som_DefaultValue_Read(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + ThrowException(XFA_IDS_INVAlID_PROP_SET); + return; + } + CFX_WideString content = GetScriptContent(TRUE); + if (content.IsEmpty()) { + pValue->SetNull(); + } else { + pValue->SetString( + FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC()); + } +} + +void CXFA_Node::Script_Boolean_Value(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + CFX_ByteString newValue; + if (!(pValue && (pValue->IsNull() || pValue->IsUndefined()))) + newValue = pValue->ToString(); + + int32_t iValue = FXSYS_atoi(newValue.c_str()); + CFX_WideString wsNewValue(iValue == 0 ? L"0" : L"1"); + CFX_WideString wsFormatValue(wsNewValue); + CXFA_WidgetData* pContainerWidgetData = GetContainerWidgetData(); + if (pContainerWidgetData) { + pContainerWidgetData->GetFormatDataValue(wsNewValue, wsFormatValue); + } + SetScriptContent(wsNewValue, wsFormatValue, true, TRUE); + } else { + CFX_WideString wsValue = GetScriptContent(TRUE); + pValue->SetBoolean(wsValue == FX_WSTRC(L"1")); + } +} + +void CXFA_Node::Script_Som_BorderColor(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + return; + } + CXFA_Border border = pWidgetData->GetBorder(TRUE); + int32_t iSize = border.CountEdges(); + if (bSetting) { + int32_t r = 0; + int32_t g = 0; + int32_t b = 0; + StrToRGB(pValue->ToWideString(), r, g, b); + FX_ARGB rgb = ArgbEncode(100, r, g, b); + for (int32_t i = 0; i < iSize; ++i) { + CXFA_Edge edge = border.GetEdge(i); + edge.SetColor(rgb); + } + } else { + CXFA_Edge edge = border.GetEdge(0); + FX_ARGB color = edge.GetColor(); + int32_t a, r, g, b; + ArgbDecode(color, a, r, g, b); + CFX_WideString strColor; + strColor.Format(L"%d,%d,%d", r, g, b); + pValue->SetString(FX_UTF8Encode(strColor).AsStringC()); + } +} + +void CXFA_Node::Script_Som_BorderWidth(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + return; + } + CXFA_Border border = pWidgetData->GetBorder(TRUE); + int32_t iSize = border.CountEdges(); + CFX_WideString wsThickness; + if (bSetting) { + wsThickness = pValue->ToWideString(); + for (int32_t i = 0; i < iSize; ++i) { + CXFA_Edge edge = border.GetEdge(i); + CXFA_Measurement thickness(wsThickness.AsStringC()); + edge.SetMSThickness(thickness); + } + } else { + CXFA_Edge edge = border.GetEdge(0); + CXFA_Measurement thickness = edge.GetMSThickness(); + thickness.ToString(wsThickness); + pValue->SetString(FX_UTF8Encode(wsThickness).AsStringC()); + } +} + +void CXFA_Node::Script_Som_FillColor(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + return; + } + CXFA_Border border = pWidgetData->GetBorder(TRUE); + CXFA_Fill borderfill = border.GetFill(TRUE); + CXFA_Node* pNode = borderfill.GetNode(); + if (!pNode) { + return; + } + if (bSetting) { + int32_t r; + int32_t g; + int32_t b; + StrToRGB(pValue->ToWideString(), r, g, b); + FX_ARGB color = ArgbEncode(0xff, r, g, b); + borderfill.SetColor(color); + } else { + FX_ARGB color = borderfill.GetColor(); + int32_t a; + int32_t r; + int32_t g; + int32_t b; + ArgbDecode(color, a, r, g, b); + CFX_WideString wsColor; + wsColor.Format(L"%d,%d,%d", r, g, b); + pValue->SetString(FX_UTF8Encode(wsColor).AsStringC()); + } +} + +void CXFA_Node::Script_Som_DataNode(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (!bSetting) { + CXFA_Node* pDataNode = GetBindData(); + if (pDataNode) { + pValue->Assign( + m_pDocument->GetScriptContext()->GetJSValueFromMap(pDataNode)); + } else { + pValue->SetNull(); + } + } else { + ThrowException(XFA_IDS_INVAlID_PROP_SET); + } +} + +void CXFA_Node::Script_Draw_DefaultValue(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + if (pValue && pValue->IsString()) { + CXFA_WidgetData* pWidgetData = GetWidgetData(); + ASSERT(pWidgetData); + XFA_Element uiType = pWidgetData->GetUIType(); + if (uiType == XFA_Element::Text) { + CFX_WideString wsNewValue = pValue->ToWideString(); + CFX_WideString wsFormatValue(wsNewValue); + SetScriptContent(wsNewValue, wsFormatValue, true, TRUE); + } + } + } else { + CFX_WideString content = GetScriptContent(TRUE); + if (content.IsEmpty()) { + pValue->SetNull(); + } else { + pValue->SetString( + FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC()); + } + } +} + +void CXFA_Node::Script_Field_DefaultValue(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + return; + } + if (bSetting) { + if (pValue && pValue->IsNull()) { + pWidgetData->m_bPreNull = pWidgetData->m_bIsNull; + pWidgetData->m_bIsNull = TRUE; + } else { + pWidgetData->m_bPreNull = pWidgetData->m_bIsNull; + pWidgetData->m_bIsNull = FALSE; + } + CFX_WideString wsNewText; + if (!(pValue && (pValue->IsNull() || pValue->IsUndefined()))) + wsNewText = pValue->ToWideString(); + + CXFA_Node* pUIChild = pWidgetData->GetUIChild(); + if (pUIChild->GetElementType() == XFA_Element::NumericEdit) { + int32_t iLeadDigits = 0; + int32_t iFracDigits = 0; + pWidgetData->GetLeadDigits(iLeadDigits); + pWidgetData->GetFracDigits(iFracDigits); + wsNewText = + pWidgetData->NumericLimit(wsNewText, iLeadDigits, iFracDigits); + } + CXFA_WidgetData* pContainerWidgetData = GetContainerWidgetData(); + CFX_WideString wsFormatText(wsNewText); + if (pContainerWidgetData) { + pContainerWidgetData->GetFormatDataValue(wsNewText, wsFormatText); + } + SetScriptContent(wsNewText, wsFormatText, true, TRUE); + } else { + CFX_WideString content = GetScriptContent(TRUE); + if (content.IsEmpty()) { + pValue->SetNull(); + } else { + CXFA_Node* pUIChild = pWidgetData->GetUIChild(); + CXFA_Value defVal = pWidgetData->GetFormValue(); + CXFA_Node* pNode = defVal.GetNode()->GetNodeItem(XFA_NODEITEM_FirstChild); + if (pNode && pNode->GetElementType() == XFA_Element::Decimal) { + if (pUIChild->GetElementType() == XFA_Element::NumericEdit && + (pNode->GetInteger(XFA_ATTRIBUTE_FracDigits) == -1)) { + pValue->SetString( + FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC()); + } else { + CFX_Decimal decimal(content.AsStringC()); + pValue->SetFloat((FX_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.AsStringC()); + pValue->SetFloat((FX_FLOAT)(double)decimal); + } else { + pValue->SetString( + FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC()); + } + } + } +} + +void CXFA_Node::Script_Field_EditValue(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + return; + } + if (bSetting) { + pWidgetData->SetValue(pValue->ToWideString(), XFA_VALUEPICTURE_Edit); + } else { + CFX_WideString wsValue; + pWidgetData->GetValue(wsValue, XFA_VALUEPICTURE_Edit); + pValue->SetString(FX_UTF8Encode(wsValue).AsStringC()); + } +} + +void CXFA_Node::Script_Som_FontColor(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + return; + } + CXFA_Font font = pWidgetData->GetFont(TRUE); + CXFA_Node* pNode = font.GetNode(); + if (!pNode) { + return; + } + if (bSetting) { + int32_t r; + int32_t g; + int32_t b; + StrToRGB(pValue->ToWideString(), r, g, b); + FX_ARGB color = ArgbEncode(0xff, r, g, b); + font.SetColor(color); + } else { + FX_ARGB color = font.GetColor(); + int32_t a; + int32_t r; + int32_t g; + int32_t b; + ArgbDecode(color, a, r, g, b); + CFX_WideString wsColor; + wsColor.Format(L"%d,%d,%d", r, g, b); + pValue->SetString(FX_UTF8Encode(wsColor).AsStringC()); + } +} + +void CXFA_Node::Script_Field_FormatMessage(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + Script_Som_Message(pValue, bSetting, XFA_SOM_FormatMessage); +} + +void CXFA_Node::Script_Field_FormattedValue(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + return; + } + if (bSetting) { + pWidgetData->SetValue(pValue->ToWideString(), XFA_VALUEPICTURE_Display); + } else { + CFX_WideString wsValue; + pWidgetData->GetValue(wsValue, XFA_VALUEPICTURE_Display); + pValue->SetString(FX_UTF8Encode(wsValue).AsStringC()); + } +} + +void CXFA_Node::Script_Som_Mandatory(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + return; + } + CXFA_Validate validate = pWidgetData->GetValidate(TRUE); + if (bSetting) { + validate.SetNullTest(pValue->ToWideString()); + } else { + int32_t iValue = validate.GetNullTest(); + const XFA_ATTRIBUTEENUMINFO* pInfo = + XFA_GetAttributeEnumByID((XFA_ATTRIBUTEENUM)iValue); + CFX_WideString wsValue; + if (pInfo) + wsValue = pInfo->pName; + pValue->SetString(FX_UTF8Encode(wsValue).AsStringC()); + } +} + +void CXFA_Node::Script_Som_MandatoryMessage(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + Script_Som_Message(pValue, bSetting, XFA_SOM_MandatoryMessage); +} + +void CXFA_Node::Script_Field_ParentSubform(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + ThrowException(XFA_IDS_INVAlID_PROP_SET); + } else { + pValue->SetNull(); + } +} + +void CXFA_Node::Script_Field_SelectedIndex(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + return; + } + if (bSetting) { + int32_t iIndex = pValue->ToInteger(); + if (iIndex == -1) { + pWidgetData->ClearAllSelections(); + return; + } + pWidgetData->SetItemState(iIndex, TRUE, true, TRUE, TRUE); + } else { + pValue->SetInteger(pWidgetData->GetSelectedItem()); + } +} + +void CXFA_Node::Script_Field_ClearItems(CFXJSE_Arguments* pArguments) { + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + return; + } + pWidgetData->DeleteItem(-1, TRUE); +} + +void CXFA_Node::Script_Field_ExecEvent(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 1) { + CFX_ByteString eventString = pArguments->GetUTF8String(0); + int32_t iRet = execSingleEventByName( + CFX_WideString::FromUTF8(eventString.AsStringC()).AsStringC(), + XFA_Element::Field); + if (eventString == "validate") { + pArguments->GetReturnValue()->SetBoolean( + (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE); + } + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent"); + } +} + +void CXFA_Node::Script_Field_ExecInitialize(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (!pNotify) { + return; + } + pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize, FALSE, FALSE); + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execInitialize"); + } +} + +void CXFA_Node::Script_Field_DeleteItem(CFXJSE_Arguments* pArguments) { + int32_t iLength = pArguments->GetLength(); + if (iLength != 1) { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"deleteItem"); + return; + } + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + return; + } + int32_t iIndex = pArguments->GetInt32(0); + FX_BOOL bValue = pWidgetData->DeleteItem(iIndex, TRUE, TRUE); + CFXJSE_Value* pValue = pArguments->GetReturnValue(); + if (pValue) + pValue->SetBoolean(bValue); +} + +void CXFA_Node::Script_Field_GetSaveItem(CFXJSE_Arguments* pArguments) { + int32_t iLength = pArguments->GetLength(); + if (iLength != 1) { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getSaveItem"); + return; + } + int32_t iIndex = pArguments->GetInt32(0); + if (iIndex < 0) { + pArguments->GetReturnValue()->SetNull(); + return; + } + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + pArguments->GetReturnValue()->SetNull(); + return; + } + CFX_WideString wsValue; + FX_BOOL bHasItem = pWidgetData->GetChoiceListItem(wsValue, iIndex, TRUE); + if (bHasItem) { + pArguments->GetReturnValue()->SetString( + FX_UTF8Encode(wsValue.c_str(), wsValue.GetLength()).AsStringC()); + } else { + pArguments->GetReturnValue()->SetNull(); + } +} + +void CXFA_Node::Script_Field_BoundItem(CFXJSE_Arguments* pArguments) { + int32_t iLength = pArguments->GetLength(); + if (iLength != 1) { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"boundItem"); + return; + } + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + return; + } + CFX_ByteString bsValue = pArguments->GetUTF8String(0); + CFX_WideString wsValue = CFX_WideString::FromUTF8(bsValue.AsStringC()); + CFX_WideString wsBoundValue; + pWidgetData->GetItemValue(wsValue.AsStringC(), wsBoundValue); + CFXJSE_Value* pValue = pArguments->GetReturnValue(); + if (pValue) + pValue->SetString(FX_UTF8Encode(wsBoundValue).AsStringC()); +} + +void CXFA_Node::Script_Field_GetItemState(CFXJSE_Arguments* pArguments) { + int32_t iLength = pArguments->GetLength(); + if (iLength != 1) { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getItemState"); + return; + } + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + return; + } + int32_t iIndex = pArguments->GetInt32(0); + FX_BOOL bValue = pWidgetData->GetItemState(iIndex); + CFXJSE_Value* pValue = pArguments->GetReturnValue(); + if (pValue) + pValue->SetBoolean(bValue); +} + +void CXFA_Node::Script_Field_ExecCalculate(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (!pNotify) { + return; + } + pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate, FALSE, FALSE); + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate"); + } +} + +void CXFA_Node::Script_Field_SetItems(CFXJSE_Arguments* pArguments) {} + +void CXFA_Node::Script_Field_GetDisplayItem(CFXJSE_Arguments* pArguments) { + int32_t iLength = pArguments->GetLength(); + if (iLength != 1) { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getDisplayItem"); + return; + } + int32_t iIndex = pArguments->GetInt32(0); + if (iIndex < 0) { + pArguments->GetReturnValue()->SetNull(); + return; + } + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + pArguments->GetReturnValue()->SetNull(); + return; + } + CFX_WideString wsValue; + FX_BOOL bHasItem = pWidgetData->GetChoiceListItem(wsValue, iIndex, FALSE); + if (bHasItem) { + pArguments->GetReturnValue()->SetString( + FX_UTF8Encode(wsValue.c_str(), wsValue.GetLength()).AsStringC()); + } else { + pArguments->GetReturnValue()->SetNull(); + } +} + +void CXFA_Node::Script_Field_SetItemState(CFXJSE_Arguments* pArguments) { + int32_t iLength = pArguments->GetLength(); + if (iLength != 2) { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"setItemState"); + return; + } + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) + return; + + int32_t iIndex = pArguments->GetInt32(0); + if (pArguments->GetInt32(1) != 0) { + pWidgetData->SetItemState(iIndex, TRUE, true, TRUE, TRUE); + } else { + if (pWidgetData->GetItemState(iIndex)) + pWidgetData->SetItemState(iIndex, FALSE, true, TRUE, TRUE); + } +} + +void CXFA_Node::Script_Field_AddItem(CFXJSE_Arguments* pArguments) { + int32_t iLength = pArguments->GetLength(); + if (iLength < 1 || iLength > 2) { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"addItem"); + return; + } + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + return; + } + CFX_WideString wsLabel; + CFX_WideString wsValue; + if (iLength >= 1) { + CFX_ByteString bsLabel = pArguments->GetUTF8String(0); + wsLabel = CFX_WideString::FromUTF8(bsLabel.AsStringC()); + } + if (iLength >= 2) { + CFX_ByteString bsValue = pArguments->GetUTF8String(1); + wsValue = CFX_WideString::FromUTF8(bsValue.AsStringC()); + } + pWidgetData->InsertItem(wsLabel, wsValue, -1, TRUE); +} + +void CXFA_Node::Script_Field_ExecValidate(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (!pNotify) { + pArguments->GetReturnValue()->SetBoolean(FALSE); + } else { + int32_t iRet = + pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate, FALSE, FALSE); + pArguments->GetReturnValue()->SetBoolean( + (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE); + } + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate"); + } +} + +void CXFA_Node::Script_ExclGroup_ErrorText(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (!bSetting) { + } else { + ThrowException(XFA_IDS_INVAlID_PROP_SET); + } +} + +void CXFA_Node::Script_ExclGroup_DefaultAndRawValue(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + return; + } + if (bSetting) { + pWidgetData->SetSelectedMemberByValue(pValue->ToWideString().AsStringC(), + true, TRUE, TRUE); + } else { + CFX_WideString wsValue = GetScriptContent(TRUE); + XFA_VERSION curVersion = GetDocument()->GetCurVersionMode(); + if (wsValue.IsEmpty() && curVersion >= XFA_VERSION_300) { + pValue->SetNull(); + } else { + pValue->SetString(FX_UTF8Encode(wsValue).AsStringC()); + } + } +} + +void CXFA_Node::Script_ExclGroup_Transient(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) {} + +void CXFA_Node::Script_ExclGroup_ExecEvent(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 1) { + CFX_ByteString eventString = pArguments->GetUTF8String(0); + execSingleEventByName( + CFX_WideString::FromUTF8(eventString.AsStringC()).AsStringC(), + XFA_Element::ExclGroup); + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent"); + } +} + +void CXFA_Node::Script_ExclGroup_SelectedMember(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc < 0 || argc > 1) { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"selectedMember"); + return; + } + + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + pArguments->GetReturnValue()->SetNull(); + return; + } + + CXFA_Node* pReturnNode = nullptr; + if (argc == 0) { + pReturnNode = pWidgetData->GetSelectedMember(); + } else { + CFX_ByteString szName; + szName = pArguments->GetUTF8String(0); + pReturnNode = pWidgetData->SetSelectedMember( + CFX_WideString::FromUTF8(szName.AsStringC()).AsStringC(), true); + } + if (!pReturnNode) { + pArguments->GetReturnValue()->SetNull(); + return; + } + pArguments->GetReturnValue()->Assign( + m_pDocument->GetScriptContext()->GetJSValueFromMap(pReturnNode)); +} + +void CXFA_Node::Script_ExclGroup_ExecInitialize(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (!pNotify) { + return; + } + pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize); + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execInitialize"); + } +} + +void CXFA_Node::Script_ExclGroup_ExecCalculate(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (!pNotify) { + return; + } + pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate); + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate"); + } +} + +void CXFA_Node::Script_ExclGroup_ExecValidate(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (!pNotify) { + pArguments->GetReturnValue()->SetBoolean(FALSE); + } else { + int32_t iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate); + pArguments->GetReturnValue()->SetBoolean( + (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE); + } + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate"); + } +} + +void CXFA_Node::Script_Som_InstanceIndex(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + int32_t iTo = pValue->ToInteger(); + int32_t iFrom = Subform_and_SubformSet_InstanceIndex(); + CXFA_Node* pManagerNode = nullptr; + for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode; + pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) { + if (pNode->GetElementType() == XFA_Element::InstanceManager) { + pManagerNode = pNode; + break; + } + } + if (pManagerNode) { + pManagerNode->InstanceManager_MoveInstance(iTo, iFrom); + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (!pNotify) { + return; + } + CXFA_Node* pToInstance = GetItem(pManagerNode, iTo); + if (pToInstance && + pToInstance->GetElementType() == XFA_Element::Subform) { + pNotify->RunSubformIndexChange(pToInstance); + } + CXFA_Node* pFromInstance = GetItem(pManagerNode, iFrom); + if (pFromInstance && + pFromInstance->GetElementType() == XFA_Element::Subform) { + pNotify->RunSubformIndexChange(pFromInstance); + } + } + } else { + pValue->SetInteger(Subform_and_SubformSet_InstanceIndex()); + } +} + +void CXFA_Node::Script_Subform_InstanceManager(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (!bSetting) { + CFX_WideStringC wsName = GetCData(XFA_ATTRIBUTE_Name); + CXFA_Node* pInstanceMgr = nullptr; + for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode; + pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) { + if (pNode->GetElementType() == XFA_Element::InstanceManager) { + CFX_WideStringC wsInstMgrName = pNode->GetCData(XFA_ATTRIBUTE_Name); + if (wsInstMgrName.GetLength() >= 1 && wsInstMgrName.GetAt(0) == '_' && + wsInstMgrName.Mid(1) == wsName) { + pInstanceMgr = pNode; + } + break; + } + } + if (pInstanceMgr) { + pValue->Assign( + m_pDocument->GetScriptContext()->GetJSValueFromMap(pInstanceMgr)); + } else { + pValue->SetNull(); + } + } else { + ThrowException(XFA_IDS_INVAlID_PROP_SET); + } +} + +void CXFA_Node::Script_Subform_Locale(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + SetCData(XFA_ATTRIBUTE_Locale, pValue->ToWideString(), true, TRUE); + } else { + CFX_WideString wsLocaleName; + GetLocaleName(wsLocaleName); + pValue->SetString( + FX_UTF8Encode(wsLocaleName.c_str(), wsLocaleName.GetLength()) + .AsStringC()); + } +} + +void CXFA_Node::Script_Subform_ExecEvent(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 1) { + CFX_ByteString eventString = pArguments->GetUTF8String(0); + execSingleEventByName( + CFX_WideString::FromUTF8(eventString.AsStringC()).AsStringC(), + XFA_Element::Subform); + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent"); + } +} + +void CXFA_Node::Script_Subform_ExecInitialize(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (!pNotify) { + return; + } + pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize); + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execInitialize"); + } +} + +void CXFA_Node::Script_Subform_ExecCalculate(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (!pNotify) { + return; + } + pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate); + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate"); + } +} + +void CXFA_Node::Script_Subform_ExecValidate(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (!pNotify) { + pArguments->GetReturnValue()->SetBoolean(FALSE); + } else { + int32_t iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate); + pArguments->GetReturnValue()->SetBoolean( + (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE); + } + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate"); + } +} + +void CXFA_Node::Script_Subform_GetInvalidObjects(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getInvalidObjects"); + } +} + +int32_t CXFA_Node::Subform_and_SubformSet_InstanceIndex() { + int32_t index = 0; + for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode; + pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) { + if ((pNode->GetElementType() == XFA_Element::Subform) || + (pNode->GetElementType() == XFA_Element::SubformSet)) { + index++; + } else { + break; + } + } + return index; +} + +void CXFA_Node::Script_Template_FormNodes(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 1) { + pArguments->GetReturnValue()->SetBoolean(TRUE); + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"formNodes"); + } +} + +void CXFA_Node::Script_Template_Remerge(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + m_pDocument->DoDataRemerge(TRUE); + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"remerge"); + } +} + +void CXFA_Node::Script_Template_ExecInitialize(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + pArguments->GetReturnValue()->SetBoolean(FALSE); + } else { + pArguments->GetReturnValue()->SetBoolean(TRUE); + } + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execInitialize"); + } +} + +void CXFA_Node::Script_Template_CreateNode(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if ((argc > 0) && (argc < 4)) { + CFX_WideString strTagName; + CFX_WideString strName; + CFX_WideString strNameSpace; + CFX_ByteString bsTagName = pArguments->GetUTF8String(0); + strTagName = CFX_WideString::FromUTF8(bsTagName.AsStringC()); + if (argc > 1) { + CFX_ByteString bsName = pArguments->GetUTF8String(1); + strName = CFX_WideString::FromUTF8(bsName.AsStringC()); + if (argc == 3) { + CFX_ByteString bsNameSpace = pArguments->GetUTF8String(2); + strNameSpace = CFX_WideString::FromUTF8(bsNameSpace.AsStringC()); + } + } + XFA_Element eType = XFA_GetElementTypeForName(strTagName.AsStringC()); + CXFA_Node* pNewNode = CreateSamePacketNode(eType); + if (!pNewNode) { + pArguments->GetReturnValue()->SetNull(); + } else { + if (!strName.IsEmpty()) { + if (XFA_GetAttributeOfElement(eType, XFA_ATTRIBUTE_Name, + XFA_XDPPACKET_UNKNOWN)) { + pNewNode->SetAttribute(XFA_ATTRIBUTE_Name, strName.AsStringC(), true); + if (pNewNode->GetPacketID() == XFA_XDPPACKET_Datasets) { + pNewNode->CreateXMLMappingNode(); + } + pArguments->GetReturnValue()->Assign( + m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewNode)); + } else { + ThrowException(XFA_IDS_NOT_HAVE_PROPERTY, strTagName.c_str(), + L"name"); + } + } else { + pArguments->GetReturnValue()->Assign( + m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewNode)); + } + } + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"createNode"); + } +} + +void CXFA_Node::Script_Template_Recalculate(CFXJSE_Arguments* pArguments) { + if (pArguments->GetLength() == 1) { + pArguments->GetReturnValue()->SetBoolean(TRUE); + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"recalculate"); + } +} + +void CXFA_Node::Script_Template_ExecCalculate(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + pArguments->GetReturnValue()->SetBoolean(FALSE); + } else { + pArguments->GetReturnValue()->SetBoolean(TRUE); + } + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate"); + } +} + +void CXFA_Node::Script_Template_ExecValidate(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + pArguments->GetReturnValue()->SetBoolean(FALSE); + } else { + pArguments->GetReturnValue()->SetBoolean(TRUE); + } + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate"); + } +} + +void CXFA_Node::Script_Manifest_Evaluate(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (!pWidgetData) { + pArguments->GetReturnValue()->SetBoolean(FALSE); + } else { + pArguments->GetReturnValue()->SetBoolean(TRUE); + } + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"evaluate"); + } +} + +void CXFA_Node::Script_InstanceManager_Max(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + ThrowException(XFA_IDS_INVAlID_PROP_SET); + return; + } + CXFA_Occur nodeOccur(GetOccurNode()); + pValue->SetInteger(nodeOccur.GetMax()); +} + +void CXFA_Node::Script_InstanceManager_Min(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + ThrowException(XFA_IDS_INVAlID_PROP_SET); + return; + } + CXFA_Occur nodeOccur(GetOccurNode()); + pValue->SetInteger(nodeOccur.GetMin()); +} + +void CXFA_Node::Script_InstanceManager_Count(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + int32_t iDesired = pValue->ToInteger(); + InstanceManager_SetInstances(iDesired); + } else { + pValue->SetInteger(GetCount(this)); + } +} + +void CXFA_Node::Script_InstanceManager_MoveInstance( + CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc != 2) { + pArguments->GetReturnValue()->SetUndefined(); + return; + } + int32_t iFrom = pArguments->GetInt32(0); + int32_t iTo = pArguments->GetInt32(1); + InstanceManager_MoveInstance(iTo, iFrom); + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (!pNotify) { + return; + } + CXFA_Node* pToInstance = GetItem(this, iTo); + if (pToInstance && pToInstance->GetElementType() == XFA_Element::Subform) { + pNotify->RunSubformIndexChange(pToInstance); + } + CXFA_Node* pFromInstance = GetItem(this, iFrom); + if (pFromInstance && + pFromInstance->GetElementType() == XFA_Element::Subform) { + pNotify->RunSubformIndexChange(pFromInstance); + } +} + +void CXFA_Node::Script_InstanceManager_RemoveInstance( + CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc != 1) { + pArguments->GetReturnValue()->SetUndefined(); + return; + } + int32_t iIndex = pArguments->GetInt32(0); + int32_t iCount = GetCount(this); + if (iIndex < 0 || iIndex >= iCount) { + ThrowException(XFA_IDS_INDEX_OUT_OF_BOUNDS); + return; + } + CXFA_Occur nodeOccur(GetOccurNode()); + int32_t iMin = nodeOccur.GetMin(); + if (iCount - 1 < iMin) { + ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"min"); + return; + } + CXFA_Node* pRemoveInstance = GetItem(this, iIndex); + RemoveItem(this, pRemoveInstance); + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (pNotify) { + for (int32_t i = iIndex; i < iCount - 1; i++) { + CXFA_Node* pSubformInstance = GetItem(this, i); + if (pSubformInstance && + pSubformInstance->GetElementType() == XFA_Element::Subform) { + pNotify->RunSubformIndexChange(pSubformInstance); + } + } + } + CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor(); + if (!pLayoutPro) { + return; + } + pLayoutPro->AddChangedContainer( + ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form))); +} + +void CXFA_Node::Script_InstanceManager_SetInstances( + CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc != 1) { + pArguments->GetReturnValue()->SetUndefined(); + return; + } + int32_t iDesired = pArguments->GetInt32(0); + InstanceManager_SetInstances(iDesired); +} + +void CXFA_Node::Script_InstanceManager_AddInstance( + CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if ((argc != 0) && (argc != 1)) { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"addInstance"); + return; + } + FX_BOOL fFlags = TRUE; + if (argc == 1) { + fFlags = pArguments->GetInt32(0) == 0 ? FALSE : TRUE; + } + int32_t iCount = GetCount(this); + CXFA_Occur nodeOccur(GetOccurNode()); + int32_t iMax = nodeOccur.GetMax(); + if (iMax >= 0 && iCount >= iMax) { + ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"max"); + return; + } + CXFA_Node* pNewInstance = CreateInstance(this, fFlags); + InsertItem(this, pNewInstance, iCount, iCount, FALSE); + pArguments->GetReturnValue()->Assign( + m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewInstance)); + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (!pNotify) { + return; + } + pNotify->RunNodeInitialize(pNewInstance); + CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor(); + if (!pLayoutPro) { + return; + } + pLayoutPro->AddChangedContainer( + ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form))); +} + +void CXFA_Node::Script_InstanceManager_InsertInstance( + CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if ((argc != 1) && (argc != 2)) { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"insertInstance"); + return; + } + int32_t iIndex = pArguments->GetInt32(0); + FX_BOOL bBind = FALSE; + if (argc == 2) { + bBind = pArguments->GetInt32(1) == 0 ? FALSE : TRUE; + } + CXFA_Occur nodeOccur(GetOccurNode()); + int32_t iCount = GetCount(this); + if (iIndex < 0 || iIndex > iCount) { + ThrowException(XFA_IDS_INDEX_OUT_OF_BOUNDS); + return; + } + int32_t iMax = nodeOccur.GetMax(); + if (iMax >= 0 && iCount >= iMax) { + ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"max"); + return; + } + CXFA_Node* pNewInstance = CreateInstance(this, bBind); + InsertItem(this, pNewInstance, iIndex, iCount, TRUE); + pArguments->GetReturnValue()->Assign( + m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewInstance)); + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (!pNotify) { + return; + } + pNotify->RunNodeInitialize(pNewInstance); + CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor(); + if (!pLayoutPro) { + return; + } + pLayoutPro->AddChangedContainer( + ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form))); +} + +int32_t CXFA_Node::InstanceManager_SetInstances(int32_t iDesired) { + CXFA_Occur nodeOccur(GetOccurNode()); + int32_t iMax = nodeOccur.GetMax(); + int32_t iMin = nodeOccur.GetMin(); + if (iDesired < iMin) { + ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"min"); + return 1; + } + if ((iMax >= 0) && (iDesired > iMax)) { + ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"max"); + return 2; + } + int32_t iCount = GetCount(this); + if (iDesired == iCount) { + return 0; + } + if (iDesired < iCount) { + CFX_WideStringC wsInstManagerName = GetCData(XFA_ATTRIBUTE_Name); + CFX_WideString wsInstanceName = + CFX_WideString(wsInstManagerName.IsEmpty() ? wsInstManagerName + : wsInstManagerName.Mid(1)); + uint32_t dInstanceNameHash = + FX_HashCode_GetW(wsInstanceName.AsStringC(), false); + CXFA_Node* pPrevSibling = + (iDesired == 0) ? this : GetItem(this, 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) { + ASSERT(FALSE); + break; + } + if (pRemoveInstance->GetNameHash() == dInstanceNameHash) { + RemoveItem(this, pRemoveInstance); + iCount--; + } + } + } else if (iDesired > iCount) { + while (iCount < iDesired) { + CXFA_Node* pNewInstance = CreateInstance(this, TRUE); + InsertItem(this, pNewInstance, iCount, iCount, FALSE); + iCount++; + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (!pNotify) { + return 0; + } + pNotify->RunNodeInitialize(pNewInstance); + } + } + CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor(); + if (pLayoutPro) { + pLayoutPro->AddChangedContainer( + ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form))); + } + return 0; +} + +int32_t CXFA_Node::InstanceManager_MoveInstance(int32_t iTo, int32_t iFrom) { + int32_t iCount = GetCount(this); + if (iFrom > iCount || iTo > iCount - 1) { + ThrowException(XFA_IDS_INDEX_OUT_OF_BOUNDS); + return 1; + } + if (iFrom < 0 || iTo < 0 || iFrom == iTo) { + return 0; + } + CXFA_Node* pMoveInstance = GetItem(this, iFrom); + RemoveItem(this, pMoveInstance, FALSE); + InsertItem(this, pMoveInstance, iTo, iCount - 1, TRUE); + CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor(); + if (pLayoutPro) { + pLayoutPro->AddChangedContainer( + ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form))); + } + return 0; +} + +void CXFA_Node::Script_Occur_Max(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + CXFA_Occur occur(this); + if (bSetting) { + int32_t iMax = pValue->ToInteger(); + occur.SetMax(iMax); + } else { + pValue->SetInteger(occur.GetMax()); + } +} + +void CXFA_Node::Script_Occur_Min(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + CXFA_Occur occur(this); + if (bSetting) { + int32_t iMin = pValue->ToInteger(); + occur.SetMin(iMin); + } else { + pValue->SetInteger(occur.GetMin()); + } +} + +void CXFA_Node::Script_Desc_Metadata(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if ((argc == 0) || (argc == 1)) { + pArguments->GetReturnValue()->SetString(""); + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"metadata"); + } +} + +void CXFA_Node::Script_Form_FormNodes(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 1) { + CXFA_Node* pDataNode = static_cast(pArguments->GetObject(0)); + if (pDataNode) { + CXFA_NodeArray formItems; + CXFA_ArrayNodeList* pFormNodes = new CXFA_ArrayNodeList(m_pDocument); + pFormNodes->SetArrayNodeList(formItems); + pArguments->GetReturnValue()->SetObject( + pFormNodes, m_pDocument->GetScriptContext()->GetJseNormalClass()); + } else { + ThrowException(XFA_IDS_ARGUMENT_MISMATCH); + } + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"formNodes"); + } +} + +void CXFA_Node::Script_Form_Remerge(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + m_pDocument->DoDataRemerge(TRUE); + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"remerge"); + } +} + +void CXFA_Node::Script_Form_ExecInitialize(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (!pNotify) { + return; + } + pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize); + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execInitialize"); + } +} + +void CXFA_Node::Script_Form_Recalculate(CFXJSE_Arguments* pArguments) { + CXFA_EventParam* pEventParam = + m_pDocument->GetScriptContext()->GetEventParam(); + if (pEventParam->m_eType == XFA_EVENT_Calculate || + pEventParam->m_eType == XFA_EVENT_InitCalculate) { + return; + } + int32_t argc = pArguments->GetLength(); + if (argc == 1) { + const bool bScriptFlags = pArguments->GetInt32(0) != 0; + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (!pNotify) { + return; + } + if (bScriptFlags) { + pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate); + pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate); + pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Ready, TRUE); + } else { + } + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"recalculate"); + } +} + +void CXFA_Node::Script_Form_ExecCalculate(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (!pNotify) { + return; + } + pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate); + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate"); + } +} + +void CXFA_Node::Script_Form_ExecValidate(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (!pNotify) { + pArguments->GetReturnValue()->SetBoolean(FALSE); + } else { + int32_t iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate); + pArguments->GetReturnValue()->SetBoolean( + (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE); + } + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate"); + } +} + +void CXFA_Node::Script_Form_Checksum(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + SetAttribute(XFA_ATTRIBUTE_Checksum, pValue->ToWideString().AsStringC()); + } else { + CFX_WideString wsChecksum; + GetAttribute(XFA_ATTRIBUTE_Checksum, wsChecksum, FALSE); + pValue->SetString( + FX_UTF8Encode(wsChecksum.c_str(), wsChecksum.GetLength()).AsStringC()); + } +} + +void CXFA_Node::Script_Packet_GetAttribute(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 1) { + CFX_ByteString bsAttributeName = pArguments->GetUTF8String(0); + CFX_WideString wsAttributeValue; + CFDE_XMLNode* pXMLNode = GetXMLMappingNode(); + if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) { + static_cast(pXMLNode)->GetString( + CFX_WideString::FromUTF8(bsAttributeName.AsStringC()).c_str(), + wsAttributeValue); + } + pArguments->GetReturnValue()->SetString( + FX_UTF8Encode(wsAttributeValue.c_str(), wsAttributeValue.GetLength()) + .AsStringC()); + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getAttribute"); + } +} + +void CXFA_Node::Script_Packet_SetAttribute(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 2) { + CFX_ByteString bsValue = pArguments->GetUTF8String(0); + CFX_ByteString bsName = pArguments->GetUTF8String(1); + CFDE_XMLNode* pXMLNode = GetXMLMappingNode(); + if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) { + static_cast(pXMLNode)->SetString( + CFX_WideString::FromUTF8(bsName.AsStringC()), + CFX_WideString::FromUTF8(bsValue.AsStringC())); + } + pArguments->GetReturnValue()->SetNull(); + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"setAttribute"); + } +} + +void CXFA_Node::Script_Packet_RemoveAttribute(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 1) { + CFX_ByteString bsName = pArguments->GetUTF8String(0); + CFX_WideString wsName = CFX_WideString::FromUTF8(bsName.AsStringC()); + CFDE_XMLNode* pXMLNode = GetXMLMappingNode(); + if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) { + CFDE_XMLElement* pXMLElement = static_cast(pXMLNode); + if (pXMLElement->HasAttribute(wsName.c_str())) { + pXMLElement->RemoveAttribute(wsName.c_str()); + } + } + pArguments->GetReturnValue()->SetNull(); + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"removeAttribute"); + } +} + +void CXFA_Node::Script_Packet_Content(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + CFDE_XMLNode* pXMLNode = GetXMLMappingNode(); + if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) { + CFDE_XMLElement* pXMLElement = static_cast(pXMLNode); + pXMLElement->SetTextData(pValue->ToWideString()); + } + } else { + CFX_WideString wsTextData; + CFDE_XMLNode* pXMLNode = GetXMLMappingNode(); + if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) { + CFDE_XMLElement* pXMLElement = static_cast(pXMLNode); + pXMLElement->GetTextData(wsTextData); + } + pValue->SetString( + FX_UTF8Encode(wsTextData.c_str(), wsTextData.GetLength()).AsStringC()); + } +} + +void CXFA_Node::Script_Source_Next(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"next"); + } +} + +void CXFA_Node::Script_Source_CancelBatch(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"cancelBatch"); + } +} + +void CXFA_Node::Script_Source_First(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"first"); + } +} + +void CXFA_Node::Script_Source_UpdateBatch(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"updateBatch"); + } +} + +void CXFA_Node::Script_Source_Previous(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"previous"); + } +} + +void CXFA_Node::Script_Source_IsBOF(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"isBOF"); + } +} + +void CXFA_Node::Script_Source_IsEOF(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"isEOF"); + } +} + +void CXFA_Node::Script_Source_Cancel(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"cancel"); + } +} + +void CXFA_Node::Script_Source_Update(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"update"); + } +} + +void CXFA_Node::Script_Source_Open(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"open"); + } +} + +void CXFA_Node::Script_Source_Delete(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"delete"); + } +} + +void CXFA_Node::Script_Source_AddNew(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"addNew"); + } +} + +void CXFA_Node::Script_Source_Requery(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"requery"); + } +} + +void CXFA_Node::Script_Source_Resync(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"resync"); + } +} + +void CXFA_Node::Script_Source_Close(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"close"); + } +} + +void CXFA_Node::Script_Source_Last(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"last"); + } +} + +void CXFA_Node::Script_Source_HasDataChanged(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 0) { + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"hasDataChanged"); + } +} + +void CXFA_Node::Script_Source_Db(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) {} + +void CXFA_Node::Script_Xfa_This(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (!bSetting) { + CXFA_Object* pThis = m_pDocument->GetScriptContext()->GetThisObject(); + ASSERT(pThis); + pValue->Assign(m_pDocument->GetScriptContext()->GetJSValueFromMap(pThis)); + } +} + +void CXFA_Node::Script_Handler_Version(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) {} + +void CXFA_Node::Script_SubmitFormat_Mode(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) {} + +void CXFA_Node::Script_Extras_Type(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) {} + +void CXFA_Node::Script_Script_Stateless(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + ThrowException(XFA_IDS_INVAlID_PROP_SET); + return; + } + pValue->SetString(FX_UTF8Encode(FX_WSTRC(L"0")).AsStringC()); +} + +void CXFA_Node::Script_Encrypt_Format(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) {} + +FX_BOOL CXFA_Node::HasAttribute(XFA_ATTRIBUTE eAttr, FX_BOOL bCanInherit) { + void* pKey = GetMapKey_Element(GetElementType(), eAttr); + return HasMapModuleKey(pKey, bCanInherit); +} + +FX_BOOL CXFA_Node::SetAttribute(XFA_ATTRIBUTE eAttr, + const CFX_WideStringC& wsValue, + bool bNotify) { + const XFA_ATTRIBUTEINFO* pAttr = XFA_GetAttributeByID(eAttr); + if (!pAttr) + return FALSE; + + XFA_ATTRIBUTETYPE eType = pAttr->eType; + if (eType == XFA_ATTRIBUTETYPE_NOTSURE) { + const XFA_NOTSUREATTRIBUTE* pNotsure = + XFA_GetNotsureAttribute(GetElementType(), pAttr->eName); + eType = pNotsure ? pNotsure->eType : XFA_ATTRIBUTETYPE_Cdata; + } + switch (eType) { + case XFA_ATTRIBUTETYPE_Enum: { + const XFA_ATTRIBUTEENUMINFO* pEnum = XFA_GetAttributeEnumByName(wsValue); + return SetEnum(pAttr->eName, + pEnum ? pEnum->eName + : (XFA_ATTRIBUTEENUM)(intptr_t)(pAttr->pDefValue), + bNotify); + } break; + case XFA_ATTRIBUTETYPE_Cdata: + return SetCData(pAttr->eName, CFX_WideString(wsValue), bNotify); + case XFA_ATTRIBUTETYPE_Boolean: + return SetBoolean(pAttr->eName, wsValue != FX_WSTRC(L"0"), bNotify); + case XFA_ATTRIBUTETYPE_Integer: + return SetInteger( + pAttr->eName, + FXSYS_round(FX_wcstof(wsValue.c_str(), wsValue.GetLength(), nullptr)), + bNotify); + case XFA_ATTRIBUTETYPE_Measure: + return SetMeasure(pAttr->eName, CXFA_Measurement(wsValue), bNotify); + default: + break; + } + return FALSE; +} + +FX_BOOL CXFA_Node::GetAttribute(XFA_ATTRIBUTE eAttr, + CFX_WideString& wsValue, + FX_BOOL bUseDefault) { + const XFA_ATTRIBUTEINFO* pAttr = XFA_GetAttributeByID(eAttr); + if (!pAttr) { + return FALSE; + } + XFA_ATTRIBUTETYPE eType = pAttr->eType; + if (eType == XFA_ATTRIBUTETYPE_NOTSURE) { + const XFA_NOTSUREATTRIBUTE* pNotsure = + XFA_GetNotsureAttribute(GetElementType(), pAttr->eName); + eType = pNotsure ? pNotsure->eType : XFA_ATTRIBUTETYPE_Cdata; + } + switch (eType) { + case XFA_ATTRIBUTETYPE_Enum: { + XFA_ATTRIBUTEENUM eValue; + if (!TryEnum(pAttr->eName, eValue, bUseDefault)) { + return FALSE; + } + wsValue = XFA_GetAttributeEnumByID(eValue)->pName; + return TRUE; + } break; + case XFA_ATTRIBUTETYPE_Cdata: { + CFX_WideStringC wsValueC; + if (!TryCData(pAttr->eName, wsValueC, bUseDefault)) { + return FALSE; + } + wsValue = wsValueC; + return TRUE; + } break; + case XFA_ATTRIBUTETYPE_Boolean: { + FX_BOOL bValue; + if (!TryBoolean(pAttr->eName, bValue, bUseDefault)) { + return FALSE; + } + wsValue = bValue ? FX_WSTRC(L"1") : FX_WSTRC(L"0"); + return TRUE; + } break; + case XFA_ATTRIBUTETYPE_Integer: { + int32_t iValue; + if (!TryInteger(pAttr->eName, iValue, bUseDefault)) { + return FALSE; + } + wsValue.Format(L"%d", iValue); + return TRUE; + } break; + case XFA_ATTRIBUTETYPE_Measure: { + CXFA_Measurement mValue; + if (!TryMeasure(pAttr->eName, mValue, bUseDefault)) { + return FALSE; + } + mValue.ToString(wsValue); + return TRUE; + } break; + default: + break; + } + return FALSE; +} + +FX_BOOL CXFA_Node::SetAttribute(const CFX_WideStringC& wsAttr, + const CFX_WideStringC& wsValue, + bool bNotify) { + const XFA_ATTRIBUTEINFO* pAttributeInfo = XFA_GetAttributeByName(wsValue); + if (pAttributeInfo) { + return SetAttribute(pAttributeInfo->eName, wsValue, bNotify); + } + void* pKey = GetMapKey_Custom(wsAttr); + SetMapModuleString(pKey, wsValue); + return TRUE; +} + +FX_BOOL CXFA_Node::GetAttribute(const CFX_WideStringC& wsAttr, + CFX_WideString& wsValue, + FX_BOOL bUseDefault) { + const XFA_ATTRIBUTEINFO* pAttributeInfo = XFA_GetAttributeByName(wsAttr); + if (pAttributeInfo) { + return GetAttribute(pAttributeInfo->eName, wsValue, bUseDefault); + } + void* pKey = GetMapKey_Custom(wsAttr); + CFX_WideStringC wsValueC; + if (GetMapModuleString(pKey, wsValueC)) { + wsValue = wsValueC; + } + return TRUE; +} + +FX_BOOL CXFA_Node::RemoveAttribute(const CFX_WideStringC& wsAttr) { + void* pKey = GetMapKey_Custom(wsAttr); + RemoveMapModuleKey(pKey); + return TRUE; +} + +FX_BOOL CXFA_Node::TryBoolean(XFA_ATTRIBUTE eAttr, + FX_BOOL& bValue, + FX_BOOL bUseDefault) { + void* pValue = nullptr; + if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Boolean, bUseDefault, pValue)) + return FALSE; + bValue = (FX_BOOL)(uintptr_t)pValue; + return TRUE; +} + +FX_BOOL CXFA_Node::TryInteger(XFA_ATTRIBUTE eAttr, + int32_t& iValue, + FX_BOOL bUseDefault) { + void* pValue = nullptr; + if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Integer, bUseDefault, pValue)) + return FALSE; + iValue = (int32_t)(uintptr_t)pValue; + return TRUE; +} + +FX_BOOL CXFA_Node::TryEnum(XFA_ATTRIBUTE eAttr, + XFA_ATTRIBUTEENUM& eValue, + FX_BOOL bUseDefault) { + void* pValue = nullptr; + if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Enum, bUseDefault, pValue)) + return FALSE; + eValue = (XFA_ATTRIBUTEENUM)(uintptr_t)pValue; + return TRUE; +} + +FX_BOOL CXFA_Node::SetMeasure(XFA_ATTRIBUTE eAttr, + CXFA_Measurement mValue, + bool bNotify) { + void* pKey = GetMapKey_Element(GetElementType(), eAttr); + OnChanging(eAttr, bNotify); + SetMapModuleBuffer(pKey, &mValue, sizeof(CXFA_Measurement)); + OnChanged(eAttr, bNotify, FALSE); + return TRUE; +} + +FX_BOOL CXFA_Node::TryMeasure(XFA_ATTRIBUTE eAttr, + CXFA_Measurement& mValue, + FX_BOOL bUseDefault) const { + void* pKey = GetMapKey_Element(GetElementType(), eAttr); + void* pValue; + int32_t iBytes; + if (GetMapModuleBuffer(pKey, pValue, iBytes) && iBytes == sizeof(mValue)) { + FXSYS_memcpy(&mValue, pValue, sizeof(mValue)); + return TRUE; + } + if (bUseDefault && + XFA_GetAttributeDefaultValue(pValue, GetElementType(), eAttr, + XFA_ATTRIBUTETYPE_Measure, m_ePacket)) { + FXSYS_memcpy(&mValue, pValue, sizeof(mValue)); + return TRUE; + } + return FALSE; +} + +CXFA_Measurement CXFA_Node::GetMeasure(XFA_ATTRIBUTE eAttr) const { + CXFA_Measurement mValue; + return TryMeasure(eAttr, mValue, TRUE) ? mValue : CXFA_Measurement(); +} + +FX_BOOL CXFA_Node::SetCData(XFA_ATTRIBUTE eAttr, + const CFX_WideString& wsValue, + bool bNotify, + FX_BOOL bScriptModify) { + void* pKey = GetMapKey_Element(GetElementType(), eAttr); + OnChanging(eAttr, bNotify); + if (eAttr == XFA_ATTRIBUTE_Value) { + CFX_WideString* pClone = new CFX_WideString(wsValue); + SetUserData(pKey, pClone, &deleteWideStringCallBack); + } else { + SetMapModuleString(pKey, wsValue.AsStringC()); + if (eAttr == XFA_ATTRIBUTE_Name) + UpdateNameHash(); + } + OnChanged(eAttr, bNotify, bScriptModify); + + if (!IsNeedSavingXMLNode() || eAttr == XFA_ATTRIBUTE_QualifiedName || + eAttr == XFA_ATTRIBUTE_BindingNode) { + return TRUE; + } + + if (eAttr == XFA_ATTRIBUTE_Name && + (m_elementType == XFA_Element::DataValue || + m_elementType == XFA_Element::DataGroup)) { + return TRUE; + } + + if (eAttr == XFA_ATTRIBUTE_Value) { + FDE_XMLNODETYPE eXMLType = m_pXMLNode->GetType(); + switch (eXMLType) { + case FDE_XMLNODE_Element: + if (IsAttributeInXML()) { + static_cast(m_pXMLNode) + ->SetString(CFX_WideString(GetCData(XFA_ATTRIBUTE_QualifiedName)), + wsValue); + } else { + FX_BOOL bDeleteChildren = TRUE; + if (GetPacketID() == XFA_XDPPACKET_Datasets) { + for (CXFA_Node* pChildDataNode = + GetNodeItem(XFA_NODEITEM_FirstChild); + pChildDataNode; pChildDataNode = pChildDataNode->GetNodeItem( + XFA_NODEITEM_NextSibling)) { + CXFA_NodeArray formNodes; + if (pChildDataNode->GetBindItems(formNodes) > 0) { + bDeleteChildren = FALSE; + break; + } + } + } + if (bDeleteChildren) { + static_cast(m_pXMLNode)->DeleteChildren(); + } + static_cast(m_pXMLNode)->SetTextData(wsValue); + } + break; + case FDE_XMLNODE_Text: + static_cast(m_pXMLNode)->SetText(wsValue); + break; + default: + ASSERT(0); + } + return TRUE; + } + + const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttr); + if (pInfo) { + ASSERT(m_pXMLNode->GetType() == FDE_XMLNODE_Element); + CFX_WideString wsAttrName = pInfo->pName; + if (pInfo->eName == XFA_ATTRIBUTE_ContentType) { + wsAttrName = FX_WSTRC(L"xfa:") + wsAttrName; + } + static_cast(m_pXMLNode)->SetString(wsAttrName, wsValue); + } + return TRUE; +} + +FX_BOOL CXFA_Node::SetAttributeValue(const CFX_WideString& wsValue, + const CFX_WideString& wsXMLValue, + bool bNotify, + FX_BOOL bScriptModify) { + void* pKey = GetMapKey_Element(GetElementType(), XFA_ATTRIBUTE_Value); + OnChanging(XFA_ATTRIBUTE_Value, bNotify); + CFX_WideString* pClone = new CFX_WideString(wsValue); + SetUserData(pKey, pClone, &deleteWideStringCallBack); + OnChanged(XFA_ATTRIBUTE_Value, bNotify, bScriptModify); + if (IsNeedSavingXMLNode()) { + FDE_XMLNODETYPE eXMLType = m_pXMLNode->GetType(); + switch (eXMLType) { + case FDE_XMLNODE_Element: + if (IsAttributeInXML()) { + static_cast(m_pXMLNode) + ->SetString(CFX_WideString(GetCData(XFA_ATTRIBUTE_QualifiedName)), + wsXMLValue); + } else { + FX_BOOL bDeleteChildren = TRUE; + if (GetPacketID() == XFA_XDPPACKET_Datasets) { + for (CXFA_Node* pChildDataNode = + GetNodeItem(XFA_NODEITEM_FirstChild); + pChildDataNode; pChildDataNode = pChildDataNode->GetNodeItem( + XFA_NODEITEM_NextSibling)) { + CXFA_NodeArray formNodes; + if (pChildDataNode->GetBindItems(formNodes) > 0) { + bDeleteChildren = FALSE; + break; + } + } + } + if (bDeleteChildren) { + static_cast(m_pXMLNode)->DeleteChildren(); + } + static_cast(m_pXMLNode)->SetTextData(wsXMLValue); + } + break; + case FDE_XMLNODE_Text: + static_cast(m_pXMLNode)->SetText(wsXMLValue); + break; + default: + ASSERT(0); + } + } + return TRUE; +} + +FX_BOOL CXFA_Node::TryCData(XFA_ATTRIBUTE eAttr, + CFX_WideString& wsValue, + FX_BOOL bUseDefault, + FX_BOOL bProto) { + void* pKey = GetMapKey_Element(GetElementType(), eAttr); + if (eAttr == XFA_ATTRIBUTE_Value) { + CFX_WideString* pStr = (CFX_WideString*)GetUserData(pKey, bProto); + if (pStr) { + wsValue = *pStr; + return TRUE; + } + } else { + CFX_WideStringC wsValueC; + if (GetMapModuleString(pKey, wsValueC)) { + wsValue = wsValueC; + return TRUE; + } + } + if (!bUseDefault) { + return FALSE; + } + void* pValue = nullptr; + if (XFA_GetAttributeDefaultValue(pValue, GetElementType(), eAttr, + XFA_ATTRIBUTETYPE_Cdata, m_ePacket)) { + wsValue = (const FX_WCHAR*)pValue; + return TRUE; + } + return FALSE; +} + +FX_BOOL CXFA_Node::TryCData(XFA_ATTRIBUTE eAttr, + CFX_WideStringC& wsValue, + FX_BOOL bUseDefault, + FX_BOOL bProto) { + void* pKey = GetMapKey_Element(GetElementType(), eAttr); + if (eAttr == XFA_ATTRIBUTE_Value) { + CFX_WideString* pStr = (CFX_WideString*)GetUserData(pKey, bProto); + if (pStr) { + wsValue = pStr->AsStringC(); + return TRUE; + } + } else { + if (GetMapModuleString(pKey, wsValue)) { + return TRUE; + } + } + if (!bUseDefault) { + return FALSE; + } + void* pValue = nullptr; + if (XFA_GetAttributeDefaultValue(pValue, GetElementType(), eAttr, + XFA_ATTRIBUTETYPE_Cdata, m_ePacket)) { + wsValue = (CFX_WideStringC)(const FX_WCHAR*)pValue; + return TRUE; + } + return FALSE; +} + +FX_BOOL CXFA_Node::SetObject(XFA_ATTRIBUTE eAttr, + void* pData, + XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) { + void* pKey = GetMapKey_Element(GetElementType(), eAttr); + return SetUserData(pKey, pData, pCallbackInfo); +} + +FX_BOOL CXFA_Node::TryObject(XFA_ATTRIBUTE eAttr, void*& pData) { + void* pKey = GetMapKey_Element(GetElementType(), eAttr); + pData = GetUserData(pKey); + return !!pData; +} + +FX_BOOL CXFA_Node::SetValue(XFA_ATTRIBUTE eAttr, + XFA_ATTRIBUTETYPE eType, + void* pValue, + bool bNotify) { + void* pKey = GetMapKey_Element(GetElementType(), eAttr); + OnChanging(eAttr, bNotify); + SetMapModuleValue(pKey, pValue); + OnChanged(eAttr, bNotify, FALSE); + if (IsNeedSavingXMLNode()) { + ASSERT(m_pXMLNode->GetType() == FDE_XMLNODE_Element); + const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttr); + if (pInfo) { + switch (eType) { + case XFA_ATTRIBUTETYPE_Enum: + static_cast(m_pXMLNode) + ->SetString( + pInfo->pName, + XFA_GetAttributeEnumByID((XFA_ATTRIBUTEENUM)(uintptr_t)pValue) + ->pName); + break; + case XFA_ATTRIBUTETYPE_Boolean: + static_cast(m_pXMLNode) + ->SetString(pInfo->pName, pValue ? L"1" : L"0"); + break; + case XFA_ATTRIBUTETYPE_Integer: + static_cast(m_pXMLNode) + ->SetInteger(pInfo->pName, (int32_t)(uintptr_t)pValue); + break; + default: + ASSERT(0); + } + } + } + return TRUE; +} + +FX_BOOL CXFA_Node::GetValue(XFA_ATTRIBUTE eAttr, + XFA_ATTRIBUTETYPE eType, + FX_BOOL bUseDefault, + void*& pValue) { + void* pKey = GetMapKey_Element(GetElementType(), eAttr); + if (GetMapModuleValue(pKey, pValue)) { + return TRUE; + } + if (!bUseDefault) { + return FALSE; + } + return XFA_GetAttributeDefaultValue(pValue, GetElementType(), eAttr, eType, + m_ePacket); +} + +FX_BOOL CXFA_Node::SetUserData(void* pKey, + void* pData, + XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) { + SetMapModuleBuffer(pKey, &pData, sizeof(void*), + pCallbackInfo ? pCallbackInfo : &gs_XFADefaultFreeData); + return TRUE; +} + +FX_BOOL CXFA_Node::TryUserData(void* pKey, void*& pData, FX_BOOL bProtoAlso) { + int32_t iBytes = 0; + if (!GetMapModuleBuffer(pKey, pData, iBytes, bProtoAlso)) { + return FALSE; + } + return iBytes == sizeof(void*) && FXSYS_memcpy(&pData, pData, iBytes); +} + +FX_BOOL CXFA_Node::SetScriptContent(const CFX_WideString& wsContent, + const CFX_WideString& wsXMLValue, + bool bNotify, + FX_BOOL bScriptModify, + FX_BOOL bSyncData) { + CXFA_Node* pNode = nullptr; + CXFA_Node* pBindNode = nullptr; + switch (GetObjectType()) { + case XFA_ObjectType::ContainerNode: { + if (XFA_FieldIsMultiListBox(this)) { + CXFA_Node* pValue = GetProperty(0, XFA_Element::Value); + CXFA_Node* pChildValue = pValue->GetNodeItem(XFA_NODEITEM_FirstChild); + ASSERT(pChildValue); + pChildValue->SetCData(XFA_ATTRIBUTE_ContentType, L"text/xml"); + pChildValue->SetScriptContent(wsContent, wsContent, bNotify, + bScriptModify, FALSE); + CXFA_Node* pBind = GetBindData(); + if (bSyncData && pBind) { + CFX_WideStringArray wsSaveTextArray; + int32_t iSize = 0; + if (!wsContent.IsEmpty()) { + int32_t iStart = 0; + int32_t iLength = wsContent.GetLength(); + int32_t iEnd = wsContent.Find(L'\n', iStart); + iEnd = (iEnd == -1) ? iLength : iEnd; + while (iEnd >= iStart) { + wsSaveTextArray.Add(wsContent.Mid(iStart, iEnd - iStart)); + iStart = iEnd + 1; + if (iStart >= iLength) { + break; + } + iEnd = wsContent.Find(L'\n', iStart); + if (iEnd < 0) { + wsSaveTextArray.Add(wsContent.Mid(iStart, iLength - iStart)); + } + } + iSize = wsSaveTextArray.GetSize(); + } + if (iSize == 0) { + while (CXFA_Node* pChildNode = + pBind->GetNodeItem(XFA_NODEITEM_FirstChild)) { + pBind->RemoveChild(pChildNode); + } + } else { + CXFA_NodeArray valueNodes; + int32_t iDatas = pBind->GetNodeList( + valueNodes, XFA_NODEFILTER_Children, XFA_Element::DataValue); + if (iDatas < iSize) { + int32_t iAddNodes = iSize - iDatas; + CXFA_Node* pValueNodes = nullptr; + while (iAddNodes-- > 0) { + pValueNodes = + pBind->CreateSamePacketNode(XFA_Element::DataValue); + pValueNodes->SetCData(XFA_ATTRIBUTE_Name, L"value"); + pValueNodes->CreateXMLMappingNode(); + pBind->InsertChild(pValueNodes); + } + pValueNodes = nullptr; + } else if (iDatas > iSize) { + int32_t iDelNodes = iDatas - iSize; + while (iDelNodes-- > 0) { + pBind->RemoveChild(pBind->GetNodeItem(XFA_NODEITEM_FirstChild)); + } + } + int32_t i = 0; + for (CXFA_Node* pValueNode = + pBind->GetNodeItem(XFA_NODEITEM_FirstChild); + pValueNode; pValueNode = pValueNode->GetNodeItem( + XFA_NODEITEM_NextSibling)) { + pValueNode->SetAttributeValue(wsSaveTextArray[i], + wsSaveTextArray[i], FALSE); + i++; + } + } + CXFA_NodeArray nodeArray; + pBind->GetBindItems(nodeArray); + for (int32_t i = 0; i < nodeArray.GetSize(); i++) { + if (nodeArray[i] != this) { + nodeArray[i]->SetScriptContent(wsContent, wsContent, bNotify, + bScriptModify, FALSE); + } + } + } + break; + } else if (GetElementType() == XFA_Element::ExclGroup) { + pNode = this; + } else { + CXFA_Node* pValue = GetProperty(0, XFA_Element::Value); + CXFA_Node* pChildValue = pValue->GetNodeItem(XFA_NODEITEM_FirstChild); + ASSERT(pChildValue); + pChildValue->SetScriptContent(wsContent, wsContent, bNotify, + bScriptModify, FALSE); + } + pBindNode = GetBindData(); + if (pBindNode && bSyncData) { + pBindNode->SetScriptContent(wsContent, wsXMLValue, bNotify, + bScriptModify, FALSE); + CXFA_NodeArray nodeArray; + pBindNode->GetBindItems(nodeArray); + for (int32_t i = 0; i < nodeArray.GetSize(); i++) { + if (nodeArray[i] != this) { + nodeArray[i]->SetScriptContent(wsContent, wsContent, bNotify, true, + FALSE); + } + } + } + pBindNode = nullptr; + break; + } + case XFA_ObjectType::ContentNode: { + CFX_WideString wsContentType; + if (GetElementType() == XFA_Element::ExData) { + GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, FALSE); + if (wsContentType == FX_WSTRC(L"text/html")) { + wsContentType = FX_WSTRC(L""); + SetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType.AsStringC()); + } + } + CXFA_Node* pContentRawDataNode = GetNodeItem(XFA_NODEITEM_FirstChild); + if (!pContentRawDataNode) { + pContentRawDataNode = CreateSamePacketNode( + (wsContentType == FX_WSTRC(L"text/xml")) ? XFA_Element::Sharpxml + : XFA_Element::Sharptext); + InsertChild(pContentRawDataNode); + } + return pContentRawDataNode->SetScriptContent( + wsContent, wsXMLValue, bNotify, bScriptModify, bSyncData); + } break; + case XFA_ObjectType::NodeC: + case XFA_ObjectType::TextNode: + pNode = this; + break; + case XFA_ObjectType::NodeV: + pNode = this; + if (bSyncData && GetPacketID() == XFA_XDPPACKET_Form) { + CXFA_Node* pParent = 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->SetScriptContent(wsContent, wsXMLValue, bNotify, + bScriptModify, FALSE); + } + } + } + } + break; + default: + if (GetElementType() == XFA_Element::DataValue) { + pNode = this; + pBindNode = this; + } + break; + } + if (pNode) { + SetAttributeValue(wsContent, wsXMLValue, bNotify, bScriptModify); + if (pBindNode && bSyncData) { + CXFA_NodeArray nodeArray; + pBindNode->GetBindItems(nodeArray); + for (int32_t i = 0; i < nodeArray.GetSize(); i++) { + nodeArray[i]->SetScriptContent(wsContent, wsContent, bNotify, + bScriptModify, FALSE); + } + } + return TRUE; + } + return FALSE; +} + +FX_BOOL CXFA_Node::SetContent(const CFX_WideString& wsContent, + const CFX_WideString& wsXMLValue, + bool bNotify, + FX_BOOL bScriptModify, + FX_BOOL bSyncData) { + return SetScriptContent(wsContent, wsXMLValue, bNotify, bScriptModify, + bSyncData); +} + +CFX_WideString CXFA_Node::GetScriptContent(FX_BOOL bScriptModify) { + CFX_WideString wsContent; + return TryContent(wsContent, bScriptModify) ? wsContent : CFX_WideString(); +} + +CFX_WideString CXFA_Node::GetContent() { + return GetScriptContent(); +} + +FX_BOOL CXFA_Node::TryContent(CFX_WideString& wsContent, + FX_BOOL bScriptModify, + FX_BOOL bProto) { + CXFA_Node* pNode = nullptr; + switch (GetObjectType()) { + case XFA_ObjectType::ContainerNode: + if (GetElementType() == XFA_Element::ExclGroup) { + pNode = this; + } else { + CXFA_Node* pValue = GetChild(0, XFA_Element::Value); + if (!pValue) { + return FALSE; + } + CXFA_Node* pChildValue = pValue->GetNodeItem(XFA_NODEITEM_FirstChild); + if (pChildValue && XFA_FieldIsMultiListBox(this)) { + pChildValue->SetAttribute(XFA_ATTRIBUTE_ContentType, + FX_WSTRC(L"text/xml")); + } + return pChildValue + ? pChildValue->TryContent(wsContent, bScriptModify, bProto) + : FALSE; + } + break; + case XFA_ObjectType::ContentNode: { + CXFA_Node* pContentRawDataNode = GetNodeItem(XFA_NODEITEM_FirstChild); + if (!pContentRawDataNode) { + XFA_Element element = XFA_Element::Sharptext; + if (GetElementType() == XFA_Element::ExData) { + CFX_WideString wsContentType; + GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, FALSE); + if (wsContentType == FX_WSTRC(L"text/html")) { + element = XFA_Element::SharpxHTML; + } else if (wsContentType == FX_WSTRC(L"text/xml")) { + element = XFA_Element::Sharpxml; + } + } + pContentRawDataNode = CreateSamePacketNode(element); + InsertChild(pContentRawDataNode); + } + return pContentRawDataNode->TryContent(wsContent, bScriptModify, bProto); + } + case XFA_ObjectType::NodeC: + case XFA_ObjectType::NodeV: + case XFA_ObjectType::TextNode: + pNode = this; + default: + if (GetElementType() == XFA_Element::DataValue) { + pNode = this; + } + break; + } + if (pNode) { + if (bScriptModify) { + CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext(); + if (pScriptContext) { + m_pDocument->GetScriptContext()->AddNodesOfRunScript(this); + } + } + return TryCData(XFA_ATTRIBUTE_Value, wsContent, FALSE, bProto); + } + return FALSE; +} + +CXFA_Node* CXFA_Node::GetModelNode() { + switch (GetPacketID()) { + case XFA_XDPPACKET_XDP: + return m_pDocument->GetRoot(); + case XFA_XDPPACKET_Config: + return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Config)); + case XFA_XDPPACKET_Template: + return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Template)); + case XFA_XDPPACKET_Form: + return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form)); + case XFA_XDPPACKET_Datasets: + return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Datasets)); + case XFA_XDPPACKET_LocaleSet: + return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_LocaleSet)); + case XFA_XDPPACKET_ConnectionSet: + return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_ConnectionSet)); + case XFA_XDPPACKET_SourceSet: + return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_SourceSet)); + case XFA_XDPPACKET_Xdc: + return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Xdc)); + default: + return this; + } +} + +FX_BOOL CXFA_Node::TryNamespace(CFX_WideString& wsNamespace) { + wsNamespace.clear(); + if (IsModelNode() || GetElementType() == XFA_Element::Packet) { + CFDE_XMLNode* pXMLNode = GetXMLMappingNode(); + if (!pXMLNode || pXMLNode->GetType() != FDE_XMLNODE_Element) { + return FALSE; + } + static_cast(pXMLNode)->GetNamespaceURI(wsNamespace); + return TRUE; + } else if (GetPacketID() == XFA_XDPPACKET_Datasets) { + CFDE_XMLNode* pXMLNode = GetXMLMappingNode(); + if (!pXMLNode) { + return FALSE; + } + if (pXMLNode->GetType() != FDE_XMLNODE_Element) { + return TRUE; + } + if (GetElementType() == XFA_Element::DataValue && + GetEnum(XFA_ATTRIBUTE_Contains) == XFA_ATTRIBUTEENUM_MetaData) { + return XFA_FDEExtension_ResolveNamespaceQualifier( + static_cast(pXMLNode), + GetCData(XFA_ATTRIBUTE_QualifiedName), wsNamespace); + } + static_cast(pXMLNode)->GetNamespaceURI(wsNamespace); + return TRUE; + } else { + CXFA_Node* pModelNode = GetModelNode(); + return pModelNode->TryNamespace(wsNamespace); + } +} + +CXFA_Node* CXFA_Node::GetProperty(int32_t index, + XFA_Element eProperty, + FX_BOOL bCreateProperty) { + XFA_Element eType = GetElementType(); + uint32_t dwPacket = GetPacketID(); + const XFA_PROPERTY* pProperty = + XFA_GetPropertyOfElement(eType, eProperty, dwPacket); + if (!pProperty || index >= pProperty->uOccur) + return nullptr; + + CXFA_Node* pNode = m_pChild; + int32_t iCount = 0; + for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { + if (pNode->GetElementType() == eProperty) { + iCount++; + if (iCount > index) { + return pNode; + } + } + } + if (!bCreateProperty) + return nullptr; + + if (pProperty->uFlags & XFA_PROPERTYFLAG_OneOf) { + pNode = m_pChild; + for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { + const XFA_PROPERTY* pExistProperty = + XFA_GetPropertyOfElement(eType, pNode->GetElementType(), dwPacket); + if (pExistProperty && (pExistProperty->uFlags & XFA_PROPERTYFLAG_OneOf)) + return nullptr; + } + } + + const XFA_PACKETINFO* pPacket = XFA_GetPacketByID(dwPacket); + CXFA_Node* pNewNode = nullptr; + for (; iCount <= index; iCount++) { + pNewNode = m_pDocument->CreateNode(pPacket, eProperty); + if (!pNewNode) + return nullptr; + InsertChild(pNewNode, nullptr); + pNewNode->SetFlag(XFA_NodeFlag_Initialized, true); + } + return pNewNode; +} + +int32_t CXFA_Node::CountChildren(XFA_Element eType, FX_BOOL bOnlyChild) { + CXFA_Node* pNode = m_pChild; + int32_t iCount = 0; + for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { + if (pNode->GetElementType() == eType || eType == XFA_Element::Unknown) { + if (bOnlyChild) { + const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement( + GetElementType(), pNode->GetElementType(), XFA_XDPPACKET_UNKNOWN); + if (pProperty) { + continue; + } + } + iCount++; + } + } + return iCount; +} + +CXFA_Node* CXFA_Node::GetChild(int32_t index, + XFA_Element eType, + FX_BOOL bOnlyChild) { + ASSERT(index > -1); + CXFA_Node* pNode = m_pChild; + int32_t iCount = 0; + for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { + if (pNode->GetElementType() == eType || eType == XFA_Element::Unknown) { + if (bOnlyChild) { + const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement( + GetElementType(), pNode->GetElementType(), XFA_XDPPACKET_UNKNOWN); + if (pProperty) { + continue; + } + } + iCount++; + if (iCount > index) { + return pNode; + } + } + } + return nullptr; +} + +int32_t CXFA_Node::InsertChild(int32_t index, CXFA_Node* pNode) { + ASSERT(!pNode->m_pNext); + pNode->m_pParent = this; + FX_BOOL ret = m_pDocument->RemovePurgeNode(pNode); + ASSERT(ret); + (void)ret; // Avoid unused variable warning. + + if (!m_pChild || index == 0) { + if (index > 0) { + return -1; + } + pNode->m_pNext = m_pChild; + m_pChild = pNode; + index = 0; + } else if (index < 0) { + m_pLastChild->m_pNext = pNode; + } else { + CXFA_Node* pPrev = m_pChild; + int32_t iCount = 0; + while (++iCount != index && pPrev->m_pNext) { + pPrev = pPrev->m_pNext; + } + if (index > 0 && index != iCount) { + return -1; + } + pNode->m_pNext = pPrev->m_pNext; + pPrev->m_pNext = pNode; + index = iCount; + } + if (!pNode->m_pNext) { + m_pLastChild = pNode; + } + ASSERT(m_pLastChild); + ASSERT(!m_pLastChild->m_pNext); + pNode->ClearFlag(XFA_NodeFlag_HasRemovedChildren); + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (pNotify) + pNotify->OnChildAdded(this); + + if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) { + ASSERT(!pNode->m_pXMLNode->GetNodeItem(CFDE_XMLNode::Parent)); + m_pXMLNode->InsertChildNode(pNode->m_pXMLNode, index); + pNode->ClearFlag(XFA_NodeFlag_OwnXMLNode); + } + return index; +} + +FX_BOOL CXFA_Node::InsertChild(CXFA_Node* pNode, CXFA_Node* pBeforeNode) { + if (!pNode || pNode->m_pParent || + (pBeforeNode && pBeforeNode->m_pParent != this)) { + ASSERT(false); + return FALSE; + } + FX_BOOL ret = m_pDocument->RemovePurgeNode(pNode); + ASSERT(ret); + (void)ret; // Avoid unused variable warning. + + int32_t nIndex = -1; + pNode->m_pParent = this; + if (!m_pChild || pBeforeNode == m_pChild) { + pNode->m_pNext = m_pChild; + m_pChild = pNode; + nIndex = 0; + } else if (!pBeforeNode) { + pNode->m_pNext = m_pLastChild->m_pNext; + m_pLastChild->m_pNext = pNode; + } else { + nIndex = 1; + CXFA_Node* pPrev = m_pChild; + while (pPrev->m_pNext != pBeforeNode) { + pPrev = pPrev->m_pNext; + nIndex++; + } + pNode->m_pNext = pPrev->m_pNext; + pPrev->m_pNext = pNode; + } + if (!pNode->m_pNext) { + m_pLastChild = pNode; + } + ASSERT(m_pLastChild); + ASSERT(!m_pLastChild->m_pNext); + pNode->ClearFlag(XFA_NodeFlag_HasRemovedChildren); + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (pNotify) + pNotify->OnChildAdded(this); + + if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) { + ASSERT(!pNode->m_pXMLNode->GetNodeItem(CFDE_XMLNode::Parent)); + m_pXMLNode->InsertChildNode(pNode->m_pXMLNode, nIndex); + pNode->ClearFlag(XFA_NodeFlag_OwnXMLNode); + } + return TRUE; +} + +CXFA_Node* CXFA_Node::Deprecated_GetPrevSibling() { + if (!m_pParent) { + return nullptr; + } + for (CXFA_Node* pSibling = m_pParent->m_pChild; pSibling; + pSibling = pSibling->m_pNext) { + if (pSibling->m_pNext == this) { + return pSibling; + } + } + return nullptr; +} + +FX_BOOL CXFA_Node::RemoveChild(CXFA_Node* pNode, bool bNotify) { + if (!pNode || pNode->m_pParent != this) { + ASSERT(FALSE); + return FALSE; + } + if (m_pChild == pNode) { + m_pChild = pNode->m_pNext; + if (m_pLastChild == pNode) { + m_pLastChild = pNode->m_pNext; + } + pNode->m_pNext = nullptr; + pNode->m_pParent = nullptr; + } else { + CXFA_Node* pPrev = pNode->Deprecated_GetPrevSibling(); + pPrev->m_pNext = pNode->m_pNext; + if (m_pLastChild == pNode) { + m_pLastChild = pNode->m_pNext ? pNode->m_pNext : pPrev; + } + pNode->m_pNext = nullptr; + pNode->m_pParent = nullptr; + } + ASSERT(!m_pLastChild || !m_pLastChild->m_pNext); + OnRemoved(bNotify); + pNode->SetFlag(XFA_NodeFlag_HasRemovedChildren, true); + m_pDocument->AddPurgeNode(pNode); + if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) { + if (pNode->IsAttributeInXML()) { + ASSERT(pNode->m_pXMLNode == m_pXMLNode && + m_pXMLNode->GetType() == FDE_XMLNODE_Element); + if (pNode->m_pXMLNode->GetType() == FDE_XMLNODE_Element) { + CFDE_XMLElement* pXMLElement = + static_cast(pNode->m_pXMLNode); + CFX_WideStringC wsAttributeName = + pNode->GetCData(XFA_ATTRIBUTE_QualifiedName); + pXMLElement->RemoveAttribute(wsAttributeName.c_str()); + } + CFX_WideString wsName; + pNode->GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE); + CFDE_XMLElement* pNewXMLElement = new CFDE_XMLElement(wsName); + CFX_WideStringC wsValue = GetCData(XFA_ATTRIBUTE_Value); + if (!wsValue.IsEmpty()) { + pNewXMLElement->SetTextData(CFX_WideString(wsValue)); + } + pNode->m_pXMLNode = pNewXMLElement; + pNode->SetEnum(XFA_ATTRIBUTE_Contains, XFA_ATTRIBUTEENUM_Unknown); + } else { + m_pXMLNode->RemoveChildNode(pNode->m_pXMLNode); + } + pNode->SetFlag(XFA_NodeFlag_OwnXMLNode, false); + } + return TRUE; +} + +CXFA_Node* CXFA_Node::GetFirstChildByName(const CFX_WideStringC& wsName) const { + return GetFirstChildByName(FX_HashCode_GetW(wsName, false)); +} + +CXFA_Node* CXFA_Node::GetFirstChildByName(uint32_t dwNameHash) const { + for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_FirstChild); pNode; + pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { + if (pNode->GetNameHash() == dwNameHash) { + return pNode; + } + } + return nullptr; +} + +CXFA_Node* CXFA_Node::GetFirstChildByClass(XFA_Element eType) const { + for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_FirstChild); pNode; + pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { + if (pNode->GetElementType() == eType) { + return pNode; + } + } + return nullptr; +} + +CXFA_Node* CXFA_Node::GetNextSameNameSibling(uint32_t dwNameHash) const { + for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_NextSibling); pNode; + pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { + if (pNode->GetNameHash() == dwNameHash) { + return pNode; + } + } + return nullptr; +} + +CXFA_Node* CXFA_Node::GetNextSameNameSibling( + const CFX_WideStringC& wsNodeName) const { + return GetNextSameNameSibling(FX_HashCode_GetW(wsNodeName, false)); +} + +CXFA_Node* CXFA_Node::GetNextSameClassSibling(XFA_Element eType) const { + for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_NextSibling); pNode; + pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { + if (pNode->GetElementType() == eType) { + return pNode; + } + } + return nullptr; +} + +int32_t CXFA_Node::GetNodeSameNameIndex() const { + CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext(); + if (!pScriptContext) { + return -1; + } + return pScriptContext->GetIndexByName(const_cast(this)); +} + +int32_t CXFA_Node::GetNodeSameClassIndex() const { + CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext(); + if (!pScriptContext) { + return -1; + } + return pScriptContext->GetIndexByClassName(const_cast(this)); +} + +void CXFA_Node::GetSOMExpression(CFX_WideString& wsSOMExpression) { + CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext(); + if (!pScriptContext) { + return; + } + pScriptContext->GetSomExpression(this, wsSOMExpression); +} + +CXFA_Node* CXFA_Node::GetInstanceMgrOfSubform() { + CXFA_Node* pInstanceMgr = nullptr; + if (m_ePacket == XFA_XDPPACKET_Form) { + CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent); + if (!pParentNode || pParentNode->GetElementType() == XFA_Element::Area) { + return pInstanceMgr; + } + for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode; + pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) { + XFA_Element eType = pNode->GetElementType(); + if ((eType == XFA_Element::Subform || eType == XFA_Element::SubformSet) && + pNode->m_dwNameHash != m_dwNameHash) { + break; + } + if (eType == XFA_Element::InstanceManager) { + CFX_WideStringC wsName = GetCData(XFA_ATTRIBUTE_Name); + CFX_WideStringC wsInstName = pNode->GetCData(XFA_ATTRIBUTE_Name); + if (wsInstName.GetLength() > 0 && wsInstName.GetAt(0) == '_' && + wsInstName.Mid(1) == wsName) { + pInstanceMgr = pNode; + } + break; + } + } + } + return pInstanceMgr; +} + +CXFA_Node* CXFA_Node::GetOccurNode() { + return GetFirstChildByClass(XFA_Element::Occur); +} + +bool CXFA_Node::HasFlag(XFA_NodeFlag dwFlag) const { + if (m_uNodeFlags & dwFlag) + return true; + if (dwFlag == XFA_NodeFlag_HasRemovedChildren) + return m_pParent && m_pParent->HasFlag(dwFlag); + return false; +} + +void CXFA_Node::SetFlag(uint32_t dwFlag, bool bNotify) { + if (dwFlag == XFA_NodeFlag_Initialized && bNotify && !IsInitialized()) { + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (pNotify) { + pNotify->OnNodeReady(this); + } + } + m_uNodeFlags |= dwFlag; +} + +void CXFA_Node::ClearFlag(uint32_t dwFlag) { + m_uNodeFlags &= ~dwFlag; +} + +FX_BOOL CXFA_Node::IsAttributeInXML() { + return GetEnum(XFA_ATTRIBUTE_Contains) == XFA_ATTRIBUTEENUM_MetaData; +} + +void CXFA_Node::OnRemoved(bool bNotify) { + if (!bNotify) + return; + + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (pNotify) + pNotify->OnChildRemoved(); +} + +void CXFA_Node::OnChanging(XFA_ATTRIBUTE eAttr, bool bNotify) { + if (bNotify && IsInitialized()) { + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (pNotify) { + pNotify->OnValueChanging(this, eAttr); + } + } +} + +void CXFA_Node::OnChanged(XFA_ATTRIBUTE eAttr, + bool bNotify, + FX_BOOL bScriptModify) { + if (bNotify && IsInitialized()) { + Script_Attribute_SendAttributeChangeMessage(eAttr, bScriptModify); + } +} + +int32_t CXFA_Node::execSingleEventByName(const CFX_WideStringC& wsEventName, + XFA_Element eType) { + int32_t iRet = XFA_EVENTERROR_NotExist; + const XFA_ExecEventParaInfo* eventParaInfo = + GetEventParaInfoByName(wsEventName); + if (eventParaInfo) { + uint32_t validFlags = eventParaInfo->m_validFlags; + CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); + if (!pNotify) { + return iRet; + } + if (validFlags == 1) { + iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType); + } else if (validFlags == 2) { + iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType, + FALSE, FALSE); + } else if (validFlags == 3) { + if (eType == XFA_Element::Subform) { + iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType, + FALSE, FALSE); + } + } else if (validFlags == 4) { + if (eType == XFA_Element::ExclGroup || eType == XFA_Element::Field) { + CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent); + if (pParentNode && + pParentNode->GetElementType() == XFA_Element::ExclGroup) { + iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType, + FALSE, FALSE); + } + iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType, + FALSE, FALSE); + } + } else if (validFlags == 5) { + if (eType == XFA_Element::Field) { + iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType, + FALSE, FALSE); + } + } else if (validFlags == 6) { + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (pWidgetData) { + CXFA_Node* pUINode = pWidgetData->GetUIChild(); + if (pUINode->m_elementType == XFA_Element::Signature) { + iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType, + FALSE, FALSE); + } + } + } else if (validFlags == 7) { + CXFA_WidgetData* pWidgetData = GetWidgetData(); + if (pWidgetData) { + CXFA_Node* pUINode = pWidgetData->GetUIChild(); + if ((pUINode->m_elementType == XFA_Element::ChoiceList) && + (!pWidgetData->IsListBox())) { + iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType, + FALSE, FALSE); + } + } + } + } + return iRet; +} + +void CXFA_Node::UpdateNameHash() { + const XFA_NOTSUREATTRIBUTE* pNotsure = + XFA_GetNotsureAttribute(GetElementType(), XFA_ATTRIBUTE_Name); + CFX_WideStringC wsName; + if (!pNotsure || pNotsure->eType == XFA_ATTRIBUTETYPE_Cdata) { + wsName = GetCData(XFA_ATTRIBUTE_Name); + m_dwNameHash = FX_HashCode_GetW(wsName, false); + } else if (pNotsure->eType == XFA_ATTRIBUTETYPE_Enum) { + wsName = XFA_GetAttributeEnumByID(GetEnum(XFA_ATTRIBUTE_Name))->pName; + m_dwNameHash = FX_HashCode_GetW(wsName, false); + } +} + +CFDE_XMLNode* CXFA_Node::CreateXMLMappingNode() { + if (!m_pXMLNode) { + CFX_WideString wsTag(GetCData(XFA_ATTRIBUTE_Name)); + m_pXMLNode = new CFDE_XMLElement(wsTag); + SetFlag(XFA_NodeFlag_OwnXMLNode, false); + } + return m_pXMLNode; +} + +FX_BOOL CXFA_Node::IsNeedSavingXMLNode() { + return m_pXMLNode && (GetPacketID() == XFA_XDPPACKET_Datasets || + GetElementType() == XFA_Element::Xfa); +} + +XFA_MAPMODULEDATA* CXFA_Node::CreateMapModuleData() { + if (!m_pMapModuleData) + m_pMapModuleData = new XFA_MAPMODULEDATA; + return m_pMapModuleData; +} + +XFA_MAPMODULEDATA* CXFA_Node::GetMapModuleData() const { + return m_pMapModuleData; +} + +void CXFA_Node::SetMapModuleValue(void* pKey, void* pValue) { + XFA_MAPMODULEDATA* pModule = CreateMapModuleData(); + pModule->m_ValueMap.SetAt(pKey, pValue); +} + +FX_BOOL CXFA_Node::GetMapModuleValue(void* pKey, void*& pValue) { + CXFA_Node* pNode = this; + while (pNode) { + XFA_MAPMODULEDATA* pModule = pNode->GetMapModuleData(); + if (pModule && pModule->m_ValueMap.Lookup(pKey, pValue)) { + return TRUE; + } + pNode = pNode->GetPacketID() != XFA_XDPPACKET_Datasets + ? pNode->GetTemplateNode() + : nullptr; + } + return FALSE; +} + +void CXFA_Node::SetMapModuleString(void* pKey, const CFX_WideStringC& wsValue) { + SetMapModuleBuffer(pKey, (void*)wsValue.c_str(), + wsValue.GetLength() * sizeof(FX_WCHAR)); +} + +FX_BOOL CXFA_Node::GetMapModuleString(void* pKey, CFX_WideStringC& wsValue) { + void* pValue; + int32_t iBytes; + if (!GetMapModuleBuffer(pKey, pValue, iBytes)) { + return FALSE; + } + wsValue = CFX_WideStringC((const FX_WCHAR*)pValue, iBytes / sizeof(FX_WCHAR)); + return TRUE; +} + +void CXFA_Node::SetMapModuleBuffer( + void* pKey, + void* pValue, + int32_t iBytes, + XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) { + XFA_MAPMODULEDATA* pModule = CreateMapModuleData(); + XFA_MAPDATABLOCK*& pBuffer = pModule->m_BufferMap[pKey]; + if (!pBuffer) { + pBuffer = + (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 = (XFA_MAPDATABLOCK*)FX_Realloc(uint8_t, pBuffer, + sizeof(XFA_MAPDATABLOCK) + iBytes); + } else if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) { + pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData()); + } + if (!pBuffer) + return; + + pBuffer->pCallbackInfo = pCallbackInfo; + pBuffer->iBytes = iBytes; + FXSYS_memcpy(pBuffer->GetData(), pValue, iBytes); +} + +FX_BOOL CXFA_Node::GetMapModuleBuffer(void* pKey, + void*& pValue, + int32_t& iBytes, + FX_BOOL bProtoAlso) const { + XFA_MAPDATABLOCK* pBuffer = nullptr; + const CXFA_Node* pNode = this; + while (pNode) { + XFA_MAPMODULEDATA* pModule = pNode->GetMapModuleData(); + if (pModule && pModule->m_BufferMap.Lookup(pKey, pBuffer)) { + break; + } + pNode = (bProtoAlso && pNode->GetPacketID() != XFA_XDPPACKET_Datasets) + ? pNode->GetTemplateNode() + : nullptr; + } + if (!pBuffer) { + return FALSE; + } + pValue = pBuffer->GetData(); + iBytes = pBuffer->iBytes; + return TRUE; +} + +FX_BOOL CXFA_Node::HasMapModuleKey(void* pKey, FX_BOOL bProtoAlso) { + CXFA_Node* pNode = this; + while (pNode) { + void* pVal; + XFA_MAPMODULEDATA* pModule = pNode->GetMapModuleData(); + if (pModule && + (pModule->m_ValueMap.Lookup(pKey, pVal) || + pModule->m_BufferMap.Lookup(pKey, (XFA_MAPDATABLOCK*&)pVal))) { + return TRUE; + } + pNode = (bProtoAlso && pNode->GetPacketID() != XFA_XDPPACKET_Datasets) + ? pNode->GetTemplateNode() + : nullptr; + } + return FALSE; +} + +void CXFA_Node::RemoveMapModuleKey(void* pKey) { + XFA_MAPMODULEDATA* pModule = GetMapModuleData(); + if (!pModule) + return; + + if (pKey) { + XFA_MAPDATABLOCK* pBuffer = nullptr; + pModule->m_BufferMap.Lookup(pKey, pBuffer); + if (pBuffer) { + if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) { + pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData()); + } + FX_Free(pBuffer); + } + pModule->m_BufferMap.RemoveKey(pKey); + pModule->m_ValueMap.RemoveKey(pKey); + } else { + XFA_MAPDATABLOCK* pBuffer; + FX_POSITION posBuffer = pModule->m_BufferMap.GetStartPosition(); + while (posBuffer) { + pModule->m_BufferMap.GetNextAssoc(posBuffer, pKey, pBuffer); + if (pBuffer) { + if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) { + pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData()); + } + FX_Free(pBuffer); + } + } + pModule->m_BufferMap.RemoveAll(); + pModule->m_ValueMap.RemoveAll(); + delete pModule; + } +} + +void CXFA_Node::MergeAllData(void* pDstModule, FX_BOOL bUseSrcAttr) { + XFA_MAPMODULEDATA* pDstModuleData = + static_cast(pDstModule)->CreateMapModuleData(); + XFA_MAPMODULEDATA* pSrcModuleData = GetMapModuleData(); + if (!pSrcModuleData) { + return; + } + FX_POSITION psValue = pSrcModuleData->m_ValueMap.GetStartPosition(); + while (psValue) { + void* pKey; + void* pValue; + pSrcModuleData->m_ValueMap.GetNextAssoc(psValue, pKey, pValue); + if (bUseSrcAttr || !pDstModuleData->m_ValueMap.GetValueAt(pKey)) { + pDstModuleData->m_ValueMap.SetAt(pKey, pValue); + } + } + FX_POSITION psBuffer = pSrcModuleData->m_BufferMap.GetStartPosition(); + while (psBuffer) { + void* pKey; + XFA_MAPDATABLOCK* pSrcBuffer; + pSrcModuleData->m_BufferMap.GetNextAssoc(psBuffer, pKey, pSrcBuffer); + XFA_MAPDATABLOCK*& pBuffer = pDstModuleData->m_BufferMap[pKey]; + if (pBuffer && !bUseSrcAttr) { + continue; + } + if (pSrcBuffer->pCallbackInfo && pSrcBuffer->pCallbackInfo->pFree && + !pSrcBuffer->pCallbackInfo->pCopy) { + if (pBuffer) { + pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData()); + pDstModuleData->m_BufferMap.RemoveKey(pKey); + } + continue; + } + if (!pBuffer) { + pBuffer = (XFA_MAPDATABLOCK*)FX_Alloc( + uint8_t, sizeof(XFA_MAPDATABLOCK) + pSrcBuffer->iBytes); + } else if (pBuffer->iBytes != pSrcBuffer->iBytes) { + if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) { + pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData()); + } + pBuffer = (XFA_MAPDATABLOCK*)FX_Realloc( + uint8_t, pBuffer, sizeof(XFA_MAPDATABLOCK) + pSrcBuffer->iBytes); + } else if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) { + pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData()); + } + if (!pBuffer) { + continue; + } + pBuffer->pCallbackInfo = pSrcBuffer->pCallbackInfo; + pBuffer->iBytes = pSrcBuffer->iBytes; + FXSYS_memcpy(pBuffer->GetData(), pSrcBuffer->GetData(), pSrcBuffer->iBytes); + if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pCopy) { + pBuffer->pCallbackInfo->pCopy(*(void**)pBuffer->GetData()); + } + } +} + +void CXFA_Node::MoveBufferMapData(CXFA_Node* pDstModule, void* pKey) { + if (!pDstModule) { + return; + } + FX_BOOL bNeedMove = TRUE; + if (!pKey) { + bNeedMove = FALSE; + } + if (pDstModule->GetElementType() != GetElementType()) { + bNeedMove = FALSE; + } + XFA_MAPMODULEDATA* pSrcModuleData = nullptr; + XFA_MAPMODULEDATA* pDstModuleData = nullptr; + if (bNeedMove) { + pSrcModuleData = GetMapModuleData(); + if (!pSrcModuleData) { + bNeedMove = FALSE; + } + pDstModuleData = pDstModule->CreateMapModuleData(); + } + if (bNeedMove) { + void* pBufferBlockData = pSrcModuleData->m_BufferMap.GetValueAt(pKey); + if (pBufferBlockData) { + pSrcModuleData->m_BufferMap.RemoveKey(pKey); + pDstModuleData->m_BufferMap.RemoveKey(pKey); + pDstModuleData->m_BufferMap.SetAt(pKey, + (XFA_MAPDATABLOCK*)pBufferBlockData); + } + } + if (pDstModule->IsNodeV()) { + CFX_WideString wsValue = pDstModule->GetScriptContent(FALSE); + CFX_WideString wsFormatValue(wsValue); + CXFA_WidgetData* pWidgetData = pDstModule->GetContainerWidgetData(); + if (pWidgetData) { + pWidgetData->GetFormatDataValue(wsValue, wsFormatValue); + } + pDstModule->SetScriptContent(wsValue, wsFormatValue, true, TRUE); + } +} + +void CXFA_Node::MoveBufferMapData(CXFA_Node* pSrcModule, + CXFA_Node* pDstModule, + void* pKey, + FX_BOOL bRecursive) { + if (!pSrcModule || !pDstModule || !pKey) { + return; + } + if (bRecursive) { + CXFA_Node* pSrcChild = pSrcModule->GetNodeItem(XFA_NODEITEM_FirstChild); + CXFA_Node* pDstChild = pDstModule->GetNodeItem(XFA_NODEITEM_FirstChild); + for (; pSrcChild && pDstChild; + pSrcChild = pSrcChild->GetNodeItem(XFA_NODEITEM_NextSibling), + pDstChild = pDstChild->GetNodeItem(XFA_NODEITEM_NextSibling)) { + MoveBufferMapData(pSrcChild, pDstChild, pKey, TRUE); + } + } + pSrcModule->MoveBufferMapData(pDstModule, pKey); +} diff --git a/xfa/fxfa/parser/cxfa_nodelist.cpp b/xfa/fxfa/parser/cxfa_nodelist.cpp new file mode 100644 index 0000000000..e95c2f61ca --- /dev/null +++ b/xfa/fxfa/parser/cxfa_nodelist.cpp @@ -0,0 +1,118 @@ +// Copyright 2016 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 "xfa/fxfa/parser/xfa_object.h" + +#include "core/fxcrt/include/fx_ext.h" +#include "xfa/fxfa/parser/xfa_document.h" +#include "xfa/fxfa/parser/xfa_script_imp.h" + +CXFA_NodeList::CXFA_NodeList(CXFA_Document* pDocument) + : CXFA_Object(pDocument, + XFA_ObjectType::NodeList, + XFA_Element::NodeList, + CFX_WideStringC(L"nodeList")) { + m_pDocument->GetScriptContext()->AddToCacheList( + std::unique_ptr(this)); +} + +CXFA_NodeList::~CXFA_NodeList() {} + +CXFA_Node* CXFA_NodeList::NamedItem(const CFX_WideStringC& wsName) { + uint32_t dwHashCode = FX_HashCode_GetW(wsName, false); + int32_t iCount = GetLength(); + for (int32_t i = 0; i < iCount; i++) { + CXFA_Node* ret = Item(i); + if (dwHashCode == ret->GetNameHash()) + return ret; + } + return nullptr; +} + +void CXFA_NodeList::Script_ListClass_Append(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 1) { + CXFA_Node* pNode = static_cast(pArguments->GetObject(0)); + if (pNode) { + Append(pNode); + } else { + ThrowException(XFA_IDS_ARGUMENT_MISMATCH); + } + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"append"); + } +} + +void CXFA_NodeList::Script_ListClass_Insert(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 2) { + CXFA_Node* pNewNode = static_cast(pArguments->GetObject(0)); + CXFA_Node* pBeforeNode = static_cast(pArguments->GetObject(1)); + if (pNewNode) { + Insert(pNewNode, pBeforeNode); + } else { + ThrowException(XFA_IDS_ARGUMENT_MISMATCH); + } + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"insert"); + } +} + +void CXFA_NodeList::Script_ListClass_Remove(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 1) { + CXFA_Node* pNode = static_cast(pArguments->GetObject(0)); + if (pNode) { + Remove(pNode); + } else { + ThrowException(XFA_IDS_ARGUMENT_MISMATCH); + } + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"remove"); + } +} + +void CXFA_NodeList::Script_ListClass_Item(CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 1) { + int32_t iIndex = pArguments->GetInt32(0); + if ((iIndex >= 0) && (iIndex + 1 <= GetLength())) { + pArguments->GetReturnValue()->Assign( + m_pDocument->GetScriptContext()->GetJSValueFromMap(Item(iIndex))); + } else { + ThrowException(XFA_IDS_INDEX_OUT_OF_BOUNDS); + } + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"item"); + } +} + +void CXFA_NodeList::Script_TreelistClass_NamedItem( + CFXJSE_Arguments* pArguments) { + int32_t argc = pArguments->GetLength(); + if (argc == 1) { + CFX_ByteString szName = pArguments->GetUTF8String(0); + CXFA_Node* pNode = + NamedItem(CFX_WideString::FromUTF8(szName.AsStringC()).AsStringC()); + if (!pNode) { + return; + } + pArguments->GetReturnValue()->Assign( + m_pDocument->GetScriptContext()->GetJSValueFromMap(pNode)); + } else { + ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"namedItem"); + } +} + +void CXFA_NodeList::Script_ListClass_Length(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (!bSetting) { + pValue->SetInteger(GetLength()); + } else { + ThrowException(XFA_IDS_INVAlID_PROP_SET); + } +} diff --git a/xfa/fxfa/parser/cxfa_object.cpp b/xfa/fxfa/parser/cxfa_object.cpp new file mode 100644 index 0000000000..fd553dd096 --- /dev/null +++ b/xfa/fxfa/parser/cxfa_object.cpp @@ -0,0 +1,62 @@ +// Copyright 2016 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 "xfa/fxfa/parser/xfa_object.h" + +#include "core/fxcrt/include/fx_ext.h" +#include "fxjs/include/cfxjse_value.h" +#include "xfa/fxfa/app/xfa_ffnotify.h" +#include "xfa/fxfa/parser/xfa_document.h" + +CXFA_Object::CXFA_Object(CXFA_Document* pDocument, + XFA_ObjectType objectType, + XFA_Element elementType, + const CFX_WideStringC& elementName) + : m_pDocument(pDocument), + m_objectType(objectType), + m_elementType(elementType), + m_elementNameHash(FX_HashCode_GetW(elementName, false)), + m_elementName(elementName) {} + +CXFA_Object::~CXFA_Object() {} + +CFX_WideStringC CXFA_Object::GetClassName() const { + return m_elementName; +} + +uint32_t CXFA_Object::GetClassHashCode() const { + return m_elementNameHash; +} + +XFA_Element CXFA_Object::GetElementType() const { + return m_elementType; +} + +void CXFA_Object::Script_ObjectClass_ClassName(CFXJSE_Value* pValue, + FX_BOOL bSetting, + XFA_ATTRIBUTE eAttribute) { + if (bSetting) { + ThrowException(XFA_IDS_INVAlID_PROP_SET); + return; + } + CFX_WideStringC className = GetClassName(); + pValue->SetString( + FX_UTF8Encode(className.c_str(), className.GetLength()).AsStringC()); +} + +void CXFA_Object::ThrowException(int32_t iStringID, ...) { + IXFA_AppProvider* pAppProvider = m_pDocument->GetNotify()->GetAppProvider(); + ASSERT(pAppProvider); + CFX_WideString wsFormat; + pAppProvider->LoadString(iStringID, wsFormat); + CFX_WideString wsMessage; + va_list arg_ptr; + va_start(arg_ptr, iStringID); + wsMessage.FormatV(wsFormat.c_str(), arg_ptr); + va_end(arg_ptr); + FXJSE_ThrowMessage( + FX_UTF8Encode(wsMessage.c_str(), wsMessage.GetLength()).AsStringC()); +} diff --git a/xfa/fxfa/parser/cxfa_thisproxy.cpp b/xfa/fxfa/parser/cxfa_thisproxy.cpp new file mode 100644 index 0000000000..bf6f12c804 --- /dev/null +++ b/xfa/fxfa/parser/cxfa_thisproxy.cpp @@ -0,0 +1,28 @@ +// Copyright 2016 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 "xfa/fxfa/parser/xfa_object.h" + +CXFA_ThisProxy::CXFA_ThisProxy(CXFA_Node* pThisNode, CXFA_Node* pScriptNode) + : CXFA_Object(pThisNode->GetDocument(), + XFA_ObjectType::VariablesThis, + XFA_Element::Unknown, + CFX_WideStringC()), + m_pThisNode(nullptr), + m_pScriptNode(nullptr) { + m_pThisNode = pThisNode; + m_pScriptNode = pScriptNode; +} + +CXFA_ThisProxy::~CXFA_ThisProxy() {} + +CXFA_Node* CXFA_ThisProxy::GetThisNode() const { + return m_pThisNode; +} + +CXFA_Node* CXFA_ThisProxy::GetScriptNode() const { + return m_pScriptNode; +} diff --git a/xfa/fxfa/parser/xfa_object_imp.cpp b/xfa/fxfa/parser/xfa_object_imp.cpp deleted file mode 100644 index 463247e640..0000000000 --- a/xfa/fxfa/parser/xfa_object_imp.cpp +++ /dev/null @@ -1,5272 +0,0 @@ -// Copyright 2014 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 "xfa/fxfa/parser/xfa_object.h" - -#include - -#include "core/fxcrt/include/fx_ext.h" -#include "fxjs/include/cfxjse_arguments.h" -#include "third_party/base/stl_util.h" -#include "xfa/fde/xml/fde_xml_imp.h" -#include "xfa/fgas/crt/fgas_codepage.h" -#include "xfa/fgas/crt/fgas_system.h" -#include "xfa/fxfa/app/xfa_ffnotify.h" -#include "xfa/fxfa/parser/cxfa_occur.h" -#include "xfa/fxfa/parser/cxfa_simple_parser.h" -#include "xfa/fxfa/parser/xfa_basic_imp.h" -#include "xfa/fxfa/parser/xfa_doclayout.h" -#include "xfa/fxfa/parser/xfa_document.h" -#include "xfa/fxfa/parser/xfa_document_layout_imp.h" -#include "xfa/fxfa/parser/xfa_localemgr.h" -#include "xfa/fxfa/parser/xfa_script.h" -#include "xfa/fxfa/parser/xfa_script_imp.h" -#include "xfa/fxfa/parser/xfa_utils.h" - -namespace { - -void XFA_DeleteWideString(void* pData) { - delete static_cast(pData); -} - -void XFA_CopyWideString(void*& pData) { - if (pData) { - CFX_WideString* pNewData = new CFX_WideString(*(CFX_WideString*)pData); - pData = pNewData; - } -} - -XFA_MAPDATABLOCKCALLBACKINFO deleteWideStringCallBack = {XFA_DeleteWideString, - XFA_CopyWideString}; - -void XFA_DataNodeDeleteBindItem(void* pData) { - delete static_cast(pData); -} - -XFA_MAPDATABLOCKCALLBACKINFO deleteBindItemCallBack = { - XFA_DataNodeDeleteBindItem, nullptr}; - -} // namespace - -CXFA_Object::CXFA_Object(CXFA_Document* pDocument, - XFA_ObjectType objectType, - XFA_Element elementType, - const CFX_WideStringC& elementName) - : m_pDocument(pDocument), - m_objectType(objectType), - m_elementType(elementType), - m_elementNameHash(FX_HashCode_GetW(elementName, false)), - m_elementName(elementName) {} - -CXFA_Object::~CXFA_Object() {} - -CFX_WideStringC CXFA_Object::GetClassName() const { - return m_elementName; -} - -uint32_t CXFA_Object::GetClassHashCode() const { - return m_elementNameHash; -} - -XFA_Element CXFA_Object::GetElementType() const { - return m_elementType; -} - -void CXFA_Object::Script_ObjectClass_ClassName(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (!bSetting) { - CFX_WideStringC className = GetClassName(); - pValue->SetString( - FX_UTF8Encode(className.c_str(), className.GetLength()).AsStringC()); - } else { - ThrowException(XFA_IDS_INVAlID_PROP_SET); - } -} - -void CXFA_Object::ThrowException(int32_t iStringID, ...) { - IXFA_AppProvider* pAppProvider = m_pDocument->GetNotify()->GetAppProvider(); - ASSERT(pAppProvider); - CFX_WideString wsFormat; - pAppProvider->LoadString(iStringID, wsFormat); - CFX_WideString wsMessage; - va_list arg_ptr; - va_start(arg_ptr, iStringID); - wsMessage.FormatV(wsFormat.c_str(), arg_ptr); - va_end(arg_ptr); - FXJSE_ThrowMessage( - FX_UTF8Encode(wsMessage.c_str(), wsMessage.GetLength()).AsStringC()); -} - -XFA_MAPMODULEDATA::XFA_MAPMODULEDATA() {} - -XFA_MAPMODULEDATA::~XFA_MAPMODULEDATA() {} - -CXFA_Node::CXFA_Node(CXFA_Document* pDoc, - uint16_t ePacket, - XFA_ObjectType oType, - XFA_Element eType, - const CFX_WideStringC& elementName) - : CXFA_Object(pDoc, oType, eType, elementName), - m_pNext(nullptr), - m_pChild(nullptr), - m_pLastChild(nullptr), - m_pParent(nullptr), - m_pXMLNode(nullptr), - m_ePacket(ePacket), - m_uNodeFlags(XFA_NodeFlag_None), - m_dwNameHash(0), - m_pAuxNode(nullptr), - m_pMapModuleData(nullptr) { - ASSERT(m_pDocument); -} - -CXFA_Node::~CXFA_Node() { - ASSERT(!m_pParent); - RemoveMapModuleKey(); - CXFA_Node* pNode = m_pChild; - while (pNode) { - CXFA_Node* pNext = pNode->m_pNext; - pNode->m_pParent = nullptr; - delete pNode; - pNode = pNext; - } - if (m_pXMLNode && IsOwnXMLNode()) - m_pXMLNode->Release(); -} - -CXFA_Node* CXFA_Node::Clone(FX_BOOL bRecursive) { - CXFA_Node* pClone = m_pDocument->CreateNode(m_ePacket, m_elementType); - if (!pClone) - return nullptr; - - MergeAllData(pClone); - pClone->UpdateNameHash(); - if (IsNeedSavingXMLNode()) { - CFDE_XMLNode* pCloneXML = nullptr; - if (IsAttributeInXML()) { - CFX_WideString wsName; - GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE); - CFDE_XMLElement* pCloneXMLElement = new CFDE_XMLElement(wsName); - CFX_WideStringC wsValue = GetCData(XFA_ATTRIBUTE_Value); - if (!wsValue.IsEmpty()) { - pCloneXMLElement->SetTextData(CFX_WideString(wsValue)); - } - pCloneXML = pCloneXMLElement; - pCloneXMLElement = nullptr; - pClone->SetEnum(XFA_ATTRIBUTE_Contains, XFA_ATTRIBUTEENUM_Unknown); - } else { - pCloneXML = m_pXMLNode->Clone(FALSE); - } - pClone->SetXMLMappingNode(pCloneXML); - pClone->SetFlag(XFA_NodeFlag_OwnXMLNode, false); - } - if (bRecursive) { - for (CXFA_Node* pChild = GetNodeItem(XFA_NODEITEM_FirstChild); pChild; - pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) { - pClone->InsertChild(pChild->Clone(bRecursive)); - } - } - pClone->SetFlag(XFA_NodeFlag_Initialized, true); - pClone->SetObject(XFA_ATTRIBUTE_BindingNode, nullptr); - return pClone; -} - -CXFA_Node* CXFA_Node::GetNodeItem(XFA_NODEITEM eItem) const { - switch (eItem) { - case XFA_NODEITEM_NextSibling: - return m_pNext; - case XFA_NODEITEM_FirstChild: - return m_pChild; - case XFA_NODEITEM_Parent: - return m_pParent; - case XFA_NODEITEM_PrevSibling: - if (m_pParent) { - CXFA_Node* pSibling = m_pParent->m_pChild; - CXFA_Node* pPrev = nullptr; - while (pSibling && pSibling != this) { - pPrev = pSibling; - pSibling = pSibling->m_pNext; - } - return pPrev; - } - return nullptr; - default: - break; - } - return nullptr; -} - -CXFA_Node* CXFA_Node::GetNodeItem(XFA_NODEITEM eItem, - XFA_ObjectType eType) const { - CXFA_Node* pNode = nullptr; - switch (eItem) { - case XFA_NODEITEM_NextSibling: - pNode = m_pNext; - while (pNode && pNode->GetObjectType() != eType) - pNode = pNode->m_pNext; - break; - case XFA_NODEITEM_FirstChild: - pNode = m_pChild; - while (pNode && pNode->GetObjectType() != eType) - pNode = pNode->m_pNext; - break; - case XFA_NODEITEM_Parent: - pNode = m_pParent; - while (pNode && pNode->GetObjectType() != eType) - pNode = pNode->m_pParent; - break; - case XFA_NODEITEM_PrevSibling: - if (m_pParent) { - CXFA_Node* pSibling = m_pParent->m_pChild; - while (pSibling && pSibling != this) { - if (eType == pSibling->GetObjectType()) - pNode = pSibling; - - pSibling = pSibling->m_pNext; - } - } - break; - default: - break; - } - return pNode; -} - -int32_t CXFA_Node::GetNodeList(CXFA_NodeArray& nodes, - uint32_t dwTypeFilter, - XFA_Element eTypeFilter, - int32_t iLevel) { - if (--iLevel < 0) { - return nodes.GetSize(); - } - if (eTypeFilter != XFA_Element::Unknown) { - CXFA_Node* pChild = m_pChild; - while (pChild) { - if (pChild->GetElementType() == eTypeFilter) { - nodes.Add(pChild); - if (iLevel > 0) { - GetNodeList(nodes, dwTypeFilter, eTypeFilter, iLevel); - } - } - pChild = pChild->m_pNext; - } - } else if (dwTypeFilter == - (XFA_NODEFILTER_Children | XFA_NODEFILTER_Properties)) { - CXFA_Node* pChild = m_pChild; - while (pChild) { - nodes.Add(pChild); - if (iLevel > 0) { - GetNodeList(nodes, dwTypeFilter, eTypeFilter, iLevel); - } - pChild = pChild->m_pNext; - } - } else if (dwTypeFilter != 0) { - bool bFilterChildren = !!(dwTypeFilter & XFA_NODEFILTER_Children); - bool bFilterProperties = !!(dwTypeFilter & XFA_NODEFILTER_Properties); - bool bFilterOneOfProperties = - !!(dwTypeFilter & XFA_NODEFILTER_OneOfProperty); - CXFA_Node* pChild = m_pChild; - while (pChild) { - const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement( - GetElementType(), pChild->GetElementType(), XFA_XDPPACKET_UNKNOWN); - if (pProperty) { - if (bFilterProperties) { - nodes.Add(pChild); - } else if (bFilterOneOfProperties && - (pProperty->uFlags & XFA_PROPERTYFLAG_OneOf)) { - nodes.Add(pChild); - } else if (bFilterChildren && - (pChild->GetElementType() == XFA_Element::Variables || - pChild->GetElementType() == XFA_Element::PageSet)) { - nodes.Add(pChild); - } - } else if (bFilterChildren) { - nodes.Add(pChild); - } - pChild = pChild->m_pNext; - } - if (bFilterOneOfProperties && nodes.GetSize() < 1) { - int32_t iProperties = 0; - const XFA_PROPERTY* pProperty = - XFA_GetElementProperties(GetElementType(), iProperties); - if (!pProperty || iProperties < 1) - return 0; - for (int32_t i = 0; i < iProperties; i++) { - if (pProperty[i].uFlags & XFA_PROPERTYFLAG_DefaultOneOf) { - const XFA_PACKETINFO* pPacket = XFA_GetPacketByID(GetPacketID()); - CXFA_Node* pNewNode = - m_pDocument->CreateNode(pPacket, pProperty[i].eName); - if (!pNewNode) - break; - InsertChild(pNewNode, nullptr); - pNewNode->SetFlag(XFA_NodeFlag_Initialized, true); - nodes.Add(pNewNode); - break; - } - } - } - } - return nodes.GetSize(); -} - -CXFA_Node* CXFA_Node::CreateSamePacketNode(XFA_Element eType, - uint32_t dwFlags) { - CXFA_Node* pNode = m_pDocument->CreateNode(m_ePacket, eType); - pNode->SetFlag(dwFlags, true); - return pNode; -} - -CXFA_Node* CXFA_Node::CloneTemplateToForm(FX_BOOL bRecursive) { - ASSERT(m_ePacket == XFA_XDPPACKET_Template); - CXFA_Node* pClone = - m_pDocument->CreateNode(XFA_XDPPACKET_Form, m_elementType); - if (!pClone) - return nullptr; - - pClone->SetTemplateNode(this); - pClone->UpdateNameHash(); - pClone->SetXMLMappingNode(GetXMLMappingNode()); - if (bRecursive) { - for (CXFA_Node* pChild = GetNodeItem(XFA_NODEITEM_FirstChild); pChild; - pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) { - pClone->InsertChild(pChild->CloneTemplateToForm(bRecursive)); - } - } - pClone->SetFlag(XFA_NodeFlag_Initialized, true); - return pClone; -} - -CXFA_Node* CXFA_Node::GetTemplateNode() const { - return m_pAuxNode; -} - -void CXFA_Node::SetTemplateNode(CXFA_Node* pTemplateNode) { - m_pAuxNode = pTemplateNode; -} - -CXFA_Node* CXFA_Node::GetBindData() { - ASSERT(GetPacketID() == XFA_XDPPACKET_Form); - return static_cast(GetObject(XFA_ATTRIBUTE_BindingNode)); -} - -int32_t CXFA_Node::GetBindItems(CXFA_NodeArray& formItems) { - if (BindsFormItems()) { - CXFA_NodeArray* pItems = nullptr; - TryObject(XFA_ATTRIBUTE_BindingNode, (void*&)pItems); - formItems.Copy(*pItems); - return formItems.GetSize(); - } - CXFA_Node* pFormNode = - static_cast(GetObject(XFA_ATTRIBUTE_BindingNode)); - if (pFormNode) - formItems.Add(pFormNode); - return formItems.GetSize(); -} - -int32_t CXFA_Node::AddBindItem(CXFA_Node* pFormNode) { - ASSERT(pFormNode); - if (BindsFormItems()) { - CXFA_NodeArray* pItems = nullptr; - TryObject(XFA_ATTRIBUTE_BindingNode, (void*&)pItems); - ASSERT(pItems); - if (pItems->Find(pFormNode) < 0) { - pItems->Add(pFormNode); - } - return pItems->GetSize(); - } - CXFA_Node* pOldFormItem = - static_cast(GetObject(XFA_ATTRIBUTE_BindingNode)); - if (!pOldFormItem) { - SetObject(XFA_ATTRIBUTE_BindingNode, pFormNode); - return 1; - } else if (pOldFormItem == pFormNode) { - return 1; - } - CXFA_NodeArray* pItems = new CXFA_NodeArray; - SetObject(XFA_ATTRIBUTE_BindingNode, pItems, &deleteBindItemCallBack); - pItems->Add(pOldFormItem); - pItems->Add(pFormNode); - m_uNodeFlags |= XFA_NodeFlag_BindFormItems; - return 2; -} - -int32_t CXFA_Node::RemoveBindItem(CXFA_Node* pFormNode) { - if (BindsFormItems()) { - CXFA_NodeArray* pItems = nullptr; - TryObject(XFA_ATTRIBUTE_BindingNode, (void*&)pItems); - ASSERT(pItems); - int32_t iIndex = pItems->Find(pFormNode); - int32_t iCount = pItems->GetSize(); - if (iIndex >= 0) { - if (iIndex != iCount - 1) - pItems->SetAt(iIndex, pItems->GetAt(iCount - 1)); - pItems->RemoveAt(iCount - 1); - if (iCount == 2) { - CXFA_Node* pLastFormNode = pItems->GetAt(0); - SetObject(XFA_ATTRIBUTE_BindingNode, pLastFormNode); - m_uNodeFlags &= ~XFA_NodeFlag_BindFormItems; - } - iCount--; - } - return iCount; - } - CXFA_Node* pOldFormItem = - static_cast(GetObject(XFA_ATTRIBUTE_BindingNode)); - if (pOldFormItem == pFormNode) { - SetObject(XFA_ATTRIBUTE_BindingNode, nullptr); - pOldFormItem = nullptr; - } - return pOldFormItem ? 1 : 0; -} - -FX_BOOL CXFA_Node::HasBindItem() { - return GetPacketID() == XFA_XDPPACKET_Datasets && - GetObject(XFA_ATTRIBUTE_BindingNode); -} - -CXFA_WidgetData* CXFA_Node::GetWidgetData() { - return (CXFA_WidgetData*)GetObject(XFA_ATTRIBUTE_WidgetData); -} - -CXFA_WidgetData* CXFA_Node::GetContainerWidgetData() { - if (GetPacketID() != XFA_XDPPACKET_Form) - return nullptr; - XFA_Element eType = GetElementType(); - if (eType == XFA_Element::ExclGroup) - return nullptr; - CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent); - if (pParentNode && pParentNode->GetElementType() == XFA_Element::ExclGroup) - return nullptr; - - if (eType == XFA_Element::Field) { - CXFA_WidgetData* pFieldWidgetData = GetWidgetData(); - if (pFieldWidgetData && - pFieldWidgetData->GetChoiceListOpen() == - XFA_ATTRIBUTEENUM_MultiSelect) { - return nullptr; - } else { - CFX_WideString wsPicture; - if (pFieldWidgetData) { - pFieldWidgetData->GetPictureContent(wsPicture, - XFA_VALUEPICTURE_DataBind); - } - if (!wsPicture.IsEmpty()) - return pFieldWidgetData; - CXFA_Node* pDataNode = GetBindData(); - if (!pDataNode) - return nullptr; - pFieldWidgetData = nullptr; - CXFA_NodeArray formNodes; - pDataNode->GetBindItems(formNodes); - for (int32_t i = 0; i < formNodes.GetSize(); i++) { - CXFA_Node* pFormNode = formNodes.GetAt(i); - if (!pFormNode || pFormNode->HasRemovedChildren()) - continue; - pFieldWidgetData = pFormNode->GetWidgetData(); - if (pFieldWidgetData) { - pFieldWidgetData->GetPictureContent(wsPicture, - XFA_VALUEPICTURE_DataBind); - } - if (!wsPicture.IsEmpty()) - break; - pFieldWidgetData = nullptr; - } - return pFieldWidgetData; - } - } - CXFA_Node* pGrandNode = - pParentNode ? pParentNode->GetNodeItem(XFA_NODEITEM_Parent) : nullptr; - CXFA_Node* pValueNode = - (pParentNode && pParentNode->GetElementType() == XFA_Element::Value) - ? pParentNode - : nullptr; - if (!pValueNode) { - pValueNode = - (pGrandNode && pGrandNode->GetElementType() == XFA_Element::Value) - ? pGrandNode - : nullptr; - } - CXFA_Node* pParentOfValueNode = - pValueNode ? pValueNode->GetNodeItem(XFA_NODEITEM_Parent) : nullptr; - return pParentOfValueNode ? pParentOfValueNode->GetContainerWidgetData() - : nullptr; -} - -FX_BOOL CXFA_Node::GetLocaleName(CFX_WideString& wsLocaleName) { - CXFA_Node* pForm = GetDocument()->GetXFAObject(XFA_HASHCODE_Form)->AsNode(); - CXFA_Node* pTopSubform = pForm->GetFirstChildByClass(XFA_Element::Subform); - ASSERT(pTopSubform); - CXFA_Node* pLocaleNode = this; - FX_BOOL bLocale = FALSE; - do { - bLocale = pLocaleNode->TryCData(XFA_ATTRIBUTE_Locale, wsLocaleName, FALSE); - if (!bLocale) { - pLocaleNode = pLocaleNode->GetNodeItem(XFA_NODEITEM_Parent); - } - } while (pLocaleNode && pLocaleNode != pTopSubform && !bLocale); - if (bLocale) - return TRUE; - CXFA_Node* pConfig = ToNode(GetDocument()->GetXFAObject(XFA_HASHCODE_Config)); - wsLocaleName = GetDocument()->GetLocalMgr()->GetConfigLocaleName(pConfig); - if (!wsLocaleName.IsEmpty()) - return TRUE; - if (pTopSubform && - pTopSubform->TryCData(XFA_ATTRIBUTE_Locale, wsLocaleName, FALSE)) { - return TRUE; - } - IFX_Locale* pLocale = GetDocument()->GetLocalMgr()->GetDefLocale(); - if (pLocale) { - wsLocaleName = pLocale->GetName(); - return TRUE; - } - return FALSE; -} - -XFA_ATTRIBUTEENUM CXFA_Node::GetIntact() { - CXFA_Node* pKeep = GetFirstChildByClass(XFA_Element::Keep); - XFA_ATTRIBUTEENUM eLayoutType = GetEnum(XFA_ATTRIBUTE_Layout); - if (pKeep) { - XFA_ATTRIBUTEENUM eIntact; - if (pKeep->TryEnum(XFA_ATTRIBUTE_Intact, eIntact, FALSE)) { - if (eIntact == XFA_ATTRIBUTEENUM_None && - eLayoutType == XFA_ATTRIBUTEENUM_Row && - m_pDocument->GetCurVersionMode() < XFA_VERSION_208) { - CXFA_Node* pPreviewRow = GetNodeItem(XFA_NODEITEM_PrevSibling, - XFA_ObjectType::ContainerNode); - if (pPreviewRow && - pPreviewRow->GetEnum(XFA_ATTRIBUTE_Layout) == - XFA_ATTRIBUTEENUM_Row) { - XFA_ATTRIBUTEENUM eValue; - if (pKeep->TryEnum(XFA_ATTRIBUTE_Previous, eValue, FALSE) && - (eValue == XFA_ATTRIBUTEENUM_ContentArea || - eValue == XFA_ATTRIBUTEENUM_PageArea)) { - return XFA_ATTRIBUTEENUM_ContentArea; - } - CXFA_Node* pNode = - pPreviewRow->GetFirstChildByClass(XFA_Element::Keep); - if (pNode && pNode->TryEnum(XFA_ATTRIBUTE_Next, eValue, FALSE) && - (eValue == XFA_ATTRIBUTEENUM_ContentArea || - eValue == XFA_ATTRIBUTEENUM_PageArea)) { - return XFA_ATTRIBUTEENUM_ContentArea; - } - } - } - return eIntact; - } - } - switch (GetElementType()) { - case XFA_Element::Subform: - switch (eLayoutType) { - case XFA_ATTRIBUTEENUM_Position: - case XFA_ATTRIBUTEENUM_Row: - return XFA_ATTRIBUTEENUM_ContentArea; - case XFA_ATTRIBUTEENUM_Tb: - case XFA_ATTRIBUTEENUM_Table: - case XFA_ATTRIBUTEENUM_Lr_tb: - case XFA_ATTRIBUTEENUM_Rl_tb: - return XFA_ATTRIBUTEENUM_None; - default: - break; - } - break; - case XFA_Element::Field: { - CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent); - if (!pParentNode || - pParentNode->GetElementType() == XFA_Element::PageArea) - return XFA_ATTRIBUTEENUM_ContentArea; - if (pParentNode->GetIntact() == XFA_ATTRIBUTEENUM_None) { - XFA_ATTRIBUTEENUM eParLayout = - pParentNode->GetEnum(XFA_ATTRIBUTE_Layout); - if (eParLayout == XFA_ATTRIBUTEENUM_Position || - eParLayout == XFA_ATTRIBUTEENUM_Row || - eParLayout == XFA_ATTRIBUTEENUM_Table) { - return XFA_ATTRIBUTEENUM_None; - } - XFA_VERSION version = m_pDocument->GetCurVersionMode(); - if (eParLayout == XFA_ATTRIBUTEENUM_Tb && version < XFA_VERSION_208) { - CXFA_Measurement measureH; - if (TryMeasure(XFA_ATTRIBUTE_H, measureH, FALSE)) - return XFA_ATTRIBUTEENUM_ContentArea; - } - return XFA_ATTRIBUTEENUM_None; - } - return XFA_ATTRIBUTEENUM_ContentArea; - } - case XFA_Element::Draw: - return XFA_ATTRIBUTEENUM_ContentArea; - default: - break; - } - return XFA_ATTRIBUTEENUM_None; -} - -CXFA_Node* CXFA_Node::GetDataDescriptionNode() { - if (m_ePacket == XFA_XDPPACKET_Datasets) - return m_pAuxNode; - return nullptr; -} - -void CXFA_Node::SetDataDescriptionNode(CXFA_Node* pDataDescriptionNode) { - ASSERT(m_ePacket == XFA_XDPPACKET_Datasets); - m_pAuxNode = pDataDescriptionNode; -} - -void CXFA_Node::Script_TreeClass_ResolveNode(CFXJSE_Arguments* pArguments) { - int32_t iLength = pArguments->GetLength(); - if (iLength != 1) { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"resolveNode"); - return; - } - CFX_WideString wsExpression = - CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC()); - CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext(); - if (!pScriptContext) - return; - CXFA_Node* refNode = this; - if (refNode->GetElementType() == XFA_Element::Xfa) - refNode = ToNode(pScriptContext->GetThisObject()); - uint32_t dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes | - XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent | - XFA_RESOLVENODE_Siblings; - XFA_RESOLVENODE_RS resoveNodeRS; - int32_t iRet = pScriptContext->ResolveObjects( - refNode, wsExpression.AsStringC(), resoveNodeRS, dwFlag); - if (iRet < 1) { - pArguments->GetReturnValue()->SetNull(); - return; - } - if (resoveNodeRS.dwFlags == XFA_RESOVENODE_RSTYPE_Nodes) { - CXFA_Object* pNode = resoveNodeRS.nodes[0]; - pArguments->GetReturnValue()->Assign( - pScriptContext->GetJSValueFromMap(pNode)); - } else { - const XFA_SCRIPTATTRIBUTEINFO* lpAttributeInfo = - resoveNodeRS.pScriptAttribute; - if (lpAttributeInfo && lpAttributeInfo->eValueType == XFA_SCRIPT_Object) { - std::unique_ptr pValue( - new CFXJSE_Value(pScriptContext->GetRuntime())); - (resoveNodeRS.nodes[0]->*(lpAttributeInfo->lpfnCallback))( - pValue.get(), FALSE, (XFA_ATTRIBUTE)lpAttributeInfo->eAttribute); - pArguments->GetReturnValue()->Assign(pValue.get()); - } else { - pArguments->GetReturnValue()->SetNull(); - } - } -} - -void CXFA_Node::Script_TreeClass_ResolveNodes(CFXJSE_Arguments* pArguments) { - int32_t iLength = pArguments->GetLength(); - if (iLength != 1) { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"resolveNodes"); - return; - } - CFX_WideString wsExpression = - CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC()); - CFXJSE_Value* pValue = pArguments->GetReturnValue(); - if (!pValue) - return; - uint32_t dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes | - XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent | - XFA_RESOLVENODE_Siblings; - CXFA_Node* refNode = this; - if (refNode->GetElementType() == XFA_Element::Xfa) - refNode = ToNode(m_pDocument->GetScriptContext()->GetThisObject()); - Script_Som_ResolveNodeList(pValue, wsExpression, dwFlag, refNode); -} - -void CXFA_Node::Script_Som_ResolveNodeList(CFXJSE_Value* pValue, - CFX_WideString wsExpression, - uint32_t dwFlag, - CXFA_Node* refNode) { - CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext(); - if (!pScriptContext) - return; - XFA_RESOLVENODE_RS resoveNodeRS; - if (!refNode) - refNode = this; - pScriptContext->ResolveObjects(refNode, wsExpression.AsStringC(), - resoveNodeRS, dwFlag); - CXFA_ArrayNodeList* pNodeList = new CXFA_ArrayNodeList(m_pDocument); - if (resoveNodeRS.dwFlags == XFA_RESOVENODE_RSTYPE_Nodes) { - for (int32_t i = 0; i < resoveNodeRS.nodes.GetSize(); i++) { - if (resoveNodeRS.nodes[i]->IsNode()) - pNodeList->Append(resoveNodeRS.nodes[i]->AsNode()); - } - } else { - CXFA_ValueArray valueArray(pScriptContext->GetRuntime()); - if (resoveNodeRS.GetAttributeResult(valueArray) > 0) { - CXFA_ObjArray objectArray; - valueArray.GetAttributeObject(objectArray); - for (int32_t i = 0; i < objectArray.GetSize(); i++) { - if (objectArray[i]->IsNode()) - pNodeList->Append(objectArray[i]->AsNode()); - } - } - } - pValue->SetObject(pNodeList, pScriptContext->GetJseNormalClass()); -} - -void CXFA_Node::Script_TreeClass_All(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - ThrowException(XFA_IDS_INVAlID_PROP_SET); - } else { - uint32_t dwFlag = XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_ALL; - CFX_WideString wsName; - GetAttribute(XFA_ATTRIBUTE_Name, wsName); - CFX_WideString wsExpression = wsName + FX_WSTRC(L"[*]"); - Script_Som_ResolveNodeList(pValue, wsExpression, dwFlag); - } -} - -void CXFA_Node::Script_TreeClass_Nodes(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext(); - if (!pScriptContext) - return; - if (bSetting) { - IXFA_AppProvider* pAppProvider = m_pDocument->GetNotify()->GetAppProvider(); - ASSERT(pAppProvider); - CFX_WideString wsMessage; - pAppProvider->LoadString(XFA_IDS_Unable_TO_SET, wsMessage); - FXJSE_ThrowMessage( - FX_UTF8Encode(wsMessage.c_str(), wsMessage.GetLength()).AsStringC()); - } else { - CXFA_AttachNodeList* pNodeList = new CXFA_AttachNodeList(m_pDocument, this); - pValue->SetObject(pNodeList, pScriptContext->GetJseNormalClass()); - } -} - -void CXFA_Node::Script_TreeClass_ClassAll(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - ThrowException(XFA_IDS_INVAlID_PROP_SET); - } else { - uint32_t dwFlag = XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_ALL; - CFX_WideString wsExpression = - FX_WSTRC(L"#") + GetClassName() + FX_WSTRC(L"[*]"); - Script_Som_ResolveNodeList(pValue, wsExpression, dwFlag); - } -} - -void CXFA_Node::Script_TreeClass_Parent(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - ThrowException(XFA_IDS_INVAlID_PROP_SET); - } else { - CXFA_Node* pParent = GetNodeItem(XFA_NODEITEM_Parent); - if (pParent) { - pValue->Assign( - m_pDocument->GetScriptContext()->GetJSValueFromMap(pParent)); - } else { - pValue->SetNull(); - } - } -} - -void CXFA_Node::Script_TreeClass_Index(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) - ThrowException(XFA_IDS_INVAlID_PROP_SET); - else - pValue->SetInteger(GetNodeSameNameIndex()); -} - -void CXFA_Node::Script_TreeClass_ClassIndex(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) - ThrowException(XFA_IDS_INVAlID_PROP_SET); - else - pValue->SetInteger(GetNodeSameClassIndex()); -} - -void CXFA_Node::Script_TreeClass_SomExpression(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - ThrowException(XFA_IDS_INVAlID_PROP_SET); - } else { - CFX_WideString wsSOMExpression; - GetSOMExpression(wsSOMExpression); - pValue->SetString(FX_UTF8Encode(wsSOMExpression).AsStringC()); - } -} - -void CXFA_Node::Script_NodeClass_ApplyXSL(CFXJSE_Arguments* pArguments) { - int32_t iLength = pArguments->GetLength(); - if (iLength != 1) { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"applyXSL"); - return; - } - CFX_WideString wsExpression = - CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC()); - // TODO(weili): check whether we need to implement this, pdfium:501. - // For now, just put the variables here to avoid unused variable warning. - (void)wsExpression; -} - -void CXFA_Node::Script_NodeClass_AssignNode(CFXJSE_Arguments* pArguments) { - int32_t iLength = pArguments->GetLength(); - if (iLength < 1 || iLength > 3) { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"assignNode"); - return; - } - CFX_WideString wsExpression; - CFX_WideString wsValue; - int32_t iAction = 0; - wsExpression = - CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC()); - if (iLength >= 2) { - wsValue = - CFX_WideString::FromUTF8(pArguments->GetUTF8String(1).AsStringC()); - } - if (iLength >= 3) - iAction = pArguments->GetInt32(2); - // TODO(weili): check whether we need to implement this, pdfium:501. - // For now, just put the variables here to avoid unused variable warning. - (void)wsExpression; - (void)wsValue; - (void)iAction; -} - -void CXFA_Node::Script_NodeClass_Clone(CFXJSE_Arguments* pArguments) { - int32_t iLength = pArguments->GetLength(); - if (iLength != 1) { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"clone"); - return; - } - bool bClone = !!pArguments->GetInt32(0); - CXFA_Node* pCloneNode = Clone(bClone); - pArguments->GetReturnValue()->Assign( - m_pDocument->GetScriptContext()->GetJSValueFromMap(pCloneNode)); -} - -void CXFA_Node::Script_NodeClass_GetAttribute(CFXJSE_Arguments* pArguments) { - int32_t iLength = pArguments->GetLength(); - if (iLength != 1) { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getAttribute"); - return; - } - CFX_WideString wsExpression = - CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC()); - CFX_WideString wsValue; - GetAttribute(wsExpression.AsStringC(), wsValue); - CFXJSE_Value* pValue = pArguments->GetReturnValue(); - if (pValue) - pValue->SetString(FX_UTF8Encode(wsValue).AsStringC()); -} - -void CXFA_Node::Script_NodeClass_GetElement(CFXJSE_Arguments* pArguments) { - int32_t iLength = pArguments->GetLength(); - if (iLength < 1 || iLength > 2) { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getElement"); - return; - } - CFX_WideString wsExpression; - int32_t iValue = 0; - wsExpression = - CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC()); - if (iLength >= 2) - iValue = pArguments->GetInt32(1); - CXFA_Node* pNode = - GetProperty(iValue, XFA_GetElementTypeForName(wsExpression.AsStringC())); - pArguments->GetReturnValue()->Assign( - m_pDocument->GetScriptContext()->GetJSValueFromMap(pNode)); -} - -void CXFA_Node::Script_NodeClass_IsPropertySpecified( - CFXJSE_Arguments* pArguments) { - int32_t iLength = pArguments->GetLength(); - if (iLength < 1 || iLength > 3) { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"isPropertySpecified"); - return; - } - CFX_WideString wsExpression; - bool bParent = true; - int32_t iIndex = 0; - wsExpression = - CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC()); - if (iLength >= 2) - bParent = !!pArguments->GetInt32(1); - if (iLength >= 3) - iIndex = pArguments->GetInt32(2); - FX_BOOL bHas = FALSE; - const XFA_ATTRIBUTEINFO* pAttributeInfo = - XFA_GetAttributeByName(wsExpression.AsStringC()); - CFX_WideString wsValue; - if (pAttributeInfo) - bHas = HasAttribute(pAttributeInfo->eName); - if (!bHas) { - XFA_Element eType = XFA_GetElementTypeForName(wsExpression.AsStringC()); - bHas = !!GetProperty(iIndex, eType); - if (!bHas && bParent && m_pParent) { - // Also check on the parent. - bHas = m_pParent->HasAttribute(pAttributeInfo->eName); - if (!bHas) - bHas = !!m_pParent->GetProperty(iIndex, eType); - } - } - CFXJSE_Value* pValue = pArguments->GetReturnValue(); - if (pValue) - pValue->SetBoolean(bHas); -} - -void CXFA_Node::Script_NodeClass_LoadXML(CFXJSE_Arguments* pArguments) { - int32_t iLength = pArguments->GetLength(); - if (iLength < 1 || iLength > 3) { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"loadXML"); - return; - } - CFX_WideString wsExpression; - bool bIgnoreRoot = true; - bool bOverwrite = 0; - wsExpression = - CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC()); - if (wsExpression.IsEmpty()) - return; - if (iLength >= 2) - bIgnoreRoot = !!pArguments->GetInt32(1); - if (iLength >= 3) - bOverwrite = !!pArguments->GetInt32(2); - std::unique_ptr pParser( - new CXFA_SimpleParser(m_pDocument, false)); - if (!pParser) - return; - CFDE_XMLNode* pXMLNode = nullptr; - int32_t iParserStatus = - pParser->ParseXMLData(wsExpression, pXMLNode, nullptr); - if (iParserStatus != XFA_PARSESTATUS_Done || !pXMLNode) - return; - if (bIgnoreRoot && - (pXMLNode->GetType() != FDE_XMLNODE_Element || - XFA_RecognizeRichText(static_cast(pXMLNode)))) { - bIgnoreRoot = false; - } - CXFA_Node* pFakeRoot = Clone(FALSE); - CFX_WideStringC wsContentType = GetCData(XFA_ATTRIBUTE_ContentType); - if (!wsContentType.IsEmpty()) { - pFakeRoot->SetCData(XFA_ATTRIBUTE_ContentType, - CFX_WideString(wsContentType)); - } - CFDE_XMLNode* pFakeXMLRoot = pFakeRoot->GetXMLMappingNode(); - if (!pFakeXMLRoot) { - CFDE_XMLNode* pThisXMLRoot = GetXMLMappingNode(); - pFakeXMLRoot = pThisXMLRoot ? pThisXMLRoot->Clone(FALSE) : nullptr; - } - if (!pFakeXMLRoot) - pFakeXMLRoot = new CFDE_XMLElement(CFX_WideString(GetClassName())); - - if (bIgnoreRoot) { - CFDE_XMLNode* pXMLChild = pXMLNode->GetNodeItem(CFDE_XMLNode::FirstChild); - while (pXMLChild) { - CFDE_XMLNode* pXMLSibling = - pXMLChild->GetNodeItem(CFDE_XMLNode::NextSibling); - pXMLNode->RemoveChildNode(pXMLChild); - pFakeXMLRoot->InsertChildNode(pXMLChild); - pXMLChild = pXMLSibling; - } - } else { - CFDE_XMLNode* pXMLParent = pXMLNode->GetNodeItem(CFDE_XMLNode::Parent); - if (pXMLParent) { - pXMLParent->RemoveChildNode(pXMLNode); - } - pFakeXMLRoot->InsertChildNode(pXMLNode); - } - pParser->ConstructXFANode(pFakeRoot, pFakeXMLRoot); - pFakeRoot = pParser->GetRootNode(); - if (pFakeRoot) { - if (bOverwrite) { - CXFA_Node* pChild = 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); - InsertChild(index++, pNewChild); - pNewChild->SetFlag(XFA_NodeFlag_Initialized, true); - pNewChild = pItem; - } - while (pChild) { - CXFA_Node* pItem = pChild->GetNodeItem(XFA_NODEITEM_NextSibling); - RemoveChild(pChild); - pFakeRoot->InsertChild(pChild); - pChild = pItem; - } - if (GetPacketID() == XFA_XDPPACKET_Form && - GetElementType() == XFA_Element::ExData) { - CFDE_XMLNode* pTempXMLNode = GetXMLMappingNode(); - SetXMLMappingNode(pFakeXMLRoot); - SetFlag(XFA_NodeFlag_OwnXMLNode, false); - if (pTempXMLNode && !pTempXMLNode->GetNodeItem(CFDE_XMLNode::Parent)) { - pFakeXMLRoot = pTempXMLNode; - } else { - pFakeXMLRoot = nullptr; - } - } - MoveBufferMapData(pFakeRoot, this, XFA_CalcData, TRUE); - } else { - CXFA_Node* pChild = pFakeRoot->GetNodeItem(XFA_NODEITEM_FirstChild); - while (pChild) { - CXFA_Node* pItem = pChild->GetNodeItem(XFA_NODEITEM_NextSibling); - pFakeRoot->RemoveChild(pChild); - InsertChild(pChild); - pChild->SetFlag(XFA_NodeFlag_Initialized, true); - pChild = pItem; - } - } - if (pFakeXMLRoot) { - pFakeRoot->SetXMLMappingNode(pFakeXMLRoot); - pFakeRoot->SetFlag(XFA_NodeFlag_OwnXMLNode, false); - } - pFakeRoot->SetFlag(XFA_NodeFlag_HasRemovedChildren, false); - } else { - if (pFakeXMLRoot) { - pFakeXMLRoot->Release(); - pFakeXMLRoot = nullptr; - } - } -} - -void CXFA_Node::Script_NodeClass_SaveFilteredXML(CFXJSE_Arguments* pArguments) { - // TODO(weili): Check whether we need to implement this, pdfium:501. -} - -void CXFA_Node::Script_NodeClass_SaveXML(CFXJSE_Arguments* pArguments) { - int32_t iLength = pArguments->GetLength(); - if (iLength < 0 || iLength > 1) { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"saveXML"); - return; - } - bool bPrettyMode = false; - if (iLength == 1) { - if (pArguments->GetUTF8String(0) != "pretty") { - ThrowException(XFA_IDS_ARGUMENT_MISMATCH); - return; - } - bPrettyMode = true; - } - CFX_ByteStringC bsXMLHeader = "\n"; - if (GetPacketID() == XFA_XDPPACKET_Form || - GetPacketID() == XFA_XDPPACKET_Datasets) { - CFDE_XMLNode* pElement = nullptr; - if (GetPacketID() == XFA_XDPPACKET_Datasets) { - pElement = GetXMLMappingNode(); - if (!pElement || pElement->GetType() != FDE_XMLNODE_Element) { - pArguments->GetReturnValue()->SetString(bsXMLHeader); - return; - } - XFA_DataExporter_DealWithDataGroupNode(this); - } - std::unique_ptr> - pMemoryStream(FX_CreateMemoryStream(TRUE)); - std::unique_ptr> pStream( - IFX_Stream::CreateStream( - static_cast(pMemoryStream.get()), - FX_STREAMACCESS_Text | FX_STREAMACCESS_Write | - FX_STREAMACCESS_Append)); - if (!pStream) { - pArguments->GetReturnValue()->SetString(bsXMLHeader); - return; - } - pStream->SetCodePage(FX_CODEPAGE_UTF8); - pStream->WriteData(bsXMLHeader.raw_str(), bsXMLHeader.GetLength()); - if (GetPacketID() == XFA_XDPPACKET_Form) - XFA_DataExporter_RegenerateFormFile(this, pStream.get(), nullptr, TRUE); - else - pElement->SaveXMLNode(pStream.get()); - // TODO(weili): Check whether we need to save pretty print XML, pdfium:501. - // For now, just put it here to avoid unused variable warning. - (void)bPrettyMode; - pArguments->GetReturnValue()->SetString( - CFX_ByteStringC(pMemoryStream->GetBuffer(), pMemoryStream->GetSize())); - return; - } - pArguments->GetReturnValue()->SetString(""); -} - -void CXFA_Node::Script_NodeClass_SetAttribute(CFXJSE_Arguments* pArguments) { - int32_t iLength = pArguments->GetLength(); - if (iLength != 2) { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"setAttribute"); - return; - } - CFX_WideString wsAttributeValue = - CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC()); - CFX_WideString wsAttribute = - CFX_WideString::FromUTF8(pArguments->GetUTF8String(1).AsStringC()); - SetAttribute(wsAttribute.AsStringC(), wsAttributeValue.AsStringC(), true); -} - -void CXFA_Node::Script_NodeClass_SetElement(CFXJSE_Arguments* pArguments) { - int32_t iLength = pArguments->GetLength(); - if (iLength != 1 && iLength != 2) { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"setElement"); - return; - } - CXFA_Node* pNode = nullptr; - CFX_WideString wsName; - pNode = static_cast(pArguments->GetObject(0)); - if (iLength == 2) - wsName = CFX_WideString::FromUTF8(pArguments->GetUTF8String(1).AsStringC()); - // TODO(weili): check whether we need to implement this, pdfium:501. - // For now, just put the variables here to avoid unused variable warning. - (void)pNode; - (void)wsName; -} - -void CXFA_Node::Script_NodeClass_Ns(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - ThrowException(XFA_IDS_INVAlID_PROP_SET); - } else { - CFX_WideString wsNameSpace; - TryNamespace(wsNameSpace); - pValue->SetString(FX_UTF8Encode(wsNameSpace).AsStringC()); - } -} - -void CXFA_Node::Script_NodeClass_Model(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - ThrowException(XFA_IDS_INVAlID_PROP_SET); - } else { - pValue->Assign( - m_pDocument->GetScriptContext()->GetJSValueFromMap(GetModelNode())); - } -} - -void CXFA_Node::Script_NodeClass_IsContainer(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) - ThrowException(XFA_IDS_INVAlID_PROP_SET); - else - pValue->SetBoolean(IsContainerNode()); -} - -void CXFA_Node::Script_NodeClass_IsNull(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - ThrowException(XFA_IDS_INVAlID_PROP_SET); - } else { - if (GetElementType() == XFA_Element::Subform) { - pValue->SetBoolean(FALSE); - return; - } - CFX_WideString strValue; - pValue->SetBoolean(!TryContent(strValue) || strValue.IsEmpty()); - } -} - -void CXFA_Node::Script_NodeClass_OneOfChild(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - ThrowException(XFA_IDS_INVAlID_PROP_SET); - } else { - CXFA_NodeArray properts; - int32_t iSize = GetNodeList(properts, XFA_NODEFILTER_OneOfProperty); - if (iSize > 0) { - pValue->Assign( - m_pDocument->GetScriptContext()->GetJSValueFromMap(properts[0])); - } - } -} - -void CXFA_Node::Script_ContainerClass_GetDelta(CFXJSE_Arguments* pArguments) {} - -void CXFA_Node::Script_ContainerClass_GetDeltas(CFXJSE_Arguments* pArguments) { - CXFA_ArrayNodeList* pFormNodes = new CXFA_ArrayNodeList(m_pDocument); - pArguments->GetReturnValue()->SetObject( - pFormNodes, m_pDocument->GetScriptContext()->GetJseNormalClass()); -} -void CXFA_Node::Script_ModelClass_ClearErrorList(CFXJSE_Arguments* pArguments) { -} -void CXFA_Node::Script_ModelClass_CreateNode(CFXJSE_Arguments* pArguments) { - Script_Template_CreateNode(pArguments); -} -void CXFA_Node::Script_ModelClass_IsCompatibleNS(CFXJSE_Arguments* pArguments) { - int32_t iLength = pArguments->GetLength(); - if (iLength < 1) { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"isCompatibleNS"); - return; - } - CFX_WideString wsNameSpace; - if (iLength >= 1) { - CFX_ByteString bsNameSpace = pArguments->GetUTF8String(0); - wsNameSpace = CFX_WideString::FromUTF8(bsNameSpace.AsStringC()); - } - CFX_WideString wsNodeNameSpace; - TryNamespace(wsNodeNameSpace); - CFXJSE_Value* pValue = pArguments->GetReturnValue(); - if (pValue) - pValue->SetBoolean(wsNodeNameSpace == wsNameSpace); -} -void CXFA_Node::Script_ModelClass_Context(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) {} -void CXFA_Node::Script_ModelClass_AliasNode(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) {} -void CXFA_Node::Script_Attribute_Integer(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - SetInteger(eAttribute, pValue->ToInteger(), true); - } else { - pValue->SetInteger(GetInteger(eAttribute)); - } -} -void CXFA_Node::Script_Attribute_IntegerRead(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (!bSetting) { - pValue->SetInteger(GetInteger(eAttribute)); - } else { - ThrowException(XFA_IDS_INVAlID_PROP_SET); - } -} -void CXFA_Node::Script_Attribute_BOOL(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - SetBoolean(eAttribute, pValue->ToBoolean(), true); - } else { - pValue->SetString(GetBoolean(eAttribute) ? "1" : "0"); - } -} -void CXFA_Node::Script_Attribute_BOOLRead(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (!bSetting) { - pValue->SetString(GetBoolean(eAttribute) ? "1" : "0"); - } else { - ThrowException(XFA_IDS_INVAlID_PROP_SET); - } -} - -void CXFA_Node::Script_Attribute_SendAttributeChangeMessage( - XFA_ATTRIBUTE eAttribute, - FX_BOOL bScriptModify) { - CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor(); - if (!pLayoutPro) - return; - - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (!pNotify) - return; - - uint32_t dwPacket = GetPacketID(); - if (!(dwPacket & XFA_XDPPACKET_Form)) { - pNotify->OnValueChanged(this, eAttribute, this, this); - return; - } - - bool bNeedFindContainer = false; - switch (GetElementType()) { - case XFA_Element::Caption: - bNeedFindContainer = true; - pNotify->OnValueChanged(this, eAttribute, this, - GetNodeItem(XFA_NODEITEM_Parent)); - break; - case XFA_Element::Font: - case XFA_Element::Para: { - bNeedFindContainer = true; - CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent); - if (pParentNode->GetElementType() == XFA_Element::Caption) { - pNotify->OnValueChanged(this, eAttribute, pParentNode, - pParentNode->GetNodeItem(XFA_NODEITEM_Parent)); - } else { - pNotify->OnValueChanged(this, eAttribute, this, pParentNode); - } - } break; - case XFA_Element::Margin: { - bNeedFindContainer = true; - CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent); - XFA_Element eParentType = pParentNode->GetElementType(); - if (pParentNode->IsContainerNode()) { - pNotify->OnValueChanged(this, eAttribute, this, pParentNode); - } else if (eParentType == XFA_Element::Caption) { - pNotify->OnValueChanged(this, eAttribute, pParentNode, - pParentNode->GetNodeItem(XFA_NODEITEM_Parent)); - } else { - CXFA_Node* pNode = pParentNode->GetNodeItem(XFA_NODEITEM_Parent); - if (pNode && pNode->GetElementType() == XFA_Element::Ui) { - pNotify->OnValueChanged(this, eAttribute, pNode, - pNode->GetNodeItem(XFA_NODEITEM_Parent)); - } - } - } break; - case XFA_Element::Comb: { - CXFA_Node* pEditNode = GetNodeItem(XFA_NODEITEM_Parent); - XFA_Element eUIType = pEditNode->GetElementType(); - if (pEditNode && (eUIType == XFA_Element::DateTimeEdit || - eUIType == XFA_Element::NumericEdit || - eUIType == XFA_Element::TextEdit)) { - CXFA_Node* pUINode = pEditNode->GetNodeItem(XFA_NODEITEM_Parent); - if (pUINode) { - pNotify->OnValueChanged(this, eAttribute, pUINode, - pUINode->GetNodeItem(XFA_NODEITEM_Parent)); - } - } - } break; - case XFA_Element::Button: - case XFA_Element::Barcode: - case XFA_Element::ChoiceList: - case XFA_Element::DateTimeEdit: - case XFA_Element::NumericEdit: - case XFA_Element::PasswordEdit: - case XFA_Element::TextEdit: { - CXFA_Node* pUINode = GetNodeItem(XFA_NODEITEM_Parent); - if (pUINode) { - pNotify->OnValueChanged(this, eAttribute, pUINode, - pUINode->GetNodeItem(XFA_NODEITEM_Parent)); - } - } break; - case XFA_Element::CheckButton: { - bNeedFindContainer = true; - CXFA_Node* pUINode = GetNodeItem(XFA_NODEITEM_Parent); - if (pUINode) { - pNotify->OnValueChanged(this, eAttribute, pUINode, - pUINode->GetNodeItem(XFA_NODEITEM_Parent)); - } - } break; - case XFA_Element::Keep: - case XFA_Element::Bookend: - case XFA_Element::Break: - case XFA_Element::BreakAfter: - case XFA_Element::BreakBefore: - case XFA_Element::Overflow: - bNeedFindContainer = true; - break; - case XFA_Element::Area: - case XFA_Element::Draw: - case XFA_Element::ExclGroup: - case XFA_Element::Field: - case XFA_Element::Subform: - case XFA_Element::SubformSet: - pLayoutPro->AddChangedContainer(this); - pNotify->OnValueChanged(this, eAttribute, this, this); - break; - case XFA_Element::Sharptext: - case XFA_Element::Sharpxml: - case XFA_Element::SharpxHTML: { - CXFA_Node* pTextNode = GetNodeItem(XFA_NODEITEM_Parent); - if (!pTextNode) { - return; - } - CXFA_Node* pValueNode = pTextNode->GetNodeItem(XFA_NODEITEM_Parent); - if (!pValueNode) { - return; - } - XFA_Element eType = pValueNode->GetElementType(); - if (eType == XFA_Element::Value) { - bNeedFindContainer = true; - CXFA_Node* pNode = pValueNode->GetNodeItem(XFA_NODEITEM_Parent); - if (pNode && pNode->IsContainerNode()) { - if (bScriptModify) { - pValueNode = pNode; - } - pNotify->OnValueChanged(this, eAttribute, pValueNode, pNode); - } else { - pNotify->OnValueChanged(this, eAttribute, pNode, - pNode->GetNodeItem(XFA_NODEITEM_Parent)); - } - } else { - if (eType == XFA_Element::Items) { - CXFA_Node* pNode = pValueNode->GetNodeItem(XFA_NODEITEM_Parent); - if (pNode && pNode->IsContainerNode()) { - pNotify->OnValueChanged(this, eAttribute, pValueNode, pNode); - } - } - } - } break; - default: - break; - } - if (bNeedFindContainer) { - CXFA_Node* pParent = this; - while (pParent) { - if (pParent->IsContainerNode()) - break; - - pParent = pParent->GetNodeItem(XFA_NODEITEM_Parent); - } - if (pParent) { - pLayoutPro->AddChangedContainer(pParent); - } - } -} - -void CXFA_Node::Script_Attribute_String(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - CFX_WideString wsValue = pValue->ToWideString(); - SetAttribute(eAttribute, wsValue.AsStringC(), true); - if (eAttribute == XFA_ATTRIBUTE_Use && - GetElementType() == XFA_Element::Desc) { - CXFA_Node* pTemplateNode = - ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Template)); - CXFA_Node* pProtoRoot = - pTemplateNode->GetFirstChildByClass(XFA_Element::Subform) - ->GetFirstChildByClass(XFA_Element::Proto); - - CFX_WideString wsID; - CFX_WideString wsSOM; - if (!wsValue.IsEmpty()) { - if (wsValue[0] == '#') { - wsID = CFX_WideString(wsValue.c_str() + 1, wsValue.GetLength() - 1); - } else { - wsSOM = wsValue; - } - } - CXFA_Node* pProtoNode = nullptr; - if (!wsSOM.IsEmpty()) { - uint32_t dwFlag = XFA_RESOLVENODE_Children | - XFA_RESOLVENODE_Attributes | - XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent | - XFA_RESOLVENODE_Siblings; - XFA_RESOLVENODE_RS resoveNodeRS; - int32_t iRet = m_pDocument->GetScriptContext()->ResolveObjects( - pProtoRoot, wsSOM.AsStringC(), resoveNodeRS, dwFlag); - if (iRet > 0 && resoveNodeRS.nodes[0]->IsNode()) { - pProtoNode = resoveNodeRS.nodes[0]->AsNode(); - } - } else if (!wsID.IsEmpty()) { - pProtoNode = m_pDocument->GetNodeByID(pProtoRoot, wsID.AsStringC()); - } - if (pProtoNode) { - CXFA_Node* pHeadChild = GetNodeItem(XFA_NODEITEM_FirstChild); - while (pHeadChild) { - CXFA_Node* pSibling = - pHeadChild->GetNodeItem(XFA_NODEITEM_NextSibling); - RemoveChild(pHeadChild); - pHeadChild = pSibling; - } - 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); - InsertChild(pHeadChild); - pHeadChild = pSibling; - } - m_pDocument->RemovePurgeNode(pProtoForm); - delete pProtoForm; - } - } - } else { - CFX_WideString wsValue; - GetAttribute(eAttribute, wsValue); - pValue->SetString( - FX_UTF8Encode(wsValue.c_str(), wsValue.GetLength()).AsStringC()); - } -} -void CXFA_Node::Script_Attribute_StringRead(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (!bSetting) { - CFX_WideString wsValue; - GetAttribute(eAttribute, wsValue); - pValue->SetString( - FX_UTF8Encode(wsValue.c_str(), wsValue.GetLength()).AsStringC()); - } else { - ThrowException(XFA_IDS_INVAlID_PROP_SET); - } -} -void CXFA_Node::Script_WsdlConnection_Execute(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if ((argc == 0) || (argc == 1)) { - pArguments->GetReturnValue()->SetBoolean(FALSE); - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execute"); - } -} -void CXFA_Node::Script_Delta_Restore(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"restore"); - } -} -void CXFA_Node::Script_Delta_CurrentValue(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) {} -void CXFA_Node::Script_Delta_SavedValue(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) {} -void CXFA_Node::Script_Delta_Target(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) {} -void CXFA_Node::Script_Som_Message(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_SOM_MESSAGETYPE iMessageType) { - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - return; - } - FX_BOOL bNew = FALSE; - CXFA_Validate validate = pWidgetData->GetValidate(); - if (!validate) { - validate = pWidgetData->GetValidate(TRUE); - bNew = TRUE; - } - if (bSetting) { - switch (iMessageType) { - case XFA_SOM_ValidationMessage: - validate.SetScriptMessageText(pValue->ToWideString()); - break; - case XFA_SOM_FormatMessage: - validate.SetFormatMessageText(pValue->ToWideString()); - break; - case XFA_SOM_MandatoryMessage: - validate.SetNullMessageText(pValue->ToWideString()); - break; - default: - break; - } - if (!bNew) { - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (!pNotify) { - return; - } - pNotify->AddCalcValidate(this); - } - } else { - CFX_WideString wsMessage; - switch (iMessageType) { - case XFA_SOM_ValidationMessage: - validate.GetScriptMessageText(wsMessage); - break; - case XFA_SOM_FormatMessage: - validate.GetFormatMessageText(wsMessage); - break; - case XFA_SOM_MandatoryMessage: - validate.GetNullMessageText(wsMessage); - break; - default: - break; - } - pValue->SetString(FX_UTF8Encode(wsMessage).AsStringC()); - } -} -void CXFA_Node::Script_Som_ValidationMessage(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - Script_Som_Message(pValue, bSetting, XFA_SOM_ValidationMessage); -} -void CXFA_Node::Script_Field_Length(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - ThrowException(XFA_IDS_INVAlID_PROP_SET); - } else { - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - pValue->SetInteger(0); - return; - } - pValue->SetInteger(pWidgetData->CountChoiceListItems(TRUE)); - } -} -void CXFA_Node::Script_Som_DefaultValue(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - XFA_Element eType = GetElementType(); - if (eType == XFA_Element::Field) { - Script_Field_DefaultValue(pValue, bSetting, eAttribute); - return; - } - if (eType == XFA_Element::Draw) { - Script_Draw_DefaultValue(pValue, bSetting, eAttribute); - return; - } - if (eType == XFA_Element::Boolean) { - Script_Boolean_Value(pValue, bSetting, eAttribute); - return; - } - if (bSetting) { - CFX_WideString wsNewValue; - if (!(pValue && (pValue->IsNull() || pValue->IsUndefined()))) - wsNewValue = pValue->ToWideString(); - - CFX_WideString wsFormatValue(wsNewValue); - CXFA_WidgetData* pContainerWidgetData = nullptr; - if (GetPacketID() == XFA_XDPPACKET_Datasets) { - CXFA_NodeArray formNodes; - GetBindItems(formNodes); - CFX_WideString wsPicture; - for (int32_t i = 0; i < formNodes.GetSize(); i++) { - CXFA_Node* pFormNode = formNodes.GetAt(i); - if (!pFormNode || pFormNode->HasRemovedChildren()) { - continue; - } - pContainerWidgetData = pFormNode->GetContainerWidgetData(); - if (pContainerWidgetData) { - pContainerWidgetData->GetPictureContent(wsPicture, - XFA_VALUEPICTURE_DataBind); - } - if (!wsPicture.IsEmpty()) { - break; - } - pContainerWidgetData = nullptr; - } - } else if (GetPacketID() == XFA_XDPPACKET_Form) { - pContainerWidgetData = GetContainerWidgetData(); - } - if (pContainerWidgetData) { - pContainerWidgetData->GetFormatDataValue(wsNewValue, wsFormatValue); - } - SetScriptContent(wsNewValue, wsFormatValue, true, TRUE); - } else { - CFX_WideString content = GetScriptContent(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.AsStringC()); - pValue->SetFloat((FX_FLOAT)(double)decimal); - } else { - pValue->SetString( - FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC()); - } - } -} -void CXFA_Node::Script_Som_DefaultValue_Read(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - ThrowException(XFA_IDS_INVAlID_PROP_SET); - return; - } - CFX_WideString content = GetScriptContent(TRUE); - if (content.IsEmpty()) { - pValue->SetNull(); - } else { - pValue->SetString( - FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC()); - } -} -void CXFA_Node::Script_Boolean_Value(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - CFX_ByteString newValue; - if (!(pValue && (pValue->IsNull() || pValue->IsUndefined()))) - newValue = pValue->ToString(); - - int32_t iValue = FXSYS_atoi(newValue.c_str()); - CFX_WideString wsNewValue(iValue == 0 ? L"0" : L"1"); - CFX_WideString wsFormatValue(wsNewValue); - CXFA_WidgetData* pContainerWidgetData = GetContainerWidgetData(); - if (pContainerWidgetData) { - pContainerWidgetData->GetFormatDataValue(wsNewValue, wsFormatValue); - } - SetScriptContent(wsNewValue, wsFormatValue, true, TRUE); - } else { - CFX_WideString wsValue = GetScriptContent(TRUE); - pValue->SetBoolean(wsValue == FX_WSTRC(L"1")); - } -} -struct XFA_ExecEventParaInfo { - public: - uint32_t m_uHash; - const FX_WCHAR* m_lpcEventName; - XFA_EVENTTYPE m_eventType; - uint32_t m_validFlags; -}; -static const XFA_ExecEventParaInfo gs_eventParaInfos[] = { - {0x02a6c55a, L"postSubmit", XFA_EVENT_PostSubmit, 0}, - {0x0ab466bb, L"preSubmit", XFA_EVENT_PreSubmit, 0}, - {0x109d7ce7, L"mouseEnter", XFA_EVENT_MouseEnter, 5}, - {0x17fad373, L"postPrint", XFA_EVENT_PostPrint, 0}, - {0x1bfc72d9, L"preOpen", XFA_EVENT_PreOpen, 7}, - {0x2196a452, L"initialize", XFA_EVENT_Initialize, 1}, - {0x27410f03, L"mouseExit", XFA_EVENT_MouseExit, 5}, - {0x33c43dec, L"docClose", XFA_EVENT_DocClose, 0}, - {0x361fa1b6, L"preSave", XFA_EVENT_PreSave, 0}, - {0x36f1c6d8, L"preSign", XFA_EVENT_PreSign, 6}, - {0x4731d6ba, L"exit", XFA_EVENT_Exit, 2}, - {0x56bf456b, L"docReady", XFA_EVENT_DocReady, 0}, - {0x7233018a, L"validate", XFA_EVENT_Validate, 1}, - {0x8808385e, L"indexChange", XFA_EVENT_IndexChange, 3}, - {0x891f4606, L"change", XFA_EVENT_Change, 4}, - {0x9528a7b4, L"prePrint", XFA_EVENT_PrePrint, 0}, - {0x9f693b21, L"mouseDown", XFA_EVENT_MouseDown, 5}, - {0xcdce56b3, L"full", XFA_EVENT_Full, 4}, - {0xd576d08e, L"mouseUp", XFA_EVENT_MouseUp, 5}, - {0xd95657a6, L"click", XFA_EVENT_Click, 4}, - {0xdbfbe02e, L"calculate", XFA_EVENT_Calculate, 1}, - {0xe25fa7b8, L"postOpen", XFA_EVENT_PostOpen, 7}, - {0xe28dce7e, L"enter", XFA_EVENT_Enter, 2}, - {0xfc82d695, L"postSave", XFA_EVENT_PostSave, 0}, - {0xfd54fbb7, L"postSign", XFA_EVENT_PostSign, 6}, -}; -const XFA_ExecEventParaInfo* GetEventParaInfoByName( - const CFX_WideStringC& 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; -} -void XFA_STRING_TO_RGB(const CFX_WideString& strRGB, - int32_t& r, - int32_t& g, - int32_t& b) { - r = 0; - g = 0; - b = 0; - - FX_WCHAR zero = '0'; - int32_t iIndex = 0; - int32_t iLen = strRGB.GetLength(); - for (int32_t i = 0; i < iLen; ++i) { - FX_WCHAR ch = strRGB.GetAt(i); - if (ch == L',') { - ++iIndex; - } - if (iIndex > 2) { - break; - } - int32_t iValue = ch - zero; - 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; - } - } - } -} -void CXFA_Node::Script_Som_BorderColor(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - return; - } - CXFA_Border border = pWidgetData->GetBorder(TRUE); - int32_t iSize = border.CountEdges(); - if (bSetting) { - int32_t r = 0; - int32_t g = 0; - int32_t b = 0; - XFA_STRING_TO_RGB(pValue->ToWideString(), r, g, b); - FX_ARGB rgb = ArgbEncode(100, r, g, b); - for (int32_t i = 0; i < iSize; ++i) { - CXFA_Edge edge = border.GetEdge(i); - edge.SetColor(rgb); - } - } else { - CXFA_Edge edge = border.GetEdge(0); - FX_ARGB color = edge.GetColor(); - int32_t a, r, g, b; - ArgbDecode(color, a, r, g, b); - CFX_WideString strColor; - strColor.Format(L"%d,%d,%d", r, g, b); - pValue->SetString(FX_UTF8Encode(strColor).AsStringC()); - } -} -void CXFA_Node::Script_Som_BorderWidth(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - return; - } - CXFA_Border border = pWidgetData->GetBorder(TRUE); - int32_t iSize = border.CountEdges(); - CFX_WideString wsThickness; - if (bSetting) { - wsThickness = pValue->ToWideString(); - for (int32_t i = 0; i < iSize; ++i) { - CXFA_Edge edge = border.GetEdge(i); - CXFA_Measurement thickness(wsThickness.AsStringC()); - edge.SetMSThickness(thickness); - } - } else { - CXFA_Edge edge = border.GetEdge(0); - CXFA_Measurement thickness = edge.GetMSThickness(); - thickness.ToString(wsThickness); - pValue->SetString(FX_UTF8Encode(wsThickness).AsStringC()); - } -} -void CXFA_Node::Script_Som_FillColor(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - return; - } - CXFA_Border border = pWidgetData->GetBorder(TRUE); - CXFA_Fill borderfill = border.GetFill(TRUE); - CXFA_Node* pNode = borderfill.GetNode(); - if (!pNode) { - return; - } - if (bSetting) { - int32_t r; - int32_t g; - int32_t b; - XFA_STRING_TO_RGB(pValue->ToWideString(), r, g, b); - FX_ARGB color = ArgbEncode(0xff, r, g, b); - borderfill.SetColor(color); - } else { - FX_ARGB color = borderfill.GetColor(); - int32_t a; - int32_t r; - int32_t g; - int32_t b; - ArgbDecode(color, a, r, g, b); - CFX_WideString wsColor; - wsColor.Format(L"%d,%d,%d", r, g, b); - pValue->SetString(FX_UTF8Encode(wsColor).AsStringC()); - } -} -void CXFA_Node::Script_Som_DataNode(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (!bSetting) { - CXFA_Node* pDataNode = GetBindData(); - if (pDataNode) { - pValue->Assign( - m_pDocument->GetScriptContext()->GetJSValueFromMap(pDataNode)); - } else { - pValue->SetNull(); - } - } else { - ThrowException(XFA_IDS_INVAlID_PROP_SET); - } -} -void CXFA_Node::Script_Draw_DefaultValue(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - if (pValue && pValue->IsString()) { - CXFA_WidgetData* pWidgetData = GetWidgetData(); - ASSERT(pWidgetData); - XFA_Element uiType = pWidgetData->GetUIType(); - if (uiType == XFA_Element::Text) { - CFX_WideString wsNewValue = pValue->ToWideString(); - CFX_WideString wsFormatValue(wsNewValue); - SetScriptContent(wsNewValue, wsFormatValue, true, TRUE); - } - } - } else { - CFX_WideString content = GetScriptContent(TRUE); - if (content.IsEmpty()) { - pValue->SetNull(); - } else { - pValue->SetString( - FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC()); - } - } -} -void CXFA_Node::Script_Field_DefaultValue(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - return; - } - if (bSetting) { - if (pValue && pValue->IsNull()) { - pWidgetData->m_bPreNull = pWidgetData->m_bIsNull; - pWidgetData->m_bIsNull = TRUE; - } else { - pWidgetData->m_bPreNull = pWidgetData->m_bIsNull; - pWidgetData->m_bIsNull = FALSE; - } - CFX_WideString wsNewText; - if (!(pValue && (pValue->IsNull() || pValue->IsUndefined()))) - wsNewText = pValue->ToWideString(); - - CXFA_Node* pUIChild = pWidgetData->GetUIChild(); - if (pUIChild->GetElementType() == XFA_Element::NumericEdit) { - int32_t iLeadDigits = 0; - int32_t iFracDigits = 0; - pWidgetData->GetLeadDigits(iLeadDigits); - pWidgetData->GetFracDigits(iFracDigits); - wsNewText = - pWidgetData->NumericLimit(wsNewText, iLeadDigits, iFracDigits); - } - CXFA_WidgetData* pContainerWidgetData = GetContainerWidgetData(); - CFX_WideString wsFormatText(wsNewText); - if (pContainerWidgetData) { - pContainerWidgetData->GetFormatDataValue(wsNewText, wsFormatText); - } - SetScriptContent(wsNewText, wsFormatText, true, TRUE); - } else { - CFX_WideString content = GetScriptContent(TRUE); - if (content.IsEmpty()) { - pValue->SetNull(); - } else { - CXFA_Node* pUIChild = pWidgetData->GetUIChild(); - CXFA_Value defVal = pWidgetData->GetFormValue(); - CXFA_Node* pNode = defVal.GetNode()->GetNodeItem(XFA_NODEITEM_FirstChild); - if (pNode && pNode->GetElementType() == XFA_Element::Decimal) { - if (pUIChild->GetElementType() == XFA_Element::NumericEdit && - (pNode->GetInteger(XFA_ATTRIBUTE_FracDigits) == -1)) { - pValue->SetString( - FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC()); - } else { - CFX_Decimal decimal(content.AsStringC()); - pValue->SetFloat((FX_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.AsStringC()); - pValue->SetFloat((FX_FLOAT)(double)decimal); - } else { - pValue->SetString( - FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC()); - } - } - } -} -void CXFA_Node::Script_Field_EditValue(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - return; - } - if (bSetting) { - pWidgetData->SetValue(pValue->ToWideString(), XFA_VALUEPICTURE_Edit); - } else { - CFX_WideString wsValue; - pWidgetData->GetValue(wsValue, XFA_VALUEPICTURE_Edit); - pValue->SetString(FX_UTF8Encode(wsValue).AsStringC()); - } -} -void CXFA_Node::Script_Som_FontColor(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - return; - } - CXFA_Font font = pWidgetData->GetFont(TRUE); - CXFA_Node* pNode = font.GetNode(); - if (!pNode) { - return; - } - if (bSetting) { - int32_t r; - int32_t g; - int32_t b; - XFA_STRING_TO_RGB(pValue->ToWideString(), r, g, b); - FX_ARGB color = ArgbEncode(0xff, r, g, b); - font.SetColor(color); - } else { - FX_ARGB color = font.GetColor(); - int32_t a; - int32_t r; - int32_t g; - int32_t b; - ArgbDecode(color, a, r, g, b); - CFX_WideString wsColor; - wsColor.Format(L"%d,%d,%d", r, g, b); - pValue->SetString(FX_UTF8Encode(wsColor).AsStringC()); - } -} -void CXFA_Node::Script_Field_FormatMessage(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - Script_Som_Message(pValue, bSetting, XFA_SOM_FormatMessage); -} -void CXFA_Node::Script_Field_FormattedValue(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - return; - } - if (bSetting) { - pWidgetData->SetValue(pValue->ToWideString(), XFA_VALUEPICTURE_Display); - } else { - CFX_WideString wsValue; - pWidgetData->GetValue(wsValue, XFA_VALUEPICTURE_Display); - pValue->SetString(FX_UTF8Encode(wsValue).AsStringC()); - } -} -void CXFA_Node::Script_Som_Mandatory(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - return; - } - CXFA_Validate validate = pWidgetData->GetValidate(TRUE); - if (bSetting) { - validate.SetNullTest(pValue->ToWideString()); - } else { - int32_t iValue = validate.GetNullTest(); - const XFA_ATTRIBUTEENUMINFO* pInfo = - XFA_GetAttributeEnumByID((XFA_ATTRIBUTEENUM)iValue); - CFX_WideString wsValue; - if (pInfo) - wsValue = pInfo->pName; - pValue->SetString(FX_UTF8Encode(wsValue).AsStringC()); - } -} -void CXFA_Node::Script_Som_MandatoryMessage(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - Script_Som_Message(pValue, bSetting, XFA_SOM_MandatoryMessage); -} -void CXFA_Node::Script_Field_ParentSubform(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - ThrowException(XFA_IDS_INVAlID_PROP_SET); - } else { - pValue->SetNull(); - } -} -void CXFA_Node::Script_Field_SelectedIndex(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - return; - } - if (bSetting) { - int32_t iIndex = pValue->ToInteger(); - if (iIndex == -1) { - pWidgetData->ClearAllSelections(); - return; - } - pWidgetData->SetItemState(iIndex, TRUE, true, TRUE, TRUE); - } else { - pValue->SetInteger(pWidgetData->GetSelectedItem()); - } -} -void CXFA_Node::Script_Field_ClearItems(CFXJSE_Arguments* pArguments) { - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - return; - } - pWidgetData->DeleteItem(-1, TRUE); -} -void CXFA_Node::Script_Field_ExecEvent(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 1) { - CFX_ByteString eventString = pArguments->GetUTF8String(0); - int32_t iRet = execSingleEventByName( - CFX_WideString::FromUTF8(eventString.AsStringC()).AsStringC(), - XFA_Element::Field); - if (eventString == "validate") { - pArguments->GetReturnValue()->SetBoolean( - (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE); - } - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent"); - } -} -void CXFA_Node::Script_Field_ExecInitialize(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (!pNotify) { - return; - } - pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize, FALSE, FALSE); - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execInitialize"); - } -} -void CXFA_Node::Script_Field_DeleteItem(CFXJSE_Arguments* pArguments) { - int32_t iLength = pArguments->GetLength(); - if (iLength != 1) { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"deleteItem"); - return; - } - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - return; - } - int32_t iIndex = pArguments->GetInt32(0); - FX_BOOL bValue = pWidgetData->DeleteItem(iIndex, TRUE, TRUE); - CFXJSE_Value* pValue = pArguments->GetReturnValue(); - if (pValue) - pValue->SetBoolean(bValue); -} -void CXFA_Node::Script_Field_GetSaveItem(CFXJSE_Arguments* pArguments) { - int32_t iLength = pArguments->GetLength(); - if (iLength != 1) { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getSaveItem"); - return; - } - int32_t iIndex = pArguments->GetInt32(0); - if (iIndex < 0) { - pArguments->GetReturnValue()->SetNull(); - return; - } - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - pArguments->GetReturnValue()->SetNull(); - return; - } - CFX_WideString wsValue; - FX_BOOL bHasItem = pWidgetData->GetChoiceListItem(wsValue, iIndex, TRUE); - if (bHasItem) { - pArguments->GetReturnValue()->SetString( - FX_UTF8Encode(wsValue.c_str(), wsValue.GetLength()).AsStringC()); - } else { - pArguments->GetReturnValue()->SetNull(); - } -} -void CXFA_Node::Script_Field_BoundItem(CFXJSE_Arguments* pArguments) { - int32_t iLength = pArguments->GetLength(); - if (iLength != 1) { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"boundItem"); - return; - } - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - return; - } - CFX_ByteString bsValue = pArguments->GetUTF8String(0); - CFX_WideString wsValue = CFX_WideString::FromUTF8(bsValue.AsStringC()); - CFX_WideString wsBoundValue; - pWidgetData->GetItemValue(wsValue.AsStringC(), wsBoundValue); - CFXJSE_Value* pValue = pArguments->GetReturnValue(); - if (pValue) - pValue->SetString(FX_UTF8Encode(wsBoundValue).AsStringC()); -} -void CXFA_Node::Script_Field_GetItemState(CFXJSE_Arguments* pArguments) { - int32_t iLength = pArguments->GetLength(); - if (iLength != 1) { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getItemState"); - return; - } - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - return; - } - int32_t iIndex = pArguments->GetInt32(0); - FX_BOOL bValue = pWidgetData->GetItemState(iIndex); - CFXJSE_Value* pValue = pArguments->GetReturnValue(); - if (pValue) - pValue->SetBoolean(bValue); -} -void CXFA_Node::Script_Field_ExecCalculate(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (!pNotify) { - return; - } - pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate, FALSE, FALSE); - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate"); - } -} -void CXFA_Node::Script_Field_SetItems(CFXJSE_Arguments* pArguments) {} -void CXFA_Node::Script_Field_GetDisplayItem(CFXJSE_Arguments* pArguments) { - int32_t iLength = pArguments->GetLength(); - if (iLength != 1) { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getDisplayItem"); - return; - } - int32_t iIndex = pArguments->GetInt32(0); - if (iIndex < 0) { - pArguments->GetReturnValue()->SetNull(); - return; - } - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - pArguments->GetReturnValue()->SetNull(); - return; - } - CFX_WideString wsValue; - FX_BOOL bHasItem = pWidgetData->GetChoiceListItem(wsValue, iIndex, FALSE); - if (bHasItem) { - pArguments->GetReturnValue()->SetString( - FX_UTF8Encode(wsValue.c_str(), wsValue.GetLength()).AsStringC()); - } else { - pArguments->GetReturnValue()->SetNull(); - } -} -void CXFA_Node::Script_Field_SetItemState(CFXJSE_Arguments* pArguments) { - int32_t iLength = pArguments->GetLength(); - if (iLength != 2) { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"setItemState"); - return; - } - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) - return; - - int32_t iIndex = pArguments->GetInt32(0); - if (pArguments->GetInt32(1) != 0) { - pWidgetData->SetItemState(iIndex, TRUE, true, TRUE, TRUE); - } else { - if (pWidgetData->GetItemState(iIndex)) - pWidgetData->SetItemState(iIndex, FALSE, true, TRUE, TRUE); - } -} -void CXFA_Node::Script_Field_AddItem(CFXJSE_Arguments* pArguments) { - int32_t iLength = pArguments->GetLength(); - if (iLength < 1 || iLength > 2) { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"addItem"); - return; - } - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - return; - } - CFX_WideString wsLabel; - CFX_WideString wsValue; - if (iLength >= 1) { - CFX_ByteString bsLabel = pArguments->GetUTF8String(0); - wsLabel = CFX_WideString::FromUTF8(bsLabel.AsStringC()); - } - if (iLength >= 2) { - CFX_ByteString bsValue = pArguments->GetUTF8String(1); - wsValue = CFX_WideString::FromUTF8(bsValue.AsStringC()); - } - pWidgetData->InsertItem(wsLabel, wsValue, -1, TRUE); -} -void CXFA_Node::Script_Field_ExecValidate(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (!pNotify) { - pArguments->GetReturnValue()->SetBoolean(FALSE); - } else { - int32_t iRet = - pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate, FALSE, FALSE); - pArguments->GetReturnValue()->SetBoolean( - (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE); - } - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate"); - } -} -void CXFA_Node::Script_ExclGroup_ErrorText(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (!bSetting) { - } else { - ThrowException(XFA_IDS_INVAlID_PROP_SET); - } -} -void CXFA_Node::Script_ExclGroup_DefaultAndRawValue(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - return; - } - if (bSetting) { - pWidgetData->SetSelectedMemberByValue(pValue->ToWideString().AsStringC(), - true, TRUE, TRUE); - } else { - CFX_WideString wsValue = GetScriptContent(TRUE); - XFA_VERSION curVersion = GetDocument()->GetCurVersionMode(); - if (wsValue.IsEmpty() && curVersion >= XFA_VERSION_300) { - pValue->SetNull(); - } else { - pValue->SetString(FX_UTF8Encode(wsValue).AsStringC()); - } - } -} -void CXFA_Node::Script_ExclGroup_Transient(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) {} -void CXFA_Node::Script_ExclGroup_ExecEvent(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 1) { - CFX_ByteString eventString = pArguments->GetUTF8String(0); - execSingleEventByName( - CFX_WideString::FromUTF8(eventString.AsStringC()).AsStringC(), - XFA_Element::ExclGroup); - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent"); - } -} - -void CXFA_Node::Script_ExclGroup_SelectedMember(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc < 0 || argc > 1) { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"selectedMember"); - return; - } - - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - pArguments->GetReturnValue()->SetNull(); - return; - } - - CXFA_Node* pReturnNode = nullptr; - if (argc == 0) { - pReturnNode = pWidgetData->GetSelectedMember(); - } else { - CFX_ByteString szName; - szName = pArguments->GetUTF8String(0); - pReturnNode = pWidgetData->SetSelectedMember( - CFX_WideString::FromUTF8(szName.AsStringC()).AsStringC(), true); - } - if (!pReturnNode) { - pArguments->GetReturnValue()->SetNull(); - return; - } - pArguments->GetReturnValue()->Assign( - m_pDocument->GetScriptContext()->GetJSValueFromMap(pReturnNode)); -} - -void CXFA_Node::Script_ExclGroup_ExecInitialize(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (!pNotify) { - return; - } - pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize); - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execInitialize"); - } -} -void CXFA_Node::Script_ExclGroup_ExecCalculate(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (!pNotify) { - return; - } - pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate); - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate"); - } -} -void CXFA_Node::Script_ExclGroup_ExecValidate(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (!pNotify) { - pArguments->GetReturnValue()->SetBoolean(FALSE); - } else { - int32_t iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate); - pArguments->GetReturnValue()->SetBoolean( - (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE); - } - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate"); - } -} -static CXFA_Node* XFA_ScriptInstanceManager_GetItem(CXFA_Node* pInstMgrNode, - int32_t iIndex) { - ASSERT(pInstMgrNode); - int32_t iCount = 0; - uint32_t dwNameHash = 0; - for (CXFA_Node* pNode = pInstMgrNode->GetNodeItem(XFA_NODEITEM_NextSibling); - pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { - XFA_Element eCurType = pNode->GetElementType(); - if (eCurType == XFA_Element::InstanceManager) { - break; - } - if ((eCurType != XFA_Element::Subform) && - (eCurType != XFA_Element::SubformSet)) { - continue; - } - if (iCount == 0) { - CFX_WideStringC wsName = pNode->GetCData(XFA_ATTRIBUTE_Name); - CFX_WideStringC wsInstName = pInstMgrNode->GetCData(XFA_ATTRIBUTE_Name); - if (wsInstName.GetLength() < 1 || wsInstName.GetAt(0) != '_' || - wsInstName.Mid(1) != wsName) { - return nullptr; - } - dwNameHash = pNode->GetNameHash(); - } - if (dwNameHash != pNode->GetNameHash()) { - break; - } - iCount++; - if (iCount > iIndex) { - return pNode; - } - } - return nullptr; -} -void CXFA_Node::Script_Som_InstanceIndex(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - int32_t iTo = pValue->ToInteger(); - int32_t iFrom = Subform_and_SubformSet_InstanceIndex(); - CXFA_Node* pManagerNode = nullptr; - for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode; - pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) { - if (pNode->GetElementType() == XFA_Element::InstanceManager) { - pManagerNode = pNode; - break; - } - } - if (pManagerNode) { - pManagerNode->InstanceManager_MoveInstance(iTo, iFrom); - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (!pNotify) { - return; - } - CXFA_Node* pToInstance = - XFA_ScriptInstanceManager_GetItem(pManagerNode, iTo); - if (pToInstance && - pToInstance->GetElementType() == XFA_Element::Subform) { - pNotify->RunSubformIndexChange(pToInstance); - } - CXFA_Node* pFromInstance = - XFA_ScriptInstanceManager_GetItem(pManagerNode, iFrom); - if (pFromInstance && - pFromInstance->GetElementType() == XFA_Element::Subform) { - pNotify->RunSubformIndexChange(pFromInstance); - } - } - } else { - pValue->SetInteger(Subform_and_SubformSet_InstanceIndex()); - } -} -void CXFA_Node::Script_Subform_InstanceManager(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (!bSetting) { - CFX_WideStringC wsName = GetCData(XFA_ATTRIBUTE_Name); - CXFA_Node* pInstanceMgr = nullptr; - for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode; - pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) { - if (pNode->GetElementType() == XFA_Element::InstanceManager) { - CFX_WideStringC wsInstMgrName = pNode->GetCData(XFA_ATTRIBUTE_Name); - if (wsInstMgrName.GetLength() >= 1 && wsInstMgrName.GetAt(0) == '_' && - wsInstMgrName.Mid(1) == wsName) { - pInstanceMgr = pNode; - } - break; - } - } - if (pInstanceMgr) { - pValue->Assign( - m_pDocument->GetScriptContext()->GetJSValueFromMap(pInstanceMgr)); - } else { - pValue->SetNull(); - } - } else { - ThrowException(XFA_IDS_INVAlID_PROP_SET); - } -} -void CXFA_Node::Script_Subform_Locale(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - SetCData(XFA_ATTRIBUTE_Locale, pValue->ToWideString(), true, TRUE); - } else { - CFX_WideString wsLocaleName; - GetLocaleName(wsLocaleName); - pValue->SetString( - FX_UTF8Encode(wsLocaleName.c_str(), wsLocaleName.GetLength()) - .AsStringC()); - } -} -void CXFA_Node::Script_Subform_ExecEvent(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 1) { - CFX_ByteString eventString = pArguments->GetUTF8String(0); - execSingleEventByName( - CFX_WideString::FromUTF8(eventString.AsStringC()).AsStringC(), - XFA_Element::Subform); - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent"); - } -} -void CXFA_Node::Script_Subform_ExecInitialize(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (!pNotify) { - return; - } - pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize); - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execInitialize"); - } -} -void CXFA_Node::Script_Subform_ExecCalculate(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (!pNotify) { - return; - } - pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate); - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate"); - } -} -void CXFA_Node::Script_Subform_ExecValidate(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (!pNotify) { - pArguments->GetReturnValue()->SetBoolean(FALSE); - } else { - int32_t iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate); - pArguments->GetReturnValue()->SetBoolean( - (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE); - } - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate"); - } -} -void CXFA_Node::Script_Subform_GetInvalidObjects(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getInvalidObjects"); - } -} -int32_t CXFA_Node::Subform_and_SubformSet_InstanceIndex() { - int32_t index = 0; - for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode; - pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) { - if ((pNode->GetElementType() == XFA_Element::Subform) || - (pNode->GetElementType() == XFA_Element::SubformSet)) { - index++; - } else { - break; - } - } - return index; -} -void CXFA_Node::Script_Template_FormNodes(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 1) { - pArguments->GetReturnValue()->SetBoolean(TRUE); - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"formNodes"); - } -} -void CXFA_Node::Script_Template_Remerge(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - m_pDocument->DoDataRemerge(TRUE); - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"remerge"); - } -} -void CXFA_Node::Script_Template_ExecInitialize(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - pArguments->GetReturnValue()->SetBoolean(FALSE); - } else { - pArguments->GetReturnValue()->SetBoolean(TRUE); - } - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execInitialize"); - } -} -void CXFA_Node::Script_Template_CreateNode(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if ((argc > 0) && (argc < 4)) { - CFX_WideString strTagName; - CFX_WideString strName; - CFX_WideString strNameSpace; - CFX_ByteString bsTagName = pArguments->GetUTF8String(0); - strTagName = CFX_WideString::FromUTF8(bsTagName.AsStringC()); - if (argc > 1) { - CFX_ByteString bsName = pArguments->GetUTF8String(1); - strName = CFX_WideString::FromUTF8(bsName.AsStringC()); - if (argc == 3) { - CFX_ByteString bsNameSpace = pArguments->GetUTF8String(2); - strNameSpace = CFX_WideString::FromUTF8(bsNameSpace.AsStringC()); - } - } - XFA_Element eType = XFA_GetElementTypeForName(strTagName.AsStringC()); - CXFA_Node* pNewNode = CreateSamePacketNode(eType); - if (!pNewNode) { - pArguments->GetReturnValue()->SetNull(); - } else { - if (!strName.IsEmpty()) { - if (XFA_GetAttributeOfElement(eType, XFA_ATTRIBUTE_Name, - XFA_XDPPACKET_UNKNOWN)) { - pNewNode->SetAttribute(XFA_ATTRIBUTE_Name, strName.AsStringC(), true); - if (pNewNode->GetPacketID() == XFA_XDPPACKET_Datasets) { - pNewNode->CreateXMLMappingNode(); - } - pArguments->GetReturnValue()->Assign( - m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewNode)); - } else { - ThrowException(XFA_IDS_NOT_HAVE_PROPERTY, strTagName.c_str(), - L"name"); - } - } else { - pArguments->GetReturnValue()->Assign( - m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewNode)); - } - } - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"createNode"); - } -} -void CXFA_Node::Script_Template_Recalculate(CFXJSE_Arguments* pArguments) { - if (pArguments->GetLength() == 1) { - pArguments->GetReturnValue()->SetBoolean(TRUE); - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"recalculate"); - } -} -void CXFA_Node::Script_Template_ExecCalculate(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - pArguments->GetReturnValue()->SetBoolean(FALSE); - } else { - pArguments->GetReturnValue()->SetBoolean(TRUE); - } - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate"); - } -} -void CXFA_Node::Script_Template_ExecValidate(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - pArguments->GetReturnValue()->SetBoolean(FALSE); - } else { - pArguments->GetReturnValue()->SetBoolean(TRUE); - } - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate"); - } -} -void CXFA_Node::Script_Manifest_Evaluate(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (!pWidgetData) { - pArguments->GetReturnValue()->SetBoolean(FALSE); - } else { - pArguments->GetReturnValue()->SetBoolean(TRUE); - } - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"evaluate"); - } -} -void CXFA_Node::Script_InstanceManager_Max(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - ThrowException(XFA_IDS_INVAlID_PROP_SET); - return; - } - CXFA_Occur nodeOccur(GetOccurNode()); - pValue->SetInteger(nodeOccur.GetMax()); -} -void CXFA_Node::Script_InstanceManager_Min(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - ThrowException(XFA_IDS_INVAlID_PROP_SET); - return; - } - CXFA_Occur nodeOccur(GetOccurNode()); - pValue->SetInteger(nodeOccur.GetMin()); -} -static int32_t XFA_ScriptInstanceManager_GetCount(CXFA_Node* pInstMgrNode) { - ASSERT(pInstMgrNode); - int32_t iCount = 0; - uint32_t dwNameHash = 0; - for (CXFA_Node* pNode = pInstMgrNode->GetNodeItem(XFA_NODEITEM_NextSibling); - pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { - XFA_Element eCurType = pNode->GetElementType(); - if (eCurType == XFA_Element::InstanceManager) { - break; - } - if ((eCurType != XFA_Element::Subform) && - (eCurType != XFA_Element::SubformSet)) { - continue; - } - if (iCount == 0) { - CFX_WideStringC wsName = pNode->GetCData(XFA_ATTRIBUTE_Name); - CFX_WideStringC wsInstName = pInstMgrNode->GetCData(XFA_ATTRIBUTE_Name); - if (wsInstName.GetLength() < 1 || wsInstName.GetAt(0) != '_' || - wsInstName.Mid(1) != wsName) { - return iCount; - } - dwNameHash = pNode->GetNameHash(); - } - if (dwNameHash != pNode->GetNameHash()) { - break; - } - iCount++; - } - return iCount; -} -static void -XFA_ScriptInstanceManager_ReorderDataNodes_SortNodeArrayByDocumentIdx( - const CXFA_NodeSet& rgNodeSet, - CXFA_NodeArray& rgNodeArray, - CFX_ArrayTemplate& rgIdxArray) { - int32_t iCount = pdfium::CollectionSize(rgNodeSet); - rgNodeArray.SetSize(iCount); - rgIdxArray.SetSize(iCount); - if (iCount == 0) - return; - - int32_t iIndex = -1; - int32_t iTotalIndex = -1; - CXFA_Node* pCommonParent = - (*rgNodeSet.begin())->GetNodeItem(XFA_NODEITEM_Parent); - for (CXFA_Node* pNode = pCommonParent->GetNodeItem(XFA_NODEITEM_FirstChild); - pNode && iIndex < iCount; - pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { - iTotalIndex++; - if (pdfium::ContainsValue(rgNodeSet, pNode)) { - iIndex++; - rgNodeArray[iIndex] = pNode; - rgIdxArray[iIndex] = iTotalIndex; - } - } -} - -using CXFA_NodeSetPair = std::pair; -using CXFA_NodeSetPairMap = - std::map>; -using CXFA_NodeSetPairMapMap = - std::map>; - -static CXFA_NodeSetPair* NodeSetPairForNode(CXFA_Node* pNode, - CXFA_NodeSetPairMapMap* pMap) { - CXFA_Node* pParentNode = pNode->GetNodeItem(XFA_NODEITEM_Parent); - uint32_t dwNameHash = pNode->GetNameHash(); - if (!pParentNode || !dwNameHash) - return nullptr; - - if (!(*pMap)[pParentNode]) - (*pMap)[pParentNode].reset(new CXFA_NodeSetPairMap); - - CXFA_NodeSetPairMap* pNodeSetPairMap = (*pMap)[pParentNode].get(); - if (!(*pNodeSetPairMap)[dwNameHash]) - (*pNodeSetPairMap)[dwNameHash].reset(new CXFA_NodeSetPair); - - return (*pNodeSetPairMap)[dwNameHash].get(); -} - -static void XFA_ScriptInstanceManager_ReorderDataNodes( - const CXFA_NodeSet& sSet1, - const CXFA_NodeSet& sSet2, - FX_BOOL bInsertBefore) { - CXFA_NodeSetPairMapMap rgMap; - for (CXFA_Node* pNode : sSet1) { - CXFA_NodeSetPair* pNodeSetPair = NodeSetPairForNode(pNode, &rgMap); - if (pNodeSetPair) - pNodeSetPair->first.insert(pNode); - } - for (CXFA_Node* pNode : sSet2) { - CXFA_NodeSetPair* pNodeSetPair = NodeSetPairForNode(pNode, &rgMap); - if (pNodeSetPair) { - if (pdfium::ContainsValue(pNodeSetPair->first, pNode)) - pNodeSetPair->first.erase(pNode); - else - pNodeSetPair->second.insert(pNode); - } - } - for (const auto& iter1 : rgMap) { - CXFA_NodeSetPairMap* pNodeSetPairMap = iter1.second.get(); - if (!pNodeSetPairMap) { - continue; - } - for (const auto& iter2 : *pNodeSetPairMap) { - CXFA_NodeSetPair* pNodeSetPair = iter2.second.get(); - if (!pNodeSetPair) { - continue; - } - if (!pNodeSetPair->first.empty() && !pNodeSetPair->second.empty()) { - CXFA_NodeArray rgNodeArray1; - CXFA_NodeArray rgNodeArray2; - CFX_ArrayTemplate rgIdxArray1; - CFX_ArrayTemplate rgIdxArray2; - XFA_ScriptInstanceManager_ReorderDataNodes_SortNodeArrayByDocumentIdx( - pNodeSetPair->first, rgNodeArray1, rgIdxArray1); - XFA_ScriptInstanceManager_ReorderDataNodes_SortNodeArrayByDocumentIdx( - pNodeSetPair->second, rgNodeArray2, rgIdxArray2); - CXFA_Node* pParentNode = nullptr; - CXFA_Node* pBeforeNode = nullptr; - if (bInsertBefore) { - pBeforeNode = rgNodeArray2[0]; - pParentNode = pBeforeNode->GetNodeItem(XFA_NODEITEM_Parent); - } else { - CXFA_Node* pLastNode = rgNodeArray2[rgIdxArray2.GetSize() - 1]; - pParentNode = pLastNode->GetNodeItem(XFA_NODEITEM_Parent); - pBeforeNode = pLastNode->GetNodeItem(XFA_NODEITEM_NextSibling); - } - for (int32_t iIdx = 0; iIdx < rgIdxArray1.GetSize(); iIdx++) { - CXFA_Node* pCurNode = rgNodeArray1[iIdx]; - pParentNode->RemoveChild(pCurNode); - pParentNode->InsertChild(pCurNode, pBeforeNode); - } - } - } - pNodeSetPairMap->clear(); - } -} - -static void XFA_ScriptInstanceManager_InsertItem( - CXFA_Node* pInstMgrNode, - CXFA_Node* pNewInstance, - int32_t iPos, - int32_t iCount = -1, - FX_BOOL bMoveDataBindingNodes = TRUE) { - if (iCount < 0) { - iCount = XFA_ScriptInstanceManager_GetCount(pInstMgrNode); - } - if (iPos < 0) { - iPos = iCount; - } - if (iPos == iCount) { - CXFA_Node* pNextSibling = - iCount > 0 - ? XFA_ScriptInstanceManager_GetItem(pInstMgrNode, iCount - 1) - ->GetNodeItem(XFA_NODEITEM_NextSibling) - : pInstMgrNode->GetNodeItem(XFA_NODEITEM_NextSibling); - pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent) - ->InsertChild(pNewInstance, pNextSibling); - if (bMoveDataBindingNodes) { - CXFA_NodeSet sNew; - CXFA_NodeSet sAfter; - CXFA_NodeIteratorTemplate - sIteratorNew(pNewInstance); - for (CXFA_Node* pNode = sIteratorNew.GetCurrent(); pNode; - pNode = sIteratorNew.MoveToNext()) { - CXFA_Node* pDataNode = pNode->GetBindData(); - if (!pDataNode) { - continue; - } - sNew.insert(pDataNode); - } - CXFA_NodeIteratorTemplate - sIteratorAfter(pNextSibling); - for (CXFA_Node* pNode = sIteratorAfter.GetCurrent(); pNode; - pNode = sIteratorAfter.MoveToNext()) { - CXFA_Node* pDataNode = pNode->GetBindData(); - if (!pDataNode) { - continue; - } - sAfter.insert(pDataNode); - } - XFA_ScriptInstanceManager_ReorderDataNodes(sNew, sAfter, FALSE); - } - } else { - CXFA_Node* pBeforeInstance = - XFA_ScriptInstanceManager_GetItem(pInstMgrNode, iPos); - pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent) - ->InsertChild(pNewInstance, pBeforeInstance); - if (bMoveDataBindingNodes) { - CXFA_NodeSet sNew; - CXFA_NodeSet sBefore; - CXFA_NodeIteratorTemplate - sIteratorNew(pNewInstance); - for (CXFA_Node* pNode = sIteratorNew.GetCurrent(); pNode; - pNode = sIteratorNew.MoveToNext()) { - CXFA_Node* pDataNode = pNode->GetBindData(); - if (!pDataNode) { - continue; - } - sNew.insert(pDataNode); - } - CXFA_NodeIteratorTemplate - sIteratorBefore(pBeforeInstance); - for (CXFA_Node* pNode = sIteratorBefore.GetCurrent(); pNode; - pNode = sIteratorBefore.MoveToNext()) { - CXFA_Node* pDataNode = pNode->GetBindData(); - if (!pDataNode) { - continue; - } - sBefore.insert(pDataNode); - } - XFA_ScriptInstanceManager_ReorderDataNodes(sNew, sBefore, TRUE); - } - } -} -static void XFA_ScriptInstanceManager_RemoveItem( - CXFA_Node* pInstMgrNode, - CXFA_Node* pRemoveInstance, - FX_BOOL bRemoveDataBinding = TRUE) { - pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent)->RemoveChild(pRemoveInstance); - if (!bRemoveDataBinding) { - return; - } - CXFA_NodeIteratorTemplate - sIterator(pRemoveInstance); - for (CXFA_Node* pFormNode = sIterator.GetCurrent(); pFormNode; - pFormNode = sIterator.MoveToNext()) { - CXFA_Node* pDataNode = pFormNode->GetBindData(); - if (!pDataNode) { - continue; - } - if (pDataNode->RemoveBindItem(pFormNode) == 0) { - if (CXFA_Node* pDataParent = - pDataNode->GetNodeItem(XFA_NODEITEM_Parent)) { - pDataParent->RemoveChild(pDataNode); - } - } - pFormNode->SetObject(XFA_ATTRIBUTE_BindingNode, nullptr); - } -} -static CXFA_Node* XFA_ScriptInstanceManager_CreateInstance( - CXFA_Node* pInstMgrNode, - FX_BOOL bDataMerge) { - CXFA_Document* pDocument = pInstMgrNode->GetDocument(); - CXFA_Node* pTemplateNode = pInstMgrNode->GetTemplateNode(); - CXFA_Node* pFormParent = pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent); - CXFA_Node* pDataScope = nullptr; - for (CXFA_Node* pRootBoundNode = pFormParent; - pRootBoundNode && pRootBoundNode->IsContainerNode(); - pRootBoundNode = pRootBoundNode->GetNodeItem(XFA_NODEITEM_Parent)) { - pDataScope = pRootBoundNode->GetBindData(); - if (pDataScope) { - break; - } - } - if (!pDataScope) { - pDataScope = ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Record)); - ASSERT(pDataScope); - } - CXFA_Node* pInstance = pDocument->DataMerge_CopyContainer( - pTemplateNode, pFormParent, pDataScope, TRUE, bDataMerge, TRUE); - if (pInstance) { - pDocument->DataMerge_UpdateBindingRelations(pInstance); - pFormParent->RemoveChild(pInstance); - } - return pInstance; -} -void CXFA_Node::Script_InstanceManager_Count(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - int32_t iDesired = pValue->ToInteger(); - InstanceManager_SetInstances(iDesired); - } else { - pValue->SetInteger(XFA_ScriptInstanceManager_GetCount(this)); - } -} -void CXFA_Node::Script_InstanceManager_MoveInstance( - CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc != 2) { - pArguments->GetReturnValue()->SetUndefined(); - return; - } - int32_t iFrom = pArguments->GetInt32(0); - int32_t iTo = pArguments->GetInt32(1); - InstanceManager_MoveInstance(iTo, iFrom); - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (!pNotify) { - return; - } - CXFA_Node* pToInstance = XFA_ScriptInstanceManager_GetItem(this, iTo); - if (pToInstance && pToInstance->GetElementType() == XFA_Element::Subform) { - pNotify->RunSubformIndexChange(pToInstance); - } - CXFA_Node* pFromInstance = XFA_ScriptInstanceManager_GetItem(this, iFrom); - if (pFromInstance && - pFromInstance->GetElementType() == XFA_Element::Subform) { - pNotify->RunSubformIndexChange(pFromInstance); - } -} -void CXFA_Node::Script_InstanceManager_RemoveInstance( - CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc != 1) { - pArguments->GetReturnValue()->SetUndefined(); - return; - } - int32_t iIndex = pArguments->GetInt32(0); - int32_t iCount = XFA_ScriptInstanceManager_GetCount(this); - if (iIndex < 0 || iIndex >= iCount) { - ThrowException(XFA_IDS_INDEX_OUT_OF_BOUNDS); - return; - } - CXFA_Occur nodeOccur(GetOccurNode()); - int32_t iMin = nodeOccur.GetMin(); - if (iCount - 1 < iMin) { - ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"min"); - return; - } - CXFA_Node* pRemoveInstance = XFA_ScriptInstanceManager_GetItem(this, iIndex); - XFA_ScriptInstanceManager_RemoveItem(this, pRemoveInstance); - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (pNotify) { - for (int32_t i = iIndex; i < iCount - 1; i++) { - CXFA_Node* pSubformInstance = XFA_ScriptInstanceManager_GetItem(this, i); - if (pSubformInstance && - pSubformInstance->GetElementType() == XFA_Element::Subform) { - pNotify->RunSubformIndexChange(pSubformInstance); - } - } - } - CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor(); - if (!pLayoutPro) { - return; - } - pLayoutPro->AddChangedContainer( - ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form))); -} -void CXFA_Node::Script_InstanceManager_SetInstances( - CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc != 1) { - pArguments->GetReturnValue()->SetUndefined(); - return; - } - int32_t iDesired = pArguments->GetInt32(0); - InstanceManager_SetInstances(iDesired); -} -void CXFA_Node::Script_InstanceManager_AddInstance( - CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if ((argc != 0) && (argc != 1)) { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"addInstance"); - return; - } - FX_BOOL fFlags = TRUE; - if (argc == 1) { - fFlags = pArguments->GetInt32(0) == 0 ? FALSE : TRUE; - } - int32_t iCount = XFA_ScriptInstanceManager_GetCount(this); - CXFA_Occur nodeOccur(GetOccurNode()); - int32_t iMax = nodeOccur.GetMax(); - if (iMax >= 0 && iCount >= iMax) { - ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"max"); - return; - } - CXFA_Node* pNewInstance = - XFA_ScriptInstanceManager_CreateInstance(this, fFlags); - XFA_ScriptInstanceManager_InsertItem(this, pNewInstance, iCount, iCount, - FALSE); - pArguments->GetReturnValue()->Assign( - m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewInstance)); - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (!pNotify) { - return; - } - pNotify->RunNodeInitialize(pNewInstance); - CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor(); - if (!pLayoutPro) { - return; - } - pLayoutPro->AddChangedContainer( - ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form))); -} -void CXFA_Node::Script_InstanceManager_InsertInstance( - CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if ((argc != 1) && (argc != 2)) { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"insertInstance"); - return; - } - int32_t iIndex = pArguments->GetInt32(0); - FX_BOOL bBind = FALSE; - if (argc == 2) { - bBind = pArguments->GetInt32(1) == 0 ? FALSE : TRUE; - } - CXFA_Occur nodeOccur(GetOccurNode()); - int32_t iCount = XFA_ScriptInstanceManager_GetCount(this); - if (iIndex < 0 || iIndex > iCount) { - ThrowException(XFA_IDS_INDEX_OUT_OF_BOUNDS); - return; - } - int32_t iMax = nodeOccur.GetMax(); - if (iMax >= 0 && iCount >= iMax) { - ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"max"); - return; - } - CXFA_Node* pNewInstance = - XFA_ScriptInstanceManager_CreateInstance(this, bBind); - XFA_ScriptInstanceManager_InsertItem(this, pNewInstance, iIndex, iCount, - TRUE); - pArguments->GetReturnValue()->Assign( - m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewInstance)); - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (!pNotify) { - return; - } - pNotify->RunNodeInitialize(pNewInstance); - CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor(); - if (!pLayoutPro) { - return; - } - pLayoutPro->AddChangedContainer( - ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form))); -} -int32_t CXFA_Node::InstanceManager_SetInstances(int32_t iDesired) { - CXFA_Occur nodeOccur(GetOccurNode()); - int32_t iMax = nodeOccur.GetMax(); - int32_t iMin = nodeOccur.GetMin(); - if (iDesired < iMin) { - ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"min"); - return 1; - } - if ((iMax >= 0) && (iDesired > iMax)) { - ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"max"); - return 2; - } - int32_t iCount = XFA_ScriptInstanceManager_GetCount(this); - if (iDesired == iCount) { - return 0; - } - if (iDesired < iCount) { - CFX_WideStringC wsInstManagerName = GetCData(XFA_ATTRIBUTE_Name); - CFX_WideString wsInstanceName = - CFX_WideString(wsInstManagerName.IsEmpty() ? wsInstManagerName - : wsInstManagerName.Mid(1)); - uint32_t dInstanceNameHash = - FX_HashCode_GetW(wsInstanceName.AsStringC(), false); - CXFA_Node* pPrevSibling = - (iDesired == 0) ? this - : XFA_ScriptInstanceManager_GetItem(this, 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) { - ASSERT(FALSE); - break; - } - if (pRemoveInstance->GetNameHash() == dInstanceNameHash) { - XFA_ScriptInstanceManager_RemoveItem(this, pRemoveInstance); - iCount--; - } - } - } else if (iDesired > iCount) { - while (iCount < iDesired) { - CXFA_Node* pNewInstance = - XFA_ScriptInstanceManager_CreateInstance(this, TRUE); - XFA_ScriptInstanceManager_InsertItem(this, pNewInstance, iCount, iCount, - FALSE); - iCount++; - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (!pNotify) { - return 0; - } - pNotify->RunNodeInitialize(pNewInstance); - } - } - CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor(); - if (pLayoutPro) { - pLayoutPro->AddChangedContainer( - ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form))); - } - return 0; -} -int32_t CXFA_Node::InstanceManager_MoveInstance(int32_t iTo, int32_t iFrom) { - int32_t iCount = XFA_ScriptInstanceManager_GetCount(this); - if (iFrom > iCount || iTo > iCount - 1) { - ThrowException(XFA_IDS_INDEX_OUT_OF_BOUNDS); - return 1; - } - if (iFrom < 0 || iTo < 0 || iFrom == iTo) { - return 0; - } - CXFA_Node* pMoveInstance = XFA_ScriptInstanceManager_GetItem(this, iFrom); - XFA_ScriptInstanceManager_RemoveItem(this, pMoveInstance, FALSE); - XFA_ScriptInstanceManager_InsertItem(this, pMoveInstance, iTo, iCount - 1, - TRUE); - CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor(); - if (pLayoutPro) { - pLayoutPro->AddChangedContainer( - ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form))); - } - return 0; -} -void CXFA_Node::Script_Occur_Max(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - CXFA_Occur occur(this); - if (bSetting) { - int32_t iMax = pValue->ToInteger(); - occur.SetMax(iMax); - } else { - pValue->SetInteger(occur.GetMax()); - } -} -void CXFA_Node::Script_Occur_Min(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - CXFA_Occur occur(this); - if (bSetting) { - int32_t iMin = pValue->ToInteger(); - occur.SetMin(iMin); - } else { - pValue->SetInteger(occur.GetMin()); - } -} -void CXFA_Node::Script_Desc_Metadata(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if ((argc == 0) || (argc == 1)) { - pArguments->GetReturnValue()->SetString(""); - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"metadata"); - } -} -void CXFA_Node::Script_Form_FormNodes(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 1) { - CXFA_Node* pDataNode = static_cast(pArguments->GetObject(0)); - if (pDataNode) { - CXFA_NodeArray formItems; - CXFA_ArrayNodeList* pFormNodes = new CXFA_ArrayNodeList(m_pDocument); - pFormNodes->SetArrayNodeList(formItems); - pArguments->GetReturnValue()->SetObject( - pFormNodes, m_pDocument->GetScriptContext()->GetJseNormalClass()); - } else { - ThrowException(XFA_IDS_ARGUMENT_MISMATCH); - } - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"formNodes"); - } -} -void CXFA_Node::Script_Form_Remerge(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - m_pDocument->DoDataRemerge(TRUE); - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"remerge"); - } -} -void CXFA_Node::Script_Form_ExecInitialize(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (!pNotify) { - return; - } - pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize); - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execInitialize"); - } -} -void CXFA_Node::Script_Form_Recalculate(CFXJSE_Arguments* pArguments) { - CXFA_EventParam* pEventParam = - m_pDocument->GetScriptContext()->GetEventParam(); - if (pEventParam->m_eType == XFA_EVENT_Calculate || - pEventParam->m_eType == XFA_EVENT_InitCalculate) { - return; - } - int32_t argc = pArguments->GetLength(); - if (argc == 1) { - const bool bScriptFlags = pArguments->GetInt32(0) != 0; - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (!pNotify) { - return; - } - if (bScriptFlags) { - pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate); - pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate); - pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Ready, TRUE); - } else { - } - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"recalculate"); - } -} -void CXFA_Node::Script_Form_ExecCalculate(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (!pNotify) { - return; - } - pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate); - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate"); - } -} -void CXFA_Node::Script_Form_ExecValidate(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (!pNotify) { - pArguments->GetReturnValue()->SetBoolean(FALSE); - } else { - int32_t iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate); - pArguments->GetReturnValue()->SetBoolean( - (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE); - } - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate"); - } -} -void CXFA_Node::Script_Form_Checksum(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - SetAttribute(XFA_ATTRIBUTE_Checksum, pValue->ToWideString().AsStringC()); - } else { - CFX_WideString wsChecksum; - GetAttribute(XFA_ATTRIBUTE_Checksum, wsChecksum, FALSE); - pValue->SetString( - FX_UTF8Encode(wsChecksum.c_str(), wsChecksum.GetLength()).AsStringC()); - } -} -void CXFA_Node::Script_Packet_GetAttribute(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 1) { - CFX_ByteString bsAttributeName = pArguments->GetUTF8String(0); - CFX_WideString wsAttributeValue; - CFDE_XMLNode* pXMLNode = GetXMLMappingNode(); - if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) { - static_cast(pXMLNode)->GetString( - CFX_WideString::FromUTF8(bsAttributeName.AsStringC()).c_str(), - wsAttributeValue); - } - pArguments->GetReturnValue()->SetString( - FX_UTF8Encode(wsAttributeValue.c_str(), wsAttributeValue.GetLength()) - .AsStringC()); - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getAttribute"); - } -} -void CXFA_Node::Script_Packet_SetAttribute(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 2) { - CFX_ByteString bsValue = pArguments->GetUTF8String(0); - CFX_ByteString bsName = pArguments->GetUTF8String(1); - CFDE_XMLNode* pXMLNode = GetXMLMappingNode(); - if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) { - static_cast(pXMLNode) - ->SetString(CFX_WideString::FromUTF8(bsName.AsStringC()), - CFX_WideString::FromUTF8(bsValue.AsStringC())); - } - pArguments->GetReturnValue()->SetNull(); - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"setAttribute"); - } -} -void CXFA_Node::Script_Packet_RemoveAttribute(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 1) { - CFX_ByteString bsName = pArguments->GetUTF8String(0); - CFX_WideString wsName = CFX_WideString::FromUTF8(bsName.AsStringC()); - CFDE_XMLNode* pXMLNode = GetXMLMappingNode(); - if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) { - CFDE_XMLElement* pXMLElement = static_cast(pXMLNode); - if (pXMLElement->HasAttribute(wsName.c_str())) { - pXMLElement->RemoveAttribute(wsName.c_str()); - } - } - pArguments->GetReturnValue()->SetNull(); - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"removeAttribute"); - } -} -void CXFA_Node::Script_Packet_Content(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - CFDE_XMLNode* pXMLNode = GetXMLMappingNode(); - if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) { - CFDE_XMLElement* pXMLElement = static_cast(pXMLNode); - pXMLElement->SetTextData(pValue->ToWideString()); - } - } else { - CFX_WideString wsTextData; - CFDE_XMLNode* pXMLNode = GetXMLMappingNode(); - if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) { - CFDE_XMLElement* pXMLElement = static_cast(pXMLNode); - pXMLElement->GetTextData(wsTextData); - } - pValue->SetString( - FX_UTF8Encode(wsTextData.c_str(), wsTextData.GetLength()).AsStringC()); - } -} -void CXFA_Node::Script_Source_Next(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"next"); - } -} -void CXFA_Node::Script_Source_CancelBatch(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"cancelBatch"); - } -} -void CXFA_Node::Script_Source_First(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"first"); - } -} -void CXFA_Node::Script_Source_UpdateBatch(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"updateBatch"); - } -} -void CXFA_Node::Script_Source_Previous(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"previous"); - } -} -void CXFA_Node::Script_Source_IsBOF(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"isBOF"); - } -} -void CXFA_Node::Script_Source_IsEOF(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"isEOF"); - } -} -void CXFA_Node::Script_Source_Cancel(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"cancel"); - } -} -void CXFA_Node::Script_Source_Update(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"update"); - } -} -void CXFA_Node::Script_Source_Open(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"open"); - } -} -void CXFA_Node::Script_Source_Delete(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"delete"); - } -} -void CXFA_Node::Script_Source_AddNew(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"addNew"); - } -} -void CXFA_Node::Script_Source_Requery(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"requery"); - } -} -void CXFA_Node::Script_Source_Resync(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"resync"); - } -} -void CXFA_Node::Script_Source_Close(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"close"); - } -} -void CXFA_Node::Script_Source_Last(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"last"); - } -} -void CXFA_Node::Script_Source_HasDataChanged(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 0) { - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"hasDataChanged"); - } -} -void CXFA_Node::Script_Source_Db(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) {} -void CXFA_Node::Script_Xfa_This(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (!bSetting) { - CXFA_Object* pThis = m_pDocument->GetScriptContext()->GetThisObject(); - ASSERT(pThis); - pValue->Assign(m_pDocument->GetScriptContext()->GetJSValueFromMap(pThis)); - } -} -void CXFA_Node::Script_Handler_Version(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) {} -void CXFA_Node::Script_SubmitFormat_Mode(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) {} -void CXFA_Node::Script_Extras_Type(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) {} -void CXFA_Node::Script_Script_Stateless(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (bSetting) { - ThrowException(XFA_IDS_INVAlID_PROP_SET); - return; - } - pValue->SetString(FX_UTF8Encode(FX_WSTRC(L"0")).AsStringC()); -} -void CXFA_Node::Script_Encrypt_Format(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) {} -enum XFA_KEYTYPE { - XFA_KEYTYPE_Custom, - XFA_KEYTYPE_Element, -}; -void* XFA_GetMapKey_Custom(const CFX_WideStringC& wsKey) { - uint32_t dwKey = FX_HashCode_GetW(wsKey, false); - return (void*)(uintptr_t)((dwKey << 1) | XFA_KEYTYPE_Custom); -} -void* XFA_GetMapKey_Element(XFA_Element eType, XFA_ATTRIBUTE eAttribute) { - return (void*)(uintptr_t)((static_cast(eType) << 16) | - (eAttribute << 8) | XFA_KEYTYPE_Element); -} -FX_BOOL CXFA_Node::HasAttribute(XFA_ATTRIBUTE eAttr, FX_BOOL bCanInherit) { - void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr); - return HasMapModuleKey(pKey, bCanInherit); -} -FX_BOOL CXFA_Node::SetAttribute(XFA_ATTRIBUTE eAttr, - const CFX_WideStringC& wsValue, - bool bNotify) { - const XFA_ATTRIBUTEINFO* pAttr = XFA_GetAttributeByID(eAttr); - if (!pAttr) - return FALSE; - - XFA_ATTRIBUTETYPE eType = pAttr->eType; - if (eType == XFA_ATTRIBUTETYPE_NOTSURE) { - const XFA_NOTSUREATTRIBUTE* pNotsure = - XFA_GetNotsureAttribute(GetElementType(), pAttr->eName); - eType = pNotsure ? pNotsure->eType : XFA_ATTRIBUTETYPE_Cdata; - } - switch (eType) { - case XFA_ATTRIBUTETYPE_Enum: { - const XFA_ATTRIBUTEENUMINFO* pEnum = XFA_GetAttributeEnumByName(wsValue); - return SetEnum(pAttr->eName, - pEnum ? pEnum->eName - : (XFA_ATTRIBUTEENUM)(intptr_t)(pAttr->pDefValue), - bNotify); - } break; - case XFA_ATTRIBUTETYPE_Cdata: - return SetCData(pAttr->eName, CFX_WideString(wsValue), bNotify); - case XFA_ATTRIBUTETYPE_Boolean: - return SetBoolean(pAttr->eName, wsValue != FX_WSTRC(L"0"), bNotify); - case XFA_ATTRIBUTETYPE_Integer: - return SetInteger( - pAttr->eName, - FXSYS_round(FX_wcstof(wsValue.c_str(), wsValue.GetLength(), nullptr)), - bNotify); - case XFA_ATTRIBUTETYPE_Measure: - return SetMeasure(pAttr->eName, CXFA_Measurement(wsValue), bNotify); - default: - break; - } - return FALSE; -} -FX_BOOL CXFA_Node::GetAttribute(XFA_ATTRIBUTE eAttr, - CFX_WideString& wsValue, - FX_BOOL bUseDefault) { - const XFA_ATTRIBUTEINFO* pAttr = XFA_GetAttributeByID(eAttr); - if (!pAttr) { - return FALSE; - } - XFA_ATTRIBUTETYPE eType = pAttr->eType; - if (eType == XFA_ATTRIBUTETYPE_NOTSURE) { - const XFA_NOTSUREATTRIBUTE* pNotsure = - XFA_GetNotsureAttribute(GetElementType(), pAttr->eName); - eType = pNotsure ? pNotsure->eType : XFA_ATTRIBUTETYPE_Cdata; - } - switch (eType) { - case XFA_ATTRIBUTETYPE_Enum: { - XFA_ATTRIBUTEENUM eValue; - if (!TryEnum(pAttr->eName, eValue, bUseDefault)) { - return FALSE; - } - wsValue = XFA_GetAttributeEnumByID(eValue)->pName; - return TRUE; - } break; - case XFA_ATTRIBUTETYPE_Cdata: { - CFX_WideStringC wsValueC; - if (!TryCData(pAttr->eName, wsValueC, bUseDefault)) { - return FALSE; - } - wsValue = wsValueC; - return TRUE; - } break; - case XFA_ATTRIBUTETYPE_Boolean: { - FX_BOOL bValue; - if (!TryBoolean(pAttr->eName, bValue, bUseDefault)) { - return FALSE; - } - wsValue = bValue ? FX_WSTRC(L"1") : FX_WSTRC(L"0"); - return TRUE; - } break; - case XFA_ATTRIBUTETYPE_Integer: { - int32_t iValue; - if (!TryInteger(pAttr->eName, iValue, bUseDefault)) { - return FALSE; - } - wsValue.Format(L"%d", iValue); - return TRUE; - } break; - case XFA_ATTRIBUTETYPE_Measure: { - CXFA_Measurement mValue; - if (!TryMeasure(pAttr->eName, mValue, bUseDefault)) { - return FALSE; - } - mValue.ToString(wsValue); - return TRUE; - } break; - default: - break; - } - return FALSE; -} -FX_BOOL CXFA_Node::SetAttribute(const CFX_WideStringC& wsAttr, - const CFX_WideStringC& wsValue, - bool bNotify) { - const XFA_ATTRIBUTEINFO* pAttributeInfo = XFA_GetAttributeByName(wsValue); - if (pAttributeInfo) { - return SetAttribute(pAttributeInfo->eName, wsValue, bNotify); - } - void* pKey = XFA_GetMapKey_Custom(wsAttr); - SetMapModuleString(pKey, wsValue); - return TRUE; -} -FX_BOOL CXFA_Node::GetAttribute(const CFX_WideStringC& wsAttr, - CFX_WideString& wsValue, - FX_BOOL bUseDefault) { - const XFA_ATTRIBUTEINFO* pAttributeInfo = XFA_GetAttributeByName(wsAttr); - if (pAttributeInfo) { - return GetAttribute(pAttributeInfo->eName, wsValue, bUseDefault); - } - void* pKey = XFA_GetMapKey_Custom(wsAttr); - CFX_WideStringC wsValueC; - if (GetMapModuleString(pKey, wsValueC)) { - wsValue = wsValueC; - } - return TRUE; -} -FX_BOOL CXFA_Node::RemoveAttribute(const CFX_WideStringC& wsAttr) { - void* pKey = XFA_GetMapKey_Custom(wsAttr); - RemoveMapModuleKey(pKey); - return TRUE; -} -FX_BOOL CXFA_Node::TryBoolean(XFA_ATTRIBUTE eAttr, - FX_BOOL& bValue, - FX_BOOL bUseDefault) { - void* pValue = nullptr; - if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Boolean, bUseDefault, pValue)) - return FALSE; - bValue = (FX_BOOL)(uintptr_t)pValue; - return TRUE; -} -FX_BOOL CXFA_Node::TryInteger(XFA_ATTRIBUTE eAttr, - int32_t& iValue, - FX_BOOL bUseDefault) { - void* pValue = nullptr; - if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Integer, bUseDefault, pValue)) - return FALSE; - iValue = (int32_t)(uintptr_t)pValue; - return TRUE; -} -FX_BOOL CXFA_Node::TryEnum(XFA_ATTRIBUTE eAttr, - XFA_ATTRIBUTEENUM& eValue, - FX_BOOL bUseDefault) { - void* pValue = nullptr; - if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Enum, bUseDefault, pValue)) - return FALSE; - eValue = (XFA_ATTRIBUTEENUM)(uintptr_t)pValue; - return TRUE; -} - -FX_BOOL CXFA_Node::SetMeasure(XFA_ATTRIBUTE eAttr, - CXFA_Measurement mValue, - bool bNotify) { - void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr); - OnChanging(eAttr, bNotify); - SetMapModuleBuffer(pKey, &mValue, sizeof(CXFA_Measurement)); - OnChanged(eAttr, bNotify, FALSE); - return TRUE; -} - -FX_BOOL CXFA_Node::TryMeasure(XFA_ATTRIBUTE eAttr, - CXFA_Measurement& mValue, - FX_BOOL bUseDefault) const { - void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr); - void* pValue; - int32_t iBytes; - if (GetMapModuleBuffer(pKey, pValue, iBytes) && iBytes == sizeof(mValue)) { - FXSYS_memcpy(&mValue, pValue, sizeof(mValue)); - return TRUE; - } - if (bUseDefault && - XFA_GetAttributeDefaultValue(pValue, GetElementType(), eAttr, - XFA_ATTRIBUTETYPE_Measure, m_ePacket)) { - FXSYS_memcpy(&mValue, pValue, sizeof(mValue)); - return TRUE; - } - return FALSE; -} - -CXFA_Measurement CXFA_Node::GetMeasure(XFA_ATTRIBUTE eAttr) const { - CXFA_Measurement mValue; - return TryMeasure(eAttr, mValue, TRUE) ? mValue : CXFA_Measurement(); -} - -FX_BOOL CXFA_Node::SetCData(XFA_ATTRIBUTE eAttr, - const CFX_WideString& wsValue, - bool bNotify, - FX_BOOL bScriptModify) { - void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr); - OnChanging(eAttr, bNotify); - if (eAttr == XFA_ATTRIBUTE_Value) { - CFX_WideString* pClone = new CFX_WideString(wsValue); - SetUserData(pKey, pClone, &deleteWideStringCallBack); - } else { - SetMapModuleString(pKey, wsValue.AsStringC()); - if (eAttr == XFA_ATTRIBUTE_Name) - UpdateNameHash(); - } - OnChanged(eAttr, bNotify, bScriptModify); - - if (!IsNeedSavingXMLNode() || eAttr == XFA_ATTRIBUTE_QualifiedName || - eAttr == XFA_ATTRIBUTE_BindingNode) { - return TRUE; - } - - if (eAttr == XFA_ATTRIBUTE_Name && - (m_elementType == XFA_Element::DataValue || - m_elementType == XFA_Element::DataGroup)) { - return TRUE; - } - - if (eAttr == XFA_ATTRIBUTE_Value) { - FDE_XMLNODETYPE eXMLType = m_pXMLNode->GetType(); - switch (eXMLType) { - case FDE_XMLNODE_Element: - if (IsAttributeInXML()) { - static_cast(m_pXMLNode) - ->SetString(CFX_WideString(GetCData(XFA_ATTRIBUTE_QualifiedName)), - wsValue); - } else { - FX_BOOL bDeleteChildren = TRUE; - if (GetPacketID() == XFA_XDPPACKET_Datasets) { - for (CXFA_Node* pChildDataNode = - GetNodeItem(XFA_NODEITEM_FirstChild); - pChildDataNode; pChildDataNode = pChildDataNode->GetNodeItem( - XFA_NODEITEM_NextSibling)) { - CXFA_NodeArray formNodes; - if (pChildDataNode->GetBindItems(formNodes) > 0) { - bDeleteChildren = FALSE; - break; - } - } - } - if (bDeleteChildren) { - static_cast(m_pXMLNode)->DeleteChildren(); - } - static_cast(m_pXMLNode)->SetTextData(wsValue); - } - break; - case FDE_XMLNODE_Text: - static_cast(m_pXMLNode)->SetText(wsValue); - break; - default: - ASSERT(0); - } - return TRUE; - } - - const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttr); - if (pInfo) { - ASSERT(m_pXMLNode->GetType() == FDE_XMLNODE_Element); - CFX_WideString wsAttrName = pInfo->pName; - if (pInfo->eName == XFA_ATTRIBUTE_ContentType) { - wsAttrName = FX_WSTRC(L"xfa:") + wsAttrName; - } - static_cast(m_pXMLNode)->SetString(wsAttrName, wsValue); - } - return TRUE; -} - -FX_BOOL CXFA_Node::SetAttributeValue(const CFX_WideString& wsValue, - const CFX_WideString& wsXMLValue, - bool bNotify, - FX_BOOL bScriptModify) { - void* pKey = XFA_GetMapKey_Element(GetElementType(), XFA_ATTRIBUTE_Value); - OnChanging(XFA_ATTRIBUTE_Value, bNotify); - CFX_WideString* pClone = new CFX_WideString(wsValue); - SetUserData(pKey, pClone, &deleteWideStringCallBack); - OnChanged(XFA_ATTRIBUTE_Value, bNotify, bScriptModify); - if (IsNeedSavingXMLNode()) { - FDE_XMLNODETYPE eXMLType = m_pXMLNode->GetType(); - switch (eXMLType) { - case FDE_XMLNODE_Element: - if (IsAttributeInXML()) { - static_cast(m_pXMLNode) - ->SetString(CFX_WideString(GetCData(XFA_ATTRIBUTE_QualifiedName)), - wsXMLValue); - } else { - FX_BOOL bDeleteChildren = TRUE; - if (GetPacketID() == XFA_XDPPACKET_Datasets) { - for (CXFA_Node* pChildDataNode = - GetNodeItem(XFA_NODEITEM_FirstChild); - pChildDataNode; pChildDataNode = pChildDataNode->GetNodeItem( - XFA_NODEITEM_NextSibling)) { - CXFA_NodeArray formNodes; - if (pChildDataNode->GetBindItems(formNodes) > 0) { - bDeleteChildren = FALSE; - break; - } - } - } - if (bDeleteChildren) { - static_cast(m_pXMLNode)->DeleteChildren(); - } - static_cast(m_pXMLNode)->SetTextData(wsXMLValue); - } - break; - case FDE_XMLNODE_Text: - static_cast(m_pXMLNode)->SetText(wsXMLValue); - break; - default: - ASSERT(0); - } - } - return TRUE; -} -FX_BOOL CXFA_Node::TryCData(XFA_ATTRIBUTE eAttr, - CFX_WideString& wsValue, - FX_BOOL bUseDefault, - FX_BOOL bProto) { - void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr); - if (eAttr == XFA_ATTRIBUTE_Value) { - CFX_WideString* pStr = (CFX_WideString*)GetUserData(pKey, bProto); - if (pStr) { - wsValue = *pStr; - return TRUE; - } - } else { - CFX_WideStringC wsValueC; - if (GetMapModuleString(pKey, wsValueC)) { - wsValue = wsValueC; - return TRUE; - } - } - if (!bUseDefault) { - return FALSE; - } - void* pValue = nullptr; - if (XFA_GetAttributeDefaultValue(pValue, GetElementType(), eAttr, - XFA_ATTRIBUTETYPE_Cdata, m_ePacket)) { - wsValue = (const FX_WCHAR*)pValue; - return TRUE; - } - return FALSE; -} -FX_BOOL CXFA_Node::TryCData(XFA_ATTRIBUTE eAttr, - CFX_WideStringC& wsValue, - FX_BOOL bUseDefault, - FX_BOOL bProto) { - void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr); - if (eAttr == XFA_ATTRIBUTE_Value) { - CFX_WideString* pStr = (CFX_WideString*)GetUserData(pKey, bProto); - if (pStr) { - wsValue = pStr->AsStringC(); - return TRUE; - } - } else { - if (GetMapModuleString(pKey, wsValue)) { - return TRUE; - } - } - if (!bUseDefault) { - return FALSE; - } - void* pValue = nullptr; - if (XFA_GetAttributeDefaultValue(pValue, GetElementType(), eAttr, - XFA_ATTRIBUTETYPE_Cdata, m_ePacket)) { - wsValue = (CFX_WideStringC)(const FX_WCHAR*)pValue; - return TRUE; - } - return FALSE; -} -FX_BOOL CXFA_Node::SetObject(XFA_ATTRIBUTE eAttr, - void* pData, - XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) { - void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr); - return SetUserData(pKey, pData, pCallbackInfo); -} -FX_BOOL CXFA_Node::TryObject(XFA_ATTRIBUTE eAttr, void*& pData) { - void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr); - pData = GetUserData(pKey); - return !!pData; -} -FX_BOOL CXFA_Node::SetValue(XFA_ATTRIBUTE eAttr, - XFA_ATTRIBUTETYPE eType, - void* pValue, - bool bNotify) { - void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr); - OnChanging(eAttr, bNotify); - SetMapModuleValue(pKey, pValue); - OnChanged(eAttr, bNotify, FALSE); - if (IsNeedSavingXMLNode()) { - ASSERT(m_pXMLNode->GetType() == FDE_XMLNODE_Element); - const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttr); - if (pInfo) { - switch (eType) { - case XFA_ATTRIBUTETYPE_Enum: - static_cast(m_pXMLNode) - ->SetString( - pInfo->pName, - XFA_GetAttributeEnumByID((XFA_ATTRIBUTEENUM)(uintptr_t)pValue) - ->pName); - break; - case XFA_ATTRIBUTETYPE_Boolean: - static_cast(m_pXMLNode) - ->SetString(pInfo->pName, pValue ? L"1" : L"0"); - break; - case XFA_ATTRIBUTETYPE_Integer: - static_cast(m_pXMLNode) - ->SetInteger(pInfo->pName, (int32_t)(uintptr_t)pValue); - break; - default: - ASSERT(0); - } - } - } - return TRUE; -} -FX_BOOL CXFA_Node::GetValue(XFA_ATTRIBUTE eAttr, - XFA_ATTRIBUTETYPE eType, - FX_BOOL bUseDefault, - void*& pValue) { - void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr); - if (GetMapModuleValue(pKey, pValue)) { - return TRUE; - } - if (!bUseDefault) { - return FALSE; - } - return XFA_GetAttributeDefaultValue(pValue, GetElementType(), eAttr, eType, - m_ePacket); -} -static void XFA_DefaultFreeData(void* pData) {} -static XFA_MAPDATABLOCKCALLBACKINFO gs_XFADefaultFreeData = { - XFA_DefaultFreeData, nullptr}; -FX_BOOL CXFA_Node::SetUserData(void* pKey, - void* pData, - XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) { - SetMapModuleBuffer(pKey, &pData, sizeof(void*), - pCallbackInfo ? pCallbackInfo : &gs_XFADefaultFreeData); - return TRUE; -} -FX_BOOL CXFA_Node::TryUserData(void* pKey, void*& pData, FX_BOOL bProtoAlso) { - int32_t iBytes = 0; - if (!GetMapModuleBuffer(pKey, pData, iBytes, bProtoAlso)) { - return FALSE; - } - return iBytes == sizeof(void*) && FXSYS_memcpy(&pData, pData, iBytes); -} -FX_BOOL CXFA_Node::SetScriptContent(const CFX_WideString& wsContent, - const CFX_WideString& wsXMLValue, - bool bNotify, - FX_BOOL bScriptModify, - FX_BOOL bSyncData) { - CXFA_Node* pNode = nullptr; - CXFA_Node* pBindNode = nullptr; - switch (GetObjectType()) { - case XFA_ObjectType::ContainerNode: { - if (XFA_FieldIsMultiListBox(this)) { - CXFA_Node* pValue = GetProperty(0, XFA_Element::Value); - CXFA_Node* pChildValue = pValue->GetNodeItem(XFA_NODEITEM_FirstChild); - ASSERT(pChildValue); - pChildValue->SetCData(XFA_ATTRIBUTE_ContentType, L"text/xml"); - pChildValue->SetScriptContent(wsContent, wsContent, bNotify, - bScriptModify, FALSE); - CXFA_Node* pBind = GetBindData(); - if (bSyncData && pBind) { - CFX_WideStringArray wsSaveTextArray; - int32_t iSize = 0; - if (!wsContent.IsEmpty()) { - int32_t iStart = 0; - int32_t iLength = wsContent.GetLength(); - int32_t iEnd = wsContent.Find(L'\n', iStart); - iEnd = (iEnd == -1) ? iLength : iEnd; - while (iEnd >= iStart) { - wsSaveTextArray.Add(wsContent.Mid(iStart, iEnd - iStart)); - iStart = iEnd + 1; - if (iStart >= iLength) { - break; - } - iEnd = wsContent.Find(L'\n', iStart); - if (iEnd < 0) { - wsSaveTextArray.Add(wsContent.Mid(iStart, iLength - iStart)); - } - } - iSize = wsSaveTextArray.GetSize(); - } - if (iSize == 0) { - while (CXFA_Node* pChildNode = - pBind->GetNodeItem(XFA_NODEITEM_FirstChild)) { - pBind->RemoveChild(pChildNode); - } - } else { - CXFA_NodeArray valueNodes; - int32_t iDatas = pBind->GetNodeList( - valueNodes, XFA_NODEFILTER_Children, XFA_Element::DataValue); - if (iDatas < iSize) { - int32_t iAddNodes = iSize - iDatas; - CXFA_Node* pValueNodes = nullptr; - while (iAddNodes-- > 0) { - pValueNodes = - pBind->CreateSamePacketNode(XFA_Element::DataValue); - pValueNodes->SetCData(XFA_ATTRIBUTE_Name, L"value"); - pValueNodes->CreateXMLMappingNode(); - pBind->InsertChild(pValueNodes); - } - pValueNodes = nullptr; - } else if (iDatas > iSize) { - int32_t iDelNodes = iDatas - iSize; - while (iDelNodes-- > 0) { - pBind->RemoveChild(pBind->GetNodeItem(XFA_NODEITEM_FirstChild)); - } - } - int32_t i = 0; - for (CXFA_Node* pValueNode = - pBind->GetNodeItem(XFA_NODEITEM_FirstChild); - pValueNode; pValueNode = pValueNode->GetNodeItem( - XFA_NODEITEM_NextSibling)) { - pValueNode->SetAttributeValue(wsSaveTextArray[i], - wsSaveTextArray[i], FALSE); - i++; - } - } - CXFA_NodeArray nodeArray; - pBind->GetBindItems(nodeArray); - for (int32_t i = 0; i < nodeArray.GetSize(); i++) { - if (nodeArray[i] != this) { - nodeArray[i]->SetScriptContent(wsContent, wsContent, bNotify, - bScriptModify, FALSE); - } - } - } - break; - } else if (GetElementType() == XFA_Element::ExclGroup) { - pNode = this; - } else { - CXFA_Node* pValue = GetProperty(0, XFA_Element::Value); - CXFA_Node* pChildValue = pValue->GetNodeItem(XFA_NODEITEM_FirstChild); - ASSERT(pChildValue); - pChildValue->SetScriptContent(wsContent, wsContent, bNotify, - bScriptModify, FALSE); - } - pBindNode = GetBindData(); - if (pBindNode && bSyncData) { - pBindNode->SetScriptContent(wsContent, wsXMLValue, bNotify, - bScriptModify, FALSE); - CXFA_NodeArray nodeArray; - pBindNode->GetBindItems(nodeArray); - for (int32_t i = 0; i < nodeArray.GetSize(); i++) { - if (nodeArray[i] != this) { - nodeArray[i]->SetScriptContent(wsContent, wsContent, bNotify, true, - FALSE); - } - } - } - pBindNode = nullptr; - break; - } - case XFA_ObjectType::ContentNode: { - CFX_WideString wsContentType; - if (GetElementType() == XFA_Element::ExData) { - GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, FALSE); - if (wsContentType == FX_WSTRC(L"text/html")) { - wsContentType = FX_WSTRC(L""); - SetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType.AsStringC()); - } - } - CXFA_Node* pContentRawDataNode = GetNodeItem(XFA_NODEITEM_FirstChild); - if (!pContentRawDataNode) { - pContentRawDataNode = CreateSamePacketNode( - (wsContentType == FX_WSTRC(L"text/xml")) ? XFA_Element::Sharpxml - : XFA_Element::Sharptext); - InsertChild(pContentRawDataNode); - } - return pContentRawDataNode->SetScriptContent( - wsContent, wsXMLValue, bNotify, bScriptModify, bSyncData); - } break; - case XFA_ObjectType::NodeC: - case XFA_ObjectType::TextNode: - pNode = this; - break; - case XFA_ObjectType::NodeV: - pNode = this; - if (bSyncData && GetPacketID() == XFA_XDPPACKET_Form) { - CXFA_Node* pParent = 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->SetScriptContent(wsContent, wsXMLValue, bNotify, - bScriptModify, FALSE); - } - } - } - } - break; - default: - if (GetElementType() == XFA_Element::DataValue) { - pNode = this; - pBindNode = this; - } - break; - } - if (pNode) { - SetAttributeValue(wsContent, wsXMLValue, bNotify, bScriptModify); - if (pBindNode && bSyncData) { - CXFA_NodeArray nodeArray; - pBindNode->GetBindItems(nodeArray); - for (int32_t i = 0; i < nodeArray.GetSize(); i++) { - nodeArray[i]->SetScriptContent(wsContent, wsContent, bNotify, - bScriptModify, FALSE); - } - } - return TRUE; - } - return FALSE; -} -FX_BOOL CXFA_Node::SetContent(const CFX_WideString& wsContent, - const CFX_WideString& wsXMLValue, - bool bNotify, - FX_BOOL bScriptModify, - FX_BOOL bSyncData) { - return SetScriptContent(wsContent, wsXMLValue, bNotify, bScriptModify, - bSyncData); -} -CFX_WideString CXFA_Node::GetScriptContent(FX_BOOL bScriptModify) { - CFX_WideString wsContent; - return TryContent(wsContent, bScriptModify) ? wsContent : CFX_WideString(); -} -CFX_WideString CXFA_Node::GetContent() { - return GetScriptContent(); -} -FX_BOOL CXFA_Node::TryContent(CFX_WideString& wsContent, - FX_BOOL bScriptModify, - FX_BOOL bProto) { - CXFA_Node* pNode = nullptr; - switch (GetObjectType()) { - case XFA_ObjectType::ContainerNode: - if (GetElementType() == XFA_Element::ExclGroup) { - pNode = this; - } else { - CXFA_Node* pValue = GetChild(0, XFA_Element::Value); - if (!pValue) { - return FALSE; - } - CXFA_Node* pChildValue = pValue->GetNodeItem(XFA_NODEITEM_FirstChild); - if (pChildValue && XFA_FieldIsMultiListBox(this)) { - pChildValue->SetAttribute(XFA_ATTRIBUTE_ContentType, - FX_WSTRC(L"text/xml")); - } - return pChildValue - ? pChildValue->TryContent(wsContent, bScriptModify, bProto) - : FALSE; - } - break; - case XFA_ObjectType::ContentNode: { - CXFA_Node* pContentRawDataNode = GetNodeItem(XFA_NODEITEM_FirstChild); - if (!pContentRawDataNode) { - XFA_Element element = XFA_Element::Sharptext; - if (GetElementType() == XFA_Element::ExData) { - CFX_WideString wsContentType; - GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, FALSE); - if (wsContentType == FX_WSTRC(L"text/html")) { - element = XFA_Element::SharpxHTML; - } else if (wsContentType == FX_WSTRC(L"text/xml")) { - element = XFA_Element::Sharpxml; - } - } - pContentRawDataNode = CreateSamePacketNode(element); - InsertChild(pContentRawDataNode); - } - return pContentRawDataNode->TryContent(wsContent, bScriptModify, bProto); - } - case XFA_ObjectType::NodeC: - case XFA_ObjectType::NodeV: - case XFA_ObjectType::TextNode: - pNode = this; - default: - if (GetElementType() == XFA_Element::DataValue) { - pNode = this; - } - break; - } - if (pNode) { - if (bScriptModify) { - CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext(); - if (pScriptContext) { - m_pDocument->GetScriptContext()->AddNodesOfRunScript(this); - } - } - return TryCData(XFA_ATTRIBUTE_Value, wsContent, FALSE, bProto); - } - return FALSE; -} -CXFA_Node* CXFA_Node::GetModelNode() { - switch (GetPacketID()) { - case XFA_XDPPACKET_XDP: - return m_pDocument->GetRoot(); - case XFA_XDPPACKET_Config: - return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Config)); - case XFA_XDPPACKET_Template: - return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Template)); - case XFA_XDPPACKET_Form: - return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form)); - case XFA_XDPPACKET_Datasets: - return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Datasets)); - case XFA_XDPPACKET_LocaleSet: - return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_LocaleSet)); - case XFA_XDPPACKET_ConnectionSet: - return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_ConnectionSet)); - case XFA_XDPPACKET_SourceSet: - return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_SourceSet)); - case XFA_XDPPACKET_Xdc: - return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Xdc)); - default: - return this; - } -} -FX_BOOL CXFA_Node::TryNamespace(CFX_WideString& wsNamespace) { - wsNamespace.clear(); - if (IsModelNode() || GetElementType() == XFA_Element::Packet) { - CFDE_XMLNode* pXMLNode = GetXMLMappingNode(); - if (!pXMLNode || pXMLNode->GetType() != FDE_XMLNODE_Element) { - return FALSE; - } - static_cast(pXMLNode)->GetNamespaceURI(wsNamespace); - return TRUE; - } else if (GetPacketID() == XFA_XDPPACKET_Datasets) { - CFDE_XMLNode* pXMLNode = GetXMLMappingNode(); - if (!pXMLNode) { - return FALSE; - } - if (pXMLNode->GetType() != FDE_XMLNODE_Element) { - return TRUE; - } - if (GetElementType() == XFA_Element::DataValue && - GetEnum(XFA_ATTRIBUTE_Contains) == XFA_ATTRIBUTEENUM_MetaData) { - return XFA_FDEExtension_ResolveNamespaceQualifier( - static_cast(pXMLNode), - GetCData(XFA_ATTRIBUTE_QualifiedName), wsNamespace); - } - static_cast(pXMLNode)->GetNamespaceURI(wsNamespace); - return TRUE; - } else { - CXFA_Node* pModelNode = GetModelNode(); - return pModelNode->TryNamespace(wsNamespace); - } -} -CXFA_Node* CXFA_Node::GetProperty(int32_t index, - XFA_Element eProperty, - FX_BOOL bCreateProperty) { - XFA_Element eType = GetElementType(); - uint32_t dwPacket = GetPacketID(); - const XFA_PROPERTY* pProperty = - XFA_GetPropertyOfElement(eType, eProperty, dwPacket); - if (!pProperty || index >= pProperty->uOccur) - return nullptr; - - CXFA_Node* pNode = m_pChild; - int32_t iCount = 0; - for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { - if (pNode->GetElementType() == eProperty) { - iCount++; - if (iCount > index) { - return pNode; - } - } - } - if (!bCreateProperty) - return nullptr; - - if (pProperty->uFlags & XFA_PROPERTYFLAG_OneOf) { - pNode = m_pChild; - for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { - const XFA_PROPERTY* pExistProperty = - XFA_GetPropertyOfElement(eType, pNode->GetElementType(), dwPacket); - if (pExistProperty && (pExistProperty->uFlags & XFA_PROPERTYFLAG_OneOf)) - return nullptr; - } - } - - const XFA_PACKETINFO* pPacket = XFA_GetPacketByID(dwPacket); - CXFA_Node* pNewNode = nullptr; - for (; iCount <= index; iCount++) { - pNewNode = m_pDocument->CreateNode(pPacket, eProperty); - if (!pNewNode) - return nullptr; - InsertChild(pNewNode, nullptr); - pNewNode->SetFlag(XFA_NodeFlag_Initialized, true); - } - return pNewNode; -} -int32_t CXFA_Node::CountChildren(XFA_Element eType, FX_BOOL bOnlyChild) { - CXFA_Node* pNode = m_pChild; - int32_t iCount = 0; - for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { - if (pNode->GetElementType() == eType || eType == XFA_Element::Unknown) { - if (bOnlyChild) { - const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement( - GetElementType(), pNode->GetElementType(), XFA_XDPPACKET_UNKNOWN); - if (pProperty) { - continue; - } - } - iCount++; - } - } - return iCount; -} -CXFA_Node* CXFA_Node::GetChild(int32_t index, - XFA_Element eType, - FX_BOOL bOnlyChild) { - ASSERT(index > -1); - CXFA_Node* pNode = m_pChild; - int32_t iCount = 0; - for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { - if (pNode->GetElementType() == eType || eType == XFA_Element::Unknown) { - if (bOnlyChild) { - const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement( - GetElementType(), pNode->GetElementType(), XFA_XDPPACKET_UNKNOWN); - if (pProperty) { - continue; - } - } - iCount++; - if (iCount > index) { - return pNode; - } - } - } - return nullptr; -} -int32_t CXFA_Node::InsertChild(int32_t index, CXFA_Node* pNode) { - ASSERT(!pNode->m_pNext); - pNode->m_pParent = this; - FX_BOOL ret = m_pDocument->RemovePurgeNode(pNode); - ASSERT(ret); - (void)ret; // Avoid unused variable warning. - - if (!m_pChild || index == 0) { - if (index > 0) { - return -1; - } - pNode->m_pNext = m_pChild; - m_pChild = pNode; - index = 0; - } else if (index < 0) { - m_pLastChild->m_pNext = pNode; - } else { - CXFA_Node* pPrev = m_pChild; - int32_t iCount = 0; - while (++iCount != index && pPrev->m_pNext) { - pPrev = pPrev->m_pNext; - } - if (index > 0 && index != iCount) { - return -1; - } - pNode->m_pNext = pPrev->m_pNext; - pPrev->m_pNext = pNode; - index = iCount; - } - if (!pNode->m_pNext) { - m_pLastChild = pNode; - } - ASSERT(m_pLastChild); - ASSERT(!m_pLastChild->m_pNext); - pNode->ClearFlag(XFA_NodeFlag_HasRemovedChildren); - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (pNotify) - pNotify->OnChildAdded(this); - - if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) { - ASSERT(!pNode->m_pXMLNode->GetNodeItem(CFDE_XMLNode::Parent)); - m_pXMLNode->InsertChildNode(pNode->m_pXMLNode, index); - pNode->ClearFlag(XFA_NodeFlag_OwnXMLNode); - } - return index; -} - -FX_BOOL CXFA_Node::InsertChild(CXFA_Node* pNode, CXFA_Node* pBeforeNode) { - if (!pNode || pNode->m_pParent || - (pBeforeNode && pBeforeNode->m_pParent != this)) { - ASSERT(false); - return FALSE; - } - FX_BOOL ret = m_pDocument->RemovePurgeNode(pNode); - ASSERT(ret); - (void)ret; // Avoid unused variable warning. - - int32_t nIndex = -1; - pNode->m_pParent = this; - if (!m_pChild || pBeforeNode == m_pChild) { - pNode->m_pNext = m_pChild; - m_pChild = pNode; - nIndex = 0; - } else if (!pBeforeNode) { - pNode->m_pNext = m_pLastChild->m_pNext; - m_pLastChild->m_pNext = pNode; - } else { - nIndex = 1; - CXFA_Node* pPrev = m_pChild; - while (pPrev->m_pNext != pBeforeNode) { - pPrev = pPrev->m_pNext; - nIndex++; - } - pNode->m_pNext = pPrev->m_pNext; - pPrev->m_pNext = pNode; - } - if (!pNode->m_pNext) { - m_pLastChild = pNode; - } - ASSERT(m_pLastChild); - ASSERT(!m_pLastChild->m_pNext); - pNode->ClearFlag(XFA_NodeFlag_HasRemovedChildren); - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (pNotify) - pNotify->OnChildAdded(this); - - if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) { - ASSERT(!pNode->m_pXMLNode->GetNodeItem(CFDE_XMLNode::Parent)); - m_pXMLNode->InsertChildNode(pNode->m_pXMLNode, nIndex); - pNode->ClearFlag(XFA_NodeFlag_OwnXMLNode); - } - return TRUE; -} -CXFA_Node* CXFA_Node::Deprecated_GetPrevSibling() { - if (!m_pParent) { - return nullptr; - } - for (CXFA_Node* pSibling = m_pParent->m_pChild; pSibling; - pSibling = pSibling->m_pNext) { - if (pSibling->m_pNext == this) { - return pSibling; - } - } - return nullptr; -} -FX_BOOL CXFA_Node::RemoveChild(CXFA_Node* pNode, bool bNotify) { - if (!pNode || pNode->m_pParent != this) { - ASSERT(FALSE); - return FALSE; - } - if (m_pChild == pNode) { - m_pChild = pNode->m_pNext; - if (m_pLastChild == pNode) { - m_pLastChild = pNode->m_pNext; - } - pNode->m_pNext = nullptr; - pNode->m_pParent = nullptr; - } else { - CXFA_Node* pPrev = pNode->Deprecated_GetPrevSibling(); - pPrev->m_pNext = pNode->m_pNext; - if (m_pLastChild == pNode) { - m_pLastChild = pNode->m_pNext ? pNode->m_pNext : pPrev; - } - pNode->m_pNext = nullptr; - pNode->m_pParent = nullptr; - } - ASSERT(!m_pLastChild || !m_pLastChild->m_pNext); - OnRemoved(bNotify); - pNode->SetFlag(XFA_NodeFlag_HasRemovedChildren, true); - m_pDocument->AddPurgeNode(pNode); - if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) { - if (pNode->IsAttributeInXML()) { - ASSERT(pNode->m_pXMLNode == m_pXMLNode && - m_pXMLNode->GetType() == FDE_XMLNODE_Element); - if (pNode->m_pXMLNode->GetType() == FDE_XMLNODE_Element) { - CFDE_XMLElement* pXMLElement = - static_cast(pNode->m_pXMLNode); - CFX_WideStringC wsAttributeName = - pNode->GetCData(XFA_ATTRIBUTE_QualifiedName); - pXMLElement->RemoveAttribute(wsAttributeName.c_str()); - } - CFX_WideString wsName; - pNode->GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE); - CFDE_XMLElement* pNewXMLElement = new CFDE_XMLElement(wsName); - CFX_WideStringC wsValue = GetCData(XFA_ATTRIBUTE_Value); - if (!wsValue.IsEmpty()) { - pNewXMLElement->SetTextData(CFX_WideString(wsValue)); - } - pNode->m_pXMLNode = pNewXMLElement; - pNode->SetEnum(XFA_ATTRIBUTE_Contains, XFA_ATTRIBUTEENUM_Unknown); - } else { - m_pXMLNode->RemoveChildNode(pNode->m_pXMLNode); - } - pNode->SetFlag(XFA_NodeFlag_OwnXMLNode, false); - } - return TRUE; -} -CXFA_Node* CXFA_Node::GetFirstChildByName(const CFX_WideStringC& wsName) const { - return GetFirstChildByName(FX_HashCode_GetW(wsName, false)); -} -CXFA_Node* CXFA_Node::GetFirstChildByName(uint32_t dwNameHash) const { - for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_FirstChild); pNode; - pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { - if (pNode->GetNameHash() == dwNameHash) { - return pNode; - } - } - return nullptr; -} -CXFA_Node* CXFA_Node::GetFirstChildByClass(XFA_Element eType) const { - for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_FirstChild); pNode; - pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { - if (pNode->GetElementType() == eType) { - return pNode; - } - } - return nullptr; -} -CXFA_Node* CXFA_Node::GetNextSameNameSibling(uint32_t dwNameHash) const { - for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_NextSibling); pNode; - pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { - if (pNode->GetNameHash() == dwNameHash) { - return pNode; - } - } - return nullptr; -} -CXFA_Node* CXFA_Node::GetNextSameNameSibling( - const CFX_WideStringC& wsNodeName) const { - return GetNextSameNameSibling(FX_HashCode_GetW(wsNodeName, false)); -} -CXFA_Node* CXFA_Node::GetNextSameClassSibling(XFA_Element eType) const { - for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_NextSibling); pNode; - pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { - if (pNode->GetElementType() == eType) { - return pNode; - } - } - return nullptr; -} -int32_t CXFA_Node::GetNodeSameNameIndex() const { - CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext(); - if (!pScriptContext) { - return -1; - } - return pScriptContext->GetIndexByName(const_cast(this)); -} -int32_t CXFA_Node::GetNodeSameClassIndex() const { - CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext(); - if (!pScriptContext) { - return -1; - } - return pScriptContext->GetIndexByClassName(const_cast(this)); -} -void CXFA_Node::GetSOMExpression(CFX_WideString& wsSOMExpression) { - CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext(); - if (!pScriptContext) { - return; - } - pScriptContext->GetSomExpression(this, wsSOMExpression); -} -CXFA_Node* CXFA_Node::GetInstanceMgrOfSubform() { - CXFA_Node* pInstanceMgr = nullptr; - if (m_ePacket == XFA_XDPPACKET_Form) { - CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent); - if (!pParentNode || pParentNode->GetElementType() == XFA_Element::Area) { - return pInstanceMgr; - } - for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode; - pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) { - XFA_Element eType = pNode->GetElementType(); - if ((eType == XFA_Element::Subform || eType == XFA_Element::SubformSet) && - pNode->m_dwNameHash != m_dwNameHash) { - break; - } - if (eType == XFA_Element::InstanceManager) { - CFX_WideStringC wsName = GetCData(XFA_ATTRIBUTE_Name); - CFX_WideStringC wsInstName = pNode->GetCData(XFA_ATTRIBUTE_Name); - if (wsInstName.GetLength() > 0 && wsInstName.GetAt(0) == '_' && - wsInstName.Mid(1) == wsName) { - pInstanceMgr = pNode; - } - break; - } - } - } - return pInstanceMgr; -} -CXFA_Node* CXFA_Node::GetOccurNode() { - return GetFirstChildByClass(XFA_Element::Occur); -} -bool CXFA_Node::HasFlag(XFA_NodeFlag dwFlag) const { - if (m_uNodeFlags & dwFlag) - return true; - if (dwFlag == XFA_NodeFlag_HasRemovedChildren) - return m_pParent && m_pParent->HasFlag(dwFlag); - return false; -} - -void CXFA_Node::SetFlag(uint32_t dwFlag, bool bNotify) { - if (dwFlag == XFA_NodeFlag_Initialized && bNotify && !IsInitialized()) { - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (pNotify) { - pNotify->OnNodeReady(this); - } - } - m_uNodeFlags |= dwFlag; -} - -void CXFA_Node::ClearFlag(uint32_t dwFlag) { - m_uNodeFlags &= ~dwFlag; -} - -FX_BOOL CXFA_Node::IsAttributeInXML() { - return GetEnum(XFA_ATTRIBUTE_Contains) == XFA_ATTRIBUTEENUM_MetaData; -} - -void CXFA_Node::OnRemoved(bool bNotify) { - if (!bNotify) - return; - - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (pNotify) - pNotify->OnChildRemoved(); -} - -void CXFA_Node::OnChanging(XFA_ATTRIBUTE eAttr, bool bNotify) { - if (bNotify && IsInitialized()) { - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (pNotify) { - pNotify->OnValueChanging(this, eAttr); - } - } -} - -void CXFA_Node::OnChanged(XFA_ATTRIBUTE eAttr, - bool bNotify, - FX_BOOL bScriptModify) { - if (bNotify && IsInitialized()) { - Script_Attribute_SendAttributeChangeMessage(eAttr, bScriptModify); - } -} - -int32_t CXFA_Node::execSingleEventByName(const CFX_WideStringC& wsEventName, - XFA_Element eType) { - int32_t iRet = XFA_EVENTERROR_NotExist; - const XFA_ExecEventParaInfo* eventParaInfo = - GetEventParaInfoByName(wsEventName); - if (eventParaInfo) { - uint32_t validFlags = eventParaInfo->m_validFlags; - CXFA_FFNotify* pNotify = m_pDocument->GetNotify(); - if (!pNotify) { - return iRet; - } - if (validFlags == 1) { - iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType); - } else if (validFlags == 2) { - iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType, - FALSE, FALSE); - } else if (validFlags == 3) { - if (eType == XFA_Element::Subform) { - iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType, - FALSE, FALSE); - } - } else if (validFlags == 4) { - if (eType == XFA_Element::ExclGroup || eType == XFA_Element::Field) { - CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent); - if (pParentNode && - pParentNode->GetElementType() == XFA_Element::ExclGroup) { - iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType, - FALSE, FALSE); - } - iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType, - FALSE, FALSE); - } - } else if (validFlags == 5) { - if (eType == XFA_Element::Field) { - iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType, - FALSE, FALSE); - } - } else if (validFlags == 6) { - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (pWidgetData) { - CXFA_Node* pUINode = pWidgetData->GetUIChild(); - if (pUINode->m_elementType == XFA_Element::Signature) { - iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType, - FALSE, FALSE); - } - } - } else if (validFlags == 7) { - CXFA_WidgetData* pWidgetData = GetWidgetData(); - if (pWidgetData) { - CXFA_Node* pUINode = pWidgetData->GetUIChild(); - if ((pUINode->m_elementType == XFA_Element::ChoiceList) && - (!pWidgetData->IsListBox())) { - iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType, - FALSE, FALSE); - } - } - } - } - return iRet; -} -void CXFA_Node::UpdateNameHash() { - const XFA_NOTSUREATTRIBUTE* pNotsure = - XFA_GetNotsureAttribute(GetElementType(), XFA_ATTRIBUTE_Name); - CFX_WideStringC wsName; - if (!pNotsure || pNotsure->eType == XFA_ATTRIBUTETYPE_Cdata) { - wsName = GetCData(XFA_ATTRIBUTE_Name); - m_dwNameHash = FX_HashCode_GetW(wsName, false); - } else if (pNotsure->eType == XFA_ATTRIBUTETYPE_Enum) { - wsName = XFA_GetAttributeEnumByID(GetEnum(XFA_ATTRIBUTE_Name))->pName; - m_dwNameHash = FX_HashCode_GetW(wsName, false); - } -} -CFDE_XMLNode* CXFA_Node::CreateXMLMappingNode() { - if (!m_pXMLNode) { - CFX_WideString wsTag(GetCData(XFA_ATTRIBUTE_Name)); - m_pXMLNode = new CFDE_XMLElement(wsTag); - SetFlag(XFA_NodeFlag_OwnXMLNode, false); - } - return m_pXMLNode; -} -FX_BOOL CXFA_Node::IsNeedSavingXMLNode() { - return m_pXMLNode && (GetPacketID() == XFA_XDPPACKET_Datasets || - GetElementType() == XFA_Element::Xfa); -} - -XFA_MAPMODULEDATA* CXFA_Node::CreateMapModuleData() { - if (!m_pMapModuleData) - m_pMapModuleData = new XFA_MAPMODULEDATA; - return m_pMapModuleData; -} - -XFA_MAPMODULEDATA* CXFA_Node::GetMapModuleData() const { - return m_pMapModuleData; -} - -void CXFA_Node::SetMapModuleValue(void* pKey, void* pValue) { - XFA_MAPMODULEDATA* pModule = CreateMapModuleData(); - pModule->m_ValueMap.SetAt(pKey, pValue); -} - -FX_BOOL CXFA_Node::GetMapModuleValue(void* pKey, void*& pValue) { - CXFA_Node* pNode = this; - while (pNode) { - XFA_MAPMODULEDATA* pModule = pNode->GetMapModuleData(); - if (pModule && pModule->m_ValueMap.Lookup(pKey, pValue)) { - return TRUE; - } - pNode = pNode->GetPacketID() != XFA_XDPPACKET_Datasets - ? pNode->GetTemplateNode() - : nullptr; - } - return FALSE; -} -void CXFA_Node::SetMapModuleString(void* pKey, const CFX_WideStringC& wsValue) { - SetMapModuleBuffer(pKey, (void*)wsValue.c_str(), - wsValue.GetLength() * sizeof(FX_WCHAR)); -} -FX_BOOL CXFA_Node::GetMapModuleString(void* pKey, CFX_WideStringC& wsValue) { - void* pValue; - int32_t iBytes; - if (!GetMapModuleBuffer(pKey, pValue, iBytes)) { - return FALSE; - } - wsValue = CFX_WideStringC((const FX_WCHAR*)pValue, iBytes / sizeof(FX_WCHAR)); - return TRUE; -} -void CXFA_Node::SetMapModuleBuffer( - void* pKey, - void* pValue, - int32_t iBytes, - XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) { - XFA_MAPMODULEDATA* pModule = CreateMapModuleData(); - XFA_MAPDATABLOCK*& pBuffer = pModule->m_BufferMap[pKey]; - if (!pBuffer) { - pBuffer = - (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 = (XFA_MAPDATABLOCK*)FX_Realloc(uint8_t, pBuffer, - sizeof(XFA_MAPDATABLOCK) + iBytes); - } else if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) { - pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData()); - } - if (!pBuffer) - return; - - pBuffer->pCallbackInfo = pCallbackInfo; - pBuffer->iBytes = iBytes; - FXSYS_memcpy(pBuffer->GetData(), pValue, iBytes); -} -FX_BOOL CXFA_Node::GetMapModuleBuffer(void* pKey, - void*& pValue, - int32_t& iBytes, - FX_BOOL bProtoAlso) const { - XFA_MAPDATABLOCK* pBuffer = nullptr; - const CXFA_Node* pNode = this; - while (pNode) { - XFA_MAPMODULEDATA* pModule = pNode->GetMapModuleData(); - if (pModule && pModule->m_BufferMap.Lookup(pKey, pBuffer)) { - break; - } - pNode = (bProtoAlso && pNode->GetPacketID() != XFA_XDPPACKET_Datasets) - ? pNode->GetTemplateNode() - : nullptr; - } - if (!pBuffer) { - return FALSE; - } - pValue = pBuffer->GetData(); - iBytes = pBuffer->iBytes; - return TRUE; -} -FX_BOOL CXFA_Node::HasMapModuleKey(void* pKey, FX_BOOL bProtoAlso) { - CXFA_Node* pNode = this; - while (pNode) { - void* pVal; - XFA_MAPMODULEDATA* pModule = pNode->GetMapModuleData(); - if (pModule && - (pModule->m_ValueMap.Lookup(pKey, pVal) || - pModule->m_BufferMap.Lookup(pKey, (XFA_MAPDATABLOCK*&)pVal))) { - return TRUE; - } - pNode = (bProtoAlso && pNode->GetPacketID() != XFA_XDPPACKET_Datasets) - ? pNode->GetTemplateNode() - : nullptr; - } - return FALSE; -} -void CXFA_Node::RemoveMapModuleKey(void* pKey) { - XFA_MAPMODULEDATA* pModule = GetMapModuleData(); - if (!pModule) - return; - - if (pKey) { - XFA_MAPDATABLOCK* pBuffer = nullptr; - pModule->m_BufferMap.Lookup(pKey, pBuffer); - if (pBuffer) { - if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) { - pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData()); - } - FX_Free(pBuffer); - } - pModule->m_BufferMap.RemoveKey(pKey); - pModule->m_ValueMap.RemoveKey(pKey); - } else { - XFA_MAPDATABLOCK* pBuffer; - FX_POSITION posBuffer = pModule->m_BufferMap.GetStartPosition(); - while (posBuffer) { - pModule->m_BufferMap.GetNextAssoc(posBuffer, pKey, pBuffer); - if (pBuffer) { - if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) { - pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData()); - } - FX_Free(pBuffer); - } - } - pModule->m_BufferMap.RemoveAll(); - pModule->m_ValueMap.RemoveAll(); - delete pModule; - } -} -void CXFA_Node::MergeAllData(void* pDstModule, FX_BOOL bUseSrcAttr) { - XFA_MAPMODULEDATA* pDstModuleData = - static_cast(pDstModule)->CreateMapModuleData(); - XFA_MAPMODULEDATA* pSrcModuleData = GetMapModuleData(); - if (!pSrcModuleData) { - return; - } - FX_POSITION psValue = pSrcModuleData->m_ValueMap.GetStartPosition(); - while (psValue) { - void* pKey; - void* pValue; - pSrcModuleData->m_ValueMap.GetNextAssoc(psValue, pKey, pValue); - if (bUseSrcAttr || !pDstModuleData->m_ValueMap.GetValueAt(pKey)) { - pDstModuleData->m_ValueMap.SetAt(pKey, pValue); - } - } - FX_POSITION psBuffer = pSrcModuleData->m_BufferMap.GetStartPosition(); - while (psBuffer) { - void* pKey; - XFA_MAPDATABLOCK* pSrcBuffer; - pSrcModuleData->m_BufferMap.GetNextAssoc(psBuffer, pKey, pSrcBuffer); - XFA_MAPDATABLOCK*& pBuffer = pDstModuleData->m_BufferMap[pKey]; - if (pBuffer && !bUseSrcAttr) { - continue; - } - if (pSrcBuffer->pCallbackInfo && pSrcBuffer->pCallbackInfo->pFree && - !pSrcBuffer->pCallbackInfo->pCopy) { - if (pBuffer) { - pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData()); - pDstModuleData->m_BufferMap.RemoveKey(pKey); - } - continue; - } - if (!pBuffer) { - pBuffer = (XFA_MAPDATABLOCK*)FX_Alloc( - uint8_t, sizeof(XFA_MAPDATABLOCK) + pSrcBuffer->iBytes); - } else if (pBuffer->iBytes != pSrcBuffer->iBytes) { - if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) { - pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData()); - } - pBuffer = (XFA_MAPDATABLOCK*)FX_Realloc( - uint8_t, pBuffer, sizeof(XFA_MAPDATABLOCK) + pSrcBuffer->iBytes); - } else if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) { - pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData()); - } - if (!pBuffer) { - continue; - } - pBuffer->pCallbackInfo = pSrcBuffer->pCallbackInfo; - pBuffer->iBytes = pSrcBuffer->iBytes; - FXSYS_memcpy(pBuffer->GetData(), pSrcBuffer->GetData(), pSrcBuffer->iBytes); - if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pCopy) { - pBuffer->pCallbackInfo->pCopy(*(void**)pBuffer->GetData()); - } - } -} -void CXFA_Node::MoveBufferMapData(CXFA_Node* pDstModule, void* pKey) { - if (!pDstModule) { - return; - } - FX_BOOL bNeedMove = TRUE; - if (!pKey) { - bNeedMove = FALSE; - } - if (pDstModule->GetElementType() != GetElementType()) { - bNeedMove = FALSE; - } - XFA_MAPMODULEDATA* pSrcModuleData = nullptr; - XFA_MAPMODULEDATA* pDstModuleData = nullptr; - if (bNeedMove) { - pSrcModuleData = GetMapModuleData(); - if (!pSrcModuleData) { - bNeedMove = FALSE; - } - pDstModuleData = pDstModule->CreateMapModuleData(); - } - if (bNeedMove) { - void* pBufferBlockData = pSrcModuleData->m_BufferMap.GetValueAt(pKey); - if (pBufferBlockData) { - pSrcModuleData->m_BufferMap.RemoveKey(pKey); - pDstModuleData->m_BufferMap.RemoveKey(pKey); - pDstModuleData->m_BufferMap.SetAt(pKey, - (XFA_MAPDATABLOCK*)pBufferBlockData); - } - } - if (pDstModule->IsNodeV()) { - CFX_WideString wsValue = pDstModule->GetScriptContent(FALSE); - CFX_WideString wsFormatValue(wsValue); - CXFA_WidgetData* pWidgetData = pDstModule->GetContainerWidgetData(); - if (pWidgetData) { - pWidgetData->GetFormatDataValue(wsValue, wsFormatValue); - } - pDstModule->SetScriptContent(wsValue, wsFormatValue, true, TRUE); - } -} -void CXFA_Node::MoveBufferMapData(CXFA_Node* pSrcModule, - CXFA_Node* pDstModule, - void* pKey, - FX_BOOL bRecursive) { - if (!pSrcModule || !pDstModule || !pKey) { - return; - } - if (bRecursive) { - CXFA_Node* pSrcChild = pSrcModule->GetNodeItem(XFA_NODEITEM_FirstChild); - CXFA_Node* pDstChild = pDstModule->GetNodeItem(XFA_NODEITEM_FirstChild); - for (; pSrcChild && pDstChild; - pSrcChild = pSrcChild->GetNodeItem(XFA_NODEITEM_NextSibling), - pDstChild = pDstChild->GetNodeItem(XFA_NODEITEM_NextSibling)) { - MoveBufferMapData(pSrcChild, pDstChild, pKey, TRUE); - } - } - pSrcModule->MoveBufferMapData(pDstModule, pKey); -} - -CXFA_ThisProxy::CXFA_ThisProxy(CXFA_Node* pThisNode, CXFA_Node* pScriptNode) - : CXFA_Object(pThisNode->GetDocument(), - XFA_ObjectType::VariablesThis, - XFA_Element::Unknown, - CFX_WideStringC()), - m_pThisNode(nullptr), - m_pScriptNode(nullptr) { - m_pThisNode = pThisNode; - m_pScriptNode = pScriptNode; -} - -CXFA_ThisProxy::~CXFA_ThisProxy() {} - -CXFA_Node* CXFA_ThisProxy::GetThisNode() const { - return m_pThisNode; -} - -CXFA_Node* CXFA_ThisProxy::GetScriptNode() const { - return m_pScriptNode; -} - -CXFA_NodeList::CXFA_NodeList(CXFA_Document* pDocument) - : CXFA_Object(pDocument, - XFA_ObjectType::NodeList, - XFA_Element::NodeList, - CFX_WideStringC(L"nodeList")) { - m_pDocument->GetScriptContext()->AddToCacheList( - std::unique_ptr(this)); -} - -CXFA_NodeList::~CXFA_NodeList() {} - -CXFA_Node* CXFA_NodeList::NamedItem(const CFX_WideStringC& wsName) { - uint32_t dwHashCode = FX_HashCode_GetW(wsName, false); - int32_t iCount = GetLength(); - for (int32_t i = 0; i < iCount; i++) { - CXFA_Node* ret = Item(i); - if (dwHashCode == ret->GetNameHash()) - return ret; - } - return nullptr; -} -void CXFA_NodeList::Script_ListClass_Append(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 1) { - CXFA_Node* pNode = static_cast(pArguments->GetObject(0)); - if (pNode) { - Append(pNode); - } else { - ThrowException(XFA_IDS_ARGUMENT_MISMATCH); - } - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"append"); - } -} -void CXFA_NodeList::Script_ListClass_Insert(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 2) { - CXFA_Node* pNewNode = static_cast(pArguments->GetObject(0)); - CXFA_Node* pBeforeNode = static_cast(pArguments->GetObject(1)); - if (pNewNode) { - Insert(pNewNode, pBeforeNode); - } else { - ThrowException(XFA_IDS_ARGUMENT_MISMATCH); - } - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"insert"); - } -} -void CXFA_NodeList::Script_ListClass_Remove(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 1) { - CXFA_Node* pNode = static_cast(pArguments->GetObject(0)); - if (pNode) { - Remove(pNode); - } else { - ThrowException(XFA_IDS_ARGUMENT_MISMATCH); - } - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"remove"); - } -} -void CXFA_NodeList::Script_ListClass_Item(CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 1) { - int32_t iIndex = pArguments->GetInt32(0); - if ((iIndex >= 0) && (iIndex + 1 <= GetLength())) { - pArguments->GetReturnValue()->Assign( - m_pDocument->GetScriptContext()->GetJSValueFromMap(Item(iIndex))); - } else { - ThrowException(XFA_IDS_INDEX_OUT_OF_BOUNDS); - } - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"item"); - } -} -void CXFA_NodeList::Script_TreelistClass_NamedItem( - CFXJSE_Arguments* pArguments) { - int32_t argc = pArguments->GetLength(); - if (argc == 1) { - CFX_ByteString szName = pArguments->GetUTF8String(0); - CXFA_Node* pNode = - NamedItem(CFX_WideString::FromUTF8(szName.AsStringC()).AsStringC()); - if (!pNode) { - return; - } - pArguments->GetReturnValue()->Assign( - m_pDocument->GetScriptContext()->GetJSValueFromMap(pNode)); - } else { - ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"namedItem"); - } -} -void CXFA_NodeList::Script_ListClass_Length(CFXJSE_Value* pValue, - FX_BOOL bSetting, - XFA_ATTRIBUTE eAttribute) { - if (!bSetting) { - pValue->SetInteger(GetLength()); - } else { - ThrowException(XFA_IDS_INVAlID_PROP_SET); - } -} -CXFA_ArrayNodeList::CXFA_ArrayNodeList(CXFA_Document* pDocument) - : CXFA_NodeList(pDocument) {} - -CXFA_ArrayNodeList::~CXFA_ArrayNodeList() {} - -void CXFA_ArrayNodeList::SetArrayNodeList(const CXFA_NodeArray& srcArray) { - if (srcArray.GetSize() > 0) { - m_array.Copy(srcArray); - } -} -int32_t CXFA_ArrayNodeList::GetLength() { - return m_array.GetSize(); -} -FX_BOOL CXFA_ArrayNodeList::Append(CXFA_Node* pNode) { - m_array.Add(pNode); - return TRUE; -} -FX_BOOL CXFA_ArrayNodeList::Insert(CXFA_Node* pNewNode, - CXFA_Node* pBeforeNode) { - if (!pBeforeNode) { - m_array.Add(pNewNode); - } else { - int32_t iSize = m_array.GetSize(); - for (int32_t i = 0; i < iSize; ++i) { - if (m_array[i] == pBeforeNode) { - m_array.InsertAt(i, pNewNode); - break; - } - } - } - return TRUE; -} -FX_BOOL CXFA_ArrayNodeList::Remove(CXFA_Node* pNode) { - int32_t iSize = m_array.GetSize(); - for (int32_t i = 0; i < iSize; ++i) { - if (m_array[i] == pNode) { - m_array.RemoveAt(i); - break; - } - } - return TRUE; -} -CXFA_Node* CXFA_ArrayNodeList::Item(int32_t iIndex) { - int32_t iSize = m_array.GetSize(); - if (iIndex >= 0 && iIndex < iSize) { - return m_array[iIndex]; - } - return nullptr; -} -CXFA_AttachNodeList::CXFA_AttachNodeList(CXFA_Document* pDocument, - CXFA_Node* pAttachNode) - : CXFA_NodeList(pDocument) { - m_pAttachNode = pAttachNode; -} -int32_t CXFA_AttachNodeList::GetLength() { - return m_pAttachNode->CountChildren( - XFA_Element::Unknown, - m_pAttachNode->GetElementType() == XFA_Element::Subform); -} -FX_BOOL CXFA_AttachNodeList::Append(CXFA_Node* pNode) { - CXFA_Node* pParent = pNode->GetNodeItem(XFA_NODEITEM_Parent); - if (pParent) { - pParent->RemoveChild(pNode); - } - return m_pAttachNode->InsertChild(pNode); -} -FX_BOOL CXFA_AttachNodeList::Insert(CXFA_Node* pNewNode, - CXFA_Node* pBeforeNode) { - CXFA_Node* pParent = pNewNode->GetNodeItem(XFA_NODEITEM_Parent); - if (pParent) { - pParent->RemoveChild(pNewNode); - } - return m_pAttachNode->InsertChild(pNewNode, pBeforeNode); -} -FX_BOOL CXFA_AttachNodeList::Remove(CXFA_Node* pNode) { - return m_pAttachNode->RemoveChild(pNode); -} -CXFA_Node* CXFA_AttachNodeList::Item(int32_t iIndex) { - return m_pAttachNode->GetChild( - iIndex, XFA_Element::Unknown, - m_pAttachNode->GetElementType() == XFA_Element::Subform); -} -- cgit v1.2.3