Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(66)

Side by Side Diff: xfa/fxfa/parser/xfa_document_datamerger_imp.cpp

Issue 2122373003: Cleanup xfa_document_datamerge files (Closed) Base URL: https://pdfium.googlesource.com/pdfium.git@master
Patch Set: Created 4 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright 2014 PDFium Authors. All rights reserved. 1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com 5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6 6
7 #include "xfa/fxfa/parser/xfa_document_datamerger_imp.h" 7 #include "xfa/fxfa/parser/xfa_document_datamerger_imp.h"
8 8
9 #include "core/fxcrt/include/fx_ext.h" 9 #include "core/fxcrt/include/fx_ext.h"
10 #include "xfa/fde/xml/fde_xml_imp.h" 10 #include "xfa/fde/xml/fde_xml_imp.h"
11 #include "xfa/fxfa/parser/cxfa_occur.h" 11 #include "xfa/fxfa/parser/cxfa_occur.h"
12 #include "xfa/fxfa/parser/xfa_basic_imp.h" 12 #include "xfa/fxfa/parser/xfa_basic_imp.h"
13 #include "xfa/fxfa/parser/xfa_doclayout.h" 13 #include "xfa/fxfa/parser/xfa_doclayout.h"
14 #include "xfa/fxfa/parser/xfa_document.h" 14 #include "xfa/fxfa/parser/xfa_document.h"
15 #include "xfa/fxfa/parser/xfa_document_datadescription_imp.h"
16 #include "xfa/fxfa/parser/xfa_document_layout_imp.h" 15 #include "xfa/fxfa/parser/xfa_document_layout_imp.h"
17 #include "xfa/fxfa/parser/xfa_localemgr.h" 16 #include "xfa/fxfa/parser/xfa_localemgr.h"
18 #include "xfa/fxfa/parser/xfa_object.h" 17 #include "xfa/fxfa/parser/xfa_object.h"
19 #include "xfa/fxfa/parser/xfa_parser.h" 18 #include "xfa/fxfa/parser/xfa_parser.h"
20 #include "xfa/fxfa/parser/xfa_parser_imp.h" 19 #include "xfa/fxfa/parser/xfa_parser_imp.h"
21 #include "xfa/fxfa/parser/xfa_script.h" 20 #include "xfa/fxfa/parser/xfa_script.h"
22 #include "xfa/fxfa/parser/xfa_script_imp.h" 21 #include "xfa/fxfa/parser/xfa_script_imp.h"
23 #include "xfa/fxfa/parser/xfa_utils.h" 22 #include "xfa/fxfa/parser/xfa_utils.h"
24 23
25 static FX_BOOL XFA_GetOccurInfo(CXFA_Node* pOccurNode, 24 namespace {
26 int32_t& iMin, 25
27 int32_t& iMax, 26 class CXFA_TraverseStrategy_DDGroup {
28 int32_t& iInit) { 27 public:
29 if (!pOccurNode) { 28 static inline CXFA_Node* GetFirstChild(CXFA_Node* pDDGroupNode) {
Lei Zhang 2016/07/07 19:23:42 Get rid of the inlines?
dsinclair 2016/07/07 19:36:16 Done.
29 return pDDGroupNode->GetFirstChildByName(XFA_HASHCODE_Group);
30 }
31 static inline CXFA_Node* GetNextSibling(CXFA_Node* pDDGroupNode) {
32 return pDDGroupNode->GetNextSameNameSibling(XFA_HASHCODE_Group);
33 }
34 static inline CXFA_Node* GetParent(CXFA_Node* pDDGroupNode) {
35 return pDDGroupNode->GetNodeItem(XFA_NODEITEM_Parent);
36 }
37 };
38
39 struct RecurseRecord {
40 CXFA_Node* pTemplateChild;
41 CXFA_Node* pDataChild;
42 };
43
44 FX_BOOL GetOccurInfo(CXFA_Node* pOccurNode,
45 int32_t& iMin,
46 int32_t& iMax,
47 int32_t& iInit) {
48 if (!pOccurNode)
30 return FALSE; 49 return FALSE;
31 } 50
32 CXFA_Occur occur(pOccurNode); 51 CXFA_Occur occur(pOccurNode);
33 return occur.GetOccurInfo(iMin, iMax, iInit); 52 return occur.GetOccurInfo(iMin, iMax, iInit);
34 } 53 }
35 struct XFA_DataMerge_RecurseRecord { 54
36 CXFA_Node* pTemplateChild; 55 CXFA_Node* FormValueNode_CreateChild(CXFA_Node* pValueNode, XFA_Element iType) {
37 CXFA_Node* pDataChild;
38 };
39 static CXFA_Node* XFA_DataMerge_FormValueNode_CreateChild(
40 CXFA_Node* pValueNode,
41 XFA_Element iType = XFA_Element::Unknown) {
42 CXFA_Node* pChildNode = pValueNode->GetNodeItem(XFA_NODEITEM_FirstChild); 56 CXFA_Node* pChildNode = pValueNode->GetNodeItem(XFA_NODEITEM_FirstChild);
43 if (!pChildNode) { 57 if (!pChildNode) {
44 if (iType == XFA_Element::Unknown) { 58 if (iType == XFA_Element::Unknown)
45 return FALSE; 59 return FALSE;
46 }
47 pChildNode = pValueNode->GetProperty(0, iType); 60 pChildNode = pValueNode->GetProperty(0, iType);
48 } 61 }
49 return pChildNode; 62 return pChildNode;
50 } 63 }
51 static void XFA_DataMerge_FormValueNode_MatchNoneCreateChild( 64
52 CXFA_Node* pFormNode) { 65 void FormValueNode_MatchNoneCreateChild(CXFA_Node* pFormNode) {
53 CXFA_WidgetData* pWidgetData = pFormNode->GetWidgetData(); 66 CXFA_WidgetData* pWidgetData = pFormNode->GetWidgetData();
54 ASSERT(pWidgetData); 67 ASSERT(pWidgetData);
55 pWidgetData->GetUIType(); 68 pWidgetData->GetUIType();
56 } 69 }
57 static FX_BOOL XFA_DataMerge_FormValueNode_SetChildContent( 70
71 FX_BOOL FormValueNode_SetChildContent(
58 CXFA_Node* pValueNode, 72 CXFA_Node* pValueNode,
59 const CFX_WideString& wsContent, 73 const CFX_WideString& wsContent,
60 XFA_Element iType = XFA_Element::Unknown) { 74 XFA_Element iType = XFA_Element::Unknown) {
61 if (!pValueNode) { 75 if (!pValueNode)
62 return FALSE; 76 return FALSE;
63 } 77
64 ASSERT(pValueNode->GetPacketID() == XFA_XDPPACKET_Form); 78 ASSERT(pValueNode->GetPacketID() == XFA_XDPPACKET_Form);
65 CXFA_Node* pChildNode = 79 CXFA_Node* pChildNode = FormValueNode_CreateChild(pValueNode, iType);
66 XFA_DataMerge_FormValueNode_CreateChild(pValueNode, iType);
67 if (!pChildNode) 80 if (!pChildNode)
68 return FALSE; 81 return FALSE;
69 82
70 switch (pChildNode->GetObjectType()) { 83 switch (pChildNode->GetObjectType()) {
71 case XFA_ObjectType::ContentNode: { 84 case XFA_ObjectType::ContentNode: {
72 CXFA_Node* pContentRawDataNode = 85 CXFA_Node* pContentRawDataNode =
73 pChildNode->GetNodeItem(XFA_NODEITEM_FirstChild); 86 pChildNode->GetNodeItem(XFA_NODEITEM_FirstChild);
74 if (!pContentRawDataNode) { 87 if (!pContentRawDataNode) {
75 XFA_Element element = XFA_Element::Sharptext; 88 XFA_Element element = XFA_Element::Sharptext;
76 if (pChildNode->GetElementType() == XFA_Element::ExData) { 89 if (pChildNode->GetElementType() == XFA_Element::ExData) {
77 CFX_WideString wsContentType; 90 CFX_WideString wsContentType;
78 pChildNode->GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, 91 pChildNode->GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType,
79 FALSE); 92 FALSE);
80 if (wsContentType == FX_WSTRC(L"text/html")) { 93 if (wsContentType == FX_WSTRC(L"text/html"))
81 element = XFA_Element::SharpxHTML; 94 element = XFA_Element::SharpxHTML;
82 } else if (wsContentType == FX_WSTRC(L"text/xml")) { 95 else if (wsContentType == FX_WSTRC(L"text/xml"))
83 element = XFA_Element::Sharpxml; 96 element = XFA_Element::Sharpxml;
84 }
85 } 97 }
86 pContentRawDataNode = pChildNode->CreateSamePacketNode(element); 98 pContentRawDataNode = pChildNode->CreateSamePacketNode(element);
87 pChildNode->InsertChild(pContentRawDataNode); 99 pChildNode->InsertChild(pContentRawDataNode);
88 } 100 }
89 pContentRawDataNode->SetCData(XFA_ATTRIBUTE_Value, wsContent); 101 pContentRawDataNode->SetCData(XFA_ATTRIBUTE_Value, wsContent);
90 } break; 102 break;
103 }
91 case XFA_ObjectType::NodeC: 104 case XFA_ObjectType::NodeC:
92 case XFA_ObjectType::TextNode: 105 case XFA_ObjectType::TextNode:
93 case XFA_ObjectType::NodeV: { 106 case XFA_ObjectType::NodeV: {
94 pChildNode->SetCData(XFA_ATTRIBUTE_Value, wsContent); 107 pChildNode->SetCData(XFA_ATTRIBUTE_Value, wsContent);
95 } break; 108 break;
109 }
96 default: 110 default:
97 ASSERT(FALSE); 111 ASSERT(FALSE);
98 break; 112 break;
99 } 113 }
100 return TRUE; 114 return TRUE;
101 } 115 }
102 static void XFA_DataMerge_CreateDataBinding(CXFA_Node* pFormNode, 116
103 CXFA_Node* pDataNode, 117 void CreateDataBinding(CXFA_Node* pFormNode,
104 FX_BOOL bDataToForm = TRUE) { 118 CXFA_Node* pDataNode,
119 FX_BOOL bDataToForm) {
105 pFormNode->SetObject(XFA_ATTRIBUTE_BindingNode, pDataNode); 120 pFormNode->SetObject(XFA_ATTRIBUTE_BindingNode, pDataNode);
106 pDataNode->AddBindItem(pFormNode); 121 pDataNode->AddBindItem(pFormNode);
107 XFA_Element eType = pFormNode->GetElementType(); 122 XFA_Element eType = pFormNode->GetElementType();
108 if (eType != XFA_Element::Field && eType != XFA_Element::ExclGroup) { 123 if (eType != XFA_Element::Field && eType != XFA_Element::ExclGroup)
109 return; 124 return;
110 } 125
111 CXFA_WidgetData* pWidgetData = pFormNode->GetWidgetData(); 126 CXFA_WidgetData* pWidgetData = pFormNode->GetWidgetData();
112 ASSERT(pWidgetData); 127 ASSERT(pWidgetData);
113 XFA_Element eUIType = pWidgetData->GetUIType(); 128 XFA_Element eUIType = pWidgetData->GetUIType();
114 CXFA_Value defValue(pFormNode->GetProperty(0, XFA_Element::Value)); 129 CXFA_Value defValue(pFormNode->GetProperty(0, XFA_Element::Value));
115 if (!bDataToForm) { 130 if (!bDataToForm) {
116 CFX_WideString wsValue; 131 CFX_WideString wsValue;
117 CFX_WideString wsFormatedValue; 132 CFX_WideString wsFormatedValue;
118 switch (eUIType) { 133 switch (eUIType) {
119 case XFA_Element::ImageEdit: { 134 case XFA_Element::ImageEdit: {
120 CXFA_Image image = defValue.GetImage(); 135 CXFA_Image image = defValue.GetImage();
121 CFX_WideString wsContentType; 136 CFX_WideString wsContentType;
122 CFX_WideString wsHref; 137 CFX_WideString wsHref;
123 if (image) { 138 if (image) {
124 image.GetContent(wsValue); 139 image.GetContent(wsValue);
125 image.GetContentType(wsContentType); 140 image.GetContentType(wsContentType);
126 image.GetHref(wsHref); 141 image.GetHref(wsHref);
127 } 142 }
128 CFDE_XMLElement* pXMLDataElement = 143 CFDE_XMLElement* pXMLDataElement =
129 static_cast<CFDE_XMLElement*>(pDataNode->GetXMLMappingNode()); 144 static_cast<CFDE_XMLElement*>(pDataNode->GetXMLMappingNode());
130 ASSERT(pXMLDataElement); 145 ASSERT(pXMLDataElement);
131 pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue); 146 pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue);
132 pDataNode->SetAttributeValue(wsValue, wsFormatedValue); 147 pDataNode->SetAttributeValue(wsValue, wsFormatedValue);
133 pDataNode->SetCData(XFA_ATTRIBUTE_ContentType, wsContentType); 148 pDataNode->SetCData(XFA_ATTRIBUTE_ContentType, wsContentType);
134 if (!wsHref.IsEmpty()) { 149 if (!wsHref.IsEmpty())
135 pXMLDataElement->SetString(L"href", wsHref); 150 pXMLDataElement->SetString(L"href", wsHref);
136 } 151
137 } break; 152 break;
153 }
138 case XFA_Element::ChoiceList: 154 case XFA_Element::ChoiceList:
139 defValue.GetChildValueContent(wsValue); 155 defValue.GetChildValueContent(wsValue);
140 if (pWidgetData->GetChoiceListOpen() == XFA_ATTRIBUTEENUM_MultiSelect) { 156 if (pWidgetData->GetChoiceListOpen() == XFA_ATTRIBUTEENUM_MultiSelect) {
141 CFX_WideStringArray wsSelTextArray; 157 CFX_WideStringArray wsSelTextArray;
142 pWidgetData->GetSelectedItemsValue(wsSelTextArray); 158 pWidgetData->GetSelectedItemsValue(wsSelTextArray);
143 int32_t iSize = wsSelTextArray.GetSize(); 159 int32_t iSize = wsSelTextArray.GetSize();
144 if (iSize >= 1) { 160 if (iSize >= 1) {
145 CXFA_Node* pValue = nullptr; 161 CXFA_Node* pValue = nullptr;
146 for (int32_t i = 0; i < iSize; i++) { 162 for (int32_t i = 0; i < iSize; i++) {
147 pValue = pDataNode->CreateSamePacketNode(XFA_Element::DataValue); 163 pValue = pDataNode->CreateSamePacketNode(XFA_Element::DataValue);
148 pValue->SetCData(XFA_ATTRIBUTE_Name, L"value"); 164 pValue->SetCData(XFA_ATTRIBUTE_Name, L"value");
149 pValue->CreateXMLMappingNode(); 165 pValue->CreateXMLMappingNode();
150 pDataNode->InsertChild(pValue); 166 pDataNode->InsertChild(pValue);
151 pValue->SetCData(XFA_ATTRIBUTE_Value, wsSelTextArray[i]); 167 pValue->SetCData(XFA_ATTRIBUTE_Value, wsSelTextArray[i]);
152 } 168 }
153 } else { 169 } else {
154 CFDE_XMLNode* pXMLNode = pDataNode->GetXMLMappingNode(); 170 CFDE_XMLNode* pXMLNode = pDataNode->GetXMLMappingNode();
155 ASSERT(pXMLNode->GetType() == FDE_XMLNODE_Element); 171 ASSERT(pXMLNode->GetType() == FDE_XMLNODE_Element);
156 static_cast<CFDE_XMLElement*>(pXMLNode)->SetString(L"xfa:dataNode", 172 static_cast<CFDE_XMLElement*>(pXMLNode)->SetString(L"xfa:dataNode",
157 L"dataGroup"); 173 L"dataGroup");
158 } 174 }
159 } else if (!wsValue.IsEmpty()) { 175 } else if (!wsValue.IsEmpty()) {
160 pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue); 176 pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue);
161 pDataNode->SetAttributeValue(wsValue, wsFormatedValue); 177 pDataNode->SetAttributeValue(wsValue, wsFormatedValue);
162 } 178 }
163 break; 179 break;
164 case XFA_Element::CheckButton: 180 case XFA_Element::CheckButton:
165 defValue.GetChildValueContent(wsValue); 181 defValue.GetChildValueContent(wsValue);
166 if (wsValue.IsEmpty()) { 182 if (wsValue.IsEmpty())
167 break; 183 break;
168 } 184
169 pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue); 185 pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue);
170 pDataNode->SetAttributeValue(wsValue, wsFormatedValue); 186 pDataNode->SetAttributeValue(wsValue, wsFormatedValue);
171 break; 187 break;
172 case XFA_Element::ExclGroup: { 188 case XFA_Element::ExclGroup: {
173 CXFA_Node* pChecked = nullptr; 189 CXFA_Node* pChecked = nullptr;
174 CXFA_Node* pChild = pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild); 190 CXFA_Node* pChild = pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild);
175 for (; pChild; pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) { 191 for (; pChild; pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
176 if (pChild->GetElementType() != XFA_Element::Field) { 192 if (pChild->GetElementType() != XFA_Element::Field)
177 continue; 193 continue;
178 } 194
179 CXFA_Node* pValue = pChild->GetChild(0, XFA_Element::Value); 195 CXFA_Node* pValue = pChild->GetChild(0, XFA_Element::Value);
180 if (!pValue) { 196 if (!pValue)
181 continue; 197 continue;
182 } 198
183 CXFA_Value valueChild(pValue); 199 CXFA_Value valueChild(pValue);
184 valueChild.GetChildValueContent(wsValue); 200 valueChild.GetChildValueContent(wsValue);
185 if (wsValue.IsEmpty()) { 201 if (wsValue.IsEmpty())
186 continue; 202 continue;
187 } 203
188 CXFA_Node* pItems = pChild->GetChild(0, XFA_Element::Items); 204 CXFA_Node* pItems = pChild->GetChild(0, XFA_Element::Items);
189 if (!pItems) { 205 if (!pItems)
190 continue; 206 continue;
191 } 207
192 CXFA_Node* pText = pItems->GetNodeItem(XFA_NODEITEM_FirstChild); 208 CXFA_Node* pText = pItems->GetNodeItem(XFA_NODEITEM_FirstChild);
193 if (!pText) { 209 if (!pText)
194 continue; 210 continue;
195 } 211
196 CFX_WideString wsContent; 212 CFX_WideString wsContent;
197 if (pText->TryContent(wsContent) && (wsContent == wsValue)) { 213 if (pText->TryContent(wsContent) && (wsContent == wsValue)) {
198 pChecked = pChild; 214 pChecked = pChild;
199 wsFormatedValue = wsValue; 215 wsFormatedValue = wsValue;
200 pDataNode->SetAttributeValue(wsValue, wsFormatedValue); 216 pDataNode->SetAttributeValue(wsValue, wsFormatedValue);
201 pFormNode->SetCData(XFA_ATTRIBUTE_Value, wsContent); 217 pFormNode->SetCData(XFA_ATTRIBUTE_Value, wsContent);
202 break; 218 break;
203 } 219 }
204 } 220 }
205 if (!pChecked) { 221 if (!pChecked)
206 break; 222 break;
207 } 223
208 pChild = pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild); 224 pChild = pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild);
209 for (; pChild; pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) { 225 for (; pChild; pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
210 if (pChild == pChecked) { 226 if (pChild == pChecked)
211 continue; 227 continue;
212 } 228 if (pChild->GetElementType() != XFA_Element::Field)
213 if (pChild->GetElementType() != XFA_Element::Field) {
214 continue; 229 continue;
215 } 230
216 CXFA_Node* pValue = pChild->GetProperty(0, XFA_Element::Value); 231 CXFA_Node* pValue = pChild->GetProperty(0, XFA_Element::Value);
217 CXFA_Node* pItems = pChild->GetChild(0, XFA_Element::Items); 232 CXFA_Node* pItems = pChild->GetChild(0, XFA_Element::Items);
218 CXFA_Node* pText = 233 CXFA_Node* pText =
219 pItems ? pItems->GetNodeItem(XFA_NODEITEM_FirstChild) : nullptr; 234 pItems ? pItems->GetNodeItem(XFA_NODEITEM_FirstChild) : nullptr;
220 if (pText) { 235 if (pText)
221 pText = pText->GetNodeItem(XFA_NODEITEM_NextSibling); 236 pText = pText->GetNodeItem(XFA_NODEITEM_NextSibling);
222 } 237
223 CFX_WideString wsContent; 238 CFX_WideString wsContent;
224 if (pText) { 239 if (pText)
225 pText->TryContent(wsContent); 240 pText->TryContent(wsContent);
226 } 241
227 XFA_DataMerge_FormValueNode_SetChildContent(pValue, wsContent, 242 FormValueNode_SetChildContent(pValue, wsContent, XFA_Element::Text);
228 XFA_Element::Text);
229 } 243 }
230 } break; 244 break;
245 }
231 case XFA_Element::NumericEdit: { 246 case XFA_Element::NumericEdit: {
232 defValue.GetChildValueContent(wsValue); 247 defValue.GetChildValueContent(wsValue);
233 if (wsValue.IsEmpty()) { 248 if (wsValue.IsEmpty())
234 break; 249 break;
235 } 250
236 CFX_WideString wsOutput; 251 CFX_WideString wsOutput;
237 pWidgetData->NormalizeNumStr(wsValue, wsOutput); 252 pWidgetData->NormalizeNumStr(wsValue, wsOutput);
238 wsValue = wsOutput; 253 wsValue = wsOutput;
239 pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue); 254 pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue);
240 pDataNode->SetAttributeValue(wsValue, wsFormatedValue); 255 pDataNode->SetAttributeValue(wsValue, wsFormatedValue);
241 CXFA_Node* pValue = pFormNode->GetProperty(0, XFA_Element::Value); 256 CXFA_Node* pValue = pFormNode->GetProperty(0, XFA_Element::Value);
242 XFA_DataMerge_FormValueNode_SetChildContent(pValue, wsValue, 257 FormValueNode_SetChildContent(pValue, wsValue, XFA_Element::Float);
243 XFA_Element::Float); 258 break;
244 } break; 259 }
245 default: 260 default:
246 defValue.GetChildValueContent(wsValue); 261 defValue.GetChildValueContent(wsValue);
247 if (wsValue.IsEmpty()) { 262 if (wsValue.IsEmpty())
248 break; 263 break;
249 } 264
250 pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue); 265 pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue);
251 pDataNode->SetAttributeValue(wsValue, wsFormatedValue); 266 pDataNode->SetAttributeValue(wsValue, wsFormatedValue);
252 break; 267 break;
253 } 268 }
254 } else { 269 return;
255 CFX_WideString wsXMLValue; 270 }
256 pDataNode->TryContent(wsXMLValue); 271
257 CFX_WideString wsNormailizeValue; 272 CFX_WideString wsXMLValue;
258 pWidgetData->GetNormalizeDataValue(wsXMLValue, wsNormailizeValue); 273 pDataNode->TryContent(wsXMLValue);
259 pDataNode->SetAttributeValue(wsNormailizeValue, wsXMLValue); 274 CFX_WideString wsNormailizeValue;
Lei Zhang 2016/07/07 19:23:42 existing typo
dsinclair 2016/07/07 19:36:16 Done.
260 switch (eUIType) { 275 pWidgetData->GetNormalizeDataValue(wsXMLValue, wsNormailizeValue);
261 case XFA_Element::ImageEdit: { 276 pDataNode->SetAttributeValue(wsNormailizeValue, wsXMLValue);
262 XFA_DataMerge_FormValueNode_SetChildContent( 277 switch (eUIType) {
263 defValue.GetNode(), wsNormailizeValue, XFA_Element::Image); 278 case XFA_Element::ImageEdit: {
264 CXFA_Image image = defValue.GetImage(); 279 FormValueNode_SetChildContent(defValue.GetNode(), wsNormailizeValue,
265 if (image) { 280 XFA_Element::Image);
266 CFDE_XMLElement* pXMLDataElement = 281 CXFA_Image image = defValue.GetImage();
267 static_cast<CFDE_XMLElement*>(pDataNode->GetXMLMappingNode()); 282 if (image) {
268 ASSERT(pXMLDataElement); 283 CFDE_XMLElement* pXMLDataElement =
269 CFX_WideString wsContentType; 284 static_cast<CFDE_XMLElement*>(pDataNode->GetXMLMappingNode());
270 CFX_WideString wsHref; 285 ASSERT(pXMLDataElement);
271 pXMLDataElement->GetString(L"xfa:contentType", wsContentType); 286 CFX_WideString wsContentType;
272 if (!wsContentType.IsEmpty()) { 287 CFX_WideString wsHref;
273 pDataNode->SetCData(XFA_ATTRIBUTE_ContentType, wsContentType); 288 pXMLDataElement->GetString(L"xfa:contentType", wsContentType);
274 image.SetContentType(wsContentType); 289 if (!wsContentType.IsEmpty()) {
290 pDataNode->SetCData(XFA_ATTRIBUTE_ContentType, wsContentType);
291 image.SetContentType(wsContentType);
292 }
293 pXMLDataElement->GetString(L"href", wsHref);
294 if (!wsHref.IsEmpty())
295 image.SetHref(wsHref);
296 }
297 break;
298 }
299 case XFA_Element::ChoiceList:
300 if (pWidgetData->GetChoiceListOpen() == XFA_ATTRIBUTEENUM_MultiSelect) {
301 CXFA_NodeArray items;
302 pDataNode->GetNodeList(items);
303 int32_t iCounts = items.GetSize();
304 if (iCounts > 0) {
305 wsNormailizeValue.clear();
306 CFX_WideString wsItem;
307 for (int32_t i = 0; i < iCounts; i++) {
308 items[i]->TryContent(wsItem);
309 wsItem = (iCounts == 1) ? wsItem : wsItem + FX_WSTRC(L"\n");
310 wsNormailizeValue += wsItem;
275 } 311 }
276 pXMLDataElement->GetString(L"href", wsHref); 312 CXFA_ExData exData = defValue.GetExData();
277 if (!wsHref.IsEmpty()) { 313 ASSERT(exData);
278 image.SetHref(wsHref); 314 exData.SetContentType(iCounts == 1 ? L"text/plain" : L"text/xml");
279 }
280 } 315 }
281 } break; 316 FormValueNode_SetChildContent(defValue.GetNode(), wsNormailizeValue,
282 case XFA_Element::ChoiceList: 317 XFA_Element::ExData);
283 if (pWidgetData->GetChoiceListOpen() == XFA_ATTRIBUTEENUM_MultiSelect) { 318 } else {
284 CXFA_NodeArray items; 319 FormValueNode_SetChildContent(defValue.GetNode(), wsNormailizeValue,
285 pDataNode->GetNodeList(items); 320 XFA_Element::Text);
286 int32_t iCounts = items.GetSize(); 321 }
287 if (iCounts > 0) { 322 break;
288 wsNormailizeValue.clear(); 323 case XFA_Element::CheckButton:
289 CFX_WideString wsItem; 324 FormValueNode_SetChildContent(defValue.GetNode(), wsNormailizeValue,
290 for (int32_t i = 0; i < iCounts; i++) { 325 XFA_Element::Text);
291 items[i]->TryContent(wsItem); 326 break;
292 wsItem = (iCounts == 1) ? wsItem : wsItem + FX_WSTRC(L"\n"); 327 case XFA_Element::ExclGroup: {
293 wsNormailizeValue += wsItem; 328 pWidgetData->SetSelectedMemberByValue(wsNormailizeValue.AsStringC(),
294 } 329 false, FALSE, FALSE);
295 CXFA_ExData exData = defValue.GetExData(); 330 break;
296 ASSERT(exData);
297 exData.SetContentType(iCounts == 1 ? L"text/plain" : L"text/xml");
298 }
299 XFA_DataMerge_FormValueNode_SetChildContent(
300 defValue.GetNode(), wsNormailizeValue, XFA_Element::ExData);
301 } else {
302 XFA_DataMerge_FormValueNode_SetChildContent(
303 defValue.GetNode(), wsNormailizeValue, XFA_Element::Text);
304 }
305 break;
306 case XFA_Element::CheckButton:
307 XFA_DataMerge_FormValueNode_SetChildContent(
308 defValue.GetNode(), wsNormailizeValue, XFA_Element::Text);
309 break;
310 case XFA_Element::ExclGroup: {
311 pWidgetData->SetSelectedMemberByValue(wsNormailizeValue.AsStringC(),
312 false, FALSE, FALSE);
313 } break;
314 case XFA_Element::DateTimeEdit:
315 XFA_DataMerge_FormValueNode_SetChildContent(
316 defValue.GetNode(), wsNormailizeValue, XFA_Element::DateTime);
317 break;
318 case XFA_Element::NumericEdit: {
319 CFX_WideString wsPicture;
320 pWidgetData->GetPictureContent(wsPicture, XFA_VALUEPICTURE_DataBind);
321 if (wsPicture.IsEmpty()) {
322 CFX_WideString wsOutput;
323 pWidgetData->NormalizeNumStr(wsNormailizeValue, wsOutput);
324 wsNormailizeValue = wsOutput;
325 }
326 XFA_DataMerge_FormValueNode_SetChildContent(
327 defValue.GetNode(), wsNormailizeValue, XFA_Element::Float);
328 } break;
329 case XFA_Element::Barcode:
330 case XFA_Element::Button:
331 case XFA_Element::PasswordEdit:
332 case XFA_Element::Signature:
333 case XFA_Element::TextEdit:
334 default:
335 XFA_DataMerge_FormValueNode_SetChildContent(
336 defValue.GetNode(), wsNormailizeValue, XFA_Element::Text);
337 break;
338 } 331 }
332 case XFA_Element::DateTimeEdit:
333 FormValueNode_SetChildContent(defValue.GetNode(), wsNormailizeValue,
334 XFA_Element::DateTime);
335 break;
336 case XFA_Element::NumericEdit: {
337 CFX_WideString wsPicture;
338 pWidgetData->GetPictureContent(wsPicture, XFA_VALUEPICTURE_DataBind);
339 if (wsPicture.IsEmpty()) {
340 CFX_WideString wsOutput;
341 pWidgetData->NormalizeNumStr(wsNormailizeValue, wsOutput);
342 wsNormailizeValue = wsOutput;
343 }
344 FormValueNode_SetChildContent(defValue.GetNode(), wsNormailizeValue,
345 XFA_Element::Float);
346 break;
347 }
348 case XFA_Element::Barcode:
349 case XFA_Element::Button:
350 case XFA_Element::PasswordEdit:
351 case XFA_Element::Signature:
352 case XFA_Element::TextEdit:
353 default:
354 FormValueNode_SetChildContent(defValue.GetNode(), wsNormailizeValue,
355 XFA_Element::Text);
356 break;
339 } 357 }
340 } 358 }
341 static CXFA_Node* XFA_DataMerge_GetGlobalBinding(CXFA_Document* pDocument, 359
342 uint32_t dwNameHash) { 360 CXFA_Node* GetGlobalBinding(CXFA_Document* pDocument, uint32_t dwNameHash) {
343 CXFA_Node* pNode = nullptr; 361 CXFA_Node* pNode = nullptr;
344 pDocument->m_rgGlobalBinding.Lookup(dwNameHash, pNode); 362 pDocument->m_rgGlobalBinding.Lookup(dwNameHash, pNode);
345 return pNode; 363 return pNode;
346 } 364 }
347 static void XFA_DataMerge_RegisterGlobalBinding(CXFA_Document* pDocument, 365
348 uint32_t dwNameHash, 366 void RegisterGlobalBinding(CXFA_Document* pDocument,
349 CXFA_Node* pDataNode) { 367 uint32_t dwNameHash,
368 CXFA_Node* pDataNode) {
350 pDocument->m_rgGlobalBinding.SetAt(dwNameHash, pDataNode); 369 pDocument->m_rgGlobalBinding.SetAt(dwNameHash, pDataNode);
351 } 370 }
352 static void XFA_DataMerge_ClearGlobalBinding(CXFA_Document* pDocument) { 371
353 pDocument->m_rgGlobalBinding.RemoveAll(); 372 CXFA_Node* ScopeMatchGlobalBinding(CXFA_Node* pDataScope,
354 } 373 uint32_t dwNameHash,
355 static CXFA_Node* XFA_DataMerge_ScopeMatchGlobalBinding( 374 XFA_Element eMatchDataNodeType,
356 CXFA_Node* pDataScope, 375 FX_BOOL bUpLevel) {
357 uint32_t dwNameHash,
358 XFA_Element eMatchDataNodeType,
359 FX_BOOL bUpLevel = TRUE) {
360 for (CXFA_Node *pCurDataScope = pDataScope, *pLastDataScope = nullptr; 376 for (CXFA_Node *pCurDataScope = pDataScope, *pLastDataScope = nullptr;
361 pCurDataScope && pCurDataScope->GetPacketID() == XFA_XDPPACKET_Datasets; 377 pCurDataScope && pCurDataScope->GetPacketID() == XFA_XDPPACKET_Datasets;
362 pLastDataScope = pCurDataScope, 378 pLastDataScope = pCurDataScope,
363 pCurDataScope = 379 pCurDataScope =
364 pCurDataScope->GetNodeItem(XFA_NODEITEM_Parent)) { 380 pCurDataScope->GetNodeItem(XFA_NODEITEM_Parent)) {
365 for (CXFA_Node* pDataChild = pCurDataScope->GetFirstChildByName(dwNameHash); 381 for (CXFA_Node* pDataChild = pCurDataScope->GetFirstChildByName(dwNameHash);
366 pDataChild; 382 pDataChild;
367 pDataChild = pDataChild->GetNextSameNameSibling(dwNameHash)) { 383 pDataChild = pDataChild->GetNextSameNameSibling(dwNameHash)) {
368 if (pDataChild == pLastDataScope || 384 if (pDataChild == pLastDataScope ||
369 (eMatchDataNodeType != XFA_Element::DataModel && 385 (eMatchDataNodeType != XFA_Element::DataModel &&
370 pDataChild->GetElementType() != eMatchDataNodeType) || 386 pDataChild->GetElementType() != eMatchDataNodeType) ||
371 pDataChild->HasBindItem()) { 387 pDataChild->HasBindItem()) {
372 continue; 388 continue;
373 } 389 }
374 return pDataChild; 390 return pDataChild;
375 } 391 }
392
376 for (CXFA_Node* pDataChild = 393 for (CXFA_Node* pDataChild =
377 pCurDataScope->GetFirstChildByClass(XFA_Element::DataGroup); 394 pCurDataScope->GetFirstChildByClass(XFA_Element::DataGroup);
378 pDataChild; pDataChild = pDataChild->GetNextSameClassSibling( 395 pDataChild; pDataChild = pDataChild->GetNextSameClassSibling(
379 XFA_Element::DataGroup)) { 396 XFA_Element::DataGroup)) {
380 CXFA_Node* pDataNode = XFA_DataMerge_ScopeMatchGlobalBinding( 397 CXFA_Node* pDataNode = ScopeMatchGlobalBinding(pDataChild, dwNameHash,
381 pDataChild, dwNameHash, eMatchDataNodeType, FALSE); 398 eMatchDataNodeType, FALSE);
382 if (pDataNode) { 399 if (pDataNode)
383 return pDataNode; 400 return pDataNode;
384 }
385 } 401 }
386 if (!bUpLevel) { 402 if (!bUpLevel)
387 break; 403 break;
388 }
389 } 404 }
390 return nullptr; 405 return nullptr;
391 } 406 }
392 static CXFA_Node* XFA_DataMerge_FindGlobalDataNode(CXFA_Document* pDocument, 407
393 CFX_WideStringC wsName, 408 CXFA_Node* FindGlobalDataNode(CXFA_Document* pDocument,
394 CXFA_Node* pDataScope, 409 CFX_WideStringC wsName,
395 XFA_Element eMatchNodeType) { 410 CXFA_Node* pDataScope,
411 XFA_Element eMatchNodeType) {
396 if (wsName.IsEmpty()) 412 if (wsName.IsEmpty())
397 return nullptr; 413 return nullptr;
398 414
399 uint32_t dwNameHash = FX_HashCode_GetW(wsName, false); 415 uint32_t dwNameHash = FX_HashCode_GetW(wsName, false);
400 CXFA_Node* pBounded = XFA_DataMerge_GetGlobalBinding(pDocument, dwNameHash); 416 CXFA_Node* pBounded = GetGlobalBinding(pDocument, dwNameHash);
401 if (!pBounded) { 417 if (!pBounded) {
402 pBounded = XFA_DataMerge_ScopeMatchGlobalBinding(pDataScope, dwNameHash, 418 pBounded =
403 eMatchNodeType); 419 ScopeMatchGlobalBinding(pDataScope, dwNameHash, eMatchNodeType, TRUE);
404 if (pBounded) { 420 if (pBounded)
405 XFA_DataMerge_RegisterGlobalBinding(pDocument, dwNameHash, pBounded); 421 RegisterGlobalBinding(pDocument, dwNameHash, pBounded);
406 }
407 } 422 }
408 return pBounded; 423 return pBounded;
409 } 424 }
410 425
411 static CXFA_Node* XFA_DataMerge_FindOnceDataNode(CXFA_Document* pDocument, 426 CXFA_Node* FindOnceDataNode(CXFA_Document* pDocument,
412 CFX_WideStringC wsName, 427 CFX_WideStringC wsName,
413 CXFA_Node* pDataScope, 428 CXFA_Node* pDataScope,
414 XFA_Element eMatchNodeType) { 429 XFA_Element eMatchNodeType) {
415 if (wsName.IsEmpty()) 430 if (wsName.IsEmpty())
416 return nullptr; 431 return nullptr;
417 432
418 uint32_t dwNameHash = FX_HashCode_GetW(wsName, false); 433 uint32_t dwNameHash = FX_HashCode_GetW(wsName, false);
419 CXFA_Node* pLastDataScope = nullptr; 434 CXFA_Node* pLastDataScope = nullptr;
420 for (CXFA_Node* pCurDataScope = pDataScope; 435 for (CXFA_Node* pCurDataScope = pDataScope;
421 pCurDataScope && pCurDataScope->GetPacketID() == XFA_XDPPACKET_Datasets; 436 pCurDataScope && pCurDataScope->GetPacketID() == XFA_XDPPACKET_Datasets;
422 pCurDataScope = pCurDataScope->GetNodeItem(XFA_NODEITEM_Parent)) { 437 pCurDataScope = pCurDataScope->GetNodeItem(XFA_NODEITEM_Parent)) {
423 for (CXFA_Node* pDataChild = pCurDataScope->GetFirstChildByName(dwNameHash); 438 for (CXFA_Node* pDataChild = pCurDataScope->GetFirstChildByName(dwNameHash);
424 pDataChild; 439 pDataChild;
425 pDataChild = pDataChild->GetNextSameNameSibling(dwNameHash)) { 440 pDataChild = pDataChild->GetNextSameNameSibling(dwNameHash)) {
426 if (pDataChild == pLastDataScope || pDataChild->HasBindItem() || 441 if (pDataChild == pLastDataScope || pDataChild->HasBindItem() ||
427 (eMatchNodeType != XFA_Element::DataModel && 442 (eMatchNodeType != XFA_Element::DataModel &&
428 pDataChild->GetElementType() != eMatchNodeType)) { 443 pDataChild->GetElementType() != eMatchNodeType)) {
429 continue; 444 continue;
430 } 445 }
431 return pDataChild; 446 return pDataChild;
432 } 447 }
433 pLastDataScope = pCurDataScope; 448 pLastDataScope = pCurDataScope;
434 } 449 }
435 return nullptr; 450 return nullptr;
436 } 451 }
437 452
438 static CXFA_Node* XFA_DataMerge_FindDataRefDataNode(CXFA_Document* pDocument, 453 CXFA_Node* FindDataRefDataNode(CXFA_Document* pDocument,
439 CFX_WideStringC wsRef, 454 CFX_WideStringC wsRef,
440 CXFA_Node* pDataScope, 455 CXFA_Node* pDataScope,
441 XFA_Element eMatchNodeType, 456 XFA_Element eMatchNodeType,
442 CXFA_Node* pTemplateNode, 457 CXFA_Node* pTemplateNode,
443 FX_BOOL bForceBind, 458 FX_BOOL bForceBind,
444 FX_BOOL bUpLevel = TRUE) { 459 FX_BOOL bUpLevel) {
445 uint32_t dFlags = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_BindNew; 460 uint32_t dFlags = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_BindNew;
446 if (bUpLevel || wsRef != FX_WSTRC(L"name")) { 461 if (bUpLevel || wsRef != FX_WSTRC(L"name"))
447 dFlags |= (XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings); 462 dFlags |= (XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings);
448 } 463
449 XFA_RESOLVENODE_RS rs; 464 XFA_RESOLVENODE_RS rs;
450 pDocument->GetScriptContext()->ResolveObjects(pDataScope, wsRef, rs, dFlags, 465 pDocument->GetScriptContext()->ResolveObjects(pDataScope, wsRef, rs, dFlags,
451 pTemplateNode); 466 pTemplateNode);
452 if (rs.dwFlags == XFA_RESOLVENODE_RSTYPE_CreateNodeAll || 467 if (rs.dwFlags == XFA_RESOLVENODE_RSTYPE_CreateNodeAll ||
453 rs.dwFlags == XFA_RESOLVENODE_RSTYPE_CreateNodeMidAll || 468 rs.dwFlags == XFA_RESOLVENODE_RSTYPE_CreateNodeMidAll ||
454 rs.nodes.GetSize() > 1) { 469 rs.nodes.GetSize() > 1) {
455 return pDocument->GetNotBindNode(rs.nodes); 470 return pDocument->GetNotBindNode(rs.nodes);
456 } 471 }
472
457 if (rs.dwFlags == XFA_RESOLVENODE_RSTYPE_CreateNodeOne) { 473 if (rs.dwFlags == XFA_RESOLVENODE_RSTYPE_CreateNodeOne) {
458 CXFA_Object* pObject = (rs.nodes.GetSize() > 0) ? rs.nodes[0] : nullptr; 474 CXFA_Object* pObject = (rs.nodes.GetSize() > 0) ? rs.nodes[0] : nullptr;
459 CXFA_Node* pNode = ToNode(pObject); 475 CXFA_Node* pNode = ToNode(pObject);
460 if (!bForceBind && pNode && pNode->HasBindItem()) { 476 if (!bForceBind && pNode && pNode->HasBindItem())
Lei Zhang 2016/07/07 19:23:42 return (!bForceBind && pNode && pNode->HasBindItem
dsinclair 2016/07/07 19:36:16 Done, had to flip the logic around.
461 pNode = nullptr; 477 pNode = nullptr;
462 }
463 return pNode; 478 return pNode;
464 } 479 }
465 return nullptr; 480 return nullptr;
466 } 481 }
467 CXFA_Node* XFA_DataMerge_FindFormDOMInstance(CXFA_Document* pDocument, 482
468 XFA_Element eType, 483 FX_BOOL NeedGenerateForm(CXFA_Node* pTemplateChild,
469 uint32_t dwNameHash, 484 FX_BOOL bUseInstanceManager) {
470 CXFA_Node* pFormParent) {
471 CXFA_Node* pFormChild = pFormParent->GetNodeItem(XFA_NODEITEM_FirstChild);
472 for (; pFormChild;
473 pFormChild = pFormChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
474 if (pFormChild->GetElementType() == eType &&
475 pFormChild->GetNameHash() == dwNameHash && pFormChild->IsUnusedNode()) {
476 return pFormChild;
477 }
478 }
479 return nullptr;
480 }
481 static FX_BOOL XFA_NeedGenerateForm(CXFA_Node* pTemplateChild,
482 FX_BOOL bUseInstanceManager = TRUE) {
483 XFA_Element eType = pTemplateChild->GetElementType(); 485 XFA_Element eType = pTemplateChild->GetElementType();
484 if (eType == XFA_Element::Variables) { 486 if (eType == XFA_Element::Variables)
485 return TRUE; 487 return TRUE;
486 } 488 if (pTemplateChild->IsContainerNode())
487 if (pTemplateChild->IsContainerNode()) {
488 return FALSE; 489 return FALSE;
489 }
490 if (eType == XFA_Element::Proto || 490 if (eType == XFA_Element::Proto ||
491 (bUseInstanceManager && eType == XFA_Element::Occur)) { 491 (bUseInstanceManager && eType == XFA_Element::Occur)) {
492 return FALSE; 492 return FALSE;
493 } 493 }
494 return TRUE; 494 return TRUE;
495 } 495 }
496 CXFA_Node* XFA_NodeMerge_CloneOrMergeContainer(CXFA_Document* pDocument, 496
497 CXFA_Node* pFormParent, 497 CXFA_Node* CloneOrMergeInstanceManager(CXFA_Document* pDocument,
498 CXFA_Node* pTemplateNode, 498 CXFA_Node* pFormParent,
499 FX_BOOL bRecursive, 499 CXFA_Node* pTemplateNode,
500 CXFA_NodeArray* pSubformArray) { 500 CXFA_NodeArray& subforms) {
501 CXFA_Node* pExistingNode = nullptr;
502 if (!pSubformArray) {
503 pExistingNode = XFA_DataMerge_FindFormDOMInstance(
504 pDocument, pTemplateNode->GetElementType(),
505 pTemplateNode->GetNameHash(), pFormParent);
506 } else if (pSubformArray->GetSize() > 0) {
507 pExistingNode = pSubformArray->GetAt(0);
508 pSubformArray->RemoveAt(0);
509 }
510 if (pExistingNode) {
511 if (pSubformArray) {
512 pFormParent->InsertChild(pExistingNode);
513 } else if (pExistingNode->IsContainerNode()) {
514 pFormParent->RemoveChild(pExistingNode);
515 pFormParent->InsertChild(pExistingNode);
516 }
517 pExistingNode->ClearFlag(XFA_NodeFlag_UnusedNode);
518 pExistingNode->SetTemplateNode(pTemplateNode);
519 if (bRecursive && pExistingNode->GetElementType() != XFA_Element::Items) {
520 for (CXFA_Node* pTemplateChild =
521 pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
522 pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
523 XFA_NODEITEM_NextSibling)) {
524 if (XFA_NeedGenerateForm(pTemplateChild)) {
525 XFA_NodeMerge_CloneOrMergeContainer(pDocument, pExistingNode,
526 pTemplateChild, bRecursive);
527 }
528 }
529 }
530 pExistingNode->SetFlag(XFA_NodeFlag_Initialized, true);
531 return pExistingNode;
532 }
533 CXFA_Node* pNewNode = pTemplateNode->CloneTemplateToForm(FALSE);
534 pFormParent->InsertChild(pNewNode, nullptr);
535 if (bRecursive) {
536 for (CXFA_Node* pTemplateChild =
537 pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
538 pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
539 XFA_NODEITEM_NextSibling)) {
540 if (XFA_NeedGenerateForm(pTemplateChild)) {
541 CXFA_Node* pNewChild = pTemplateChild->CloneTemplateToForm(TRUE);
542 pNewNode->InsertChild(pNewChild, nullptr);
543 }
544 }
545 }
546 return pNewNode;
547 }
548 static CXFA_Node* XFA_NodeMerge_CloneOrMergeInstanceManager(
549 CXFA_Document* pDocument,
550 CXFA_Node* pFormParent,
551 CXFA_Node* pTemplateNode,
552 CXFA_NodeArray& subforms) {
553 CFX_WideStringC wsSubformName = pTemplateNode->GetCData(XFA_ATTRIBUTE_Name); 501 CFX_WideStringC wsSubformName = pTemplateNode->GetCData(XFA_ATTRIBUTE_Name);
554 CFX_WideString wsInstMgrNodeName = FX_WSTRC(L"_") + wsSubformName; 502 CFX_WideString wsInstMgrNodeName = FX_WSTRC(L"_") + wsSubformName;
555 uint32_t dwInstNameHash = 503 uint32_t dwInstNameHash =
556 FX_HashCode_GetW(wsInstMgrNodeName.AsStringC(), false); 504 FX_HashCode_GetW(wsInstMgrNodeName.AsStringC(), false);
557 CXFA_Node* pExistingNode = XFA_DataMerge_FindFormDOMInstance( 505 CXFA_Node* pExistingNode = XFA_DataMerge_FindFormDOMInstance(
558 pDocument, XFA_Element::InstanceManager, dwInstNameHash, pFormParent); 506 pDocument, XFA_Element::InstanceManager, dwInstNameHash, pFormParent);
559 if (pExistingNode) { 507 if (pExistingNode) {
560 uint32_t dwNameHash = pTemplateNode->GetNameHash(); 508 uint32_t dwNameHash = pTemplateNode->GetNameHash();
561 for (CXFA_Node* pNode = 509 for (CXFA_Node* pNode =
562 pExistingNode->GetNodeItem(XFA_NODEITEM_NextSibling); 510 pExistingNode->GetNodeItem(XFA_NODEITEM_NextSibling);
563 pNode;) { 511 pNode;) {
564 XFA_Element eCurType = pNode->GetElementType(); 512 XFA_Element eCurType = pNode->GetElementType();
565 if (eCurType == XFA_Element::InstanceManager) { 513 if (eCurType == XFA_Element::InstanceManager)
566 break; 514 break;
567 } 515
568 if ((eCurType != XFA_Element::Subform) && 516 if ((eCurType != XFA_Element::Subform) &&
569 (eCurType != XFA_Element::SubformSet)) { 517 (eCurType != XFA_Element::SubformSet)) {
570 pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling); 518 pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling);
571 continue; 519 continue;
572 } 520 }
573 if (dwNameHash != pNode->GetNameHash()) { 521 if (dwNameHash != pNode->GetNameHash())
574 break; 522 break;
575 } 523
576 CXFA_Node* pNextNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling); 524 CXFA_Node* pNextNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling);
577 pFormParent->RemoveChild(pNode); 525 pFormParent->RemoveChild(pNode);
578 subforms.Add(pNode); 526 subforms.Add(pNode);
579 pNode = pNextNode; 527 pNode = pNextNode;
580 } 528 }
581 pFormParent->RemoveChild(pExistingNode); 529 pFormParent->RemoveChild(pExistingNode);
582 pFormParent->InsertChild(pExistingNode); 530 pFormParent->InsertChild(pExistingNode);
583 pExistingNode->ClearFlag(XFA_NodeFlag_UnusedNode); 531 pExistingNode->ClearFlag(XFA_NodeFlag_UnusedNode);
584 pExistingNode->SetTemplateNode(pTemplateNode); 532 pExistingNode->SetTemplateNode(pTemplateNode);
585 return pExistingNode; 533 return pExistingNode;
586 } 534 }
535
587 CXFA_Node* pNewNode = pDocument->GetParser()->GetFactory()->CreateNode( 536 CXFA_Node* pNewNode = pDocument->GetParser()->GetFactory()->CreateNode(
588 XFA_XDPPACKET_Form, XFA_Element::InstanceManager); 537 XFA_XDPPACKET_Form, XFA_Element::InstanceManager);
589 ASSERT(pNewNode); 538 ASSERT(pNewNode);
590 wsInstMgrNodeName = 539 wsInstMgrNodeName =
591 FX_WSTRC(L"_") + pTemplateNode->GetCData(XFA_ATTRIBUTE_Name); 540 FX_WSTRC(L"_") + pTemplateNode->GetCData(XFA_ATTRIBUTE_Name);
592 pNewNode->SetCData(XFA_ATTRIBUTE_Name, wsInstMgrNodeName); 541 pNewNode->SetCData(XFA_ATTRIBUTE_Name, wsInstMgrNodeName);
593 pFormParent->InsertChild(pNewNode, nullptr); 542 pFormParent->InsertChild(pNewNode, nullptr);
594 pNewNode->SetTemplateNode(pTemplateNode); 543 pNewNode->SetTemplateNode(pTemplateNode);
595 return pNewNode; 544 return pNewNode;
596 } 545 }
597 static CXFA_Node* XFA_DataMerge_FindMatchingDataNode( 546
547 CXFA_Node* FindMatchingDataNode(
598 CXFA_Document* pDocument, 548 CXFA_Document* pDocument,
599 CXFA_Node* pTemplateNode, 549 CXFA_Node* pTemplateNode,
600 CXFA_Node* pDataScope, 550 CXFA_Node* pDataScope,
601 FX_BOOL& bAccessedDataDOM, 551 FX_BOOL& bAccessedDataDOM,
602 FX_BOOL bForceBind, 552 FX_BOOL bForceBind,
603 CXFA_NodeIteratorTemplate<CXFA_Node, 553 CXFA_NodeIteratorTemplate<CXFA_Node,
604 CXFA_TraverseStrategy_XFAContainerNode>* 554 CXFA_TraverseStrategy_XFAContainerNode>*
605 pIterator, 555 pIterator,
606 FX_BOOL& bSelfMatch, 556 FX_BOOL& bSelfMatch,
607 XFA_ATTRIBUTEENUM& eBindMatch, 557 XFA_ATTRIBUTEENUM& eBindMatch,
608 FX_BOOL bUpLevel = TRUE) { 558 FX_BOOL bUpLevel) {
609 FX_BOOL bOwnIterator = FALSE; 559 FX_BOOL bOwnIterator = FALSE;
610 if (!pIterator) { 560 if (!pIterator) {
611 bOwnIterator = TRUE; 561 bOwnIterator = TRUE;
612 pIterator = new CXFA_NodeIteratorTemplate< 562 pIterator = new CXFA_NodeIteratorTemplate<
613 CXFA_Node, CXFA_TraverseStrategy_XFAContainerNode>(pTemplateNode); 563 CXFA_Node, CXFA_TraverseStrategy_XFAContainerNode>(pTemplateNode);
614 } 564 }
565
615 CXFA_Node* pResult = nullptr; 566 CXFA_Node* pResult = nullptr;
616 for (CXFA_Node* pCurTemplateNode = pIterator->GetCurrent(); 567 for (CXFA_Node* pCurTemplateNode = pIterator->GetCurrent();
617 pCurTemplateNode;) { 568 pCurTemplateNode;) {
618 XFA_Element eMatchNodeType; 569 XFA_Element eMatchNodeType;
619 switch (pCurTemplateNode->GetElementType()) { 570 switch (pCurTemplateNode->GetElementType()) {
620 case XFA_Element::Subform: 571 case XFA_Element::Subform:
621 eMatchNodeType = XFA_Element::DataGroup; 572 eMatchNodeType = XFA_Element::DataGroup;
622 break; 573 break;
623 case XFA_Element::Field: { 574 case XFA_Element::Field: {
624 eMatchNodeType = XFA_FieldIsMultiListBox(pCurTemplateNode) 575 eMatchNodeType = XFA_FieldIsMultiListBox(pCurTemplateNode)
625 ? XFA_Element::DataGroup 576 ? XFA_Element::DataGroup
626 : XFA_Element::DataValue; 577 : XFA_Element::DataValue;
627 } break; 578 } break;
628 case XFA_Element::ExclGroup: 579 case XFA_Element::ExclGroup:
629 eMatchNodeType = XFA_Element::DataValue; 580 eMatchNodeType = XFA_Element::DataValue;
630 break; 581 break;
631 default: 582 default:
632 pCurTemplateNode = pIterator->MoveToNext(); 583 pCurTemplateNode = pIterator->MoveToNext();
633 continue; 584 continue;
634 } 585 }
635 CXFA_Node* pTemplateNodeOccur = 586 CXFA_Node* pTemplateNodeOccur =
636 pCurTemplateNode->GetFirstChildByClass(XFA_Element::Occur); 587 pCurTemplateNode->GetFirstChildByClass(XFA_Element::Occur);
637 int32_t iMin, iMax, iInit; 588 int32_t iMin, iMax, iInit;
638 if (pTemplateNodeOccur && 589 if (pTemplateNodeOccur &&
639 XFA_GetOccurInfo(pTemplateNodeOccur, iMin, iMax, iInit) && iMax == 0) { 590 GetOccurInfo(pTemplateNodeOccur, iMin, iMax, iInit) && iMax == 0) {
640 pCurTemplateNode = pIterator->MoveToNext(); 591 pCurTemplateNode = pIterator->MoveToNext();
641 continue; 592 continue;
642 } 593 }
594
643 CXFA_Node* pTemplateNodeBind = 595 CXFA_Node* pTemplateNodeBind =
644 pCurTemplateNode->GetFirstChildByClass(XFA_Element::Bind); 596 pCurTemplateNode->GetFirstChildByClass(XFA_Element::Bind);
645 XFA_ATTRIBUTEENUM eMatch = 597 XFA_ATTRIBUTEENUM eMatch =
646 pTemplateNodeBind ? pTemplateNodeBind->GetEnum(XFA_ATTRIBUTE_Match) 598 pTemplateNodeBind ? pTemplateNodeBind->GetEnum(XFA_ATTRIBUTE_Match)
647 : XFA_ATTRIBUTEENUM_Once; 599 : XFA_ATTRIBUTEENUM_Once;
648 eBindMatch = eMatch; 600 eBindMatch = eMatch;
649 switch (eMatch) { 601 switch (eMatch) {
650 case XFA_ATTRIBUTEENUM_None: 602 case XFA_ATTRIBUTEENUM_None:
651 pCurTemplateNode = pIterator->MoveToNext(); 603 pCurTemplateNode = pIterator->MoveToNext();
652 continue; 604 continue;
653 case XFA_ATTRIBUTEENUM_Global: 605 case XFA_ATTRIBUTEENUM_Global:
654 bAccessedDataDOM = TRUE; 606 bAccessedDataDOM = TRUE;
655 if (!bForceBind) { 607 if (!bForceBind) {
656 pCurTemplateNode = pIterator->MoveToNext(); 608 pCurTemplateNode = pIterator->MoveToNext();
657 continue; 609 continue;
658 } 610 }
659 if (eMatchNodeType == XFA_Element::DataValue || 611 if (eMatchNodeType == XFA_Element::DataValue ||
660 (eMatchNodeType == XFA_Element::DataGroup && 612 (eMatchNodeType == XFA_Element::DataGroup &&
661 XFA_FieldIsMultiListBox(pTemplateNodeBind))) { 613 XFA_FieldIsMultiListBox(pTemplateNodeBind))) {
662 CXFA_Node* pGlobalBindNode = XFA_DataMerge_FindGlobalDataNode( 614 CXFA_Node* pGlobalBindNode = FindGlobalDataNode(
663 pDocument, pCurTemplateNode->GetCData(XFA_ATTRIBUTE_Name), 615 pDocument, pCurTemplateNode->GetCData(XFA_ATTRIBUTE_Name),
664 pDataScope, eMatchNodeType); 616 pDataScope, eMatchNodeType);
665 if (!pGlobalBindNode) { 617 if (!pGlobalBindNode) {
666 pCurTemplateNode = pIterator->MoveToNext(); 618 pCurTemplateNode = pIterator->MoveToNext();
667 continue; 619 continue;
668 } 620 }
669 pResult = pGlobalBindNode; 621 pResult = pGlobalBindNode;
670 break; 622 break;
671 } 623 }
672 case XFA_ATTRIBUTEENUM_Once: { 624 case XFA_ATTRIBUTEENUM_Once: {
673 bAccessedDataDOM = TRUE; 625 bAccessedDataDOM = TRUE;
674 CXFA_Node* pOnceBindNode = XFA_DataMerge_FindOnceDataNode( 626 CXFA_Node* pOnceBindNode = FindOnceDataNode(
675 pDocument, pCurTemplateNode->GetCData(XFA_ATTRIBUTE_Name), 627 pDocument, pCurTemplateNode->GetCData(XFA_ATTRIBUTE_Name),
676 pDataScope, eMatchNodeType); 628 pDataScope, eMatchNodeType);
677 if (!pOnceBindNode) { 629 if (!pOnceBindNode) {
678 pCurTemplateNode = pIterator->MoveToNext(); 630 pCurTemplateNode = pIterator->MoveToNext();
679 continue; 631 continue;
680 } 632 }
681 pResult = pOnceBindNode; 633 pResult = pOnceBindNode;
682 } break; 634 break;
635 }
683 case XFA_ATTRIBUTEENUM_DataRef: { 636 case XFA_ATTRIBUTEENUM_DataRef: {
684 bAccessedDataDOM = TRUE; 637 bAccessedDataDOM = TRUE;
685 CXFA_Node* pDataRefBindNode = XFA_DataMerge_FindDataRefDataNode( 638 CXFA_Node* pDataRefBindNode = FindDataRefDataNode(
686 pDocument, pTemplateNodeBind->GetCData(XFA_ATTRIBUTE_Ref), 639 pDocument, pTemplateNodeBind->GetCData(XFA_ATTRIBUTE_Ref),
687 pDataScope, eMatchNodeType, pTemplateNode, bForceBind, bUpLevel); 640 pDataScope, eMatchNodeType, pTemplateNode, bForceBind, bUpLevel);
688 if (pDataRefBindNode && 641 if (pDataRefBindNode &&
689 pDataRefBindNode->GetElementType() == eMatchNodeType) { 642 pDataRefBindNode->GetElementType() == eMatchNodeType) {
690 pResult = pDataRefBindNode; 643 pResult = pDataRefBindNode;
691 } 644 }
692 if (!pResult) { 645 if (!pResult) {
693 pCurTemplateNode = pIterator->SkipChildrenAndMoveToNext(); 646 pCurTemplateNode = pIterator->SkipChildrenAndMoveToNext();
694 continue; 647 continue;
695 } 648 }
696 } break; 649 break;
650 }
697 default: 651 default:
698 break; 652 break;
699 } 653 }
700 if (pCurTemplateNode == pTemplateNode && pResult) { 654 if (pCurTemplateNode == pTemplateNode && pResult)
701 bSelfMatch = TRUE; 655 bSelfMatch = TRUE;
702 }
703 break; 656 break;
704 } 657 }
705 if (bOwnIterator) { 658 if (bOwnIterator)
706 delete pIterator; 659 delete pIterator;
707 }
708 return pResult; 660 return pResult;
709 } 661 }
710 static void XFA_DataMerge_SortRecurseRecord( 662
711 CFX_ArrayTemplate<XFA_DataMerge_RecurseRecord>& rgRecords, 663 void SortRecurseRecord(CFX_ArrayTemplate<RecurseRecord>& rgRecords,
712 CXFA_Node* pDataScope, 664 CXFA_Node* pDataScope,
713 FX_BOOL bChoiceMode = FALSE) { 665 FX_BOOL bChoiceMode) {
714 int32_t iCount = rgRecords.GetSize(); 666 int32_t iCount = rgRecords.GetSize();
715 CFX_ArrayTemplate<XFA_DataMerge_RecurseRecord> rgResultRecord; 667 CFX_ArrayTemplate<RecurseRecord> rgResultRecord;
716 for (CXFA_Node* pChildNode = pDataScope->GetNodeItem(XFA_NODEITEM_FirstChild); 668 for (CXFA_Node* pChildNode = pDataScope->GetNodeItem(XFA_NODEITEM_FirstChild);
717 pChildNode; 669 pChildNode;
718 pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { 670 pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
719 for (int32_t i = 0; i < iCount; i++) { 671 for (int32_t i = 0; i < iCount; i++) {
720 CXFA_Node* pNode = rgRecords[i].pDataChild; 672 CXFA_Node* pNode = rgRecords[i].pDataChild;
721 if (pChildNode == pNode) { 673 if (pChildNode == pNode) {
722 XFA_DataMerge_RecurseRecord sNewRecord = {rgRecords[i].pTemplateChild, 674 RecurseRecord sNewRecord = {rgRecords[i].pTemplateChild, pNode};
723 pNode};
724 rgResultRecord.Add(sNewRecord); 675 rgResultRecord.Add(sNewRecord);
725 rgRecords.RemoveAt(i); 676 rgRecords.RemoveAt(i);
726 iCount--; 677 iCount--;
727 break; 678 break;
728 } 679 }
729 } 680 }
730 if (bChoiceMode && rgResultRecord.GetSize() > 0) { 681 if (bChoiceMode && rgResultRecord.GetSize() > 0)
731 break; 682 break;
732 }
733 } 683 }
684
734 if (rgResultRecord.GetSize() > 0) { 685 if (rgResultRecord.GetSize() > 0) {
735 if (!bChoiceMode) { 686 if (!bChoiceMode) {
736 for (int32_t i = 0; i < iCount; i++) { 687 for (int32_t i = 0; i < iCount; i++) {
737 XFA_DataMerge_RecurseRecord sNewRecord = {rgRecords[i].pTemplateChild, 688 RecurseRecord sNewRecord = {rgRecords[i].pTemplateChild,
738 rgRecords[i].pDataChild}; 689 rgRecords[i].pDataChild};
739 rgResultRecord.Add(sNewRecord); 690 rgResultRecord.Add(sNewRecord);
740 } 691 }
741 } 692 }
742 rgRecords.RemoveAll(); 693 rgRecords.RemoveAll();
743 rgRecords.Copy(rgResultRecord); 694 rgRecords.Copy(rgResultRecord);
744 } 695 }
745 } 696 }
746 static CXFA_Node* XFA_DataMerge_CopyContainer_SubformSet( 697
747 CXFA_Document* pDocument, 698 CXFA_Node* CopyContainer_SubformSet(CXFA_Document* pDocument,
748 CXFA_Node* pTemplateNode, 699 CXFA_Node* pTemplateNode,
749 CXFA_Node* pFormParentNode, 700 CXFA_Node* pFormParentNode,
750 CXFA_Node* pDataScope, 701 CXFA_Node* pDataScope,
751 FX_BOOL bOneInstance, 702 FX_BOOL bOneInstance,
752 FX_BOOL bDataMerge) { 703 FX_BOOL bDataMerge) {
753 XFA_Element eType = pTemplateNode->GetElementType(); 704 XFA_Element eType = pTemplateNode->GetElementType();
754 CXFA_Node* pOccurNode = nullptr; 705 CXFA_Node* pOccurNode = nullptr;
755 CXFA_Node* pFirstInstance = nullptr; 706 CXFA_Node* pFirstInstance = nullptr;
756 FX_BOOL bUseInstanceManager = 707 FX_BOOL bUseInstanceManager =
757 pFormParentNode->GetElementType() != XFA_Element::Area; 708 pFormParentNode->GetElementType() != XFA_Element::Area;
758 CXFA_Node* pInstMgrNode = nullptr; 709 CXFA_Node* pInstMgrNode = nullptr;
759 CXFA_NodeArray subformArray; 710 CXFA_NodeArray subformArray;
760 CXFA_NodeArray* pSearchArray = nullptr; 711 CXFA_NodeArray* pSearchArray = nullptr;
761 if (!bOneInstance && 712 if (!bOneInstance &&
762 (eType == XFA_Element::SubformSet || eType == XFA_Element::Subform)) { 713 (eType == XFA_Element::SubformSet || eType == XFA_Element::Subform)) {
763 pInstMgrNode = 714 pInstMgrNode = bUseInstanceManager ? CloneOrMergeInstanceManager(
764 bUseInstanceManager 715 pDocument, pFormParentNode,
765 ? XFA_NodeMerge_CloneOrMergeInstanceManager( 716 pTemplateNode, subformArray)
766 pDocument, pFormParentNode, pTemplateNode, subformArray) 717 : nullptr;
767 : nullptr;
768 if (CXFA_Node* pOccurTemplateNode = 718 if (CXFA_Node* pOccurTemplateNode =
769 pTemplateNode->GetFirstChildByClass(XFA_Element::Occur)) { 719 pTemplateNode->GetFirstChildByClass(XFA_Element::Occur)) {
770 pOccurNode = pInstMgrNode 720 pOccurNode = pInstMgrNode ? XFA_NodeMerge_CloneOrMergeContainer(
771 ? XFA_NodeMerge_CloneOrMergeContainer( 721 pDocument, pInstMgrNode,
772 pDocument, pInstMgrNode, pOccurTemplateNode, FALSE) 722 pOccurTemplateNode, FALSE, nullptr)
773 : pOccurTemplateNode; 723 : pOccurTemplateNode;
774 } else if (pInstMgrNode) { 724 } else if (pInstMgrNode) {
775 pOccurNode = pInstMgrNode->GetFirstChildByClass(XFA_Element::Occur); 725 pOccurNode = pInstMgrNode->GetFirstChildByClass(XFA_Element::Occur);
776 if (pOccurNode) { 726 if (pOccurNode)
777 pOccurNode->ClearFlag(XFA_NodeFlag_UnusedNode); 727 pOccurNode->ClearFlag(XFA_NodeFlag_UnusedNode);
778 }
779 } 728 }
780 if (pInstMgrNode) { 729 if (pInstMgrNode) {
781 pInstMgrNode->SetFlag(XFA_NodeFlag_Initialized, true); 730 pInstMgrNode->SetFlag(XFA_NodeFlag_Initialized, true);
782 pSearchArray = &subformArray; 731 pSearchArray = &subformArray;
783 if (pFormParentNode->GetElementType() == XFA_Element::PageArea) { 732 if (pFormParentNode->GetElementType() == XFA_Element::PageArea) {
784 bOneInstance = TRUE; 733 bOneInstance = TRUE;
785 if (subformArray.GetSize() < 1) { 734 if (subformArray.GetSize() < 1)
786 pSearchArray = nullptr; 735 pSearchArray = nullptr;
787 }
788 } else if ((pTemplateNode->GetNameHash() == 0) && 736 } else if ((pTemplateNode->GetNameHash() == 0) &&
789 (subformArray.GetSize() < 1)) { 737 (subformArray.GetSize() < 1)) {
790 pSearchArray = nullptr; 738 pSearchArray = nullptr;
791 } 739 }
792 } 740 }
793 } 741 }
742
794 int32_t iMax = 1, iInit = 1, iMin = 1; 743 int32_t iMax = 1, iInit = 1, iMin = 1;
Lei Zhang 2016/07/07 19:23:43 One per line
dsinclair 2016/07/07 19:36:16 Done.
795 if (!bOneInstance) { 744 if (!bOneInstance)
796 XFA_GetOccurInfo(pOccurNode, iMin, iMax, iInit); 745 GetOccurInfo(pOccurNode, iMin, iMax, iInit);
797 } 746
798 XFA_ATTRIBUTEENUM eRelation = 747 XFA_ATTRIBUTEENUM eRelation =
799 eType == XFA_Element::SubformSet 748 eType == XFA_Element::SubformSet
800 ? pTemplateNode->GetEnum(XFA_ATTRIBUTE_Relation) 749 ? pTemplateNode->GetEnum(XFA_ATTRIBUTE_Relation)
801 : XFA_ATTRIBUTEENUM_Ordered; 750 : XFA_ATTRIBUTEENUM_Ordered;
802 int32_t iCurRepeatIndex = 0; 751 int32_t iCurRepeatIndex = 0;
803 XFA_ATTRIBUTEENUM eParentBindMatch = XFA_ATTRIBUTEENUM_None; 752 XFA_ATTRIBUTEENUM eParentBindMatch = XFA_ATTRIBUTEENUM_None;
804 if (bDataMerge) { 753 if (bDataMerge) {
805 CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFAContainerNode> 754 CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFAContainerNode>
806 sNodeIterator(pTemplateNode); 755 sNodeIterator(pTemplateNode);
807 FX_BOOL bAccessedDataDOM = FALSE; 756 FX_BOOL bAccessedDataDOM = FALSE;
808 if (eType == XFA_Element::SubformSet || eType == XFA_Element::Area) { 757 if (eType == XFA_Element::SubformSet || eType == XFA_Element::Area) {
809 sNodeIterator.MoveToNext(); 758 sNodeIterator.MoveToNext();
810 } else { 759 } else {
811 CFX_MapPtrTemplate<CXFA_Node*, CXFA_Node*> subformMapArray; 760 CFX_MapPtrTemplate<CXFA_Node*, CXFA_Node*> subformMapArray;
812 CXFA_NodeArray nodeArray; 761 CXFA_NodeArray nodeArray;
813 for (; iMax < 0 || iCurRepeatIndex < iMax; iCurRepeatIndex++) { 762 for (; iMax < 0 || iCurRepeatIndex < iMax; iCurRepeatIndex++) {
814 FX_BOOL bSelfMatch = FALSE; 763 FX_BOOL bSelfMatch = FALSE;
815 XFA_ATTRIBUTEENUM eBindMatch = XFA_ATTRIBUTEENUM_None; 764 XFA_ATTRIBUTEENUM eBindMatch = XFA_ATTRIBUTEENUM_None;
816 CXFA_Node* pDataNode = XFA_DataMerge_FindMatchingDataNode( 765 CXFA_Node* pDataNode = FindMatchingDataNode(
817 pDocument, pTemplateNode, pDataScope, bAccessedDataDOM, FALSE, 766 pDocument, pTemplateNode, pDataScope, bAccessedDataDOM, FALSE,
818 &sNodeIterator, bSelfMatch, eBindMatch); 767 &sNodeIterator, bSelfMatch, eBindMatch, TRUE);
819 if (!pDataNode || sNodeIterator.GetCurrent() != pTemplateNode) { 768 if (!pDataNode || sNodeIterator.GetCurrent() != pTemplateNode)
820 break; 769 break;
821 } 770
822 eParentBindMatch = eBindMatch; 771 eParentBindMatch = eBindMatch;
823 CXFA_Node* pSubformNode = XFA_NodeMerge_CloneOrMergeContainer( 772 CXFA_Node* pSubformNode = XFA_NodeMerge_CloneOrMergeContainer(
824 pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray); 773 pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray);
825 if (!pFirstInstance) { 774 if (!pFirstInstance)
826 pFirstInstance = pSubformNode; 775 pFirstInstance = pSubformNode;
827 } 776
828 XFA_DataMerge_CreateDataBinding(pSubformNode, pDataNode); 777 CreateDataBinding(pSubformNode, pDataNode, TRUE);
829 ASSERT(pSubformNode); 778 ASSERT(pSubformNode);
830 subformMapArray.SetAt(pSubformNode, pDataNode); 779 subformMapArray.SetAt(pSubformNode, pDataNode);
831 nodeArray.Add(pSubformNode); 780 nodeArray.Add(pSubformNode);
832 } 781 }
782
833 subformMapArray.GetStartPosition(); 783 subformMapArray.GetStartPosition();
834 for (int32_t iIndex = 0; iIndex < nodeArray.GetSize(); iIndex++) { 784 for (int32_t iIndex = 0; iIndex < nodeArray.GetSize(); iIndex++) {
835 CXFA_Node* pSubform = nodeArray[iIndex]; 785 CXFA_Node* pSubform = nodeArray[iIndex];
836 CXFA_Node* pDataNode = 786 CXFA_Node* pDataNode =
837 reinterpret_cast<CXFA_Node*>(subformMapArray.GetValueAt(pSubform)); 787 reinterpret_cast<CXFA_Node*>(subformMapArray.GetValueAt(pSubform));
838 for (CXFA_Node* pTemplateChild = 788 for (CXFA_Node* pTemplateChild =
839 pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild); 789 pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
840 pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem( 790 pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
841 XFA_NODEITEM_NextSibling)) { 791 XFA_NODEITEM_NextSibling)) {
842 if (XFA_NeedGenerateForm(pTemplateChild, bUseInstanceManager)) { 792 if (NeedGenerateForm(pTemplateChild, bUseInstanceManager)) {
843 XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubform, 793 XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubform,
844 pTemplateChild, TRUE); 794 pTemplateChild, TRUE, nullptr);
845 } else if (pTemplateChild->IsContainerNode()) { 795 } else if (pTemplateChild->IsContainerNode()) {
846 pDocument->DataMerge_CopyContainer(pTemplateChild, pSubform, 796 pDocument->DataMerge_CopyContainer(pTemplateChild, pSubform,
847 pDataNode, FALSE, TRUE, FALSE); 797 pDataNode, FALSE, TRUE, FALSE);
848 } 798 }
849 } 799 }
850 } 800 }
851 subformMapArray.RemoveAll(); 801 subformMapArray.RemoveAll();
852 } 802 }
803
853 for (; iMax < 0 || iCurRepeatIndex < iMax; iCurRepeatIndex++) { 804 for (; iMax < 0 || iCurRepeatIndex < iMax; iCurRepeatIndex++) {
854 FX_BOOL bSelfMatch = FALSE; 805 FX_BOOL bSelfMatch = FALSE;
855 XFA_ATTRIBUTEENUM eBindMatch = XFA_ATTRIBUTEENUM_None; 806 XFA_ATTRIBUTEENUM eBindMatch = XFA_ATTRIBUTEENUM_None;
856 if (!XFA_DataMerge_FindMatchingDataNode( 807 if (!FindMatchingDataNode(pDocument, pTemplateNode, pDataScope,
857 pDocument, pTemplateNode, pDataScope, bAccessedDataDOM, FALSE, 808 bAccessedDataDOM, FALSE, &sNodeIterator,
858 &sNodeIterator, bSelfMatch, eBindMatch)) { 809 bSelfMatch, eBindMatch, TRUE)) {
859 break; 810 break;
860 } 811 }
861 if (eBindMatch == XFA_ATTRIBUTEENUM_DataRef && 812 if (eBindMatch == XFA_ATTRIBUTEENUM_DataRef &&
862 eParentBindMatch == XFA_ATTRIBUTEENUM_DataRef) { 813 eParentBindMatch == XFA_ATTRIBUTEENUM_DataRef) {
863 break; 814 break;
864 } 815 }
816
865 if (eRelation == XFA_ATTRIBUTEENUM_Choice || 817 if (eRelation == XFA_ATTRIBUTEENUM_Choice ||
866 eRelation == XFA_ATTRIBUTEENUM_Unordered) { 818 eRelation == XFA_ATTRIBUTEENUM_Unordered) {
867 CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer( 819 CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer(
868 pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray); 820 pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray);
869 ASSERT(pSubformSetNode); 821 ASSERT(pSubformSetNode);
870 if (!pFirstInstance) { 822 if (!pFirstInstance)
871 pFirstInstance = pSubformSetNode; 823 pFirstInstance = pSubformSetNode;
872 } 824
873 CFX_ArrayTemplate<XFA_DataMerge_RecurseRecord> rgItemMatchList; 825 CFX_ArrayTemplate<RecurseRecord> rgItemMatchList;
874 CFX_ArrayTemplate<CXFA_Node*> rgItemUnmatchList; 826 CFX_ArrayTemplate<CXFA_Node*> rgItemUnmatchList;
875 for (CXFA_Node* pTemplateChild = 827 for (CXFA_Node* pTemplateChild =
876 pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild); 828 pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
877 pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem( 829 pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
878 XFA_NODEITEM_NextSibling)) { 830 XFA_NODEITEM_NextSibling)) {
879 if (XFA_NeedGenerateForm(pTemplateChild, bUseInstanceManager)) { 831 if (NeedGenerateForm(pTemplateChild, bUseInstanceManager)) {
880 XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformSetNode, 832 XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformSetNode,
881 pTemplateChild, TRUE); 833 pTemplateChild, TRUE, nullptr);
882 } else if (pTemplateChild->IsContainerNode()) { 834 } else if (pTemplateChild->IsContainerNode()) {
883 bSelfMatch = FALSE; 835 bSelfMatch = FALSE;
884 eBindMatch = XFA_ATTRIBUTEENUM_None; 836 eBindMatch = XFA_ATTRIBUTEENUM_None;
885 CXFA_Node* pDataMatch; 837 CXFA_Node* pDataMatch;
886 if (eRelation != XFA_ATTRIBUTEENUM_Ordered && 838 if (eRelation != XFA_ATTRIBUTEENUM_Ordered &&
887 (pDataMatch = XFA_DataMerge_FindMatchingDataNode( 839 (pDataMatch = FindMatchingDataNode(
Lei Zhang 2016/07/07 19:23:42 Not a fan of assignments in the middle of an if st
dsinclair 2016/07/07 19:36:16 Done.
888 pDocument, pTemplateChild, pDataScope, bAccessedDataDOM, 840 pDocument, pTemplateChild, pDataScope, bAccessedDataDOM,
889 FALSE, nullptr, bSelfMatch, eBindMatch)) != nullptr) { 841 FALSE, nullptr, bSelfMatch, eBindMatch, TRUE)) !=
890 XFA_DataMerge_RecurseRecord sNewRecord = {pTemplateChild, 842 nullptr) {
891 pDataMatch}; 843 RecurseRecord sNewRecord = {pTemplateChild, pDataMatch};
892 if (bSelfMatch) { 844 if (bSelfMatch)
893 rgItemMatchList.InsertAt(0, sNewRecord); 845 rgItemMatchList.InsertAt(0, sNewRecord);
894 } else { 846 else
895 rgItemMatchList.Add(sNewRecord); 847 rgItemMatchList.Add(sNewRecord);
896 }
897 } else { 848 } else {
898 rgItemUnmatchList.Add(pTemplateChild); 849 rgItemUnmatchList.Add(pTemplateChild);
899 } 850 }
900 } 851 }
901 } 852 }
853
902 switch (eRelation) { 854 switch (eRelation) {
903 case XFA_ATTRIBUTEENUM_Choice: { 855 case XFA_ATTRIBUTEENUM_Choice: {
904 ASSERT(rgItemMatchList.GetSize()); 856 ASSERT(rgItemMatchList.GetSize());
905 XFA_DataMerge_SortRecurseRecord(rgItemMatchList, pDataScope, TRUE); 857 SortRecurseRecord(rgItemMatchList, pDataScope, TRUE);
906 pDocument->DataMerge_CopyContainer( 858 pDocument->DataMerge_CopyContainer(
907 rgItemMatchList[0].pTemplateChild, pSubformSetNode, pDataScope); 859 rgItemMatchList[0].pTemplateChild, pSubformSetNode, pDataScope);
908 } break; 860 break;
861 }
909 case XFA_ATTRIBUTEENUM_Unordered: { 862 case XFA_ATTRIBUTEENUM_Unordered: {
910 if (rgItemMatchList.GetSize()) { 863 if (rgItemMatchList.GetSize()) {
911 XFA_DataMerge_SortRecurseRecord(rgItemMatchList, pDataScope); 864 SortRecurseRecord(rgItemMatchList, pDataScope, FALSE);
912 for (int32_t i = 0, count = rgItemMatchList.GetSize(); i < count; 865 for (int32_t i = 0, count = rgItemMatchList.GetSize(); i < count;
913 i++) { 866 i++) {
914 pDocument->DataMerge_CopyContainer( 867 pDocument->DataMerge_CopyContainer(
915 rgItemMatchList[i].pTemplateChild, pSubformSetNode, 868 rgItemMatchList[i].pTemplateChild, pSubformSetNode,
916 pDataScope); 869 pDataScope);
917 } 870 }
918 } 871 }
919 for (int32_t i = 0, count = rgItemUnmatchList.GetSize(); i < count; 872 for (int32_t i = 0, count = rgItemUnmatchList.GetSize(); i < count;
920 i++) { 873 i++) {
921 pDocument->DataMerge_CopyContainer(rgItemUnmatchList[i], 874 pDocument->DataMerge_CopyContainer(rgItemUnmatchList[i],
922 pSubformSetNode, pDataScope); 875 pSubformSetNode, pDataScope);
923 } 876 }
924 } break; 877 break;
878 }
925 default: 879 default:
926 break; 880 break;
927 } 881 }
928 } else { 882 } else {
929 CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer( 883 CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer(
930 pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray); 884 pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray);
931 ASSERT(pSubformSetNode); 885 ASSERT(pSubformSetNode);
932 if (!pFirstInstance) { 886 if (!pFirstInstance)
933 pFirstInstance = pSubformSetNode; 887 pFirstInstance = pSubformSetNode;
934 } 888
935 for (CXFA_Node* pTemplateChild = 889 for (CXFA_Node* pTemplateChild =
936 pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild); 890 pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
937 pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem( 891 pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
938 XFA_NODEITEM_NextSibling)) { 892 XFA_NODEITEM_NextSibling)) {
939 if (XFA_NeedGenerateForm(pTemplateChild, bUseInstanceManager)) { 893 if (NeedGenerateForm(pTemplateChild, bUseInstanceManager)) {
940 XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformSetNode, 894 XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformSetNode,
941 pTemplateChild, TRUE); 895 pTemplateChild, TRUE, nullptr);
942 } else if (pTemplateChild->IsContainerNode()) { 896 } else if (pTemplateChild->IsContainerNode()) {
943 pDocument->DataMerge_CopyContainer(pTemplateChild, pSubformSetNode, 897 pDocument->DataMerge_CopyContainer(pTemplateChild, pSubformSetNode,
944 pDataScope); 898 pDataScope);
945 } 899 }
946 } 900 }
947 } 901 }
948 } 902 }
903
949 if (iCurRepeatIndex == 0 && bAccessedDataDOM == FALSE) { 904 if (iCurRepeatIndex == 0 && bAccessedDataDOM == FALSE) {
950 int32_t iLimit = iMax; 905 int32_t iLimit = iMax;
951 if (pInstMgrNode && pTemplateNode->GetNameHash() == 0) { 906 if (pInstMgrNode && pTemplateNode->GetNameHash() == 0) {
952 iLimit = subformArray.GetSize(); 907 iLimit = subformArray.GetSize();
953 if (iLimit < iMin) { 908 if (iLimit < iMin)
954 iLimit = iInit; 909 iLimit = iInit;
955 }
956 } 910 }
911
957 for (; (iLimit < 0 || iCurRepeatIndex < iLimit); iCurRepeatIndex++) { 912 for (; (iLimit < 0 || iCurRepeatIndex < iLimit); iCurRepeatIndex++) {
958 if (pInstMgrNode) { 913 if (pInstMgrNode) {
959 if (pSearchArray && pSearchArray->GetSize() < 1) { 914 if (pSearchArray && pSearchArray->GetSize() < 1) {
960 if (pTemplateNode->GetNameHash() != 0) { 915 if (pTemplateNode->GetNameHash() != 0)
961 break; 916 break;
962 }
963 pSearchArray = nullptr; 917 pSearchArray = nullptr;
964 } 918 }
965 } else if (!XFA_DataMerge_FindFormDOMInstance( 919 } else if (!XFA_DataMerge_FindFormDOMInstance(
966 pDocument, pTemplateNode->GetElementType(), 920 pDocument, pTemplateNode->GetElementType(),
967 pTemplateNode->GetNameHash(), pFormParentNode)) { 921 pTemplateNode->GetNameHash(), pFormParentNode)) {
968 break; 922 break;
969 } 923 }
970 CXFA_Node* pSubformNode = XFA_NodeMerge_CloneOrMergeContainer( 924 CXFA_Node* pSubformNode = XFA_NodeMerge_CloneOrMergeContainer(
971 pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray); 925 pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray);
972 ASSERT(pSubformNode); 926 ASSERT(pSubformNode);
973 if (!pFirstInstance) { 927 if (!pFirstInstance)
974 pFirstInstance = pSubformNode; 928 pFirstInstance = pSubformNode;
975 } 929
976 for (CXFA_Node* pTemplateChild = 930 for (CXFA_Node* pTemplateChild =
977 pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild); 931 pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
978 pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem( 932 pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
979 XFA_NODEITEM_NextSibling)) { 933 XFA_NODEITEM_NextSibling)) {
980 if (XFA_NeedGenerateForm(pTemplateChild, bUseInstanceManager)) { 934 if (NeedGenerateForm(pTemplateChild, bUseInstanceManager)) {
981 XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformNode, 935 XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformNode,
982 pTemplateChild, TRUE); 936 pTemplateChild, TRUE, nullptr);
983 } else if (pTemplateChild->IsContainerNode()) { 937 } else if (pTemplateChild->IsContainerNode()) {
984 pDocument->DataMerge_CopyContainer(pTemplateChild, pSubformNode, 938 pDocument->DataMerge_CopyContainer(pTemplateChild, pSubformNode,
985 pDataScope); 939 pDataScope);
986 } 940 }
987 } 941 }
988 } 942 }
989 } 943 }
990 } 944 }
945
991 int32_t iMinimalLimit = iCurRepeatIndex == 0 ? iInit : iMin; 946 int32_t iMinimalLimit = iCurRepeatIndex == 0 ? iInit : iMin;
992 for (; iCurRepeatIndex < iMinimalLimit; iCurRepeatIndex++) { 947 for (; iCurRepeatIndex < iMinimalLimit; iCurRepeatIndex++) {
993 CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer( 948 CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer(
994 pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray); 949 pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray);
995 ASSERT(pSubformSetNode); 950 ASSERT(pSubformSetNode);
996 if (!pFirstInstance) { 951 if (!pFirstInstance)
997 pFirstInstance = pSubformSetNode; 952 pFirstInstance = pSubformSetNode;
998 } 953
999 FX_BOOL bFound = FALSE; 954 FX_BOOL bFound = FALSE;
1000 for (CXFA_Node* pTemplateChild = 955 for (CXFA_Node* pTemplateChild =
1001 pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild); 956 pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
1002 pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem( 957 pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
1003 XFA_NODEITEM_NextSibling)) { 958 XFA_NODEITEM_NextSibling)) {
1004 if (XFA_NeedGenerateForm(pTemplateChild, bUseInstanceManager)) { 959 if (NeedGenerateForm(pTemplateChild, bUseInstanceManager)) {
1005 XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformSetNode, 960 XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformSetNode,
1006 pTemplateChild, TRUE); 961 pTemplateChild, TRUE, nullptr);
1007 } else if (pTemplateChild->IsContainerNode()) { 962 } else if (pTemplateChild->IsContainerNode()) {
1008 if (bFound && eRelation == XFA_ATTRIBUTEENUM_Choice) { 963 if (bFound && eRelation == XFA_ATTRIBUTEENUM_Choice)
1009 continue; 964 continue;
1010 } 965
1011 pDocument->DataMerge_CopyContainer(pTemplateChild, pSubformSetNode, 966 pDocument->DataMerge_CopyContainer(pTemplateChild, pSubformSetNode,
1012 pDataScope, FALSE, bDataMerge); 967 pDataScope, FALSE, bDataMerge);
1013 bFound = TRUE; 968 bFound = TRUE;
1014 } 969 }
1015 } 970 }
1016 } 971 }
1017 return pFirstInstance; 972 return pFirstInstance;
1018 } 973 }
1019 static CXFA_Node* XFA_DataMerge_CopyContainer_Field(CXFA_Document* pDocument, 974
1020 CXFA_Node* pTemplateNode, 975 CXFA_Node* CopyContainer_Field(CXFA_Document* pDocument,
1021 CXFA_Node* pFormNode, 976 CXFA_Node* pTemplateNode,
1022 CXFA_Node* pDataScope, 977 CXFA_Node* pFormNode,
1023 FX_BOOL bDataMerge, 978 CXFA_Node* pDataScope,
1024 FX_BOOL bUpLevel = TRUE) { 979 FX_BOOL bDataMerge,
980 FX_BOOL bUpLevel) {
1025 CXFA_Node* pFieldNode = XFA_NodeMerge_CloneOrMergeContainer( 981 CXFA_Node* pFieldNode = XFA_NodeMerge_CloneOrMergeContainer(
1026 pDocument, pFormNode, pTemplateNode, FALSE); 982 pDocument, pFormNode, pTemplateNode, FALSE, nullptr);
1027 ASSERT(pFieldNode); 983 ASSERT(pFieldNode);
1028 for (CXFA_Node* pTemplateChildNode = 984 for (CXFA_Node* pTemplateChildNode =
1029 pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild); 985 pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
1030 pTemplateChildNode; pTemplateChildNode = pTemplateChildNode->GetNodeItem( 986 pTemplateChildNode; pTemplateChildNode = pTemplateChildNode->GetNodeItem(
1031 XFA_NODEITEM_NextSibling)) { 987 XFA_NODEITEM_NextSibling)) {
1032 if (XFA_NeedGenerateForm(pTemplateChildNode)) { 988 if (NeedGenerateForm(pTemplateChildNode, TRUE)) {
1033 XFA_NodeMerge_CloneOrMergeContainer(pDocument, pFieldNode, 989 XFA_NodeMerge_CloneOrMergeContainer(pDocument, pFieldNode,
1034 pTemplateChildNode, TRUE); 990 pTemplateChildNode, TRUE, nullptr);
1035 } else if (pTemplateNode->GetElementType() == XFA_Element::ExclGroup && 991 } else if (pTemplateNode->GetElementType() == XFA_Element::ExclGroup &&
1036 pTemplateChildNode->IsContainerNode()) { 992 pTemplateChildNode->IsContainerNode()) {
1037 if (pTemplateChildNode->GetElementType() == XFA_Element::Field) { 993 if (pTemplateChildNode->GetElementType() == XFA_Element::Field) {
1038 XFA_DataMerge_CopyContainer_Field(pDocument, pTemplateChildNode, 994 CopyContainer_Field(pDocument, pTemplateChildNode, pFieldNode, nullptr,
1039 pFieldNode, nullptr, FALSE); 995 FALSE, TRUE);
1040 } 996 }
1041 } 997 }
1042 } 998 }
1043 if (bDataMerge) { 999 if (bDataMerge) {
1044 FX_BOOL bAccessedDataDOM = FALSE; 1000 FX_BOOL bAccessedDataDOM = FALSE;
1045 FX_BOOL bSelfMatch = FALSE; 1001 FX_BOOL bSelfMatch = FALSE;
1046 XFA_ATTRIBUTEENUM eBindMatch; 1002 XFA_ATTRIBUTEENUM eBindMatch;
1047 CXFA_Node* pDataNode = XFA_DataMerge_FindMatchingDataNode( 1003 CXFA_Node* pDataNode = FindMatchingDataNode(
1048 pDocument, pTemplateNode, pDataScope, bAccessedDataDOM, TRUE, nullptr, 1004 pDocument, pTemplateNode, pDataScope, bAccessedDataDOM, TRUE, nullptr,
1049 bSelfMatch, eBindMatch, bUpLevel); 1005 bSelfMatch, eBindMatch, bUpLevel);
1050 if (pDataNode) { 1006 if (pDataNode)
1051 XFA_DataMerge_CreateDataBinding(pFieldNode, pDataNode); 1007 CreateDataBinding(pFieldNode, pDataNode, TRUE);
1052 }
1053 } else { 1008 } else {
1054 XFA_DataMerge_FormValueNode_MatchNoneCreateChild(pFieldNode); 1009 FormValueNode_MatchNoneCreateChild(pFieldNode);
1055 } 1010 }
1056 return pFieldNode; 1011 return pFieldNode;
1057 } 1012 }
1058 CXFA_Node* CXFA_Document::DataMerge_CopyContainer(CXFA_Node* pTemplateNode, 1013
1059 CXFA_Node* pFormNode, 1014 CXFA_Node* MaybeCreateDataNode(CXFA_Document* pDocument,
1060 CXFA_Node* pDataScope, 1015 CXFA_Node* pDataParent,
1061 FX_BOOL bOneInstance, 1016 XFA_Element eNodeType,
1062 FX_BOOL bDataMerge, 1017 const CFX_WideString& wsName) {
1063 FX_BOOL bUpLevel) { 1018 if (!pDataParent)
1064 switch (pTemplateNode->GetElementType()) { 1019 return nullptr;
1065 case XFA_Element::SubformSet: 1020
1066 case XFA_Element::Subform: 1021 CXFA_Node* pParentDDNode = pDataParent->GetDataDescriptionNode();
1067 case XFA_Element::Area: 1022 if (!pParentDDNode) {
1068 case XFA_Element::PageArea: 1023 CXFA_Node* pDataNode =
1069 return XFA_DataMerge_CopyContainer_SubformSet( 1024 pDocument->CreateNode(XFA_XDPPACKET_Datasets, eNodeType);
1070 this, pTemplateNode, pFormNode, pDataScope, bOneInstance, bDataMerge); 1025 ASSERT(pDataNode);
Lei Zhang 2016/07/07 19:23:42 No need
dsinclair 2016/07/07 19:36:16 Done.
1071 case XFA_Element::ExclGroup: 1026 pDataNode->SetCData(XFA_ATTRIBUTE_Name, wsName);
1072 case XFA_Element::Field: 1027 pDataNode->CreateXMLMappingNode();
1073 case XFA_Element::Draw: 1028 pDataParent->InsertChild(pDataNode);
1074 case XFA_Element::ContentArea: 1029 pDataNode->SetFlag(XFA_NodeFlag_Initialized, false);
1075 return XFA_DataMerge_CopyContainer_Field( 1030 return pDataNode;
1076 this, pTemplateNode, pFormNode, pDataScope, bDataMerge, bUpLevel); 1031 }
1077 case XFA_Element::PageSet: 1032
1033 CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_DDGroup> sIterator(
1034 pParentDDNode);
1035 for (CXFA_Node* pDDGroupNode = sIterator.GetCurrent(); pDDGroupNode;
1036 pDDGroupNode = sIterator.MoveToNext()) {
1037 if (pDDGroupNode != pParentDDNode) {
1038 if (pDDGroupNode->GetElementType() != XFA_Element::DataGroup)
1039 continue;
1040
1041 CFX_WideString wsNamespace;
1042 if (!pDDGroupNode->TryNamespace(wsNamespace) ||
1043 wsNamespace != FX_WSTRC(L"http://ns.adobe.com/data-description/")) {
1044 continue;
1045 }
1046 }
1047 CXFA_Node* pDDNode = pDDGroupNode->GetFirstChildByName(wsName.AsStringC());
1048 if (!pDDNode)
1049 continue;
1050 if (pDDNode->GetElementType() != eNodeType)
1078 break; 1051 break;
1079 case XFA_Element::Variables: 1052
1080 break; 1053 CXFA_Node* pDataNode =
1081 default: 1054 pDocument->CreateNode(XFA_XDPPACKET_Datasets, eNodeType);
1082 ASSERT(FALSE); 1055 ASSERT(pDataNode);
Lei Zhang 2016/07/07 19:23:42 Ditto
dsinclair 2016/07/07 19:36:16 Done.
1083 break; 1056 pDataNode->SetCData(XFA_ATTRIBUTE_Name, wsName);
1057 pDataNode->CreateXMLMappingNode();
1058 if (eNodeType == XFA_Element::DataValue &&
1059 pDDNode->GetEnum(XFA_ATTRIBUTE_Contains) ==
1060 XFA_ATTRIBUTEENUM_MetaData) {
1061 pDataNode->SetEnum(XFA_ATTRIBUTE_Contains, XFA_ATTRIBUTEENUM_MetaData);
1062 }
1063 pDataParent->InsertChild(pDataNode);
1064 pDataNode->SetDataDescriptionNode(pDDNode);
1065 pDataNode->SetFlag(XFA_NodeFlag_Initialized, false);
1066 return pDataNode;
1084 } 1067 }
1085 return nullptr; 1068 return nullptr;
1086 } 1069 }
1087 1070
1088 static void XFA_DataMerge_UpdateBindingRelations(CXFA_Document* pDocument, 1071 void UpdateBindingRelations(CXFA_Document* pDocument,
1089 CXFA_Node* pFormNode, 1072 CXFA_Node* pFormNode,
1090 CXFA_Node* pDataScope, 1073 CXFA_Node* pDataScope,
1091 FX_BOOL bDataRef, 1074 FX_BOOL bDataRef,
1092 FX_BOOL bParentDataRef) { 1075 FX_BOOL bParentDataRef) {
1093 FX_BOOL bMatchRef = TRUE; 1076 FX_BOOL bMatchRef = TRUE;
1094 XFA_Element eType = pFormNode->GetElementType(); 1077 XFA_Element eType = pFormNode->GetElementType();
1095 CXFA_Node* pDataNode = pFormNode->GetBindData(); 1078 CXFA_Node* pDataNode = pFormNode->GetBindData();
1096 if (eType == XFA_Element::Subform || eType == XFA_Element::ExclGroup || 1079 if (eType == XFA_Element::Subform || eType == XFA_Element::ExclGroup ||
1097 eType == XFA_Element::Field) { 1080 eType == XFA_Element::Field) {
1098 CXFA_Node* pTemplateNode = pFormNode->GetTemplateNode(); 1081 CXFA_Node* pTemplateNode = pFormNode->GetTemplateNode();
1099 CXFA_Node* pTemplateNodeBind = 1082 CXFA_Node* pTemplateNodeBind =
1100 pTemplateNode ? pTemplateNode->GetFirstChildByClass(XFA_Element::Bind) 1083 pTemplateNode ? pTemplateNode->GetFirstChildByClass(XFA_Element::Bind)
1101 : nullptr; 1084 : nullptr;
1102 XFA_ATTRIBUTEENUM eMatch = 1085 XFA_ATTRIBUTEENUM eMatch =
1103 pTemplateNodeBind ? pTemplateNodeBind->GetEnum(XFA_ATTRIBUTE_Match) 1086 pTemplateNodeBind ? pTemplateNodeBind->GetEnum(XFA_ATTRIBUTE_Match)
1104 : XFA_ATTRIBUTEENUM_Once; 1087 : XFA_ATTRIBUTEENUM_Once;
1105 switch (eMatch) { 1088 switch (eMatch) {
1106 case XFA_ATTRIBUTEENUM_None: 1089 case XFA_ATTRIBUTEENUM_None:
1107 if (!bDataRef || bParentDataRef) { 1090 if (!bDataRef || bParentDataRef)
1108 XFA_DataMerge_FormValueNode_MatchNoneCreateChild(pFormNode); 1091 FormValueNode_MatchNoneCreateChild(pFormNode);
1109 }
1110 break; 1092 break;
1111 case XFA_ATTRIBUTEENUM_Once: 1093 case XFA_ATTRIBUTEENUM_Once:
1112 if (!bDataRef || bParentDataRef) { 1094 if (!bDataRef || bParentDataRef) {
1113 if (!pDataNode) { 1095 if (!pDataNode) {
1114 if (pFormNode->GetNameHash() != 0 && 1096 if (pFormNode->GetNameHash() != 0 &&
1115 pFormNode->GetEnum(XFA_ATTRIBUTE_Scope) != 1097 pFormNode->GetEnum(XFA_ATTRIBUTE_Scope) !=
1116 XFA_ATTRIBUTEENUM_None) { 1098 XFA_ATTRIBUTEENUM_None) {
1117 XFA_Element eDataNodeType = (eType == XFA_Element::Subform || 1099 XFA_Element eDataNodeType = (eType == XFA_Element::Subform ||
1118 XFA_FieldIsMultiListBox(pFormNode)) 1100 XFA_FieldIsMultiListBox(pFormNode))
1119 ? XFA_Element::DataGroup 1101 ? XFA_Element::DataGroup
1120 : XFA_Element::DataValue; 1102 : XFA_Element::DataValue;
1121 pDataNode = XFA_DataDescription_MaybeCreateDataNode( 1103 pDataNode = MaybeCreateDataNode(
1122 pDocument, pDataScope, eDataNodeType, 1104 pDocument, pDataScope, eDataNodeType,
1123 CFX_WideString(pFormNode->GetCData(XFA_ATTRIBUTE_Name))); 1105 CFX_WideString(pFormNode->GetCData(XFA_ATTRIBUTE_Name)));
1124 if (pDataNode) { 1106 if (pDataNode)
1125 XFA_DataMerge_CreateDataBinding(pFormNode, pDataNode, FALSE); 1107 CreateDataBinding(pFormNode, pDataNode, FALSE);
1126 }
1127 } 1108 }
1128 if (!pDataNode) { 1109 if (!pDataNode)
1129 XFA_DataMerge_FormValueNode_MatchNoneCreateChild(pFormNode); 1110 FormValueNode_MatchNoneCreateChild(pFormNode);
1130 } 1111
1131 } else { 1112 } else {
1132 CXFA_Node* pDataParent = 1113 CXFA_Node* pDataParent =
1133 pDataNode->GetNodeItem(XFA_NODEITEM_Parent); 1114 pDataNode->GetNodeItem(XFA_NODEITEM_Parent);
1134 if (pDataParent != pDataScope) { 1115 if (pDataParent != pDataScope) {
1135 ASSERT(pDataParent); 1116 ASSERT(pDataParent);
1136 pDataParent->RemoveChild(pDataNode); 1117 pDataParent->RemoveChild(pDataNode);
1137 pDataScope->InsertChild(pDataNode); 1118 pDataScope->InsertChild(pDataNode);
1138 } 1119 }
1139 } 1120 }
1140 } 1121 }
1141 break; 1122 break;
1142 case XFA_ATTRIBUTEENUM_Global: 1123 case XFA_ATTRIBUTEENUM_Global:
1143 if (!bDataRef || bParentDataRef) { 1124 if (!bDataRef || bParentDataRef) {
1144 uint32_t dwNameHash = pFormNode->GetNameHash(); 1125 uint32_t dwNameHash = pFormNode->GetNameHash();
1145 if (dwNameHash != 0 && !pDataNode) { 1126 if (dwNameHash != 0 && !pDataNode) {
1146 pDataNode = XFA_DataMerge_GetGlobalBinding(pDocument, dwNameHash); 1127 pDataNode = GetGlobalBinding(pDocument, dwNameHash);
1147 if (!pDataNode) { 1128 if (!pDataNode) {
1148 XFA_Element eDataNodeType = (eType == XFA_Element::Subform || 1129 XFA_Element eDataNodeType = (eType == XFA_Element::Subform ||
1149 XFA_FieldIsMultiListBox(pFormNode)) 1130 XFA_FieldIsMultiListBox(pFormNode))
1150 ? XFA_Element::DataGroup 1131 ? XFA_Element::DataGroup
1151 : XFA_Element::DataValue; 1132 : XFA_Element::DataValue;
1152 CXFA_Node* pRecordNode = 1133 CXFA_Node* pRecordNode =
1153 ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Record)); 1134 ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Record));
1154 pDataNode = XFA_DataDescription_MaybeCreateDataNode( 1135 pDataNode = MaybeCreateDataNode(
1155 pDocument, pRecordNode, eDataNodeType, 1136 pDocument, pRecordNode, eDataNodeType,
1156 CFX_WideString(pFormNode->GetCData(XFA_ATTRIBUTE_Name))); 1137 CFX_WideString(pFormNode->GetCData(XFA_ATTRIBUTE_Name)));
1157 if (pDataNode) { 1138 if (pDataNode) {
1158 XFA_DataMerge_CreateDataBinding(pFormNode, pDataNode, FALSE); 1139 CreateDataBinding(pFormNode, pDataNode, FALSE);
1159 XFA_DataMerge_RegisterGlobalBinding( 1140 RegisterGlobalBinding(pDocument, pFormNode->GetNameHash(),
1160 pDocument, pFormNode->GetNameHash(), pDataNode); 1141 pDataNode);
1161 } 1142 }
1162 } else { 1143 } else {
1163 XFA_DataMerge_CreateDataBinding(pFormNode, pDataNode); 1144 CreateDataBinding(pFormNode, pDataNode, TRUE);
1164 } 1145 }
1165 } 1146 }
1166 if (!pDataNode) { 1147 if (!pDataNode)
1167 XFA_DataMerge_FormValueNode_MatchNoneCreateChild(pFormNode); 1148 FormValueNode_MatchNoneCreateChild(pFormNode);
1168 }
1169 } 1149 }
1170 break; 1150 break;
1171 case XFA_ATTRIBUTEENUM_DataRef: { 1151 case XFA_ATTRIBUTEENUM_DataRef: {
1172 bMatchRef = bDataRef; 1152 bMatchRef = bDataRef;
1173 bParentDataRef = TRUE; 1153 bParentDataRef = TRUE;
1174 if (!pDataNode && bDataRef) { 1154 if (!pDataNode && bDataRef) {
1175 CFX_WideStringC wsRef = 1155 CFX_WideStringC wsRef =
1176 pTemplateNodeBind->GetCData(XFA_ATTRIBUTE_Ref); 1156 pTemplateNodeBind->GetCData(XFA_ATTRIBUTE_Ref);
1177 uint32_t dFlags = 1157 uint32_t dFlags =
1178 XFA_RESOLVENODE_Children | XFA_RESOLVENODE_CreateNode; 1158 XFA_RESOLVENODE_Children | XFA_RESOLVENODE_CreateNode;
1179 XFA_RESOLVENODE_RS rs; 1159 XFA_RESOLVENODE_RS rs;
1180 pDocument->GetScriptContext()->ResolveObjects(pDataScope, wsRef, rs, 1160 pDocument->GetScriptContext()->ResolveObjects(pDataScope, wsRef, rs,
1181 dFlags, pTemplateNode); 1161 dFlags, pTemplateNode);
1182 CXFA_Object* pObject = 1162 CXFA_Object* pObject =
1183 (rs.nodes.GetSize() > 0) ? rs.nodes[0] : nullptr; 1163 (rs.nodes.GetSize() > 0) ? rs.nodes[0] : nullptr;
1184 pDataNode = ToNode(pObject); 1164 pDataNode = ToNode(pObject);
1185 if (pDataNode) { 1165 if (pDataNode) {
1186 XFA_DataMerge_CreateDataBinding( 1166 CreateDataBinding(pFormNode, pDataNode,
1187 pFormNode, pDataNode, 1167 rs.dwFlags == XFA_RESOVENODE_RSTYPE_ExistNodes);
1188 rs.dwFlags == XFA_RESOVENODE_RSTYPE_ExistNodes);
1189 } else { 1168 } else {
1190 XFA_DataMerge_FormValueNode_MatchNoneCreateChild(pFormNode); 1169 FormValueNode_MatchNoneCreateChild(pFormNode);
1191 } 1170 }
1192 } 1171 }
1193 } break; 1172 break;
1173 }
1194 default: 1174 default:
1195 break; 1175 break;
1196 } 1176 }
1197 } 1177 }
1178
1198 if (bMatchRef && 1179 if (bMatchRef &&
1199 (eType == XFA_Element::Subform || eType == XFA_Element::SubformSet || 1180 (eType == XFA_Element::Subform || eType == XFA_Element::SubformSet ||
1200 eType == XFA_Element::Area || eType == XFA_Element::PageArea || 1181 eType == XFA_Element::Area || eType == XFA_Element::PageArea ||
1201 eType == XFA_Element::PageSet)) { 1182 eType == XFA_Element::PageSet)) {
1202 for (CXFA_Node* pFormChild = 1183 for (CXFA_Node* pFormChild =
1203 pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild); 1184 pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild);
1204 pFormChild; 1185 pFormChild;
1205 pFormChild = pFormChild->GetNodeItem(XFA_NODEITEM_NextSibling)) { 1186 pFormChild = pFormChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
1206 if (!pFormChild->IsContainerNode()) 1187 if (!pFormChild->IsContainerNode())
1207 continue; 1188 continue;
1208 if (pFormChild->IsUnusedNode()) 1189 if (pFormChild->IsUnusedNode())
1209 continue; 1190 continue;
1210 1191
1211 XFA_DataMerge_UpdateBindingRelations(pDocument, pFormChild, 1192 UpdateBindingRelations(pDocument, pFormChild,
1212 pDataNode ? pDataNode : pDataScope, 1193 pDataNode ? pDataNode : pDataScope, bDataRef,
1213 bDataRef, bParentDataRef); 1194 bParentDataRef);
1214 } 1195 }
1215 } 1196 }
1216 } 1197 }
1198
1199 void UpdateDataRelation(CXFA_Node* pDataNode, CXFA_Node* pDataDescriptionNode) {
1200 ASSERT(pDataDescriptionNode);
1201 for (CXFA_Node* pDataChild = pDataNode->GetNodeItem(XFA_NODEITEM_FirstChild);
1202 pDataChild;
1203 pDataChild = pDataChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
1204 uint32_t dwNameHash = pDataChild->GetNameHash();
1205 if (!dwNameHash)
1206 continue;
1207
1208 CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_DDGroup>
1209 sIterator(pDataDescriptionNode);
1210 for (CXFA_Node* pDDGroupNode = sIterator.GetCurrent(); pDDGroupNode;
1211 pDDGroupNode = sIterator.MoveToNext()) {
1212 if (pDDGroupNode != pDataDescriptionNode) {
1213 if (pDDGroupNode->GetElementType() != XFA_Element::DataGroup)
1214 continue;
1215
1216 CFX_WideString wsNamespace;
1217 if (!pDDGroupNode->TryNamespace(wsNamespace) ||
1218 wsNamespace != FX_WSTRC(L"http://ns.adobe.com/data-description/")) {
1219 continue;
1220 }
1221 }
1222 CXFA_Node* pDDNode = pDDGroupNode->GetFirstChildByName(dwNameHash);
1223 if (!pDDNode)
1224 continue;
1225 if (pDDNode->GetElementType() != pDataChild->GetElementType())
1226 break;
1227
1228 pDataChild->SetDataDescriptionNode(pDDNode);
1229 UpdateDataRelation(pDataChild, pDDNode);
1230 break;
1231 }
1232 }
1233 }
1234
1235 } // namespace
1236
1237 CXFA_Node* XFA_DataMerge_FindFormDOMInstance(CXFA_Document* pDocument,
1238 XFA_Element eType,
1239 uint32_t dwNameHash,
1240 CXFA_Node* pFormParent) {
1241 CXFA_Node* pFormChild = pFormParent->GetNodeItem(XFA_NODEITEM_FirstChild);
1242 for (; pFormChild;
1243 pFormChild = pFormChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
1244 if (pFormChild->GetElementType() == eType &&
1245 pFormChild->GetNameHash() == dwNameHash && pFormChild->IsUnusedNode()) {
1246 return pFormChild;
1247 }
1248 }
1249 return nullptr;
1250 }
1251
1252 CXFA_Node* XFA_NodeMerge_CloneOrMergeContainer(CXFA_Document* pDocument,
1253 CXFA_Node* pFormParent,
1254 CXFA_Node* pTemplateNode,
1255 FX_BOOL bRecursive,
1256 CXFA_NodeArray* pSubformArray) {
1257 CXFA_Node* pExistingNode = nullptr;
1258 if (!pSubformArray) {
1259 pExistingNode = XFA_DataMerge_FindFormDOMInstance(
1260 pDocument, pTemplateNode->GetElementType(),
1261 pTemplateNode->GetNameHash(), pFormParent);
1262 } else if (pSubformArray->GetSize() > 0) {
1263 pExistingNode = pSubformArray->GetAt(0);
1264 pSubformArray->RemoveAt(0);
1265 }
1266
1267 if (pExistingNode) {
1268 if (pSubformArray) {
1269 pFormParent->InsertChild(pExistingNode);
1270 } else if (pExistingNode->IsContainerNode()) {
1271 pFormParent->RemoveChild(pExistingNode);
1272 pFormParent->InsertChild(pExistingNode);
1273 }
1274 pExistingNode->ClearFlag(XFA_NodeFlag_UnusedNode);
1275 pExistingNode->SetTemplateNode(pTemplateNode);
1276 if (bRecursive && pExistingNode->GetElementType() != XFA_Element::Items) {
1277 for (CXFA_Node* pTemplateChild =
1278 pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
1279 pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
1280 XFA_NODEITEM_NextSibling)) {
1281 if (NeedGenerateForm(pTemplateChild, TRUE)) {
1282 XFA_NodeMerge_CloneOrMergeContainer(
1283 pDocument, pExistingNode, pTemplateChild, bRecursive, nullptr);
1284 }
1285 }
1286 }
1287 pExistingNode->SetFlag(XFA_NodeFlag_Initialized, true);
1288 return pExistingNode;
1289 }
1290
1291 CXFA_Node* pNewNode = pTemplateNode->CloneTemplateToForm(FALSE);
1292 pFormParent->InsertChild(pNewNode, nullptr);
1293 if (bRecursive) {
1294 for (CXFA_Node* pTemplateChild =
1295 pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
1296 pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
1297 XFA_NODEITEM_NextSibling)) {
1298 if (NeedGenerateForm(pTemplateChild, TRUE)) {
1299 CXFA_Node* pNewChild = pTemplateChild->CloneTemplateToForm(TRUE);
1300 pNewNode->InsertChild(pNewChild, nullptr);
1301 }
1302 }
1303 }
1304 return pNewNode;
1305 }
1306
1217 CXFA_Node* XFA_DataMerge_FindDataScope(CXFA_Node* pParentFormNode) { 1307 CXFA_Node* XFA_DataMerge_FindDataScope(CXFA_Node* pParentFormNode) {
1218 for (CXFA_Node* pRootBoundNode = pParentFormNode; 1308 for (CXFA_Node* pRootBoundNode = pParentFormNode;
1219 pRootBoundNode && pRootBoundNode->IsContainerNode(); 1309 pRootBoundNode && pRootBoundNode->IsContainerNode();
1220 pRootBoundNode = pRootBoundNode->GetNodeItem(XFA_NODEITEM_Parent)) { 1310 pRootBoundNode = pRootBoundNode->GetNodeItem(XFA_NODEITEM_Parent)) {
1221 CXFA_Node* pDataScope = pRootBoundNode->GetBindData(); 1311 CXFA_Node* pDataScope = pRootBoundNode->GetBindData();
1222 if (pDataScope) { 1312 if (pDataScope)
1223 return pDataScope; 1313 return pDataScope;
1224 }
1225 } 1314 }
1226 return ToNode( 1315 return ToNode(
1227 pParentFormNode->GetDocument()->GetXFAObject(XFA_HASHCODE_Data)); 1316 pParentFormNode->GetDocument()->GetXFAObject(XFA_HASHCODE_Data));
1228 } 1317 }
1318
1319 CXFA_Node* CXFA_Document::DataMerge_CopyContainer(CXFA_Node* pTemplateNode,
1320 CXFA_Node* pFormNode,
1321 CXFA_Node* pDataScope,
1322 FX_BOOL bOneInstance,
1323 FX_BOOL bDataMerge,
1324 FX_BOOL bUpLevel) {
1325 switch (pTemplateNode->GetElementType()) {
1326 case XFA_Element::SubformSet:
1327 case XFA_Element::Subform:
1328 case XFA_Element::Area:
1329 case XFA_Element::PageArea:
1330 return CopyContainer_SubformSet(this, pTemplateNode, pFormNode,
1331 pDataScope, bOneInstance, bDataMerge);
1332 case XFA_Element::ExclGroup:
1333 case XFA_Element::Field:
1334 case XFA_Element::Draw:
1335 case XFA_Element::ContentArea:
1336 return CopyContainer_Field(this, pTemplateNode, pFormNode, pDataScope,
1337 bDataMerge, bUpLevel);
1338 case XFA_Element::PageSet:
1339 break;
Lei Zhang 2016/07/07 19:23:42 Not needed
dsinclair 2016/07/07 19:36:16 Done.
1340 case XFA_Element::Variables:
1341 break;
1342 default:
1343 ASSERT(FALSE);
1344 break;
1345 }
1346 return nullptr;
1347 }
1348
1229 void CXFA_Document::DataMerge_UpdateBindingRelations( 1349 void CXFA_Document::DataMerge_UpdateBindingRelations(
1230 CXFA_Node* pFormUpdateRoot) { 1350 CXFA_Node* pFormUpdateRoot) {
1231 CXFA_Node* pDataScope = XFA_DataMerge_FindDataScope( 1351 CXFA_Node* pDataScope = XFA_DataMerge_FindDataScope(
1232 pFormUpdateRoot->GetNodeItem(XFA_NODEITEM_Parent)); 1352 pFormUpdateRoot->GetNodeItem(XFA_NODEITEM_Parent));
1233 if (!pDataScope) { 1353 if (!pDataScope)
1234 return; 1354 return;
1235 } 1355
1236 XFA_DataMerge_UpdateBindingRelations(this, pFormUpdateRoot, pDataScope, FALSE, 1356 UpdateBindingRelations(this, pFormUpdateRoot, pDataScope, FALSE, FALSE);
1237 FALSE); 1357 UpdateBindingRelations(this, pFormUpdateRoot, pDataScope, TRUE, FALSE);
1238 XFA_DataMerge_UpdateBindingRelations(this, pFormUpdateRoot, pDataScope, TRUE,
1239 FALSE);
1240 } 1358 }
1359
1241 CXFA_Node* CXFA_Document::GetNotBindNode(CXFA_ObjArray& arrayNodes) { 1360 CXFA_Node* CXFA_Document::GetNotBindNode(CXFA_ObjArray& arrayNodes) {
1242 for (int32_t i = 0; i < arrayNodes.GetSize(); i++) { 1361 for (int32_t i = 0; i < arrayNodes.GetSize(); i++) {
1243 CXFA_Node* pNode = arrayNodes[i]->AsNode(); 1362 CXFA_Node* pNode = arrayNodes[i]->AsNode();
1244 if (pNode && !pNode->HasBindItem()) 1363 if (pNode && !pNode->HasBindItem())
1245 return pNode; 1364 return pNode;
1246 } 1365 }
1247 return nullptr; 1366 return nullptr;
1248 } 1367 }
1368
1249 void CXFA_Document::DoDataMerge() { 1369 void CXFA_Document::DoDataMerge() {
1250 CXFA_Node* pDatasetsRoot = ToNode(GetXFAObject(XFA_HASHCODE_Datasets)); 1370 CXFA_Node* pDatasetsRoot = ToNode(GetXFAObject(XFA_HASHCODE_Datasets));
1251 if (!pDatasetsRoot) { 1371 if (!pDatasetsRoot) {
1252 CFDE_XMLElement* pDatasetsXMLNode = new CFDE_XMLElement(L"xfa:datasets"); 1372 CFDE_XMLElement* pDatasetsXMLNode = new CFDE_XMLElement(L"xfa:datasets");
1253 pDatasetsXMLNode->SetString(L"xmlns:xfa", 1373 pDatasetsXMLNode->SetString(L"xmlns:xfa",
1254 L"http://www.xfa.org/schema/xfa-data/1.0/"); 1374 L"http://www.xfa.org/schema/xfa-data/1.0/");
1255 pDatasetsRoot = CreateNode(XFA_XDPPACKET_Datasets, XFA_Element::DataModel); 1375 pDatasetsRoot = CreateNode(XFA_XDPPACKET_Datasets, XFA_Element::DataModel);
1256 pDatasetsRoot->SetCData(XFA_ATTRIBUTE_Name, L"datasets"); 1376 pDatasetsRoot->SetCData(XFA_ATTRIBUTE_Name, L"datasets");
1257 m_pRootNode->GetXMLMappingNode()->InsertChildNode(pDatasetsXMLNode); 1377 m_pRootNode->GetXMLMappingNode()->InsertChildNode(pDatasetsXMLNode);
1258 m_pRootNode->InsertChild(pDatasetsRoot); 1378 m_pRootNode->InsertChild(pDatasetsRoot);
1259 pDatasetsRoot->SetXMLMappingNode(pDatasetsXMLNode); 1379 pDatasetsRoot->SetXMLMappingNode(pDatasetsXMLNode);
1260 } 1380 }
1261 CXFA_Node *pDataRoot = nullptr, *pDDRoot = nullptr; 1381 CXFA_Node *pDataRoot = nullptr, *pDDRoot = nullptr;
1262 CFX_WideString wsDatasetsURI; 1382 CFX_WideString wsDatasetsURI;
1263 pDatasetsRoot->TryNamespace(wsDatasetsURI); 1383 pDatasetsRoot->TryNamespace(wsDatasetsURI);
1264 for (CXFA_Node* pChildNode = 1384 for (CXFA_Node* pChildNode =
1265 pDatasetsRoot->GetNodeItem(XFA_NODEITEM_FirstChild); 1385 pDatasetsRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
1266 pChildNode; 1386 pChildNode;
1267 pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling)) { 1387 pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
1268 if (pChildNode->GetElementType() != XFA_Element::DataGroup) { 1388 if (pChildNode->GetElementType() != XFA_Element::DataGroup)
1269 continue; 1389 continue;
1270 } 1390
1271 CFX_WideString wsNamespaceURI; 1391 CFX_WideString wsNamespaceURI;
1272 if (!pDDRoot && pChildNode->GetNameHash() == XFA_HASHCODE_DataDescription) { 1392 if (!pDDRoot && pChildNode->GetNameHash() == XFA_HASHCODE_DataDescription) {
1273 if (!pChildNode->TryNamespace(wsNamespaceURI)) { 1393 if (!pChildNode->TryNamespace(wsNamespaceURI))
1274 continue; 1394 continue;
1275 } 1395 if (wsNamespaceURI == FX_WSTRC(L"http://ns.adobe.com/data-description/"))
1276 if (wsNamespaceURI ==
1277 FX_WSTRC(L"http://ns.adobe.com/data-description/")) {
1278 pDDRoot = pChildNode; 1396 pDDRoot = pChildNode;
1279 }
1280 } else if (!pDataRoot && pChildNode->GetNameHash() == XFA_HASHCODE_Data) { 1397 } else if (!pDataRoot && pChildNode->GetNameHash() == XFA_HASHCODE_Data) {
1281 if (!pChildNode->TryNamespace(wsNamespaceURI)) { 1398 if (!pChildNode->TryNamespace(wsNamespaceURI))
1282 continue; 1399 continue;
1283 } 1400 if (wsNamespaceURI == wsDatasetsURI)
1284 if (wsNamespaceURI == wsDatasetsURI) {
1285 pDataRoot = pChildNode; 1401 pDataRoot = pChildNode;
1286 }
1287 } 1402 }
1288 if (pDataRoot && pDDRoot) { 1403 if (pDataRoot && pDDRoot)
1289 break; 1404 break;
1290 }
1291 } 1405 }
1406
1292 if (!pDataRoot) { 1407 if (!pDataRoot) {
1293 CFDE_XMLElement* pDataRootXMLNode = new CFDE_XMLElement(L"xfa:data"); 1408 CFDE_XMLElement* pDataRootXMLNode = new CFDE_XMLElement(L"xfa:data");
1294 pDataRoot = CreateNode(XFA_XDPPACKET_Datasets, XFA_Element::DataGroup); 1409 pDataRoot = CreateNode(XFA_XDPPACKET_Datasets, XFA_Element::DataGroup);
1295 pDataRoot->SetCData(XFA_ATTRIBUTE_Name, L"data"); 1410 pDataRoot->SetCData(XFA_ATTRIBUTE_Name, L"data");
1296 pDataRoot->SetXMLMappingNode(pDataRootXMLNode); 1411 pDataRoot->SetXMLMappingNode(pDataRootXMLNode);
1297 pDatasetsRoot->InsertChild(pDataRoot); 1412 pDatasetsRoot->InsertChild(pDataRoot);
1298 } 1413 }
1414
1299 CXFA_Node* pDataTopLevel = 1415 CXFA_Node* pDataTopLevel =
1300 pDataRoot->GetFirstChildByClass(XFA_Element::DataGroup); 1416 pDataRoot->GetFirstChildByClass(XFA_Element::DataGroup);
1301 uint32_t dwNameHash = pDataTopLevel ? pDataTopLevel->GetNameHash() : 0; 1417 uint32_t dwNameHash = pDataTopLevel ? pDataTopLevel->GetNameHash() : 0;
1302 CXFA_Node* pTemplateRoot = 1418 CXFA_Node* pTemplateRoot =
1303 m_pRootNode->GetFirstChildByClass(XFA_Element::Template); 1419 m_pRootNode->GetFirstChildByClass(XFA_Element::Template);
1304 if (!pTemplateRoot) { 1420 if (!pTemplateRoot)
1305 return; 1421 return;
1306 } 1422
1307 CXFA_Node* pTemplateChosen = 1423 CXFA_Node* pTemplateChosen =
1308 dwNameHash != 0 ? pTemplateRoot->GetFirstChildByName(dwNameHash) 1424 dwNameHash != 0 ? pTemplateRoot->GetFirstChildByName(dwNameHash)
1309 : nullptr; 1425 : nullptr;
1310 if (!pTemplateChosen || 1426 if (!pTemplateChosen ||
1311 pTemplateChosen->GetElementType() != XFA_Element::Subform) { 1427 pTemplateChosen->GetElementType() != XFA_Element::Subform) {
1312 pTemplateChosen = pTemplateRoot->GetFirstChildByClass(XFA_Element::Subform); 1428 pTemplateChosen = pTemplateRoot->GetFirstChildByClass(XFA_Element::Subform);
1313 } 1429 }
1314 if (!pTemplateChosen) { 1430 if (!pTemplateChosen)
1315 return; 1431 return;
1316 } 1432
1317 CXFA_Node* pFormRoot = m_pRootNode->GetFirstChildByClass(XFA_Element::Form); 1433 CXFA_Node* pFormRoot = m_pRootNode->GetFirstChildByClass(XFA_Element::Form);
1318 FX_BOOL bEmptyForm = FALSE; 1434 FX_BOOL bEmptyForm = FALSE;
1319 if (!pFormRoot) { 1435 if (!pFormRoot) {
1320 bEmptyForm = TRUE; 1436 bEmptyForm = TRUE;
1321 pFormRoot = CreateNode(XFA_XDPPACKET_Form, XFA_Element::Form); 1437 pFormRoot = CreateNode(XFA_XDPPACKET_Form, XFA_Element::Form);
1322 ASSERT(pFormRoot); 1438 ASSERT(pFormRoot);
1323 pFormRoot->SetCData(XFA_ATTRIBUTE_Name, L"form"); 1439 pFormRoot->SetCData(XFA_ATTRIBUTE_Name, L"form");
1324 m_pRootNode->InsertChild(pFormRoot, nullptr); 1440 m_pRootNode->InsertChild(pFormRoot, nullptr);
1325 } else { 1441 } else {
1326 CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode> 1442 CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode>
1327 sIterator(pFormRoot); 1443 sIterator(pFormRoot);
1328 for (CXFA_Node* pNode = sIterator.MoveToNext(); pNode; 1444 for (CXFA_Node* pNode = sIterator.MoveToNext(); pNode;
1329 pNode = sIterator.MoveToNext()) { 1445 pNode = sIterator.MoveToNext()) {
1330 pNode->SetFlag(XFA_NodeFlag_UnusedNode, true); 1446 pNode->SetFlag(XFA_NodeFlag_UnusedNode, true);
1331 } 1447 }
1332 } 1448 }
1449
1333 CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer( 1450 CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer(
1334 this, pFormRoot, pTemplateChosen, FALSE); 1451 this, pFormRoot, pTemplateChosen, FALSE, nullptr);
1335 ASSERT(pSubformSetNode); 1452 ASSERT(pSubformSetNode);
1336 if (!pDataTopLevel) { 1453 if (!pDataTopLevel) {
1337 CFX_WideStringC wsFormName = pSubformSetNode->GetCData(XFA_ATTRIBUTE_Name); 1454 CFX_WideStringC wsFormName = pSubformSetNode->GetCData(XFA_ATTRIBUTE_Name);
1338 CFX_WideString wsDataTopLevelName(wsFormName.IsEmpty() ? L"form" 1455 CFX_WideString wsDataTopLevelName(wsFormName.IsEmpty() ? L"form"
1339 : wsFormName); 1456 : wsFormName);
1340 CFDE_XMLElement* pDataTopLevelXMLNode = 1457 CFDE_XMLElement* pDataTopLevelXMLNode =
1341 new CFDE_XMLElement(wsDataTopLevelName); 1458 new CFDE_XMLElement(wsDataTopLevelName);
1342 1459
1343 pDataTopLevel = CreateNode(XFA_XDPPACKET_Datasets, XFA_Element::DataGroup); 1460 pDataTopLevel = CreateNode(XFA_XDPPACKET_Datasets, XFA_Element::DataGroup);
1344 pDataTopLevel->SetCData(XFA_ATTRIBUTE_Name, wsDataTopLevelName); 1461 pDataTopLevel->SetCData(XFA_ATTRIBUTE_Name, wsDataTopLevelName);
1345 pDataTopLevel->SetXMLMappingNode(pDataTopLevelXMLNode); 1462 pDataTopLevel->SetXMLMappingNode(pDataTopLevelXMLNode);
1346 CXFA_Node* pBeforeNode = pDataRoot->GetNodeItem(XFA_NODEITEM_FirstChild); 1463 CXFA_Node* pBeforeNode = pDataRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
1347 pDataRoot->InsertChild(pDataTopLevel, pBeforeNode); 1464 pDataRoot->InsertChild(pDataTopLevel, pBeforeNode);
1348 } 1465 }
1466
1349 ASSERT(pDataTopLevel); 1467 ASSERT(pDataTopLevel);
1350 XFA_DataMerge_CreateDataBinding(pSubformSetNode, pDataTopLevel); 1468 CreateDataBinding(pSubformSetNode, pDataTopLevel, TRUE);
1351 for (CXFA_Node* pTemplateChild = 1469 for (CXFA_Node* pTemplateChild =
1352 pTemplateChosen->GetNodeItem(XFA_NODEITEM_FirstChild); 1470 pTemplateChosen->GetNodeItem(XFA_NODEITEM_FirstChild);
1353 pTemplateChild; 1471 pTemplateChild;
1354 pTemplateChild = pTemplateChild->GetNodeItem(XFA_NODEITEM_NextSibling)) { 1472 pTemplateChild = pTemplateChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
1355 if (XFA_NeedGenerateForm(pTemplateChild)) { 1473 if (NeedGenerateForm(pTemplateChild, TRUE)) {
1356 XFA_NodeMerge_CloneOrMergeContainer(this, pSubformSetNode, pTemplateChild, 1474 XFA_NodeMerge_CloneOrMergeContainer(this, pSubformSetNode, pTemplateChild,
1357 TRUE); 1475 TRUE, nullptr);
1358 } else if (pTemplateChild->IsContainerNode()) { 1476 } else if (pTemplateChild->IsContainerNode()) {
1359 DataMerge_CopyContainer(pTemplateChild, pSubformSetNode, pDataTopLevel); 1477 DataMerge_CopyContainer(pTemplateChild, pSubformSetNode, pDataTopLevel);
1360 } 1478 }
1361 } 1479 }
1362 if (pDDRoot) { 1480 if (pDDRoot)
1363 XFA_DataDescription_UpdateDataRelation(pDataRoot, pDDRoot); 1481 UpdateDataRelation(pDataRoot, pDDRoot);
1364 } 1482
1365 DataMerge_UpdateBindingRelations(pSubformSetNode); 1483 DataMerge_UpdateBindingRelations(pSubformSetNode);
1366 CXFA_Node* pPageSetNode = 1484 CXFA_Node* pPageSetNode =
1367 pSubformSetNode->GetFirstChildByClass(XFA_Element::PageSet); 1485 pSubformSetNode->GetFirstChildByClass(XFA_Element::PageSet);
1368 while (pPageSetNode) { 1486 while (pPageSetNode) {
1369 m_pPendingPageSet.Add(pPageSetNode); 1487 m_pPendingPageSet.Add(pPageSetNode);
1370 CXFA_Node* pNextPageSetNode = 1488 CXFA_Node* pNextPageSetNode =
1371 pPageSetNode->GetNextSameClassSibling(XFA_Element::PageSet); 1489 pPageSetNode->GetNextSameClassSibling(XFA_Element::PageSet);
1372 pSubformSetNode->RemoveChild(pPageSetNode); 1490 pSubformSetNode->RemoveChild(pPageSetNode);
1373 pPageSetNode = pNextPageSetNode; 1491 pPageSetNode = pNextPageSetNode;
1374 } 1492 }
1375 if (!bEmptyForm) { 1493
1376 CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode> 1494 if (bEmptyForm)
1377 sIterator(pFormRoot); 1495 return;
1378 CXFA_Node* pNode = sIterator.MoveToNext(); 1496
1379 while (pNode) { 1497 CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode> sIterator(
1380 if (pNode->IsUnusedNode()) { 1498 pFormRoot);
1381 if (pNode->IsContainerNode() || 1499 CXFA_Node* pNode = sIterator.MoveToNext();
1382 pNode->GetElementType() == XFA_Element::InstanceManager) { 1500 while (pNode) {
1383 CXFA_Node* pNext = sIterator.SkipChildrenAndMoveToNext(); 1501 if (pNode->IsUnusedNode()) {
1384 pNode->GetNodeItem(XFA_NODEITEM_Parent)->RemoveChild(pNode); 1502 if (pNode->IsContainerNode() ||
1385 pNode = pNext; 1503 pNode->GetElementType() == XFA_Element::InstanceManager) {
1386 } else { 1504 CXFA_Node* pNext = sIterator.SkipChildrenAndMoveToNext();
1387 pNode->ClearFlag(XFA_NodeFlag_UnusedNode); 1505 pNode->GetNodeItem(XFA_NODEITEM_Parent)->RemoveChild(pNode);
1388 pNode->SetFlag(XFA_NodeFlag_Initialized, true); 1506 pNode = pNext;
1389 pNode = sIterator.MoveToNext();
1390 }
1391 } else { 1507 } else {
1508 pNode->ClearFlag(XFA_NodeFlag_UnusedNode);
1392 pNode->SetFlag(XFA_NodeFlag_Initialized, true); 1509 pNode->SetFlag(XFA_NodeFlag_Initialized, true);
1393 pNode = sIterator.MoveToNext(); 1510 pNode = sIterator.MoveToNext();
1394 } 1511 }
1512 } else {
1513 pNode->SetFlag(XFA_NodeFlag_Initialized, true);
1514 pNode = sIterator.MoveToNext();
1395 } 1515 }
1396 } 1516 }
1397 } 1517 }
1518
1398 void CXFA_Document::DoDataRemerge(FX_BOOL bDoDataMerge) { 1519 void CXFA_Document::DoDataRemerge(FX_BOOL bDoDataMerge) {
1399 CXFA_Node* pFormRoot = ToNode(GetXFAObject(XFA_HASHCODE_Form)); 1520 CXFA_Node* pFormRoot = ToNode(GetXFAObject(XFA_HASHCODE_Form));
1400 if (pFormRoot) { 1521 if (pFormRoot) {
1401 while (CXFA_Node* pNode = pFormRoot->GetNodeItem(XFA_NODEITEM_FirstChild)) { 1522 while (CXFA_Node* pNode = pFormRoot->GetNodeItem(XFA_NODEITEM_FirstChild))
1402 pFormRoot->RemoveChild(pNode); 1523 pFormRoot->RemoveChild(pNode);
1403 }
1404 pFormRoot->SetObject(XFA_ATTRIBUTE_BindingNode, nullptr); 1524 pFormRoot->SetObject(XFA_ATTRIBUTE_BindingNode, nullptr);
1405 } 1525 }
1406 XFA_DataMerge_ClearGlobalBinding(this); 1526 m_rgGlobalBinding.RemoveAll();
1407 if (bDoDataMerge) { 1527 if (bDoDataMerge)
1408 DoDataMerge(); 1528 DoDataMerge();
1409 } 1529
1410 CXFA_LayoutProcessor* pLayoutProcessor = GetLayoutProcessor(); 1530 CXFA_LayoutProcessor* pLayoutProcessor = GetLayoutProcessor();
1411 pLayoutProcessor->SetForceReLayout(TRUE); 1531 pLayoutProcessor->SetForceReLayout(TRUE);
1412 } 1532 }
OLDNEW
« no previous file with comments | « xfa/fxfa/parser/xfa_document_datamerger_imp.h ('k') | xfa/fxfa/parser/xfa_layout_pagemgr_new.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698