| // 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, L"postSubmit", XFA_EVENT_PostSubmit, 0}, | |
| {0x0ab466bb, L"preSubmit", XFA_EVENT_PreSubmit, 0}, | |
| {0x109d7ce7, L"mouseEnter", XFA_EVENT_MouseEnter, 5}, | |
| {0x17fad373, L"postPrint", XFA_EVENT_PostPrint, 0}, | |
| {0x1bfc72d9, L"preOpen", XFA_EVENT_PreOpen, 7}, | |
| {0x2196a452, L"initialize", XFA_EVENT_Initialize, 1}, | |
| {0x27410f03, L"mouseExit", XFA_EVENT_MouseExit, 5}, | |
| {0x33c43dec, L"docClose", XFA_EVENT_DocClose, 0}, | |
| {0x361fa1b6, L"preSave", XFA_EVENT_PreSave, 0}, | |
| {0x36f1c6d8, L"preSign", XFA_EVENT_PreSign, 6}, | |
| {0x4731d6ba, L"exit", XFA_EVENT_Exit, 2}, | |
| {0x56bf456b, L"docReady", XFA_EVENT_DocReady, 0}, | |
| {0x7233018a, L"validate", XFA_EVENT_Validate, 1}, | |
| {0x8808385e, L"indexChange", XFA_EVENT_IndexChange, 3}, | |
| {0x891f4606, L"change", XFA_EVENT_Change, 4}, | |
| {0x9528a7b4, L"prePrint", XFA_EVENT_PrePrint, 0}, | |
| {0x9f693b21, L"mouseDown", XFA_EVENT_MouseDown, 5}, | |
| {0xcdce56b3, L"full", XFA_EVENT_Full, 4}, | |
| {0xd576d08e, L"mouseUp", XFA_EVENT_MouseUp, 5}, | |
| {0xd95657a6, L"click", XFA_EVENT_Click, 4}, | |
| {0xdbfbe02e, L"calculate", XFA_EVENT_Calculate, 1}, | |
| {0xe25fa7b8, L"postOpen", XFA_EVENT_PostOpen, 7}, | |
| {0xe28dce7e, L"enter", XFA_EVENT_Enter, 2}, | |
| {0xfc82d695, L"postSave", XFA_EVENT_PostSave, 0}, | |
| {0xfd54fbb7, L"postSign", XFA_EVENT_PostSign, 6}, | |
| }; | |
| const XFA_ExecEventParaInfo* GetEventParaInfoByName(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(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(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(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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, L"name"); | |
| } | |
| } else { | |
| FXJSE_Value_Set(pArguments->GetReturnValue(), m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewNode)); | |
| } | |
| } | |
| } else { | |
| ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, L"min"); | |
| return 1; | |
| } | |
| if ((iMax >= 0) && (iDesired > iMax)) { | |
| ThrowScriptErrorMessage(XFA_IDS_VIOLATE_BOUNDARY, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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(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, 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, 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, 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, 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, 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); | |
| } |