summaryrefslogtreecommitdiff
path: root/xfa/fxfa/parser/cxfa_node.cpp
diff options
context:
space:
mode:
authordsinclair <dsinclair@chromium.org>2016-07-19 10:56:23 -0700
committerCommit bot <commit-bot@chromium.org>2016-07-19 10:56:24 -0700
commit5b36f0a0eff7f3666a0e642640db3c89e4bb6748 (patch)
tree1c9c719ea55062ac7bf36dbee7dfb9e9753471dc /xfa/fxfa/parser/cxfa_node.cpp
parenteea31b75a11215aa72a9845d47c38d2ce1edd4f7 (diff)
downloadpdfium-5b36f0a0eff7f3666a0e642640db3c89e4bb6748.tar.xz
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
Diffstat (limited to 'xfa/fxfa/parser/cxfa_node.cpp')
-rw-r--r--xfa/fxfa/parser/cxfa_node.cpp5172
1 files changed, 5172 insertions, 0 deletions
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 <map>
+#include <memory>
+
+#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<CFX_WideString*>(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<CXFA_NodeArray*>(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<int32_t>& rgIdxArray) {
+ int32_t iCount = pdfium::CollectionSize<int32_t>(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<CXFA_NodeSet, CXFA_NodeSet>;
+using CXFA_NodeSetPairMap =
+ std::map<uint32_t, std::unique_ptr<CXFA_NodeSetPair>>;
+using CXFA_NodeSetPairMapMap =
+ std::map<CXFA_Node*, std::unique_ptr<CXFA_NodeSetPairMap>>;
+
+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<int32_t> rgIdxArray1;
+ CFX_ArrayTemplate<int32_t> 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<CXFA_Node,
+ CXFA_TraverseStrategy_XFAContainerNode>
+ 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<CXFA_Node,
+ CXFA_TraverseStrategy_XFAContainerNode>
+ 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<CXFA_Node,
+ CXFA_TraverseStrategy_XFAContainerNode>
+ 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<CXFA_Node,
+ CXFA_TraverseStrategy_XFAContainerNode>
+ 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<CXFA_Node, CXFA_TraverseStrategy_XFAContainerNode>
+ 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<int32_t>(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<CXFA_Node*>(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<CXFA_Node*>(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<CXFA_Node*>(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<CXFA_Node*>(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<CFXJSE_Value> 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<CXFA_SimpleParser> 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<CFDE_XMLElement*>(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 = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\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<IFX_MemoryStream, ReleaseDeleter<IFX_MemoryStream>>
+ pMemoryStream(FX_CreateMemoryStream(TRUE));
+ std::unique_ptr<IFX_Stream, ReleaseDeleter<IFX_Stream>> pStream(
+ IFX_Stream::CreateStream(
+ static_cast<IFX_FileWrite*>(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<CXFA_Node*>(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<CXFA_Node*>(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<CFDE_XMLElement*>(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<CFDE_XMLElement*>(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<CFDE_XMLElement*>(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<CFDE_XMLElement*>(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<CFDE_XMLElement*>(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<CFDE_XMLElement*>(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<CFDE_XMLElement*>(m_pXMLNode)->DeleteChildren();
+ }
+ static_cast<CFDE_XMLElement*>(m_pXMLNode)->SetTextData(wsValue);
+ }
+ break;
+ case FDE_XMLNODE_Text:
+ static_cast<CFDE_XMLText*>(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<CFDE_XMLElement*>(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<CFDE_XMLElement*>(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<CFDE_XMLElement*>(m_pXMLNode)->DeleteChildren();
+ }
+ static_cast<CFDE_XMLElement*>(m_pXMLNode)->SetTextData(wsXMLValue);
+ }
+ break;
+ case FDE_XMLNODE_Text:
+ static_cast<CFDE_XMLText*>(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<CFDE_XMLElement*>(m_pXMLNode)
+ ->SetString(
+ pInfo->pName,
+ XFA_GetAttributeEnumByID((XFA_ATTRIBUTEENUM)(uintptr_t)pValue)
+ ->pName);
+ break;
+ case XFA_ATTRIBUTETYPE_Boolean:
+ static_cast<CFDE_XMLElement*>(m_pXMLNode)
+ ->SetString(pInfo->pName, pValue ? L"1" : L"0");
+ break;
+ case XFA_ATTRIBUTETYPE_Integer:
+ static_cast<CFDE_XMLElement*>(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<CFDE_XMLElement*>(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<CFDE_XMLElement*>(pXMLNode),
+ GetCData(XFA_ATTRIBUTE_QualifiedName), wsNamespace);
+ }
+ static_cast<CFDE_XMLElement*>(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<CFDE_XMLElement*>(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<CXFA_Node*>(this));
+}
+
+int32_t CXFA_Node::GetNodeSameClassIndex() const {
+ CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
+ if (!pScriptContext) {
+ return -1;
+ }
+ return pScriptContext->GetIndexByClassName(const_cast<CXFA_Node*>(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<CXFA_Node*>(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);
+}