OLD | NEW |
---|---|
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 } |
OLD | NEW |