Merge to XFA: Use stdint.h types throughout PDFium.
[pdfium.git] / xfa / src / fxfa / src / parser / xfa_objectacc_imp.cpp
1 // Copyright 2014 PDFium Authors. All rights reserved.\r
2 // Use of this source code is governed by a BSD-style license that can be\r
3 // found in the LICENSE file.\r
4 \r
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com\r
6 \r
7 #include "../../../foxitlib.h"\r
8 #include "../common/xfa_utils.h"\r
9 #include "../common/xfa_object.h"\r
10 #include "../common/xfa_document.h"\r
11 #include "../common/xfa_parser.h"\r
12 #include "../common/xfa_script.h"\r
13 #include "../common/xfa_docdata.h"\r
14 #include "../common/xfa_doclayout.h"\r
15 #include "../common/xfa_debug.h"\r
16 #include "../common/xfa_localemgr.h"\r
17 #include "../common/xfa_fm2jsapi.h"\r
18 #include "xfa_debug_parser.h"\r
19 static FX_ARGB  XFA_WStringToColor(FX_WSTR wsValue)\r
20 {\r
21     uint8_t r = 0, g = 0, b = 0;\r
22     if (wsValue.GetLength() == 0) {\r
23         return 0xff000000;\r
24     }\r
25     int cc = 0;\r
26     FX_LPCWSTR str = wsValue.GetPtr();\r
27     int len = wsValue.GetLength();\r
28     while (XFA_IsSpace(str[cc]) && cc < len) {\r
29         cc++;\r
30     }\r
31     if (cc >= len) {\r
32         return 0xff000000;\r
33     }\r
34     while (cc < len) {\r
35         if (str[cc] == ',' || !XFA_IsDigit(str[cc])) {\r
36             break;\r
37         }\r
38         r = r * 10 + str[cc] - '0';\r
39         cc ++;\r
40     }\r
41     if (cc < len && str[cc] == ',') {\r
42         cc ++;\r
43         while (XFA_IsSpace(str[cc]) && cc < len) {\r
44             cc++;\r
45         }\r
46         while (cc < len) {\r
47             if (str[cc] == ',' || !XFA_IsDigit(str[cc])) {\r
48                 break;\r
49             }\r
50             g = g * 10 + str[cc] - '0';\r
51             cc ++;\r
52         }\r
53         if (cc < len && str[cc] == ',') {\r
54             cc ++;\r
55             while (XFA_IsSpace(str[cc]) && cc < len) {\r
56                 cc++;\r
57             }\r
58             while (cc < len) {\r
59                 if (str[cc] == ',' || !XFA_IsDigit(str[cc])) {\r
60                     break;\r
61                 }\r
62                 b = b * 10 + str[cc] - '0';\r
63                 cc ++;\r
64             }\r
65         }\r
66     }\r
67     return (0xff << 24) | (r << 16) | (g << 8) | b;\r
68 }\r
69 XFA_ELEMENT CXFA_Data::GetClassID() const\r
70 {\r
71     return m_pNode ? m_pNode->GetClassID() : XFA_ELEMENT_UNKNOWN;\r
72 }\r
73 FX_BOOL CXFA_Data::TryMeasure(XFA_ATTRIBUTE eAttr, FX_FLOAT &fValue, FX_BOOL bUseDefault ) const\r
74 {\r
75     CXFA_Measurement ms;\r
76     if (m_pNode->TryMeasure(eAttr, ms, bUseDefault)) {\r
77         fValue = ms.ToUnit(XFA_UNIT_Pt);\r
78         return TRUE;\r
79     }\r
80     return FALSE;\r
81 }\r
82 FX_BOOL CXFA_Data::SetMeasure(XFA_ATTRIBUTE eAttr, FX_FLOAT fValue)\r
83 {\r
84     CXFA_Measurement ms(fValue, XFA_UNIT_Pt);\r
85     return m_pNode->SetMeasure(eAttr, ms);\r
86 }\r
87 CXFA_Fill::CXFA_Fill(CXFA_Node* pNode)\r
88     : CXFA_Data(pNode)\r
89 {\r
90 }\r
91 CXFA_Fill::~CXFA_Fill()\r
92 {\r
93 }\r
94 int32_t CXFA_Fill::GetPresence()\r
95 {\r
96     return m_pNode->GetEnum(XFA_ATTRIBUTE_Presence);\r
97 }\r
98 void CXFA_Fill::SetColor(FX_ARGB color)\r
99 {\r
100     CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Color);\r
101     CFX_WideString wsColor;\r
102     int a, r, g, b;\r
103     ArgbDecode(color, a, r, g, b);\r
104     wsColor.Format(L"%d,%d,%d", r, g, b);\r
105     pNode->SetCData(XFA_ATTRIBUTE_Value, wsColor);\r
106 }\r
107 FX_ARGB CXFA_Fill::GetColor(FX_BOOL bText)\r
108 {\r
109     if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_ELEMENT_Color)) {\r
110         CFX_WideStringC wsColor;\r
111         if (pNode->TryCData(XFA_ATTRIBUTE_Value, wsColor, FALSE)) {\r
112             return XFA_WStringToColor(wsColor);\r
113         }\r
114     }\r
115     if (bText) {\r
116         return 0xFF000000;\r
117     }\r
118     return 0xFFFFFFFF;\r
119 }\r
120 int32_t CXFA_Fill::GetFillType()\r
121 {\r
122     CXFA_Node* pChild = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);\r
123     while (pChild) {\r
124         int32_t eType = pChild->GetClassID();\r
125         if (eType != XFA_ELEMENT_Color && eType != XFA_ELEMENT_Extras) {\r
126             return eType;\r
127         }\r
128         pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling);\r
129     }\r
130     return XFA_ELEMENT_Solid;\r
131 }\r
132 int32_t CXFA_Fill::GetPattern(FX_ARGB& foreColor)\r
133 {\r
134     CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Pattern);\r
135     if (CXFA_Node* pColor = pNode->GetChild(0, XFA_ELEMENT_Color)) {\r
136         CFX_WideStringC wsColor;\r
137         pColor->TryCData(XFA_ATTRIBUTE_Value, wsColor, FALSE);\r
138         foreColor = XFA_WStringToColor(wsColor);\r
139     } else {\r
140         foreColor = 0xFF000000;\r
141     }\r
142     return pNode->GetEnum(XFA_ATTRIBUTE_Type);\r
143 }\r
144 int32_t CXFA_Fill::GetStipple(FX_ARGB& stippleColor)\r
145 {\r
146     CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Stipple);\r
147     int32_t eAttr = 50;\r
148     pNode->TryInteger(XFA_ATTRIBUTE_Rate, eAttr);\r
149     if (CXFA_Node* pColor = pNode->GetChild(0, XFA_ELEMENT_Color)) {\r
150         CFX_WideStringC wsColor;\r
151         pColor->TryCData(XFA_ATTRIBUTE_Value, wsColor, FALSE);\r
152         stippleColor = XFA_WStringToColor(wsColor);\r
153     } else {\r
154         stippleColor = 0xFF000000;\r
155     }\r
156     return eAttr;\r
157 }\r
158 int32_t CXFA_Fill::GetLinear(FX_ARGB& endColor)\r
159 {\r
160     CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Linear);\r
161     XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_ToRight;\r
162     pNode->TryEnum(XFA_ATTRIBUTE_Type, eAttr);\r
163     if (CXFA_Node* pColor = pNode->GetChild(0, XFA_ELEMENT_Color)) {\r
164         CFX_WideStringC wsColor;\r
165         pColor->TryCData(XFA_ATTRIBUTE_Value, wsColor, FALSE);\r
166         endColor = XFA_WStringToColor(wsColor);\r
167     } else {\r
168         endColor = 0xFF000000;\r
169     }\r
170     return eAttr;\r
171 }\r
172 int32_t CXFA_Fill::GetRadial(FX_ARGB& endColor)\r
173 {\r
174     CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Radial);\r
175     XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_ToEdge;\r
176     pNode->TryEnum(XFA_ATTRIBUTE_Type, eAttr);\r
177     if (CXFA_Node* pColor = pNode->GetChild(0, XFA_ELEMENT_Color)) {\r
178         CFX_WideStringC wsColor;\r
179         pColor->TryCData(XFA_ATTRIBUTE_Value, wsColor, FALSE);\r
180         endColor = XFA_WStringToColor(wsColor);\r
181     } else {\r
182         endColor = 0xFF000000;\r
183     }\r
184     return eAttr;\r
185 }\r
186 FX_BOOL CXFA_Fill::SetPresence(int32_t iPresence)\r
187 {\r
188     return m_pNode->SetEnum(XFA_ATTRIBUTE_Presence, (XFA_ATTRIBUTEENUM)iPresence);\r
189 }\r
190 FX_BOOL CXFA_Fill::SetFillType(int32_t iType)\r
191 {\r
192     return FALSE;\r
193 }\r
194 FX_BOOL CXFA_Fill::SetPattern(int32_t iPattern, FX_ARGB foreColor)\r
195 {\r
196     CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Pattern);\r
197     CXFA_Node* pColor = pNode->GetProperty(0, XFA_ELEMENT_Color);\r
198     CFX_WideString wsColor;\r
199     int a, r, g, b;\r
200     ArgbDecode(foreColor, a, r, g, b);\r
201     wsColor.Format(L"%d,%d,%d", r, g, b);\r
202     pColor->SetCData(XFA_ATTRIBUTE_Value, wsColor);\r
203     return pNode->SetEnum(XFA_ATTRIBUTE_Type, (XFA_ATTRIBUTEENUM)iPattern);\r
204 }\r
205 FX_BOOL CXFA_Fill::SetStipple(int32_t iStipple, FX_ARGB stippleColor)\r
206 {\r
207     CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Stipple);\r
208     CXFA_Node* pColor = pNode->GetProperty(0, XFA_ELEMENT_Color);\r
209     CFX_WideString wsColor;\r
210     int a, r, g, b;\r
211     ArgbDecode(stippleColor, a, r, g, b);\r
212     wsColor.Format(L"%d,%d,%d", r, g, b);\r
213     pColor->SetCData(XFA_ATTRIBUTE_Value, wsColor);\r
214     return pNode->SetEnum(XFA_ATTRIBUTE_Rate, (XFA_ATTRIBUTEENUM)iStipple);\r
215 }\r
216 FX_BOOL CXFA_Fill::SetLinear(int32_t iLinear, FX_ARGB endColor)\r
217 {\r
218     CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Linear);\r
219     CXFA_Node* pColor = pNode->GetProperty(0, XFA_ELEMENT_Color);\r
220     CFX_WideString wsColor;\r
221     int a, r, g, b;\r
222     ArgbDecode(endColor, a, r, g, b);\r
223     wsColor.Format(L"%d,%d,%d", r, g, b);\r
224     pColor->SetCData(XFA_ATTRIBUTE_Value, wsColor);\r
225     return pNode->SetEnum(XFA_ATTRIBUTE_Type, (XFA_ATTRIBUTEENUM)iLinear);\r
226 }\r
227 FX_BOOL CXFA_Fill::SetRadial(int32_t iRadial, FX_ARGB endColor)\r
228 {\r
229     CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Radial);\r
230     CXFA_Node* pColor = pNode->GetProperty(0, XFA_ELEMENT_Color);\r
231     CFX_WideString wsColor;\r
232     int a, r, g, b;\r
233     ArgbDecode(endColor, a, r, g, b);\r
234     wsColor.Format(L"%d,%d,%d", r, g, b);\r
235     pColor->SetCData(XFA_ATTRIBUTE_Value, wsColor);\r
236     return pNode->SetEnum(XFA_ATTRIBUTE_Type, (XFA_ATTRIBUTEENUM)iRadial);\r
237 }\r
238 CXFA_Margin::CXFA_Margin(CXFA_Node* pNode)\r
239     : CXFA_Data(pNode)\r
240 {\r
241 }\r
242 FX_BOOL CXFA_Margin::GetLeftInset(FX_FLOAT &fInset, FX_FLOAT fDefInset ) const\r
243 {\r
244     fInset = fDefInset;\r
245     return TryMeasure(XFA_ATTRIBUTE_LeftInset, fInset);\r
246 }\r
247 FX_BOOL CXFA_Margin::GetTopInset(FX_FLOAT &fInset, FX_FLOAT fDefInset ) const\r
248 {\r
249     fInset = fDefInset;\r
250     return TryMeasure(XFA_ATTRIBUTE_TopInset, fInset);\r
251 }\r
252 FX_BOOL CXFA_Margin::GetRightInset(FX_FLOAT &fInset, FX_FLOAT fDefInset ) const\r
253 {\r
254     fInset = fDefInset;\r
255     return TryMeasure(XFA_ATTRIBUTE_RightInset, fInset);\r
256 }\r
257 FX_BOOL CXFA_Margin::GetBottomInset(FX_FLOAT &fInset, FX_FLOAT fDefInset ) const\r
258 {\r
259     fInset = fDefInset;\r
260     return TryMeasure(XFA_ATTRIBUTE_BottomInset, fInset);\r
261 }\r
262 FX_BOOL CXFA_Margin::SetLeftInset(FX_FLOAT fInset)\r
263 {\r
264     return SetMeasure(XFA_ATTRIBUTE_LeftInset, fInset);\r
265 }\r
266 FX_BOOL CXFA_Margin::SetTopInset(FX_FLOAT fInset)\r
267 {\r
268     return SetMeasure(XFA_ATTRIBUTE_TopInset, fInset);\r
269 }\r
270 FX_BOOL CXFA_Margin::SetRightInset(FX_FLOAT fInset)\r
271 {\r
272     return SetMeasure(XFA_ATTRIBUTE_RightInset, fInset);\r
273 }\r
274 FX_BOOL CXFA_Margin::SetBottomInset(FX_FLOAT fInset)\r
275 {\r
276     return SetMeasure(XFA_ATTRIBUTE_BottomInset, fInset);\r
277 }\r
278 CXFA_Font::CXFA_Font(CXFA_Node* pNode)\r
279     : CXFA_Data(pNode)\r
280 {\r
281 }\r
282 FX_FLOAT CXFA_Font::GetBaselineShift()\r
283 {\r
284     return m_pNode->GetMeasure(XFA_ATTRIBUTE_BaselineShift).ToUnit(XFA_UNIT_Pt);\r
285 }\r
286 FX_FLOAT CXFA_Font::GetHorizontalScale()\r
287 {\r
288     CFX_WideString wsValue;\r
289     m_pNode->TryCData(XFA_ATTRIBUTE_FontHorizontalScale, wsValue);\r
290     int32_t iScale = FXSYS_wtoi((FX_LPCWSTR)wsValue);\r
291     return iScale > 0 ? (FX_FLOAT)iScale : 100.0f;\r
292 }\r
293 FX_FLOAT CXFA_Font::GetVerticalScale()\r
294 {\r
295     CFX_WideString wsValue;\r
296     m_pNode->TryCData(XFA_ATTRIBUTE_FontVerticalScale, wsValue);\r
297     int32_t iScale = FXSYS_wtoi((FX_LPCWSTR)wsValue);\r
298     return iScale > 0 ? (FX_FLOAT)iScale : 100.0f;\r
299 }\r
300 FX_FLOAT CXFA_Font::GetLetterSpacing()\r
301 {\r
302     CFX_WideStringC wsValue;\r
303     if (!m_pNode->TryCData(XFA_ATTRIBUTE_LetterSpacing, wsValue)) {\r
304         return 0;\r
305     }\r
306     CXFA_Measurement ms(wsValue);\r
307     if (ms.GetUnit() == XFA_UNIT_Em) {\r
308         return ms.GetValue() * GetFontSize();\r
309     }\r
310     return ms.ToUnit(XFA_UNIT_Pt);\r
311 }\r
312 int32_t CXFA_Font::GetLineThrough()\r
313 {\r
314     int32_t iValue = 0;\r
315     m_pNode->TryInteger(XFA_ATTRIBUTE_LineThrough, iValue);\r
316     return iValue;\r
317 }\r
318 int32_t CXFA_Font::GetLineThroughPeriod()\r
319 {\r
320     XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_All;\r
321     m_pNode->TryEnum(XFA_ATTRIBUTE_LineThroughPeriod, eAttr);\r
322     return eAttr;\r
323 }\r
324 int32_t CXFA_Font::GetOverline()\r
325 {\r
326     int32_t iValue = 0;\r
327     m_pNode->TryInteger(XFA_ATTRIBUTE_Overline, iValue);\r
328     return iValue;\r
329 }\r
330 int32_t CXFA_Font::GetOverlinePeriod()\r
331 {\r
332     XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_All;\r
333     m_pNode->TryEnum(XFA_ATTRIBUTE_OverlinePeriod, eAttr);\r
334     return eAttr;\r
335 }\r
336 int32_t CXFA_Font::GetUnderline()\r
337 {\r
338     int32_t iValue = 0;\r
339     m_pNode->TryInteger(XFA_ATTRIBUTE_Underline, iValue);\r
340     return iValue;\r
341 }\r
342 int32_t CXFA_Font::GetUnderlinePeriod()\r
343 {\r
344     XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_All;\r
345     m_pNode->TryEnum(XFA_ATTRIBUTE_UnderlinePeriod, eAttr);\r
346     return eAttr;\r
347 }\r
348 FX_FLOAT CXFA_Font::GetFontSize()\r
349 {\r
350     CXFA_Measurement ms;\r
351     m_pNode->TryMeasure(XFA_ATTRIBUTE_Size, ms);\r
352     return ms.ToUnit(XFA_UNIT_Pt);\r
353 }\r
354 void CXFA_Font::GetTypeface(CFX_WideStringC &wsTypeFace)\r
355 {\r
356     m_pNode->TryCData(XFA_ATTRIBUTE_Typeface, wsTypeFace);\r
357 }\r
358 FX_BOOL CXFA_Font::IsBold()\r
359 {\r
360     XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_Normal;\r
361     m_pNode->TryEnum(XFA_ATTRIBUTE_Weight, eAttr);\r
362     return eAttr == XFA_ATTRIBUTEENUM_Bold;\r
363 }\r
364 FX_BOOL CXFA_Font::IsItalic()\r
365 {\r
366     XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_Normal;\r
367     m_pNode->TryEnum(XFA_ATTRIBUTE_Posture, eAttr);\r
368     return eAttr == XFA_ATTRIBUTEENUM_Italic;\r
369 }\r
370 FX_BOOL CXFA_Font::IsUseKerning()\r
371 {\r
372     XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_None;\r
373     m_pNode->TryEnum(XFA_ATTRIBUTE_KerningMode, eAttr);\r
374     return eAttr == XFA_ATTRIBUTEENUM_Pair;\r
375 }\r
376 void CXFA_Font::SetColor(FX_ARGB color)\r
377 {\r
378     CXFA_Fill fill = m_pNode->GetProperty(0, XFA_ELEMENT_Fill);\r
379     fill.SetColor(color);\r
380 }\r
381 FX_ARGB CXFA_Font::GetColor()\r
382 {\r
383     if (CXFA_Fill fill = m_pNode->GetChild(0, XFA_ELEMENT_Fill)) {\r
384         return fill.GetColor(TRUE);\r
385     }\r
386     return 0xFF000000;\r
387 }\r
388 FX_BOOL CXFA_Font::SetBaselineShift(FX_FLOAT fBaselineShift)\r
389 {\r
390     CXFA_Measurement ms(fBaselineShift, XFA_UNIT_Pt);\r
391     return m_pNode->SetMeasure(XFA_ATTRIBUTE_BaselineShift, ms);\r
392 }\r
393 FX_BOOL CXFA_Font::SetHorizontalScale(FX_FLOAT fHorizontalScale)\r
394 {\r
395     CFX_WideString wsValue;\r
396     wsValue.Format(L"%d", (int32_t)fHorizontalScale);\r
397     return m_pNode->SetCData(XFA_ATTRIBUTE_FontHorizontalScale, wsValue);\r
398 }\r
399 FX_BOOL CXFA_Font::SetVerticalScale(FX_FLOAT fVerticalScale)\r
400 {\r
401     CFX_WideString wsValue;\r
402     wsValue.Format(L"%d", (int32_t)fVerticalScale);\r
403     return m_pNode->SetCData(XFA_ATTRIBUTE_FontVerticalScale, wsValue);\r
404 }\r
405 FX_BOOL CXFA_Font::SetLetterSpacing(FX_FLOAT fLetterSpacing, XFA_UNIT eUnit)\r
406 {\r
407     return FALSE;\r
408 }\r
409 FX_BOOL CXFA_Font::SetLineThrough(int32_t iLineThrough)\r
410 {\r
411     return m_pNode->SetInteger(XFA_ATTRIBUTE_LineThrough, iLineThrough);\r
412 }\r
413 FX_BOOL CXFA_Font::SetLineThroughPeriod(int32_t iLineThroughPeriod)\r
414 {\r
415     return m_pNode->SetEnum(XFA_ATTRIBUTE_LineThroughPeriod, (XFA_ATTRIBUTEENUM)iLineThroughPeriod);\r
416 }\r
417 FX_BOOL CXFA_Font::SetOverline(int32_t iOverline)\r
418 {\r
419     return m_pNode->SetInteger(XFA_ATTRIBUTE_Overline, iOverline);\r
420 }\r
421 FX_BOOL CXFA_Font::SetOverlinePeriod(int32_t iOverlinePeriod)\r
422 {\r
423     return m_pNode->SetEnum(XFA_ATTRIBUTE_OverlinePeriod, (XFA_ATTRIBUTEENUM)iOverlinePeriod);\r
424 }\r
425 FX_BOOL CXFA_Font::SetUnderline(int32_t iUnderline)\r
426 {\r
427     return m_pNode->SetInteger(XFA_ATTRIBUTE_Underline, iUnderline);\r
428 }\r
429 FX_BOOL CXFA_Font::SetUnderlinePeriod(int32_t iUnderlinePeriod)\r
430 {\r
431     return m_pNode->SetEnum(XFA_ATTRIBUTE_UnderlinePeriod, (XFA_ATTRIBUTEENUM)iUnderlinePeriod);\r
432 }\r
433 CXFA_Caption::CXFA_Caption(CXFA_Node* pNode)\r
434     : CXFA_Data(pNode)\r
435 {\r
436 }\r
437 int32_t CXFA_Caption::GetPresence()\r
438 {\r
439     XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_Visible;\r
440     m_pNode->TryEnum(XFA_ATTRIBUTE_Presence, eAttr);\r
441     return eAttr;\r
442 }\r
443 int32_t CXFA_Caption::GetPlacementType()\r
444 {\r
445     XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_Left;\r
446     m_pNode->TryEnum(XFA_ATTRIBUTE_Placement, eAttr);\r
447     return eAttr;\r
448 }\r
449 FX_FLOAT CXFA_Caption::GetReserve()\r
450 {\r
451     CXFA_Measurement ms;\r
452     m_pNode->TryMeasure(XFA_ATTRIBUTE_Reserve, ms);\r
453     return ms.ToUnit(XFA_UNIT_Pt);\r
454 }\r
455 CXFA_Margin CXFA_Caption::GetMargin()\r
456 {\r
457     return CXFA_Margin(m_pNode ? m_pNode->GetChild(0, XFA_ELEMENT_Margin) : NULL);\r
458 }\r
459 CXFA_Font CXFA_Caption::GetFont()\r
460 {\r
461     return CXFA_Font(m_pNode ? m_pNode->GetChild(0, XFA_ELEMENT_Font) : NULL);\r
462 }\r
463 CXFA_Value CXFA_Caption::GetValue()\r
464 {\r
465     return CXFA_Value(m_pNode ? m_pNode->GetChild(0, XFA_ELEMENT_Value) : NULL);\r
466 }\r
467 CXFA_Para CXFA_Caption::GetPara()\r
468 {\r
469     return CXFA_Para(m_pNode ? m_pNode->GetChild(0, XFA_ELEMENT_Para) : NULL);\r
470 }\r
471 FX_BOOL CXFA_Caption::SetPresence(int32_t iPresence)\r
472 {\r
473     return m_pNode->SetEnum(XFA_ATTRIBUTE_Presence, (XFA_ATTRIBUTEENUM)iPresence);\r
474 }\r
475 FX_BOOL CXFA_Caption::SetPlacementType(int32_t iType)\r
476 {\r
477     return m_pNode->SetEnum(XFA_ATTRIBUTE_Placement, (XFA_ATTRIBUTEENUM)iType);\r
478 }\r
479 FX_BOOL CXFA_Caption::SetReserve(FX_FLOAT fReserve)\r
480 {\r
481     CXFA_Measurement ms(fReserve, XFA_UNIT_Pt);\r
482     return m_pNode->SetMeasure(XFA_ATTRIBUTE_Reserve, ms);\r
483 }\r
484 CXFA_Para::CXFA_Para(CXFA_Node* pNode)\r
485     : CXFA_Data(pNode)\r
486 {\r
487 }\r
488 int32_t CXFA_Para::GetHorizontalAlign()\r
489 {\r
490     XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_Left;\r
491     m_pNode->TryEnum(XFA_ATTRIBUTE_HAlign, eAttr);\r
492     return eAttr;\r
493 }\r
494 int32_t CXFA_Para::GetVerticalAlign()\r
495 {\r
496     XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_Top;\r
497     m_pNode->TryEnum(XFA_ATTRIBUTE_VAlign, eAttr);\r
498     return eAttr;\r
499 }\r
500 FX_FLOAT CXFA_Para::GetLineHeight()\r
501 {\r
502     CXFA_Measurement ms;\r
503     m_pNode->TryMeasure(XFA_ATTRIBUTE_LineHeight, ms);\r
504     return ms.ToUnit(XFA_UNIT_Pt);\r
505 }\r
506 FX_FLOAT CXFA_Para::GetMarginLeft()\r
507 {\r
508     CXFA_Measurement ms;\r
509     m_pNode->TryMeasure(XFA_ATTRIBUTE_MarginLeft, ms);\r
510     return ms.ToUnit(XFA_UNIT_Pt);\r
511 }\r
512 FX_FLOAT CXFA_Para::GetMarginRight()\r
513 {\r
514     CXFA_Measurement ms;\r
515     m_pNode->TryMeasure(XFA_ATTRIBUTE_MarginRight, ms);\r
516     return ms.ToUnit(XFA_UNIT_Pt);\r
517 }\r
518 int32_t CXFA_Para::GetOrphans()\r
519 {\r
520     int32_t iValue = 0;\r
521     m_pNode->TryInteger(XFA_ATTRIBUTE_Orphans, iValue);\r
522     return iValue;\r
523 }\r
524 FX_FLOAT CXFA_Para::GetRadixOffset()\r
525 {\r
526     CXFA_Measurement ms;\r
527     m_pNode->TryMeasure(XFA_ATTRIBUTE_RadixOffset, ms);\r
528     return ms.ToUnit(XFA_UNIT_Pt);\r
529 }\r
530 FX_FLOAT CXFA_Para::GetSpaceAbove()\r
531 {\r
532     CXFA_Measurement ms;\r
533     m_pNode->TryMeasure(XFA_ATTRIBUTE_SpaceAbove, ms);\r
534     return ms.ToUnit(XFA_UNIT_Pt);\r
535 }\r
536 FX_FLOAT CXFA_Para::GetSpaceBelow()\r
537 {\r
538     CXFA_Measurement ms;\r
539     m_pNode->TryMeasure(XFA_ATTRIBUTE_SpaceBelow, ms);\r
540     return ms.ToUnit(XFA_UNIT_Pt);\r
541 }\r
542 FX_FLOAT CXFA_Para::GetTextIndent()\r
543 {\r
544     CXFA_Measurement ms;\r
545     m_pNode->TryMeasure(XFA_ATTRIBUTE_TextIndent, ms);\r
546     return ms.ToUnit(XFA_UNIT_Pt);\r
547 }\r
548 int32_t CXFA_Para::GetWidows()\r
549 {\r
550     int32_t iValue = 0;\r
551     m_pNode->TryInteger(XFA_ATTRIBUTE_Widows, iValue);\r
552     return iValue;\r
553 }\r
554 FX_BOOL CXFA_Para::SetHorizontalAlign(int32_t iHorizontalAlign)\r
555 {\r
556     return m_pNode->SetEnum(XFA_ATTRIBUTE_HAlign, (XFA_ATTRIBUTEENUM)iHorizontalAlign);\r
557 }\r
558 FX_BOOL CXFA_Para::SetVerticalAlign(int32_t iVerticalAlign)\r
559 {\r
560     return m_pNode->SetEnum(XFA_ATTRIBUTE_VAlign, (XFA_ATTRIBUTEENUM)iVerticalAlign);\r
561 }\r
562 FX_BOOL CXFA_Para::SetLineHeight(FX_FLOAT fLineHeight)\r
563 {\r
564     CXFA_Measurement ms;\r
565     return m_pNode->SetMeasure(XFA_ATTRIBUTE_LineHeight, ms);\r
566 }\r
567 FX_BOOL CXFA_Para::SetMarginLeft(FX_FLOAT fMarginLeft)\r
568 {\r
569     CXFA_Measurement ms(fMarginLeft, XFA_UNIT_Pt);\r
570     return m_pNode->SetMeasure(XFA_ATTRIBUTE_MarginLeft, ms);\r
571 }\r
572 FX_BOOL CXFA_Para::SetMarginRight(FX_FLOAT fMarginRight)\r
573 {\r
574     CXFA_Measurement ms(fMarginRight, XFA_UNIT_Pt);\r
575     return m_pNode->SetMeasure(XFA_ATTRIBUTE_MarginRight, ms);\r
576 }\r
577 FX_BOOL CXFA_Para::SetOrphans(int32_t iOrphans)\r
578 {\r
579     return m_pNode->SetInteger(XFA_ATTRIBUTE_Orphans, iOrphans);\r
580 }\r
581 FX_BOOL CXFA_Para::SetRadixOffset(FX_FLOAT fRadixOffset)\r
582 {\r
583     CXFA_Measurement ms(fRadixOffset, XFA_UNIT_Pt);\r
584     return m_pNode->SetMeasure(XFA_ATTRIBUTE_RadixOffset, ms);\r
585 }\r
586 FX_BOOL CXFA_Para::SetSpaceAbove(FX_FLOAT fSpaceAbove)\r
587 {\r
588     CXFA_Measurement ms(fSpaceAbove, XFA_UNIT_Pt);\r
589     return m_pNode->SetMeasure(XFA_ATTRIBUTE_SpaceAbove, ms);\r
590 }\r
591 FX_BOOL CXFA_Para::SetSpaceBelow(FX_FLOAT fSpaceBelow)\r
592 {\r
593     CXFA_Measurement ms(fSpaceBelow, XFA_UNIT_Pt);\r
594     return m_pNode->SetMeasure(XFA_ATTRIBUTE_SpaceBelow, ms);\r
595 }\r
596 FX_BOOL CXFA_Para::SetTextIndent(FX_FLOAT fTextIndent)\r
597 {\r
598     CXFA_Measurement ms(fTextIndent, XFA_UNIT_Pt);\r
599     return m_pNode->SetMeasure(XFA_ATTRIBUTE_TextIndent, ms);\r
600 }\r
601 FX_BOOL CXFA_Para::SetWidows(int32_t iWidows)\r
602 {\r
603     return m_pNode->SetInteger(XFA_ATTRIBUTE_Widows, iWidows);\r
604 }\r
605 CXFA_Keep::CXFA_Keep(CXFA_Node *pNode, CXFA_Node *pParent)\r
606     : CXFA_Data(pNode)\r
607     , m_pParent(pParent)\r
608 {\r
609 }\r
610 int32_t CXFA_Keep::GetIntact()\r
611 {\r
612     XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_None;\r
613     switch (m_pParent->GetClassID()) {\r
614         case XFA_ELEMENT_Subform: {\r
615                 XFA_ATTRIBUTEENUM eAttrSubForm;\r
616                 m_pParent->TryEnum(XFA_ATTRIBUTE_Layout, eAttrSubForm);\r
617                 if (eAttrSubForm == XFA_ATTRIBUTEENUM_Position || eAttrSubForm == XFA_ATTRIBUTEENUM_Row) {\r
618                     eAttr = XFA_ATTRIBUTEENUM_ContentArea;\r
619                 }\r
620             }\r
621             break;\r
622         case XFA_ELEMENT_Draw:\r
623             eAttr = XFA_ATTRIBUTEENUM_ContentArea;\r
624             break;\r
625         default:\r
626             break;\r
627     }\r
628     m_pNode->TryEnum(XFA_ATTRIBUTE_Intact, eAttr, FALSE);\r
629     return eAttr;\r
630 }\r
631 int32_t CXFA_Keep::GetNext()\r
632 {\r
633     XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_None;\r
634     m_pNode->TryEnum(XFA_ATTRIBUTE_Next, eAttr);\r
635     return eAttr;\r
636 }\r
637 int32_t CXFA_Keep::GetPrevious()\r
638 {\r
639     XFA_ATTRIBUTEENUM eAttr = XFA_ATTRIBUTEENUM_None;\r
640     m_pNode->TryEnum(XFA_ATTRIBUTE_Previous, eAttr);\r
641     return eAttr;\r
642 }\r
643 FX_BOOL CXFA_Keep::SetIntact(int32_t iIntact)\r
644 {\r
645     return m_pNode->SetEnum(XFA_ATTRIBUTE_Intact, (XFA_ATTRIBUTEENUM)iIntact);\r
646 }\r
647 FX_BOOL CXFA_Keep::SetNext(int32_t iNext)\r
648 {\r
649     return m_pNode->SetEnum(XFA_ATTRIBUTE_Next, (XFA_ATTRIBUTEENUM)iNext);\r
650 }\r
651 FX_BOOL CXFA_Keep::SetPrevious(int32_t iPrevious)\r
652 {\r
653     return m_pNode->SetEnum(XFA_ATTRIBUTE_Previous, (XFA_ATTRIBUTEENUM)iPrevious);\r
654 }\r
655 CXFA_Event::CXFA_Event(CXFA_Node* pNode)\r
656     : CXFA_Data(pNode)\r
657 {\r
658 }\r
659 int32_t CXFA_Event::GetActivity()\r
660 {\r
661     return m_pNode->GetEnum(XFA_ATTRIBUTE_Activity);\r
662 }\r
663 int32_t CXFA_Event::GetEventType()\r
664 {\r
665     CXFA_Node* pChild = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);\r
666     while (pChild) {\r
667         int32_t eType = pChild->GetClassID();\r
668         if (eType != XFA_ELEMENT_Extras) {\r
669             return eType;\r
670         }\r
671         pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling);\r
672     }\r
673     return XFA_ELEMENT_UNKNOWN;\r
674 }\r
675 void CXFA_Event::GetRef(CFX_WideStringC &wsRef)\r
676 {\r
677     m_pNode->TryCData(XFA_ATTRIBUTE_Ref, wsRef);\r
678 }\r
679 int32_t CXFA_Event::GetExecuteRunAt()\r
680 {\r
681     CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Execute);\r
682     return pNode->GetEnum(XFA_ATTRIBUTE_RunAt);\r
683 }\r
684 int32_t CXFA_Event::GetExecuteType()\r
685 {\r
686     CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Execute);\r
687     return pNode->GetEnum(XFA_ATTRIBUTE_ExecuteType);\r
688 }\r
689 void CXFA_Event::GetExecuteConnection(CFX_WideString &wsConnection)\r
690 {\r
691     CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Execute);\r
692     CFX_WideStringC cData;\r
693     pNode->TryCData(XFA_ATTRIBUTE_Connection, cData);\r
694     wsConnection = cData;\r
695 }\r
696 CXFA_Script CXFA_Event::GetScript()\r
697 {\r
698     return m_pNode->GetChild(0, XFA_ELEMENT_Script);\r
699 }\r
700 CXFA_Submit CXFA_Event::GetSubmit()\r
701 {\r
702     return m_pNode->GetChild(0, XFA_ELEMENT_Submit);\r
703 }\r
704 int32_t CXFA_Event::GetSignDataOperation()\r
705 {\r
706     CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_SignData);\r
707     return pNode->GetEnum(XFA_ATTRIBUTE_Operation);\r
708 }\r
709 void CXFA_Event::GetSignDataTarget(CFX_WideString &wsTarget)\r
710 {\r
711     if (CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_SignData)) {\r
712         CFX_WideStringC wsCData;\r
713         pNode->TryCData(XFA_ATTRIBUTE_Target, wsCData);\r
714         wsTarget = wsCData;\r
715     }\r
716 }\r
717 FX_BOOL CXFA_Event::SetActivity(int32_t iActivity)\r
718 {\r
719     return m_pNode->SetEnum(XFA_ATTRIBUTE_Activity, (XFA_ATTRIBUTEENUM)iActivity);\r
720 }\r
721 FX_BOOL CXFA_Event::SetEventType(int32_t iEventType)\r
722 {\r
723     return FALSE;\r
724 }\r
725 FX_BOOL CXFA_Event::SetExecuteRunAt(int32_t iExecuteRunAt)\r
726 {\r
727     CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Execute);\r
728     return pNode->SetEnum(XFA_ATTRIBUTE_RunAt, (XFA_ATTRIBUTEENUM)iExecuteRunAt);\r
729 }\r
730 FX_BOOL CXFA_Event::SetExecuteType(int32_t iExecuteType)\r
731 {\r
732     CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Execute);\r
733     return pNode->SetEnum(XFA_ATTRIBUTE_ExecuteType, (XFA_ATTRIBUTEENUM)iExecuteType);\r
734 }\r
735 FX_BOOL CXFA_Event::SetExecuteConnection(const CFX_WideString& wsConnection)\r
736 {\r
737     CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Execute);\r
738     return pNode->SetCData(XFA_ATTRIBUTE_Connection, wsConnection);\r
739 }\r
740 FX_BOOL CXFA_Event::SetSignDataOperation(int32_t iOperation)\r
741 {\r
742     CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_SignData);\r
743     return pNode->SetEnum(XFA_ATTRIBUTE_Operation, (XFA_ATTRIBUTEENUM)iOperation);\r
744 }\r
745 FX_BOOL CXFA_Event::SetSignDataTarget(const CFX_WideString& wsTarget)\r
746 {\r
747     if (CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_SignData)) {\r
748         return pNode->SetCData(XFA_ATTRIBUTE_Target, wsTarget);\r
749     }\r
750     return FALSE;\r
751 }\r
752 CXFA_Script::CXFA_Script(CXFA_Node* pNode)\r
753     : CXFA_Data(pNode)\r
754 {\r
755 }\r
756 void CXFA_Script::GetBinding(CFX_WideString &wsBinding)\r
757 {\r
758     CFX_WideStringC cData;\r
759     m_pNode->TryCData(XFA_ATTRIBUTE_Binding, cData);\r
760     wsBinding = cData;\r
761 }\r
762 XFA_SCRIPTTYPE CXFA_Script::GetContentType()\r
763 {\r
764     CFX_WideStringC cData;\r
765     if (m_pNode->TryCData(XFA_ATTRIBUTE_ContentType, cData, FALSE)) {\r
766         if (cData == FX_WSTRC(L"application/x-javascript")) {\r
767             return XFA_SCRIPTTYPE_Javascript;\r
768         } else if (cData == FX_WSTRC(L"application/x-formcalc")) {\r
769             return XFA_SCRIPTTYPE_Formcalc;\r
770         } else {\r
771             return XFA_SCRIPTTYPE_Unkown;\r
772         }\r
773     }\r
774     return XFA_SCRIPTTYPE_Formcalc;\r
775 }\r
776 int32_t CXFA_Script::GetRunAt()\r
777 {\r
778     return m_pNode->GetEnum(XFA_ATTRIBUTE_RunAt);\r
779 }\r
780 void CXFA_Script::GetExpression(CFX_WideString &wsExpression)\r
781 {\r
782     m_pNode->TryContent(wsExpression);\r
783 }\r
784 FX_BOOL CXFA_Script::SetBinding(const CFX_WideString& wsBinding)\r
785 {\r
786     return m_pNode->SetCData(XFA_ATTRIBUTE_Binding, wsBinding);\r
787 }\r
788 FX_BOOL CXFA_Script::SetContentType(XFA_SCRIPTTYPE eType)\r
789 {\r
790     CFX_WideString wsType;\r
791     switch (eType) {\r
792         case XFA_SCRIPTTYPE_Javascript:\r
793             wsType = L"application/x-javascript";\r
794             break;\r
795         case XFA_SCRIPTTYPE_Formcalc:\r
796             wsType = L"application/x-formcalc";\r
797             break;\r
798         default:\r
799             break;\r
800     }\r
801     return m_pNode->SetCData(XFA_ATTRIBUTE_ContentType, wsType);\r
802 }\r
803 FX_BOOL CXFA_Script::SetRunAt(int32_t iRunAt)\r
804 {\r
805     return m_pNode->SetEnum(XFA_ATTRIBUTE_RunAt, (XFA_ATTRIBUTEENUM)iRunAt);\r
806 }\r
807 FX_BOOL CXFA_Script::SetExpression(const CFX_WideString& wsExpression)\r
808 {\r
809     return m_pNode->SetContent(wsExpression, wsExpression);\r
810 }\r
811 CXFA_Submit::CXFA_Submit(CXFA_Node* pNode)\r
812     : CXFA_Data (pNode)\r
813 {\r
814 }\r
815 FX_BOOL CXFA_Submit::IsSubmitEmbedPDF()\r
816 {\r
817     return m_pNode->GetBoolean(XFA_ATTRIBUTE_EmbedPDF);\r
818 }\r
819 int32_t CXFA_Submit::GetSubmitFormat()\r
820 {\r
821     return m_pNode->GetEnum(XFA_ATTRIBUTE_Format);\r
822 }\r
823 void CXFA_Submit::GetSubmitTarget(CFX_WideStringC &wsTarget)\r
824 {\r
825     m_pNode->TryCData(XFA_ATTRIBUTE_Target, wsTarget);\r
826 }\r
827 XFA_TEXTENCODING CXFA_Submit::GetSubmitTextEncoding()\r
828 {\r
829     CFX_WideStringC wsCData;\r
830     if (!m_pNode->TryCData(XFA_ATTRIBUTE_TextEncoding, wsCData)) {\r
831         return XFA_TEXTENCODING_None;\r
832     }\r
833     CFX_WideString wsValue(wsCData);\r
834     if (wsValue == L"Big-Five") {\r
835         return XFA_TEXTENCODING_Big5;\r
836     } else if (wsValue == L"fontSpecific") {\r
837         return XFA_TEXTENCODING_FontSpecific;\r
838     } else if (wsValue == L"GBK") {\r
839         return XFA_TEXTENCODING_GBK;\r
840     } else if (wsValue == L"GB-18030") {\r
841         return XFA_TEXTENCODING_GB18030;\r
842     } else if (wsValue == L"GB-2312") {\r
843         return XFA_TEXTENCODING_GB2312;\r
844     } else if (wsValue == L"ISO-8859-NN") {\r
845         return XFA_TEXTENCODING_ISO8859NN;\r
846     } else if (wsValue == L"KSC-5601") {\r
847         return XFA_TEXTENCODING_KSC5601;\r
848     } else if (wsValue == L"Shift-JIS") {\r
849         return XFA_TEXTENCODING_ShiftJIS;\r
850     } else if (wsValue == L"UCS-2") {\r
851         return XFA_TEXTENCODING_UCS2;\r
852     } else if (wsValue == L"UTF-16") {\r
853         return XFA_TEXTENCODING_UTF16;\r
854     } else if (wsValue == L"UTF-8") {\r
855         return XFA_TEXTENCODING_UTF8;\r
856     }\r
857     return XFA_TEXTENCODING_None;\r
858 }\r
859 void CXFA_Submit::GetSubmitXDPContent(CFX_WideStringC &wsContent)\r
860 {\r
861     m_pNode->TryCData(XFA_ATTRIBUTE_XdpContent, wsContent);\r
862 }\r
863 FX_BOOL CXFA_Submit::SetSubmitFormat(int32_t iSubmitFormat)\r
864 {\r
865     return m_pNode->SetEnum(XFA_ATTRIBUTE_Format, (XFA_ATTRIBUTEENUM)iSubmitFormat);\r
866 }\r
867 FX_BOOL CXFA_Submit::SetSubmitTarget(const CFX_WideString& wsTarget)\r
868 {\r
869     return m_pNode->SetCData(XFA_ATTRIBUTE_Target, wsTarget);\r
870 }\r
871 FX_BOOL CXFA_Submit::SetSubmitTextEncoding(XFA_TEXTENCODING eTextEncoding)\r
872 {\r
873     CFX_WideString wsValue;\r
874     switch (eTextEncoding) {\r
875         case  XFA_TEXTENCODING_Big5:\r
876             wsValue = L"Big-Five";\r
877             break;\r
878         case XFA_TEXTENCODING_FontSpecific:\r
879             wsValue = L"fontSpecific";\r
880             break;\r
881         case XFA_TEXTENCODING_GBK:\r
882             wsValue = L"GBK";\r
883             break;\r
884         case XFA_TEXTENCODING_GB18030:\r
885             wsValue = L"GB-18030";\r
886             break;\r
887         case XFA_TEXTENCODING_GB2312:\r
888             wsValue = L"GB-2312";\r
889             break;\r
890         case XFA_TEXTENCODING_ISO8859NN:\r
891             wsValue = L"ISO-8859-NN";\r
892             break;\r
893         case XFA_TEXTENCODING_KSC5601:\r
894             wsValue = L"KSC-5601";\r
895             break;\r
896         case XFA_TEXTENCODING_ShiftJIS:\r
897             wsValue = L"Shift-JIS";\r
898             break;\r
899         case XFA_TEXTENCODING_UCS2:\r
900             wsValue = L"UCS-2";\r
901             break;\r
902         case XFA_TEXTENCODING_UTF16:\r
903             wsValue = L"UTF-16";\r
904             break;\r
905         case XFA_TEXTENCODING_UTF8:\r
906             wsValue = L"UTF-8";\r
907             break;\r
908         default:\r
909             break;\r
910     }\r
911     return m_pNode->SetCData(XFA_ATTRIBUTE_TextEncoding, wsValue);\r
912 }\r
913 FX_BOOL CXFA_Submit::SetSubmitXDPContent(const CFX_WideString& wsContent)\r
914 {\r
915     return m_pNode->SetCData(XFA_ATTRIBUTE_XdpContent, wsContent);\r
916 }\r
917 XFA_ELEMENT CXFA_Value::GetChildValueClassID()\r
918 {\r
919     if (!m_pNode) {\r
920         return XFA_ELEMENT_UNKNOWN;\r
921     }\r
922     if (CXFA_Node* pNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild)) {\r
923         return pNode->GetClassID();\r
924     }\r
925     return XFA_ELEMENT_UNKNOWN;\r
926 }\r
927 FX_BOOL CXFA_Value::GetChildValueContent(CFX_WideString &wsContent)\r
928 {\r
929     if (!m_pNode) {\r
930         return FALSE;\r
931     }\r
932     if (CXFA_Node* pNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild)) {\r
933         return pNode->TryContent(wsContent);\r
934     }\r
935     return FALSE;\r
936 }\r
937 CXFA_Arc CXFA_Value::GetArc()\r
938 {\r
939     return m_pNode ? CXFA_Arc(m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild)) : NULL;\r
940 }\r
941 CXFA_Line CXFA_Value::GetLine()\r
942 {\r
943     return m_pNode ? CXFA_Line(m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild)) : NULL;\r
944 }\r
945 CXFA_Rectangle CXFA_Value::GetRectangle()\r
946 {\r
947     return m_pNode ? CXFA_Rectangle(m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild)) : NULL;\r
948 }\r
949 CXFA_Text CXFA_Value::GetText()\r
950 {\r
951     return m_pNode ? CXFA_Text(m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild)) : NULL;\r
952 }\r
953 CXFA_ExData CXFA_Value::GetExData()\r
954 {\r
955     return m_pNode ? CXFA_ExData(m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild)) : NULL;\r
956 }\r
957 CXFA_Image CXFA_Value::GetImage()\r
958 {\r
959     return CXFA_Image(m_pNode ? (m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild)) : NULL, TRUE);\r
960 }\r
961 FX_BOOL CXFA_Value::SetChildValueContent(const CFX_WideString& wsContent, FX_BOOL bNotify , XFA_ELEMENT iType )\r
962 {\r
963     if (!m_pNode) {\r
964         return FALSE;\r
965     }\r
966     CXFA_Node* pNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);\r
967     if (!pNode) {\r
968         if (iType == XFA_ELEMENT_UNKNOWN) {\r
969             return FALSE;\r
970         }\r
971         pNode = m_pNode->GetProperty(0, iType);\r
972     }\r
973     CFX_WideString wsFormatContent(wsContent);\r
974     CXFA_WidgetData* pContainerWidgetData = pNode->GetContainerWidgetData();\r
975     if (pContainerWidgetData) {\r
976         pContainerWidgetData->GetFormatDataValue(wsContent, wsFormatContent);\r
977     }\r
978     return pNode->SetContent(wsContent, wsFormatContent, bNotify);\r
979 }\r
980 int32_t CXFA_Line::GetHand()\r
981 {\r
982     return m_pNode->GetEnum(XFA_ATTRIBUTE_Hand);\r
983 }\r
984 FX_BOOL CXFA_Line::GetSlop()\r
985 {\r
986     XFA_ATTRIBUTEENUM eSlop = m_pNode->GetEnum(XFA_ATTRIBUTE_Slope);\r
987     return (eSlop == XFA_ATTRIBUTEENUM_Slash) ? TRUE : FALSE;\r
988 }\r
989 CXFA_Edge CXFA_Line::GetEdge()\r
990 {\r
991     return CXFA_Edge(m_pNode->GetChild(0, XFA_ELEMENT_Edge));\r
992 }\r
993 FX_BOOL CXFA_Line::SetHand(int32_t iHand)\r
994 {\r
995     return m_pNode->SetEnum(XFA_ATTRIBUTE_Hand, (XFA_ATTRIBUTEENUM)iHand);\r
996 }\r
997 FX_BOOL CXFA_Line::SetSlop(int32_t iSlop)\r
998 {\r
999     return m_pNode->SetEnum(XFA_ATTRIBUTE_Slope, (XFA_ATTRIBUTEENUM)iSlop);\r
1000 }\r
1001 CXFA_Text::CXFA_Text(CXFA_Node* pNode)\r
1002     : CXFA_Data(pNode)\r
1003 {\r
1004 }\r
1005 void CXFA_Text::GetName(CFX_WideStringC &wsName)\r
1006 {\r
1007     m_pNode->TryCData(XFA_ATTRIBUTE_Name, wsName);\r
1008 }\r
1009 int32_t CXFA_Text::GetMaxChars()\r
1010 {\r
1011     return m_pNode->GetInteger(XFA_ATTRIBUTE_MaxChars);\r
1012 }\r
1013 void CXFA_Text::GetRid(CFX_WideStringC &wsRid)\r
1014 {\r
1015     m_pNode->TryCData(XFA_ATTRIBUTE_Rid, wsRid);\r
1016 }\r
1017 void CXFA_Text::GetContent(CFX_WideString &wsText)\r
1018 {\r
1019     m_pNode->TryContent(wsText);\r
1020 }\r
1021 void CXFA_Text::SetContent(CFX_WideString wsText, FX_BOOL bNotify )\r
1022 {\r
1023     CFX_WideString wsFormatValue(wsText);\r
1024     CXFA_WidgetData* pContainerWidgetData = m_pNode->GetContainerWidgetData();\r
1025     if (pContainerWidgetData) {\r
1026         pContainerWidgetData->GetFormatDataValue(wsText, wsFormatValue);\r
1027     }\r
1028     m_pNode->SetContent(wsText, wsFormatValue, bNotify);\r
1029 }\r
1030 FX_BOOL CXFA_Text::SetName(const CFX_WideString& wsName)\r
1031 {\r
1032     return m_pNode->SetCData(XFA_ATTRIBUTE_Name, wsName);\r
1033 }\r
1034 FX_BOOL CXFA_Text::SetMaxChars(int32_t iMaxChars)\r
1035 {\r
1036     return m_pNode->SetInteger(XFA_ATTRIBUTE_MaxChars, iMaxChars);\r
1037 }\r
1038 FX_BOOL CXFA_Text::SetRid(const CFX_WideString& wsRid)\r
1039 {\r
1040     return m_pNode->SetCData(XFA_ATTRIBUTE_Rid, wsRid);\r
1041 }\r
1042 CXFA_ExData::CXFA_ExData(CXFA_Node* pNode)\r
1043     : CXFA_Data(pNode)\r
1044 {\r
1045 }\r
1046 void CXFA_ExData::GetContentType(CFX_WideStringC &wsContentType)\r
1047 {\r
1048     m_pNode->TryCData(XFA_ATTRIBUTE_ContentType, wsContentType);\r
1049 }\r
1050 void CXFA_ExData::GetHref(CFX_WideStringC &wsHref)\r
1051 {\r
1052     m_pNode->TryCData(XFA_ATTRIBUTE_Href, wsHref);\r
1053 }\r
1054 int32_t CXFA_ExData::GetMaxLength()\r
1055 {\r
1056     return m_pNode->GetInteger(XFA_ATTRIBUTE_MaxLength);\r
1057 }\r
1058 void CXFA_ExData::GetRid(CFX_WideStringC &wsRid)\r
1059 {\r
1060     m_pNode->TryCData(XFA_ATTRIBUTE_Rid, wsRid);\r
1061 }\r
1062 int32_t CXFA_ExData::GetTransferEncoding()\r
1063 {\r
1064     return m_pNode->GetEnum(XFA_ATTRIBUTE_TransferEncoding);\r
1065 }\r
1066 void CXFA_ExData::GetContent(CFX_WideString &wsText)\r
1067 {\r
1068     m_pNode->TryContent(wsText);\r
1069 }\r
1070 FX_BOOL CXFA_ExData::SetContentType(const CFX_WideString& wsContentType)\r
1071 {\r
1072     return m_pNode->SetCData(XFA_ATTRIBUTE_ContentType, wsContentType);\r
1073 }\r
1074 FX_BOOL CXFA_ExData::SetHref(const CFX_WideString& wsHref)\r
1075 {\r
1076     return m_pNode->SetCData(XFA_ATTRIBUTE_Href, wsHref);\r
1077 }\r
1078 FX_BOOL CXFA_ExData::SetMaxLength(int32_t iMaxLength)\r
1079 {\r
1080     return m_pNode->SetInteger(XFA_ATTRIBUTE_MaxLength, iMaxLength);\r
1081 }\r
1082 FX_BOOL CXFA_ExData::SetRid(const CFX_WideString& wsRid)\r
1083 {\r
1084     return m_pNode->SetCData(XFA_ATTRIBUTE_Rid, wsRid);\r
1085 }\r
1086 FX_BOOL CXFA_ExData::SetTransferEncoding(int32_t iTransferEncoding)\r
1087 {\r
1088     return m_pNode->SetEnum(XFA_ATTRIBUTE_TransferEncoding, (XFA_ATTRIBUTEENUM)iTransferEncoding);\r
1089 }\r
1090 FX_BOOL CXFA_ExData::SetContent(const CFX_WideString& wsText, FX_BOOL bNotify ,  FX_BOOL bScriptModify, FX_BOOL bSyncData )\r
1091 {\r
1092     CFX_WideString wsFormatValue(wsText);\r
1093     CXFA_WidgetData* pContainerWidgetData = m_pNode->GetContainerWidgetData();\r
1094     if (pContainerWidgetData) {\r
1095         pContainerWidgetData->GetFormatDataValue(wsText, wsFormatValue);\r
1096     }\r
1097     return m_pNode->SetContent(wsText, wsFormatValue, bNotify, bScriptModify, bSyncData);\r
1098 }\r
1099 CXFA_Image::CXFA_Image(CXFA_Node* pNode, FX_BOOL bDefValue)\r
1100     : CXFA_Data(pNode)\r
1101     , m_bDefValue(bDefValue)\r
1102 {\r
1103 }\r
1104 int32_t CXFA_Image::GetAspect()\r
1105 {\r
1106     return m_pNode->GetEnum(XFA_ATTRIBUTE_Aspect);\r
1107 }\r
1108 FX_BOOL CXFA_Image::GetContentType(CFX_WideString &wsContentType)\r
1109 {\r
1110     return m_pNode->TryCData(XFA_ATTRIBUTE_ContentType, wsContentType);\r
1111 }\r
1112 FX_BOOL CXFA_Image::GetHref(CFX_WideString &wsHref)\r
1113 {\r
1114     if (m_bDefValue) {\r
1115         return  m_pNode->TryCData(XFA_ATTRIBUTE_Href, wsHref);\r
1116     }\r
1117     return m_pNode->GetAttribute(FX_WSTRC(L"href"), wsHref);\r
1118 }\r
1119 int32_t CXFA_Image::GetTransferEncoding()\r
1120 {\r
1121     if (m_bDefValue) {\r
1122         return m_pNode->GetEnum(XFA_ATTRIBUTE_TransferEncoding);\r
1123     }\r
1124     return XFA_ATTRIBUTEENUM_Base64;\r
1125 }\r
1126 FX_BOOL CXFA_Image::GetContent(CFX_WideString &wsText)\r
1127 {\r
1128     return      m_pNode->TryContent(wsText);\r
1129 }\r
1130 FX_BOOL CXFA_Image::SetAspect(int32_t iAspect)\r
1131 {\r
1132     return m_pNode->SetEnum(XFA_ATTRIBUTE_Aspect, (XFA_ATTRIBUTEENUM)iAspect);\r
1133 }\r
1134 FX_BOOL CXFA_Image::SetContentType(const CFX_WideString& wsContentType)\r
1135 {\r
1136     return m_pNode->SetCData(XFA_ATTRIBUTE_ContentType, wsContentType);\r
1137 }\r
1138 FX_BOOL CXFA_Image::SetHref(const CFX_WideString& wsHref)\r
1139 {\r
1140     if (m_bDefValue) {\r
1141         return  m_pNode->SetCData(XFA_ATTRIBUTE_Href, wsHref);\r
1142     }\r
1143     return m_pNode->SetAttribute(XFA_ATTRIBUTE_Href, wsHref);\r
1144 }\r
1145 FX_BOOL CXFA_Image::SetTransferEncoding(int32_t iTransferEncoding)\r
1146 {\r
1147     if (m_bDefValue) {\r
1148         return m_pNode->SetEnum(XFA_ATTRIBUTE_TransferEncoding, (XFA_ATTRIBUTEENUM)iTransferEncoding);\r
1149     }\r
1150     return TRUE;\r
1151 }\r
1152 FX_BOOL CXFA_Image::SetContent(const CFX_WideString& wsText)\r
1153 {\r
1154     CFX_WideString wsFormatValue(wsText);\r
1155     CXFA_WidgetData* pContainerWidgetData = m_pNode->GetContainerWidgetData();\r
1156     if (pContainerWidgetData) {\r
1157         pContainerWidgetData->GetFormatDataValue(wsText, wsFormatValue);\r
1158     }\r
1159     return m_pNode->SetContent(wsText, wsFormatValue);\r
1160 }\r
1161 CXFA_Calculate::CXFA_Calculate(CXFA_Node* pNode)\r
1162     : CXFA_Data(pNode)\r
1163 {\r
1164 }\r
1165 int32_t CXFA_Calculate::GetOverride()\r
1166 {\r
1167     XFA_ATTRIBUTEENUM eAtt = XFA_ATTRIBUTEENUM_Error;\r
1168     m_pNode->TryEnum(XFA_ATTRIBUTE_Override, eAtt, FALSE);\r
1169     return eAtt;\r
1170 }\r
1171 CXFA_Script CXFA_Calculate::GetScript()\r
1172 {\r
1173     return m_pNode->GetChild(0, XFA_ELEMENT_Script);\r
1174 }\r
1175 void CXFA_Calculate::GetMessageText(CFX_WideString &wsMessage)\r
1176 {\r
1177     if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_ELEMENT_Message)) {\r
1178         CXFA_Text text(pNode->GetChild(0, XFA_ELEMENT_Text));\r
1179         if (text) {\r
1180             text.GetContent(wsMessage);\r
1181         }\r
1182     }\r
1183 }\r
1184 FX_BOOL CXFA_Calculate::SetOverride(int32_t iOverride)\r
1185 {\r
1186     return m_pNode->SetEnum(XFA_ATTRIBUTE_Override, (XFA_ATTRIBUTEENUM)iOverride);\r
1187 }\r
1188 FX_BOOL CXFA_Calculate::SetMessageText(const CFX_WideString& wsMessage)\r
1189 {\r
1190     if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_ELEMENT_Message)) {\r
1191         CXFA_Node* pChildNode = pNode->GetProperty(0, XFA_ELEMENT_Text);\r
1192         return pChildNode->SetContent(wsMessage, wsMessage);\r
1193     }\r
1194     return FALSE;\r
1195 }\r
1196 CXFA_Validate::CXFA_Validate(CXFA_Node* pNode)\r
1197     : CXFA_Data(pNode)\r
1198 {\r
1199 }\r
1200 int32_t CXFA_Validate::GetFormatTest()\r
1201 {\r
1202     return m_pNode->GetEnum(XFA_ATTRIBUTE_FormatTest);\r
1203 }\r
1204 FX_BOOL CXFA_Validate::SetTestValue(int32_t iType, CFX_WideString &wsValue, XFA_ATTRIBUTEENUM eName)\r
1205 {\r
1206     XFA_LPCATTRIBUTEENUMINFO pInfo = XFA_GetAttributeEnumByName(wsValue);\r
1207     if (pInfo) {\r
1208         eName = pInfo->eName;\r
1209     }\r
1210     m_pNode->SetEnum((XFA_ATTRIBUTE)iType, eName, FALSE);\r
1211     return TRUE;\r
1212 }\r
1213 FX_BOOL CXFA_Validate::SetFormatTest(CFX_WideString wsValue)\r
1214 {\r
1215     return SetTestValue(XFA_ATTRIBUTE_FormatTest, wsValue, XFA_ATTRIBUTEENUM_Warning);\r
1216 }\r
1217 FX_BOOL CXFA_Validate::SetNullTest(CFX_WideString wsValue)\r
1218 {\r
1219     return SetTestValue(XFA_ATTRIBUTE_NullTest, wsValue, XFA_ATTRIBUTEENUM_Disabled);\r
1220 }\r
1221 int32_t CXFA_Validate::GetNullTest()\r
1222 {\r
1223     return m_pNode->GetEnum(XFA_ATTRIBUTE_NullTest);\r
1224 }\r
1225 int32_t CXFA_Validate::GetScriptTest()\r
1226 {\r
1227     return m_pNode->GetEnum(XFA_ATTRIBUTE_ScriptTest);\r
1228 }\r
1229 void CXFA_Validate::GetMessageText(CFX_WideString &wsMessage, FX_WSTR wsMessageType)\r
1230 {\r
1231     if (CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Message, FALSE)) {\r
1232         CXFA_Node *pItemNode = pNode->GetNodeItem(XFA_NODEITEM_FirstChild);\r
1233         for (; pItemNode; pItemNode = pItemNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {\r
1234             if (pItemNode->GetClassID() != XFA_ELEMENT_Text) {\r
1235                 continue;\r
1236             }\r
1237             CFX_WideStringC wsName;\r
1238             pItemNode->TryCData(XFA_ATTRIBUTE_Name, wsName);\r
1239             if (wsName.IsEmpty() || wsName == wsMessageType) {\r
1240                 pItemNode->TryContent(wsMessage);\r
1241                 return;\r
1242             }\r
1243         }\r
1244     }\r
1245 }\r
1246 void CXFA_Validate::SetFormatMessageText(CFX_WideString wsMessage)\r
1247 {\r
1248     SetMessageText(wsMessage, FX_WSTRC(L"formatTest"));\r
1249 }\r
1250 void CXFA_Validate::GetFormatMessageText(CFX_WideString &wsMessage)\r
1251 {\r
1252     GetMessageText(wsMessage, FX_WSTRC(L"formatTest"));\r
1253 }\r
1254 void CXFA_Validate::SetNullMessageText(CFX_WideString wsMessage)\r
1255 {\r
1256     SetMessageText(wsMessage, FX_WSTRC(L"nullTest"));\r
1257 }\r
1258 void CXFA_Validate::GetNullMessageText(CFX_WideString &wsMessage)\r
1259 {\r
1260     GetMessageText(wsMessage, FX_WSTRC(L"nullTest"));\r
1261 }\r
1262 void CXFA_Validate::SetMessageText(CFX_WideString &wsMessage, FX_WSTR wsMessageType)\r
1263 {\r
1264     if (CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Message, TRUE)) {\r
1265         CXFA_Node *pItemNode = pNode->GetNodeItem(XFA_NODEITEM_FirstChild);\r
1266         for (; pItemNode; pItemNode = pItemNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {\r
1267             if (pItemNode->GetClassID() != XFA_ELEMENT_Text) {\r
1268                 continue;\r
1269             }\r
1270             CFX_WideStringC wsName;\r
1271             pItemNode->TryCData(XFA_ATTRIBUTE_Name, wsName);\r
1272             if (wsName.IsEmpty() || wsName == wsMessageType) {\r
1273                 pItemNode->SetContent(wsMessage, wsMessage, FALSE);\r
1274                 return;\r
1275             }\r
1276         }\r
1277         CXFA_Node* pTextNode = pNode->CreateSamePacketNode(XFA_ELEMENT_Text);\r
1278         pNode->InsertChild(pTextNode);\r
1279         pTextNode->SetCData(XFA_ATTRIBUTE_Name, wsMessageType, FALSE);\r
1280         pTextNode->SetContent(wsMessage, wsMessage, FALSE);\r
1281     }\r
1282 }\r
1283 void CXFA_Validate::GetScriptMessageText(CFX_WideString &wsMessage)\r
1284 {\r
1285     GetMessageText(wsMessage, FX_WSTRC(L"scriptTest"));\r
1286 }\r
1287 void CXFA_Validate::SetScriptMessageText(CFX_WideString wsMessage)\r
1288 {\r
1289     SetMessageText(wsMessage, FX_WSTRC(L"scriptTest"));\r
1290 }\r
1291 void CXFA_Validate::GetPicture(CFX_WideString &wsPicture)\r
1292 {\r
1293     if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_ELEMENT_Picture)) {\r
1294         pNode->TryContent(wsPicture);\r
1295     }\r
1296 }\r
1297 CXFA_Script CXFA_Validate::GetScript()\r
1298 {\r
1299     return m_pNode->GetChild(0, XFA_ELEMENT_Script);\r
1300 }\r
1301 CXFA_Variables::CXFA_Variables(CXFA_Node* pNode)\r
1302     : CXFA_Data(pNode)\r
1303 {\r
1304 }\r
1305 int32_t CXFA_Variables::CountScripts()\r
1306 {\r
1307     return m_pNode->CountChildren(XFA_ELEMENT_Script);\r
1308 }\r
1309 CXFA_Script CXFA_Variables::GetScript(int32_t nIndex)\r
1310 {\r
1311     return m_pNode->GetChild(nIndex, XFA_ELEMENT_Script);\r
1312 }\r
1313 CXFA_Bind::CXFA_Bind(CXFA_Node* pNode)\r
1314     : CXFA_Data(pNode)\r
1315 {\r
1316 }\r
1317 int32_t CXFA_Bind::GetMatch()\r
1318 {\r
1319     return m_pNode->GetEnum(XFA_ATTRIBUTE_Match);\r
1320 }\r
1321 void CXFA_Bind::GetRef(CFX_WideStringC &wsRef)\r
1322 {\r
1323     m_pNode->TryCData(XFA_ATTRIBUTE_Ref, wsRef);\r
1324 }\r
1325 void CXFA_Bind::GetPicture(CFX_WideString &wsPicture)\r
1326 {\r
1327     if (CXFA_Node* pPicture = m_pNode->GetChild(0, XFA_ELEMENT_Picture)) {\r
1328         pPicture->TryContent(wsPicture);\r
1329     }\r
1330 }\r
1331 FX_BOOL CXFA_Bind::SetMatch(int32_t iMatch)\r
1332 {\r
1333     return m_pNode->SetEnum(XFA_ATTRIBUTE_Match, (XFA_ATTRIBUTEENUM)iMatch);\r
1334 }\r
1335 FX_BOOL CXFA_Bind::SetRef(const CFX_WideString& wsRef)\r
1336 {\r
1337     return m_pNode->SetCData(XFA_ATTRIBUTE_Ref, wsRef);\r
1338 }\r
1339 FX_BOOL CXFA_Bind::SetPicture(const CFX_WideString& wsPicture)\r
1340 {\r
1341     if (CXFA_Node* pPicture = m_pNode->GetChild(0, XFA_ELEMENT_Picture)) {\r
1342         return pPicture->SetContent(wsPicture, wsPicture);\r
1343     }\r
1344     return FALSE;\r
1345 }\r
1346 CXFA_Assist::CXFA_Assist(CXFA_Node* pNode)\r
1347     : CXFA_Data(pNode)\r
1348 {\r
1349 }\r
1350 CXFA_ToolTip CXFA_Assist::GetToolTip()\r
1351 {\r
1352     return m_pNode->GetChild(0, XFA_ELEMENT_ToolTip);\r
1353 }\r
1354 CXFA_ToolTip::CXFA_ToolTip(CXFA_Node* pNode)\r
1355     : CXFA_Data(pNode)\r
1356 {\r
1357 }\r
1358 FX_BOOL CXFA_ToolTip::GetTip(CFX_WideString &wsTip)\r
1359 {\r
1360     return m_pNode->TryContent(wsTip);\r
1361 }\r
1362 FX_BOOL CXFA_ToolTip::SetTip(const CFX_WideString& wsTip)\r
1363 {\r
1364     return m_pNode->SetContent(wsTip, wsTip);\r
1365 }\r
1366 CXFA_BindItems::CXFA_BindItems(CXFA_Node* pNode)\r
1367     : CXFA_Data(pNode)\r
1368 {\r
1369 }\r
1370 void CXFA_BindItems::GetConnection(CFX_WideStringC &wsConnection)\r
1371 {\r
1372     m_pNode->TryCData(XFA_ATTRIBUTE_Connection, wsConnection);\r
1373 }\r
1374 void CXFA_BindItems::GetLabelRef(CFX_WideStringC &wsLabelRef)\r
1375 {\r
1376     m_pNode->TryCData(XFA_ATTRIBUTE_LabelRef, wsLabelRef);\r
1377 }\r
1378 void CXFA_BindItems::GetValueRef(CFX_WideStringC &wsValueRef)\r
1379 {\r
1380     m_pNode->TryCData(XFA_ATTRIBUTE_ValueRef, wsValueRef);\r
1381 }\r
1382 void CXFA_BindItems::GetRef(CFX_WideStringC &wsRef)\r
1383 {\r
1384     m_pNode->TryCData(XFA_ATTRIBUTE_Ref, wsRef);\r
1385 }\r
1386 FX_BOOL CXFA_BindItems::SetConnection(const CFX_WideString& wsConnection)\r
1387 {\r
1388     return m_pNode->SetCData(XFA_ATTRIBUTE_Connection, wsConnection);\r
1389 }\r
1390 FX_BOOL CXFA_BindItems::SetLabelRef(const CFX_WideString& wsLabelRef)\r
1391 {\r
1392     return m_pNode->SetCData(XFA_ATTRIBUTE_LabelRef, wsLabelRef);\r
1393 }\r
1394 FX_BOOL CXFA_BindItems::SetValueRef(const CFX_WideString& wsValueRef)\r
1395 {\r
1396     return m_pNode->SetCData(XFA_ATTRIBUTE_ValueRef, wsValueRef);\r
1397 }\r
1398 FX_BOOL CXFA_BindItems::SetRef(const CFX_WideString& wsRef)\r
1399 {\r
1400     return m_pNode->SetCData(XFA_ATTRIBUTE_Ref, wsRef);\r
1401 }\r
1402 int32_t CXFA_Box::GetBreak() const\r
1403 {\r
1404     if (!m_pNode) {\r
1405         return XFA_ATTRIBUTEENUM_Close;\r
1406     }\r
1407     return m_pNode->GetEnum(XFA_ATTRIBUTE_Break);\r
1408 }\r
1409 int32_t CXFA_Box::GetHand() const\r
1410 {\r
1411     if (!m_pNode) {\r
1412         return XFA_ATTRIBUTEENUM_Even;\r
1413     }\r
1414     return m_pNode->GetEnum(XFA_ATTRIBUTE_Hand);\r
1415 }\r
1416 int32_t CXFA_Box::GetPresence() const\r
1417 {\r
1418     if (!m_pNode) {\r
1419         return XFA_ATTRIBUTEENUM_Hidden;\r
1420     }\r
1421     return m_pNode->GetEnum(XFA_ATTRIBUTE_Presence);\r
1422 }\r
1423 int32_t CXFA_Box::CountCorners() const\r
1424 {\r
1425     if (!m_pNode) {\r
1426         return 0;\r
1427     }\r
1428     return m_pNode->CountChildren(XFA_ELEMENT_Corner);\r
1429 }\r
1430 CXFA_Corner CXFA_Box::GetCorner(int32_t nIndex) const\r
1431 {\r
1432     if (!m_pNode) {\r
1433         return NULL;\r
1434     }\r
1435     return CXFA_Corner(m_pNode->GetProperty(nIndex, XFA_ELEMENT_Corner, nIndex == 0));\r
1436 }\r
1437 int32_t CXFA_Box::CountEdges() const\r
1438 {\r
1439     if (!m_pNode) {\r
1440         return 0;\r
1441     }\r
1442     return m_pNode->CountChildren(XFA_ELEMENT_Edge);\r
1443 }\r
1444 CXFA_Edge CXFA_Box::GetEdge(int32_t nIndex) const\r
1445 {\r
1446     if (!m_pNode) {\r
1447         return NULL;\r
1448     }\r
1449     return CXFA_Edge(m_pNode->GetProperty(nIndex, XFA_ELEMENT_Edge, nIndex == 0));\r
1450 }\r
1451 static void XFA_BOX_GetStrokes(CXFA_Node *pNode, CXFA_StrokeArray &strokes, FX_BOOL bNULL)\r
1452 {\r
1453     strokes.RemoveAll();\r
1454     if (!pNode) {\r
1455         return;\r
1456     }\r
1457     strokes.SetSize(8);\r
1458     int32_t i, j;\r
1459     for (i = 0, j = 0; i < 4; i ++) {\r
1460         CXFA_Corner corner = CXFA_Corner(pNode->GetProperty(i, XFA_ELEMENT_Corner, i == 0));\r
1461         if (corner.IsExistInXML() || i == 0) {\r
1462             strokes.SetAt(j, corner);\r
1463         } else if (bNULL) {\r
1464             strokes.SetAt(j, NULL);\r
1465         } else if (i == 1) {\r
1466             strokes.SetAt(j, strokes[0]);\r
1467         } else if (i == 2) {\r
1468             strokes.SetAt(j, strokes[0]);\r
1469         } else {\r
1470             strokes.SetAt(j, strokes[2]);\r
1471         }\r
1472         j ++;\r
1473         CXFA_Edge edge = CXFA_Edge(pNode->GetProperty(i, XFA_ELEMENT_Edge, i == 0));\r
1474         if (edge.IsExistInXML() || i == 0) {\r
1475             strokes.SetAt(j, edge);\r
1476         } else if (bNULL) {\r
1477             strokes.SetAt(j, NULL);\r
1478         } else if (i == 1) {\r
1479             strokes.SetAt(j, strokes[1]);\r
1480         } else if (i == 2) {\r
1481             strokes.SetAt(j, strokes[1]);\r
1482         } else {\r
1483             strokes.SetAt(j, strokes[3]);\r
1484         }\r
1485         j ++;\r
1486     }\r
1487 }\r
1488 void CXFA_Box::GetStrokes(CXFA_StrokeArray &strokes) const\r
1489 {\r
1490     XFA_BOX_GetStrokes(m_pNode, strokes, FALSE);\r
1491 }\r
1492 FX_BOOL CXFA_Box::IsCircular() const\r
1493 {\r
1494     if (!m_pNode) {\r
1495         return FALSE;\r
1496     }\r
1497     return m_pNode->GetBoolean(XFA_ATTRIBUTE_Circular);\r
1498 }\r
1499 FX_BOOL CXFA_Box::GetStartAngle(FX_FLOAT &fStartAngle) const\r
1500 {\r
1501     fStartAngle = 0;\r
1502     if (!m_pNode) {\r
1503         return FALSE;\r
1504     }\r
1505     CXFA_Measurement ms;\r
1506     FX_BOOL bRet = m_pNode->TryMeasure(XFA_ATTRIBUTE_StartAngle, ms, FALSE);\r
1507     if (bRet) {\r
1508         fStartAngle = ms.GetValue();\r
1509     }\r
1510     return bRet;\r
1511 }\r
1512 FX_BOOL CXFA_Box::GetSweepAngle(FX_FLOAT &fSweepAngle) const\r
1513 {\r
1514     fSweepAngle = 360;\r
1515     if (!m_pNode) {\r
1516         return FALSE;\r
1517     }\r
1518     CXFA_Measurement ms;\r
1519     FX_BOOL bRet = m_pNode->TryMeasure(XFA_ATTRIBUTE_SweepAngle, ms, FALSE);\r
1520     if (bRet) {\r
1521         fSweepAngle = ms.GetValue();\r
1522     }\r
1523     return bRet;\r
1524 }\r
1525 CXFA_Fill CXFA_Box::GetFill(FX_BOOL bModified) const\r
1526 {\r
1527     if (!m_pNode) {\r
1528         return NULL;\r
1529     }\r
1530     CXFA_Node *pFillNode = m_pNode->GetProperty(0, XFA_ELEMENT_Fill, bModified);\r
1531     return CXFA_Fill(pFillNode);\r
1532 }\r
1533 CXFA_Margin CXFA_Box::GetMargin() const\r
1534 {\r
1535     if (!m_pNode) {\r
1536         return NULL;\r
1537     }\r
1538     return CXFA_Margin(m_pNode->GetChild(0, XFA_ELEMENT_Margin));\r
1539 }\r
1540 static FX_BOOL XFA_BOX_SameStyles(const CXFA_StrokeArray &strokes)\r
1541 {\r
1542     int32_t iCount = strokes.GetSize();\r
1543     if (iCount < 1) {\r
1544         return TRUE;\r
1545     }\r
1546     CXFA_Stroke stroke1 = strokes[0];\r
1547     for (int32_t i = 1; i < iCount; i ++) {\r
1548         CXFA_Stroke stroke2 = strokes[i];\r
1549         if (!stroke2.IsExistInXML()) {\r
1550             continue;\r
1551         }\r
1552         if (!stroke1.IsExistInXML()) {\r
1553             stroke1 = stroke2;\r
1554         } else if (!stroke1.SameStyles(stroke2)) {\r
1555             return FALSE;\r
1556         }\r
1557     }\r
1558     return TRUE;\r
1559 }\r
1560 FX_BOOL CXFA_Box::SameStyles() const\r
1561 {\r
1562     if (IsArc()) {\r
1563         return TRUE;\r
1564     }\r
1565     CXFA_StrokeArray strokes;\r
1566     XFA_BOX_GetStrokes(m_pNode, strokes, TRUE);\r
1567     return XFA_BOX_SameStyles(strokes);\r
1568 }\r
1569 static int32_t XFA_BOX_3DStyle(const CXFA_StrokeArray &strokes, CXFA_Stroke &stroke)\r
1570 {\r
1571     int32_t iCount = strokes.GetSize();\r
1572     if (iCount < 1) {\r
1573         return 0;\r
1574     }\r
1575     stroke = strokes[0];\r
1576     for (int32_t i = 1; i < iCount; i ++) {\r
1577         CXFA_Stroke find = strokes[i];\r
1578         if (!find.IsExistInXML()) {\r
1579             continue;\r
1580         }\r
1581         if (!stroke.IsExistInXML()) {\r
1582             stroke = find;\r
1583         } else if (stroke.GetStrokeType() != find.GetStrokeType()) {\r
1584             stroke = find;\r
1585             break;\r
1586         }\r
1587     }\r
1588     int32_t iType = stroke.GetStrokeType();\r
1589     if (iType == XFA_ATTRIBUTEENUM_Lowered || iType == XFA_ATTRIBUTEENUM_Raised ||\r
1590             iType == XFA_ATTRIBUTEENUM_Etched || iType == XFA_ATTRIBUTEENUM_Embossed) {\r
1591         return iType;\r
1592     }\r
1593     return 0;\r
1594 }\r
1595 int32_t CXFA_Box::Get3DStyle(FX_BOOL &bVisible, FX_FLOAT &fThickness) const\r
1596 {\r
1597     if (IsArc()) {\r
1598         return 0;\r
1599     }\r
1600     CXFA_StrokeArray strokes;\r
1601     XFA_BOX_GetStrokes(m_pNode, strokes, TRUE);\r
1602     CXFA_Stroke stroke(NULL);\r
1603     int32_t iType = XFA_BOX_3DStyle(strokes, stroke);\r
1604     if (iType) {\r
1605         bVisible = stroke.IsVisible();\r
1606         fThickness = stroke.GetThickness();\r
1607     }\r
1608     return iType;\r
1609 }\r
1610 int32_t CXFA_Stroke::GetPresence() const\r
1611 {\r
1612     return m_pNode ? m_pNode->GetEnum(XFA_ATTRIBUTE_Presence) : XFA_ATTRIBUTEENUM_Invisible;\r
1613 }\r
1614 int32_t CXFA_Stroke::GetCapType() const\r
1615 {\r
1616     if (!m_pNode) {\r
1617         return XFA_ATTRIBUTEENUM_Square;\r
1618     }\r
1619     return m_pNode->GetEnum(XFA_ATTRIBUTE_Cap);\r
1620 }\r
1621 int32_t CXFA_Stroke::GetStrokeType() const\r
1622 {\r
1623     return m_pNode ? m_pNode->GetEnum(XFA_ATTRIBUTE_Stroke) : XFA_ATTRIBUTEENUM_Solid;\r
1624 }\r
1625 FX_FLOAT CXFA_Stroke::GetThickness() const\r
1626 {\r
1627     return GetMSThickness().ToUnit(XFA_UNIT_Pt);\r
1628 }\r
1629 CXFA_Measurement CXFA_Stroke::GetMSThickness() const\r
1630 {\r
1631     return m_pNode ? m_pNode->GetMeasure(XFA_ATTRIBUTE_Thickness) : XFA_GetAttributeDefaultValue_Measure(XFA_ELEMENT_Edge, XFA_ATTRIBUTE_Thickness, XFA_XDPPACKET_Form);\r
1632 }\r
1633 void CXFA_Stroke::SetThickness(FX_FLOAT fThickness)\r
1634 {\r
1635     if (!m_pNode) {\r
1636         return;\r
1637     }\r
1638     CXFA_Measurement thickness(fThickness, XFA_UNIT_Pt);\r
1639     m_pNode->SetMeasure(XFA_ATTRIBUTE_Thickness, thickness);\r
1640 }\r
1641 void CXFA_Stroke::SetMSThickness(CXFA_Measurement msThinkness)\r
1642 {\r
1643     if (!m_pNode) {\r
1644         return;\r
1645     }\r
1646     m_pNode->SetMeasure(XFA_ATTRIBUTE_Thickness, msThinkness);\r
1647 }\r
1648 FX_ARGB CXFA_Stroke::GetColor() const\r
1649 {\r
1650     if (!m_pNode) {\r
1651         return 0xFF000000;\r
1652     }\r
1653     CXFA_Node* pNode = m_pNode->GetChild(0, XFA_ELEMENT_Color);\r
1654     if (!pNode) {\r
1655         return 0xFF000000;\r
1656     }\r
1657     CFX_WideStringC wsColor;\r
1658     pNode->TryCData(XFA_ATTRIBUTE_Value, wsColor);\r
1659     return XFA_WStringToColor(wsColor);\r
1660 }\r
1661 void CXFA_Stroke::SetColor(FX_ARGB argb)\r
1662 {\r
1663     if (!m_pNode) {\r
1664         return;\r
1665     }\r
1666     CXFA_Node* pNode = m_pNode->GetProperty(0, XFA_ELEMENT_Color);\r
1667     CFX_WideString wsColor;\r
1668     int a, r, g, b;\r
1669     ArgbDecode(argb, a, r, g, b);\r
1670     wsColor.Format(L"%d,%d,%d", r, g, b);\r
1671     pNode->SetCData(XFA_ATTRIBUTE_Value, wsColor);\r
1672 }\r
1673 int32_t CXFA_Stroke::GetJoinType() const\r
1674 {\r
1675     return m_pNode ? m_pNode->GetEnum(XFA_ATTRIBUTE_Join) : XFA_ATTRIBUTEENUM_Square;\r
1676 }\r
1677 FX_BOOL CXFA_Stroke::IsInverted() const\r
1678 {\r
1679     return m_pNode ? m_pNode->GetBoolean(XFA_ATTRIBUTE_Inverted) : FALSE;\r
1680 }\r
1681 FX_FLOAT CXFA_Stroke::GetRadius() const\r
1682 {\r
1683     return m_pNode ? m_pNode->GetMeasure(XFA_ATTRIBUTE_Radius).ToUnit(XFA_UNIT_Pt) : 0;\r
1684 }\r
1685 FX_BOOL CXFA_Stroke::SameStyles(CXFA_Stroke stroke, FX_DWORD dwFlags) const\r
1686 {\r
1687     if (m_pNode == (CXFA_Node*)stroke) {\r
1688         return TRUE;\r
1689     }\r
1690     if (FXSYS_fabs(GetThickness() - stroke.GetThickness()) >= 0.01f) {\r
1691         return FALSE;\r
1692     }\r
1693     if ((dwFlags & XFA_STROKE_SAMESTYLE_NoPresence) == 0 && IsVisible() != stroke.IsVisible()) {\r
1694         return FALSE;\r
1695     }\r
1696     if (GetStrokeType() != stroke.GetStrokeType()) {\r
1697         return FALSE;\r
1698     }\r
1699     if (GetColor() != stroke.GetColor()) {\r
1700         return FALSE;\r
1701     }\r
1702     if ((dwFlags & XFA_STROKE_SAMESTYLE_Corner) != 0 && FXSYS_fabs(GetRadius() - stroke.GetRadius()) >= 0.01f) {\r
1703         return FALSE;\r
1704     }\r
1705     return TRUE;\r
1706 }\r
1707 FX_FLOAT XFA_GetEdgeThickness(const CXFA_StrokeArray &strokes, FX_BOOL b3DStyle, int32_t nIndex)\r
1708 {\r
1709     FX_FLOAT fThickness = 0;\r
1710     {\r
1711         if (strokes[nIndex * 2 + 1].GetPresence() == XFA_ATTRIBUTEENUM_Visible) {\r
1712             if (nIndex == 0) {\r
1713                 fThickness += 2.5f;\r
1714             }\r
1715             fThickness += strokes[nIndex * 2 + 1].GetThickness() * (b3DStyle ? 4 : 2);\r
1716         }\r
1717     }\r
1718     return fThickness;\r
1719 }\r
1720 CXFA_WidgetData::CXFA_WidgetData(CXFA_Node *pNode)\r
1721     : CXFA_Data(pNode)\r
1722     , m_bIsNull(TRUE)\r
1723     , m_bPreNull(TRUE)\r
1724     , m_pUiChildNode(NULL)\r
1725     , m_eUIType(XFA_ELEMENT_UNKNOWN)\r
1726 {\r
1727 }\r
1728 CXFA_Node* CXFA_WidgetData::GetUIChild()\r
1729 {\r
1730     if (m_eUIType == XFA_ELEMENT_UNKNOWN) {\r
1731         m_pUiChildNode = XFA_CreateUIChild(m_pNode, m_eUIType);\r
1732     }\r
1733     return m_pUiChildNode;\r
1734 }\r
1735 XFA_ELEMENT CXFA_WidgetData::GetUIType()\r
1736 {\r
1737     GetUIChild();\r
1738     return m_eUIType;\r
1739 }\r
1740 CFX_WideString  CXFA_WidgetData::GetRawValue()\r
1741 {\r
1742     return m_pNode->GetContent();\r
1743 }\r
1744 int32_t CXFA_WidgetData::GetAccess(FX_BOOL bTemplate)\r
1745 {\r
1746     if (bTemplate) {\r
1747         CXFA_Node* pNode = m_pNode->GetTemplateNode();\r
1748         if (pNode) {\r
1749             return pNode->GetEnum(XFA_ATTRIBUTE_Access);\r
1750         }\r
1751         return XFA_ATTRIBUTEENUM_Open;\r
1752     }\r
1753     CXFA_Node* pNode = m_pNode;\r
1754     while (pNode) {\r
1755         int32_t iAcc = pNode->GetEnum(XFA_ATTRIBUTE_Access);\r
1756         if (iAcc != XFA_ATTRIBUTEENUM_Open) {\r
1757             return iAcc;\r
1758         }\r
1759         pNode = pNode->GetNodeItem(XFA_NODEITEM_Parent, XFA_OBJECTTYPE_ContainerNode);\r
1760     }\r
1761     return XFA_ATTRIBUTEENUM_Open;\r
1762 }\r
1763 FX_BOOL CXFA_WidgetData::GetAccessKey(CFX_WideStringC &wsAccessKey)\r
1764 {\r
1765     return m_pNode->TryCData(XFA_ATTRIBUTE_AccessKey, wsAccessKey);\r
1766 }\r
1767 int32_t CXFA_WidgetData::GetAnchorType()\r
1768 {\r
1769     return m_pNode->GetEnum(XFA_ATTRIBUTE_AnchorType);\r
1770 }\r
1771 int32_t CXFA_WidgetData::GetColSpan()\r
1772 {\r
1773     return m_pNode->GetInteger(XFA_ATTRIBUTE_ColSpan);\r
1774 }\r
1775 int32_t CXFA_WidgetData::GetPresence()\r
1776 {\r
1777     return m_pNode->GetEnum(XFA_ATTRIBUTE_Presence);\r
1778     CXFA_Node* pNode = m_pNode;\r
1779     while (pNode && pNode->GetObjectType() == XFA_OBJECTTYPE_ContainerNode) {\r
1780         int32_t iAcc = pNode->GetEnum(XFA_ATTRIBUTE_Presence);\r
1781         if ( iAcc != XFA_ATTRIBUTEENUM_Visible) {\r
1782             return iAcc;\r
1783         }\r
1784         pNode = pNode->GetNodeItem(XFA_NODEITEM_Parent);\r
1785     }\r
1786     return XFA_ATTRIBUTEENUM_Visible;\r
1787 }\r
1788 int32_t CXFA_WidgetData::GetRotate()\r
1789 {\r
1790     CXFA_Measurement ms;\r
1791     if (!m_pNode->TryMeasure(XFA_ATTRIBUTE_Rotate, ms, FALSE)) {\r
1792         return 0;\r
1793     }\r
1794     int32_t iRotate =  FXSYS_round(ms.GetValue());\r
1795     iRotate = XFA_MapRotation(iRotate);\r
1796     return iRotate / 90 * 90;\r
1797 }\r
1798 CXFA_Border CXFA_WidgetData::GetBorder(FX_BOOL bModified)\r
1799 {\r
1800     return CXFA_Border(m_pNode->GetProperty(0, XFA_ELEMENT_Border, bModified));\r
1801 }\r
1802 CXFA_Caption CXFA_WidgetData::GetCaption(FX_BOOL bModified )\r
1803 {\r
1804     return CXFA_Caption(m_pNode->GetProperty(0, XFA_ELEMENT_Caption, bModified));\r
1805 }\r
1806 CXFA_Font CXFA_WidgetData::GetFont(FX_BOOL bModified )\r
1807 {\r
1808     return CXFA_Font(m_pNode->GetProperty(0, XFA_ELEMENT_Font, bModified));\r
1809 }\r
1810 CXFA_Margin CXFA_WidgetData::GetMargin(FX_BOOL bModified )\r
1811 {\r
1812     return CXFA_Margin(m_pNode->GetProperty(0, XFA_ELEMENT_Margin, bModified));\r
1813 }\r
1814 CXFA_Para CXFA_WidgetData::GetPara(FX_BOOL bModified )\r
1815 {\r
1816     return CXFA_Para(m_pNode->GetProperty(0, XFA_ELEMENT_Para, bModified));\r
1817 }\r
1818 CXFA_Keep CXFA_WidgetData::GetKeep(FX_BOOL bModified )\r
1819 {\r
1820     return CXFA_Keep(m_pNode->GetProperty(0, XFA_ELEMENT_Keep, bModified), m_pNode);\r
1821 }\r
1822 void CXFA_WidgetData::GetEventList(CXFA_NodeArray &events)\r
1823 {\r
1824     m_pNode->GetNodeList(events, 0, XFA_ELEMENT_Event);\r
1825 }\r
1826 int32_t CXFA_WidgetData::GetEventByActivity(int32_t iActivity, CXFA_NodeArray &events, FX_BOOL bIsFormReady)\r
1827 {\r
1828     CXFA_NodeArray allEvents;\r
1829     GetEventList(allEvents);\r
1830     int32_t iCount = allEvents.GetSize();\r
1831     for (int32_t i = 0; i < iCount; i++) {\r
1832         CXFA_Event event(allEvents[i]);\r
1833         if (event.GetActivity() == iActivity) {\r
1834             if (iActivity == XFA_ATTRIBUTEENUM_Ready) {\r
1835                 CFX_WideStringC wsRef;\r
1836                 event.GetRef(wsRef);\r
1837                 if (bIsFormReady) {\r
1838                     if (wsRef == CFX_WideStringC(L"$form")) {\r
1839                         events.Add(allEvents[i]);\r
1840                     }\r
1841                 } else {\r
1842                     if (wsRef == CFX_WideStringC(L"$layout")) {\r
1843                         events.Add(allEvents[i]);\r
1844                     }\r
1845                 }\r
1846             } else {\r
1847                 events.Add(allEvents[i]);\r
1848             }\r
1849         }\r
1850     }\r
1851     return events.GetSize();\r
1852 }\r
1853 CXFA_Value CXFA_WidgetData::GetDefaultValue(FX_BOOL bModified )\r
1854 {\r
1855     CXFA_Node* pTemNode = m_pNode->GetTemplateNode();\r
1856     return pTemNode ? pTemNode->GetProperty(0, XFA_ELEMENT_Value, bModified) : NULL;\r
1857 }\r
1858 CXFA_Value CXFA_WidgetData::GetFormValue(FX_BOOL bModified )\r
1859 {\r
1860     return m_pNode->GetProperty(0, XFA_ELEMENT_Value, bModified);\r
1861 }\r
1862 CXFA_Calculate CXFA_WidgetData::GetCalculate(FX_BOOL bModified )\r
1863 {\r
1864     return m_pNode->GetProperty(0, XFA_ELEMENT_Calculate, bModified);\r
1865 }\r
1866 CXFA_Validate CXFA_WidgetData::GetValidate(FX_BOOL bModified)\r
1867 {\r
1868     return m_pNode->GetProperty(0, XFA_ELEMENT_Validate, bModified);\r
1869 }\r
1870 CXFA_Variables CXFA_WidgetData::GetVariables(FX_BOOL bModified )\r
1871 {\r
1872     return m_pNode->GetProperty(0, XFA_ELEMENT_Variables, bModified);\r
1873 }\r
1874 CXFA_Bind CXFA_WidgetData::GetBind(FX_BOOL bModified )\r
1875 {\r
1876     return m_pNode->GetProperty(0, XFA_ELEMENT_Bind, bModified);\r
1877 }\r
1878 CXFA_Assist CXFA_WidgetData::GetAssist(FX_BOOL bModified )\r
1879 {\r
1880     return m_pNode->GetProperty(0, XFA_ELEMENT_Assist, bModified);\r
1881 }\r
1882 void CXFA_WidgetData::GetRelevant(CFX_WideStringC &wsRelevant)\r
1883 {\r
1884     m_pNode->TryCData(XFA_ATTRIBUTE_Relevant, wsRelevant);\r
1885 }\r
1886 FX_BOOL CXFA_WidgetData::GetWidth(FX_FLOAT &fWidth)\r
1887 {\r
1888     return TryMeasure(XFA_ATTRIBUTE_W, fWidth);\r
1889 }\r
1890 FX_BOOL CXFA_WidgetData::GetHeight(FX_FLOAT &fHeight)\r
1891 {\r
1892     return TryMeasure(XFA_ATTRIBUTE_H, fHeight);\r
1893 }\r
1894 FX_BOOL CXFA_WidgetData::GetMinWidth(FX_FLOAT &fMinWidth)\r
1895 {\r
1896     return TryMeasure(XFA_ATTRIBUTE_MinW, fMinWidth);\r
1897 }\r
1898 FX_BOOL CXFA_WidgetData::GetMinHeight(FX_FLOAT &fMinHeight)\r
1899 {\r
1900     return TryMeasure(XFA_ATTRIBUTE_MinH, fMinHeight);\r
1901 }\r
1902 FX_BOOL CXFA_WidgetData::GetMaxWidth(FX_FLOAT &fMaxWidth)\r
1903 {\r
1904     return TryMeasure(XFA_ATTRIBUTE_MaxW, fMaxWidth);\r
1905 }\r
1906 FX_BOOL CXFA_WidgetData::GetMaxHeight(FX_FLOAT &fMaxHeight)\r
1907 {\r
1908     return TryMeasure(XFA_ATTRIBUTE_MaxH, fMaxHeight);\r
1909 }\r
1910 CXFA_BindItems CXFA_WidgetData::GetBindItems()\r
1911 {\r
1912     return m_pNode->GetChild(0, XFA_ELEMENT_BindItems);\r
1913 }\r
1914 FX_BOOL CXFA_WidgetData::SetAccess(int32_t iAccess, FX_BOOL bNotify)\r
1915 {\r
1916     return m_pNode->SetEnum(XFA_ATTRIBUTE_Access, (XFA_ATTRIBUTEENUM)iAccess, bNotify);\r
1917 }\r
1918 FX_BOOL CXFA_WidgetData::SetAccessKey(const CFX_WideString& wsAccessKey)\r
1919 {\r
1920     return m_pNode->SetCData(XFA_ATTRIBUTE_AccessKey, wsAccessKey);\r
1921 }\r
1922 FX_BOOL CXFA_WidgetData::SetAnchorType(int32_t iType)\r
1923 {\r
1924     return m_pNode->SetEnum(XFA_ATTRIBUTE_AnchorType, (XFA_ATTRIBUTEENUM)iType);\r
1925 }\r
1926 FX_BOOL CXFA_WidgetData::SetColSpan(int32_t iColSpan)\r
1927 {\r
1928     return m_pNode->SetInteger(XFA_ATTRIBUTE_ColSpan, (XFA_ATTRIBUTEENUM)iColSpan);\r
1929 }\r
1930 FX_BOOL CXFA_WidgetData::SetPresence(int32_t iPresence)\r
1931 {\r
1932     return m_pNode->SetEnum(XFA_ATTRIBUTE_Presence, (XFA_ATTRIBUTEENUM)iPresence);\r
1933 }\r
1934 FX_BOOL CXFA_WidgetData::SetRotate(int32_t iRotate)\r
1935 {\r
1936     iRotate = XFA_MapRotation(iRotate);\r
1937     CXFA_Measurement ms((FX_FLOAT)iRotate, XFA_UNIT_Angle);\r
1938     return m_pNode->SetMeasure(XFA_ATTRIBUTE_Rotate, ms);\r
1939 }\r
1940 FX_BOOL CXFA_WidgetData::SetRelevant(const CFX_WideString& wsRelevant)\r
1941 {\r
1942     return m_pNode->SetCData(XFA_ATTRIBUTE_Relevant, wsRelevant);\r
1943 }\r
1944 FX_BOOL CXFA_WidgetData::SetStatus(FX_DWORD dwStatus)\r
1945 {\r
1946     return FALSE;\r
1947 }\r
1948 FX_BOOL CXFA_WidgetData::SetWidth(FX_FLOAT fWidth)\r
1949 {\r
1950     return SetMeasure(XFA_ATTRIBUTE_W, fWidth);\r
1951 }\r
1952 FX_BOOL CXFA_WidgetData::SetHeight(FX_FLOAT fHeight)\r
1953 {\r
1954     return SetMeasure(XFA_ATTRIBUTE_H, fHeight);\r
1955 }\r
1956 FX_BOOL CXFA_WidgetData::SetMinWidth(FX_FLOAT fMinWidth)\r
1957 {\r
1958     return SetMeasure(XFA_ATTRIBUTE_MinW, fMinWidth);\r
1959 }\r
1960 FX_BOOL CXFA_WidgetData::SetMinHeight(FX_FLOAT fMinHeight)\r
1961 {\r
1962     return SetMeasure(XFA_ATTRIBUTE_MinH, fMinHeight);\r
1963 }\r
1964 FX_BOOL CXFA_WidgetData::SetMaxWidth(FX_FLOAT fMaxWidth)\r
1965 {\r
1966     return SetMeasure(XFA_ATTRIBUTE_MaxW, fMaxWidth);\r
1967 }\r
1968 FX_BOOL CXFA_WidgetData::SetMaxHeight(FX_FLOAT fMaxHeight)\r
1969 {\r
1970     return SetMeasure(XFA_ATTRIBUTE_MaxH, fMaxHeight);\r
1971 }\r
1972 FX_BOOL CXFA_WidgetData::SetPos(FX_FLOAT x, FX_FLOAT y)\r
1973 {\r
1974     return SetMeasure(XFA_ATTRIBUTE_X, x) && SetMeasure(XFA_ATTRIBUTE_Y, y);\r
1975 }\r
1976 FX_BOOL CXFA_WidgetData::SetName(const CFX_WideString& wsName)\r
1977 {\r
1978     return m_pNode->SetCData(XFA_ATTRIBUTE_Name, wsName);\r
1979 }\r
1980 FX_BOOL CXFA_WidgetData::SetButtonHighlight(int32_t iButtonHighlight)\r
1981 {\r
1982     CXFA_Node* pUiChildNode = GetUIChild();\r
1983     return pUiChildNode->SetEnum(XFA_ATTRIBUTE_Highlight, (XFA_ATTRIBUTEENUM)iButtonHighlight);\r
1984 }\r
1985 FX_BOOL CXFA_WidgetData::SetButtonRollover(const CFX_WideString &wsRollover, FX_BOOL bRichText)\r
1986 {\r
1987     return FALSE;\r
1988 }\r
1989 FX_BOOL CXFA_WidgetData::SetButtonDown(const CFX_WideString& wsDown, FX_BOOL bRichText)\r
1990 {\r
1991     return FALSE;\r
1992 }\r
1993 FX_BOOL CXFA_WidgetData::SetCheckButtonShape(int32_t iCheckButtonShape)\r
1994 {\r
1995     CXFA_Node* pUiChildNode = GetUIChild();\r
1996     return pUiChildNode->SetEnum(XFA_ATTRIBUTE_Shape, (XFA_ATTRIBUTEENUM)iCheckButtonShape);\r
1997 }\r
1998 FX_BOOL CXFA_WidgetData::SetCheckButtonMark(int32_t iCheckButtonMark)\r
1999 {\r
2000     CXFA_Node* pUiChildNode = GetUIChild();\r
2001     return pUiChildNode->SetEnum(XFA_ATTRIBUTE_Mark, (XFA_ATTRIBUTEENUM)iCheckButtonMark);\r
2002 }\r
2003 FX_BOOL CXFA_WidgetData::SetCheckButtonSize(FX_FLOAT fCheckButtonMark)\r
2004 {\r
2005     CXFA_Node* pUiChildNode = GetUIChild();\r
2006     if (pUiChildNode) {\r
2007         CXFA_Measurement ms(fCheckButtonMark, XFA_UNIT_Pt);\r
2008         return pUiChildNode->SetMeasure(XFA_ATTRIBUTE_Size, ms);\r
2009     }\r
2010     return FALSE;\r
2011 }\r
2012 CXFA_Border CXFA_WidgetData::GetUIBorder(FX_BOOL bModified )\r
2013 {\r
2014     CXFA_Node* pUIChild = GetUIChild();\r
2015     return pUIChild ? pUIChild->GetProperty(0, XFA_ELEMENT_Border, bModified) : NULL;\r
2016 }\r
2017 CXFA_Margin CXFA_WidgetData::GetUIMargin(FX_BOOL bModified )\r
2018 {\r
2019     CXFA_Node* pUIChild = GetUIChild();\r
2020     return pUIChild ? pUIChild->GetProperty(0, XFA_ELEMENT_Margin, bModified) : NULL;\r
2021 }\r
2022 void CXFA_WidgetData::GetUIMargin(CFX_RectF &rtUIMargin)\r
2023 {\r
2024     rtUIMargin.Reset();\r
2025     CXFA_Margin mgUI = GetUIMargin();\r
2026     if (!mgUI) {\r
2027         return;\r
2028     }\r
2029     CXFA_Border border = GetUIBorder();\r
2030     if (border && border.GetPresence() != XFA_ATTRIBUTEENUM_Visible) {\r
2031         return;\r
2032     }\r
2033     FX_FLOAT fLeftInset, fTopInset, fRightInset, fBottomInset;\r
2034     FX_BOOL bLeft = mgUI.GetLeftInset(fLeftInset);\r
2035     FX_BOOL bTop = mgUI.GetTopInset(fTopInset);\r
2036     FX_BOOL bRight = mgUI.GetRightInset(fRightInset);\r
2037     FX_BOOL bBottom = mgUI.GetBottomInset(fBottomInset);\r
2038     if (border) {\r
2039         FX_BOOL bVisible = FALSE;\r
2040         FX_FLOAT fThickness = 0;\r
2041         border.Get3DStyle(bVisible, fThickness);\r
2042         if (!bLeft || !bTop || !bRight || !bBottom) {\r
2043             CXFA_StrokeArray strokes;\r
2044             border.GetStrokes(strokes);\r
2045             if (!bTop) {\r
2046                 fTopInset = XFA_GetEdgeThickness(strokes, bVisible, 0);\r
2047             }\r
2048             if (!bRight) {\r
2049                 fRightInset = XFA_GetEdgeThickness(strokes, bVisible, 1);\r
2050             }\r
2051             if (!bBottom) {\r
2052                 fBottomInset = XFA_GetEdgeThickness(strokes, bVisible, 2);\r
2053             }\r
2054             if (!bLeft) {\r
2055                 fLeftInset = XFA_GetEdgeThickness(strokes, bVisible, 3);\r
2056             }\r
2057         }\r
2058     }\r
2059     rtUIMargin.Set(fLeftInset, fTopInset, fRightInset, fBottomInset);\r
2060 }\r
2061 int32_t CXFA_WidgetData::GetButtonHighlight()\r
2062 {\r
2063     CXFA_Node* pUIChild = GetUIChild();\r
2064     if (pUIChild) {\r
2065         return pUIChild->GetEnum(XFA_ATTRIBUTE_Highlight);\r
2066     }\r
2067     return XFA_GetAttributeDefaultValue_Enum(XFA_ELEMENT_Button, XFA_ATTRIBUTE_Highlight, XFA_XDPPACKET_Form);\r
2068 }\r
2069 FX_BOOL CXFA_WidgetData::GetButtonRollover(CFX_WideString &wsRollover, FX_BOOL &bRichText)\r
2070 {\r
2071     if (CXFA_Node* pItems = m_pNode->GetChild(0, XFA_ELEMENT_Items)) {\r
2072         CXFA_Node* pText = pItems->GetNodeItem(XFA_NODEITEM_FirstChild);\r
2073         while (pText) {\r
2074             CFX_WideStringC wsName;\r
2075             pText->TryCData(XFA_ATTRIBUTE_Name, wsName);\r
2076             if (wsName == FX_WSTRC(L"rollover")) {\r
2077                 pText->TryContent(wsRollover);\r
2078                 bRichText = pText->GetClassID() == XFA_ELEMENT_ExData;\r
2079                 return !wsRollover.IsEmpty();\r
2080             }\r
2081             pText = pText->GetNodeItem(XFA_NODEITEM_NextSibling);\r
2082         }\r
2083     }\r
2084     return FALSE;\r
2085 }\r
2086 FX_BOOL CXFA_WidgetData::GetButtonDown(CFX_WideString &wsDown, FX_BOOL &bRichText)\r
2087 {\r
2088     if (CXFA_Node* pItems = m_pNode->GetChild(0, XFA_ELEMENT_Items)) {\r
2089         CXFA_Node* pText = pItems->GetNodeItem(XFA_NODEITEM_FirstChild);\r
2090         while(pText) {\r
2091             CFX_WideStringC wsName;\r
2092             pText->TryCData(XFA_ATTRIBUTE_Name, wsName);\r
2093             if (wsName == FX_WSTRC(L"down")) {\r
2094                 pText->TryContent(wsDown);\r
2095                 bRichText = pText->GetClassID() == XFA_ELEMENT_ExData;\r
2096                 return !wsDown.IsEmpty();\r
2097             }\r
2098             pText = pText->GetNodeItem(XFA_NODEITEM_NextSibling);\r
2099         }\r
2100     }\r
2101     return FALSE;\r
2102 }\r
2103 int32_t CXFA_WidgetData::GetCheckButtonShape()\r
2104 {\r
2105     CXFA_Node* pUIChild = GetUIChild();\r
2106     if (pUIChild) {\r
2107         return pUIChild->GetEnum(XFA_ATTRIBUTE_Shape);\r
2108     }\r
2109     return XFA_GetAttributeDefaultValue_Enum(XFA_ELEMENT_CheckButton, XFA_ATTRIBUTE_Shape, XFA_XDPPACKET_Form);\r
2110 }\r
2111 int32_t CXFA_WidgetData::GetCheckButtonMark()\r
2112 {\r
2113     CXFA_Node* pUIChild = GetUIChild();\r
2114     if (pUIChild) {\r
2115         return pUIChild->GetEnum(XFA_ATTRIBUTE_Mark);\r
2116     }\r
2117     return XFA_GetAttributeDefaultValue_Enum(XFA_ELEMENT_CheckButton, XFA_ATTRIBUTE_Mark, XFA_XDPPACKET_Form);\r
2118 }\r
2119 FX_BOOL CXFA_WidgetData::IsRadioButton()\r
2120 {\r
2121     if (CXFA_Node* pParent = m_pNode->GetNodeItem(XFA_NODEITEM_Parent)) {\r
2122         return pParent->GetClassID() == XFA_ELEMENT_ExclGroup;\r
2123     }\r
2124     return FALSE;\r
2125 }\r
2126 FX_FLOAT CXFA_WidgetData::GetCheckButtonSize()\r
2127 {\r
2128     CXFA_Node* pUIChild = GetUIChild();\r
2129     if (pUIChild) {\r
2130         return pUIChild->GetMeasure(XFA_ATTRIBUTE_Size).ToUnit(XFA_UNIT_Pt);\r
2131     }\r
2132     return XFA_GetAttributeDefaultValue_Measure(XFA_ELEMENT_CheckButton, XFA_ATTRIBUTE_Size, XFA_XDPPACKET_Form).ToUnit(XFA_UNIT_Pt);\r
2133 }\r
2134 FX_BOOL CXFA_WidgetData::IsAllowNeutral()\r
2135 {\r
2136     CXFA_Node* pUIChild = GetUIChild();\r
2137     if (pUIChild) {\r
2138         return pUIChild->GetBoolean(XFA_ATTRIBUTE_AllowNeutral);\r
2139     }\r
2140     return XFA_GetAttributeDefaultValue_Boolean(XFA_ELEMENT_CheckButton, XFA_ATTRIBUTE_AllowNeutral, XFA_XDPPACKET_Form);\r
2141 }\r
2142 XFA_CHECKSTATE CXFA_WidgetData::GetCheckState()\r
2143 {\r
2144     CFX_WideString wsValue = GetRawValue();\r
2145     if (wsValue.IsEmpty()) {\r
2146         return XFA_CHECKSTATE_Off;\r
2147     }\r
2148     if (CXFA_Node* pItems = m_pNode->GetChild(0, XFA_ELEMENT_Items)) {\r
2149         CXFA_Node* pText = pItems->GetNodeItem(XFA_NODEITEM_FirstChild);\r
2150         int32_t i = 0;\r
2151         while(pText) {\r
2152             CFX_WideString wsContent;\r
2153             if (pText->TryContent(wsContent) && (wsContent == wsValue)) {\r
2154                 return (XFA_CHECKSTATE)i;\r
2155             }\r
2156             i++;\r
2157             pText = pText->GetNodeItem(XFA_NODEITEM_NextSibling);\r
2158         }\r
2159     }\r
2160     return XFA_CHECKSTATE_Off;\r
2161 }\r
2162 void CXFA_WidgetData::SetCheckState(XFA_CHECKSTATE eCheckState, FX_BOOL bNotify)\r
2163 {\r
2164     if (CXFA_WidgetData exclGroup = GetExclGroupNode()) {\r
2165         CFX_WideString wsValue;\r
2166         if (eCheckState != XFA_CHECKSTATE_Off) {\r
2167             if (CXFA_Node* pItems = m_pNode->GetChild(0, XFA_ELEMENT_Items)) {\r
2168                 CXFA_Node* pText = pItems->GetNodeItem(XFA_NODEITEM_FirstChild);\r
2169                 if (pText) {\r
2170                     pText->TryContent(wsValue);\r
2171                 }\r
2172             }\r
2173         }\r
2174         CXFA_Node* pChild = ((CXFA_Node*)exclGroup)->GetNodeItem(XFA_NODEITEM_FirstChild);\r
2175         for (; pChild; pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {\r
2176             if (pChild->GetClassID() != XFA_ELEMENT_Field) {\r
2177                 continue;\r
2178             }\r
2179             CXFA_Node* pItem = pChild->GetChild(0, XFA_ELEMENT_Items);\r
2180             if (!pItem) {\r
2181                 continue;\r
2182             }\r
2183             CXFA_Node* pItemchild = pItem->GetNodeItem(XFA_NODEITEM_FirstChild);\r
2184             if (!pItemchild) {\r
2185                 continue;\r
2186             }\r
2187             CFX_WideString text = pItemchild->GetContent();\r
2188             CFX_WideString wsChildValue = text;\r
2189             if (wsValue != text) {\r
2190                 pItemchild = pItemchild->GetNodeItem(XFA_NODEITEM_NextSibling);\r
2191                 if (pItemchild) {\r
2192                     wsChildValue = pItemchild->GetContent();\r
2193                 } else {\r
2194                     wsChildValue.Empty();\r
2195                 }\r
2196             }\r
2197             CXFA_WidgetData ch(pChild);\r
2198             ch.SyncValue(wsChildValue, bNotify);\r
2199         }\r
2200         exclGroup.SyncValue(wsValue, bNotify);\r
2201     } else {\r
2202         CXFA_Node* pItems = m_pNode->GetChild(0, XFA_ELEMENT_Items);\r
2203         if (!pItems) {\r
2204             return;\r
2205         }\r
2206         int32_t i = -1;\r
2207         CXFA_Node* pText = pItems->GetNodeItem(XFA_NODEITEM_FirstChild);\r
2208         CFX_WideString wsContent;\r
2209         while (pText) {\r
2210             i++;\r
2211             if (i == eCheckState) {\r
2212                 pText->TryContent(wsContent);\r
2213                 break;\r
2214             }\r
2215             pText = pText->GetNodeItem(XFA_NODEITEM_NextSibling);\r
2216         }\r
2217         SyncValue(wsContent, bNotify);\r
2218     }\r
2219 }\r
2220 CXFA_Node*      CXFA_WidgetData::GetExclGroupNode()\r
2221 {\r
2222     CXFA_Node* pExcl = (CXFA_Node*)m_pNode->GetNodeItem(XFA_NODEITEM_Parent);\r
2223     if (!pExcl || pExcl->GetClassID() != XFA_ELEMENT_ExclGroup) {\r
2224         return NULL;\r
2225     }\r
2226     return pExcl;\r
2227 }\r
2228 CXFA_Node* CXFA_WidgetData::GetSelectedMember()\r
2229 {\r
2230     CXFA_Node *pSelectedMember = NULL;\r
2231     CFX_WideString wsState = GetRawValue();\r
2232     if (wsState.IsEmpty()) {\r
2233         return pSelectedMember;\r
2234     }\r
2235     for (CXFA_Node *pNode = (CXFA_Node*)m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild); pNode != NULL; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {\r
2236         CXFA_WidgetData widgetData(pNode);\r
2237         if (widgetData.GetCheckState() == XFA_CHECKSTATE_On) {\r
2238             pSelectedMember = pNode;\r
2239             break;\r
2240         }\r
2241     }\r
2242     return pSelectedMember;\r
2243 }\r
2244 CXFA_Node* CXFA_WidgetData::SetSelectedMember(FX_WSTR wsName, FX_BOOL bNotify)\r
2245 {\r
2246     CXFA_Node *pSelectedMember = NULL;\r
2247     FX_DWORD nameHash = FX_HashCode_String_GetW(wsName.GetPtr(), wsName.GetLength());\r
2248     for (CXFA_Node *pNode = (CXFA_Node*)m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild); pNode != NULL; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {\r
2249         if (pNode->GetNameHash() == nameHash) {\r
2250             CXFA_WidgetData widgetData(pNode);\r
2251             widgetData.SetCheckState(XFA_CHECKSTATE_On, bNotify);\r
2252             pSelectedMember = pNode;\r
2253             break;\r
2254         }\r
2255     }\r
2256     return pSelectedMember;\r
2257 }\r
2258 void CXFA_WidgetData::SetSelectedMemberByValue(FX_WSTR wsValue, FX_BOOL bNotify, FX_BOOL bScriptModify, FX_BOOL bSyncData)\r
2259 {\r
2260     CFX_WideString wsExclGroup;\r
2261     for (CXFA_Node *pNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild); pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {\r
2262         if (pNode->GetClassID() != XFA_ELEMENT_Field) {\r
2263             continue;\r
2264         }\r
2265         CXFA_Node* pItem = pNode->GetChild(0, XFA_ELEMENT_Items);\r
2266         if (!pItem) {\r
2267             continue;\r
2268         }\r
2269         CXFA_Node* pItemchild = pItem->GetNodeItem(XFA_NODEITEM_FirstChild);\r
2270         if (!pItemchild) {\r
2271             continue;\r
2272         }\r
2273         CFX_WideString wsChildValue = pItemchild->GetContent();\r
2274         if (wsValue != wsChildValue) {\r
2275             pItemchild = pItemchild->GetNodeItem(XFA_NODEITEM_NextSibling);\r
2276             if (pItemchild) {\r
2277                 wsChildValue = pItemchild->GetContent();\r
2278             } else {\r
2279                 wsChildValue.Empty();\r
2280             }\r
2281         } else {\r
2282             wsExclGroup = wsValue;\r
2283         }\r
2284         pNode->SetContent(wsChildValue, wsChildValue, bNotify, bScriptModify, FALSE);\r
2285     }\r
2286     if (m_pNode) {\r
2287         m_pNode->SetContent(wsExclGroup, wsExclGroup, bNotify, bScriptModify, bSyncData);\r
2288     }\r
2289 }\r
2290 CXFA_Node* CXFA_WidgetData::GetExclGroupFirstMember()\r
2291 {\r
2292     CXFA_Node* pExcl = GetNode();\r
2293     if (!pExcl) {\r
2294         return NULL;\r
2295     }\r
2296     CXFA_Node* pNode = pExcl->GetNodeItem(XFA_NODEITEM_FirstChild);\r
2297     while (pNode) {\r
2298         if (pNode->GetClassID() == XFA_ELEMENT_Field) {\r
2299             return pNode;\r
2300         }\r
2301         pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling);\r
2302     }\r
2303     return NULL;\r
2304 }\r
2305 CXFA_Node* CXFA_WidgetData::GetExclGroupNextMember(CXFA_Node* pNode)\r
2306 {\r
2307     if (!pNode) {\r
2308         return NULL;\r
2309     }\r
2310     CXFA_Node* pNodeField = pNode->GetNodeItem(XFA_NODEITEM_NextSibling);\r
2311     while (pNodeField) {\r
2312         if (pNodeField->GetClassID() == XFA_ELEMENT_Field) {\r
2313             return pNodeField;\r
2314         }\r
2315         pNodeField = pNodeField->GetNodeItem(XFA_NODEITEM_NextSibling);\r
2316     }\r
2317     return NULL;\r
2318 }\r
2319 int32_t CXFA_WidgetData::GetChoiceListCommitOn()\r
2320 {\r
2321     CXFA_Node* pUIChild = GetUIChild();\r
2322     if (pUIChild) {\r
2323         return pUIChild->GetEnum(XFA_ATTRIBUTE_CommitOn);\r
2324     }\r
2325     return XFA_GetAttributeDefaultValue_Enum(XFA_ELEMENT_ChoiceList, XFA_ATTRIBUTE_CommitOn, XFA_XDPPACKET_Form);\r
2326 }\r
2327 FX_BOOL CXFA_WidgetData::IsChoiceListAllowTextEntry()\r
2328 {\r
2329     CXFA_Node* pUIChild = GetUIChild();\r
2330     if (pUIChild) {\r
2331         return pUIChild->GetBoolean(XFA_ATTRIBUTE_TextEntry);\r
2332     }\r
2333     return XFA_GetAttributeDefaultValue_Boolean(XFA_ELEMENT_ChoiceList, XFA_ATTRIBUTE_TextEntry, XFA_XDPPACKET_Form);\r
2334 }\r
2335 int32_t CXFA_WidgetData::GetChoiceListOpen()\r
2336 {\r
2337     CXFA_Node* pUIChild = GetUIChild();\r
2338     if (pUIChild) {\r
2339         return pUIChild->GetEnum(XFA_ATTRIBUTE_Open);\r
2340     }\r
2341     return XFA_GetAttributeDefaultValue_Enum(XFA_ELEMENT_ChoiceList, XFA_ATTRIBUTE_Open, XFA_XDPPACKET_Form);\r
2342 }\r
2343 FX_BOOL CXFA_WidgetData::IsListBox()\r
2344 {\r
2345     int32_t iOpenMode = GetChoiceListOpen();\r
2346     return (iOpenMode == XFA_ATTRIBUTEENUM_Always || iOpenMode == XFA_ATTRIBUTEENUM_MultiSelect);\r
2347 }\r
2348 int32_t CXFA_WidgetData::CountChoiceListItems(FX_BOOL bSaveValue)\r
2349 {\r
2350     CXFA_NodeArray pItems;\r
2351     CXFA_Node* pItem = NULL;\r
2352     int32_t iCount = 0;\r
2353     CXFA_Node* pNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);\r
2354     for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {\r
2355         if (pNode->GetClassID() != XFA_ELEMENT_Items) {\r
2356             continue;\r
2357         }\r
2358         iCount++;\r
2359         pItems.Add(pNode);\r
2360         if (iCount == 2) {\r
2361             break;\r
2362         }\r
2363     }\r
2364     if(iCount == 0) {\r
2365         return 0;\r
2366     }\r
2367     pItem = pItems[0];\r
2368     if (iCount > 1) {\r
2369         FX_BOOL bItemOneHasSave = pItems[0]->GetBoolean(XFA_ATTRIBUTE_Save);\r
2370         FX_BOOL bItemTwoHasSave = pItems[1]->GetBoolean(XFA_ATTRIBUTE_Save);\r
2371         if (bItemOneHasSave != bItemTwoHasSave && bSaveValue == bItemTwoHasSave) {\r
2372             pItem = pItems[1];\r
2373         }\r
2374     }\r
2375     pItems.RemoveAll();\r
2376     return pItem->CountChildren(XFA_ELEMENT_UNKNOWN);\r
2377 }\r
2378 FX_BOOL CXFA_WidgetData::GetChoiceListItem(CFX_WideString &wsText, int32_t nIndex, FX_BOOL bSaveValue )\r
2379 {\r
2380     wsText.Empty();\r
2381     CXFA_NodeArray pItemsArray;\r
2382     CXFA_Node* pItems = NULL;\r
2383     int32_t iCount = 0;\r
2384     CXFA_Node* pNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);\r
2385     for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {\r
2386         if (pNode->GetClassID() != XFA_ELEMENT_Items) {\r
2387             continue;\r
2388         }\r
2389         iCount++;\r
2390         pItemsArray.Add(pNode);\r
2391         if (iCount == 2) {\r
2392             break;\r
2393         }\r
2394     }\r
2395     if (iCount == 0) {\r
2396         return FALSE;\r
2397     }\r
2398     pItems = pItemsArray[0];\r
2399     if (iCount > 1) {\r
2400         FX_BOOL bItemOneHasSave = pItemsArray[0]->GetBoolean(XFA_ATTRIBUTE_Save);\r
2401         FX_BOOL bItemTwoHasSave = pItemsArray[1]->GetBoolean(XFA_ATTRIBUTE_Save);\r
2402         if (bItemOneHasSave != bItemTwoHasSave && bSaveValue == bItemTwoHasSave) {\r
2403             pItems = pItemsArray[1];\r
2404         }\r
2405     }\r
2406     if (pItems) {\r
2407         CXFA_Node *pItem = pItems->GetChild(nIndex, XFA_ELEMENT_UNKNOWN);\r
2408         if(pItem != NULL) {\r
2409             pItem->TryContent(wsText);\r
2410             return TRUE;\r
2411         }\r
2412     }\r
2413     return FALSE;\r
2414 }\r
2415 void CXFA_WidgetData::GetChoiceListItems(CFX_WideStringArray &wsTextArray, FX_BOOL bSaveValue )\r
2416 {\r
2417     CXFA_NodeArray pItems;\r
2418     CXFA_Node* pItem = NULL;\r
2419     int32_t iCount = 0;\r
2420     CXFA_Node* pNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);\r
2421     for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {\r
2422         if (pNode->GetClassID() != XFA_ELEMENT_Items) {\r
2423             continue;\r
2424         }\r
2425         iCount++;\r
2426         pItems.Add(pNode);\r
2427         if (iCount == 2) {\r
2428             break;\r
2429         }\r
2430     }\r
2431     if(iCount == 0) {\r
2432         return;\r
2433     }\r
2434     pItem = pItems[0];\r
2435     if (iCount > 1) {\r
2436         FX_BOOL bItemOneHasSave = pItems[0]->GetBoolean(XFA_ATTRIBUTE_Save);\r
2437         FX_BOOL bItemTwoHasSave = pItems[1]->GetBoolean(XFA_ATTRIBUTE_Save);\r
2438         if (bItemOneHasSave != bItemTwoHasSave && bSaveValue == bItemTwoHasSave) {\r
2439             pItem = pItems[1];\r
2440         }\r
2441     }\r
2442     pItems.RemoveAll();\r
2443     pNode = pItem->GetNodeItem(XFA_NODEITEM_FirstChild);\r
2444     for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {\r
2445         pNode->TryContent(wsTextArray.Add());\r
2446     }\r
2447 }\r
2448 int32_t CXFA_WidgetData::CountSelectedItems()\r
2449 {\r
2450     CFX_WideStringArray wsValueArray;\r
2451     GetSelectedItemsValue(wsValueArray);\r
2452     if (IsListBox() || !IsChoiceListAllowTextEntry()) {\r
2453         return wsValueArray.GetSize();\r
2454     }\r
2455     int32_t iSelected = 0;\r
2456     CFX_WideStringArray wsSaveTextArray;\r
2457     GetChoiceListItems(wsSaveTextArray, TRUE);\r
2458     int32_t iValues = wsValueArray.GetSize();\r
2459     for (int32_t i = 0; i < iValues; i++) {\r
2460         int32_t iSaves = wsSaveTextArray.GetSize();\r
2461         for (int32_t j = 0; j < iSaves; j++) {\r
2462             if (wsValueArray[i] == wsSaveTextArray[j]) {\r
2463                 iSelected++;\r
2464                 break;\r
2465             }\r
2466         }\r
2467     }\r
2468     return iSelected;\r
2469 }\r
2470 int32_t CXFA_WidgetData::GetSelectedItem(int32_t nIndex )\r
2471 {\r
2472     CFX_WideStringArray wsValueArray;\r
2473     GetSelectedItemsValue(wsValueArray);\r
2474     int32_t iSelected = 0;\r
2475     CFX_WideStringArray wsSaveTextArray;\r
2476     GetChoiceListItems(wsSaveTextArray, TRUE);\r
2477     int32_t iSaves = wsSaveTextArray.GetSize();\r
2478     for (int32_t j = 0; j < iSaves; j++) {\r
2479         if (wsValueArray[nIndex] == wsSaveTextArray[j]) {\r
2480             return j;\r
2481         }\r
2482     }\r
2483     return -1;\r
2484 }\r
2485 void CXFA_WidgetData::GetSelectedItems(CFX_Int32Array &iSelArray)\r
2486 {\r
2487     CFX_WideStringArray wsValueArray;\r
2488     GetSelectedItemsValue(wsValueArray);\r
2489     int32_t iValues = wsValueArray.GetSize();\r
2490     if (iValues < 1) {\r
2491         return;\r
2492     }\r
2493     CFX_WideStringArray wsSaveTextArray;\r
2494     GetChoiceListItems(wsSaveTextArray, TRUE);\r
2495     int32_t iSaves = wsSaveTextArray.GetSize();\r
2496     for (int32_t i = 0; i < iValues; i++) {\r
2497         for (int32_t j = 0; j < iSaves; j++) {\r
2498             if (wsValueArray[i] == wsSaveTextArray[j]) {\r
2499                 iSelArray.Add(j);\r
2500                 break;\r
2501             }\r
2502         }\r
2503     }\r
2504 }\r
2505 void CXFA_WidgetData::GetSelectedItemsValue(CFX_WideStringArray &wsSelTextArray)\r
2506 {\r
2507     CFX_WideString wsValue = GetRawValue();\r
2508     if (GetChoiceListOpen() == XFA_ATTRIBUTEENUM_MultiSelect) {\r
2509         if (!wsValue.IsEmpty()) {\r
2510             int32_t iStart = 0;\r
2511             int32_t iLength = wsValue.GetLength();\r
2512             int32_t iEnd = wsValue.Find(L'\n', iStart);\r
2513             iEnd = (iEnd == -1) ? iLength : iEnd;\r
2514             while (iEnd >= iStart) {\r
2515                 wsSelTextArray.Add(wsValue.Mid(iStart, iEnd - iStart));\r
2516                 iStart = iEnd + 1;\r
2517                 if (iStart >= iLength) {\r
2518                     break;\r
2519                 }\r
2520                 iEnd = wsValue.Find(L'\n', iStart);\r
2521                 if (iEnd < 0) {\r
2522                     wsSelTextArray.Add(wsValue.Mid(iStart, iLength - iStart));\r
2523                 }\r
2524             }\r
2525         }\r
2526     } else {\r
2527         wsSelTextArray.Add(wsValue);\r
2528     }\r
2529 }\r
2530 FX_BOOL CXFA_WidgetData::GetItemState(int32_t nIndex)\r
2531 {\r
2532     if (nIndex < 0) {\r
2533         return FALSE;\r
2534     }\r
2535     CFX_WideStringArray wsSaveTextArray;\r
2536     GetChoiceListItems(wsSaveTextArray, TRUE);\r
2537     if (wsSaveTextArray.GetSize() <= nIndex) {\r
2538         return FALSE;\r
2539     }\r
2540     CFX_WideStringArray wsValueArray;\r
2541     GetSelectedItemsValue(wsValueArray);\r
2542     int32_t iValues = wsValueArray.GetSize();\r
2543     for (int32_t j = 0; j < iValues; j++) {\r
2544         if (wsValueArray[j] == wsSaveTextArray[nIndex]) {\r
2545             return TRUE;\r
2546         }\r
2547     }\r
2548     return FALSE;\r
2549 }\r
2550 void CXFA_WidgetData::SetItemState(int32_t nIndex, FX_BOOL bSelected, FX_BOOL bNotify, FX_BOOL bScriptModify, FX_BOOL bSyncData)\r
2551 {\r
2552     if (nIndex < 0) {\r
2553         return;\r
2554     }\r
2555     CFX_WideStringArray wsSaveTextArray;\r
2556     GetChoiceListItems(wsSaveTextArray, TRUE);\r
2557     if (wsSaveTextArray.GetSize() <= nIndex) {\r
2558         return;\r
2559     }\r
2560     int32_t iSel = -1;\r
2561     CFX_WideStringArray wsValueArray;\r
2562     GetSelectedItemsValue(wsValueArray);\r
2563     int32_t iValues = wsValueArray.GetSize();\r
2564     for (int32_t j = 0; j < iValues; j++) {\r
2565         if (wsValueArray[j] == wsSaveTextArray[nIndex]) {\r
2566             iSel = j;\r
2567             break;\r
2568         }\r
2569     }\r
2570     if (GetChoiceListOpen() == XFA_ATTRIBUTEENUM_MultiSelect) {\r
2571         if (bSelected) {\r
2572             if (iSel < 0) {\r
2573                 CFX_WideString wsValue = GetRawValue();\r
2574                 if (!wsValue.IsEmpty()) {\r
2575                     wsValue += L"\n";\r
2576                 }\r
2577                 wsValue += wsSaveTextArray[nIndex];\r
2578                 m_pNode->SetContent(wsValue, wsValue, bNotify, bScriptModify, bSyncData);\r
2579             }\r
2580         } else if (iSel >= 0) {\r
2581             CFX_Int32Array iSelArray;\r
2582             GetSelectedItems(iSelArray);\r
2583             for (int32_t i = 0; i < iSelArray.GetSize(); i++) {\r
2584                 if (iSelArray[i] == nIndex) {\r
2585                     iSelArray.RemoveAt(i);\r
2586                     break;\r
2587                 }\r
2588             }\r
2589             SetSelectdItems(iSelArray, bNotify, bScriptModify, bSyncData);\r
2590         }\r
2591     } else {\r
2592         if (bSelected) {\r
2593             if (iSel < 0) {\r
2594                 CFX_WideString wsSaveText = wsSaveTextArray[nIndex];\r
2595                 CFX_WideString wsFormatText(wsSaveText);\r
2596                 GetFormatDataValue(wsSaveText, wsFormatText);\r
2597                 m_pNode->SetContent(wsSaveText, wsFormatText, bNotify, bScriptModify, bSyncData);\r
2598             }\r
2599         } else if (iSel >= 0) {\r
2600             m_pNode->SetContent(CFX_WideString(), CFX_WideString(), bNotify, bScriptModify, bSyncData);\r
2601         }\r
2602     }\r
2603 }\r
2604 void CXFA_WidgetData::SetSelectdItems(CFX_Int32Array &iSelArray, FX_BOOL bNotify, FX_BOOL bScriptModify, FX_BOOL bSyncData)\r
2605 {\r
2606     CFX_WideString wsValue;\r
2607     int32_t iSize = iSelArray.GetSize();\r
2608     if (iSize >= 1) {\r
2609         CFX_WideStringArray wsSaveTextArray;\r
2610         GetChoiceListItems(wsSaveTextArray, TRUE);\r
2611         CFX_WideString wsItemValue;\r
2612         for (int32_t i = 0; i < iSize; i++) {\r
2613             wsItemValue = (iSize == 1) ? wsSaveTextArray[iSelArray[i]] : wsSaveTextArray[iSelArray[i]] + FX_WSTRC(L"\n");\r
2614             wsValue += wsItemValue;\r
2615         }\r
2616     }\r
2617     CFX_WideString wsFormat(wsValue);\r
2618     if (GetChoiceListOpen() != XFA_ATTRIBUTEENUM_MultiSelect) {\r
2619         GetFormatDataValue(wsValue, wsFormat);\r
2620     }\r
2621     m_pNode->SetContent(wsValue, wsFormat, bNotify, bScriptModify, bSyncData);\r
2622 }\r
2623 void CXFA_WidgetData::ClearAllSelections()\r
2624 {\r
2625     CXFA_Node* pBind = m_pNode->GetBindData();\r
2626     if (pBind && GetChoiceListOpen() == XFA_ATTRIBUTEENUM_MultiSelect) {\r
2627         while (CXFA_Node* pChildNode = pBind->GetNodeItem(XFA_NODEITEM_FirstChild)) {\r
2628             pBind->RemoveChild(pChildNode);\r
2629         }\r
2630     } else {\r
2631         SyncValue(CFX_WideString(), FALSE);\r
2632     }\r
2633 }\r
2634 void CXFA_WidgetData::InsertItem(const CFX_WideString &wsLabel, const CFX_WideString &wsValue, int32_t nIndex ,  FX_BOOL bNotify )\r
2635 {\r
2636     CFX_WideString wsNewValue(wsValue);\r
2637     if (wsNewValue.IsEmpty()) {\r
2638         wsNewValue = wsLabel;\r
2639     }\r
2640     CXFA_NodeArray listitems;\r
2641     int32_t iCount = 0;\r
2642     CXFA_Node *pItemNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);\r
2643     for (; pItemNode; pItemNode = pItemNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {\r
2644         if (pItemNode->GetClassID() != XFA_ELEMENT_Items) {\r
2645             continue;\r
2646         }\r
2647         listitems.Add(pItemNode);\r
2648         iCount ++;\r
2649     }\r
2650     if (iCount < 1) {\r
2651         CXFA_Node* pItems = m_pNode->CreateSamePacketNode(XFA_ELEMENT_Items);\r
2652         m_pNode->InsertChild(-1, pItems);\r
2653         InsertListTextItem(pItems, wsLabel, nIndex);\r
2654         CXFA_Node* pSaveItems = m_pNode->CreateSamePacketNode(XFA_ELEMENT_Items);\r
2655         m_pNode->InsertChild(-1, pSaveItems);\r
2656         pSaveItems->SetBoolean(XFA_ATTRIBUTE_Save, TRUE);\r
2657         InsertListTextItem(pSaveItems, wsNewValue, nIndex);\r
2658     } else if (iCount > 1) {\r
2659         for (int32_t i = 0; i < 2; i++) {\r
2660             CXFA_Node* pNode = listitems[i];\r
2661             FX_BOOL bHasSave = pNode->GetBoolean(XFA_ATTRIBUTE_Save);\r
2662             if (bHasSave) {\r
2663                 InsertListTextItem(pNode, wsNewValue, nIndex);\r
2664             } else {\r
2665                 InsertListTextItem(pNode, wsLabel, nIndex);\r
2666             }\r
2667         }\r
2668     } else {\r
2669         CXFA_Node* pNode = listitems[0];\r
2670         pNode->SetBoolean(XFA_ATTRIBUTE_Save, FALSE);\r
2671         pNode->SetEnum(XFA_ATTRIBUTE_Presence, XFA_ATTRIBUTEENUM_Visible);\r
2672         CXFA_Node* pSaveItems = m_pNode->CreateSamePacketNode(XFA_ELEMENT_Items);\r
2673         m_pNode->InsertChild(-1, pSaveItems);\r
2674         pSaveItems->SetBoolean(XFA_ATTRIBUTE_Save, TRUE);\r
2675         pSaveItems->SetEnum(XFA_ATTRIBUTE_Presence, XFA_ATTRIBUTEENUM_Hidden);\r
2676         listitems.RemoveAll();\r
2677         CXFA_Node *pListNode = pNode->GetNodeItem(XFA_NODEITEM_FirstChild);\r
2678         int32_t i = 0;\r
2679         while(pListNode) {\r
2680             CFX_WideString wsOldValue;\r
2681             pListNode->TryContent(wsOldValue);\r
2682             InsertListTextItem(pSaveItems, wsOldValue, i);\r
2683             i++;\r
2684             pListNode = pListNode->GetNodeItem(XFA_NODEITEM_NextSibling);\r
2685         }\r
2686         InsertListTextItem(pNode, wsLabel, nIndex);\r
2687         InsertListTextItem(pSaveItems, wsNewValue, nIndex);\r
2688     }\r
2689     if(!bNotify) {\r
2690         return;\r
2691     }\r
2692     m_pNode->GetDocument()->GetNotify()->OnWidgetDataEvent(this, XFA_WIDGETEVENT_ListItemAdded, (FX_LPVOID)(FX_LPCWSTR)wsLabel, (FX_LPVOID)(FX_LPCWSTR)wsValue, (FX_LPVOID)(uintptr_t)nIndex);\r
2693 }\r
2694 void CXFA_WidgetData::GetItemLabel(FX_WSTR wsValue, CFX_WideString &wsLabel)\r
2695 {\r
2696     int32_t iCount = 0;\r
2697     CXFA_NodeArray listitems;\r
2698     CXFA_Node* pItems = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);\r
2699     for (; pItems; pItems = pItems->GetNodeItem(XFA_NODEITEM_NextSibling)) {\r
2700         if (pItems->GetClassID() != XFA_ELEMENT_Items) {\r
2701             continue;\r
2702         }\r
2703         iCount++;\r
2704         listitems.Add(pItems);\r
2705     }\r
2706     if (iCount <= 1) {\r
2707         wsLabel = wsValue;\r
2708     } else {\r
2709         CXFA_Node* pLabelItems = listitems[0];\r
2710         FX_BOOL bSave = pLabelItems->GetBoolean(XFA_ATTRIBUTE_Save);\r
2711         CXFA_Node* pSaveItems = NULL;\r
2712         if (bSave) {\r
2713             pSaveItems = pLabelItems;\r
2714             pLabelItems = listitems[1];\r
2715         } else {\r
2716             pSaveItems = listitems[1];\r
2717         }\r
2718         iCount = 0;\r
2719         int32_t iSearch = -1;\r
2720         CFX_WideString wsContent;\r
2721         CXFA_Node* pChildItem = pSaveItems->GetNodeItem(XFA_NODEITEM_FirstChild);\r
2722         for (; pChildItem; pChildItem = pChildItem->GetNodeItem(XFA_NODEITEM_NextSibling)) {\r
2723             pChildItem->TryContent(wsContent);\r
2724             if (wsContent == wsValue) {\r
2725                 iSearch = iCount;\r
2726                 break;\r
2727             }\r
2728             iCount ++;\r
2729         }\r
2730         if (iSearch < 0) {\r
2731             return;\r
2732         }\r
2733         if (CXFA_Node* pText = pLabelItems->GetChild(iSearch, XFA_ELEMENT_UNKNOWN)) {\r
2734             pText->TryContent(wsLabel);\r
2735         }\r
2736     }\r
2737 }\r
2738 void CXFA_WidgetData::GetItemValue(FX_WSTR wsLabel, CFX_WideString &wsValue)\r
2739 {\r
2740     int32_t iCount = 0;\r
2741     CXFA_NodeArray listitems;\r
2742     CXFA_Node* pItems = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);\r
2743     for (; pItems; pItems = pItems->GetNodeItem(XFA_NODEITEM_NextSibling)) {\r
2744         if (pItems->GetClassID() != XFA_ELEMENT_Items) {\r
2745             continue;\r
2746         }\r
2747         iCount++;\r
2748         listitems.Add(pItems);\r
2749     }\r
2750     if (iCount <= 1) {\r
2751         wsValue = wsLabel;\r
2752     } else {\r
2753         CXFA_Node* pLabelItems = listitems[0];\r
2754         FX_BOOL bSave = pLabelItems->GetBoolean(XFA_ATTRIBUTE_Save);\r
2755         CXFA_Node* pSaveItems = NULL;\r
2756         if (bSave) {\r
2757             pSaveItems = pLabelItems;\r
2758             pLabelItems = listitems[1];\r
2759         } else {\r
2760             pSaveItems = listitems[1];\r
2761         }\r
2762         iCount = 0;\r
2763         int32_t iSearch = -1;\r
2764         CFX_WideString wsContent;\r
2765         CXFA_Node* pChildItem = pLabelItems->GetNodeItem(XFA_NODEITEM_FirstChild);\r
2766         for (; pChildItem; pChildItem = pChildItem->GetNodeItem(XFA_NODEITEM_NextSibling)) {\r
2767             pChildItem->TryContent(wsContent);\r
2768             if (wsContent == wsLabel) {\r
2769                 iSearch = iCount;\r
2770                 break;\r
2771             }\r
2772             iCount ++;\r
2773         }\r
2774         if (iSearch < 0) {\r
2775             return;\r
2776         }\r
2777         if (CXFA_Node* pText = pSaveItems->GetChild(iSearch, XFA_ELEMENT_UNKNOWN)) {\r
2778             pText->TryContent(wsValue);\r
2779         }\r
2780     }\r
2781 }\r
2782 FX_BOOL CXFA_WidgetData::DeleteItem(int32_t nIndex, FX_BOOL bNotify, FX_BOOL bScriptModify, FX_BOOL bSyncData)\r
2783 {\r
2784     FX_BOOL bSetValue = FALSE;\r
2785     CXFA_Node* pItems = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);\r
2786     for (; pItems; pItems = pItems->GetNodeItem(XFA_NODEITEM_NextSibling)) {\r
2787         if (pItems->GetClassID() != XFA_ELEMENT_Items) {\r
2788             continue;\r
2789         }\r
2790         if (nIndex < 0) {\r
2791             while (CXFA_Node* pNode = pItems->GetNodeItem(XFA_NODEITEM_FirstChild)) {\r
2792                 pItems->RemoveChild(pNode);\r
2793             }\r
2794         } else {\r
2795             if (!bSetValue && pItems->GetBoolean(XFA_ATTRIBUTE_Save)) {\r
2796                 SetItemState(nIndex, FALSE, TRUE, bScriptModify, bSyncData);\r
2797                 bSetValue = TRUE;\r
2798             }\r
2799             int32_t i = 0;\r
2800             CXFA_Node* pNode = pItems->GetNodeItem(XFA_NODEITEM_FirstChild);\r
2801             while (pNode) {\r
2802                 if (i == nIndex) {\r
2803                     pItems->RemoveChild(pNode);\r
2804                     break;\r
2805                 }\r
2806                 i++;\r
2807                 pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling);\r
2808             }\r
2809         }\r
2810     }\r
2811     if(!bNotify) {\r
2812         return TRUE;\r
2813     }\r
2814     m_pNode->GetDocument()->GetNotify()->OnWidgetDataEvent(this, XFA_WIDGETEVENT_ListItemRemoved, (FX_LPVOID)(uintptr_t)nIndex);\r
2815     return TRUE;\r
2816 }\r
2817 int32_t CXFA_WidgetData::GetHorizontalScrollPolicy()\r
2818 {\r
2819     CXFA_Node* pUIChild = GetUIChild();\r
2820     if (pUIChild) {\r
2821         return pUIChild->GetEnum(XFA_ATTRIBUTE_HScrollPolicy);\r
2822     }\r
2823     return XFA_ATTRIBUTEENUM_Auto;\r
2824 }\r
2825 int32_t CXFA_WidgetData::GetNumberOfCells()\r
2826 {\r
2827     CXFA_Node* pUIChild = GetUIChild();\r
2828     if (!pUIChild) {\r
2829         return -1;\r
2830     }\r
2831     if (CXFA_Node* pNode = pUIChild->GetChild(0, XFA_ELEMENT_Comb)) {\r
2832         return pNode->GetInteger(XFA_ATTRIBUTE_NumberOfCells);\r
2833     }\r
2834     return -1;\r
2835 }\r
2836 FX_BOOL CXFA_WidgetData::IsDateTimeEditUsePicker()\r
2837 {\r
2838     return TRUE;\r
2839 }\r
2840 CFX_WideString CXFA_WidgetData::GetBarcodeType()\r
2841 {\r
2842     CXFA_Node* pUIChild = GetUIChild();\r
2843     return pUIChild ? pUIChild->GetCData(XFA_ATTRIBUTE_Type) : NULL;\r
2844 }\r
2845 FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_CharEncoding(int32_t& val)\r
2846 {\r
2847     CXFA_Node* pUIChild = GetUIChild();\r
2848     CFX_WideString wsCharEncoding;\r
2849     if(pUIChild->TryCData(XFA_ATTRIBUTE_CharEncoding, wsCharEncoding)) {\r
2850         if (wsCharEncoding.CompareNoCase(L"UTF-16")) {\r
2851             val = CHAR_ENCODING_UNICODE;\r
2852             return TRUE;\r
2853         } else if (wsCharEncoding.CompareNoCase(L"UTF-8")) {\r
2854             val = CHAR_ENCODING_UTF8;\r
2855             return TRUE;\r
2856         }\r
2857     }\r
2858     return FALSE;\r
2859 }\r
2860 FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_Checksum(int32_t& val)\r
2861 {\r
2862     CXFA_Node* pUIChild = GetUIChild();\r
2863     XFA_ATTRIBUTEENUM eChecksum;\r
2864     if (pUIChild->TryEnum(XFA_ATTRIBUTE_Checksum, eChecksum)) {\r
2865         switch (eChecksum) {\r
2866             case XFA_ATTRIBUTEENUM_None:\r
2867                 val = 0;\r
2868                 return TRUE;\r
2869             case XFA_ATTRIBUTEENUM_Auto:\r
2870                 val = 1;\r
2871                 return TRUE;\r
2872             case XFA_ATTRIBUTEENUM_1mod10:\r
2873                 break;\r
2874             case XFA_ATTRIBUTEENUM_1mod10_1mod11:\r
2875                 break;\r
2876             case XFA_ATTRIBUTEENUM_2mod10:\r
2877                 break;\r
2878             default:\r
2879                 break;\r
2880         }\r
2881     }\r
2882     return FALSE;\r
2883 }\r
2884 FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_DataLength(int32_t& val)\r
2885 {\r
2886     CXFA_Node* pUIChild = GetUIChild();\r
2887     CFX_WideString wsDataLength;\r
2888     if(pUIChild->TryCData(XFA_ATTRIBUTE_DataLength, wsDataLength)) {\r
2889         val = FXSYS_wtoi(wsDataLength);\r
2890         return TRUE;\r
2891     }\r
2892     return FALSE;\r
2893 }\r
2894 FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_StartChar(FX_CHAR& val)\r
2895 {\r
2896     CXFA_Node* pUIChild = GetUIChild();\r
2897     CFX_WideStringC wsStartEndChar;\r
2898     if(pUIChild->TryCData(XFA_ATTRIBUTE_StartChar, wsStartEndChar)) {\r
2899         if(wsStartEndChar.GetLength()) {\r
2900             val = (FX_CHAR)wsStartEndChar.GetAt(0);\r
2901             return TRUE;\r
2902         }\r
2903     }\r
2904     return FALSE;\r
2905 }\r
2906 FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_EndChar(FX_CHAR& val)\r
2907 {\r
2908     CXFA_Node* pUIChild = GetUIChild();\r
2909     CFX_WideStringC wsStartEndChar;\r
2910     if(pUIChild->TryCData(XFA_ATTRIBUTE_EndChar, wsStartEndChar)) {\r
2911         if(wsStartEndChar.GetLength()) {\r
2912             val = (FX_CHAR)wsStartEndChar.GetAt(0);\r
2913             return TRUE;\r
2914         }\r
2915     }\r
2916     return FALSE;\r
2917 }\r
2918 FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_ECLevel(int32_t& val)\r
2919 {\r
2920     CXFA_Node* pUIChild = GetUIChild();\r
2921     CFX_WideString wsECLevel;\r
2922     if(pUIChild->TryCData(XFA_ATTRIBUTE_ErrorCorrectionLevel, wsECLevel)) {\r
2923         val = FXSYS_wtoi(wsECLevel);\r
2924         return TRUE;\r
2925     }\r
2926     return FALSE;\r
2927 }\r
2928 FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_ModuleWidth(int32_t& val)\r
2929 {\r
2930     CXFA_Node* pUIChild = GetUIChild();\r
2931     CXFA_Measurement mModuleWidthHeight;\r
2932     if (pUIChild->TryMeasure(XFA_ATTRIBUTE_ModuleWidth, mModuleWidthHeight)) {\r
2933         val = (int32_t)mModuleWidthHeight.ToUnit(XFA_UNIT_Pt);\r
2934         return TRUE;\r
2935     }\r
2936     return FALSE;\r
2937 }\r
2938 FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_ModuleHeight(int32_t& val)\r
2939 {\r
2940     CXFA_Node* pUIChild = GetUIChild();\r
2941     CXFA_Measurement mModuleWidthHeight;\r
2942     if (pUIChild->TryMeasure(XFA_ATTRIBUTE_ModuleHeight, mModuleWidthHeight)) {\r
2943         val = (int32_t)mModuleWidthHeight.ToUnit(XFA_UNIT_Pt);\r
2944         return TRUE;\r
2945     }\r
2946     return FALSE;\r
2947 }\r
2948 FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_PrintChecksum(FX_BOOL& val)\r
2949 {\r
2950     CXFA_Node* pUIChild = GetUIChild();\r
2951     FX_BOOL bPrintCheckDigit;\r
2952     if(pUIChild->TryBoolean(XFA_ATTRIBUTE_PrintCheckDigit, bPrintCheckDigit)) {\r
2953         val = bPrintCheckDigit;\r
2954         return TRUE;\r
2955     }\r
2956     return FALSE;\r
2957 }\r
2958 FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_TextLocation(int32_t& val)\r
2959 {\r
2960     CXFA_Node* pUIChild = GetUIChild();\r
2961     XFA_ATTRIBUTEENUM eTextLocation;\r
2962     if (pUIChild->TryEnum(XFA_ATTRIBUTE_TextLocation, eTextLocation)) {\r
2963         switch(eTextLocation) {\r
2964             case XFA_ATTRIBUTEENUM_None:\r
2965                 val = BC_TEXT_LOC_NONE;\r
2966                 return TRUE;\r
2967             case XFA_ATTRIBUTEENUM_Above:\r
2968                 val = BC_TEXT_LOC_ABOVE;\r
2969                 return TRUE;\r
2970             case XFA_ATTRIBUTEENUM_Below:\r
2971                 val = BC_TEXT_LOC_BELOW;\r
2972                 return TRUE;\r
2973             case XFA_ATTRIBUTEENUM_AboveEmbedded:\r
2974                 val = BC_TEXT_LOC_ABOVEEMBED;\r
2975                 return TRUE;\r
2976             case XFA_ATTRIBUTEENUM_BelowEmbedded:\r
2977                 val = BC_TEXT_LOC_BELOWEMBED;\r
2978                 return TRUE;\r
2979             default:\r
2980                 break;\r
2981         }\r
2982     }\r
2983     return FALSE;\r
2984 }\r
2985 FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_Truncate(FX_BOOL& val)\r
2986 {\r
2987     CXFA_Node* pUIChild = GetUIChild();\r
2988     FX_BOOL bTruncate;\r
2989     if(pUIChild->TryBoolean(XFA_ATTRIBUTE_Truncate, bTruncate)) {\r
2990         val = bTruncate;\r
2991         return TRUE;\r
2992     }\r
2993     return FALSE;\r
2994 }\r
2995 FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_WideNarrowRatio(FX_FLOAT& val)\r
2996 {\r
2997     CXFA_Node* pUIChild = GetUIChild();\r
2998     CFX_WideString wsWideNarrowRatio;\r
2999     if (pUIChild->TryCData(XFA_ATTRIBUTE_WideNarrowRatio, wsWideNarrowRatio)) {\r
3000         FX_STRSIZE ptPos = wsWideNarrowRatio.Find(':');\r
3001         FX_FLOAT   fRatio = 0;\r
3002         if(ptPos >= 0) {\r
3003             fRatio = (FX_FLOAT)FXSYS_wtoi(wsWideNarrowRatio);\r
3004         } else {\r
3005             int32_t fA, fB;\r
3006             fA = FXSYS_wtoi(wsWideNarrowRatio.Left(ptPos));\r
3007             fB = FXSYS_wtoi(wsWideNarrowRatio.Mid(ptPos + 1));\r
3008             if(fB) {\r
3009                 fRatio = (FX_FLOAT)fA / fB;\r
3010             }\r
3011         }\r
3012         val = fRatio;\r
3013         return TRUE;\r
3014     }\r
3015     return FALSE;\r
3016 }\r
3017 void CXFA_WidgetData::GetPasswordChar(CFX_WideString &wsPassWord)\r
3018 {\r
3019     CXFA_Node* pUIChild = GetUIChild();\r
3020     if (pUIChild) {\r
3021         pUIChild->TryCData(XFA_ATTRIBUTE_PasswordChar, wsPassWord);\r
3022     } else {\r
3023         wsPassWord = XFA_GetAttributeDefaultValue_Cdata(XFA_ELEMENT_PasswordEdit, XFA_ATTRIBUTE_PasswordChar, XFA_XDPPACKET_Form);\r
3024     }\r
3025 }\r
3026 FX_BOOL CXFA_WidgetData::IsAllowRichText()\r
3027 {\r
3028     CXFA_Node* pUIChild = GetUIChild();\r
3029     FX_BOOL bValue = FALSE;\r
3030     if (pUIChild && pUIChild->TryBoolean(XFA_ATTRIBUTE_AllowRichText, bValue, FALSE)) {\r
3031         return bValue;\r
3032     }\r
3033     if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_ELEMENT_Value)) {\r
3034         if (CXFA_Node* pChild = pNode->GetNodeItem(XFA_NODEITEM_FirstChild)) {\r
3035             return pChild->GetClassID() == XFA_ELEMENT_ExData;\r
3036         }\r
3037     }\r
3038     return FALSE;\r
3039 }\r
3040 FX_BOOL CXFA_WidgetData::IsMultiLine()\r
3041 {\r
3042     CXFA_Node* pUIChild = GetUIChild();\r
3043     if (pUIChild) {\r
3044         return pUIChild->GetBoolean(XFA_ATTRIBUTE_MultiLine);\r
3045     }\r
3046     return XFA_GetAttributeDefaultValue_Boolean(XFA_ELEMENT_TextEdit, XFA_ATTRIBUTE_MultiLine, XFA_XDPPACKET_Form);\r
3047 }\r
3048 int32_t CXFA_WidgetData::GetVerticalScrollPolicy()\r
3049 {\r
3050     CXFA_Node* pUIChild = GetUIChild();\r
3051     if (pUIChild) {\r
3052         return pUIChild->GetEnum(XFA_ATTRIBUTE_VScrollPolicy);\r
3053     }\r
3054     return XFA_GetAttributeDefaultValue_Enum(XFA_ELEMENT_TextEdit, XFA_ATTRIBUTE_VScrollPolicy, XFA_XDPPACKET_Form);\r
3055 }\r
3056 int32_t CXFA_WidgetData::GetMaxChars(XFA_ELEMENT& eType)\r
3057 {\r
3058     if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_ELEMENT_Value)) {\r
3059         if (CXFA_Node* pChild = pNode->GetNodeItem(XFA_NODEITEM_FirstChild)) {\r
3060             switch(pChild->GetClassID()) {\r
3061                 case XFA_ELEMENT_Text:\r
3062                     eType = XFA_ELEMENT_Text;\r
3063                     return pChild->GetInteger(XFA_ATTRIBUTE_MaxChars);\r
3064                 case XFA_ELEMENT_ExData: {\r
3065                         eType = XFA_ELEMENT_ExData;\r
3066                         int32_t iMax = pChild->GetInteger(XFA_ATTRIBUTE_MaxLength);\r
3067                         return iMax < 0 ? 0 : iMax;\r
3068                     }\r
3069                 default:\r
3070                     break;\r
3071             }\r
3072         }\r
3073     }\r
3074     return 0;\r
3075 }\r
3076 FX_BOOL CXFA_WidgetData::GetFracDigits(int32_t &iFracDigits)\r
3077 {\r
3078     if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_ELEMENT_Value)) {\r
3079         if (CXFA_Node* pChild = pNode->GetChild(0, XFA_ELEMENT_Decimal)) {\r
3080             return pChild->TryInteger(XFA_ATTRIBUTE_FracDigits, iFracDigits);\r
3081         }\r
3082     }\r
3083     iFracDigits = -1;\r
3084     return FALSE;\r
3085 }\r
3086 FX_BOOL CXFA_WidgetData::GetLeadDigits(int32_t &iLeadDigits)\r
3087 {\r
3088     if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_ELEMENT_Value)) {\r
3089         if (CXFA_Node* pChild = pNode->GetChild(0, XFA_ELEMENT_Decimal)) {\r
3090             return pChild->TryInteger(XFA_ATTRIBUTE_LeadDigits, iLeadDigits);\r
3091         }\r
3092     }\r
3093     iLeadDigits = -1;\r
3094     return FALSE;\r
3095 }\r
3096 static CFX_WideString XFA_NumericNormalize(const CFX_WideString &wsValue, IFX_Locale* pLocale)\r
3097 {\r
3098     CFX_WideString wsDecimalSymbol;\r
3099     if (pLocale) {\r
3100         pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_Decimal, wsDecimalSymbol);\r
3101     }\r
3102     if (wsDecimalSymbol.IsEmpty()) {\r
3103         wsDecimalSymbol = '.';\r
3104     }\r
3105     CFX_WideString wsNewValue(wsValue);\r
3106     wsNewValue.TrimLeft(L" ");\r
3107     wsNewValue.TrimLeft(L"0");\r
3108     wsNewValue.TrimRight(L" ");\r
3109     int32_t iCount      = wsNewValue.GetLength();\r
3110     if (iCount == 0) {\r
3111         return FX_WSTRC(L"0");\r
3112     }\r
3113     int32_t iIndex = 0;\r
3114     CFX_WideString wsRet;\r
3115     FX_LPWSTR pRetBuffer = wsRet.GetBuffer(iCount);\r
3116     int32_t iDestCount = 0;\r
3117     int32_t i = 0;\r
3118     if (wsNewValue[i] == L'-') {\r
3119         pRetBuffer[iIndex++] = '-';\r
3120     } else if (wsNewValue[i] == L'+') {\r
3121         i++;\r
3122     }\r
3123     FX_BOOL     bHasPoint = FALSE;\r
3124     int32_t nCharStart = -1;\r
3125     for ( ; i < iCount; i ++) {\r
3126         FX_WCHAR wc = wsNewValue[i];\r
3127         if (XFA_IsDigit(wc)) {\r
3128             if (nCharStart != -1) {\r
3129                 CFX_WideStringC wsChar((FX_LPCWSTR)wsNewValue + nCharStart, i - nCharStart);\r
3130                 if (wsChar == '.' || wsChar == wsDecimalSymbol) {\r
3131                     bHasPoint = TRUE;\r
3132                     nCharStart = -1;\r
3133                 } else {\r
3134                     pRetBuffer[0] = '0';\r
3135                     iCount = 1;\r
3136                     break;\r
3137                 }\r
3138             }\r
3139             pRetBuffer[iIndex++] = wc;\r
3140             continue;\r
3141         }\r
3142         if (bHasPoint) {\r
3143             pRetBuffer[0] = '0';\r
3144             iCount = 1;\r
3145             break;\r
3146         }\r
3147         if (nCharStart == -1) {\r
3148             nCharStart = i;\r
3149             pRetBuffer[iIndex++] = wc;\r
3150         }\r
3151     }\r
3152     wsRet.ReleaseBuffer(iCount);\r
3153     return wsRet;\r
3154 }\r
3155 CFX_WideString XFA_NumericLimit(const CFX_WideString &wsValue, int32_t iLead, int32_t iTread)\r
3156 {\r
3157     if ((iLead == - 1)  && (iTread == -1)) {\r
3158         return wsValue;\r
3159     }\r
3160     CFX_WideString wsRet;\r
3161     int32_t iLead_ = 0, iTread_ = -1;\r
3162     int32_t iCount = wsValue.GetLength();\r
3163     if (iCount == 0) {\r
3164         return wsValue;\r
3165     }\r
3166     int32_t i = 0;\r
3167     if (wsValue[i] == L'-') {\r
3168         wsRet += L'-';\r
3169         i++;\r
3170     }\r
3171     for (; i < iCount; i ++) {\r
3172         FX_WCHAR wc = wsValue[i];\r
3173         if (XFA_IsDigit(wc)) {\r
3174             if (iLead >= 0) {\r
3175                 iLead_ ++;\r
3176                 if (iLead_ > iLead) {\r
3177                     return L"0";\r
3178                 }\r
3179             } else if (iTread_ >= 0) {\r
3180                 iTread_ ++;\r
3181                 if (iTread_ > iTread) {\r
3182                     if (iTread != -1) {\r
3183                         CFX_Decimal wsDeci = CFX_Decimal(wsValue);\r
3184                         wsDeci.SetScale(iTread);\r
3185                         wsRet = wsDeci;\r
3186                     }\r
3187                     return wsRet;\r
3188                 }\r
3189             }\r
3190         } else if (wc == L'.') {\r
3191             iTread_ = 0;\r
3192             iLead = -1;\r
3193         }\r
3194         wsRet += wc;\r
3195     }\r
3196     return wsRet;\r
3197 }\r
3198 FX_BOOL CXFA_WidgetData::SetValue(const CFX_WideString& wsValue, XFA_VALUEPICTURE eValueType)\r
3199 {\r