| // Copyright 2014 PDFium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com |
| |
| #include "xfa/fxfa/parser/xfa_document_datamerger_imp.h" |
| |
| #include "core/fxcrt/include/fx_ext.h" |
| #include "xfa/fde/xml/fde_xml_imp.h" |
| #include "xfa/fxfa/fm2js/xfa_fm2jsapi.h" |
| #include "xfa/fxfa/parser/cxfa_occur.h" |
| #include "xfa/fxfa/parser/xfa_basic_imp.h" |
| #include "xfa/fxfa/parser/xfa_doclayout.h" |
| #include "xfa/fxfa/parser/xfa_document.h" |
| #include "xfa/fxfa/parser/xfa_document_datadescription_imp.h" |
| #include "xfa/fxfa/parser/xfa_document_layout_imp.h" |
| #include "xfa/fxfa/parser/xfa_localemgr.h" |
| #include "xfa/fxfa/parser/xfa_object.h" |
| #include "xfa/fxfa/parser/xfa_parser.h" |
| #include "xfa/fxfa/parser/xfa_parser_imp.h" |
| #include "xfa/fxfa/parser/xfa_script.h" |
| #include "xfa/fxfa/parser/xfa_script_imp.h" |
| #include "xfa/fxfa/parser/xfa_utils.h" |
| |
| static FX_BOOL XFA_GetOccurInfo(CXFA_Node* pOccurNode, |
| int32_t& iMin, |
| int32_t& iMax, |
| int32_t& iInit) { |
| if (!pOccurNode) { |
| return FALSE; |
| } |
| CXFA_Occur occur(pOccurNode); |
| return occur.GetOccurInfo(iMin, iMax, iInit); |
| } |
| struct XFA_DataMerge_RecurseRecord { |
| CXFA_Node* pTemplateChild; |
| CXFA_Node* pDataChild; |
| }; |
| static CXFA_Node* XFA_DataMerge_FormValueNode_CreateChild( |
| CXFA_Node* pValueNode, |
| XFA_ELEMENT iType = XFA_ELEMENT_UNKNOWN) { |
| CXFA_Node* pChildNode = pValueNode->GetNodeItem(XFA_NODEITEM_FirstChild); |
| if (!pChildNode) { |
| if (iType == XFA_ELEMENT_UNKNOWN) { |
| return FALSE; |
| } |
| pChildNode = pValueNode->GetProperty(0, iType); |
| } |
| return pChildNode; |
| } |
| static void XFA_DataMerge_FormValueNode_MatchNoneCreateChild( |
| CXFA_Node* pFormNode) { |
| CXFA_WidgetData* pWidgetData = pFormNode->GetWidgetData(); |
| ASSERT(pWidgetData); |
| pWidgetData->GetUIType(); |
| } |
| static FX_BOOL XFA_DataMerge_FormValueNode_SetChildContent( |
| CXFA_Node* pValueNode, |
| const CFX_WideString& wsContent, |
| XFA_ELEMENT iType = XFA_ELEMENT_UNKNOWN) { |
| if (!pValueNode) { |
| return FALSE; |
| } |
| ASSERT(pValueNode->GetPacketID() == XFA_XDPPACKET_Form); |
| CXFA_Node* pChildNode = |
| XFA_DataMerge_FormValueNode_CreateChild(pValueNode, iType); |
| if (!pChildNode) { |
| return FALSE; |
| } |
| XFA_OBJECTTYPE objectType = pChildNode->GetObjectType(); |
| switch (objectType) { |
| case XFA_OBJECTTYPE_ContentNode: { |
| CXFA_Node* pContentRawDataNode = |
| pChildNode->GetNodeItem(XFA_NODEITEM_FirstChild); |
| if (!pContentRawDataNode) { |
| XFA_ELEMENT element = XFA_ELEMENT_Sharptext; |
| if (pChildNode->GetClassID() == XFA_ELEMENT_ExData) { |
| CFX_WideString wsContentType; |
| pChildNode->GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, |
| FALSE); |
| if (wsContentType == FX_WSTRC(L"text/html")) { |
| element = XFA_ELEMENT_SharpxHTML; |
| } else if (wsContentType == FX_WSTRC(L"text/xml")) { |
| element = XFA_ELEMENT_Sharpxml; |
| } |
| } |
| pContentRawDataNode = pChildNode->CreateSamePacketNode(element); |
| pChildNode->InsertChild(pContentRawDataNode); |
| } |
| pContentRawDataNode->SetCData(XFA_ATTRIBUTE_Value, wsContent); |
| } break; |
| case XFA_OBJECTTYPE_NodeC: |
| case XFA_OBJECTTYPE_TextNode: |
| case XFA_OBJECTTYPE_NodeV: { |
| pChildNode->SetCData(XFA_ATTRIBUTE_Value, wsContent); |
| } break; |
| default: |
| ASSERT(FALSE); |
| break; |
| } |
| return TRUE; |
| } |
| static void XFA_DataMerge_CreateDataBinding(CXFA_Node* pFormNode, |
| CXFA_Node* pDataNode, |
| FX_BOOL bDataToForm = TRUE) { |
| pFormNode->SetObject(XFA_ATTRIBUTE_BindingNode, pDataNode); |
| pDataNode->AddBindItem(pFormNode); |
| XFA_ELEMENT eClass = pFormNode->GetClassID(); |
| if (eClass != XFA_ELEMENT_Field && eClass != XFA_ELEMENT_ExclGroup) { |
| return; |
| } |
| CXFA_WidgetData* pWidgetData = pFormNode->GetWidgetData(); |
| ASSERT(pWidgetData); |
| FX_BOOL bNotify = FALSE; |
| XFA_ELEMENT eUIType = pWidgetData->GetUIType(); |
| CXFA_Value defValue(pFormNode->GetProperty(0, XFA_ELEMENT_Value)); |
| if (!bDataToForm) { |
| CFX_WideString wsValue; |
| CFX_WideString wsFormatedValue; |
| switch (eUIType) { |
| case XFA_ELEMENT_ImageEdit: { |
| CXFA_Image image = defValue.GetImage(); |
| CFX_WideString wsContentType; |
| CFX_WideString wsHref; |
| if (image) { |
| image.GetContent(wsValue); |
| image.GetContentType(wsContentType); |
| image.GetHref(wsHref); |
| } |
| CFDE_XMLElement* pXMLDataElement = |
| static_cast<CFDE_XMLElement*>(pDataNode->GetXMLMappingNode()); |
| ASSERT(pXMLDataElement); |
| pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue); |
| pDataNode->SetAttributeValue(wsValue, wsFormatedValue); |
| pDataNode->SetCData(XFA_ATTRIBUTE_ContentType, wsContentType); |
| if (!wsHref.IsEmpty()) { |
| pXMLDataElement->SetString(FX_WSTRC(L"href"), wsHref); |
| } |
| } break; |
| case XFA_ELEMENT_ChoiceList: |
| defValue.GetChildValueContent(wsValue); |
| if (pWidgetData->GetChoiceListOpen() == XFA_ATTRIBUTEENUM_MultiSelect) { |
| CFX_WideStringArray wsSelTextArray; |
| pWidgetData->GetSelectedItemsValue(wsSelTextArray); |
| int32_t iSize = wsSelTextArray.GetSize(); |
| if (iSize >= 1) { |
| CXFA_Node* pValue = NULL; |
| for (int32_t i = 0; i < iSize; i++) { |
| pValue = pDataNode->CreateSamePacketNode(XFA_ELEMENT_DataValue); |
| pValue->SetCData(XFA_ATTRIBUTE_Name, FX_WSTRC(L"value")); |
| pValue->CreateXMLMappingNode(); |
| pDataNode->InsertChild(pValue); |
| pValue->SetCData(XFA_ATTRIBUTE_Value, wsSelTextArray[i]); |
| } |
| } else { |
| CFDE_XMLNode* pXMLNode = pDataNode->GetXMLMappingNode(); |
| ASSERT(pXMLNode->GetType() == FDE_XMLNODE_Element); |
| static_cast<CFDE_XMLElement*>(pXMLNode) |
| ->SetString(FX_WSTRC(L"xfa:dataNode"), FX_WSTRC(L"dataGroup")); |
| } |
| } else if (!wsValue.IsEmpty()) { |
| pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue); |
| pDataNode->SetAttributeValue(wsValue, wsFormatedValue); |
| } |
| break; |
| case XFA_ELEMENT_CheckButton: |
| defValue.GetChildValueContent(wsValue); |
| if (wsValue.IsEmpty()) { |
| break; |
| } |
| pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue); |
| pDataNode->SetAttributeValue(wsValue, wsFormatedValue); |
| break; |
| case XFA_ELEMENT_ExclGroup: { |
| CXFA_Node* pChecked = NULL; |
| CXFA_Node* pChild = pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild); |
| for (; pChild; pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) { |
| if (pChild->GetClassID() != XFA_ELEMENT_Field) { |
| continue; |
| } |
| CXFA_Node* pValue = pChild->GetChild(0, XFA_ELEMENT_Value); |
| if (!pValue) { |
| continue; |
| } |
| CXFA_Value valueChild(pValue); |
| valueChild.GetChildValueContent(wsValue); |
| if (wsValue.IsEmpty()) { |
| continue; |
| } |
| CXFA_Node* pItems = pChild->GetChild(0, XFA_ELEMENT_Items); |
| if (!pItems) { |
| continue; |
| } |
| CXFA_Node* pText = pItems->GetNodeItem(XFA_NODEITEM_FirstChild); |
| if (!pText) { |
| continue; |
| } |
| CFX_WideString wsContent; |
| if (pText->TryContent(wsContent) && (wsContent == wsValue)) { |
| pChecked = pChild; |
| wsFormatedValue = wsValue; |
| pDataNode->SetAttributeValue(wsValue, wsFormatedValue); |
| pFormNode->SetCData(XFA_ATTRIBUTE_Value, wsContent); |
| break; |
| } |
| } |
| if (!pChecked) { |
| break; |
| } |
| pChild = pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild); |
| for (; pChild; pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) { |
| if (pChild == pChecked) { |
| continue; |
| } |
| if (pChild->GetClassID() != XFA_ELEMENT_Field) { |
| continue; |
| } |
| CXFA_Node* pValue = pChild->GetProperty(0, XFA_ELEMENT_Value); |
| CXFA_Node* pItems = pChild->GetChild(0, XFA_ELEMENT_Items); |
| CXFA_Node* pText = |
| pItems ? pItems->GetNodeItem(XFA_NODEITEM_FirstChild) : NULL; |
| if (pText) { |
| pText = pText->GetNodeItem(XFA_NODEITEM_NextSibling); |
| } |
| CFX_WideString wsContent; |
| if (pText) { |
| pText->TryContent(wsContent); |
| } |
| XFA_DataMerge_FormValueNode_SetChildContent(pValue, wsContent, |
| XFA_ELEMENT_Text); |
| } |
| } break; |
| case XFA_ELEMENT_NumericEdit: { |
| defValue.GetChildValueContent(wsValue); |
| if (wsValue.IsEmpty()) { |
| break; |
| } |
| CFX_WideString wsOutput; |
| pWidgetData->NormalizeNumStr(wsValue, wsOutput); |
| wsValue = wsOutput; |
| pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue); |
| pDataNode->SetAttributeValue(wsValue, wsFormatedValue); |
| CXFA_Node* pValue = pFormNode->GetProperty(0, XFA_ELEMENT_Value); |
| XFA_DataMerge_FormValueNode_SetChildContent(pValue, wsValue, |
| XFA_ELEMENT_Float); |
| } break; |
| default: |
| defValue.GetChildValueContent(wsValue); |
| if (wsValue.IsEmpty()) { |
| break; |
| } |
| pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue); |
| pDataNode->SetAttributeValue(wsValue, wsFormatedValue); |
| break; |
| } |
| } else { |
| CFX_WideString wsXMLValue; |
| pDataNode->TryContent(wsXMLValue); |
| CFX_WideString wsNormailizeValue; |
| pWidgetData->GetNormalizeDataValue(wsXMLValue, wsNormailizeValue); |
| pDataNode->SetAttributeValue(wsNormailizeValue, wsXMLValue); |
| switch (eUIType) { |
| case XFA_ELEMENT_ImageEdit: { |
| XFA_DataMerge_FormValueNode_SetChildContent( |
| defValue.GetNode(), wsNormailizeValue, XFA_ELEMENT_Image); |
| CXFA_Image image = defValue.GetImage(); |
| if (image) { |
| CFDE_XMLElement* pXMLDataElement = |
| static_cast<CFDE_XMLElement*>(pDataNode->GetXMLMappingNode()); |
| ASSERT(pXMLDataElement); |
| CFX_WideString wsContentType; |
| CFX_WideString wsHref; |
| pXMLDataElement->GetString(L"xfa:contentType", wsContentType); |
| if (!wsContentType.IsEmpty()) { |
| pDataNode->SetCData(XFA_ATTRIBUTE_ContentType, wsContentType); |
| image.SetContentType(wsContentType); |
| } |
| pXMLDataElement->GetString(L"href", wsHref); |
| if (!wsHref.IsEmpty()) { |
| image.SetHref(wsHref); |
| } |
| } |
| } break; |
| case XFA_ELEMENT_ChoiceList: |
| if (pWidgetData->GetChoiceListOpen() == XFA_ATTRIBUTEENUM_MultiSelect) { |
| CXFA_NodeArray items; |
| pDataNode->GetNodeList(items); |
| int32_t iCounts = items.GetSize(); |
| if (iCounts > 0) { |
| wsNormailizeValue.clear(); |
| CFX_WideString wsItem; |
| for (int32_t i = 0; i < iCounts; i++) { |
| items[i]->TryContent(wsItem); |
| wsItem = (iCounts == 1) ? wsItem : wsItem + FX_WSTRC(L"\n"); |
| wsNormailizeValue += wsItem; |
| } |
| CXFA_ExData exData = defValue.GetExData(); |
| ASSERT(exData); |
| exData.SetContentType((iCounts == 1) ? FX_WSTRC(L"text/plain") |
| : FX_WSTRC(L"text/xml")); |
| } |
| XFA_DataMerge_FormValueNode_SetChildContent( |
| defValue.GetNode(), wsNormailizeValue, XFA_ELEMENT_ExData); |
| } else { |
| XFA_DataMerge_FormValueNode_SetChildContent( |
| defValue.GetNode(), wsNormailizeValue, XFA_ELEMENT_Text); |
| } |
| break; |
| case XFA_ELEMENT_CheckButton: |
| XFA_DataMerge_FormValueNode_SetChildContent( |
| defValue.GetNode(), wsNormailizeValue, XFA_ELEMENT_Text); |
| break; |
| case XFA_ELEMENT_ExclGroup: { |
| pWidgetData->SetSelectedMemberByValue(wsNormailizeValue.AsStringC(), |
| bNotify, FALSE, FALSE); |
| } break; |
| case XFA_ELEMENT_DateTimeEdit: |
| XFA_DataMerge_FormValueNode_SetChildContent( |
| defValue.GetNode(), wsNormailizeValue, XFA_ELEMENT_DateTime); |
| break; |
| case XFA_ELEMENT_NumericEdit: { |
| CFX_WideString wsPicture; |
| pWidgetData->GetPictureContent(wsPicture, XFA_VALUEPICTURE_DataBind); |
| if (wsPicture.IsEmpty()) { |
| CFX_WideString wsOutput; |
| pWidgetData->NormalizeNumStr(wsNormailizeValue, wsOutput); |
| wsNormailizeValue = wsOutput; |
| } |
| XFA_DataMerge_FormValueNode_SetChildContent( |
| defValue.GetNode(), wsNormailizeValue, XFA_ELEMENT_Float); |
| } break; |
| case XFA_ELEMENT_Barcode: |
| case XFA_ELEMENT_Button: |
| case XFA_ELEMENT_PasswordEdit: |
| case XFA_ELEMENT_Signature: |
| case XFA_ELEMENT_TextEdit: |
| default: |
| XFA_DataMerge_FormValueNode_SetChildContent( |
| defValue.GetNode(), wsNormailizeValue, XFA_ELEMENT_Text); |
| break; |
| } |
| } |
| } |
| static CXFA_Node* XFA_DataMerge_GetGlobalBinding(CXFA_Document* pDocument, |
| uint32_t dwNameHash) { |
| CXFA_Node* pNode = NULL; |
| pDocument->m_rgGlobalBinding.Lookup(dwNameHash, pNode); |
| return pNode; |
| } |
| static void XFA_DataMerge_RegisterGlobalBinding(CXFA_Document* pDocument, |
| uint32_t dwNameHash, |
| CXFA_Node* pDataNode) { |
| pDocument->m_rgGlobalBinding.SetAt(dwNameHash, pDataNode); |
| } |
| static void XFA_DataMerge_ClearGlobalBinding(CXFA_Document* pDocument) { |
| pDocument->m_rgGlobalBinding.RemoveAll(); |
| } |
| static CXFA_Node* XFA_DataMerge_ScopeMatchGlobalBinding( |
| CXFA_Node* pDataScope, |
| uint32_t dwNameHash, |
| XFA_ELEMENT eMatchDataNodeType, |
| FX_BOOL bUpLevel = TRUE) { |
| for (CXFA_Node *pCurDataScope = pDataScope, *pLastDataScope = NULL; |
| pCurDataScope && pCurDataScope->GetPacketID() == XFA_XDPPACKET_Datasets; |
| pLastDataScope = pCurDataScope, |
| pCurDataScope = |
| pCurDataScope->GetNodeItem(XFA_NODEITEM_Parent)) { |
| for (CXFA_Node* pDataChild = pCurDataScope->GetFirstChildByName(dwNameHash); |
| pDataChild; |
| pDataChild = pDataChild->GetNextSameNameSibling(dwNameHash)) { |
| if (pDataChild == pLastDataScope || |
| (eMatchDataNodeType != XFA_ELEMENT_DataModel && |
| pDataChild->GetClassID() != eMatchDataNodeType) || |
| pDataChild->HasBindItem()) { |
| continue; |
| } |
| return pDataChild; |
| } |
| for (CXFA_Node* pDataChild = |
| pCurDataScope->GetFirstChildByClass(XFA_ELEMENT_DataGroup); |
| pDataChild; pDataChild = pDataChild->GetNextSameClassSibling( |
| XFA_ELEMENT_DataGroup)) { |
| CXFA_Node* pDataNode = XFA_DataMerge_ScopeMatchGlobalBinding( |
| pDataChild, dwNameHash, eMatchDataNodeType, FALSE); |
| if (pDataNode) { |
| return pDataNode; |
| } |
| } |
| if (!bUpLevel) { |
| break; |
| } |
| } |
| return NULL; |
| } |
| static CXFA_Node* XFA_DataMerge_FindGlobalDataNode(CXFA_Document* pDocument, |
| CFX_WideStringC wsName, |
| CXFA_Node* pDataScope, |
| XFA_ELEMENT eMatchNodeType) { |
| if (wsName.IsEmpty()) |
| return nullptr; |
| |
| uint32_t dwNameHash = FX_HashCode_GetW(wsName, false); |
| CXFA_Node* pBounded = XFA_DataMerge_GetGlobalBinding(pDocument, dwNameHash); |
| if (!pBounded) { |
| pBounded = XFA_DataMerge_ScopeMatchGlobalBinding(pDataScope, dwNameHash, |
| eMatchNodeType); |
| if (pBounded) { |
| XFA_DataMerge_RegisterGlobalBinding(pDocument, dwNameHash, pBounded); |
| } |
| } |
| return pBounded; |
| } |
| |
| static CXFA_Node* XFA_DataMerge_FindOnceDataNode(CXFA_Document* pDocument, |
| CFX_WideStringC wsName, |
| CXFA_Node* pDataScope, |
| XFA_ELEMENT eMatchNodeType) { |
| if (wsName.IsEmpty()) |
| return nullptr; |
| |
| uint32_t dwNameHash = FX_HashCode_GetW(wsName, false); |
| CXFA_Node* pLastDataScope = nullptr; |
| for (CXFA_Node* pCurDataScope = pDataScope; |
| pCurDataScope && pCurDataScope->GetPacketID() == XFA_XDPPACKET_Datasets; |
| pCurDataScope = pCurDataScope->GetNodeItem(XFA_NODEITEM_Parent)) { |
| for (CXFA_Node* pDataChild = pCurDataScope->GetFirstChildByName(dwNameHash); |
| pDataChild; |
| pDataChild = pDataChild->GetNextSameNameSibling(dwNameHash)) { |
| if (pDataChild == pLastDataScope || pDataChild->HasBindItem() || |
| (eMatchNodeType != XFA_ELEMENT_DataModel && |
| pDataChild->GetClassID() != eMatchNodeType)) { |
| continue; |
| } |
| return pDataChild; |
| } |
| pLastDataScope = pCurDataScope; |
| } |
| return nullptr; |
| } |
| |
| static CXFA_Node* XFA_DataMerge_FindDataRefDataNode(CXFA_Document* pDocument, |
| CFX_WideStringC wsRef, |
| CXFA_Node* pDataScope, |
| XFA_ELEMENT eMatchNodeType, |
| CXFA_Node* pTemplateNode, |
| FX_BOOL bForceBind, |
| FX_BOOL bUpLevel = TRUE) { |
| uint32_t dFlags = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_BindNew; |
| if (bUpLevel || wsRef != FX_WSTRC(L"name")) { |
| dFlags |= (XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings); |
| } |
| XFA_RESOLVENODE_RS rs; |
| pDocument->GetScriptContext()->ResolveObjects(pDataScope, wsRef, rs, dFlags, |
| pTemplateNode); |
| if (rs.dwFlags == XFA_RESOLVENODE_RSTYPE_CreateNodeAll || |
| rs.dwFlags == XFA_RESOLVENODE_RSTYPE_CreateNodeMidAll || |
| rs.nodes.GetSize() > 1) { |
| return pDocument->GetNotBindNode(rs.nodes); |
| } |
| if (rs.dwFlags == XFA_RESOLVENODE_RSTYPE_CreateNodeOne) { |
| CXFA_Object* pObject = (rs.nodes.GetSize() > 0) ? rs.nodes[0] : NULL; |
| CXFA_Node* pNode = ToNode(pObject); |
| if (!bForceBind && pNode && pNode->HasBindItem()) { |
| pNode = NULL; |
| } |
| return pNode; |
| } |
| return NULL; |
| } |
| CXFA_Node* XFA_DataMerge_FindFormDOMInstance(CXFA_Document* pDocument, |
| XFA_ELEMENT eClassID, |
| uint32_t dwNameHash, |
| CXFA_Node* pFormParent) { |
| CXFA_Node* pFormChild = pFormParent->GetNodeItem(XFA_NODEITEM_FirstChild); |
| for (; pFormChild; |
| pFormChild = pFormChild->GetNodeItem(XFA_NODEITEM_NextSibling)) { |
| if (pFormChild->GetClassID() == eClassID && |
| pFormChild->GetNameHash() == dwNameHash && |
| pFormChild->HasFlag(XFA_NODEFLAG_UnusedNode)) { |
| return pFormChild; |
| } |
| } |
| return NULL; |
| } |
| static FX_BOOL XFA_NeedGenerateForm(CXFA_Node* pTemplateChild, |
| FX_BOOL bUseInstanceManager = TRUE) { |
| XFA_ELEMENT eType = pTemplateChild->GetClassID(); |
| if (eType == XFA_ELEMENT_Variables) { |
| return TRUE; |
| } |
| if (pTemplateChild->GetObjectType() == XFA_OBJECTTYPE_ContainerNode) { |
| return FALSE; |
| } |
| if (eType == XFA_ELEMENT_Proto || |
| (bUseInstanceManager && eType == XFA_ELEMENT_Occur)) { |
| return FALSE; |
| } |
| return TRUE; |
| } |
| CXFA_Node* XFA_NodeMerge_CloneOrMergeContainer(CXFA_Document* pDocument, |
| CXFA_Node* pFormParent, |
| CXFA_Node* pTemplateNode, |
| FX_BOOL bRecursive, |
| CXFA_NodeArray* pSubformArray) { |
| CXFA_Node* pExistingNode = NULL; |
| if (pSubformArray == NULL) { |
| pExistingNode = XFA_DataMerge_FindFormDOMInstance( |
| pDocument, pTemplateNode->GetClassID(), pTemplateNode->GetNameHash(), |
| pFormParent); |
| } else if (pSubformArray->GetSize() > 0) { |
| pExistingNode = pSubformArray->GetAt(0); |
| pSubformArray->RemoveAt(0); |
| } |
| if (pExistingNode) { |
| if (pSubformArray) { |
| pFormParent->InsertChild(pExistingNode); |
| } else if (pExistingNode->IsContainerNode()) { |
| pFormParent->RemoveChild(pExistingNode); |
| pFormParent->InsertChild(pExistingNode); |
| } |
| pExistingNode->ClearFlag(XFA_NODEFLAG_UnusedNode); |
| pExistingNode->SetTemplateNode(pTemplateNode); |
| if (bRecursive && pExistingNode->GetClassID() != XFA_ELEMENT_Items) { |
| for (CXFA_Node* pTemplateChild = |
| pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild); |
| pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem( |
| XFA_NODEITEM_NextSibling)) { |
| if (XFA_NeedGenerateForm(pTemplateChild)) { |
| XFA_NodeMerge_CloneOrMergeContainer(pDocument, pExistingNode, |
| pTemplateChild, bRecursive); |
| } |
| } |
| } |
| pExistingNode->SetFlag(XFA_NODEFLAG_Initialized, true); |
| return pExistingNode; |
| } |
| CXFA_Node* pNewNode = pTemplateNode->CloneTemplateToForm(FALSE); |
| pFormParent->InsertChild(pNewNode, NULL); |
| if (bRecursive) { |
| for (CXFA_Node* pTemplateChild = |
| pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild); |
| pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem( |
| XFA_NODEITEM_NextSibling)) { |
| if (XFA_NeedGenerateForm(pTemplateChild)) { |
| CXFA_Node* pNewChild = pTemplateChild->CloneTemplateToForm(TRUE); |
| pNewNode->InsertChild(pNewChild, NULL); |
| } |
| } |
| } |
| return pNewNode; |
| } |
| static CXFA_Node* XFA_NodeMerge_CloneOrMergeInstanceManager( |
| CXFA_Document* pDocument, |
| CXFA_Node* pFormParent, |
| CXFA_Node* pTemplateNode, |
| CXFA_NodeArray& subforms) { |
| CFX_WideStringC wsSubformName = pTemplateNode->GetCData(XFA_ATTRIBUTE_Name); |
| CFX_WideString wsInstMgrNodeName = FX_WSTRC(L"_") + wsSubformName; |
| uint32_t dwInstNameHash = |
| FX_HashCode_GetW(wsInstMgrNodeName.AsStringC(), false); |
| CXFA_Node* pExistingNode = XFA_DataMerge_FindFormDOMInstance( |
| pDocument, XFA_ELEMENT_InstanceManager, dwInstNameHash, pFormParent); |
| if (pExistingNode) { |
| uint32_t dwNameHash = pTemplateNode->GetNameHash(); |
| for (CXFA_Node* pNode = |
| pExistingNode->GetNodeItem(XFA_NODEITEM_NextSibling); |
| pNode;) { |
| XFA_ELEMENT eCurType = pNode->GetClassID(); |
| if (eCurType == XFA_ELEMENT_InstanceManager) { |
| break; |
| } |
| if ((eCurType != XFA_ELEMENT_Subform) && |
| (eCurType != XFA_ELEMENT_SubformSet)) { |
| pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling); |
| continue; |
| } |
| if (dwNameHash != pNode->GetNameHash()) { |
| break; |
| } |
| CXFA_Node* pNextNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling); |
| pFormParent->RemoveChild(pNode); |
| subforms.Add(pNode); |
| pNode = pNextNode; |
| } |
| pFormParent->RemoveChild(pExistingNode); |
| pFormParent->InsertChild(pExistingNode); |
| pExistingNode->ClearFlag(XFA_NODEFLAG_UnusedNode); |
| pExistingNode->SetTemplateNode(pTemplateNode); |
| return pExistingNode; |
| } |
| CXFA_Node* pNewNode = pDocument->GetParser()->GetFactory()->CreateNode( |
| XFA_XDPPACKET_Form, XFA_ELEMENT_InstanceManager); |
| ASSERT(pNewNode); |
| wsInstMgrNodeName = |
| FX_WSTRC(L"_") + pTemplateNode->GetCData(XFA_ATTRIBUTE_Name); |
| pNewNode->SetCData(XFA_ATTRIBUTE_Name, wsInstMgrNodeName); |
| pFormParent->InsertChild(pNewNode, NULL); |
| pNewNode->SetTemplateNode(pTemplateNode); |
| return pNewNode; |
| } |
| static CXFA_Node* XFA_DataMerge_FindMatchingDataNode( |
| CXFA_Document* pDocument, |
| CXFA_Node* pTemplateNode, |
| CXFA_Node* pDataScope, |
| FX_BOOL& bAccessedDataDOM, |
| FX_BOOL bForceBind, |
| CXFA_NodeIteratorTemplate<CXFA_Node, |
| CXFA_TraverseStrategy_XFAContainerNode>* |
| pIterator, |
| FX_BOOL& bSelfMatch, |
| XFA_ATTRIBUTEENUM& eBindMatch, |
| FX_BOOL bUpLevel = TRUE) { |
| FX_BOOL bOwnIterator = FALSE; |
| if (!pIterator) { |
| bOwnIterator = TRUE; |
| pIterator = new CXFA_NodeIteratorTemplate< |
| CXFA_Node, CXFA_TraverseStrategy_XFAContainerNode>(pTemplateNode); |
| } |
| CXFA_Node* pResult = NULL; |
| for (CXFA_Node* pCurTemplateNode = pIterator->GetCurrent(); |
| pCurTemplateNode;) { |
| XFA_ELEMENT eMatchNodeType; |
| switch (pCurTemplateNode->GetClassID()) { |
| case XFA_ELEMENT_Subform: |
| eMatchNodeType = XFA_ELEMENT_DataGroup; |
| break; |
| case XFA_ELEMENT_Field: { |
| eMatchNodeType = XFA_FieldIsMultiListBox(pCurTemplateNode) |
| ? XFA_ELEMENT_DataGroup |
| : XFA_ELEMENT_DataValue; |
| } break; |
| case XFA_ELEMENT_ExclGroup: |
| eMatchNodeType = XFA_ELEMENT_DataValue; |
| break; |
| default: |
| pCurTemplateNode = pIterator->MoveToNext(); |
| continue; |
| } |
| CXFA_Node* pTemplateNodeOccur = |
| pCurTemplateNode->GetFirstChildByClass(XFA_ELEMENT_Occur); |
| int32_t iMin, iMax, iInit; |
| if (pTemplateNodeOccur && |
| XFA_GetOccurInfo(pTemplateNodeOccur, iMin, iMax, iInit) && iMax == 0) { |
| pCurTemplateNode = pIterator->MoveToNext(); |
| continue; |
| } |
| CXFA_Node* pTemplateNodeBind = |
| pCurTemplateNode->GetFirstChildByClass(XFA_ELEMENT_Bind); |
| XFA_ATTRIBUTEENUM eMatch = |
| pTemplateNodeBind ? pTemplateNodeBind->GetEnum(XFA_ATTRIBUTE_Match) |
| : XFA_ATTRIBUTEENUM_Once; |
| eBindMatch = eMatch; |
| switch (eMatch) { |
| case XFA_ATTRIBUTEENUM_None: |
| pCurTemplateNode = pIterator->MoveToNext(); |
| continue; |
| case XFA_ATTRIBUTEENUM_Global: |
| bAccessedDataDOM = TRUE; |
| if (!bForceBind) { |
| pCurTemplateNode = pIterator->MoveToNext(); |
| continue; |
| } |
| if (eMatchNodeType == XFA_ELEMENT_DataValue || |
| (eMatchNodeType == XFA_ELEMENT_DataGroup && |
| XFA_FieldIsMultiListBox(pTemplateNodeBind))) { |
| CXFA_Node* pGlobalBindNode = XFA_DataMerge_FindGlobalDataNode( |
| pDocument, pCurTemplateNode->GetCData(XFA_ATTRIBUTE_Name), |
| pDataScope, eMatchNodeType); |
| if (!pGlobalBindNode) { |
| pCurTemplateNode = pIterator->MoveToNext(); |
| continue; |
| } |
| pResult = pGlobalBindNode; |
| break; |
| } |
| case XFA_ATTRIBUTEENUM_Once: { |
| bAccessedDataDOM = TRUE; |
| CXFA_Node* pOnceBindNode = XFA_DataMerge_FindOnceDataNode( |
| pDocument, pCurTemplateNode->GetCData(XFA_ATTRIBUTE_Name), |
| pDataScope, eMatchNodeType); |
| if (!pOnceBindNode) { |
| pCurTemplateNode = pIterator->MoveToNext(); |
| continue; |
| } |
| pResult = pOnceBindNode; |
| } break; |
| case XFA_ATTRIBUTEENUM_DataRef: { |
| bAccessedDataDOM = TRUE; |
| CXFA_Node* pDataRefBindNode = XFA_DataMerge_FindDataRefDataNode( |
| pDocument, pTemplateNodeBind->GetCData(XFA_ATTRIBUTE_Ref), |
| pDataScope, eMatchNodeType, pTemplateNode, bForceBind, bUpLevel); |
| if (pDataRefBindNode && |
| pDataRefBindNode->GetClassID() == eMatchNodeType) { |
| pResult = pDataRefBindNode; |
| } |
| if (!pResult) { |
| pCurTemplateNode = pIterator->SkipChildrenAndMoveToNext(); |
| continue; |
| } |
| } break; |
| default: |
| break; |
| } |
| if (pCurTemplateNode == pTemplateNode && pResult) { |
| bSelfMatch = TRUE; |
| } |
| break; |
| } |
| if (bOwnIterator) { |
| delete pIterator; |
| } |
| return pResult; |
| } |
| static void XFA_DataMerge_SortRecurseRecord( |
| CFX_ArrayTemplate<XFA_DataMerge_RecurseRecord>& rgRecords, |
| CXFA_Node* pDataScope, |
| FX_BOOL bChoiceMode = FALSE) { |
| int32_t iCount = rgRecords.GetSize(); |
| CFX_ArrayTemplate<XFA_DataMerge_RecurseRecord> rgResultRecord; |
| for (CXFA_Node* pChildNode = pDataScope->GetNodeItem(XFA_NODEITEM_FirstChild); |
| pChildNode; |
| pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { |
| for (int32_t i = 0; i < iCount; i++) { |
| CXFA_Node* pNode = rgRecords[i].pDataChild; |
| if (pChildNode == pNode) { |
| XFA_DataMerge_RecurseRecord sNewRecord = {rgRecords[i].pTemplateChild, |
| pNode}; |
| rgResultRecord.Add(sNewRecord); |
| rgRecords.RemoveAt(i); |
| iCount--; |
| break; |
| } |
| } |
| if (bChoiceMode && rgResultRecord.GetSize() > 0) { |
| break; |
| } |
| } |
| if (rgResultRecord.GetSize() > 0) { |
| if (!bChoiceMode) { |
| for (int32_t i = 0; i < iCount; i++) { |
| XFA_DataMerge_RecurseRecord sNewRecord = {rgRecords[i].pTemplateChild, |
| rgRecords[i].pDataChild}; |
| rgResultRecord.Add(sNewRecord); |
| } |
| } |
| rgRecords.RemoveAll(); |
| rgRecords.Copy(rgResultRecord); |
| } |
| } |
| static CXFA_Node* XFA_DataMerge_CopyContainer_SubformSet( |
| CXFA_Document* pDocument, |
| CXFA_Node* pTemplateNode, |
| CXFA_Node* pFormParentNode, |
| CXFA_Node* pDataScope, |
| FX_BOOL bOneInstance, |
| FX_BOOL bDataMerge) { |
| XFA_ELEMENT eElement = pTemplateNode->GetClassID(); |
| CXFA_Node* pOccurNode = NULL; |
| CXFA_Node* pFirstInstance = NULL; |
| FX_BOOL bUseInstanceManager = |
| pFormParentNode->GetClassID() != XFA_ELEMENT_Area; |
| CXFA_Node* pInstMgrNode = NULL; |
| CXFA_NodeArray subformArray; |
| CXFA_NodeArray* pSearchArray = NULL; |
| if (!bOneInstance && |
| (eElement == XFA_ELEMENT_SubformSet || eElement == XFA_ELEMENT_Subform)) { |
| pInstMgrNode = |
| bUseInstanceManager |
| ? XFA_NodeMerge_CloneOrMergeInstanceManager( |
| pDocument, pFormParentNode, pTemplateNode, subformArray) |
| : NULL; |
| if (CXFA_Node* pOccurTemplateNode = |
| pTemplateNode->GetFirstChildByClass(XFA_ELEMENT_Occur)) { |
| pOccurNode = pInstMgrNode |
| ? XFA_NodeMerge_CloneOrMergeContainer( |
| pDocument, pInstMgrNode, pOccurTemplateNode, FALSE) |
| : pOccurTemplateNode; |
| } else if (pInstMgrNode) { |
| pOccurNode = pInstMgrNode->GetFirstChildByClass(XFA_ELEMENT_Occur); |
| if (pOccurNode) { |
| pOccurNode->ClearFlag(XFA_NODEFLAG_UnusedNode); |
| } |
| } |
| if (pInstMgrNode) { |
| pInstMgrNode->SetFlag(XFA_NODEFLAG_Initialized, true); |
| pSearchArray = &subformArray; |
| if (pFormParentNode->GetClassID() == XFA_ELEMENT_PageArea) { |
| bOneInstance = TRUE; |
| if (subformArray.GetSize() < 1) { |
| pSearchArray = NULL; |
| } |
| } else if ((pTemplateNode->GetNameHash() == 0) && |
| (subformArray.GetSize() < 1)) { |
| pSearchArray = NULL; |
| } |
| } |
| } |
| int32_t iMax = 1, iInit = 1, iMin = 1; |
| if (!bOneInstance) { |
| XFA_GetOccurInfo(pOccurNode, iMin, iMax, iInit); |
| } |
| XFA_ATTRIBUTEENUM eRelation = |
| eElement == XFA_ELEMENT_SubformSet |
| ? pTemplateNode->GetEnum(XFA_ATTRIBUTE_Relation) |
| : XFA_ATTRIBUTEENUM_Ordered; |
| int32_t iCurRepeatIndex = 0; |
| XFA_ATTRIBUTEENUM eParentBindMatch = XFA_ATTRIBUTEENUM_None; |
| if (bDataMerge) { |
| CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFAContainerNode> |
| sNodeIterator(pTemplateNode); |
| FX_BOOL bAccessedDataDOM = FALSE; |
| if (eElement == XFA_ELEMENT_SubformSet || eElement == XFA_ELEMENT_Area) { |
| sNodeIterator.MoveToNext(); |
| } else { |
| CFX_MapPtrTemplate<CXFA_Node*, CXFA_Node*> subformMapArray; |
| CXFA_NodeArray subformArray; |
| for (; iMax < 0 || iCurRepeatIndex < iMax; iCurRepeatIndex++) { |
| FX_BOOL bSelfMatch = FALSE; |
| XFA_ATTRIBUTEENUM eBindMatch = XFA_ATTRIBUTEENUM_None; |
| CXFA_Node* pDataNode = XFA_DataMerge_FindMatchingDataNode( |
| pDocument, pTemplateNode, pDataScope, bAccessedDataDOM, FALSE, |
| &sNodeIterator, bSelfMatch, eBindMatch); |
| if (!pDataNode || sNodeIterator.GetCurrent() != pTemplateNode) { |
| break; |
| } |
| eParentBindMatch = eBindMatch; |
| CXFA_Node* pSubformNode = XFA_NodeMerge_CloneOrMergeContainer( |
| pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray); |
| if (!pFirstInstance) { |
| pFirstInstance = pSubformNode; |
| } |
| XFA_DataMerge_CreateDataBinding(pSubformNode, pDataNode); |
| ASSERT(pSubformNode); |
| subformMapArray.SetAt(pSubformNode, pDataNode); |
| subformArray.Add(pSubformNode); |
| } |
| subformMapArray.GetStartPosition(); |
| for (int32_t iIndex = 0; iIndex < subformArray.GetSize(); iIndex++) { |
| CXFA_Node* pSubform = subformArray[iIndex]; |
| CXFA_Node* pDataNode = |
| reinterpret_cast<CXFA_Node*>(subformMapArray.GetValueAt(pSubform)); |
| for (CXFA_Node* pTemplateChild = |
| pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild); |
| pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem( |
| XFA_NODEITEM_NextSibling)) { |
| if (XFA_NeedGenerateForm(pTemplateChild, bUseInstanceManager)) { |
| XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubform, |
| pTemplateChild, TRUE); |
| } else if (pTemplateChild->GetObjectType() == |
| XFA_OBJECTTYPE_ContainerNode) { |
| pDocument->DataMerge_CopyContainer(pTemplateChild, pSubform, |
| pDataNode, FALSE, TRUE, FALSE); |
| } |
| } |
| } |
| subformMapArray.RemoveAll(); |
| } |
| for (; iMax < 0 || iCurRepeatIndex < iMax; iCurRepeatIndex++) { |
| FX_BOOL bSelfMatch = FALSE; |
| XFA_ATTRIBUTEENUM eBindMatch = XFA_ATTRIBUTEENUM_None; |
| if (!XFA_DataMerge_FindMatchingDataNode( |
| pDocument, pTemplateNode, pDataScope, bAccessedDataDOM, FALSE, |
| &sNodeIterator, bSelfMatch, eBindMatch)) { |
| break; |
| } |
| if (eBindMatch == XFA_ATTRIBUTEENUM_DataRef && |
| eParentBindMatch == XFA_ATTRIBUTEENUM_DataRef) { |
| break; |
| } |
| if (eRelation == XFA_ATTRIBUTEENUM_Choice || |
| eRelation == XFA_ATTRIBUTEENUM_Unordered) { |
| CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer( |
| pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray); |
| ASSERT(pSubformSetNode); |
| if (!pFirstInstance) { |
| pFirstInstance = pSubformSetNode; |
| } |
| CFX_ArrayTemplate<XFA_DataMerge_RecurseRecord> rgItemMatchList; |
| CFX_ArrayTemplate<CXFA_Node*> rgItemUnmatchList; |
| for (CXFA_Node* pTemplateChild = |
| pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild); |
| pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem( |
| XFA_NODEITEM_NextSibling)) { |
| if (XFA_NeedGenerateForm(pTemplateChild, bUseInstanceManager)) { |
| XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformSetNode, |
| pTemplateChild, TRUE); |
| } else if (pTemplateChild->GetObjectType() == |
| XFA_OBJECTTYPE_ContainerNode) { |
| CXFA_Node* pDataMatch; |
| bSelfMatch = FALSE; |
| eBindMatch = XFA_ATTRIBUTEENUM_None; |
| if (eRelation != XFA_ATTRIBUTEENUM_Ordered && |
| (pDataMatch = XFA_DataMerge_FindMatchingDataNode( |
| pDocument, pTemplateChild, pDataScope, bAccessedDataDOM, |
| FALSE, NULL, bSelfMatch, eBindMatch))) { |
| XFA_DataMerge_RecurseRecord sNewRecord = {pTemplateChild, |
| pDataMatch}; |
| if (bSelfMatch) { |
| rgItemMatchList.InsertAt(0, sNewRecord); |
| } else { |
| rgItemMatchList.Add(sNewRecord); |
| } |
| } else { |
| rgItemUnmatchList.Add(pTemplateChild); |
| } |
| } |
| } |
| switch (eRelation) { |
| case XFA_ATTRIBUTEENUM_Choice: { |
| ASSERT(rgItemMatchList.GetSize()); |
| XFA_DataMerge_SortRecurseRecord(rgItemMatchList, pDataScope, TRUE); |
| pDocument->DataMerge_CopyContainer( |
| rgItemMatchList[0].pTemplateChild, pSubformSetNode, pDataScope); |
| } break; |
| case XFA_ATTRIBUTEENUM_Unordered: { |
| if (rgItemMatchList.GetSize()) { |
| XFA_DataMerge_SortRecurseRecord(rgItemMatchList, pDataScope); |
| for (int32_t i = 0, count = rgItemMatchList.GetSize(); i < count; |
| i++) { |
| pDocument->DataMerge_CopyContainer( |
| rgItemMatchList[i].pTemplateChild, pSubformSetNode, |
| pDataScope); |
| } |
| } |
| for (int32_t i = 0, count = rgItemUnmatchList.GetSize(); i < count; |
| i++) { |
| pDocument->DataMerge_CopyContainer(rgItemUnmatchList[i], |
| pSubformSetNode, pDataScope); |
| } |
| } break; |
| default: |
| break; |
| } |
| } else { |
| CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer( |
| pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray); |
| ASSERT(pSubformSetNode); |
| if (!pFirstInstance) { |
| pFirstInstance = pSubformSetNode; |
| } |
| for (CXFA_Node* pTemplateChild = |
| pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild); |
| pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem( |
| XFA_NODEITEM_NextSibling)) { |
| if (XFA_NeedGenerateForm(pTemplateChild, bUseInstanceManager)) { |
| XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformSetNode, |
| pTemplateChild, TRUE); |
| } else if (pTemplateChild->GetObjectType() == |
| XFA_OBJECTTYPE_ContainerNode) { |
| pDocument->DataMerge_CopyContainer(pTemplateChild, pSubformSetNode, |
| pDataScope); |
| } |
| } |
| } |
| } |
| if (iCurRepeatIndex == 0 && bAccessedDataDOM == FALSE) { |
| int32_t iLimit = iMax; |
| if (pInstMgrNode && pTemplateNode->GetNameHash() == 0) { |
| iLimit = subformArray.GetSize(); |
| if (iLimit < iMin) { |
| iLimit = iInit; |
| } |
| } |
| for (; (iLimit < 0 || iCurRepeatIndex < iLimit); iCurRepeatIndex++) { |
| if (pInstMgrNode) { |
| if (pSearchArray && pSearchArray->GetSize() < 1) { |
| if (pTemplateNode->GetNameHash() != 0) { |
| break; |
| } |
| pSearchArray = NULL; |
| } |
| } else if (!XFA_DataMerge_FindFormDOMInstance( |
| pDocument, pTemplateNode->GetClassID(), |
| pTemplateNode->GetNameHash(), pFormParentNode)) { |
| break; |
| } |
| CXFA_Node* pSubformNode = XFA_NodeMerge_CloneOrMergeContainer( |
| pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray); |
| ASSERT(pSubformNode); |
| if (!pFirstInstance) { |
| pFirstInstance = pSubformNode; |
| } |
| for (CXFA_Node* pTemplateChild = |
| pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild); |
| pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem( |
| XFA_NODEITEM_NextSibling)) { |
| if (XFA_NeedGenerateForm(pTemplateChild, bUseInstanceManager)) { |
| XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformNode, |
| pTemplateChild, TRUE); |
| } else if (pTemplateChild->GetObjectType() == |
| XFA_OBJECTTYPE_ContainerNode) { |
| pDocument->DataMerge_CopyContainer(pTemplateChild, pSubformNode, |
| pDataScope); |
| } |
| } |
| } |
| } |
| } |
| int32_t iMinimalLimit = iCurRepeatIndex == 0 ? iInit : iMin; |
| for (; iCurRepeatIndex < iMinimalLimit; iCurRepeatIndex++) { |
| CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer( |
| pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray); |
| ASSERT(pSubformSetNode); |
| if (!pFirstInstance) { |
| pFirstInstance = pSubformSetNode; |
| } |
| FX_BOOL bFound = FALSE; |
| for (CXFA_Node* pTemplateChild = |
| pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild); |
| pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem( |
| XFA_NODEITEM_NextSibling)) { |
| if (XFA_NeedGenerateForm(pTemplateChild, bUseInstanceManager)) { |
| XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformSetNode, |
| pTemplateChild, TRUE); |
| } else if (pTemplateChild->GetObjectType() == |
| XFA_OBJECTTYPE_ContainerNode) { |
| if (bFound && eRelation == XFA_ATTRIBUTEENUM_Choice) { |
| continue; |
| } |
| pDocument->DataMerge_CopyContainer(pTemplateChild, pSubformSetNode, |
| pDataScope, FALSE, bDataMerge); |
| bFound = TRUE; |
| } |
| } |
| } |
| return pFirstInstance; |
| } |
| static CXFA_Node* XFA_DataMerge_CopyContainer_Field(CXFA_Document* pDocument, |
| CXFA_Node* pTemplateNode, |
| CXFA_Node* pFormNode, |
| CXFA_Node* pDataScope, |
| FX_BOOL bDataMerge, |
| FX_BOOL bUpLevel = TRUE) { |
| CXFA_Node* pFieldNode = XFA_NodeMerge_CloneOrMergeContainer( |
| pDocument, pFormNode, pTemplateNode, FALSE); |
| ASSERT(pFieldNode); |
| for (CXFA_Node* pTemplateChildNode = |
| pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild); |
| pTemplateChildNode; pTemplateChildNode = pTemplateChildNode->GetNodeItem( |
| XFA_NODEITEM_NextSibling)) { |
| if (XFA_NeedGenerateForm(pTemplateChildNode)) { |
| XFA_NodeMerge_CloneOrMergeContainer(pDocument, pFieldNode, |
| pTemplateChildNode, TRUE); |
| } else if (pTemplateNode->GetClassID() == XFA_ELEMENT_ExclGroup && |
| pTemplateChildNode->IsContainerNode()) { |
| if (pTemplateChildNode->GetClassID() == XFA_ELEMENT_Field) { |
| XFA_DataMerge_CopyContainer_Field(pDocument, pTemplateChildNode, |
| pFieldNode, NULL, FALSE); |
| } |
| } |
| } |
| if (bDataMerge) { |
| FX_BOOL bAccessedDataDOM = FALSE; |
| FX_BOOL bSelfMatch = FALSE; |
| XFA_ATTRIBUTEENUM eBindMatch; |
| CXFA_Node* pDataNode = XFA_DataMerge_FindMatchingDataNode( |
| pDocument, pTemplateNode, pDataScope, bAccessedDataDOM, TRUE, NULL, |
| bSelfMatch, eBindMatch, bUpLevel); |
| if (pDataNode) { |
| XFA_DataMerge_CreateDataBinding(pFieldNode, pDataNode); |
| } |
| } else { |
| XFA_DataMerge_FormValueNode_MatchNoneCreateChild(pFieldNode); |
| } |
| return pFieldNode; |
| } |
| CXFA_Node* CXFA_Document::DataMerge_CopyContainer(CXFA_Node* pTemplateNode, |
| CXFA_Node* pFormNode, |
| CXFA_Node* pDataScope, |
| FX_BOOL bOneInstance, |
| FX_BOOL bDataMerge, |
| FX_BOOL bUpLevel) { |
| switch (pTemplateNode->GetClassID()) { |
| case XFA_ELEMENT_SubformSet: |
| case XFA_ELEMENT_Subform: |
| case XFA_ELEMENT_Area: |
| case XFA_ELEMENT_PageArea: |
| return XFA_DataMerge_CopyContainer_SubformSet( |
| this, pTemplateNode, pFormNode, pDataScope, bOneInstance, bDataMerge); |
| case XFA_ELEMENT_ExclGroup: |
| case XFA_ELEMENT_Field: |
| case XFA_ELEMENT_Draw: |
| case XFA_ELEMENT_ContentArea: |
| return XFA_DataMerge_CopyContainer_Field( |
| this, pTemplateNode, pFormNode, pDataScope, bDataMerge, bUpLevel); |
| case XFA_ELEMENT_PageSet: |
| break; |
| case XFA_ELEMENT_Variables: |
| break; |
| default: |
| ASSERT(FALSE); |
| break; |
| } |
| return NULL; |
| } |
| |
| static void XFA_DataMerge_UpdateBindingRelations(CXFA_Document* pDocument, |
| CXFA_Node* pFormNode, |
| CXFA_Node* pDataScope, |
| FX_BOOL bDataRef, |
| FX_BOOL bParentDataRef) { |
| FX_BOOL bMatchRef = TRUE; |
| XFA_ELEMENT eClassID = pFormNode->GetClassID(); |
| CXFA_Node* pDataNode = pFormNode->GetBindData(); |
| if (eClassID == XFA_ELEMENT_Subform || eClassID == XFA_ELEMENT_ExclGroup || |
| eClassID == XFA_ELEMENT_Field) { |
| CXFA_Node* pTemplateNode = pFormNode->GetTemplateNode(); |
| CXFA_Node* pTemplateNodeBind = |
| pTemplateNode ? pTemplateNode->GetFirstChildByClass(XFA_ELEMENT_Bind) |
| : NULL; |
| XFA_ATTRIBUTEENUM eMatch = |
| pTemplateNodeBind ? pTemplateNodeBind->GetEnum(XFA_ATTRIBUTE_Match) |
| : XFA_ATTRIBUTEENUM_Once; |
| switch (eMatch) { |
| case XFA_ATTRIBUTEENUM_None: |
| if (!bDataRef || bParentDataRef) { |
| XFA_DataMerge_FormValueNode_MatchNoneCreateChild(pFormNode); |
| } |
| break; |
| case XFA_ATTRIBUTEENUM_Once: |
| if (!bDataRef || bParentDataRef) { |
| if (!pDataNode) { |
| if (pFormNode->GetNameHash() != 0 && |
| pFormNode->GetEnum(XFA_ATTRIBUTE_Scope) != |
| XFA_ATTRIBUTEENUM_None) { |
| XFA_ELEMENT eDataNodeType = (eClassID == XFA_ELEMENT_Subform || |
| XFA_FieldIsMultiListBox(pFormNode)) |
| ? XFA_ELEMENT_DataGroup |
| : XFA_ELEMENT_DataValue; |
| pDataNode = XFA_DataDescription_MaybeCreateDataNode( |
| pDocument, pDataScope, eDataNodeType, |
| pFormNode->GetCData(XFA_ATTRIBUTE_Name)); |
| if (pDataNode) { |
| XFA_DataMerge_CreateDataBinding(pFormNode, pDataNode, FALSE); |
| } |
| } |
| if (!pDataNode) { |
| XFA_DataMerge_FormValueNode_MatchNoneCreateChild(pFormNode); |
| } |
| } else { |
| CXFA_Node* pDataParent = |
| pDataNode->GetNodeItem(XFA_NODEITEM_Parent); |
| if (pDataParent != pDataScope) { |
| ASSERT(pDataParent); |
| pDataParent->RemoveChild(pDataNode); |
| pDataScope->InsertChild(pDataNode); |
| } |
| } |
| } |
| break; |
| case XFA_ATTRIBUTEENUM_Global: |
| if (!bDataRef || bParentDataRef) { |
| uint32_t dwNameHash = pFormNode->GetNameHash(); |
| if (dwNameHash != 0 && !pDataNode) { |
| pDataNode = XFA_DataMerge_GetGlobalBinding(pDocument, dwNameHash); |
| if (!pDataNode) { |
| XFA_ELEMENT eDataNodeType = (eClassID == XFA_ELEMENT_Subform || |
| XFA_FieldIsMultiListBox(pFormNode)) |
| ? XFA_ELEMENT_DataGroup |
| : XFA_ELEMENT_DataValue; |
| CXFA_Node* pRecordNode = |
| ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Record)); |
| pDataNode = XFA_DataDescription_MaybeCreateDataNode( |
| pDocument, pRecordNode, eDataNodeType, |
| pFormNode->GetCData(XFA_ATTRIBUTE_Name)); |
| if (pDataNode) { |
| XFA_DataMerge_CreateDataBinding(pFormNode, pDataNode, FALSE); |
| XFA_DataMerge_RegisterGlobalBinding( |
| pDocument, pFormNode->GetNameHash(), pDataNode); |
| } |
| } else { |
| XFA_DataMerge_CreateDataBinding(pFormNode, pDataNode); |
| } |
| } |
| if (!pDataNode) { |
| XFA_DataMerge_FormValueNode_MatchNoneCreateChild(pFormNode); |
| } |
| } |
| break; |
| case XFA_ATTRIBUTEENUM_DataRef: { |
| bMatchRef = bDataRef; |
| bParentDataRef = TRUE; |
| if (!pDataNode && bDataRef) { |
| CFX_WideStringC wsRef = |
| pTemplateNodeBind->GetCData(XFA_ATTRIBUTE_Ref); |
| uint32_t dFlags = |
| XFA_RESOLVENODE_Children | XFA_RESOLVENODE_CreateNode; |
| XFA_RESOLVENODE_RS rs; |
| pDocument->GetScriptContext()->ResolveObjects(pDataScope, wsRef, rs, |
| dFlags, pTemplateNode); |
| CXFA_Object* pObject = (rs.nodes.GetSize() > 0) ? rs.nodes[0] : NULL; |
| pDataNode = ToNode(pObject); |
| if (pDataNode) { |
| XFA_DataMerge_CreateDataBinding( |
| pFormNode, pDataNode, |
| rs.dwFlags == XFA_RESOVENODE_RSTYPE_ExistNodes); |
| } else { |
| XFA_DataMerge_FormValueNode_MatchNoneCreateChild(pFormNode); |
| } |
| } |
| } break; |
| default: |
| break; |
| } |
| } |
| if (bMatchRef && |
| (eClassID == XFA_ELEMENT_Subform || eClassID == XFA_ELEMENT_SubformSet || |
| eClassID == XFA_ELEMENT_Area || eClassID == XFA_ELEMENT_PageArea || |
| eClassID == XFA_ELEMENT_PageSet)) { |
| for (CXFA_Node* pFormChild = |
| pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild); |
| pFormChild; |
| pFormChild = pFormChild->GetNodeItem(XFA_NODEITEM_NextSibling)) { |
| if (pFormChild->GetObjectType() != XFA_OBJECTTYPE_ContainerNode) { |
| continue; |
| } |
| if (pFormChild->HasFlag(XFA_NODEFLAG_UnusedNode)) { |
| continue; |
| } |
| XFA_DataMerge_UpdateBindingRelations(pDocument, pFormChild, |
| pDataNode ? pDataNode : pDataScope, |
| bDataRef, bParentDataRef); |
| } |
| } |
| } |
| CXFA_Node* XFA_DataMerge_FindDataScope(CXFA_Node* pParentFormNode) { |
| for (CXFA_Node* pRootBoundNode = pParentFormNode; |
| pRootBoundNode && |
| pRootBoundNode->GetObjectType() == XFA_OBJECTTYPE_ContainerNode; |
| pRootBoundNode = pRootBoundNode->GetNodeItem(XFA_NODEITEM_Parent)) { |
| CXFA_Node* pDataScope = pRootBoundNode->GetBindData(); |
| if (pDataScope) { |
| return pDataScope; |
| } |
| } |
| return ToNode( |
| pParentFormNode->GetDocument()->GetXFAObject(XFA_HASHCODE_Data)); |
| } |
| void CXFA_Document::DataMerge_UpdateBindingRelations( |
| CXFA_Node* pFormUpdateRoot) { |
| CXFA_Node* pDataScope = XFA_DataMerge_FindDataScope( |
| pFormUpdateRoot->GetNodeItem(XFA_NODEITEM_Parent)); |
| if (!pDataScope) { |
| return; |
| } |
| XFA_DataMerge_UpdateBindingRelations(this, pFormUpdateRoot, pDataScope, FALSE, |
| FALSE); |
| XFA_DataMerge_UpdateBindingRelations(this, pFormUpdateRoot, pDataScope, TRUE, |
| FALSE); |
| } |
| CXFA_Node* CXFA_Document::GetNotBindNode(CXFA_ObjArray& arrayNodes) { |
| for (int32_t i = 0; i < arrayNodes.GetSize(); i++) { |
| CXFA_Node* pNode = arrayNodes[i]->AsNode(); |
| if (pNode && !pNode->HasBindItem()) |
| return pNode; |
| } |
| return nullptr; |
| } |
| void CXFA_Document::DoDataMerge() { |
| CXFA_Node* pDatasetsRoot = ToNode(GetXFAObject(XFA_HASHCODE_Datasets)); |
| if (!pDatasetsRoot) { |
| CFDE_XMLElement* pDatasetsXMLNode = |
| new CFDE_XMLElement(FX_WSTRC(L"xfa:datasets")); |
| |
| pDatasetsXMLNode->SetString( |
| FX_WSTRC(L"xmlns:xfa"), |
| FX_WSTRC(L"http://www.xfa.org/schema/xfa-data/1.0/")); |
| pDatasetsRoot = CreateNode(XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataModel); |
| pDatasetsRoot->SetCData(XFA_ATTRIBUTE_Name, FX_WSTRC(L"datasets")); |
| m_pRootNode->GetXMLMappingNode()->InsertChildNode(pDatasetsXMLNode); |
| m_pRootNode->InsertChild(pDatasetsRoot); |
| pDatasetsRoot->SetXMLMappingNode(pDatasetsXMLNode); |
| } |
| CXFA_Node *pDataRoot = NULL, *pDDRoot = NULL; |
| CFX_WideString wsDatasetsURI; |
| pDatasetsRoot->TryNamespace(wsDatasetsURI); |
| for (CXFA_Node* pChildNode = |
| pDatasetsRoot->GetNodeItem(XFA_NODEITEM_FirstChild); |
| pChildNode; |
| pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { |
| if (pChildNode->GetClassID() != XFA_ELEMENT_DataGroup) { |
| continue; |
| } |
| CFX_WideString wsNamespaceURI; |
| if (!pDDRoot && pChildNode->GetNameHash() == XFA_HASHCODE_DataDescription) { |
| if (!pChildNode->TryNamespace(wsNamespaceURI)) { |
| continue; |
| } |
| if (wsNamespaceURI == |
| FX_WSTRC(L"http://ns.adobe.com/data-description/")) { |
| pDDRoot = pChildNode; |
| } |
| } else if (!pDataRoot && pChildNode->GetNameHash() == XFA_HASHCODE_Data) { |
| if (!pChildNode->TryNamespace(wsNamespaceURI)) { |
| continue; |
| } |
| if (wsNamespaceURI == wsDatasetsURI) { |
| pDataRoot = pChildNode; |
| } |
| } |
| if (pDataRoot && pDDRoot) { |
| break; |
| } |
| } |
| if (!pDataRoot) { |
| CFDE_XMLElement* pDataRootXMLNode = |
| new CFDE_XMLElement(FX_WSTRC(L"xfa:data")); |
| |
| pDataRoot = CreateNode(XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataGroup); |
| pDataRoot->SetCData(XFA_ATTRIBUTE_Name, FX_WSTRC(L"data")); |
| pDataRoot->SetXMLMappingNode(pDataRootXMLNode); |
| pDatasetsRoot->InsertChild(pDataRoot); |
| } |
| CXFA_Node* pDataTopLevel = |
| pDataRoot->GetFirstChildByClass(XFA_ELEMENT_DataGroup); |
| uint32_t dwNameHash = pDataTopLevel ? pDataTopLevel->GetNameHash() : 0; |
| CXFA_Node* pTemplateRoot = |
| m_pRootNode->GetFirstChildByClass(XFA_ELEMENT_Template); |
| if (!pTemplateRoot) { |
| return; |
| } |
| CXFA_Node* pTemplateChosen = |
| dwNameHash != 0 ? pTemplateRoot->GetFirstChildByName(dwNameHash) : NULL; |
| if (!pTemplateChosen || |
| pTemplateChosen->GetClassID() != XFA_ELEMENT_Subform) { |
| pTemplateChosen = pTemplateRoot->GetFirstChildByClass(XFA_ELEMENT_Subform); |
| } |
| if (!pTemplateChosen) { |
| return; |
| } |
| CXFA_Node* pFormRoot = m_pRootNode->GetFirstChildByClass(XFA_ELEMENT_Form); |
| FX_BOOL bEmptyForm = FALSE; |
| if (!pFormRoot) { |
| bEmptyForm = TRUE; |
| pFormRoot = CreateNode(XFA_XDPPACKET_Form, XFA_ELEMENT_Form); |
| ASSERT(pFormRoot); |
| pFormRoot->SetCData(XFA_ATTRIBUTE_Name, FX_WSTRC(L"form")); |
| m_pRootNode->InsertChild(pFormRoot, NULL); |
| } else { |
| CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode> |
| sIterator(pFormRoot); |
| for (CXFA_Node* pNode = sIterator.MoveToNext(); pNode; |
| pNode = sIterator.MoveToNext()) { |
| pNode->SetFlag(XFA_NODEFLAG_UnusedNode, true); |
| } |
| } |
| CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer( |
| this, pFormRoot, pTemplateChosen, FALSE); |
| ASSERT(pSubformSetNode); |
| if (!pDataTopLevel) { |
| CFX_WideStringC wsFormName = pSubformSetNode->GetCData(XFA_ATTRIBUTE_Name); |
| CFX_WideString wsDataTopLevelName = |
| wsFormName.IsEmpty() ? FX_WSTRC(L"form") : wsFormName; |
| CFDE_XMLElement* pDataTopLevelXMLNode = |
| new CFDE_XMLElement(wsDataTopLevelName); |
| |
| pDataTopLevel = CreateNode(XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataGroup); |
| pDataTopLevel->SetCData(XFA_ATTRIBUTE_Name, wsDataTopLevelName); |
| pDataTopLevel->SetXMLMappingNode(pDataTopLevelXMLNode); |
| CXFA_Node* pBeforeNode = pDataRoot->GetNodeItem(XFA_NODEITEM_FirstChild); |
| pDataRoot->InsertChild(pDataTopLevel, pBeforeNode); |
| } |
| ASSERT(pDataTopLevel); |
| XFA_DataMerge_CreateDataBinding(pSubformSetNode, pDataTopLevel); |
| for (CXFA_Node* pTemplateChild = |
| pTemplateChosen->GetNodeItem(XFA_NODEITEM_FirstChild); |
| pTemplateChild; |
| pTemplateChild = pTemplateChild->GetNodeItem(XFA_NODEITEM_NextSibling)) { |
| if (XFA_NeedGenerateForm(pTemplateChild)) { |
| XFA_NodeMerge_CloneOrMergeContainer(this, pSubformSetNode, pTemplateChild, |
| TRUE); |
| } else if (pTemplateChild->GetObjectType() == |
| XFA_OBJECTTYPE_ContainerNode) { |
| DataMerge_CopyContainer(pTemplateChild, pSubformSetNode, pDataTopLevel); |
| } |
| } |
| if (pDDRoot) { |
| XFA_DataDescription_UpdateDataRelation(pDataRoot, pDDRoot); |
| } |
| DataMerge_UpdateBindingRelations(pSubformSetNode); |
| CXFA_Node* pPageSetNode = |
| pSubformSetNode->GetFirstChildByClass(XFA_ELEMENT_PageSet); |
| while (pPageSetNode) { |
| m_pPendingPageSet.Add(pPageSetNode); |
| CXFA_Node* pNextPageSetNode = |
| pPageSetNode->GetNextSameClassSibling(XFA_ELEMENT_PageSet); |
| pSubformSetNode->RemoveChild(pPageSetNode); |
| pPageSetNode = pNextPageSetNode; |
| } |
| if (!bEmptyForm) { |
| CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode> |
| sIterator(pFormRoot); |
| CXFA_Node* pNode = sIterator.MoveToNext(); |
| while (pNode) { |
| if (pNode->HasFlag(XFA_NODEFLAG_UnusedNode)) { |
| if (pNode->GetObjectType() == XFA_OBJECTTYPE_ContainerNode || |
| pNode->GetClassID() == XFA_ELEMENT_InstanceManager) { |
| CXFA_Node* pNext = sIterator.SkipChildrenAndMoveToNext(); |
| pNode->GetNodeItem(XFA_NODEITEM_Parent)->RemoveChild(pNode); |
| pNode = pNext; |
| } else { |
| pNode->ClearFlag(XFA_NODEFLAG_UnusedNode); |
| pNode->SetFlag(XFA_NODEFLAG_Initialized, true); |
| pNode = sIterator.MoveToNext(); |
| } |
| } else { |
| pNode->SetFlag(XFA_NODEFLAG_Initialized, true); |
| pNode = sIterator.MoveToNext(); |
| } |
| } |
| } |
| } |
| void CXFA_Document::DoDataRemerge(FX_BOOL bDoDataMerge) { |
| CXFA_Node* pFormRoot = ToNode(GetXFAObject(XFA_HASHCODE_Form)); |
| if (pFormRoot) { |
| while (CXFA_Node* pNode = pFormRoot->GetNodeItem(XFA_NODEITEM_FirstChild)) { |
| pFormRoot->RemoveChild(pNode); |
| } |
| pFormRoot->SetObject(XFA_ATTRIBUTE_BindingNode, NULL); |
| } |
| XFA_DataMerge_ClearGlobalBinding(this); |
| if (bDoDataMerge) { |
| DoDataMerge(); |
| } |
| CXFA_LayoutProcessor* pLayoutProcessor = GetLayoutProcessor(); |
| pLayoutProcessor->SetForceReLayout(TRUE); |
| } |