diff options
Diffstat (limited to 'xfa/src/fxfa/src/parser/xfa_object_imp.cpp')
| -rw-r--r-- | xfa/src/fxfa/src/parser/xfa_object_imp.cpp | 5125 |
1 files changed, 5125 insertions, 0 deletions
diff --git a/xfa/src/fxfa/src/parser/xfa_object_imp.cpp b/xfa/src/fxfa/src/parser/xfa_object_imp.cpp new file mode 100644 index 0000000000..54f29a5c94 --- /dev/null +++ b/xfa/src/fxfa/src/parser/xfa_object_imp.cpp @@ -0,0 +1,5125 @@ +// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#include "../../../foxitlib.h"
+#include "../common/xfa_utils.h"
+#include "../common/xfa_object.h"
+#include "../common/xfa_document.h"
+#include "../common/xfa_parser.h"
+#include "../common/xfa_script.h"
+#include "../common/xfa_docdata.h"
+#include "../common/xfa_doclayout.h"
+#include "../common/xfa_debug.h"
+#include "../common/xfa_localemgr.h"
+#include "../common/xfa_fm2jsapi.h"
+#include "xfa_debug_parser.h"
+#include "xfa_basic_imp.h"
+#include "xfa_document_layout_imp.h"
+CXFA_Object::CXFA_Object(CXFA_Document* pDocument, FX_DWORD uFlags)
+ : m_pDocument(pDocument)
+ , m_uFlags(uFlags)
+{
+}
+void CXFA_Object::GetClassName(CFX_WideStringC &wsName) const
+{
+ XFA_LPCELEMENTINFO pElement = XFA_GetElementByID(GetClassID());
+ ASSERT(pElement != NULL);
+ wsName = pElement->pName;
+}
+FX_UINT32 CXFA_Object::GetClassHashCode() const
+{
+ XFA_LPCELEMENTINFO pElement = XFA_GetElementByID(GetClassID());
+ ASSERT(pElement != NULL);
+ return pElement->uHash;
+}
+XFA_ELEMENT CXFA_Object::GetClassID() const
+{
+ if (IsNode()) {
+ return ((const CXFA_Node*)this)->GetClassID();
+ } else if(IsOrdinaryObject()) {
+ return ((const CXFA_OrdinaryObject*)this)->GetClassID();
+ } else if(IsNodeList()) {
+ return ((const CXFA_NodeList*)this)->GetClassID();
+ } else if(IsOrdinaryList()) {
+ return XFA_ELEMENT_List;
+ }
+ ASSERT(FALSE);
+ return (XFA_ELEMENT)0;
+}
+void CXFA_Object::Script_ObjectClass_ClassName(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (!bSetting) {
+ CFX_WideStringC className;
+ GetClassName(className);
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(className.GetPtr(), className.GetLength()));
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ }
+}
+void CXFA_Object::ThrowScriptErrorMessage(FX_INT32 iStringID, ...)
+{
+ IXFA_AppProvider* pAppProvider = m_pDocument->GetNotify()->GetAppProvider();
+ FXSYS_assert(pAppProvider);
+ CFX_WideString wsFormat;
+ pAppProvider->LoadString(iStringID, wsFormat);
+ CFX_WideString wsMessage;
+ va_list arg_ptr;
+ va_start(arg_ptr, iStringID);
+ wsMessage.FormatV((FX_LPCWSTR)wsFormat, arg_ptr);
+ va_end(arg_ptr);
+ FXJSE_ThrowMessage(FX_BSTRC(""), FX_UTF8Encode(wsMessage, wsMessage.GetLength()));
+}
+static void XFA_DeleteWideString(FX_LPVOID pData)
+{
+ if (pData) {
+ delete (CFX_WideString*)pData;
+ }
+}
+static void XFA_CopyWideString(FX_LPVOID& pData)
+{
+ if (pData) {
+ CFX_WideString* pNewData = FX_NEW CFX_WideString(*(CFX_WideString*)pData);
+ pData = pNewData;
+ }
+}
+static XFA_MAPDATABLOCKCALLBACKINFO deleteWideStringCallBack = {XFA_DeleteWideString, XFA_CopyWideString};
+static XFA_OBJECTTYPE XFA_GetElementObjectType(XFA_ELEMENT eElement)
+{
+ XFA_LPCELEMENTINFO pElement = XFA_GetElementByID(eElement);
+ ASSERT(pElement != NULL);
+ return (XFA_OBJECTTYPE)pElement->eObjectType;
+}
+CXFA_Node::CXFA_Node(CXFA_Document *pDoc, FX_WORD ePacket, XFA_ELEMENT eElement)
+ : CXFA_Object(pDoc, XFA_GetElementObjectType(eElement))
+ , m_pParent(NULL)
+ , m_pNext(NULL)
+ , m_pChild(NULL)
+ , m_pLastChild(NULL)
+ , m_pXMLNode(NULL)
+ , m_ePacket(ePacket)
+ , m_eNodeClass(eElement)
+ , m_dwNameHash(0)
+ , m_pAuxNode(NULL)
+ , m_pMapModuleData(NULL)
+{
+ ASSERT(m_pDocument != NULL);
+}
+CXFA_Node::~CXFA_Node()
+{
+ FXSYS_assert(m_pParent == NULL);
+ RemoveMapModuleKey();
+ CXFA_Node *pNext, *pNode = m_pChild;
+ while (pNode) {
+ pNext = pNode->m_pNext;
+ pNode->m_pParent = NULL;
+ delete pNode;
+ pNode = pNext;
+ }
+ if (m_pXMLNode && HasFlag(XFA_NODEFLAG_OwnXMLNode)) {
+ m_pXMLNode->Release();
+ }
+}
+CXFA_Node* CXFA_Node::Clone(FX_BOOL bRecursive)
+{
+ IXFA_ObjFactory *pFactory = m_pDocument->GetParser()->GetFactory();
+ CXFA_Node *pClone = pFactory->CreateNode(m_ePacket, m_eNodeClass);
+ if(!pClone) {
+ return NULL;
+ }
+ MergeAllData(pClone);
+ pClone->UpdateNameHash();
+ if (IsNeedSavingXMLNode()) {
+ IFDE_XMLNode* pCloneXML = NULL;
+ if (IsAttributeInXML()) {
+ CFX_WideString wsName;
+ this->GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE);
+ IFDE_XMLElement* pCloneXMLElement = IFDE_XMLElement::Create(wsName);
+ CFX_WideStringC wsValue = this->GetCData(XFA_ATTRIBUTE_Value);
+ if (!wsValue.IsEmpty()) {
+ pCloneXMLElement->SetTextData(wsValue);
+ }
+ pCloneXML = pCloneXMLElement;
+ pCloneXMLElement = NULL;
+ pClone->SetEnum(XFA_ATTRIBUTE_Contains, XFA_ATTRIBUTEENUM_Unknown);
+ } else {
+ pCloneXML = m_pXMLNode->Clone(FALSE);
+ }
+ pClone->SetXMLMappingNode(pCloneXML);
+ pClone->SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, 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);
+ pClone->SetObject(XFA_ATTRIBUTE_BindingNode, NULL);
+ 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 = NULL;
+ while (pSibling && pSibling != this) {
+ pPrev = pSibling;
+ pSibling = pSibling->m_pNext;
+ }
+ return pPrev;
+ }
+ return NULL;
+ default:
+ break;
+ }
+ return NULL;
+}
+CXFA_Node* CXFA_Node::GetNodeItem(XFA_NODEITEM eItem, XFA_OBJECTTYPE eType) const
+{
+ CXFA_Node *pNode = NULL;
+ switch (eItem) {
+ case XFA_NODEITEM_NextSibling:
+ pNode = m_pNext;
+ if (eType != XFA_OBJECTTYPEMASK)
+ while (pNode && pNode->GetObjectType() != eType) {
+ pNode = pNode->m_pNext;
+ }
+ break;
+ case XFA_NODEITEM_FirstChild:
+ pNode = m_pChild;
+ if (eType != XFA_OBJECTTYPEMASK)
+ while (pNode && pNode->GetObjectType() != eType) {
+ pNode = pNode->m_pNext;
+ }
+ break;
+ case XFA_NODEITEM_Parent:
+ pNode = m_pParent;
+ if (eType != XFA_OBJECTTYPEMASK)
+ 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 == XFA_OBJECTTYPEMASK || eType == pSibling->GetObjectType()) {
+ pNode = pSibling;
+ }
+ pSibling = pSibling->m_pNext;
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ return pNode;
+}
+FX_INT32 CXFA_Node::GetNodeList(CXFA_NodeArray &nodes, FX_DWORD dwTypeFilter , XFA_ELEMENT eElementFilter , FX_INT32 iLevel )
+{
+ if (--iLevel < 0) {
+ return nodes.GetSize();
+ }
+ if (eElementFilter != XFA_ELEMENT_UNKNOWN) {
+ CXFA_Node *pChild = m_pChild;
+ while (pChild) {
+ if (pChild->GetClassID() == eElementFilter) {
+ nodes.Add(pChild);
+ if (iLevel > 0) {
+ GetNodeList(nodes, dwTypeFilter, eElementFilter, 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, eElementFilter, iLevel);
+ }
+ pChild = pChild->m_pNext;
+ }
+ } else if (dwTypeFilter != 0) {
+ FX_BOOL bFilterChildren = (dwTypeFilter & XFA_NODEFILTER_Children) != 0;
+ FX_BOOL bFilterProperties = (dwTypeFilter & XFA_NODEFILTER_Properties) != 0;
+ FX_BOOL bFilterOneOfProperties = (dwTypeFilter & XFA_NODEFILTER_OneOfProperty) != 0;
+ CXFA_Node *pChild = m_pChild;
+ while (pChild) {
+ XFA_LPCPROPERTY pPropert = XFA_GetPropertyOfElement(GetClassID(), pChild->GetClassID(), XFA_XDPPACKET_UNKNOWN);
+ if (pPropert) {
+ if (bFilterProperties) {
+ nodes.Add(pChild);
+ } else if (bFilterOneOfProperties && (pPropert->uFlags & XFA_PROPERTYFLAG_OneOf)) {
+ nodes.Add(pChild);
+ } else if(bFilterChildren && (pChild->GetClassID() == XFA_ELEMENT_Variables || pChild->GetClassID() == XFA_ELEMENT_PageSet)) {
+ nodes.Add(pChild);
+ }
+ } else {
+ if (bFilterChildren) {
+ nodes.Add(pChild);
+ }
+ }
+ pChild = pChild->m_pNext;
+ }
+ if (bFilterOneOfProperties && nodes.GetSize() < 1) {
+ FX_INT32 iProperties = 0;
+ XFA_LPCPROPERTY pProperty = XFA_GetElementProperties(GetClassID(), iProperties);
+ if (pProperty == NULL || iProperties < 1) {
+ return 0;
+ }
+ for (FX_INT32 i = 0; i < iProperties; i++) {
+ if (pProperty[i].uFlags & XFA_PROPERTYFLAG_DefaultOneOf) {
+ IXFA_ObjFactory *pFactory = m_pDocument->GetParser()->GetFactory();
+ XFA_LPCPACKETINFO pPacket = XFA_GetPacketByID(GetPacketID());
+ CXFA_Node* pNewNode = pFactory->CreateNode(pPacket, (XFA_ELEMENT)pProperty[i].eName);
+ if(!pNewNode) {
+ break;
+ }
+ InsertChild(pNewNode, NULL);
+ pNewNode->SetFlag(XFA_NODEFLAG_Initialized);
+ nodes.Add(pNewNode);
+ break;
+ }
+ }
+ }
+ }
+ return nodes.GetSize();
+}
+CXFA_Node* CXFA_Node::CreateSamePacketNode(XFA_ELEMENT eElement, FX_DWORD dwFlags)
+{
+ IXFA_ObjFactory *pFactory = m_pDocument->GetParser()->GetFactory();
+ CXFA_Node* pNode = pFactory->CreateNode(m_ePacket, eElement);
+ pNode->SetFlag(dwFlags);
+ return pNode;
+}
+CXFA_Node* CXFA_Node::CloneTemplateToForm(FX_BOOL bRecursive)
+{
+ FXSYS_assert(m_ePacket == XFA_XDPPACKET_Template);
+ IXFA_ObjFactory *pFactory = m_pDocument->GetParser()->GetFactory();
+ CXFA_Node *pClone = pFactory->CreateNode(XFA_XDPPACKET_Form, m_eNodeClass);
+ if(!pClone) {
+ return NULL;
+ }
+ 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);
+ return pClone;
+}
+CXFA_Node* CXFA_Node::GetTemplateNode()
+{
+ return m_pAuxNode;
+}
+void CXFA_Node::SetTemplateNode(CXFA_Node* pTemplateNode)
+{
+ m_pAuxNode = pTemplateNode;
+}
+CXFA_Node* CXFA_Node::GetBindData()
+{
+ ASSERT(GetPacketID() == XFA_XDPPACKET_Form);
+ return (CXFA_Node*)GetObject(XFA_ATTRIBUTE_BindingNode);
+}
+FX_INT32 CXFA_Node::GetBindItems(CXFA_NodeArray& formItems)
+{
+ if (m_uFlags & XFA_NODEFLAG_BindFormItems) {
+ CXFA_NodeArray* pItems = NULL;
+ TryObject(XFA_ATTRIBUTE_BindingNode, (FX_LPVOID&)pItems);
+ formItems.Copy(*pItems);
+ return formItems.GetSize();
+ }
+ CXFA_Node* pFormNode = (CXFA_Node*)GetObject(XFA_ATTRIBUTE_BindingNode);
+ if (pFormNode) {
+ formItems.Add(pFormNode);
+ }
+ return formItems.GetSize();
+}
+static void XFA_DataNodeDeleteBindItem(FX_LPVOID pData)
+{
+ if (pData) {
+ delete ((CXFA_NodeArray*)pData);
+ }
+}
+static XFA_MAPDATABLOCKCALLBACKINFO deleteBindItemCallBack = {XFA_DataNodeDeleteBindItem, NULL};
+FX_INT32 CXFA_Node::AddBindItem(CXFA_Node* pFormNode)
+{
+ ASSERT(pFormNode);
+ if (m_uFlags & XFA_NODEFLAG_BindFormItems) {
+ CXFA_NodeArray* pItems = NULL;
+ TryObject(XFA_ATTRIBUTE_BindingNode, (FX_LPVOID&)pItems);
+ ASSERT(pItems);
+ if (pItems->Find(pFormNode) < 0) {
+ pItems->Add(pFormNode);
+ }
+ return pItems->GetSize();
+ }
+ CXFA_Node* pOldFormItem = (CXFA_Node*)GetObject(XFA_ATTRIBUTE_BindingNode);
+ if (!pOldFormItem) {
+ SetObject(XFA_ATTRIBUTE_BindingNode, pFormNode);
+ return 1;
+ } else if (pOldFormItem == pFormNode) {
+ return 1;
+ }
+ CXFA_NodeArray* pItems = FX_NEW CXFA_NodeArray;
+ SetObject(XFA_ATTRIBUTE_BindingNode, pItems, &deleteBindItemCallBack);
+ pItems->Add(pOldFormItem);
+ pItems->Add(pFormNode);
+ m_uFlags |= XFA_NODEFLAG_BindFormItems;
+ return 2;
+}
+FX_INT32 CXFA_Node::RemoveBindItem(CXFA_Node* pFormNode)
+{
+ if (m_uFlags & XFA_NODEFLAG_BindFormItems) {
+ CXFA_NodeArray* pItems = NULL;
+ TryObject(XFA_ATTRIBUTE_BindingNode, (FX_LPVOID&)pItems);
+ ASSERT(pItems);
+ FX_INT32 iIndex = pItems->Find(pFormNode);
+ FX_INT32 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_uFlags &= ~XFA_NODEFLAG_BindFormItems;
+ }
+ iCount--;
+ }
+ return iCount;
+ }
+ CXFA_Node* pOldFormItem = (CXFA_Node*)GetObject(XFA_ATTRIBUTE_BindingNode);
+ if(pOldFormItem == pFormNode) {
+ SetObject(XFA_ATTRIBUTE_BindingNode, NULL);
+ pOldFormItem = NULL;
+ }
+ return pOldFormItem == NULL ? 0 : 1;
+}
+FX_BOOL CXFA_Node::HasBindItem()
+{
+ return (GetPacketID() == XFA_XDPPACKET_Datasets) && GetObject(XFA_ATTRIBUTE_BindingNode) != NULL;
+}
+CXFA_WidgetData* CXFA_Node::GetWidgetData()
+{
+ return (CXFA_WidgetData*)GetObject(XFA_ATTRIBUTE_WidgetData);
+}
+CXFA_WidgetData* CXFA_Node::GetContainerWidgetData()
+{
+ if (GetPacketID() != XFA_XDPPACKET_Form) {
+ return NULL;
+ }
+ XFA_ELEMENT classID = GetClassID();
+ if (classID == XFA_ELEMENT_ExclGroup) {
+ return NULL;
+ }
+ CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
+ if (pParentNode && pParentNode->GetClassID() == XFA_ELEMENT_ExclGroup) {
+ return NULL;
+ }
+ if (classID == XFA_ELEMENT_Field) {
+ CXFA_WidgetData* pFieldWidgetData = this->GetWidgetData();
+ if (pFieldWidgetData && pFieldWidgetData->GetChoiceListOpen() == XFA_ATTRIBUTEENUM_MultiSelect) {
+ return NULL;
+ } else {
+ CFX_WideString wsPicture;
+ if (pFieldWidgetData) {
+ pFieldWidgetData->GetPictureContent(wsPicture, XFA_VALUEPICTURE_DataBind);
+ }
+ if (!wsPicture.IsEmpty()) {
+ return pFieldWidgetData;
+ }
+ CXFA_Node* pDataNode = this->GetBindData();
+ if (!pDataNode) {
+ return NULL;
+ }
+ pFieldWidgetData = NULL;
+ CXFA_NodeArray formNodes;
+ pDataNode->GetBindItems(formNodes);
+ for (FX_INT32 i = 0; i < formNodes.GetSize(); i++) {
+ CXFA_Node* pFormNode = formNodes.GetAt(i);
+ if (!pFormNode || pFormNode->HasFlag(XFA_NODEFLAG_HasRemoved)) {
+ continue;
+ }
+ pFieldWidgetData = pFormNode->GetWidgetData();
+ if (pFieldWidgetData) {
+ pFieldWidgetData->GetPictureContent(wsPicture, XFA_VALUEPICTURE_DataBind);
+ }
+ if (!wsPicture.IsEmpty()) {
+ break;
+ }
+ pFieldWidgetData = NULL;
+ }
+ return pFieldWidgetData;
+ }
+ }
+ CXFA_Node* pGrandNode = pParentNode ? pParentNode->GetNodeItem(XFA_NODEITEM_Parent) : NULL;
+ CXFA_Node* pValueNode = (pParentNode && pParentNode->GetClassID() == XFA_ELEMENT_Value) ? pParentNode : NULL;
+ if (!pValueNode) {
+ pValueNode = (pGrandNode && pGrandNode->GetClassID() == XFA_ELEMENT_Value) ? pGrandNode : NULL;
+ }
+ CXFA_Node* pParentOfValueNode = pValueNode ? pValueNode->GetNodeItem(XFA_NODEITEM_Parent) : NULL;
+ return pParentOfValueNode ? pParentOfValueNode->GetContainerWidgetData() : NULL;
+}
+FX_BOOL CXFA_Node::GetLocaleName(CFX_WideString& wsLocaleName)
+{
+ CXFA_Node* pForm = (CXFA_Node*)GetDocument()->GetXFANode(XFA_HASHCODE_Form);
+ CXFA_Node* pTopSubform = pForm->GetFirstChildByClass(XFA_ELEMENT_Subform);
+ FXSYS_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 bLocale;
+ }
+ CXFA_Node* pConfig = (CXFA_Node*)GetDocument()->GetXFANode(XFA_HASHCODE_Config);
+ wsLocaleName = GetDocument()->GetLocalMgr()->GetConfigLocaleName(pConfig);
+ if (!wsLocaleName.IsEmpty()) {
+ bLocale = TRUE;
+ }
+ if (bLocale) {
+ return bLocale;
+ }
+ if (pTopSubform) {
+ bLocale = pTopSubform->TryCData(XFA_ATTRIBUTE_Locale, wsLocaleName, FALSE);
+ }
+ if (bLocale) {
+ return bLocale;
+ }
+ IFX_Locale* pLocale = GetDocument()->GetLocalMgr()->GetDefLocale();
+ if (pLocale) {
+ wsLocaleName = pLocale->GetName();
+ bLocale = TRUE;
+ }
+ return bLocale;
+}
+XFA_ATTRIBUTEENUM CXFA_Node::GetIntact()
+{
+ XFA_ELEMENT eElement = GetClassID();
+ 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)) {
+ if(eValue == XFA_ATTRIBUTEENUM_ContentArea || eValue == XFA_ATTRIBUTEENUM_PageArea) {
+ return XFA_ATTRIBUTEENUM_ContentArea;
+ }
+ }
+ CXFA_Node* pKeep = pPreviewRow->GetFirstChildByClass(XFA_ELEMENT_Keep);
+ if (pKeep) {
+ if (pKeep->TryEnum(XFA_ATTRIBUTE_Next, eValue, FALSE)) {
+ if(eValue == XFA_ATTRIBUTEENUM_ContentArea || eValue == XFA_ATTRIBUTEENUM_PageArea) {
+ return XFA_ATTRIBUTEENUM_ContentArea;
+ }
+ }
+ }
+ }
+ }
+ return eIntact;
+ }
+ }
+ switch (eElement) {
+ 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 = this->GetNodeItem(XFA_NODEITEM_Parent);
+ if (!pParentNode || pParentNode->GetClassID() == 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 (this->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 NULL;
+}
+void CXFA_Node::SetDataDescriptionNode(CXFA_Node* pDataDescriptionNode)
+{
+ FXSYS_assert(m_ePacket == XFA_XDPPACKET_Datasets);
+ m_pAuxNode = pDataDescriptionNode;
+}
+void CXFA_Node::Script_TreeClass_ResolveNode(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 iLength = pArguments->GetLength();
+ if (iLength != 1) {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"resolveNode"));
+ return;
+ }
+ CFX_WideString wsExpression;
+ CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
+ wsExpression = CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
+ IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
+ if (!pScriptContext) {
+ return;
+ }
+ CXFA_Node* refNode = this;
+ if(refNode->GetClassID() == XFA_ELEMENT_Xfa) {
+ refNode = (CXFA_Node*)pScriptContext->GetThisObject();
+ }
+ FX_DWORD dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes | XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings;
+ XFA_RESOLVENODE_RS resoveNodeRS;
+ FX_INT32 iRet = pScriptContext->ResolveObjects(refNode, wsExpression, resoveNodeRS, dwFlag);
+ if (iRet < 1) {
+ return FXJSE_Value_SetNull(pArguments->GetReturnValue());
+ }
+ FXJSE_HVALUE hValue = NULL;
+ if (resoveNodeRS.dwFlags == XFA_RESOVENODE_RSTYPE_Nodes) {
+ CXFA_Object* pNode = resoveNodeRS.nodes[0];
+ hValue = pScriptContext->GetJSValueFromMap(pNode);
+ FXJSE_Value_Set(pArguments->GetReturnValue(), hValue);
+ } else {
+ XFA_LPCSCRIPTATTRIBUTEINFO lpAttributeInfo = resoveNodeRS.pScriptAttribute;
+ if (lpAttributeInfo && lpAttributeInfo->eValueType == XFA_SCRIPT_Object) {
+ hValue = FXJSE_Value_Create(pScriptContext->GetRuntime());
+ (resoveNodeRS.nodes[0]->*(lpAttributeInfo->lpfnCallback))(hValue, FALSE, (XFA_ATTRIBUTE)lpAttributeInfo->eAttribute);
+ FXJSE_Value_Set(pArguments->GetReturnValue(), hValue);
+ FXJSE_Value_Release(hValue);
+ } else {
+ FXJSE_Value_SetNull(pArguments->GetReturnValue());
+ }
+ }
+}
+void CXFA_Node::Script_TreeClass_ResolveNodes(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 iLength = pArguments->GetLength();
+ if (iLength != 1) {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"resolveNodes"));
+ return;
+ }
+ CFX_WideString wsExpression;
+ CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
+ wsExpression = CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
+ FXJSE_HVALUE hValue = pArguments->GetReturnValue();
+ if (!hValue) {
+ return;
+ }
+ FX_DWORD dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes | XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings;
+ CXFA_Node* refNode = this;
+ if(refNode->GetClassID() == XFA_ELEMENT_Xfa) {
+ refNode = (CXFA_Node*)m_pDocument->GetScriptContext()->GetThisObject();
+ }
+ Script_Som_ResolveNodeList(hValue, wsExpression, dwFlag, refNode);
+}
+void CXFA_Node::Script_Som_ResolveNodeList(FXJSE_HVALUE hValue, CFX_WideString wsExpression, FX_DWORD dwFlag, CXFA_Node* refNode)
+{
+ IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
+ if (!pScriptContext) {
+ return;
+ }
+ XFA_RESOLVENODE_RS resoveNodeRS;
+ if(refNode == NULL) {
+ refNode = this;
+ }
+ FX_INT32 iRet = pScriptContext->ResolveObjects(refNode, wsExpression, resoveNodeRS, dwFlag);
+ CXFA_ArrayNodeList* pNodeList = FX_NEW CXFA_ArrayNodeList(m_pDocument);
+ if (resoveNodeRS.dwFlags == XFA_RESOVENODE_RSTYPE_Nodes) {
+ for (FX_INT32 i = 0; i < resoveNodeRS.nodes.GetSize(); i++) {
+ if (resoveNodeRS.nodes[i]->IsNode()) {
+ pNodeList->Append((CXFA_Node*)resoveNodeRS.nodes[i]);
+ }
+ }
+ } else {
+ CXFA_HVALUEArray hValueArray(pScriptContext->GetRuntime());
+ if (resoveNodeRS.GetAttributeResult(hValueArray) > 0) {
+ CXFA_ObjArray objectArray;
+ hValueArray.GetAttributeObject(objectArray);
+ for (FX_INT32 i = 0; i < objectArray.GetSize(); i++) {
+ if (objectArray[i]->IsNode()) {
+ pNodeList->Append((CXFA_Node*)objectArray[i]);
+ }
+ }
+ }
+ }
+ FXJSE_Value_SetObject(hValue, (CXFA_Object*)pNodeList, pScriptContext->GetJseNormalClass());
+}
+void CXFA_Node::Script_TreeClass_All(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ } else {
+ FX_DWORD 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(hValue, wsExpression, dwFlag);
+ }
+}
+void CXFA_Node::Script_TreeClass_Nodes(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
+ if (!pScriptContext) {
+ return;
+ }
+ if (bSetting) {
+ IXFA_AppProvider* pAppProvider = m_pDocument->GetNotify()->GetAppProvider();
+ FXSYS_assert(pAppProvider);
+ CFX_WideString wsMessage;
+ pAppProvider->LoadString(XFA_IDS_Unable_TO_SET, wsMessage);
+ FXJSE_ThrowMessage(FX_BSTRC(""), FX_UTF8Encode(wsMessage, wsMessage.GetLength()));
+ } else {
+ CXFA_AttachNodeList* pNodeList = FX_NEW CXFA_AttachNodeList(m_pDocument, this);
+ FXJSE_Value_SetObject(hValue, (CXFA_Object*)pNodeList, pScriptContext->GetJseNormalClass());
+ }
+}
+void CXFA_Node::Script_TreeClass_ClassAll(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ } else {
+ FX_DWORD dwFlag = XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_ALL;
+ CFX_WideStringC wsName;
+ this->GetClassName(wsName);
+ CFX_WideString wsExpression = FX_WSTRC(L"#") + wsName + FX_WSTRC(L"[*]");
+ Script_Som_ResolveNodeList(hValue, wsExpression, dwFlag);
+ }
+}
+void CXFA_Node::Script_TreeClass_Parent(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ } else {
+ CXFA_Node* pParent = this->GetNodeItem(XFA_NODEITEM_Parent);
+ if (pParent) {
+ FXJSE_Value_Set(hValue, m_pDocument->GetScriptContext()->GetJSValueFromMap(pParent));
+ } else {
+ FXJSE_Value_SetNull(hValue);
+ }
+ }
+}
+void CXFA_Node::Script_TreeClass_Index(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ } else {
+ FXJSE_Value_SetInteger(hValue, GetNodeSameNameIndex());
+ }
+}
+void CXFA_Node::Script_TreeClass_ClassIndex(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ } else {
+ FXJSE_Value_SetInteger(hValue, GetNodeSameClassIndex());
+ }
+}
+void CXFA_Node::Script_TreeClass_SomExpression(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ } else {
+ CFX_WideString wsSOMExpression;
+ GetSOMExpression(wsSOMExpression);
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsSOMExpression));
+ }
+}
+void CXFA_Node::Script_NodeClass_ApplyXSL(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 iLength = pArguments->GetLength();
+ if (iLength != 1) {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"applyXSL"));
+ return;
+ }
+ CFX_WideString wsExpression;
+ CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
+ wsExpression = CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
+}
+void CXFA_Node::Script_NodeClass_AssignNode(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 iLength = pArguments->GetLength();
+ if (iLength < 1 || iLength > 3) {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"assignNode"));
+ return;
+ }
+ CFX_WideString wsExpression;
+ CFX_WideString wsValue;
+ FX_INT32 iAction = 0;
+ if (iLength >= 1) {
+ CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
+ wsExpression = CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
+ }
+ if (iLength >= 2) {
+ CFX_ByteString bsValue = pArguments->GetUTF8String(1);
+ wsValue = CFX_WideString::FromUTF8(bsValue, bsValue.GetLength());
+ }
+ if (iLength >= 3) {
+ iAction = pArguments->GetInt32(2);
+ }
+}
+void CXFA_Node::Script_NodeClass_Clone(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 iLength = pArguments->GetLength();
+ if (iLength != 1) {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"clone"));
+ return;
+ }
+ FX_BOOL bClone = TRUE;
+ bClone = pArguments->GetInt32(0) == 0 ? FALSE : TRUE;
+ CXFA_Node* pCloneNode = this->Clone(bClone);
+ FXJSE_Value_Set(pArguments->GetReturnValue(), m_pDocument->GetScriptContext()->GetJSValueFromMap(pCloneNode));
+}
+void CXFA_Node::Script_NodeClass_GetAttribute(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 iLength = pArguments->GetLength();
+ if (iLength != 1) {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"getAttribute"));
+ return;
+ }
+ CFX_WideString wsExpression;
+ CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
+ wsExpression = CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
+ CFX_WideString wsValue;
+ this->GetAttribute(wsExpression, wsValue);
+ FXJSE_HVALUE hValue = pArguments->GetReturnValue();
+ if (hValue) {
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue));
+ }
+}
+void CXFA_Node::Script_NodeClass_GetElement(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 iLength = pArguments->GetLength();
+ if (iLength < 1 || iLength > 2) {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"getElement"));
+ return;
+ }
+ CFX_WideString wsExpression;
+ FX_INT32 iValue = 0;
+ if (iLength >= 1) {
+ CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
+ wsExpression = CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
+ }
+ if (iLength >= 2) {
+ iValue = pArguments->GetInt32(1);
+ }
+ XFA_LPCELEMENTINFO pElementInfo = XFA_GetElementByName(wsExpression);
+ CXFA_Node* pNode = this->GetProperty(iValue, pElementInfo->eName);
+ FXJSE_Value_Set(pArguments->GetReturnValue(), m_pDocument->GetScriptContext()->GetJSValueFromMap(pNode));
+}
+void CXFA_Node::Script_NodeClass_IsPropertySpecified(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 iLength = pArguments->GetLength();
+ if (iLength < 1 || iLength > 3) {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"isPropertySpecified"));
+ return;
+ }
+ CFX_WideString wsExpression;
+ FX_BOOL bParent = TRUE;
+ FX_INT32 iIndex = 0;
+ if (iLength >= 1) {
+ CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
+ wsExpression = CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
+ }
+ if (iLength >= 2) {
+ bParent = pArguments->GetInt32(1) == 0 ? FALSE : TRUE;
+ }
+ if (iLength >= 3) {
+ iIndex = pArguments->GetInt32(2);
+ }
+ FX_BOOL bHas = FALSE;
+ XFA_LPCATTRIBUTEINFO pAttributeInfo = XFA_GetAttributeByName(wsExpression);
+ CFX_WideString wsValue;
+ if(pAttributeInfo) {
+ bHas = this->HasAttribute(pAttributeInfo->eName);
+ }
+ if (!bHas) {
+ XFA_LPCELEMENTINFO pElementInfo = XFA_GetElementByName(wsExpression);
+ bHas = (this->GetProperty(iIndex, pElementInfo->eName) != NULL);
+ }
+ FXJSE_HVALUE hValue = pArguments->GetReturnValue();
+ if (hValue) {
+ FXJSE_Value_SetBoolean(hValue, bHas);
+ }
+}
+void CXFA_Node::Script_NodeClass_LoadXML(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 iLength = pArguments->GetLength();
+ if (iLength < 1 || iLength > 3) {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"loadXML"));
+ return;
+ }
+ CFX_WideString wsExpression;
+ FX_BOOL bIgnoreRoot = TRUE;
+ FX_BOOL bOverwrite = 0;
+ if (iLength >= 1) {
+ CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
+ wsExpression = CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
+ if (wsExpression.IsEmpty()) {
+ return;
+ }
+ }
+ if (iLength >= 2) {
+ bIgnoreRoot = pArguments->GetInt32(1) == 0 ? FALSE : TRUE;
+ }
+ if (iLength >= 3) {
+ bOverwrite = pArguments->GetInt32(2) == 0 ? FALSE : TRUE;
+ }
+ IXFA_Parser* pParser = IXFA_Parser::Create(m_pDocument);
+ if (!pParser) {
+ return;
+ }
+ IFDE_XMLNode* pXMLNode = NULL;
+ FX_INT32 iParserStatus = pParser->ParseXMLData(wsExpression, pXMLNode, NULL);
+ if (iParserStatus != XFA_PARSESTATUS_Done || !pXMLNode) {
+ pParser->Release();
+ pParser = NULL;
+ return;
+ }
+ if (bIgnoreRoot && (pXMLNode->GetType() != FDE_XMLNODE_Element || XFA_RecognizeRichText((IFDE_XMLElement*)pXMLNode))) {
+ bIgnoreRoot = FALSE;
+ }
+ CXFA_Node* pFakeRoot = this->Clone(FALSE);
+ CFX_WideStringC wsContentType = this->GetCData(XFA_ATTRIBUTE_ContentType);
+ if (!wsContentType.IsEmpty()) {
+ pFakeRoot->SetCData(XFA_ATTRIBUTE_ContentType, wsContentType);
+ }
+ IFDE_XMLNode* pFakeXMLRoot = pFakeRoot->GetXMLMappingNode();
+ if (!pFakeXMLRoot) {
+ IFDE_XMLNode* pThisXMLRoot = this->GetXMLMappingNode();
+ pFakeXMLRoot = pThisXMLRoot ? pThisXMLRoot->Clone(FALSE) : NULL;
+ }
+ if (!pFakeXMLRoot) {
+ CFX_WideStringC wsClassName;
+ this->GetClassName(wsClassName);
+ pFakeXMLRoot = IFDE_XMLElement::Create(wsClassName);
+ }
+ if (bIgnoreRoot) {
+ IFDE_XMLNode *pXMLChild = pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild);
+ while (pXMLChild) {
+ IFDE_XMLNode * pXMLSibling = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling);
+ pXMLNode->RemoveChildNode(pXMLChild);
+ pFakeXMLRoot->InsertChildNode(pXMLChild);
+ pXMLChild = pXMLSibling;
+ }
+ } else {
+ IFDE_XMLNode *pXMLParent = pXMLNode->GetNodeItem(IFDE_XMLNode::Parent);
+ if (pXMLParent) {
+ pXMLParent->RemoveChildNode(pXMLNode);
+ }
+ pFakeXMLRoot->InsertChildNode(pXMLNode);
+ }
+ pParser->ConstructXFANode(pFakeRoot, pFakeXMLRoot);
+ pFakeRoot = pParser->GetRootNode();
+ if (pFakeRoot) {
+ if (bOverwrite) {
+ CXFA_Node *pChild = this->GetNodeItem(XFA_NODEITEM_FirstChild);
+ CXFA_Node* pNewChild = pFakeRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
+ FX_INT32 index = 0;
+ while (pNewChild) {
+ CXFA_Node* pItem = pNewChild->GetNodeItem(XFA_NODEITEM_NextSibling);
+ pFakeRoot->RemoveChild(pNewChild);
+ this->InsertChild(index++, pNewChild);
+ pNewChild->SetFlag(XFA_NODEFLAG_Initialized);
+ pNewChild = pItem;
+ }
+ while (pChild) {
+ CXFA_Node *pItem = pChild->GetNodeItem(XFA_NODEITEM_NextSibling);
+ this->RemoveChild(pChild);
+ pFakeRoot->InsertChild(pChild);
+ pChild = pItem;
+ }
+ if (GetPacketID() == XFA_XDPPACKET_Form && GetClassID() == XFA_ELEMENT_ExData) {
+ IFDE_XMLNode* pTempXMLNode = this->GetXMLMappingNode();
+ this->SetXMLMappingNode(pFakeXMLRoot);
+ this->SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, FALSE);
+ if (pTempXMLNode && pTempXMLNode->GetNodeItem(IFDE_XMLNode::Parent) == NULL) {
+ pFakeXMLRoot = pTempXMLNode;
+ } else {
+ pFakeXMLRoot = NULL;
+ }
+ }
+ 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);
+ this->InsertChild(pChild);
+ pChild->SetFlag(XFA_NODEFLAG_Initialized);
+ pChild = pItem;
+ }
+ }
+ if (pFakeXMLRoot) {
+ pFakeRoot->SetXMLMappingNode(pFakeXMLRoot);
+ pFakeRoot->SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, FALSE);
+ }
+ pFakeRoot->SetFlag(XFA_NODEFLAG_HasRemoved, TRUE, FALSE);
+ } else {
+ if (pFakeXMLRoot) {
+ pFakeXMLRoot->Release();
+ pFakeXMLRoot = NULL;
+ }
+ }
+ pParser->Release();
+ pParser = NULL;
+}
+void CXFA_Node::Script_NodeClass_SaveFilteredXML(CFXJSE_Arguments* pArguments)
+{
+}
+void CXFA_Node::Script_NodeClass_SaveXML(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 iLength = pArguments->GetLength();
+ if (iLength < 0 || iLength > 1) {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"saveXML"));
+ return;
+ }
+ FX_BOOL bPrettyMode = FALSE;
+ if (iLength == 1) {
+ CFX_ByteString bsPretty = pArguments->GetUTF8String(0);
+ if (bsPretty.Equal(FX_BSTRC("pretty"))) {
+ bPrettyMode = TRUE;
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+ return;
+ }
+ }
+ CFX_ByteStringC bsXMLHeader = FX_BSTRC("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
+ if (GetPacketID() == XFA_XDPPACKET_Form) {
+ IFX_MemoryStream* pMemoryStream = FX_CreateMemoryStream(TRUE);
+ if (!pMemoryStream) {
+ FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), bsXMLHeader);
+ return;
+ }
+ IFX_Stream *pStream = IFX_Stream::CreateStream((IFX_FileWrite*)pMemoryStream, FX_STREAMACCESS_Text | FX_STREAMACCESS_Write | FX_STREAMACCESS_Append);
+ if (!pStream) {
+ FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), bsXMLHeader);
+ pMemoryStream->Release();
+ pMemoryStream = NULL;
+ return;
+ }
+ pStream->SetCodePage(FX_CODEPAGE_UTF8);
+ pStream->WriteData(bsXMLHeader, bsXMLHeader.GetLength());
+ XFA_DataExporter_RegenerateFormFile(this, pStream, NULL, TRUE);
+ FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), CFX_ByteStringC(pMemoryStream->GetBuffer(), pMemoryStream->GetSize()));
+ pStream->Release();
+ pStream = NULL;
+ if (pMemoryStream) {
+ pMemoryStream->Release();
+ pMemoryStream = NULL;
+ }
+ return;
+ } else if (GetPacketID() == XFA_XDPPACKET_Datasets) {
+ IFDE_XMLNode* pElement = this->GetXMLMappingNode();
+ if(!pElement || pElement->GetType() != FDE_XMLNODE_Element) {
+ FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), bsXMLHeader);
+ return;
+ }
+ XFA_DataExporter_DealWithDataGroupNode(this);
+ IFX_MemoryStream* pMemoryStream = FX_CreateMemoryStream(TRUE);
+ if (!pMemoryStream) {
+ FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), bsXMLHeader);
+ return;
+ }
+ if (pMemoryStream) {
+ IFX_Stream *pStream = IFX_Stream::CreateStream((IFX_FileWrite*)pMemoryStream, FX_STREAMACCESS_Text | FX_STREAMACCESS_Write | FX_STREAMACCESS_Append);
+ if (pStream) {
+ pStream->SetCodePage(FX_CODEPAGE_UTF8);
+ pStream->WriteData(bsXMLHeader, bsXMLHeader.GetLength());
+ pElement->SaveXMLNode(pStream);
+ FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), CFX_ByteStringC(pMemoryStream->GetBuffer(), pMemoryStream->GetSize()));
+ pStream->Release();
+ pStream = NULL;
+ }
+ if (pMemoryStream) {
+ pMemoryStream->Release();
+ pMemoryStream = NULL;
+ }
+ return;
+ }
+ } else {
+ FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), FX_BSTRC(""));
+ }
+}
+void CXFA_Node::Script_NodeClass_SetAttribute(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 iLength = pArguments->GetLength();
+ if (iLength != 2) {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"setAttribute"));
+ return;
+ }
+ CFX_WideString wsAttribute;
+ CFX_WideString wsAttributeValue;
+ CFX_ByteString bsAttributeValue = pArguments->GetUTF8String(0);
+ CFX_ByteString bsAttribute = pArguments->GetUTF8String(1);
+ wsAttributeValue = CFX_WideString::FromUTF8(bsAttributeValue, bsAttributeValue.GetLength());
+ wsAttribute = CFX_WideString::FromUTF8(bsAttribute, bsAttribute.GetLength());
+ this->SetAttribute(wsAttribute, wsAttributeValue, TRUE);
+}
+void CXFA_Node::Script_NodeClass_SetElement(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 iLength = pArguments->GetLength();
+ if (iLength != 1 && iLength != 2) {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"setElement"));
+ return;
+ }
+ CXFA_Node* pNode = NULL;
+ CFX_WideString wsName;
+ if (iLength >= 1) {
+ pNode = (CXFA_Node*)pArguments->GetObject(0);
+ }
+ if (iLength >= 2) {
+ CFX_ByteString bsName = pArguments->GetUTF8String(1);
+ wsName = CFX_WideString::FromUTF8(bsName, bsName.GetLength());
+ }
+}
+void CXFA_Node::Script_NodeClass_Ns(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ } else {
+ CFX_WideString wsNameSpace;
+ this->TryNamespace(wsNameSpace);
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsNameSpace));
+ }
+}
+void CXFA_Node::Script_NodeClass_Model(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ } else {
+ FXJSE_Value_Set(hValue, m_pDocument->GetScriptContext()->GetJSValueFromMap(this->GetModelNode()));
+ }
+}
+void CXFA_Node::Script_NodeClass_IsContainer(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ } else {
+ FXJSE_Value_SetBoolean(hValue, this->IsContainerNode());
+ }
+}
+void CXFA_Node::Script_NodeClass_IsNull(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ } else {
+ if (this->GetClassID() == XFA_ELEMENT_Subform) {
+ FXJSE_Value_SetBoolean(hValue, FALSE);
+ return;
+ }
+ CFX_WideString strValue;
+ FXJSE_Value_SetBoolean(hValue, !TryContent(strValue) || strValue.IsEmpty());
+ }
+}
+void CXFA_Node::Script_NodeClass_OneOfChild(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ } else {
+ CXFA_NodeArray properts;
+ FX_INT32 iSize = this->GetNodeList(properts, XFA_NODEFILTER_OneOfProperty);
+ if (iSize > 0) {
+ FXJSE_Value_Set(hValue, 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 = FX_NEW CXFA_ArrayNodeList(m_pDocument);
+ FXJSE_Value_SetObject(pArguments->GetReturnValue(), (CXFA_Object*)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)
+{
+ FX_INT32 iLength = pArguments->GetLength();
+ if (iLength < 1) {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"isCompatibleNS"));
+ return;
+ }
+ CFX_WideString wsNameSpace;
+ if (iLength >= 1) {
+ CFX_ByteString bsNameSpace = pArguments->GetUTF8String(0);
+ wsNameSpace = CFX_WideString::FromUTF8(bsNameSpace, bsNameSpace.GetLength());
+ }
+ CFX_WideString wsNodeNameSpace;
+ this->TryNamespace(wsNodeNameSpace);
+ FXJSE_HVALUE hValue = pArguments->GetReturnValue();
+ if (hValue) {
+ FXJSE_Value_SetBoolean(hValue, wsNodeNameSpace.Equal(wsNameSpace));
+ }
+}
+void CXFA_Node::Script_ModelClass_Context(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+}
+void CXFA_Node::Script_ModelClass_AliasNode(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+}
+void CXFA_Node::Script_Attribute_Integer(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ SetInteger(eAttribute, FXJSE_Value_ToInteger(hValue), TRUE);
+ } else {
+ FXJSE_Value_SetInteger(hValue, GetInteger(eAttribute));
+ }
+}
+void CXFA_Node::Script_Attribute_IntegerRead(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (!bSetting) {
+ FXJSE_Value_SetInteger(hValue, GetInteger(eAttribute));
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ }
+}
+void CXFA_Node::Script_Attribute_BOOL(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ SetBoolean(eAttribute, FXJSE_Value_ToBoolean(hValue), TRUE);
+ } else {
+ FXJSE_Value_SetUTF8String(hValue, GetBoolean(eAttribute) ? FX_BSTRC("1") : FX_BSTRC("0"));
+ }
+}
+void CXFA_Node::Script_Attribute_BOOLRead(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (!bSetting) {
+ FXJSE_Value_SetUTF8String(hValue, GetBoolean(eAttribute) ? FX_BSTRC("1") : FX_BSTRC("0"));
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ }
+}
+void CXFA_Node::Script_Attribute_SendAttributeChangeMessage(FX_LPVOID eAttribute, FX_LPVOID eValue, FX_BOOL bScriptModify)
+{
+ CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
+ if (!pLayoutPro) {
+ return;
+ }
+ IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
+ if (!pNotify) {
+ return;
+ }
+ FX_DWORD dwPacket = this->GetPacketID();
+ if (dwPacket & XFA_XDPPACKET_Form) {
+ FX_BOOL bNeedFindContainer = FALSE;
+ XFA_ELEMENT eType = this->GetClassID();
+ switch (eType) {
+ case XFA_ELEMENT_Caption:
+ bNeedFindContainer = TRUE;
+ pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute, eValue, this, this->GetNodeItem(XFA_NODEITEM_Parent));
+ break;
+ case XFA_ELEMENT_Font:
+ case XFA_ELEMENT_Para: {
+ bNeedFindContainer = TRUE;
+ CXFA_Node* pParentNode = this->GetNodeItem(XFA_NODEITEM_Parent);
+ if (pParentNode->GetClassID() == XFA_ELEMENT_Caption) {
+ pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute, eValue, pParentNode, pParentNode->GetNodeItem(XFA_NODEITEM_Parent));
+ } else {
+ pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute, eValue, this, pParentNode);
+ }
+ }
+ break;
+ case XFA_ELEMENT_Margin: {
+ bNeedFindContainer = TRUE;
+ CXFA_Node* pParentNode = this->GetNodeItem(XFA_NODEITEM_Parent);
+ XFA_ELEMENT eParentType = pParentNode->GetClassID();
+ if (pParentNode->IsContainerNode()) {
+ pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute, eValue, this, pParentNode);
+ } else if (eParentType == XFA_ELEMENT_Caption) {
+ pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute, eValue, pParentNode, pParentNode->GetNodeItem(XFA_NODEITEM_Parent));
+ } else {
+ CXFA_Node* pNode = pParentNode->GetNodeItem(XFA_NODEITEM_Parent);
+ if (pNode && pNode->GetClassID() == XFA_ELEMENT_Ui) {
+ pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute, eValue, pNode, pNode->GetNodeItem(XFA_NODEITEM_Parent));
+ }
+ }
+ }
+ break;
+ case XFA_ELEMENT_Comb: {
+ CXFA_Node* pEditNode = this->GetNodeItem(XFA_NODEITEM_Parent);
+ XFA_ELEMENT eUIType = pEditNode->GetClassID();
+ 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->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute, eValue, 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 = this->GetNodeItem(XFA_NODEITEM_Parent);
+ if (pUINode) {
+ pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute, eValue, pUINode, pUINode->GetNodeItem(XFA_NODEITEM_Parent));
+ }
+ }
+ break;
+ case XFA_ELEMENT_CheckButton: {
+ bNeedFindContainer = TRUE;
+ CXFA_Node* pUINode = this->GetNodeItem(XFA_NODEITEM_Parent);
+ if (pUINode) {
+ pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute, eValue, 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->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute, eValue, this, this);
+ break;
+ case XFA_ELEMENT_Sharptext:
+ case XFA_ELEMENT_Sharpxml:
+ case XFA_ELEMENT_SharpxHTML: {
+ CXFA_Node* pTextNode = this->GetNodeItem(XFA_NODEITEM_Parent);
+ if (!pTextNode) {
+ return;
+ }
+ CXFA_Node* pValueNode = pTextNode->GetNodeItem(XFA_NODEITEM_Parent);
+ if (!pValueNode) {
+ return;
+ }
+ XFA_ELEMENT eType = pValueNode->GetClassID();
+ if (eType == XFA_ELEMENT_Value) {
+ bNeedFindContainer = TRUE;
+ CXFA_Node* pNode = pValueNode->GetNodeItem(XFA_NODEITEM_Parent);
+ if (pNode && pNode->IsContainerNode()) {
+ if (bScriptModify) {
+ pValueNode = pNode;
+ }
+ pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute, eValue, pValueNode, pNode);
+ } else {
+ pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute, eValue, 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->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute, eValue, 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);
+ }
+ }
+ } else {
+ pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute, eValue, this, this);
+ }
+}
+void CXFA_Node::Script_Attribute_String(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ CFX_ByteString szValue;
+ FXJSE_Value_ToUTF8String(hValue, szValue);
+ CFX_WideString wsValue = CFX_WideString::FromUTF8(szValue, szValue.GetLength());
+ SetAttribute(eAttribute, wsValue, TRUE);
+ if(eAttribute == XFA_ATTRIBUTE_Use && this->GetClassID() == XFA_ELEMENT_Desc) {
+ CFX_WideString wsUseVal = wsValue, wsID, wsSOM;
+ CXFA_Node* pTemplateNode = (CXFA_Node*)m_pDocument->GetXFANode(XFA_HASHCODE_Template);
+ CXFA_Node* pProtoRoot = pTemplateNode->GetFirstChildByClass(XFA_ELEMENT_Subform)->GetFirstChildByClass(XFA_ELEMENT_Proto);
+ if(!wsUseVal.IsEmpty()) {
+ if(wsUseVal[0] == '#') {
+ wsID = CFX_WideString((FX_LPCWSTR)wsUseVal + 1, wsUseVal.GetLength() - 1);
+ } else {
+ wsSOM = CFX_WideString((FX_LPCWSTR)wsUseVal, wsUseVal.GetLength());
+ }
+ }
+ CXFA_Node* pProtoNode = NULL;
+ if(!wsSOM.IsEmpty()) {
+ FX_DWORD dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes | XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings;
+ XFA_RESOLVENODE_RS resoveNodeRS;
+ FX_INT32 iRet = m_pDocument->GetScriptContext()->ResolveObjects(pProtoRoot, wsSOM, resoveNodeRS, dwFlag);
+ if(iRet > 0 && resoveNodeRS.nodes[0]->IsNode()) {
+ pProtoNode = (CXFA_Node*)resoveNodeRS.nodes[0];
+ }
+ } else if(!wsID.IsEmpty()) {
+ pProtoNode = m_pDocument->GetNodeByID(pProtoRoot, wsID);
+ }
+ 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);
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue, wsValue.GetLength()));
+ }
+}
+void CXFA_Node::Script_Attribute_StringRead(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (!bSetting) {
+ CFX_WideString wsValue;
+ GetAttribute(eAttribute, wsValue);
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue, wsValue.GetLength()));
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ }
+}
+void CXFA_Node::Script_WsdlConnection_Execute(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if ((argc == 0) || (argc == 1)) {
+ FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"execute"));
+ }
+}
+void CXFA_Node::Script_Delta_Restore(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"restore"));
+ }
+}
+void CXFA_Node::Script_Delta_CurrentValue(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+}
+void CXFA_Node::Script_Delta_SavedValue(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+}
+void CXFA_Node::Script_Delta_Target(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+}
+void CXFA_Node::Script_Som_Message(FXJSE_HVALUE hValue, 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) {
+ CFX_ByteString bsMessage;
+ FXJSE_Value_ToUTF8String(hValue, bsMessage);
+ switch (iMessageType) {
+ case XFA_SOM_ValidationMessage:
+ validate.SetScriptMessageText(CFX_WideString::FromUTF8(bsMessage, bsMessage.GetLength()));
+ break;
+ case XFA_SOM_FormatMessage:
+ validate.SetFormatMessageText(CFX_WideString::FromUTF8(bsMessage, bsMessage.GetLength()));
+ break;
+ case XFA_SOM_MandatoryMessage:
+ validate.SetNullMessageText(CFX_WideString::FromUTF8(bsMessage, bsMessage.GetLength()));
+ break;
+ default:
+ break;
+ }
+ if (!bNew) {
+ IXFA_Notify* pNotify = m_pDocument->GetParser()->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;
+ }
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsMessage));
+ }
+}
+void CXFA_Node::Script_Som_ValidationMessage(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ Script_Som_Message(hValue, bSetting, XFA_SOM_ValidationMessage);
+}
+void CXFA_Node::Script_Field_Length(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ } else {
+ CXFA_WidgetData *pWidgetData = GetWidgetData();
+ if (!pWidgetData) {
+ FXJSE_Value_SetInteger(hValue, 0);
+ return;
+ }
+ FXJSE_Value_SetInteger(hValue, pWidgetData->CountChoiceListItems(TRUE));
+ }
+}
+void CXFA_Node::Script_Som_DefaultValue(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ XFA_ELEMENT classID = GetClassID();
+ if(classID == XFA_ELEMENT_Field) {
+ Script_Field_DefaultValue(hValue, bSetting, eAttribute);
+ return;
+ } else if(classID == XFA_ELEMENT_Draw) {
+ Script_Draw_DefaultValue(hValue, bSetting, eAttribute);
+ return;
+ } else if (classID == XFA_ELEMENT_Boolean) {
+ Script_Boolean_Value(hValue, bSetting, eAttribute);
+ return;
+ }
+ if (bSetting) {
+ CFX_ByteString newValue;
+ if (!(FXJSE_Value_IsNull(hValue) || FXJSE_Value_IsUndefined(hValue))) {
+ FXJSE_Value_ToUTF8String(hValue, newValue);
+ }
+ CFX_WideString wsNewValue = CFX_WideString::FromUTF8(newValue, newValue.GetLength());
+ CFX_WideString wsFormatValue(wsNewValue);
+ CXFA_WidgetData* pContainerWidgetData = NULL;
+ if (GetPacketID() == XFA_XDPPACKET_Datasets) {
+ CXFA_NodeArray formNodes;
+ this->GetBindItems(formNodes);
+ CFX_WideString wsPicture;
+ for (FX_INT32 i = 0; i < formNodes.GetSize(); i++) {
+ CXFA_Node* pFormNode = formNodes.GetAt(i);
+ if (!pFormNode || pFormNode->HasFlag(XFA_NODEFLAG_HasRemoved)) {
+ continue;
+ }
+ pContainerWidgetData = pFormNode->GetContainerWidgetData();
+ if (pContainerWidgetData) {
+ pContainerWidgetData->GetPictureContent(wsPicture, XFA_VALUEPICTURE_DataBind);
+ }
+ if (!wsPicture.IsEmpty()) {
+ break;
+ }
+ pContainerWidgetData = NULL;
+ }
+ } 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() && classID != XFA_ELEMENT_Text && classID != XFA_ELEMENT_SubmitUrl) {
+ FXJSE_Value_SetNull(hValue);
+ } else if (classID == XFA_ELEMENT_Integer) {
+ FXJSE_Value_SetInteger(hValue, FXSYS_wtoi(content)) ;
+ } else if (classID == XFA_ELEMENT_Float || classID == XFA_ELEMENT_Decimal) {
+ CFX_Decimal decimal(content);
+ FXJSE_Value_SetFloat(hValue, (FX_FLOAT)(double)decimal);
+ } else {
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(content, content.GetLength()));
+ }
+ }
+}
+void CXFA_Node::Script_Som_DefaultValue_Read(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ return;
+ }
+ CFX_WideString content = GetScriptContent(TRUE);
+ if (content.IsEmpty()) {
+ FXJSE_Value_SetNull(hValue);
+ } else {
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(content, content.GetLength()));
+ }
+}
+void CXFA_Node::Script_Boolean_Value(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ CFX_ByteString newValue;
+ if (!(FXJSE_Value_IsNull(hValue) || FXJSE_Value_IsUndefined(hValue))) {
+ FXJSE_Value_ToUTF8String(hValue, newValue);
+ }
+ FX_INT32 iValue = FXSYS_atoi(newValue);
+ CFX_WideString wsNewValue = (iValue == 0) ? FX_WSTRC(L"0") : FX_WSTRC(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);
+ FXJSE_Value_SetBoolean(hValue, wsValue.Equal(FX_WSTRC(L"1")) ? TRUE : FALSE);
+ }
+}
+struct XFA_ExecEventParaInfo {
+public:
+ FX_UINT32 m_uHash;
+ FX_LPCWSTR m_lpcEventName;
+ XFA_EVENTTYPE m_eventType;
+ FX_UINT32 m_validFlags;
+};
+static const XFA_ExecEventParaInfo gs_eventParaInfos[] = {
+ {0x02a6c55a, (FX_LPCWSTR)L"postSubmit", XFA_EVENT_PostSubmit, 0},
+ {0x0ab466bb, (FX_LPCWSTR)L"preSubmit", XFA_EVENT_PreSubmit, 0},
+ {0x109d7ce7, (FX_LPCWSTR)L"mouseEnter", XFA_EVENT_MouseEnter, 5},
+ {0x17fad373, (FX_LPCWSTR)L"postPrint", XFA_EVENT_PostPrint, 0},
+ {0x1bfc72d9, (FX_LPCWSTR)L"preOpen", XFA_EVENT_PreOpen, 7},
+ {0x2196a452, (FX_LPCWSTR)L"initialize", XFA_EVENT_Initialize, 1},
+ {0x27410f03, (FX_LPCWSTR)L"mouseExit", XFA_EVENT_MouseExit, 5},
+ {0x33c43dec, (FX_LPCWSTR)L"docClose", XFA_EVENT_DocClose, 0},
+ {0x361fa1b6, (FX_LPCWSTR)L"preSave", XFA_EVENT_PreSave, 0},
+ {0x36f1c6d8, (FX_LPCWSTR)L"preSign", XFA_EVENT_PreSign, 6},
+ {0x4731d6ba, (FX_LPCWSTR)L"exit", XFA_EVENT_Exit, 2},
+ {0x56bf456b, (FX_LPCWSTR)L"docReady", XFA_EVENT_DocReady, 0},
+ {0x7233018a, (FX_LPCWSTR)L"validate", XFA_EVENT_Validate, 1},
+ {0x8808385e, (FX_LPCWSTR)L"indexChange", XFA_EVENT_IndexChange, 3},
+ {0x891f4606, (FX_LPCWSTR)L"change", XFA_EVENT_Change, 4},
+ {0x9528a7b4, (FX_LPCWSTR)L"prePrint", XFA_EVENT_PrePrint, 0},
+ {0x9f693b21, (FX_LPCWSTR)L"mouseDown", XFA_EVENT_MouseDown, 5},
+ {0xcdce56b3, (FX_LPCWSTR)L"full", XFA_EVENT_Full, 4},
+ {0xd576d08e, (FX_LPCWSTR)L"mouseUp", XFA_EVENT_MouseUp, 5},
+ {0xd95657a6, (FX_LPCWSTR)L"click", XFA_EVENT_Click, 4},
+ {0xdbfbe02e, (FX_LPCWSTR)L"calculate", XFA_EVENT_Calculate, 1},
+ {0xe25fa7b8, (FX_LPCWSTR)L"postOpen", XFA_EVENT_PostOpen, 7},
+ {0xe28dce7e, (FX_LPCWSTR)L"enter", XFA_EVENT_Enter, 2},
+ {0xfc82d695, (FX_LPCWSTR)L"postSave", XFA_EVENT_PostSave, 0},
+ {0xfd54fbb7, (FX_LPCWSTR)L"postSign", XFA_EVENT_PostSign, 6},
+};
+const XFA_ExecEventParaInfo* GetEventParaInfoByName(FX_WSTR wsEventName)
+{
+ FX_INT32 iLength = wsEventName.GetLength();
+ FX_UINT32 uHash = FX_HashCode_String_GetW(wsEventName.GetPtr(), iLength);
+ const XFA_ExecEventParaInfo* eventParaInfo = NULL;
+ FX_INT32 iStart = 0, iEnd = (sizeof(gs_eventParaInfos) / sizeof(gs_eventParaInfos[0])) - 1;
+ FX_INT32 iMid = (iStart + iEnd) / 2;
+ do {
+ iMid = (iStart + iEnd) / 2;
+ eventParaInfo = &gs_eventParaInfos[iMid];
+ if (uHash == eventParaInfo->m_uHash) {
+ return eventParaInfo;
+ } else if (uHash < eventParaInfo->m_uHash) {
+ iEnd = iMid - 1;
+ } else {
+ iStart = iMid + 1;
+ }
+ } while (iStart <= iEnd);
+ return NULL;
+}
+void XFA_STRING_TO_RGB(CFX_WideString &strRGB, FX_INT32 &r, FX_INT32 &g, FX_INT32 &b)
+{
+ r = 0;
+ g = 0;
+ b = 0;
+ FX_WCHAR zero = '0';
+ FX_INT32 iIndex = 0;
+ FX_INT32 iLen = strRGB.GetLength();
+ for (FX_INT32 i = 0; i < iLen; ++i) {
+ FX_WCHAR ch = strRGB.GetAt(i);
+ if (ch == L',') {
+ ++iIndex;
+ }
+ if (iIndex > 2) {
+ break;
+ }
+ FX_INT32 iValue = ch - zero;
+ if (iValue >= 0 && iValue <= 9) {
+ switch (iIndex) {
+ case 0:
+ r = r * 10 + iValue;
+ break;
+ case 1:
+ g = g * 10 + iValue;
+ break;
+ default:
+ b = b * 10 + iValue;
+ break;
+ }
+ }
+ }
+}
+void CXFA_Node::Script_Som_BorderColor(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ CXFA_WidgetData* pWidgetData = GetWidgetData();
+ if (!pWidgetData) {
+ return;
+ }
+ CXFA_Border border = pWidgetData->GetBorder(TRUE);
+ FX_INT32 iSize = border.CountEdges();
+ CFX_WideString strColor;
+ if (bSetting) {
+ CFX_ByteString bsValue;
+ FXJSE_Value_ToUTF8String(hValue, bsValue);
+ strColor = CFX_WideString::FromUTF8(bsValue, bsValue.GetLength());
+ FX_INT32 r = 0, g = 0, b = 0;
+ XFA_STRING_TO_RGB(strColor, r, g, b);
+ FX_ARGB rgb = ArgbEncode(100, r, g, b);
+ for (FX_INT32 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();
+ FX_INT32 a, r, g, b;
+ ArgbDecode(color, a, r, g, b);
+ strColor.Format((FX_LPCWSTR)L"%d,%d,%d", r, g, b);
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(strColor));
+ }
+}
+void CXFA_Node::Script_Som_BorderWidth(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ CXFA_WidgetData* pWidgetData = GetWidgetData();
+ if (!pWidgetData) {
+ return;
+ }
+ CXFA_Border border = pWidgetData->GetBorder(TRUE);
+ FX_INT32 iSize = border.CountEdges();
+ CFX_WideString wsThickness;
+ if (bSetting) {
+ CFX_ByteString bsValue;
+ FXJSE_Value_ToUTF8String(hValue, bsValue);
+ wsThickness = CFX_WideString::FromUTF8(bsValue, bsValue.GetLength());
+ for (FX_INT32 i = 0; i < iSize; ++i) {
+ CXFA_Edge edge = border.GetEdge(i);
+ CXFA_Measurement thickness(wsThickness);
+ edge.SetMSThickness(thickness);
+ }
+ } else {
+ CXFA_Edge edge = border.GetEdge(0);
+ CXFA_Measurement thickness = edge.GetMSThickness();
+ thickness.ToString(wsThickness);
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsThickness));
+ }
+}
+void CXFA_Node::Script_Som_FillColor(FXJSE_HVALUE hValue, 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 = (CXFA_Node*)borderfill;
+ if (!pNode) {
+ return;
+ }
+ CFX_WideString wsColor;
+ if (bSetting) {
+ CFX_ByteString bsValue;
+ FXJSE_Value_ToUTF8String(hValue, bsValue);
+ wsColor = CFX_WideString::FromUTF8(bsValue, bsValue.GetLength());
+ FX_INT32 r, g, b;
+ XFA_STRING_TO_RGB(wsColor, r, g, b);
+ FX_ARGB color = ArgbEncode(0xff, r, g, b);
+ borderfill.SetColor(color);
+ } else {
+ FX_ARGB color = borderfill.GetColor();
+ FX_INT32 a, r, g, b;
+ ArgbDecode(color, a, r, g, b);
+ wsColor.Format((FX_LPCWSTR)L"%d,%d,%d", r, g, b);
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsColor));
+ }
+}
+void CXFA_Node::Script_Som_DataNode(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (!bSetting) {
+ CXFA_Node *pDataNode = GetBindData();
+ if (pDataNode) {
+ FXJSE_Value_Set(hValue, m_pDocument->GetScriptContext()->GetJSValueFromMap(pDataNode));
+ } else {
+ FXJSE_Value_SetNull(hValue);
+ }
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ }
+}
+void CXFA_Node::Script_Draw_DefaultValue(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ if (FXJSE_Value_IsUTF8String(hValue)) {
+ CXFA_WidgetData *pWidgetData = GetWidgetData();
+ FXSYS_assert(pWidgetData);
+ XFA_ELEMENT uiType = pWidgetData->GetUIType();
+ if (uiType == XFA_ELEMENT_Text) {
+ CFX_ByteString newValue;
+ FXJSE_Value_ToUTF8String(hValue, newValue);
+ CFX_WideString wsNewValue = CFX_WideString::FromUTF8(newValue, newValue.GetLength());
+ CFX_WideString wsFormatValue(wsNewValue);
+ SetScriptContent(wsNewValue, wsFormatValue, TRUE, TRUE);
+ } else if(uiType != XFA_ELEMENT_Image) {
+ }
+ }
+ } else {
+ CFX_WideString content = GetScriptContent(TRUE);
+ if(content.IsEmpty()) {
+ FXJSE_Value_SetNull(hValue);
+ } else {
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(content, content.GetLength()));
+ }
+ }
+}
+void CXFA_Node::Script_Field_DefaultValue(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ CXFA_WidgetData* pWidgetData = GetWidgetData();
+ if (!pWidgetData) {
+ return;
+ }
+ if (bSetting) {
+ if (FXJSE_Value_IsNull(hValue)) {
+ pWidgetData->m_bPreNull = pWidgetData->m_bIsNull;
+ pWidgetData->m_bIsNull = TRUE;
+ } else {
+ pWidgetData->m_bPreNull = pWidgetData->m_bIsNull;
+ pWidgetData->m_bIsNull = FALSE;
+ }
+ CFX_ByteString newValue;
+ if (!(FXJSE_Value_IsNull(hValue) || FXJSE_Value_IsUndefined(hValue))) {
+ FXJSE_Value_ToUTF8String(hValue, newValue);
+ }
+ CFX_WideString wsNewText = CFX_WideString::FromUTF8(newValue, newValue.GetLength());
+ CXFA_Node *pUIChild = pWidgetData->GetUIChild();
+ if (pUIChild->GetClassID() == XFA_ELEMENT_NumericEdit) {
+ FX_INT32 iLeadDigits = 0;
+ FX_INT32 iFracDigits = 0;
+ pWidgetData->GetLeadDigits(iLeadDigits);
+ pWidgetData->GetFracDigits(iFracDigits);
+ wsNewText = XFA_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()) {
+ FXJSE_Value_SetNull(hValue);
+ } else {
+ CXFA_Node *pUIChild = pWidgetData->GetUIChild();
+ XFA_ELEMENT eUI = pUIChild->GetClassID();
+ CXFA_Value defVal = pWidgetData->GetFormValue();
+ CXFA_Node* pNode = defVal.GetNode()->GetNodeItem(XFA_NODEITEM_FirstChild);
+ if (pNode && pNode->GetClassID() == XFA_ELEMENT_Decimal) {
+ if(eUI == XFA_ELEMENT_NumericEdit && (pNode->GetInteger(XFA_ATTRIBUTE_FracDigits) == -1)) {
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(content, content.GetLength()));
+ } else {
+ CFX_Decimal decimal(content);
+ FXJSE_Value_SetFloat(hValue, (FX_FLOAT)(double)decimal);
+ }
+ } else if (pNode && pNode->GetClassID() == XFA_ELEMENT_Integer) {
+ FXJSE_Value_SetInteger(hValue, FXSYS_wtoi(content)) ;
+ } else if (pNode && pNode->GetClassID() == XFA_ELEMENT_Boolean) {
+ FXJSE_Value_SetBoolean(hValue, FXSYS_wtoi(content) == 0 ? FALSE : TRUE);
+ } else if (pNode && pNode->GetClassID() == XFA_ELEMENT_Float) {
+ CFX_Decimal decimal(content);
+ FXJSE_Value_SetFloat(hValue, (FX_FLOAT)(double)decimal);
+ } else {
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(content, content.GetLength()));
+ }
+ }
+ }
+}
+void CXFA_Node::Script_Field_EditValue(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ CXFA_WidgetData* pWidgetData = GetWidgetData();
+ if (!pWidgetData) {
+ return;
+ }
+ CFX_WideString wsValue;
+ if (bSetting) {
+ CFX_ByteString bsValue;
+ FXJSE_Value_ToUTF8String(hValue, bsValue);
+ wsValue = CFX_WideString::FromUTF8(bsValue, bsValue.GetLength());
+ pWidgetData->SetValue(wsValue, XFA_VALUEPICTURE_Edit);
+ } else {
+ pWidgetData->GetValue(wsValue, XFA_VALUEPICTURE_Edit);
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue));
+ }
+}
+void CXFA_Node::Script_Som_FontColor(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ CXFA_WidgetData* pWidgetData = GetWidgetData();
+ if (!pWidgetData) {
+ return;
+ }
+ CXFA_Font font = pWidgetData->GetFont(TRUE);
+ CXFA_Node *pNode = (CXFA_Node*)font;
+ if (!pNode) {
+ return;
+ }
+ CFX_WideString wsColor;
+ if (bSetting) {
+ CFX_ByteString bsValue;
+ FXJSE_Value_ToUTF8String(hValue, bsValue);
+ wsColor = CFX_WideString::FromUTF8(bsValue, bsValue.GetLength());
+ FX_INT32 r, g, b;
+ XFA_STRING_TO_RGB(wsColor, r, g, b);
+ FX_ARGB color = ArgbEncode(0xff, r, g, b);
+ font.SetColor(color);
+ } else {
+ FX_ARGB color = font.GetColor();
+ FX_INT32 a, r, g, b;
+ ArgbDecode(color, a, r, g, b);
+ wsColor.Format((FX_LPCWSTR)L"%d,%d,%d", r, g, b);
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsColor));
+ }
+}
+void CXFA_Node::Script_Field_FormatMessage(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ Script_Som_Message(hValue, bSetting, XFA_SOM_FormatMessage);
+}
+void CXFA_Node::Script_Field_FormattedValue(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ CXFA_WidgetData* pWidgetData = GetWidgetData();
+ if (!pWidgetData) {
+ return;
+ }
+ CFX_WideString wsValue;
+ if (bSetting) {
+ CFX_ByteString bsValue;
+ FXJSE_Value_ToUTF8String(hValue, bsValue);
+ wsValue = CFX_WideString::FromUTF8(bsValue, bsValue.GetLength());
+ pWidgetData->SetValue(wsValue, XFA_VALUEPICTURE_Display);
+ } else {
+ pWidgetData->GetValue(wsValue, XFA_VALUEPICTURE_Display);
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue));
+ }
+}
+void CXFA_Node::Script_Som_Mandatory(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ CXFA_WidgetData* pWidgetData = GetWidgetData();
+ if (!pWidgetData) {
+ return;
+ }
+ CXFA_Validate validate = pWidgetData->GetValidate(TRUE);
+ CFX_WideString wsValue;
+ if (bSetting) {
+ CFX_ByteString bsValue;
+ FXJSE_Value_ToUTF8String(hValue, bsValue);
+ wsValue = CFX_WideString::FromUTF8(bsValue, bsValue.GetLength());
+ validate.SetNullTest(wsValue);
+ } else {
+ FX_INT32 iValue = validate.GetNullTest();
+ XFA_LPCATTRIBUTEENUMINFO pInfo = XFA_GetAttributeEnumByID((XFA_ATTRIBUTEENUM)iValue);
+ if (pInfo) {
+ wsValue = pInfo->pName;
+ }
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue));
+ }
+}
+void CXFA_Node::Script_Som_MandatoryMessage(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ Script_Som_Message(hValue, bSetting, XFA_SOM_MandatoryMessage);
+}
+void CXFA_Node::Script_Field_ParentSubform(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ } else {
+ FXJSE_Value_SetNull(hValue);
+ }
+}
+void CXFA_Node::Script_Field_SelectedIndex(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ CXFA_WidgetData* pWidgetData = GetWidgetData();
+ if (!pWidgetData) {
+ return;
+ }
+ if (bSetting) {
+ FX_INT32 iIndex = FXJSE_Value_ToInteger(hValue);
+ if (iIndex == -1) {
+ pWidgetData->ClearAllSelections();
+ return;
+ }
+ pWidgetData->SetItemState(iIndex, TRUE, TRUE, TRUE);
+ } else {
+ FXJSE_Value_SetInteger(hValue, 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)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 1) {
+ CFX_ByteString eventString = pArguments->GetUTF8String(0);
+ FX_INT32 iRet = execSingleEventByName(CFX_WideString::FromUTF8(eventString, eventString.GetLength()), XFA_ELEMENT_Field);
+ if (eventString == FX_BSTRC("validate")) {
+ FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), ((iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE));
+ }
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"execEvent"));
+ }
+}
+void CXFA_Node::Script_Field_ExecInitialize(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
+ if (!pNotify) {
+ return;
+ }
+ pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize, FALSE, FALSE);
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"execInitialize"));
+ }
+}
+void CXFA_Node::Script_Field_DeleteItem(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 iLength = pArguments->GetLength();
+ if (iLength != 1) {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"deleteItem"));
+ return;
+ }
+ CXFA_WidgetData* pWidgetData = GetWidgetData();
+ if (!pWidgetData) {
+ return;
+ }
+ FX_INT32 iIndex = pArguments->GetInt32(0);
+ FX_BOOL bValue = pWidgetData->DeleteItem(iIndex, TRUE, TRUE);
+ FXJSE_HVALUE hValue = pArguments->GetReturnValue();
+ if (hValue) {
+ FXJSE_Value_SetBoolean(hValue, bValue);
+ }
+}
+void CXFA_Node::Script_Field_GetSaveItem(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 iLength = pArguments->GetLength();
+ if (iLength != 1) {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"getSaveItem"));
+ return;
+ }
+ FX_INT32 iIndex = pArguments->GetInt32(0);
+ if (iIndex < 0) {
+ FXJSE_Value_SetNull(pArguments->GetReturnValue());
+ return;
+ }
+ CXFA_WidgetData* pWidgetData = GetWidgetData();
+ if (!pWidgetData) {
+ FXJSE_Value_SetNull(pArguments->GetReturnValue());
+ return;
+ }
+ CFX_WideString wsValue;
+ FX_BOOL bHasItem = pWidgetData->GetChoiceListItem(wsValue, iIndex, TRUE);
+ if (bHasItem) {
+ FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), FX_UTF8Encode(wsValue, wsValue.GetLength()));
+ } else {
+ FXJSE_Value_SetNull(pArguments->GetReturnValue());
+ }
+}
+void CXFA_Node::Script_Field_BoundItem(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 iLength = pArguments->GetLength();
+ if (iLength != 1) {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"boundItem"));
+ return;
+ }
+ CXFA_WidgetData* pWidgetData = GetWidgetData();
+ if (!pWidgetData) {
+ return;
+ }
+ CFX_ByteString bsValue = pArguments->GetUTF8String(0);
+ CFX_WideString wsValue = CFX_WideString::FromUTF8(bsValue, bsValue.GetLength());
+ CFX_WideString wsBoundValue;
+ pWidgetData->GetItemValue(wsValue, wsBoundValue);
+ FXJSE_HVALUE hValue = pArguments->GetReturnValue();
+ if (hValue) {
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsBoundValue));
+ }
+}
+void CXFA_Node::Script_Field_GetItemState(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 iLength = pArguments->GetLength();
+ if (iLength != 1) {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"getItemState"));
+ return;
+ }
+ CXFA_WidgetData* pWidgetData = GetWidgetData();
+ if (!pWidgetData) {
+ return;
+ }
+ FX_INT32 iIndex = pArguments->GetInt32(0);
+ FX_BOOL bValue = pWidgetData->GetItemState(iIndex);
+ FXJSE_HVALUE hValue = pArguments->GetReturnValue();
+ if (hValue) {
+ FXJSE_Value_SetBoolean(hValue, bValue);
+ }
+}
+void CXFA_Node::Script_Field_ExecCalculate(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
+ if (!pNotify) {
+ return;
+ }
+ pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate, FALSE, FALSE);
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"execCalculate"));
+ }
+}
+void CXFA_Node::Script_Field_SetItems(CFXJSE_Arguments* pArguments)
+{
+}
+void CXFA_Node::Script_Field_GetDisplayItem(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 iLength = pArguments->GetLength();
+ if (iLength != 1) {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"getDisplayItem"));
+ return;
+ }
+ FX_INT32 iIndex = pArguments->GetInt32(0);
+ if (iIndex < 0) {
+ FXJSE_Value_SetNull(pArguments->GetReturnValue());
+ return;
+ }
+ CXFA_WidgetData* pWidgetData = GetWidgetData();
+ if (!pWidgetData) {
+ FXJSE_Value_SetNull(pArguments->GetReturnValue());
+ return;
+ }
+ CFX_WideString wsValue;
+ FX_BOOL bHasItem = pWidgetData->GetChoiceListItem(wsValue, iIndex, FALSE);
+ if (bHasItem) {
+ FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), FX_UTF8Encode(wsValue, wsValue.GetLength()));
+ } else {
+ FXJSE_Value_SetNull(pArguments->GetReturnValue());
+ }
+}
+void CXFA_Node::Script_Field_SetItemState(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 iLength = pArguments->GetLength();
+ if (iLength != 2) {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"setItemState"));
+ return;
+ }
+ CXFA_WidgetData* pWidgetData = GetWidgetData();
+ if (!pWidgetData) {
+ return;
+ }
+ FX_INT32 iIndex = pArguments->GetInt32(0);
+ FX_BOOL bAdd = pArguments->GetInt32(1) == 0 ? FALSE : TRUE;
+ if (bAdd) {
+ pWidgetData->SetItemState(iIndex, TRUE, TRUE, TRUE);
+ } else {
+ if (pWidgetData->GetItemState(iIndex)) {
+ pWidgetData->SetItemState(iIndex, FALSE, TRUE, TRUE);
+ }
+ }
+}
+void CXFA_Node::Script_Field_AddItem(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 iLength = pArguments->GetLength();
+ if (iLength < 1 || iLength > 2) {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"addItem"));
+ return;
+ }
+ CXFA_WidgetData* pWidgetData = GetWidgetData();
+ if (!pWidgetData) {
+ return;
+ }
+ CFX_WideString wsLabel;
+ CFX_WideString wsValue;
+ if (iLength >= 1) {
+ CFX_ByteString bsLable = pArguments->GetUTF8String(0);
+ wsLabel = CFX_WideString::FromUTF8(bsLable, bsLable.GetLength());
+ }
+ if (iLength >= 2) {
+ CFX_ByteString bsValue = pArguments->GetUTF8String(1);
+ wsValue = CFX_WideString::FromUTF8(bsValue, bsValue.GetLength());
+ }
+ pWidgetData->InsertItem(wsLabel, wsValue, -1, TRUE);
+}
+void CXFA_Node::Script_Field_ExecValidate(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
+ if (!pNotify) {
+ FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
+ } else {
+ FX_INT32 iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate, FALSE, FALSE);
+ FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), ((iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE));
+ }
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"execValidate"));
+ }
+}
+void CXFA_Node::Script_ExclGroup_ErrorText(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (!bSetting) {
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ }
+}
+void CXFA_Node::Script_ExclGroup_DefaultAndRawValue(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ CXFA_WidgetData* pWidgetData = GetWidgetData();
+ if(!pWidgetData) {
+ return;
+ }
+ if (bSetting) {
+ CFX_ByteString bsValue;
+ FXJSE_Value_ToUTF8String(hValue, bsValue);
+ pWidgetData->SetSelectedMemberByValue(CFX_WideString::FromUTF8(bsValue, bsValue.GetLength()), TRUE, TRUE);
+ } else {
+ CFX_WideString wsValue = GetScriptContent(TRUE);
+ XFA_VERSION curVersion = GetDocument()->GetCurVersionMode();
+ if (wsValue.IsEmpty() && curVersion >= XFA_VERSION_300) {
+ FXJSE_Value_SetNull(hValue);
+ } else {
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue));
+ }
+ }
+}
+void CXFA_Node::Script_ExclGroup_Transient(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+}
+void CXFA_Node::Script_ExclGroup_ExecEvent(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 1) {
+ CFX_ByteString eventString = pArguments->GetUTF8String(0);
+ execSingleEventByName(CFX_WideString::FromUTF8(eventString, eventString.GetLength()), XFA_ELEMENT_ExclGroup);
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"execEvent"));
+ }
+}
+void CXFA_Node::Script_ExclGroup_SelectedMember(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if ((argc == 0) || (argc == 1)) {
+ CXFA_WidgetData* pWidgetData = GetWidgetData();
+ if (!pWidgetData) {
+ FXJSE_Value_SetNull(pArguments->GetReturnValue());
+ } else {
+ CXFA_Node * pReturnNode = NULL;
+ if (argc == 0) {
+ pReturnNode = pWidgetData->GetSelectedMember();
+ } else {
+ CFX_ByteString szName;
+ szName = pArguments->GetUTF8String(0);
+ pReturnNode = pWidgetData->SetSelectedMember(CFX_WideString::FromUTF8(szName, szName.GetLength()));
+ }
+ if (pReturnNode) {
+ FXJSE_Value_Set(pArguments->GetReturnValue(), m_pDocument->GetScriptContext()->GetJSValueFromMap(pReturnNode));
+ } else {
+ FXJSE_Value_SetNull(pArguments->GetReturnValue());
+ }
+ }
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"selectedMember"));
+ }
+}
+void CXFA_Node::Script_ExclGroup_ExecInitialize(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
+ if (!pNotify) {
+ return;
+ }
+ pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize);
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"execInitialize"));
+ }
+}
+void CXFA_Node::Script_ExclGroup_ExecCalculate(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
+ if (!pNotify) {
+ return;
+ }
+ pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate);
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"execCalculate"));
+ }
+}
+void CXFA_Node::Script_ExclGroup_ExecValidate(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
+ if (!pNotify) {
+ FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
+ } else {
+ FX_INT32 iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate);
+ FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), ((iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE));
+ }
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"execValidate"));
+ }
+}
+static CXFA_Node* XFA_ScriptInstanceManager_GetItem(CXFA_Node *pInstMgrNode, FX_INT32 iIndex)
+{
+ ASSERT(pInstMgrNode);
+ FX_INT32 iCount = 0;
+ FX_DWORD dwNameHash = 0;
+ for(CXFA_Node* pNode = pInstMgrNode->GetNodeItem(XFA_NODEITEM_NextSibling); pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
+ XFA_ELEMENT eCurType = pNode->GetClassID();
+ 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 NULL;
+ }
+ dwNameHash = pNode->GetNameHash();
+ }
+ if (dwNameHash != pNode->GetNameHash()) {
+ break;
+ }
+ iCount ++;
+ if (iCount > iIndex) {
+ return pNode;
+ }
+ }
+ return NULL;
+}
+void CXFA_Node::Script_Som_InstanceIndex(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ FX_INT32 iTo = FXJSE_Value_ToInteger(hValue);
+ FX_INT32 iFrom = Subform_and_SubformSet_InstanceIndex();
+ CXFA_Node *pManagerNode = NULL;
+ for (CXFA_Node *pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode != NULL; pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
+ if (pNode->GetClassID() == XFA_ELEMENT_InstanceManager) {
+ pManagerNode = pNode;
+ break;
+ }
+ }
+ if (pManagerNode) {
+ pManagerNode->InstanceManager_MoveInstance(iTo, iFrom);
+ IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
+ if (!pNotify) {
+ return;
+ }
+ CXFA_Node* pToInstance = XFA_ScriptInstanceManager_GetItem(pManagerNode, iTo);
+ if (pToInstance && pToInstance->GetClassID() == XFA_ELEMENT_Subform) {
+ pNotify->RunSubformIndexChange(pToInstance);
+ }
+ CXFA_Node* pFromInstance = XFA_ScriptInstanceManager_GetItem(pManagerNode, iFrom);
+ if (pFromInstance && pFromInstance->GetClassID() == XFA_ELEMENT_Subform) {
+ pNotify->RunSubformIndexChange(pFromInstance);
+ }
+ }
+ } else {
+ FXJSE_Value_SetInteger(hValue, Subform_and_SubformSet_InstanceIndex());
+ }
+}
+void CXFA_Node::Script_Subform_InstanceManager(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (!bSetting) {
+ CFX_WideStringC wsName = this->GetCData(XFA_ATTRIBUTE_Name);
+ CXFA_Node* pInstanceMgr = NULL;
+ for (CXFA_Node *pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode != NULL; pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
+ if (pNode->GetClassID() == 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) {
+ FXJSE_Value_Set(hValue, m_pDocument->GetScriptContext()->GetJSValueFromMap(pInstanceMgr));
+ } else {
+ FXJSE_Value_SetNull(hValue);
+ }
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ }
+}
+void CXFA_Node::Script_Subform_Locale(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ CFX_ByteString bsLocaleName;
+ FXJSE_Value_ToUTF8String(hValue, bsLocaleName);
+ this->SetCData(XFA_ATTRIBUTE_Locale, CFX_WideString::FromUTF8(bsLocaleName, bsLocaleName.GetLength()), TRUE, TRUE);
+ } else {
+ CFX_WideString wsLocaleName;
+ GetLocaleName(wsLocaleName);
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsLocaleName, wsLocaleName.GetLength()));
+ }
+}
+void CXFA_Node::Script_Subform_ExecEvent(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 1) {
+ CFX_ByteString eventString = pArguments->GetUTF8String(0);
+ execSingleEventByName(CFX_WideString::FromUTF8(eventString, eventString.GetLength()), XFA_ELEMENT_Subform);
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"execEvent"));
+ }
+}
+void CXFA_Node::Script_Subform_ExecInitialize(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
+ if (!pNotify) {
+ return;
+ }
+ pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize);
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"execInitialize"));
+ }
+}
+void CXFA_Node::Script_Subform_ExecCalculate(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
+ if (!pNotify) {
+ return;
+ }
+ pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate);
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"execCalculate"));
+ }
+}
+void CXFA_Node::Script_Subform_ExecValidate(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
+ if (!pNotify) {
+ FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
+ } else {
+ FX_INT32 iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate);
+ FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), ((iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE));
+ }
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"execValidate"));
+ }
+}
+void CXFA_Node::Script_Subform_GetInvalidObjects(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"getInvalidObjects"));
+ }
+}
+FX_INT32 CXFA_Node::Subform_and_SubformSet_InstanceIndex()
+{
+ FX_INT32 index = 0;
+ for (CXFA_Node *pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode != NULL; pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
+ if ((pNode->GetClassID() == XFA_ELEMENT_Subform) || (pNode->GetClassID() == XFA_ELEMENT_SubformSet)) {
+ index++;
+ } else {
+ break;
+ }
+ }
+ return index;
+}
+void CXFA_Node::Script_Template_FormNodes(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 1) {
+ FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), TRUE);
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"formNodes"));
+ }
+}
+void CXFA_Node::Script_Template_Remerge(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ m_pDocument->DoDataRemerge(TRUE);
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"remerge"));
+ }
+}
+void CXFA_Node::Script_Template_ExecInitialize(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ CXFA_WidgetData* pWidgetData = GetWidgetData();
+ if (!pWidgetData) {
+ FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
+ } else {
+ FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), TRUE);
+ }
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"execInitialize"));
+ }
+}
+void CXFA_Node::Script_Template_CreateNode(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 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, bsTagName.GetLength());
+ if (argc > 1) {
+ CFX_ByteString bsName = pArguments->GetUTF8String(1);
+ strName = CFX_WideString::FromUTF8(bsName, bsName.GetLength());
+ if (argc == 3) {
+ CFX_ByteString bsNameSpace = pArguments->GetUTF8String(2);
+ strNameSpace = CFX_WideString::FromUTF8(bsNameSpace, bsNameSpace.GetLength());
+ }
+ }
+ XFA_LPCELEMENTINFO pElement = XFA_GetElementByName(strTagName);
+ CXFA_Node *pNewNode = CreateSamePacketNode(pElement->eName);
+ if (!pNewNode) {
+ FXJSE_Value_SetNull(pArguments->GetReturnValue());
+ } else {
+ if (!strName.IsEmpty()) {
+ if ( XFA_GetAttributeOfElement(pElement->eName, XFA_ATTRIBUTE_Name, XFA_XDPPACKET_UNKNOWN)) {
+ pNewNode->SetAttribute(XFA_ATTRIBUTE_Name, strName, TRUE);
+ if (pNewNode->GetPacketID() == XFA_XDPPACKET_Datasets) {
+ pNewNode->CreateXMLMappingNode();
+ }
+ FXJSE_Value_Set(pArguments->GetReturnValue(), m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewNode));
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_NOT_HAVE_PROPERTY, (FX_LPCWSTR)strTagName, (FX_LPCWSTR)(L"name"));
+ }
+ } else {
+ FXJSE_Value_Set(pArguments->GetReturnValue(), m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewNode));
+ }
+ }
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"createNode"));
+ }
+}
+void CXFA_Node::Script_Template_Recalculate(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 1) {
+ FX_BOOL bScriptFlags = pArguments->GetInt32(0) == 0 ? FALSE : TRUE;
+ FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), TRUE);
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"recalculate"));
+ }
+}
+void CXFA_Node::Script_Template_ExecCalculate(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ CXFA_WidgetData* pWidgetData = GetWidgetData();
+ if (!pWidgetData) {
+ FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
+ } else {
+ FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), TRUE);
+ }
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"execCalculate"));
+ }
+}
+void CXFA_Node::Script_Template_ExecValidate(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ CXFA_WidgetData* pWidgetData = GetWidgetData();
+ if (!pWidgetData) {
+ FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
+ } else {
+ FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), TRUE);
+ }
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"execValidate"));
+ }
+}
+void CXFA_Node::Script_Manifest_Evaluate(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ CXFA_WidgetData* pWidgetData = GetWidgetData();
+ if (!pWidgetData) {
+ FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
+ } else {
+ FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), TRUE);
+ }
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"evaluate"));
+ }
+}
+void CXFA_Node::Script_InstanceManager_Max(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ return;
+ } else {
+ CXFA_Occur nodeOccur = GetOccurNode();
+ FXJSE_Value_SetInteger(hValue, nodeOccur.GetMax());
+ }
+}
+void CXFA_Node::Script_InstanceManager_Min(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ return;
+ } else {
+ CXFA_Occur nodeOccur = GetOccurNode();
+ FXJSE_Value_SetInteger(hValue, nodeOccur.GetMin());
+ }
+}
+static FX_INT32 XFA_ScriptInstanceManager_GetCount(CXFA_Node *pInstMgrNode)
+{
+ ASSERT(pInstMgrNode);
+ FX_INT32 iCount = 0;
+ FX_DWORD dwNameHash = 0;
+ for(CXFA_Node* pNode = pInstMgrNode->GetNodeItem(XFA_NODEITEM_NextSibling); pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
+ XFA_ELEMENT eCurType = pNode->GetClassID();
+ if (eCurType == XFA_ELEMENT_InstanceManager) {
+ break;
+ }
+ if ((eCurType != XFA_ELEMENT_Subform) && (eCurType != XFA_ELEMENT_SubformSet)) {
+ continue;
+ }
+ if (iCount == 0) {
+ CFX_WideStringC wsName = pNode->GetCData(XFA_ATTRIBUTE_Name);
+ CFX_WideStringC wsInstName = pInstMgrNode->GetCData(XFA_ATTRIBUTE_Name);
+ if (wsInstName.GetLength() < 1 || wsInstName.GetAt(0) != '_' || wsInstName.Mid(1) != wsName) {
+ return iCount;
+ }
+ dwNameHash = pNode->GetNameHash();
+ }
+ if (dwNameHash != pNode->GetNameHash()) {
+ break;
+ }
+ iCount ++;
+ }
+ return iCount;
+}
+static void XFA_ScriptInstanceManager_ReorderDataNodes_SortNodeArrayByDocumentIdx(const CXFA_NodeSet& rgNodeSet, CXFA_NodeArray& rgNodeArray, CFX_ArrayTemplate<FX_INT32>& rgIdxArray)
+{
+ FX_INT32 iCount = rgNodeSet.GetCount();
+ rgNodeArray.SetSize(iCount);
+ rgIdxArray.SetSize(iCount);
+ if(iCount == 0) {
+ return;
+ }
+ FX_INT32 iIndex = -1, iTotalIndex = -1;
+ CXFA_Node* pNode = NULL;
+ FX_POSITION pos = rgNodeSet.GetStartPosition();
+ rgNodeSet.GetNextAssoc(pos, pNode);
+ for(pNode = pNode->GetNodeItem(XFA_NODEITEM_Parent)->GetNodeItem(XFA_NODEITEM_FirstChild);
+ pNode && iIndex < iCount;
+ pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
+ iTotalIndex++;
+ if(rgNodeSet.Lookup(pNode)) {
+ iIndex ++;
+ rgNodeArray[iIndex] = pNode;
+ rgIdxArray[iIndex] = iTotalIndex;
+ }
+ }
+}
+struct CXFA_DualNodeArray : CFX_Object {
+ CXFA_NodeSet firstNodeList;
+ CXFA_NodeSet secondNodeList;
+};
+static void XFA_ScriptInstanceManager_ReorderDataNodes(CXFA_NodeSet& sSet1, CXFA_NodeSet& sSet2, FX_BOOL bInsertBefore)
+{
+ CFX_MapPtrTemplate<CXFA_Node*, CFX_MapPtrTemplate<FX_DWORD, CXFA_DualNodeArray*>*> rgNodeListMap;
+ FX_POSITION pos;
+ pos = sSet1.GetStartPosition();
+ while(pos) {
+ CXFA_Node* pNode = NULL;
+ sSet1.GetNextAssoc(pos, pNode);
+ CXFA_Node* pParentNode = pNode->GetNodeItem(XFA_NODEITEM_Parent);
+ FX_DWORD dwNameHash = pNode->GetNameHash();
+ if(!pParentNode || !dwNameHash) {
+ continue;
+ }
+ CFX_MapPtrTemplate<FX_DWORD, CXFA_DualNodeArray*>* pNodeListChildMap = rgNodeListMap[pParentNode];
+ if(!pNodeListChildMap) {
+ rgNodeListMap[pParentNode] = pNodeListChildMap = FX_NEW CFX_MapPtrTemplate<FX_DWORD, CXFA_DualNodeArray*>;
+ }
+ CXFA_DualNodeArray* pDualNodeArray = (*pNodeListChildMap)[dwNameHash];
+ if(!pDualNodeArray) {
+ (*pNodeListChildMap)[dwNameHash] = pDualNodeArray = FX_NEW CXFA_DualNodeArray;
+ }
+ pDualNodeArray->firstNodeList.Add(pNode);
+ }
+ pos = sSet2.GetStartPosition();
+ while(pos) {
+ CXFA_Node* pNode = NULL;
+ sSet2.GetNextAssoc(pos, pNode);
+ CXFA_Node* pParentNode = pNode->GetNodeItem(XFA_NODEITEM_Parent);
+ FX_DWORD dwNameHash = pNode->GetNameHash();
+ if(!pParentNode || !dwNameHash) {
+ continue;
+ }
+ CFX_MapPtrTemplate<FX_DWORD, CXFA_DualNodeArray*>* pNodeListChildMap = rgNodeListMap[pParentNode];
+ if(!pNodeListChildMap) {
+ rgNodeListMap[pParentNode] = pNodeListChildMap = FX_NEW CFX_MapPtrTemplate<FX_DWORD, CXFA_DualNodeArray*>;
+ }
+ CXFA_DualNodeArray* pDualNodeArray = (*pNodeListChildMap)[dwNameHash];
+ if(!pDualNodeArray) {
+ (*pNodeListChildMap)[dwNameHash] = pDualNodeArray = FX_NEW CXFA_DualNodeArray;
+ }
+ if(pDualNodeArray->firstNodeList.Lookup(pNode)) {
+ pDualNodeArray->firstNodeList.RemoveKey(pNode);
+ } else {
+ pDualNodeArray->secondNodeList.Add(pNode);
+ }
+ }
+ pos = rgNodeListMap.GetStartPosition();
+ while (pos) {
+ CXFA_Node* pParentNode = NULL;
+ CFX_MapPtrTemplate<FX_DWORD, CXFA_DualNodeArray*>* pNodeListChildMap = NULL;
+ rgNodeListMap.GetNextAssoc(pos, pParentNode, pNodeListChildMap);
+ if(!pNodeListChildMap) {
+ continue;
+ }
+ FX_POSITION childpos = pNodeListChildMap->GetStartPosition();
+ while(childpos) {
+ FX_DWORD dwNameHash = 0;
+ CXFA_DualNodeArray* pDualNodeArray = NULL;
+ pNodeListChildMap->GetNextAssoc(childpos, dwNameHash, pDualNodeArray);
+ if(!pDualNodeArray) {
+ continue;
+ }
+ if(pDualNodeArray->firstNodeList.GetCount() != 0 && pDualNodeArray->secondNodeList.GetCount() != 0) {
+ CXFA_NodeArray rgNodeArray1, rgNodeArray2;
+ CFX_ArrayTemplate<FX_INT32> rgIdxArray1, rgIdxArray2;
+ XFA_ScriptInstanceManager_ReorderDataNodes_SortNodeArrayByDocumentIdx(pDualNodeArray->firstNodeList, rgNodeArray1, rgIdxArray1);
+ XFA_ScriptInstanceManager_ReorderDataNodes_SortNodeArrayByDocumentIdx(pDualNodeArray->secondNodeList, rgNodeArray2, rgIdxArray2);
+ FX_INT32 iLimit;
+ CXFA_Node *pParentNode = NULL, *pBeforeNode = NULL;
+ if(bInsertBefore) {
+ iLimit = rgIdxArray2[0];
+ pBeforeNode = rgNodeArray2[0];
+ pParentNode = pBeforeNode->GetNodeItem(XFA_NODEITEM_Parent);
+ } else {
+ iLimit = rgIdxArray2[rgIdxArray2.GetSize() - 1];
+ CXFA_Node *pLastNode = rgNodeArray2[rgIdxArray2.GetSize() - 1];
+ pParentNode = pLastNode->GetNodeItem(XFA_NODEITEM_Parent);
+ pBeforeNode = pLastNode->GetNodeItem(XFA_NODEITEM_NextSibling);
+ }
+ for(FX_INT32 iIdx = 0, iCount = rgIdxArray1.GetSize(); iIdx < iCount; iIdx++) {
+ CXFA_Node* pCurNode = rgNodeArray1[iIdx];
+ pParentNode->RemoveChild(pCurNode);
+ pParentNode->InsertChild(pCurNode, pBeforeNode);
+ }
+ }
+ delete pDualNodeArray;
+ }
+ pNodeListChildMap->RemoveAll();
+ }
+ rgNodeListMap.RemoveAll();
+}
+static void XFA_ScriptInstanceManager_InsertItem(CXFA_Node *pInstMgrNode, CXFA_Node *pNewInstance, FX_INT32 iPos, FX_INT32 iCount = -1, FX_BOOL bMoveDataBindingNodes = TRUE)
+{
+ if(iCount < 0) {
+ iCount = XFA_ScriptInstanceManager_GetCount(pInstMgrNode);
+ }
+ if(iPos < 0) {
+ iPos = iCount;
+ }
+ if(iPos == iCount) {
+ CXFA_Node* pNextSibling = iCount > 0 ? XFA_ScriptInstanceManager_GetItem(pInstMgrNode, iCount - 1)->GetNodeItem(XFA_NODEITEM_NextSibling)
+ : pInstMgrNode->GetNodeItem(XFA_NODEITEM_NextSibling);
+ pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent)->InsertChild(pNewInstance, pNextSibling);
+ if(bMoveDataBindingNodes) {
+ CXFA_NodeSet sNew, 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.Add(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.Add(pDataNode);
+ }
+ XFA_ScriptInstanceManager_ReorderDataNodes(sNew, sAfter, FALSE);
+ }
+ } else {
+ CXFA_Node * pBeforeInstance = XFA_ScriptInstanceManager_GetItem(pInstMgrNode, iPos);
+ pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent)->InsertChild(pNewInstance, pBeforeInstance);
+ if(bMoveDataBindingNodes) {
+ CXFA_NodeSet sNew, 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.Add(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.Add(pDataNode);
+ }
+ XFA_ScriptInstanceManager_ReorderDataNodes(sNew, sBefore, TRUE);
+ }
+ }
+}
+static void XFA_ScriptInstanceManager_RemoveItem(CXFA_Node *pInstMgrNode, CXFA_Node *pRemoveInstance, FX_BOOL bRemoveDataBinding = TRUE)
+{
+ pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent)->RemoveChild(pRemoveInstance);
+ if(!bRemoveDataBinding) {
+ return;
+ }
+ CXFA_NodeIteratorTemplate<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, NULL);
+ }
+}
+static CXFA_Node* XFA_ScriptInstanceManager_CreateInstance(CXFA_Node *pInstMgrNode, FX_BOOL bDataMerge)
+{
+ CXFA_Document* pDocument = pInstMgrNode->GetDocument();
+ CXFA_Node* pTemplateNode = pInstMgrNode->GetTemplateNode();
+ CXFA_Node* pFormParent = pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent);
+ CXFA_Node* pDataScope = NULL;
+ for(CXFA_Node* pRootBoundNode = pFormParent; pRootBoundNode && pRootBoundNode->GetObjectType() == XFA_OBJECTTYPE_ContainerNode; pRootBoundNode = pRootBoundNode->GetNodeItem(XFA_NODEITEM_Parent)) {
+ pDataScope = pRootBoundNode->GetBindData();
+ if(pDataScope) {
+ break;
+ }
+ }
+ if(!pDataScope) {
+ pDataScope = (CXFA_Node*)pDocument->GetXFANode(XFA_HASHCODE_Record);
+ ASSERT(pDataScope);
+ }
+ CXFA_Node *pInstance = pDocument->DataMerge_CopyContainer(pTemplateNode, pFormParent, pDataScope, TRUE, bDataMerge);
+ if(pInstance) {
+ pDocument->DataMerge_UpdateBindingRelations(pInstance);
+ pFormParent->RemoveChild(pInstance);
+ }
+ return pInstance;
+}
+void CXFA_Node::Script_InstanceManager_Count(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ FX_INT32 iDesired = FXJSE_Value_ToInteger(hValue);
+ InstanceManager_SetInstances(iDesired);
+ } else {
+ FXJSE_Value_SetInteger(hValue, XFA_ScriptInstanceManager_GetCount(this));
+ }
+}
+void CXFA_Node::Script_InstanceManager_MoveInstance(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc != 2) {
+ FXJSE_Value_SetUndefined(pArguments->GetReturnValue());
+ return;
+ }
+ FX_INT32 iFrom = pArguments->GetInt32(0);
+ FX_INT32 iTo = pArguments->GetInt32(1);
+ InstanceManager_MoveInstance(iTo, iFrom);
+ IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
+ if (!pNotify) {
+ return;
+ }
+ CXFA_Node* pToInstance = XFA_ScriptInstanceManager_GetItem(this, iTo);
+ if (pToInstance && pToInstance->GetClassID() == XFA_ELEMENT_Subform) {
+ pNotify->RunSubformIndexChange(pToInstance);
+ }
+ CXFA_Node* pFromInstance = XFA_ScriptInstanceManager_GetItem(this, iFrom);
+ if (pFromInstance && pFromInstance->GetClassID() == XFA_ELEMENT_Subform) {
+ pNotify->RunSubformIndexChange(pFromInstance);
+ }
+}
+void CXFA_Node::Script_InstanceManager_RemoveInstance(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc != 1) {
+ FXJSE_Value_SetUndefined(pArguments->GetReturnValue());
+ return;
+ }
+ FX_INT32 iIndex = pArguments->GetInt32(0);
+ FX_INT32 iCount = XFA_ScriptInstanceManager_GetCount(this);
+ if (iIndex < 0 || iIndex >= iCount) {
+ ThrowScriptErrorMessage(XFA_IDS_INDEX_OUT_OF_BOUNDS);
+ return;
+ }
+ CXFA_Occur nodeOccur = GetOccurNode();
+ FX_INT32 iMin = nodeOccur.GetMin();
+ if (iCount - 1 < iMin) {
+ ThrowScriptErrorMessage(XFA_IDS_VIOLATE_BOUNDARY, (FX_LPCWSTR)(L"min"));
+ return;
+ }
+ CXFA_Node *pRemoveInstance = XFA_ScriptInstanceManager_GetItem(this, iIndex);
+ XFA_ScriptInstanceManager_RemoveItem(this, pRemoveInstance);
+ IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
+ if (pNotify) {
+ for (FX_INT32 i = iIndex; i < iCount - 1; i++) {
+ CXFA_Node *pSubformInstance = XFA_ScriptInstanceManager_GetItem(this, i);
+ if (pSubformInstance && pSubformInstance->GetClassID() == XFA_ELEMENT_Subform) {
+ pNotify->RunSubformIndexChange(pSubformInstance);
+ }
+ }
+ }
+ CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
+ if (!pLayoutPro) {
+ return;
+ }
+ pLayoutPro->AddChangedContainer((CXFA_Node*)m_pDocument->GetXFANode(XFA_HASHCODE_Form));
+}
+void CXFA_Node::Script_InstanceManager_SetInstances(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc != 1) {
+ FXJSE_Value_SetUndefined(pArguments->GetReturnValue());
+ return;
+ }
+ FX_INT32 iDesired = pArguments->GetInt32(0);
+ InstanceManager_SetInstances(iDesired);
+}
+void CXFA_Node::Script_InstanceManager_AddInstance(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if ((argc != 0) && (argc != 1)) {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"addInstance"));
+ return;
+ }
+ FX_BOOL fFlags = TRUE;
+ if (argc == 1) {
+ fFlags = pArguments->GetInt32(0) == 0 ? FALSE : TRUE;
+ }
+ FX_INT32 iCount = XFA_ScriptInstanceManager_GetCount(this);
+ CXFA_Occur nodeOccur = GetOccurNode();
+ FX_INT32 iMax = nodeOccur.GetMax();
+ if (iMax >= 0 && iCount >= iMax) {
+ ThrowScriptErrorMessage(XFA_IDS_VIOLATE_BOUNDARY, (FX_LPCWSTR)(L"max"));
+ return;
+ }
+ CXFA_Node* pNewInstance = XFA_ScriptInstanceManager_CreateInstance(this, fFlags);
+ XFA_ScriptInstanceManager_InsertItem(this, pNewInstance, iCount, iCount, FALSE);
+ FXJSE_Value_Set(pArguments->GetReturnValue(), m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewInstance));
+ IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
+ if (!pNotify) {
+ return;
+ }
+ pNotify->RunNodeInitialize(pNewInstance);
+ CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
+ if (!pLayoutPro) {
+ return;
+ }
+ pLayoutPro->AddChangedContainer((CXFA_Node*)m_pDocument->GetXFANode(XFA_HASHCODE_Form));
+}
+void CXFA_Node::Script_InstanceManager_InsertInstance(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if ((argc != 1) && (argc != 2)) {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"insertInstance"));
+ return;
+ }
+ FX_INT32 iIndex = pArguments->GetInt32(0);
+ FX_BOOL bBind = FALSE;
+ if (argc == 2) {
+ bBind = pArguments->GetInt32(1) == 0 ? FALSE : TRUE;
+ }
+ CXFA_Occur nodeOccur = GetOccurNode();
+ FX_INT32 iCount = XFA_ScriptInstanceManager_GetCount(this);
+ if (iIndex < 0 || iIndex > iCount) {
+ ThrowScriptErrorMessage(XFA_IDS_INDEX_OUT_OF_BOUNDS);
+ return;
+ }
+ FX_INT32 iMax = nodeOccur.GetMax();
+ if (iMax >= 0 && iCount >= iMax) {
+ ThrowScriptErrorMessage(XFA_IDS_VIOLATE_BOUNDARY, (FX_LPCWSTR)(L"max"));
+ return;
+ }
+ CXFA_Node* pNewInstance = XFA_ScriptInstanceManager_CreateInstance(this, bBind);
+ XFA_ScriptInstanceManager_InsertItem(this, pNewInstance, iIndex, iCount, TRUE);
+ FXJSE_Value_Set(pArguments->GetReturnValue(), m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewInstance));
+ IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
+ if (!pNotify) {
+ return;
+ }
+ pNotify->RunNodeInitialize(pNewInstance);
+ CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
+ if (!pLayoutPro) {
+ return;
+ }
+ pLayoutPro->AddChangedContainer((CXFA_Node*)m_pDocument->GetXFANode(XFA_HASHCODE_Form));
+}
+FX_INT32 CXFA_Node::InstanceManager_SetInstances(FX_INT32 iDesired)
+{
+ CXFA_Occur nodeOccur = GetOccurNode();
+ FX_INT32 iMax = nodeOccur.GetMax();
+ FX_INT32 iMin = nodeOccur.GetMin();
+ if (iDesired < iMin) {
+ ThrowScriptErrorMessage(XFA_IDS_VIOLATE_BOUNDARY, (FX_LPCWSTR)(L"min"));
+ return 1;
+ }
+ if ((iMax >= 0) && (iDesired > iMax)) {
+ ThrowScriptErrorMessage(XFA_IDS_VIOLATE_BOUNDARY, (FX_LPCWSTR)(L"max"));
+ return 2;
+ }
+ FX_INT32 iCount = XFA_ScriptInstanceManager_GetCount(this);
+ if (iDesired == iCount) {
+ return 0;
+ }
+ if(iDesired < iCount) {
+ CFX_WideStringC wsInstManagerName = this->GetCData(XFA_ATTRIBUTE_Name);
+ CFX_WideString wsInstanceName = wsInstManagerName.IsEmpty() ? wsInstManagerName : wsInstManagerName.Mid(1);
+ FX_DWORD dInstanceNameHash = wsInstanceName.IsEmpty() ? 0 : FX_HashCode_String_GetW(wsInstanceName, wsInstanceName.GetLength());
+ CXFA_Node* pPrevSibling = (iDesired == 0) ? this : XFA_ScriptInstanceManager_GetItem(this, iDesired - 1);
+ while(iCount > iDesired) {
+ CXFA_Node* pRemoveInstance = pPrevSibling->GetNodeItem(XFA_NODEITEM_NextSibling);
+ if (pRemoveInstance->GetClassID() != XFA_ELEMENT_Subform && pRemoveInstance->GetClassID() != XFA_ELEMENT_SubformSet) {
+ continue;
+ }
+ if (pRemoveInstance->GetClassID() == XFA_ELEMENT_InstanceManager) {
+ FXSYS_assert(FALSE);
+ break;
+ }
+ if (pRemoveInstance->GetNameHash() == dInstanceNameHash) {
+ XFA_ScriptInstanceManager_RemoveItem(this, pRemoveInstance);
+ iCount--;
+ }
+ }
+ } else if (iDesired > iCount) {
+ CXFA_Node* pTemplateNode = GetTemplateNode();
+ CXFA_Node* pFormNode = GetNodeItem(XFA_NODEITEM_NextSibling);
+ while (iCount < iDesired) {
+ CXFA_Node* pNewInstance = XFA_ScriptInstanceManager_CreateInstance(this, TRUE);
+ XFA_ScriptInstanceManager_InsertItem(this, pNewInstance, iCount, iCount, FALSE);
+ iCount ++;
+ IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
+ if (!pNotify) {
+ return 0;
+ }
+ pNotify->RunNodeInitialize(pNewInstance);
+ }
+ }
+ CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
+ if (!pLayoutPro) {
+ return 0;
+ }
+ pLayoutPro->AddChangedContainer((CXFA_Node*)m_pDocument->GetXFANode(XFA_HASHCODE_Form));
+ return 0;
+}
+FX_INT32 CXFA_Node::InstanceManager_MoveInstance(FX_INT32 iTo, FX_INT32 iFrom)
+{
+ FX_INT32 iCount = XFA_ScriptInstanceManager_GetCount(this);
+ if (iFrom > iCount || iTo > iCount - 1) {
+ ThrowScriptErrorMessage(XFA_IDS_INDEX_OUT_OF_BOUNDS);
+ return 1;
+ }
+ if (iFrom < 0 || iTo < 0 || iFrom == iTo) {
+ return 0;
+ }
+ CXFA_Node * pMoveInstance = XFA_ScriptInstanceManager_GetItem(this, iFrom);
+ XFA_ScriptInstanceManager_RemoveItem(this, pMoveInstance, FALSE);
+ XFA_ScriptInstanceManager_InsertItem(this, pMoveInstance, iTo, iCount - 1, TRUE);
+ CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
+ if (!pLayoutPro) {
+ return 0;
+ }
+ pLayoutPro->AddChangedContainer((CXFA_Node*)m_pDocument->GetXFANode(XFA_HASHCODE_Form));
+ return 0;
+}
+void CXFA_Node::Script_Occur_Max(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ CXFA_Occur occur(this);
+ if (bSetting) {
+ FX_INT32 iMax = FXJSE_Value_ToInteger(hValue);
+ occur.SetMax(iMax);
+ } else {
+ FXJSE_Value_SetInteger(hValue, occur.GetMax());
+ }
+}
+void CXFA_Node::Script_Occur_Min(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ CXFA_Occur occur(this);
+ if (bSetting) {
+ FX_INT32 iMin = FXJSE_Value_ToInteger(hValue);
+ occur.SetMin(iMin);
+ } else {
+ FXJSE_Value_SetInteger(hValue, occur.GetMin());
+ }
+}
+void CXFA_Node::Script_Desc_Metadata(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if ((argc == 0) || (argc == 1)) {
+ FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), FX_BSTRC(""));
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"metadata"));
+ }
+}
+void CXFA_Node::Script_Form_FormNodes(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 1) {
+ CXFA_Node * pDataNode = (CXFA_Node *)pArguments->GetObject(0);
+ if (pDataNode) {
+ CXFA_NodeArray formItems;
+ FX_INT32 iSize = pDataNode->GetBindItems(formItems);
+ CXFA_ArrayNodeList *pFormNodes = FX_NEW CXFA_ArrayNodeList(m_pDocument);
+ pFormNodes->SetArrayNodeList(formItems);
+ FXJSE_Value_SetObject(pArguments->GetReturnValue(), (CXFA_Object*)pFormNodes, m_pDocument->GetScriptContext()->GetJseNormalClass());
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+ }
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"formNodes"));
+ }
+}
+void CXFA_Node::Script_Form_Remerge(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ m_pDocument->DoDataRemerge(TRUE);
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"remerge"));
+ }
+}
+void CXFA_Node::Script_Form_ExecInitialize(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
+ if (!pNotify) {
+ return;
+ }
+ pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize);
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(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;
+ }
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 1) {
+ FX_BOOL bScriptFlags = pArguments->GetInt32(0) == 0 ? FALSE : TRUE;
+ IXFA_Notify* pNotify = m_pDocument->GetParser()->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 {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"recalculate"));
+ }
+}
+void CXFA_Node::Script_Form_ExecCalculate(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
+ if (!pNotify) {
+ return;
+ }
+ pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate);
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"execCalculate"));
+ }
+}
+void CXFA_Node::Script_Form_ExecValidate(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
+ if (!pNotify) {
+ FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
+ } else {
+ FX_INT32 iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate);
+ FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), ((iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE));
+ }
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"execValidate"));
+ }
+}
+void CXFA_Node::Script_Form_Checksum(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ CFX_ByteString bsChecksum;
+ FXJSE_Value_ToUTF8String(hValue, bsChecksum);
+ SetAttribute(XFA_ATTRIBUTE_Checksum, CFX_WideString::FromUTF8(bsChecksum, bsChecksum.GetLength()));
+ } else {
+ CFX_WideString wsChecksum;
+ GetAttribute(XFA_ATTRIBUTE_Checksum, wsChecksum, FALSE);
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsChecksum, wsChecksum.GetLength()));
+ }
+}
+void CXFA_Node::Script_Packet_GetAttribute(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 1) {
+ CFX_ByteString bsAttributeName = pArguments->GetUTF8String(0);
+ CFX_WideString wsAttributeValue;
+ IFDE_XMLNode* pXMLNode = GetXMLMappingNode();
+ if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
+ ((IFDE_XMLElement *)pXMLNode)->GetString(CFX_WideString::FromUTF8(bsAttributeName, bsAttributeName.GetLength()), wsAttributeValue);
+ }
+ FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), FX_UTF8Encode(wsAttributeValue, wsAttributeValue.GetLength()));
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"getAttribute"));
+ }
+}
+void CXFA_Node::Script_Packet_SetAttribute(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 2) {
+ CFX_ByteString bsValue = pArguments->GetUTF8String(0);
+ CFX_ByteString bsName = pArguments->GetUTF8String(1);
+ IFDE_XMLNode* pXMLNode = GetXMLMappingNode();
+ if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
+ ((IFDE_XMLElement *)pXMLNode)->SetString(CFX_WideString::FromUTF8(bsName, bsName.GetLength()), CFX_WideString::FromUTF8(bsValue, bsValue.GetLength()));
+ }
+ FXJSE_Value_SetNull(pArguments->GetReturnValue());
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"setAttribute"));
+ }
+}
+void CXFA_Node::Script_Packet_RemoveAttribute(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 1) {
+ CFX_ByteString bsName = pArguments->GetUTF8String(0);
+ CFX_WideString wsName = CFX_WideString::FromUTF8(bsName, bsName.GetLength());
+ IFDE_XMLNode* pXMLNode = GetXMLMappingNode();
+ if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
+ IFDE_XMLElement *pXMLElement = (IFDE_XMLElement *)pXMLNode;
+ if (pXMLElement->HasAttribute(wsName)) {
+ pXMLElement->RemoveAttribute(wsName);
+ }
+ }
+ FXJSE_Value_SetNull(pArguments->GetReturnValue());
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"removeAttribute"));
+ }
+}
+void CXFA_Node::Script_Packet_Content(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ CFX_ByteString bsNewContent;
+ FXJSE_Value_ToUTF8String(hValue, bsNewContent);
+ IFDE_XMLNode* pXMLNode = GetXMLMappingNode();
+ if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
+ IFDE_XMLElement *pXMLElement = (IFDE_XMLElement *)pXMLNode;
+ pXMLElement->SetTextData(CFX_WideString::FromUTF8(bsNewContent, bsNewContent.GetLength()));
+ }
+ } else {
+ CFX_WideString wsTextData;
+ IFDE_XMLNode* pXMLNode = GetXMLMappingNode();
+ if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
+ IFDE_XMLElement *pXMLElement = (IFDE_XMLElement *)pXMLNode;
+ pXMLElement->GetTextData(wsTextData);
+ }
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsTextData, wsTextData.GetLength()));
+ }
+}
+void CXFA_Node::Script_Source_Next(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"next"));
+ }
+}
+void CXFA_Node::Script_Source_CancelBatch(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"cancelBatch"));
+ }
+}
+void CXFA_Node::Script_Source_First(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"first"));
+ }
+}
+void CXFA_Node::Script_Source_UpdateBatch(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"updateBatch"));
+ }
+}
+void CXFA_Node::Script_Source_Previous(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"previous"));
+ }
+}
+void CXFA_Node::Script_Source_IsBOF(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"isBOF"));
+ }
+}
+void CXFA_Node::Script_Source_IsEOF(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"isEOF"));
+ }
+}
+void CXFA_Node::Script_Source_Cancel(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"cancel"));
+ }
+}
+void CXFA_Node::Script_Source_Update(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"update"));
+ }
+}
+void CXFA_Node::Script_Source_Open(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"open"));
+ }
+}
+void CXFA_Node::Script_Source_Delete(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"delete"));
+ }
+}
+void CXFA_Node::Script_Source_AddNew(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"addNew"));
+ }
+}
+void CXFA_Node::Script_Source_Requery(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"requery"));
+ }
+}
+void CXFA_Node::Script_Source_Resync(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"resync"));
+ }
+}
+void CXFA_Node::Script_Source_Close(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"close"));
+ }
+}
+void CXFA_Node::Script_Source_Last(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"last"));
+ }
+}
+void CXFA_Node::Script_Source_HasDataChanged(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if (argc == 0) {
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"hasDataChanged"));
+ }
+}
+void CXFA_Node::Script_Source_Db(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+}
+void CXFA_Node::Script_Xfa_This(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (!bSetting) {
+ CXFA_Object* pThis = m_pDocument->GetScriptContext()->GetThisObject();
+ FXSYS_assert(pThis);
+ FXJSE_Value_Set(hValue, m_pDocument->GetScriptContext()->GetJSValueFromMap(pThis));
+ }
+}
+void CXFA_Node::Script_Handler_Version(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+}
+void CXFA_Node::Script_SubmitFormat_Mode(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+}
+void CXFA_Node::Script_Extras_Type(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+}
+void CXFA_Node::Script_Script_Stateless(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if (bSetting) {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ return;
+ }
+ FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(FX_WSTRC(L"0")));
+}
+void CXFA_Node::Script_Encrypt_Format(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+}
+enum XFA_KEYTYPE {
+ XFA_KEYTYPE_Custom,
+ XFA_KEYTYPE_Element,
+};
+FX_LPVOID XFA_GetMapKey_Custom(FX_WSTR wsKey)
+{
+ FX_DWORD dwKey = FX_HashCode_String_GetW(wsKey.GetPtr(), wsKey.GetLength());
+ return (FX_LPVOID)(FX_UINTPTR)((dwKey << 1) | XFA_KEYTYPE_Custom);
+}
+FX_LPVOID XFA_GetMapKey_Element(XFA_ELEMENT eElement, XFA_ATTRIBUTE eAttribute)
+{
+ return (FX_LPVOID)(FX_UINTPTR)((eElement << 16) | (eAttribute << 8) | XFA_KEYTYPE_Element);
+}
+static inline FX_BOOL XFA_NodeData_PrepareKey(XFA_ELEMENT eElem, XFA_ATTRIBUTE eAttr, FX_LPVOID &pKey)
+{
+ pKey = XFA_GetMapKey_Element(eElem, eAttr);
+ return TRUE;
+}
+FX_BOOL CXFA_Node::HasAttribute(XFA_ATTRIBUTE eAttr, FX_BOOL bCanInherit )
+{
+ FX_LPVOID pKey = NULL;
+ if (!XFA_NodeData_PrepareKey(GetClassID(), eAttr, pKey)) {
+ return FALSE;
+ }
+ return HasMapModuleKey(pKey, bCanInherit);
+}
+FX_BOOL CXFA_Node::SetAttribute(XFA_ATTRIBUTE eAttr, FX_WSTR wsValue, FX_BOOL bNotify )
+{
+ XFA_LPCATTRIBUTEINFO pAttr = XFA_GetAttributeByID(eAttr);
+ if (pAttr == NULL) {
+ return FALSE;
+ }
+ XFA_ATTRIBUTETYPE eType = pAttr->eType;
+ if (eType == XFA_ATTRIBUTETYPE_NOTSURE) {
+ XFA_LPCNOTSUREATTRIBUTE pNotsure = XFA_GetNotsureAttribute(GetClassID(), pAttr->eName);
+ eType = pNotsure ? pNotsure->eType : XFA_ATTRIBUTETYPE_Cdata;
+ }
+ switch (eType) {
+ case XFA_ATTRIBUTETYPE_Enum: {
+ XFA_LPCATTRIBUTEENUMINFO pEnum = XFA_GetAttributeEnumByName(wsValue);
+ return SetEnum(pAttr->eName, pEnum ? pEnum->eName : (XFA_ATTRIBUTEENUM)(FX_INTPTR)(pAttr->pDefValue), bNotify);
+ }
+ break;
+ case XFA_ATTRIBUTETYPE_Cdata:
+ return SetCData(pAttr->eName, 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.GetPtr(), wsValue.GetLength())), 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 )
+{
+ XFA_LPCATTRIBUTEINFO pAttr = XFA_GetAttributeByID(eAttr);
+ if (pAttr == NULL) {
+ return FALSE;
+ }
+ XFA_ATTRIBUTETYPE eType = pAttr->eType;
+ if (eType == XFA_ATTRIBUTETYPE_NOTSURE) {
+ XFA_LPCNOTSUREATTRIBUTE pNotsure = XFA_GetNotsureAttribute(GetClassID(), 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: {
+ FX_INT32 iValue;
+ if (!TryInteger(pAttr->eName, iValue, bUseDefault)) {
+ return FALSE;
+ }
+ wsValue.Format((FX_LPCWSTR)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(FX_WSTR wsAttr, FX_WSTR wsValue, FX_BOOL bNotify)
+{
+ XFA_LPCATTRIBUTEINFO pAttributeInfo = XFA_GetAttributeByName(wsValue);
+ if (pAttributeInfo) {
+ return SetAttribute(pAttributeInfo->eName, wsValue, bNotify);
+ }
+ FX_LPVOID pKey = XFA_GetMapKey_Custom(wsAttr);
+ SetMapModuleString(pKey, wsValue);
+ return TRUE;
+}
+FX_BOOL CXFA_Node::GetAttribute(FX_WSTR wsAttr, CFX_WideString &wsValue, FX_BOOL bUseDefault)
+{
+ XFA_LPCATTRIBUTEINFO pAttributeInfo = XFA_GetAttributeByName(wsAttr);
+ if (pAttributeInfo) {
+ return GetAttribute(pAttributeInfo->eName, wsValue, bUseDefault);
+ }
+ FX_LPVOID pKey = XFA_GetMapKey_Custom(wsAttr);
+ CFX_WideStringC wsValueC;
+ if (GetMapModuleString(pKey, wsValueC)) {
+ wsValue = wsValueC;
+ }
+ return TRUE;
+}
+FX_BOOL CXFA_Node::RemoveAttribute(FX_WSTR wsAttr)
+{
+ FX_LPVOID pKey = XFA_GetMapKey_Custom(wsAttr);
+ RemoveMapModuleKey(pKey);
+ return TRUE;
+}
+FX_BOOL CXFA_Node::TryBoolean(XFA_ATTRIBUTE eAttr, FX_BOOL &bValue, FX_BOOL bUseDefault )
+{
+ FX_LPVOID pValue = NULL;
+ if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Boolean, bUseDefault, pValue)) {
+ return FALSE;
+ }
+ bValue = (FX_BOOL)(FX_UINTPTR)pValue;
+ return TRUE;
+}
+FX_BOOL CXFA_Node::TryInteger(XFA_ATTRIBUTE eAttr, FX_INT32 &iValue, FX_BOOL bUseDefault)
+{
+ FX_LPVOID pValue = NULL;
+ if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Integer, bUseDefault, pValue)) {
+ return FALSE;
+ }
+ iValue = (FX_INT32)(FX_UINTPTR)pValue;
+ return TRUE;
+}
+FX_BOOL CXFA_Node::TryEnum(XFA_ATTRIBUTE eAttr, XFA_ATTRIBUTEENUM &eValue, FX_BOOL bUseDefault)
+{
+ FX_LPVOID pValue = NULL;
+ if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Enum, bUseDefault, pValue)) {
+ return FALSE;
+ }
+ eValue = (XFA_ATTRIBUTEENUM)(FX_UINTPTR)pValue;
+ return TRUE;
+}
+FX_BOOL CXFA_Node::SetMeasure(XFA_ATTRIBUTE eAttr, CXFA_Measurement mValue, FX_BOOL bNotify )
+{
+ FX_LPVOID pKey = NULL;
+ if (!XFA_NodeData_PrepareKey(GetClassID(), eAttr, pKey)) {
+ return FALSE;
+ }
+ OnChanging(eAttr, &mValue, bNotify);
+ SetMapModuleBuffer(pKey, &mValue, sizeof(CXFA_Measurement));
+ OnChanged(eAttr, &mValue, bNotify);
+ return TRUE;
+}
+FX_BOOL CXFA_Node::TryMeasure(XFA_ATTRIBUTE eAttr, CXFA_Measurement &mValue, FX_BOOL bUseDefault)
+{
+ FX_LPVOID pKey = NULL;
+ if (!XFA_NodeData_PrepareKey(GetClassID(), eAttr, pKey)) {
+ return FALSE;
+ }
+ FX_LPVOID pValue;
+ FX_INT32 iBytes;
+ if(GetMapModuleBuffer(pKey, pValue, iBytes) && iBytes == sizeof(mValue)) {
+ FX_memcpy(&mValue, pValue, sizeof(mValue));
+ return TRUE;
+ }
+ if(bUseDefault && XFA_GetAttributeDefaultValue(pValue, GetClassID(), eAttr, XFA_ATTRIBUTETYPE_Measure, m_ePacket)) {
+ FX_memcpy(&mValue, pValue, sizeof(mValue));
+ return TRUE;
+ }
+ return FALSE;
+}
+FX_BOOL CXFA_Node::SetCData(XFA_ATTRIBUTE eAttr, const CFX_WideString& wsValue, FX_BOOL bNotify, FX_BOOL bScriptModify)
+{
+ FX_LPVOID pKey = NULL;
+ if (!XFA_NodeData_PrepareKey(GetClassID(), eAttr, pKey)) {
+ return FALSE;
+ }
+ OnChanging(eAttr, (FX_LPVOID)(FX_LPCWSTR)wsValue, bNotify);
+ if (eAttr == XFA_ATTRIBUTE_Value) {
+ CFX_WideString *pClone = FX_NEW CFX_WideString(wsValue);
+ if (pClone == NULL) {
+ return FALSE;
+ }
+ SetUserData(pKey, pClone, &deleteWideStringCallBack);
+ } else {
+ SetMapModuleString(pKey, wsValue);
+ if(eAttr == XFA_ATTRIBUTE_Name) {
+ UpdateNameHash();
+ if (XFA_LPCJSBUILTININFO pBuiltin = XFA_GetJSBuiltinByHash(m_dwNameHash)) {
+ m_pDocument->GetScriptContext()->AddJSBuiltinObject(pBuiltin);
+ }
+ }
+ }
+ OnChanged(eAttr, (FX_LPVOID)(FX_LPCWSTR)wsValue, bNotify, bScriptModify);
+ if (IsNeedSavingXMLNode() && eAttr != XFA_ATTRIBUTE_QualifiedName && eAttr != XFA_ATTRIBUTE_BindingNode) {
+ if (eAttr == XFA_ATTRIBUTE_Name && (m_eNodeClass == XFA_ELEMENT_DataValue || m_eNodeClass == XFA_ELEMENT_DataGroup)) {
+ return TRUE;
+ }
+ if (eAttr == XFA_ATTRIBUTE_Value) {
+ FDE_XMLNODETYPE eXMLType = m_pXMLNode->GetType();
+ switch (eXMLType) {
+ case FDE_XMLNODE_Element:
+ if (IsAttributeInXML()) {
+ ((IFDE_XMLElement*)m_pXMLNode)->SetString(GetCData(XFA_ATTRIBUTE_QualifiedName), wsValue);
+ } else {
+ FX_BOOL bDeleteChildren = TRUE;
+ if (GetPacketID() == XFA_XDPPACKET_Datasets) {
+ for (CXFA_Node* pChildDataNode = this->GetNodeItem(XFA_NODEITEM_FirstChild); pChildDataNode; pChildDataNode = pChildDataNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
+ CXFA_NodeArray formNodes;
+ if (pChildDataNode->GetBindItems(formNodes) > 0) {
+ bDeleteChildren = FALSE;
+ break;
+ }
+ }
+ }
+ if (bDeleteChildren) {
+ ((IFDE_XMLElement*)m_pXMLNode)->DeleteChildren();
+ }
+ ((IFDE_XMLElement*)m_pXMLNode)->SetTextData(wsValue);
+ }
+ break;
+ case FDE_XMLNODE_Text:
+ ((IFDE_XMLText*)m_pXMLNode)->SetText(wsValue);
+ break;
+ default:
+ FXSYS_assert(0);
+ }
+ return TRUE;
+ }
+ XFA_LPCATTRIBUTEINFO pInfo = XFA_GetAttributeByID(eAttr);
+ if (pInfo) {
+ FXSYS_assert(m_pXMLNode->GetType() == FDE_XMLNODE_Element);
+ CFX_WideString wsAttrName = pInfo->pName;
+ if(pInfo->eName == XFA_ATTRIBUTE_ContentType) {
+ wsAttrName = FX_WSTRC(L"xfa:") + wsAttrName;
+ }
+ ((IFDE_XMLElement*)m_pXMLNode)->SetString(wsAttrName, wsValue);
+ }
+ }
+ return TRUE;
+}
+FX_BOOL CXFA_Node::SetAttributeValue(const CFX_WideString& wsValue, const CFX_WideString& wsXMLValue, FX_BOOL bNotify, FX_BOOL bScriptModify)
+{
+ FX_LPVOID pKey = NULL;
+ if (!XFA_NodeData_PrepareKey(GetClassID(), XFA_ATTRIBUTE_Value, pKey)) {
+ return FALSE;
+ }
+ OnChanging(XFA_ATTRIBUTE_Value, (FX_LPVOID)(FX_LPCWSTR)wsValue, bNotify);
+ CFX_WideString *pClone = FX_NEW CFX_WideString(wsValue);
+ if (pClone == NULL) {
+ return FALSE;
+ }
+ SetUserData(pKey, pClone, &deleteWideStringCallBack);
+ OnChanged(XFA_ATTRIBUTE_Value, (FX_LPVOID)(FX_LPCWSTR)wsValue, bNotify, bScriptModify);
+ if (IsNeedSavingXMLNode()) {
+ FDE_XMLNODETYPE eXMLType = m_pXMLNode->GetType();
+ switch (eXMLType) {
+ case FDE_XMLNODE_Element:
+ if (IsAttributeInXML()) {
+ ((IFDE_XMLElement*)m_pXMLNode)->SetString(GetCData(XFA_ATTRIBUTE_QualifiedName), wsXMLValue);
+ } else {
+ FX_BOOL bDeleteChildren = TRUE;
+ if (GetPacketID() == XFA_XDPPACKET_Datasets) {
+ for (CXFA_Node* pChildDataNode = this->GetNodeItem(XFA_NODEITEM_FirstChild); pChildDataNode; pChildDataNode = pChildDataNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
+ CXFA_NodeArray formNodes;
+ if (pChildDataNode->GetBindItems(formNodes) > 0) {
+ bDeleteChildren = FALSE;
+ break;
+ }
+ }
+ }
+ if (bDeleteChildren) {
+ ((IFDE_XMLElement*)m_pXMLNode)->DeleteChildren();
+ }
+ ((IFDE_XMLElement*)m_pXMLNode)->SetTextData(wsXMLValue);
+ }
+ break;
+ case FDE_XMLNODE_Text:
+ ((IFDE_XMLText*)m_pXMLNode)->SetText(wsXMLValue);
+ break;
+ default:
+ FXSYS_assert(0);
+ }
+ }
+ return TRUE;
+}
+FX_BOOL CXFA_Node::TryCData(XFA_ATTRIBUTE eAttr, CFX_WideString &wsValue, FX_BOOL bUseDefault, FX_BOOL bProto)
+{
+ FX_LPVOID pKey = NULL;
+ if (!XFA_NodeData_PrepareKey(GetClassID(), eAttr, pKey)) {
+ return FALSE;
+ }
+ 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;
+ }
+ FX_LPVOID pValue = NULL;
+ if (XFA_GetAttributeDefaultValue(pValue, GetClassID(), eAttr, XFA_ATTRIBUTETYPE_Cdata, m_ePacket)) {
+ wsValue = (FX_LPCWSTR)pValue;
+ return TRUE;
+ }
+ return FALSE;
+}
+FX_BOOL CXFA_Node::TryCData(XFA_ATTRIBUTE eAttr, CFX_WideStringC &wsValue, FX_BOOL bUseDefault, FX_BOOL bProto)
+{
+ FX_LPVOID pKey = NULL;
+ if (!XFA_NodeData_PrepareKey(GetClassID(), eAttr, pKey)) {
+ return FALSE;
+ }
+ if (eAttr == XFA_ATTRIBUTE_Value) {
+ CFX_WideString *pStr = (CFX_WideString*)GetUserData(pKey, bProto);
+ if (pStr) {
+ wsValue = *pStr;
+ return TRUE;
+ }
+ } else {
+ if (GetMapModuleString(pKey, wsValue)) {
+ return TRUE;
+ }
+ }
+ if (!bUseDefault) {
+ return FALSE;
+ }
+ FX_LPVOID pValue = NULL;
+ if (XFA_GetAttributeDefaultValue(pValue, GetClassID(), eAttr, XFA_ATTRIBUTETYPE_Cdata, m_ePacket)) {
+ wsValue = (CFX_WideStringC)(FX_LPCWSTR)pValue;
+ return TRUE;
+ }
+ return FALSE;
+}
+FX_BOOL CXFA_Node::SetObject(XFA_ATTRIBUTE eAttr, FX_LPVOID pData, XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo )
+{
+ FX_LPVOID pKey = NULL;
+ if (!XFA_NodeData_PrepareKey(GetClassID(), eAttr, pKey)) {
+ return FALSE;
+ }
+ return SetUserData(pKey, pData, pCallbackInfo);
+}
+FX_BOOL CXFA_Node::TryObject(XFA_ATTRIBUTE eAttr, FX_LPVOID &pData)
+{
+ FX_LPVOID pKey = NULL;
+ if (!XFA_NodeData_PrepareKey(GetClassID(), eAttr, pKey)) {
+ return FALSE;
+ }
+ pData = GetUserData(pKey);
+ return pData != NULL;
+}
+FX_BOOL CXFA_Node::SetValue(XFA_ATTRIBUTE eAttr, XFA_ATTRIBUTETYPE eType, FX_LPVOID pValue, FX_BOOL bNotify)
+{
+ FX_LPVOID pKey = NULL;
+ if (!XFA_NodeData_PrepareKey(GetClassID(), eAttr, pKey)) {
+ return FALSE;
+ }
+ OnChanging(eAttr, pValue, bNotify);
+ SetMapModuleValue(pKey, pValue);
+ OnChanged(eAttr, pValue, bNotify);
+ if (IsNeedSavingXMLNode()) {
+ FXSYS_assert(m_pXMLNode->GetType() == FDE_XMLNODE_Element);
+ XFA_LPCATTRIBUTEINFO pInfo = XFA_GetAttributeByID(eAttr);
+ if (pInfo) {
+ switch (eType) {
+ case XFA_ATTRIBUTETYPE_Enum:
+ ((IFDE_XMLElement*)m_pXMLNode)->SetString(pInfo->pName, XFA_GetAttributeEnumByID((XFA_ATTRIBUTEENUM)(FX_UINTPTR)pValue)->pName);
+ break;
+ case XFA_ATTRIBUTETYPE_Boolean:
+ ((IFDE_XMLElement*)m_pXMLNode)->SetString(pInfo->pName, pValue ? FX_WSTRC(L"1") : FX_WSTRC(L"0"));
+ break;
+ case XFA_ATTRIBUTETYPE_Integer:
+ ((IFDE_XMLElement*)m_pXMLNode)->SetInteger(pInfo->pName, (FX_INT32)(FX_UINTPTR)pValue);
+ break;
+ default:
+ FXSYS_assert(0);
+ }
+ }
+ }
+ return TRUE;
+}
+FX_BOOL CXFA_Node::GetValue(XFA_ATTRIBUTE eAttr, XFA_ATTRIBUTETYPE eType, FX_BOOL bUseDefault, FX_LPVOID &pValue)
+{
+ FX_LPVOID pKey = NULL;
+ if (!XFA_NodeData_PrepareKey(GetClassID(), eAttr, pKey)) {
+ return FALSE;
+ }
+ if(GetMapModuleValue(pKey, pValue)) {
+ return TRUE;
+ }
+ if (!bUseDefault) {
+ return FALSE;
+ }
+ return XFA_GetAttributeDefaultValue(pValue, GetClassID(), eAttr, eType, m_ePacket);
+}
+static void XFA_DefaultFreeData(FX_LPVOID pData)
+{
+}
+static XFA_MAPDATABLOCKCALLBACKINFO gs_XFADefaultFreeData = {XFA_DefaultFreeData, NULL};
+FX_BOOL CXFA_Node::SetUserData(FX_LPVOID pKey, FX_LPVOID pData, XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo )
+{
+ SetMapModuleBuffer(pKey, &pData, sizeof(FX_LPVOID), pCallbackInfo ? pCallbackInfo : &gs_XFADefaultFreeData);
+ return TRUE;
+}
+FX_BOOL CXFA_Node::TryUserData(FX_LPVOID pKey, FX_LPVOID &pData, FX_BOOL bProtoAlso)
+{
+ FX_INT32 iBytes = 0;
+ if (!GetMapModuleBuffer(pKey, pData, iBytes, bProtoAlso)) {
+ return FALSE;
+ }
+ return iBytes == sizeof(FX_LPVOID) && FXSYS_memcpy(&pData, pData, iBytes);
+}
+FX_BOOL CXFA_Node::SetScriptContent(const CFX_WideString& wsContent, const CFX_WideString& wsXMLValue, FX_BOOL bNotify, FX_BOOL bScriptModify, FX_BOOL bSyncData)
+{
+ CXFA_Node* pNode = NULL;
+ CXFA_Node* pBindNode = NULL;
+ 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);
+ FXSYS_assert(pChildValue);
+ pChildValue->SetCData(XFA_ATTRIBUTE_ContentType, FX_WSTRC(L"text/xml"));
+ pChildValue->SetScriptContent(wsContent, wsContent, bNotify, bScriptModify, FALSE);
+ CXFA_Node *pBind = GetBindData();
+ if (bSyncData && pBind) {
+ CFX_WideStringArray wsSaveTextArray;
+ FX_INT32 iSize = 0;
+ if (!wsContent.IsEmpty()) {
+ FX_INT32 iStart = 0;
+ FX_INT32 iLength = wsContent.GetLength();
+ FX_INT32 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;
+ FX_INT32 iDatas = pBind->GetNodeList(valueNodes, XFA_NODEFILTER_Children, XFA_ELEMENT_DataValue);
+ if (iDatas < iSize) {
+ FX_INT32 iAddNodes = iSize - iDatas;
+ CXFA_Node *pValueNodes = NULL;
+ while (iAddNodes-- > 0) {
+ pValueNodes = pBind->CreateSamePacketNode(XFA_ELEMENT_DataValue);
+ pValueNodes->SetCData(XFA_ATTRIBUTE_Name, FX_WSTRC(L"value"));
+ pValueNodes->CreateXMLMappingNode();
+ pBind->InsertChild(pValueNodes);
+ }
+ pValueNodes = NULL;
+ } else if (iDatas > iSize) {
+ FX_INT32 iDelNodes = iDatas - iSize;
+ while (iDelNodes-- > 0) {
+ pBind->RemoveChild(pBind->GetNodeItem(XFA_NODEITEM_FirstChild));
+ }
+ }
+ FX_INT32 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 (FX_INT32 i = 0; i < nodeArray.GetSize(); i++) {
+ CXFA_Node* pNode = nodeArray[i];
+ if (pNode == this) {
+ continue;
+ }
+ pNode->SetScriptContent(wsContent, wsContent, bNotify, bScriptModify, FALSE);
+ }
+ }
+ break;
+ } else if (GetClassID() == XFA_ELEMENT_ExclGroup) {
+ pNode = this;
+ } else {
+ CXFA_Node* pValue = GetProperty(0, XFA_ELEMENT_Value);
+ CXFA_Node* pChildValue = pValue->GetNodeItem(XFA_NODEITEM_FirstChild);
+ FXSYS_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 (FX_INT32 i = 0; i < nodeArray.GetSize(); i++) {
+ CXFA_Node* pNode = nodeArray[i];
+ if (pNode == this) {
+ continue;
+ }
+ pNode->SetScriptContent(wsContent, wsContent, bNotify, TRUE, FALSE);
+ }
+ }
+ pBindNode = NULL;
+ break;
+ }
+ case XFA_OBJECTTYPE_ContentNode: {
+ CFX_WideString wsContentType;
+ if (GetClassID() == XFA_ELEMENT_ExData) {
+ GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, FALSE);
+ if (wsContentType.Equal(FX_WSTRC(L"text/html"))) {
+ wsContentType = FX_WSTRC(L"");
+ SetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType);
+ }
+ }
+ CXFA_Node *pContentRawDataNode = GetNodeItem(XFA_NODEITEM_FirstChild);
+ if (!pContentRawDataNode) {
+ pContentRawDataNode = CreateSamePacketNode((wsContentType.Equal(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->GetClassID() == 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 (GetClassID() == 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 (FX_INT32 i = 0; i < nodeArray.GetSize(); i++) {
+ CXFA_Node* pNode = nodeArray[i];
+ pNode->SetScriptContent(wsContent, wsContent, bNotify, bScriptModify, FALSE);
+ }
+ }
+ return TRUE;
+ }
+ return FALSE;
+}
+FX_BOOL CXFA_Node::SetContent(const CFX_WideString& wsContent, const CFX_WideString& wsXMLValue, FX_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 = NULL;
+ switch (GetObjectType()) {
+ case XFA_OBJECTTYPE_ContainerNode:
+ if (GetClassID() == 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 (GetClassID() == XFA_ELEMENT_ExData) {
+ CFX_WideString wsContentType;
+ GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, FALSE);
+ if (wsContentType.Equal(FX_WSTRC(L"text/html"))) {
+ element = XFA_ELEMENT_SharpxHTML;
+ } else if (wsContentType.Equal(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 (GetClassID() == XFA_ELEMENT_DataValue) {
+ pNode = this;
+ }
+ break;
+ }
+ if (pNode) {
+ if (bScriptModify) {
+ IXFA_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 (CXFA_Node*)m_pDocument->GetXFANode(XFA_HASHCODE_Config);
+ case XFA_XDPPACKET_Template:
+ return (CXFA_Node*)m_pDocument->GetXFANode(XFA_HASHCODE_Template);
+ case XFA_XDPPACKET_Form:
+ return (CXFA_Node*)m_pDocument->GetXFANode(XFA_HASHCODE_Form);
+ case XFA_XDPPACKET_Datasets:
+ return (CXFA_Node*)m_pDocument->GetXFANode(XFA_HASHCODE_Datasets);
+ case XFA_XDPPACKET_LocaleSet:
+ return (CXFA_Node*)m_pDocument->GetXFANode(XFA_HASHCODE_LocaleSet);
+ case XFA_XDPPACKET_ConnectionSet:
+ return (CXFA_Node*)m_pDocument->GetXFANode(XFA_HASHCODE_ConnectionSet);
+ case XFA_XDPPACKET_SourceSet:
+ return (CXFA_Node*)m_pDocument->GetXFANode(XFA_HASHCODE_SourceSet);
+ case XFA_XDPPACKET_Xdc:
+ return (CXFA_Node*)m_pDocument->GetXFANode(XFA_HASHCODE_Xdc);
+ default:
+ return this;
+ }
+}
+FX_BOOL CXFA_Node::TryNamespace(CFX_WideString& wsNamespace)
+{
+ wsNamespace.Empty();
+ if(this->GetObjectType() == XFA_OBJECTTYPE_ModelNode || this->GetClassID() == XFA_ELEMENT_Packet) {
+ IFDE_XMLNode* pXMLNode = this->GetXMLMappingNode();
+ if(!pXMLNode || pXMLNode->GetType() != FDE_XMLNODE_Element) {
+ return FALSE;
+ }
+ ((IFDE_XMLElement*)pXMLNode)->GetNamespaceURI(wsNamespace);
+ return TRUE;
+ } else if(this->GetPacketID() == XFA_XDPPACKET_Datasets) {
+ IFDE_XMLNode* pXMLNode = this->GetXMLMappingNode();
+ if(!pXMLNode) {
+ return FALSE;
+ }
+ if(pXMLNode->GetType() != FDE_XMLNODE_Element) {
+ return TRUE;
+ }
+ if(this->GetClassID() == XFA_ELEMENT_DataValue && this->GetEnum(XFA_ATTRIBUTE_Contains) == XFA_ATTRIBUTEENUM_MetaData) {
+ return XFA_FDEExtension_ResolveNamespaceQualifier((IFDE_XMLElement*)pXMLNode, this->GetCData(XFA_ATTRIBUTE_QualifiedName), wsNamespace);
+ }
+ ((IFDE_XMLElement*)pXMLNode)->GetNamespaceURI(wsNamespace);
+ return TRUE;
+ } else {
+ CXFA_Node *pModelNode = GetModelNode();
+ return pModelNode->TryNamespace(wsNamespace);
+ }
+}
+CXFA_Node* CXFA_Node::GetProperty(FX_INT32 index, XFA_ELEMENT eProperty, FX_BOOL bCreateProperty )
+{
+ XFA_ELEMENT eElement = GetClassID();
+ FX_DWORD dwPacket = GetPacketID();
+ XFA_LPCPROPERTY pProperty = XFA_GetPropertyOfElement(eElement, eProperty, dwPacket);
+ if (pProperty == NULL || index >= pProperty->uOccur) {
+ return NULL;
+ }
+ CXFA_Node *pNode = m_pChild;
+ FX_INT32 iCount = 0;
+ for(; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
+ if (pNode->GetClassID() == eProperty) {
+ iCount ++;
+ if (iCount > index) {
+ return pNode;
+ }
+ }
+ }
+ if (!bCreateProperty) {
+ return NULL;
+ }
+ if (pProperty->uFlags & XFA_PROPERTYFLAG_OneOf) {
+ pNode = m_pChild;
+ for(; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
+ XFA_LPCPROPERTY pExistProterty = XFA_GetPropertyOfElement(eElement, pNode->GetClassID(), dwPacket);
+ if (pExistProterty && (pExistProterty->uFlags & XFA_PROPERTYFLAG_OneOf)) {
+ return NULL;
+ }
+ }
+ }
+ IXFA_ObjFactory *pFactory = m_pDocument->GetParser()->GetFactory();
+ XFA_LPCPACKETINFO pPacket = XFA_GetPacketByID(dwPacket);
+ CXFA_Node *pNewNode;
+ for (; iCount <= index ; iCount ++) {
+ pNewNode = pFactory->CreateNode(pPacket, eProperty);
+ if(!pNewNode) {
+ return NULL;
+ }
+ this->InsertChild(pNewNode, NULL);
+ pNewNode->SetFlag(XFA_NODEFLAG_Initialized);
+ }
+ return pNewNode;
+}
+FX_INT32 CXFA_Node::CountChildren(XFA_ELEMENT eElement, FX_BOOL bOnlyChild)
+{
+ CXFA_Node *pNode = m_pChild;
+ FX_INT32 iCount = 0;
+ for(; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
+ if (pNode->GetClassID() == eElement || eElement == XFA_ELEMENT_UNKNOWN) {
+ if(bOnlyChild) {
+ XFA_LPCPROPERTY pPropert = XFA_GetPropertyOfElement(GetClassID(), pNode->GetClassID(), XFA_XDPPACKET_UNKNOWN);
+ if(pPropert) {
+ continue;
+ }
+ }
+ iCount ++;
+ }
+ }
+ return iCount;
+}
+CXFA_Node* CXFA_Node::GetChild(FX_INT32 index, XFA_ELEMENT eElement, FX_BOOL bOnlyChild)
+{
+ FXSYS_assert(index > -1);
+ CXFA_Node *pNode = m_pChild;
+ FX_INT32 iCount = 0;
+ for(; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
+ if (pNode->GetClassID() == eElement || eElement == XFA_ELEMENT_UNKNOWN) {
+ if(bOnlyChild) {
+ XFA_LPCPROPERTY pPropert = XFA_GetPropertyOfElement(GetClassID(), pNode->GetClassID(), XFA_XDPPACKET_UNKNOWN);
+ if(pPropert) {
+ continue;
+ }
+ }
+ iCount ++;
+ if (iCount > index) {
+ return pNode;
+ }
+ }
+ }
+ return NULL;
+}
+FX_INT32 CXFA_Node::InsertChild(FX_INT32 index, CXFA_Node *pNode)
+{
+ ASSERT(pNode != NULL && pNode->m_pNext == NULL);
+ pNode->m_pParent = this;
+ FX_BOOL bWasPurgeNode = m_pDocument->RemovePurgeNode(pNode);
+ FXSYS_assert(bWasPurgeNode == TRUE);
+ if (m_pChild == NULL || 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;
+ FX_INT32 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 == NULL) {
+ m_pLastChild = pNode;
+ }
+ ASSERT(m_pLastChild != NULL && m_pLastChild->m_pNext == NULL);
+ pNode->SetFlag(XFA_NODEFLAG_HasRemoved, FALSE);
+ IXFA_Notify *pNotify = m_pDocument->GetParser()->GetNotify();
+ if (pNotify) {
+ pNotify->OnNodeEvent(this, XFA_NODEEVENT_ChildAdded, pNode);
+ }
+ if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) {
+ FXSYS_assert(pNode->m_pXMLNode->GetNodeItem(IFDE_XMLNode::Parent) == NULL);
+ m_pXMLNode->InsertChildNode(pNode->m_pXMLNode, index);
+ pNode->SetFlag(XFA_NODEFLAG_OwnXMLNode, FALSE, FALSE);
+ }
+ return index;
+}
+FX_BOOL CXFA_Node::InsertChild(CXFA_Node *pNode, CXFA_Node *pBeforeNode)
+{
+ if (!pNode || pNode->m_pParent != NULL || (pBeforeNode && pBeforeNode->m_pParent != this)) {
+ FXSYS_assert(FALSE);
+ return FALSE;
+ }
+ FX_BOOL bWasPurgeNode = m_pDocument->RemovePurgeNode(pNode);
+ FXSYS_assert(bWasPurgeNode == TRUE);
+ FX_INT32 nIndex = -1;
+ pNode->m_pParent = this;
+ if (m_pChild == NULL || 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 == NULL) {
+ m_pLastChild = pNode;
+ }
+ ASSERT(m_pLastChild != NULL && m_pLastChild->m_pNext == NULL);
+ pNode->SetFlag(XFA_NODEFLAG_HasRemoved, FALSE);
+ IXFA_Notify *pNotify = m_pDocument->GetParser()->GetNotify();
+ if (pNotify) {
+ pNotify->OnNodeEvent(this, XFA_NODEEVENT_ChildAdded, pNode);
+ }
+ if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) {
+ FXSYS_assert(pNode->m_pXMLNode->GetNodeItem(IFDE_XMLNode::Parent) == NULL);
+ m_pXMLNode->InsertChildNode(pNode->m_pXMLNode, nIndex);
+ pNode->SetFlag(XFA_NODEFLAG_OwnXMLNode, FALSE, FALSE);
+ }
+ return TRUE;
+}
+CXFA_Node* CXFA_Node::Deprecated_GetPrevSibling()
+{
+ if(!m_pParent) {
+ return NULL;
+ }
+ for (CXFA_Node *pSibling = m_pParent->m_pChild; pSibling; pSibling = pSibling->m_pNext) {
+ if(pSibling->m_pNext == this) {
+ return pSibling;
+ }
+ }
+ return NULL;
+}
+FX_BOOL CXFA_Node::RemoveChild(CXFA_Node *pNode, FX_BOOL bNotify)
+{
+ if (pNode == NULL || pNode->m_pParent != this) {
+ FXSYS_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 = NULL;
+ pNode->m_pParent = NULL;
+ } 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 = NULL;
+ pNode->m_pParent = NULL;
+ }
+ ASSERT(m_pLastChild == NULL || m_pLastChild->m_pNext == NULL);
+ OnRemoved(this, pNode, bNotify);
+ pNode->SetFlag(XFA_NODEFLAG_HasRemoved);
+ m_pDocument->AddPurgeNode(pNode);
+ if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) {
+ if (pNode->IsAttributeInXML()) {
+ FXSYS_assert(pNode->m_pXMLNode == m_pXMLNode && m_pXMLNode->GetType() == FDE_XMLNODE_Element);
+ if (pNode->m_pXMLNode->GetType() == FDE_XMLNODE_Element) {
+ IFDE_XMLElement* pXMLElement = (IFDE_XMLElement*)(pNode->m_pXMLNode);
+ CFX_WideStringC wsAttributeName = pNode->GetCData(XFA_ATTRIBUTE_QualifiedName);
+ pXMLElement->RemoveAttribute(wsAttributeName.GetPtr());
+ }
+ CFX_WideString wsName;
+ pNode->GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE);
+ IFDE_XMLElement* pNewXMLElement = IFDE_XMLElement::Create(wsName);
+ CFX_WideStringC wsValue = this->GetCData(XFA_ATTRIBUTE_Value);
+ if (!wsValue.IsEmpty()) {
+ pNewXMLElement->SetTextData(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, TRUE, FALSE);
+ }
+ return TRUE;
+}
+CXFA_Node* CXFA_Node::GetFirstChildByName(FX_WSTR wsName) const
+{
+ return GetFirstChildByName(wsName.IsEmpty() ? 0 : FX_HashCode_String_GetW(wsName.GetPtr(), wsName.GetLength()));
+}
+CXFA_Node* CXFA_Node::GetFirstChildByName(FX_DWORD dwNameHash) const
+{
+ for(CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_FirstChild); pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
+ if(pNode->GetNameHash() == dwNameHash) {
+ return pNode;
+ }
+ }
+ return NULL;
+}
+CXFA_Node* CXFA_Node::GetFirstChildByClass(XFA_ELEMENT eElement) const
+{
+ for(CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_FirstChild); pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
+ if(pNode->GetClassID() == eElement) {
+ return pNode;
+ }
+ }
+ return NULL;
+}
+CXFA_Node* CXFA_Node::GetNextSameNameSibling(FX_DWORD dwNameHash) const
+{
+ for(CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_NextSibling); pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
+ if(pNode->GetNameHash() == dwNameHash) {
+ return pNode;
+ }
+ }
+ return NULL;
+}
+CXFA_Node* CXFA_Node::GetNextSameNameSibling(FX_WSTR wsNodeName) const
+{
+ return GetNextSameNameSibling(wsNodeName.IsEmpty() ? 0 : FX_HashCode_String_GetW(wsNodeName.GetPtr(), wsNodeName.GetLength()));
+}
+CXFA_Node* CXFA_Node::GetNextSameClassSibling(XFA_ELEMENT eElement) const
+{
+ for(CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_NextSibling); pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
+ if(pNode->GetClassID() == eElement) {
+ return pNode;
+ }
+ }
+ return NULL;
+}
+FX_INT32 CXFA_Node::GetNodeSameNameIndex() const
+{
+ IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
+ if (!pScriptContext) {
+ return -1;
+ }
+ return pScriptContext->GetIndexByName((CXFA_Node*)this);
+}
+FX_INT32 CXFA_Node::GetNodeSameClassIndex() const
+{
+ IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
+ if (!pScriptContext) {
+ return -1;
+ }
+ return pScriptContext->GetIndexByClassName((CXFA_Node*)this);
+}
+void CXFA_Node::GetSOMExpression(CFX_WideString& wsSOMExpression)
+{
+ IXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
+ if (!pScriptContext) {
+ return;
+ }
+ pScriptContext->GetSomExpression(this, wsSOMExpression);
+}
+CXFA_Node* CXFA_Node::GetInstanceMgrOfSubform()
+{
+ CXFA_Node* pInstanceMgr = NULL;
+ if (m_ePacket == XFA_XDPPACKET_Form) {
+ CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
+ if (!pParentNode || pParentNode->GetClassID() == XFA_ELEMENT_Area) {
+ return pInstanceMgr;
+ }
+ for (CXFA_Node *pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode != NULL; pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
+ XFA_ELEMENT eType = pNode->GetClassID();
+ 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);
+}
+FX_BOOL CXFA_Node::HasFlag(FX_DWORD dwFlag) const
+{
+ if (m_uFlags & dwFlag) {
+ return TRUE;
+ }
+ switch (dwFlag) {
+ case XFA_NODEFLAG_HasRemoved:
+ return m_pParent && m_pParent->HasFlag(dwFlag);
+ default:
+ break;
+ }
+ return FALSE;
+}
+void CXFA_Node::SetFlag(FX_DWORD dwFlag, FX_BOOL bOn , FX_BOOL bNotify )
+{
+ if (bOn) {
+ switch (dwFlag) {
+ case XFA_NODEFLAG_Initialized:
+ if (bNotify && !HasFlag(XFA_NODEFLAG_Initialized)) {
+ IXFA_Notify *pNotify = m_pDocument->GetParser()->GetNotify();
+ if (pNotify) {
+ pNotify->OnNodeEvent(this, XFA_NODEEVENT_Ready);
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ m_uFlags |= dwFlag;
+ } else {
+ m_uFlags &= ~dwFlag;
+ }
+}
+FX_BOOL CXFA_Node::IsAttributeInXML()
+{
+ return GetEnum(XFA_ATTRIBUTE_Contains) == XFA_ATTRIBUTEENUM_MetaData;
+}
+void CXFA_Node::OnRemoved(CXFA_Node *pParent, CXFA_Node *pRemoved, FX_BOOL bNotify)
+{
+ if (bNotify && (pParent != NULL)) {
+ IXFA_Notify *pNotify = m_pDocument->GetParser()->GetNotify();
+ if (pNotify) {
+ pNotify->OnNodeEvent(pParent, XFA_NODEEVENT_ChildRemoved, pRemoved);
+ }
+ }
+}
+void CXFA_Node::OnChanging(XFA_ATTRIBUTE eAttr, FX_LPVOID pNewValue, FX_BOOL bNotify)
+{
+ if (bNotify && HasFlag(XFA_NODEFLAG_Initialized)) {
+ IXFA_Notify *pNotify = m_pDocument->GetParser()->GetNotify();
+ if (pNotify) {
+ pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanging, (FX_LPVOID)(FX_UINTPTR)eAttr, pNewValue);
+ }
+ }
+}
+void CXFA_Node::OnChanged(XFA_ATTRIBUTE eAttr, FX_LPVOID pNewValue, FX_BOOL bNotify, FX_BOOL bScriptModify)
+{
+ if (bNotify && HasFlag(XFA_NODEFLAG_Initialized)) {
+ Script_Attribute_SendAttributeChangeMessage((FX_LPVOID)(FX_UINTPTR)eAttr, pNewValue, bScriptModify);
+ }
+}
+FX_INT32 CXFA_Node::execSingleEventByName(FX_WSTR wsEventName, XFA_ELEMENT eElementType)
+{
+ FX_INT32 iRet = XFA_EVENTERROR_NotExist;
+ const XFA_ExecEventParaInfo* eventParaInfo = GetEventParaInfoByName(wsEventName);
+ if (eventParaInfo) {
+ FX_UINT32 validFlags = eventParaInfo->m_validFlags;
+ IXFA_Notify * pNotify = m_pDocument->GetParser()->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 (eElementType == XFA_ELEMENT_Subform) {
+ iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType, FALSE, FALSE);
+ }
+ } else if (validFlags == 4) {
+ if (eElementType == XFA_ELEMENT_ExclGroup || eElementType == XFA_ELEMENT_Field) {
+ CXFA_Node *pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
+ if (pParentNode && pParentNode->GetClassID() == 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 (eElementType == 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_eNodeClass == 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_eNodeClass == XFA_ELEMENT_ChoiceList) && (!pWidgetData->IsListBox())) {
+ iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType, FALSE, FALSE);
+ }
+ }
+ }
+ }
+ return iRet;
+}
+void CXFA_Node::UpdateNameHash()
+{
+ XFA_LPCNOTSUREATTRIBUTE pNotsure = XFA_GetNotsureAttribute(GetClassID(), XFA_ATTRIBUTE_Name);
+ if(!pNotsure || pNotsure->eType == XFA_ATTRIBUTETYPE_Cdata) {
+ CFX_WideStringC wsName = GetCData(XFA_ATTRIBUTE_Name);
+ m_dwNameHash = wsName.IsEmpty() ? 0 : FX_HashCode_String_GetW(wsName.GetPtr(), wsName.GetLength());
+ } else if (pNotsure->eType == XFA_ATTRIBUTETYPE_Enum) {
+ CFX_WideStringC wsName = XFA_GetAttributeEnumByID(GetEnum(XFA_ATTRIBUTE_Name))->pName;
+ m_dwNameHash = wsName.IsEmpty() ? 0 : FX_HashCode_String_GetW(wsName.GetPtr(), wsName.GetLength());
+ }
+}
+IFDE_XMLNode* CXFA_Node::CreateXMLMappingNode()
+{
+ if (!m_pXMLNode) {
+ CFX_WideStringC wsTag = GetCData(XFA_ATTRIBUTE_Name);
+ m_pXMLNode = IFDE_XMLElement::Create(wsTag);
+ SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, FALSE);
+ }
+ return m_pXMLNode;
+}
+FX_BOOL CXFA_Node::IsNeedSavingXMLNode()
+{
+ return m_pXMLNode && (GetPacketID() == XFA_XDPPACKET_Datasets || GetClassID() == XFA_ELEMENT_Xfa );
+}
+XFA_LPMAPMODULEDATA CXFA_Node::GetMapModuleData(FX_BOOL bCreateNew)
+{
+ if (!m_pMapModuleData && bCreateNew) {
+ m_pMapModuleData = FX_NEW XFA_MAPMODULEDATA;
+ }
+ return m_pMapModuleData;
+}
+void CXFA_Node::SetMapModuleValue(FX_LPVOID pKey, FX_LPVOID pValue)
+{
+ XFA_LPMAPMODULEDATA pMoudle = this->GetMapModuleData(TRUE);
+ if (!pMoudle) {
+ return;
+ }
+ pMoudle->m_ValueMap.SetAt(pKey, pValue);
+}
+FX_BOOL CXFA_Node::GetMapModuleValue(FX_LPVOID pKey, FX_LPVOID &pValue)
+{
+ CXFA_Node* pNode = this;
+ while (pNode) {
+ XFA_LPMAPMODULEDATA pMoudle = pNode->GetMapModuleData(FALSE);
+ if (pMoudle && pMoudle->m_ValueMap.Lookup(pKey, pValue)) {
+ return TRUE;
+ }
+ pNode = pNode->GetPacketID() != XFA_XDPPACKET_Datasets ? pNode->GetTemplateNode() : NULL;
+ }
+ return FALSE;
+}
+void CXFA_Node::SetMapModuleString(FX_LPVOID pKey, FX_WSTR wsValue)
+{
+ SetMapModuleBuffer(pKey, (FX_LPVOID)wsValue.GetPtr(), wsValue.GetLength() * sizeof(FX_WCHAR));
+}
+FX_BOOL CXFA_Node::GetMapModuleString(FX_LPVOID pKey, CFX_WideStringC &wsValue)
+{
+ FX_LPVOID pValue;
+ FX_INT32 iBytes;
+ if (!GetMapModuleBuffer(pKey, pValue, iBytes)) {
+ return FALSE;
+ }
+ wsValue = CFX_WideStringC((FX_LPCWSTR)pValue, iBytes / sizeof(FX_WCHAR));
+ return TRUE;
+}
+void CXFA_Node::SetMapModuleBuffer(FX_LPVOID pKey, FX_LPVOID pValue, FX_INT32 iBytes, XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo )
+{
+ XFA_LPMAPMODULEDATA pMoudle = this->GetMapModuleData(TRUE);
+ if (!pMoudle) {
+ return;
+ }
+ XFA_LPMAPDATABLOCK &pBuffer = pMoudle->m_BufferMap[pKey];
+ if (pBuffer == NULL) {
+ pBuffer = (XFA_LPMAPDATABLOCK)FX_Alloc(FX_BYTE, sizeof(XFA_MAPDATABLOCK) + iBytes);
+ } else if (pBuffer->iBytes != iBytes) {
+ if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
+ pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
+ }
+ pBuffer = (XFA_LPMAPDATABLOCK)FX_Realloc(FX_BYTE, pBuffer, sizeof(XFA_MAPDATABLOCK) + iBytes);
+ } else if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
+ pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
+ }
+ if (pBuffer == NULL) {
+ return;
+ }
+ pBuffer->pCallbackInfo = pCallbackInfo;
+ pBuffer->iBytes = iBytes;
+ FXSYS_memcpy(pBuffer->GetData(), pValue, iBytes);
+}
+FX_BOOL CXFA_Node::GetMapModuleBuffer(FX_LPVOID pKey, FX_LPVOID &pValue, FX_INT32 &iBytes, FX_BOOL bProtoAlso)
+{
+ XFA_LPMAPDATABLOCK pBuffer = NULL;
+ CXFA_Node* pNode = this;
+ while (pNode) {
+ XFA_LPMAPMODULEDATA pMoudle = pNode->GetMapModuleData(FALSE);
+ if (pMoudle && pMoudle->m_BufferMap.Lookup(pKey, pBuffer)) {
+ break;
+ }
+ pNode = (bProtoAlso && pNode->GetPacketID() != XFA_XDPPACKET_Datasets) ? pNode->GetTemplateNode() : NULL;
+ }
+ if (pBuffer == NULL) {
+ return FALSE;
+ }
+ pValue = pBuffer->GetData();
+ iBytes = pBuffer->iBytes;
+ return TRUE;
+}
+FX_BOOL CXFA_Node::HasMapModuleKey(FX_LPVOID pKey, FX_BOOL bProtoAlso)
+{
+ CXFA_Node* pNode = this;
+ while (pNode) {
+ FX_LPVOID pVal;
+ XFA_LPMAPMODULEDATA pMoudle = pNode->GetMapModuleData(FALSE);
+ if (pMoudle && (pMoudle->m_ValueMap.Lookup(pKey, pVal) || pMoudle->m_BufferMap.Lookup(pKey, (XFA_LPMAPDATABLOCK&)pVal))) {
+ return TRUE;
+ }
+ pNode = (bProtoAlso && pNode->GetPacketID() != XFA_XDPPACKET_Datasets) ? pNode->GetTemplateNode() : NULL;
+ }
+ return FALSE;
+}
+void CXFA_Node::RemoveMapModuleKey(FX_LPVOID pKey )
+{
+ XFA_LPMAPMODULEDATA pMoudle = this->GetMapModuleData(FALSE);
+ if (!pMoudle) {
+ return;
+ }
+ if (pKey) {
+ XFA_LPMAPDATABLOCK pBuffer = NULL;
+ pMoudle->m_BufferMap.Lookup(pKey, pBuffer);
+ if (pBuffer) {
+ if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
+ pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
+ }
+ FX_Free(pBuffer);
+ }
+ pMoudle->m_BufferMap.RemoveKey(pKey);
+ pMoudle->m_ValueMap.RemoveKey(pKey);
+ } else {
+ XFA_LPMAPDATABLOCK pBuffer;
+ FX_POSITION posBuffer = pMoudle->m_BufferMap.GetStartPosition();
+ while (posBuffer) {
+ pMoudle->m_BufferMap.GetNextAssoc(posBuffer, pKey, pBuffer);
+ if (pBuffer) {
+ if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
+ pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
+ }
+ FX_Free(pBuffer);
+ }
+ }
+ pMoudle->m_BufferMap.RemoveAll();
+ pMoudle->m_ValueMap.RemoveAll();
+ if (pMoudle) {
+ delete pMoudle;
+ pMoudle = NULL;
+ }
+ }
+}
+void CXFA_Node::MergeAllData(FX_LPVOID pDstModule, FX_BOOL bUseSrcAttr )
+{
+ XFA_LPMAPMODULEDATA pDstModuleData = ((CXFA_Node*)pDstModule)->GetMapModuleData(TRUE);
+ if (!pDstModuleData) {
+ return;
+ }
+ XFA_LPMAPMODULEDATA pSrcModuleData = this->GetMapModuleData(FALSE);
+ if (!pSrcModuleData) {
+ return;
+ }
+ FX_POSITION psValue = pSrcModuleData->m_ValueMap.GetStartPosition();
+ while (psValue) {
+ FX_LPVOID pKey;
+ FX_LPVOID 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) {
+ FX_LPVOID pKey;
+ XFA_LPMAPDATABLOCK pSrcBuffer;
+ pSrcModuleData->m_BufferMap.GetNextAssoc(psBuffer, pKey, pSrcBuffer);
+ XFA_LPMAPDATABLOCK &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 == NULL) {
+ pBuffer = (XFA_LPMAPDATABLOCK)FX_Alloc(FX_BYTE, 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_LPMAPDATABLOCK)FX_Realloc(FX_BYTE, pBuffer, sizeof(XFA_MAPDATABLOCK) + pSrcBuffer->iBytes);
+ } else if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
+ pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
+ }
+ if (pBuffer == NULL) {
+ 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, FX_LPVOID pKey)
+{
+ if (!pDstModule) {
+ return;
+ }
+ FX_BOOL bNeedMove = TRUE;
+ if (!pKey) {
+ bNeedMove = FALSE;
+ }
+ if (pDstModule->GetClassID() != this->GetClassID()) {
+ bNeedMove = FALSE;
+ }
+ XFA_LPMAPMODULEDATA pSrcModuleData = NULL;
+ XFA_LPMAPMODULEDATA pDstModuleData = NULL;
+ if (bNeedMove) {
+ pSrcModuleData = this->GetMapModuleData(FALSE);
+ if (!pSrcModuleData) {
+ bNeedMove = FALSE;
+ }
+ pDstModuleData = pDstModule->GetMapModuleData(TRUE);
+ if (!pDstModuleData) {
+ bNeedMove = FALSE;
+ }
+ }
+ if (bNeedMove) {
+ FX_LPVOID pBufferBlockData = pSrcModuleData->m_BufferMap.GetValueAt(pKey);
+ if (pBufferBlockData) {
+ pSrcModuleData->m_BufferMap.RemoveKey(pKey);
+ pDstModuleData->m_BufferMap.RemoveKey(pKey);
+ pDstModuleData->m_BufferMap.SetAt(pKey, (XFA_LPMAPDATABLOCK)pBufferBlockData);
+ }
+ }
+ if (pDstModule->GetObjectType() == XFA_OBJECTTYPE_NodeV) {
+ 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, FX_LPVOID pKey, FX_BOOL bRecursive )
+{
+ if (!pSrcModule || !pDstModule || !pKey) {
+ return;
+ }
+ if (bRecursive) {
+ CXFA_Node* pSrcChild = pSrcModule->GetNodeItem(XFA_NODEITEM_FirstChild);
+ CXFA_Node* pDstChild = pDstModule->GetNodeItem(XFA_NODEITEM_FirstChild);
+ for ( ; pSrcChild && pDstChild; pSrcChild = pSrcChild->GetNodeItem(XFA_NODEITEM_NextSibling), pDstChild = pDstChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
+ MoveBufferMapData(pSrcChild, pDstChild, pKey, TRUE);
+ }
+ }
+ pSrcModule->MoveBufferMapData(pDstModule, pKey);
+}
+CXFA_NodeList::CXFA_NodeList(CXFA_Document* pDocument)
+ : CXFA_Object(pDocument, XFA_OBJECTTYPE_NodeList)
+{
+ m_pDocument->GetScriptContext()->CacheList(this);
+}
+CXFA_Node* CXFA_NodeList::NamedItem(FX_WSTR wsName)
+{
+ FX_INT32 iCount = GetLength();
+ FX_DWORD dwHashCode = FX_HashCode_String_GetW(wsName.GetPtr(), wsName.GetLength());
+ for (FX_INT32 i = 0; i < iCount; i++) {
+ CXFA_Node* ret = Item(i);
+ if (dwHashCode == ret->GetNameHash()) {
+ return ret;
+ }
+ }
+ return NULL;
+}
+void CXFA_NodeList::Script_ListClass_Append(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if(argc == 1) {
+ CXFA_Node *pNode = (CXFA_Node *)pArguments->GetObject(0);
+ if(pNode) {
+ Append(pNode);
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+ }
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"append"));
+ }
+}
+void CXFA_NodeList::Script_ListClass_Insert(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if(argc == 2) {
+ CXFA_Node *pNewNode = (CXFA_Node *)pArguments->GetObject(0);
+ CXFA_Node *pBeforeNode = (CXFA_Node *)pArguments->GetObject(1);
+ if(pNewNode) {
+ Insert(pNewNode, pBeforeNode);
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+ }
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"insert"));
+ }
+}
+void CXFA_NodeList::Script_ListClass_Remove(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if(argc == 1) {
+ CXFA_Node *pNode = (CXFA_Node *)pArguments->GetObject(0);
+ if(pNode) {
+ Remove(pNode);
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
+ }
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"remove"));
+ }
+}
+void CXFA_NodeList::Script_ListClass_Item(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if(argc == 1) {
+ FX_INT32 iIndex = pArguments->GetInt32(0);
+ if((iIndex >= 0) && (iIndex + 1 <= GetLength())) {
+ FXJSE_Value_Set(pArguments->GetReturnValue(), m_pDocument->GetScriptContext()->GetJSValueFromMap(Item(iIndex)));
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INDEX_OUT_OF_BOUNDS);
+ }
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"item"));
+ }
+}
+void CXFA_NodeList::Script_TreelistClass_NamedItem(CFXJSE_Arguments* pArguments)
+{
+ FX_INT32 argc = pArguments->GetLength();
+ if(argc == 1) {
+ CFX_ByteString szName = pArguments->GetUTF8String(0);
+ CXFA_Node* pNode = NamedItem(CFX_WideString::FromUTF8(szName, szName.GetLength()));
+ if (!pNode) {
+ return;
+ }
+ FXJSE_Value_Set(pArguments->GetReturnValue(), m_pDocument->GetScriptContext()->GetJSValueFromMap(pNode));
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, (FX_LPCWSTR)(L"namedItem"));
+ }
+}
+void CXFA_NodeList::Script_ListClass_Length(FXJSE_HVALUE hValue, FX_BOOL bSetting, XFA_ATTRIBUTE eAttribute)
+{
+ if(!bSetting) {
+ FXJSE_Value_SetInteger(hValue, GetLength());
+ } else {
+ ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
+ }
+}
+CXFA_ArrayNodeList::CXFA_ArrayNodeList(CXFA_Document* pDocument)
+ : CXFA_NodeList(pDocument)
+{
+}
+void CXFA_ArrayNodeList::SetArrayNodeList(const CXFA_NodeArray &srcArray)
+{
+ if (srcArray.GetSize() > 0) {
+ m_array.Copy(srcArray);
+ }
+}
+FX_INT32 CXFA_ArrayNodeList::GetLength()
+{
+ return m_array.GetSize();
+}
+FX_BOOL CXFA_ArrayNodeList::Append(CXFA_Node* pNode)
+{
+ m_array.Add(pNode);
+ return TRUE;
+}
+FX_BOOL CXFA_ArrayNodeList::Insert(CXFA_Node* pNewNode, CXFA_Node* pBeforeNode)
+{
+ if (pBeforeNode == NULL) {
+ m_array.Add(pNewNode);
+ } else {
+ FX_INT32 iSize = m_array.GetSize();
+ for (FX_INT32 i = 0; i < iSize; ++i) {
+ if (m_array[i] == pBeforeNode) {
+ m_array.InsertAt(i, pNewNode);
+ break;
+ }
+ }
+ }
+ return TRUE;
+}
+FX_BOOL CXFA_ArrayNodeList::Remove(CXFA_Node* pNode)
+{
+ FX_INT32 iSize = m_array.GetSize();
+ for (FX_INT32 i = 0; i < iSize; ++i) {
+ if (m_array[i] == pNode) {
+ m_array.RemoveAt(i);
+ break;
+ }
+ }
+ return TRUE;
+}
+CXFA_Node* CXFA_ArrayNodeList::Item(FX_INT32 iIndex)
+{
+ FX_INT32 iSize = m_array.GetSize();
+ if (iIndex >= 0 && iIndex < iSize) {
+ return m_array[iIndex];
+ }
+ return NULL;
+}
+CXFA_AttachNodeList::CXFA_AttachNodeList(CXFA_Document* pDocument, CXFA_Node* pAttachNode)
+ : CXFA_NodeList(pDocument)
+{
+ m_pAttachNode = pAttachNode;
+}
+FX_INT32 CXFA_AttachNodeList::GetLength()
+{
+ return m_pAttachNode->CountChildren(XFA_ELEMENT_UNKNOWN, m_pAttachNode->GetClassID() == XFA_ELEMENT_Subform ? TRUE : FALSE);
+}
+FX_BOOL CXFA_AttachNodeList::Append(CXFA_Node* pNode)
+{
+ CXFA_Node* pParent = pNode->GetNodeItem(XFA_NODEITEM_Parent);
+ if (pParent) {
+ pParent->RemoveChild(pNode);
+ }
+ return m_pAttachNode->InsertChild(pNode);
+}
+FX_BOOL CXFA_AttachNodeList::Insert(CXFA_Node* pNewNode, CXFA_Node* pBeforeNode)
+{
+ CXFA_Node* pParent = pNewNode->GetNodeItem(XFA_NODEITEM_Parent);
+ if (pParent) {
+ pParent->RemoveChild(pNewNode);
+ }
+ return m_pAttachNode->InsertChild(pNewNode, pBeforeNode);
+}
+FX_BOOL CXFA_AttachNodeList::Remove(CXFA_Node* pNode)
+{
+ return m_pAttachNode->RemoveChild(pNode);
+}
+CXFA_Node* CXFA_AttachNodeList::Item(FX_INT32 iIndex)
+{
+ return m_pAttachNode->GetChild(iIndex, XFA_ELEMENT_UNKNOWN, m_pAttachNode->GetClassID() == XFA_ELEMENT_Subform ? TRUE : FALSE);
+}
|