Convert XFA_ELEMENT to an enum class

xfa/fxfa/parser/cxfa_widgetdata.cpp

 // Copyright 2016 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "xfa/fxfa/parser/cxfa_widgetdata.h"
 
 #include "core/fxcrt/include/fx_ext.h"
 #include "xfa/fxbarcode/include/BC_Library.h"
@@ skipping 59 matching lines @@
   return TRUE;
 }
 
 }  // namespace
 
 CXFA_WidgetData::CXFA_WidgetData(CXFA_Node* pNode)
     : CXFA_Data(pNode),
       m_bIsNull(TRUE),
       m_bPreNull(TRUE),
       m_pUiChildNode(NULL),
-      m_eUIType(XFA_ELEMENT_UNKNOWN) {}
+      m_eUIType(XFA_Element::Unknown) {}
 
 CXFA_Node* CXFA_WidgetData::GetUIChild() {
-  if (m_eUIType == XFA_ELEMENT_UNKNOWN)
+  if (m_eUIType == XFA_Element::Unknown)
     m_pUiChildNode = XFA_CreateUIChild(m_pNode, m_eUIType);
 
   return m_pUiChildNode;
 }
 
-XFA_ELEMENT CXFA_WidgetData::GetUIType() {
+XFA_Element CXFA_WidgetData::GetUIType() {
   GetUIChild();
   return m_eUIType;
 }
 
 CFX_WideString CXFA_WidgetData::GetRawValue() {
   return m_pNode->GetContent();
 }
 
 int32_t CXFA_WidgetData::GetAccess(FX_BOOL bTemplate) {
   if (bTemplate) {
@@ skipping 18 matching lines @@
   CXFA_Measurement ms;
   if (!m_pNode->TryMeasure(XFA_ATTRIBUTE_Rotate, ms, FALSE))
     return 0;
 
   int32_t iRotate = FXSYS_round(ms.GetValue());
   iRotate = XFA_MapRotation(iRotate);
   return iRotate / 90 * 90;
 }
 
 CXFA_Border CXFA_WidgetData::GetBorder(FX_BOOL bModified) {
-  return CXFA_Border(m_pNode->GetProperty(0, XFA_ELEMENT_Border, bModified));
+  return CXFA_Border(m_pNode->GetProperty(0, XFA_Element::Border, bModified));
 }
 
 CXFA_Caption CXFA_WidgetData::GetCaption(FX_BOOL bModified) {
-  return CXFA_Caption(m_pNode->GetProperty(0, XFA_ELEMENT_Caption, bModified));
+  return CXFA_Caption(m_pNode->GetProperty(0, XFA_Element::Caption, bModified));
 }
 
 CXFA_Font CXFA_WidgetData::GetFont(FX_BOOL bModified) {
-  return CXFA_Font(m_pNode->GetProperty(0, XFA_ELEMENT_Font, bModified));
+  return CXFA_Font(m_pNode->GetProperty(0, XFA_Element::Font, bModified));
 }
 
 CXFA_Margin CXFA_WidgetData::GetMargin(FX_BOOL bModified) {
-  return CXFA_Margin(m_pNode->GetProperty(0, XFA_ELEMENT_Margin, bModified));
+  return CXFA_Margin(m_pNode->GetProperty(0, XFA_Element::Margin, bModified));
 }
 
 CXFA_Para CXFA_WidgetData::GetPara(FX_BOOL bModified) {
-  return CXFA_Para(m_pNode->GetProperty(0, XFA_ELEMENT_Para, bModified));
+  return CXFA_Para(m_pNode->GetProperty(0, XFA_Element::Para, bModified));
 }
 
 void CXFA_WidgetData::GetEventList(CXFA_NodeArray& events) {
-  m_pNode->GetNodeList(events, 0, XFA_ELEMENT_Event);
+  m_pNode->GetNodeList(events, 0, XFA_Element::Event);
 }
 
 int32_t CXFA_WidgetData::GetEventByActivity(int32_t iActivity,
                                             CXFA_NodeArray& events,
                                             FX_BOOL bIsFormReady) {
   CXFA_NodeArray allEvents;
   GetEventList(allEvents);
   int32_t iCount = allEvents.GetSize();
   for (int32_t i = 0; i < iCount; i++) {
     CXFA_Event event(allEvents[i]);
@@ skipping 11 matching lines @@
       } else {
         events.Add(allEvents[i]);
       }
     }
   }
   return events.GetSize();
 }
 
 CXFA_Value CXFA_WidgetData::GetDefaultValue(FX_BOOL bModified) {
   CXFA_Node* pTemNode = m_pNode->GetTemplateNode();
-  return CXFA_Value(pTemNode
-                        ? pTemNode->GetProperty(0, XFA_ELEMENT_Value, bModified)
-                        : nullptr);
+  return CXFA_Value(
+      pTemNode ? pTemNode->GetProperty(0, XFA_Element::Value, bModified)
+               : nullptr);
 }
 
 CXFA_Value CXFA_WidgetData::GetFormValue(FX_BOOL bModified) {
-  return CXFA_Value(m_pNode->GetProperty(0, XFA_ELEMENT_Value, bModified));
+  return CXFA_Value(m_pNode->GetProperty(0, XFA_Element::Value, bModified));
 }
 
 CXFA_Calculate CXFA_WidgetData::GetCalculate(FX_BOOL bModified) {
   return CXFA_Calculate(
-      m_pNode->GetProperty(0, XFA_ELEMENT_Calculate, bModified));
+      m_pNode->GetProperty(0, XFA_Element::Calculate, bModified));
 }
 
 CXFA_Validate CXFA_WidgetData::GetValidate(FX_BOOL bModified) {
   return CXFA_Validate(
-      m_pNode->GetProperty(0, XFA_ELEMENT_Validate, bModified));
+      m_pNode->GetProperty(0, XFA_Element::Validate, bModified));
 }
 
 CXFA_Bind CXFA_WidgetData::GetBind(FX_BOOL bModified) {
-  return CXFA_Bind(m_pNode->GetProperty(0, XFA_ELEMENT_Bind, bModified));
+  return CXFA_Bind(m_pNode->GetProperty(0, XFA_Element::Bind, bModified));
 }
 
 CXFA_Assist CXFA_WidgetData::GetAssist(FX_BOOL bModified) {
-  return CXFA_Assist(m_pNode->GetProperty(0, XFA_ELEMENT_Assist, bModified));
+  return CXFA_Assist(m_pNode->GetProperty(0, XFA_Element::Assist, bModified));
 }
 
 FX_BOOL CXFA_WidgetData::GetWidth(FX_FLOAT& fWidth) {
   return TryMeasure(XFA_ATTRIBUTE_W, fWidth);
 }
 
 FX_BOOL CXFA_WidgetData::GetHeight(FX_FLOAT& fHeight) {
   return TryMeasure(XFA_ATTRIBUTE_H, fHeight);
 }
 
 FX_BOOL CXFA_WidgetData::GetMinWidth(FX_FLOAT& fMinWidth) {
   return TryMeasure(XFA_ATTRIBUTE_MinW, fMinWidth);
 }
 
 FX_BOOL CXFA_WidgetData::GetMinHeight(FX_FLOAT& fMinHeight) {
   return TryMeasure(XFA_ATTRIBUTE_MinH, fMinHeight);
 }
 
 FX_BOOL CXFA_WidgetData::GetMaxWidth(FX_FLOAT& fMaxWidth) {
   return TryMeasure(XFA_ATTRIBUTE_MaxW, fMaxWidth);
 }
 
 FX_BOOL CXFA_WidgetData::GetMaxHeight(FX_FLOAT& fMaxHeight) {
   return TryMeasure(XFA_ATTRIBUTE_MaxH, fMaxHeight);
 }
 
 CXFA_Border CXFA_WidgetData::GetUIBorder(FX_BOOL bModified) {
   CXFA_Node* pUIChild = GetUIChild();
   return CXFA_Border(
-      pUIChild ? pUIChild->GetProperty(0, XFA_ELEMENT_Border, bModified)
+      pUIChild ? pUIChild->GetProperty(0, XFA_Element::Border, bModified)
                : nullptr);
 }
 
 CXFA_Margin CXFA_WidgetData::GetUIMargin(FX_BOOL bModified) {
   CXFA_Node* pUIChild = GetUIChild();
   return CXFA_Margin(
-      pUIChild ? pUIChild->GetProperty(0, XFA_ELEMENT_Margin, bModified)
+      pUIChild ? pUIChild->GetProperty(0, XFA_Element::Margin, bModified)
                : nullptr);
 }
 
 void CXFA_WidgetData::GetUIMargin(CFX_RectF& rtUIMargin) {
   rtUIMargin.Reset();
   CXFA_Margin mgUI = GetUIMargin();
   if (!mgUI)
     return;
 
   CXFA_Border border = GetUIBorder();
@@ skipping 23 matching lines @@
     }
   }
   rtUIMargin.Set(fLeftInset, fTopInset, fRightInset, fBottomInset);
 }
 
 int32_t CXFA_WidgetData::GetButtonHighlight() {
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild)
     return pUIChild->GetEnum(XFA_ATTRIBUTE_Highlight);
   return XFA_GetAttributeDefaultValue_Enum(
-      XFA_ELEMENT_Button, XFA_ATTRIBUTE_Highlight, XFA_XDPPACKET_Form);
+      XFA_Element::Button, XFA_ATTRIBUTE_Highlight, XFA_XDPPACKET_Form);
 }
 
 FX_BOOL CXFA_WidgetData::GetButtonRollover(CFX_WideString& wsRollover,
                                            FX_BOOL& bRichText) {
-  if (CXFA_Node* pItems = m_pNode->GetChild(0, XFA_ELEMENT_Items)) {
+  if (CXFA_Node* pItems = m_pNode->GetChild(0, XFA_Element::Items)) {
     CXFA_Node* pText = pItems->GetNodeItem(XFA_NODEITEM_FirstChild);
     while (pText) {
       CFX_WideStringC wsName;
       pText->TryCData(XFA_ATTRIBUTE_Name, wsName);
       if (wsName == FX_WSTRC(L"rollover")) {
         pText->TryContent(wsRollover);
-        bRichText = pText->GetClassID() == XFA_ELEMENT_ExData;
+        bRichText = pText->GetClassID() == XFA_Element::ExData;
         return !wsRollover.IsEmpty();
       }
       pText = pText->GetNodeItem(XFA_NODEITEM_NextSibling);
     }
   }
   return FALSE;
 }
 
 FX_BOOL CXFA_WidgetData::GetButtonDown(CFX_WideString& wsDown,
                                        FX_BOOL& bRichText) {
-  if (CXFA_Node* pItems = m_pNode->GetChild(0, XFA_ELEMENT_Items)) {
+  if (CXFA_Node* pItems = m_pNode->GetChild(0, XFA_Element::Items)) {
     CXFA_Node* pText = pItems->GetNodeItem(XFA_NODEITEM_FirstChild);
     while (pText) {
       CFX_WideStringC wsName;
       pText->TryCData(XFA_ATTRIBUTE_Name, wsName);
       if (wsName == FX_WSTRC(L"down")) {
         pText->TryContent(wsDown);
-        bRichText = pText->GetClassID() == XFA_ELEMENT_ExData;
+        bRichText = pText->GetClassID() == XFA_Element::ExData;
         return !wsDown.IsEmpty();
       }
       pText = pText->GetNodeItem(XFA_NODEITEM_NextSibling);
     }
   }
   return FALSE;
 }
 
 int32_t CXFA_WidgetData::GetCheckButtonShape() {
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild)
     return pUIChild->GetEnum(XFA_ATTRIBUTE_Shape);
   return XFA_GetAttributeDefaultValue_Enum(
-      XFA_ELEMENT_CheckButton, XFA_ATTRIBUTE_Shape, XFA_XDPPACKET_Form);
+      XFA_Element::CheckButton, XFA_ATTRIBUTE_Shape, XFA_XDPPACKET_Form);
 }
 
 int32_t CXFA_WidgetData::GetCheckButtonMark() {
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild)
     return pUIChild->GetEnum(XFA_ATTRIBUTE_Mark);
   return XFA_GetAttributeDefaultValue_Enum(
-      XFA_ELEMENT_CheckButton, XFA_ATTRIBUTE_Mark, XFA_XDPPACKET_Form);
+      XFA_Element::CheckButton, XFA_ATTRIBUTE_Mark, XFA_XDPPACKET_Form);
 }
 
 FX_BOOL CXFA_WidgetData::IsRadioButton() {
   if (CXFA_Node* pParent = m_pNode->GetNodeItem(XFA_NODEITEM_Parent))
-    return pParent->GetClassID() == XFA_ELEMENT_ExclGroup;
+    return pParent->GetClassID() == XFA_Element::ExclGroup;
   return FALSE;
 }
 
 FX_FLOAT CXFA_WidgetData::GetCheckButtonSize() {
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild)
     return pUIChild->GetMeasure(XFA_ATTRIBUTE_Size).ToUnit(XFA_UNIT_Pt);
   return XFA_GetAttributeDefaultValue_Measure(
-             XFA_ELEMENT_CheckButton, XFA_ATTRIBUTE_Size, XFA_XDPPACKET_Form)
+             XFA_Element::CheckButton, XFA_ATTRIBUTE_Size, XFA_XDPPACKET_Form)
       .ToUnit(XFA_UNIT_Pt);
 }
 
 FX_BOOL CXFA_WidgetData::IsAllowNeutral() {
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild)
     return pUIChild->GetBoolean(XFA_ATTRIBUTE_AllowNeutral);
   return XFA_GetAttributeDefaultValue_Boolean(
-      XFA_ELEMENT_CheckButton, XFA_ATTRIBUTE_AllowNeutral, XFA_XDPPACKET_Form);
+      XFA_Element::CheckButton, XFA_ATTRIBUTE_AllowNeutral, XFA_XDPPACKET_Form);
 }
 
 XFA_CHECKSTATE CXFA_WidgetData::GetCheckState() {
   CFX_WideString wsValue = GetRawValue();
   if (wsValue.IsEmpty())
     return XFA_CHECKSTATE_Off;
 
-  if (CXFA_Node* pItems = m_pNode->GetChild(0, XFA_ELEMENT_Items)) {
+  if (CXFA_Node* pItems = m_pNode->GetChild(0, XFA_Element::Items)) {
     CXFA_Node* pText = pItems->GetNodeItem(XFA_NODEITEM_FirstChild);
     int32_t i = 0;
     while (pText) {
       CFX_WideString wsContent;
       if (pText->TryContent(wsContent) && (wsContent == wsValue))
         return (XFA_CHECKSTATE)i;
 
       i++;
       pText = pText->GetNodeItem(XFA_NODEITEM_NextSibling);
     }
   }
   return XFA_CHECKSTATE_Off;
 }
 
 void CXFA_WidgetData::SetCheckState(XFA_CHECKSTATE eCheckState, bool bNotify) {
   CXFA_WidgetData exclGroup(GetExclGroupNode());
   if (exclGroup) {
     CFX_WideString wsValue;
     if (eCheckState != XFA_CHECKSTATE_Off) {
-      if (CXFA_Node* pItems = m_pNode->GetChild(0, XFA_ELEMENT_Items)) {
+      if (CXFA_Node* pItems = m_pNode->GetChild(0, XFA_Element::Items)) {
         CXFA_Node* pText = pItems->GetNodeItem(XFA_NODEITEM_FirstChild);
         if (pText)
           pText->TryContent(wsValue);
       }
     }
     CXFA_Node* pChild =
         exclGroup.GetNode()->GetNodeItem(XFA_NODEITEM_FirstChild);
     for (; pChild; pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-      if (pChild->GetClassID() != XFA_ELEMENT_Field)
+      if (pChild->GetClassID() != XFA_Element::Field)
         continue;
 
-      CXFA_Node* pItem = pChild->GetChild(0, XFA_ELEMENT_Items);
+      CXFA_Node* pItem = pChild->GetChild(0, XFA_Element::Items);
       if (!pItem)
         continue;
 
       CXFA_Node* pItemchild = pItem->GetNodeItem(XFA_NODEITEM_FirstChild);
       if (!pItemchild)
         continue;
 
       CFX_WideString text = pItemchild->GetContent();
       CFX_WideString wsChildValue = text;
       if (wsValue != text) {
         pItemchild = pItemchild->GetNodeItem(XFA_NODEITEM_NextSibling);
         if (pItemchild)
           wsChildValue = pItemchild->GetContent();
         else
           wsChildValue.clear();
       }
       CXFA_WidgetData ch(pChild);
       ch.SyncValue(wsChildValue, bNotify);
     }
     exclGroup.SyncValue(wsValue, bNotify);
   } else {
-    CXFA_Node* pItems = m_pNode->GetChild(0, XFA_ELEMENT_Items);
+    CXFA_Node* pItems = m_pNode->GetChild(0, XFA_Element::Items);
     if (!pItems)
       return;
 
     int32_t i = -1;
     CXFA_Node* pText = pItems->GetNodeItem(XFA_NODEITEM_FirstChild);
     CFX_WideString wsContent;
     while (pText) {
       i++;
       if (i == eCheckState) {
         pText->TryContent(wsContent);
         break;
       }
       pText = pText->GetNodeItem(XFA_NODEITEM_NextSibling);
     }
     SyncValue(wsContent, bNotify);
   }
 }
 
 CXFA_Node* CXFA_WidgetData::GetExclGroupNode() {
   CXFA_Node* pExcl = ToNode(m_pNode->GetNodeItem(XFA_NODEITEM_Parent));
-  if (!pExcl || pExcl->GetClassID() != XFA_ELEMENT_ExclGroup)
+  if (!pExcl || pExcl->GetClassID() != XFA_Element::ExclGroup)
     return NULL;
   return pExcl;
 }
 
 CXFA_Node* CXFA_WidgetData::GetSelectedMember() {
   CXFA_Node* pSelectedMember = NULL;
   CFX_WideString wsState = GetRawValue();
   if (wsState.IsEmpty())
     return pSelectedMember;
 
@@ skipping 22 matching lines @@
   return nullptr;
 }
 
 void CXFA_WidgetData::SetSelectedMemberByValue(const CFX_WideStringC& wsValue,
                                                bool bNotify,
                                                FX_BOOL bScriptModify,
                                                FX_BOOL bSyncData) {
   CFX_WideString wsExclGroup;
   for (CXFA_Node* pNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetClassID() != XFA_ELEMENT_Field)
+    if (pNode->GetClassID() != XFA_Element::Field)
       continue;
 
-    CXFA_Node* pItem = pNode->GetChild(0, XFA_ELEMENT_Items);
+    CXFA_Node* pItem = pNode->GetChild(0, XFA_Element::Items);
     if (!pItem)
       continue;
 
     CXFA_Node* pItemchild = pItem->GetNodeItem(XFA_NODEITEM_FirstChild);
     if (!pItemchild)
       continue;
 
     CFX_WideString wsChildValue = pItemchild->GetContent();
     if (wsValue != wsChildValue) {
       pItemchild = pItemchild->GetNodeItem(XFA_NODEITEM_NextSibling);
@@ skipping 13 matching lines @@
   }
 }
 
 CXFA_Node* CXFA_WidgetData::GetExclGroupFirstMember() {
   CXFA_Node* pExcl = GetNode();
   if (!pExcl)
     return NULL;
 
   CXFA_Node* pNode = pExcl->GetNodeItem(XFA_NODEITEM_FirstChild);
   while (pNode) {
-    if (pNode->GetClassID() == XFA_ELEMENT_Field)
+    if (pNode->GetClassID() == XFA_Element::Field)
       return pNode;
 
     pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling);
   }
   return NULL;
 }
 CXFA_Node* CXFA_WidgetData::GetExclGroupNextMember(CXFA_Node* pNode) {
   if (!pNode)
     return NULL;
 
   CXFA_Node* pNodeField = pNode->GetNodeItem(XFA_NODEITEM_NextSibling);
   while (pNodeField) {
-    if (pNodeField->GetClassID() == XFA_ELEMENT_Field)
+    if (pNodeField->GetClassID() == XFA_Element::Field)
       return pNodeField;
 
     pNodeField = pNodeField->GetNodeItem(XFA_NODEITEM_NextSibling);
   }
   return NULL;
 }
 
 int32_t CXFA_WidgetData::GetChoiceListCommitOn() {
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild)
     return pUIChild->GetEnum(XFA_ATTRIBUTE_CommitOn);
   return XFA_GetAttributeDefaultValue_Enum(
-      XFA_ELEMENT_ChoiceList, XFA_ATTRIBUTE_CommitOn, XFA_XDPPACKET_Form);
+      XFA_Element::ChoiceList, XFA_ATTRIBUTE_CommitOn, XFA_XDPPACKET_Form);
 }
 
 FX_BOOL CXFA_WidgetData::IsChoiceListAllowTextEntry() {
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild)
     return pUIChild->GetBoolean(XFA_ATTRIBUTE_TextEntry);
   return XFA_GetAttributeDefaultValue_Boolean(
-      XFA_ELEMENT_ChoiceList, XFA_ATTRIBUTE_TextEntry, XFA_XDPPACKET_Form);
+      XFA_Element::ChoiceList, XFA_ATTRIBUTE_TextEntry, XFA_XDPPACKET_Form);
 }
 
 int32_t CXFA_WidgetData::GetChoiceListOpen() {
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild)
     return pUIChild->GetEnum(XFA_ATTRIBUTE_Open);
   return XFA_GetAttributeDefaultValue_Enum(
-      XFA_ELEMENT_ChoiceList, XFA_ATTRIBUTE_Open, XFA_XDPPACKET_Form);
+      XFA_Element::ChoiceList, XFA_ATTRIBUTE_Open, XFA_XDPPACKET_Form);
 }
 
 FX_BOOL CXFA_WidgetData::IsListBox() {
   int32_t iOpenMode = GetChoiceListOpen();
   return (iOpenMode == XFA_ATTRIBUTEENUM_Always ||
           iOpenMode == XFA_ATTRIBUTEENUM_MultiSelect);
 }
 
 int32_t CXFA_WidgetData::CountChoiceListItems(FX_BOOL bSaveValue) {
   CXFA_NodeArray pItems;
   CXFA_Node* pItem = NULL;
   int32_t iCount = 0;
   CXFA_Node* pNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
   for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetClassID() != XFA_ELEMENT_Items)
+    if (pNode->GetClassID() != XFA_Element::Items)
       continue;
 
     iCount++;
     pItems.Add(pNode);
     if (iCount == 2)
       break;
   }
   if (iCount == 0)
     return 0;
 
   pItem = pItems[0];
   if (iCount > 1) {
     FX_BOOL bItemOneHasSave = pItems[0]->GetBoolean(XFA_ATTRIBUTE_Save);
     FX_BOOL bItemTwoHasSave = pItems[1]->GetBoolean(XFA_ATTRIBUTE_Save);
     if (bItemOneHasSave != bItemTwoHasSave && bSaveValue == bItemTwoHasSave)
       pItem = pItems[1];
   }
   pItems.RemoveAll();
-  return pItem->CountChildren(XFA_ELEMENT_UNKNOWN);
+  return pItem->CountChildren(XFA_Element::Unknown);
 }
 
 FX_BOOL CXFA_WidgetData::GetChoiceListItem(CFX_WideString& wsText,
                                            int32_t nIndex,
                                            FX_BOOL bSaveValue) {
   wsText.clear();
   CXFA_NodeArray pItemsArray;
-  CXFA_Node* pItems = NULL;
+  CXFA_Node* pItems = nullptr;
   int32_t iCount = 0;
   CXFA_Node* pNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
   for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetClassID() != XFA_ELEMENT_Items)
+    if (pNode->GetClassID() != XFA_Element::Items)
       continue;
 
     iCount++;
     pItemsArray.Add(pNode);
     if (iCount == 2)
       break;
   }
   if (iCount == 0)
     return FALSE;
 
   pItems = pItemsArray[0];
   if (iCount > 1) {
     FX_BOOL bItemOneHasSave = pItemsArray[0]->GetBoolean(XFA_ATTRIBUTE_Save);
     FX_BOOL bItemTwoHasSave = pItemsArray[1]->GetBoolean(XFA_ATTRIBUTE_Save);
     if (bItemOneHasSave != bItemTwoHasSave && bSaveValue == bItemTwoHasSave)
       pItems = pItemsArray[1];
   }
   if (pItems) {
-    CXFA_Node* pItem = pItems->GetChild(nIndex, XFA_ELEMENT_UNKNOWN);
+    CXFA_Node* pItem = pItems->GetChild(nIndex, XFA_Element::Unknown);
     if (pItem) {
       pItem->TryContent(wsText);
       return TRUE;
     }
   }
   return FALSE;
 }
 
 void CXFA_WidgetData::GetChoiceListItems(CFX_WideStringArray& wsTextArray,
                                          FX_BOOL bSaveValue) {
   CXFA_NodeArray pItems;
   CXFA_Node* pItem = NULL;
   int32_t iCount = 0;
   CXFA_Node* pNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
   for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetClassID() != XFA_ELEMENT_Items)
+    if (pNode->GetClassID() != XFA_Element::Items)
       continue;
 
     iCount++;
     pItems.Add(pNode);
     if (iCount == 2)
       break;
   }
   if (iCount == 0)
     return;
 
@@ skipping 211 matching lines @@
                                  FX_BOOL bNotify) {
   CFX_WideString wsNewValue(wsValue);
   if (wsNewValue.IsEmpty())
     wsNewValue = wsLabel;
 
   CXFA_NodeArray listitems;
   int32_t iCount = 0;
   CXFA_Node* pItemNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
   for (; pItemNode;
        pItemNode = pItemNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pItemNode->GetClassID() != XFA_ELEMENT_Items)
+    if (pItemNode->GetClassID() != XFA_Element::Items)
       continue;
 
     listitems.Add(pItemNode);
     iCount++;
   }
   if (iCount < 1) {
-    CXFA_Node* pItems = m_pNode->CreateSamePacketNode(XFA_ELEMENT_Items);
+    CXFA_Node* pItems = m_pNode->CreateSamePacketNode(XFA_Element::Items);
     m_pNode->InsertChild(-1, pItems);
     InsertListTextItem(pItems, wsLabel, nIndex);
-    CXFA_Node* pSaveItems = m_pNode->CreateSamePacketNode(XFA_ELEMENT_Items);
+    CXFA_Node* pSaveItems = m_pNode->CreateSamePacketNode(XFA_Element::Items);
     m_pNode->InsertChild(-1, pSaveItems);
     pSaveItems->SetBoolean(XFA_ATTRIBUTE_Save, TRUE);
     InsertListTextItem(pSaveItems, wsNewValue, nIndex);
   } else if (iCount > 1) {
     for (int32_t i = 0; i < 2; i++) {
       CXFA_Node* pNode = listitems[i];
       FX_BOOL bHasSave = pNode->GetBoolean(XFA_ATTRIBUTE_Save);
       if (bHasSave)
         InsertListTextItem(pNode, wsNewValue, nIndex);
       else
         InsertListTextItem(pNode, wsLabel, nIndex);
     }
   } else {
     CXFA_Node* pNode = listitems[0];
     pNode->SetBoolean(XFA_ATTRIBUTE_Save, FALSE);
     pNode->SetEnum(XFA_ATTRIBUTE_Presence, XFA_ATTRIBUTEENUM_Visible);
-    CXFA_Node* pSaveItems = m_pNode->CreateSamePacketNode(XFA_ELEMENT_Items);
+    CXFA_Node* pSaveItems = m_pNode->CreateSamePacketNode(XFA_Element::Items);
     m_pNode->InsertChild(-1, pSaveItems);
     pSaveItems->SetBoolean(XFA_ATTRIBUTE_Save, TRUE);
     pSaveItems->SetEnum(XFA_ATTRIBUTE_Presence, XFA_ATTRIBUTEENUM_Hidden);
     listitems.RemoveAll();
     CXFA_Node* pListNode = pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
     int32_t i = 0;
     while (pListNode) {
       CFX_WideString wsOldValue;
       pListNode->TryContent(wsOldValue);
       InsertListTextItem(pSaveItems, wsOldValue, i);
       i++;
       pListNode = pListNode->GetNodeItem(XFA_NODEITEM_NextSibling);
     }
     InsertListTextItem(pNode, wsLabel, nIndex);
     InsertListTextItem(pSaveItems, wsNewValue, nIndex);
   }
   if (!bNotify)
     return;
 
   m_pNode->GetDocument()->GetNotify()->OnWidgetListItemAdded(
       this, wsLabel.c_str(), wsValue.c_str(), nIndex);
 }
 
 void CXFA_WidgetData::GetItemLabel(const CFX_WideStringC& wsValue,
                                    CFX_WideString& wsLabel) {
   int32_t iCount = 0;
   CXFA_NodeArray listitems;
   CXFA_Node* pItems = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
   for (; pItems; pItems = pItems->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pItems->GetClassID() != XFA_ELEMENT_Items)
+    if (pItems->GetClassID() != XFA_Element::Items)
       continue;
 
     iCount++;
     listitems.Add(pItems);
   }
   if (iCount <= 1) {
     wsLabel = wsValue;
   } else {
     CXFA_Node* pLabelItems = listitems[0];
     FX_BOOL bSave = pLabelItems->GetBoolean(XFA_ATTRIBUTE_Save);
@@ skipping 13 matching lines @@
       pChildItem->TryContent(wsContent);
       if (wsContent == wsValue) {
         iSearch = iCount;
         break;
       }
       iCount++;
     }
     if (iSearch < 0)
       return;
     if (CXFA_Node* pText =
-            pLabelItems->GetChild(iSearch, XFA_ELEMENT_UNKNOWN)) {
+            pLabelItems->GetChild(iSearch, XFA_Element::Unknown)) {
       pText->TryContent(wsLabel);
     }
   }
 }
 
 void CXFA_WidgetData::GetItemValue(const CFX_WideStringC& wsLabel,
                                    CFX_WideString& wsValue) {
   int32_t iCount = 0;
   CXFA_NodeArray listitems;
   CXFA_Node* pItems = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
   for (; pItems; pItems = pItems->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pItems->GetClassID() != XFA_ELEMENT_Items)
+    if (pItems->GetClassID() != XFA_Element::Items)
       continue;
 
     iCount++;
     listitems.Add(pItems);
   }
   if (iCount <= 1) {
     wsValue = wsLabel;
   } else {
     CXFA_Node* pLabelItems = listitems[0];
     FX_BOOL bSave = pLabelItems->GetBoolean(XFA_ATTRIBUTE_Save);
@@ skipping 12 matching lines @@
          pChildItem = pChildItem->GetNodeItem(XFA_NODEITEM_NextSibling)) {
       pChildItem->TryContent(wsContent);
       if (wsContent == wsLabel) {
         iSearch = iCount;
         break;
       }
       iCount++;
     }
     if (iSearch < 0)
       return;
-    if (CXFA_Node* pText = pSaveItems->GetChild(iSearch, XFA_ELEMENT_UNKNOWN))
+    if (CXFA_Node* pText = pSaveItems->GetChild(iSearch, XFA_Element::Unknown))
       pText->TryContent(wsValue);
   }
 }
 
 FX_BOOL CXFA_WidgetData::DeleteItem(int32_t nIndex,
                                     FX_BOOL bNotify,
                                     FX_BOOL bScriptModify,
                                     FX_BOOL bSyncData) {
   FX_BOOL bSetValue = FALSE;
   CXFA_Node* pItems = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
   for (; pItems; pItems = pItems->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pItems->GetClassID() != XFA_ELEMENT_Items)
+    if (pItems->GetClassID() != XFA_Element::Items)
       continue;
 
     if (nIndex < 0) {
       while (CXFA_Node* pNode = pItems->GetNodeItem(XFA_NODEITEM_FirstChild)) {
         pItems->RemoveChild(pNode);
       }
     } else {
       if (!bSetValue && pItems->GetBoolean(XFA_ATTRIBUTE_Save)) {
         SetItemState(nIndex, FALSE, true, bScriptModify, bSyncData);
         bSetValue = TRUE;
@@ skipping 19 matching lines @@
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild)
     return pUIChild->GetEnum(XFA_ATTRIBUTE_HScrollPolicy);
   return XFA_ATTRIBUTEENUM_Auto;
 }
 
 int32_t CXFA_WidgetData::GetNumberOfCells() {
   CXFA_Node* pUIChild = GetUIChild();
   if (!pUIChild)
     return -1;
-  if (CXFA_Node* pNode = pUIChild->GetChild(0, XFA_ELEMENT_Comb))
+  if (CXFA_Node* pNode = pUIChild->GetChild(0, XFA_Element::Comb))
     return pNode->GetInteger(XFA_ATTRIBUTE_NumberOfCells);
   return -1;
 }
 
 CFX_WideString CXFA_WidgetData::GetBarcodeType() {
   CXFA_Node* pUIChild = GetUIChild();
   return pUIChild ? CFX_WideString(pUIChild->GetCData(XFA_ATTRIBUTE_Type))
                   : CFX_WideString();
 }
 
@@ skipping 167 matching lines @@
     return TRUE;
   }
   return FALSE;
 }
 
 void CXFA_WidgetData::GetPasswordChar(CFX_WideString& wsPassWord) {
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild) {
     pUIChild->TryCData(XFA_ATTRIBUTE_PasswordChar, wsPassWord);
   } else {
-    wsPassWord = XFA_GetAttributeDefaultValue_Cdata(XFA_ELEMENT_PasswordEdit,
+    wsPassWord = XFA_GetAttributeDefaultValue_Cdata(XFA_Element::PasswordEdit,
                                                     XFA_ATTRIBUTE_PasswordChar,
                                                     XFA_XDPPACKET_Form);
   }
 }
 
 FX_BOOL CXFA_WidgetData::IsMultiLine() {
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild)
     return pUIChild->GetBoolean(XFA_ATTRIBUTE_MultiLine);
   return XFA_GetAttributeDefaultValue_Boolean(
-      XFA_ELEMENT_TextEdit, XFA_ATTRIBUTE_MultiLine, XFA_XDPPACKET_Form);
+      XFA_Element::TextEdit, XFA_ATTRIBUTE_MultiLine, XFA_XDPPACKET_Form);
 }
 
 int32_t CXFA_WidgetData::GetVerticalScrollPolicy() {
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild)
     return pUIChild->GetEnum(XFA_ATTRIBUTE_VScrollPolicy);
   return XFA_GetAttributeDefaultValue_Enum(
-      XFA_ELEMENT_TextEdit, XFA_ATTRIBUTE_VScrollPolicy, XFA_XDPPACKET_Form);
+      XFA_Element::TextEdit, XFA_ATTRIBUTE_VScrollPolicy, XFA_XDPPACKET_Form);
 }
 
-int32_t CXFA_WidgetData::GetMaxChars(XFA_ELEMENT& eType) {
-  if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_ELEMENT_Value)) {
+int32_t CXFA_WidgetData::GetMaxChars(XFA_Element& eType) {
+  if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_Element::Value)) {
     if (CXFA_Node* pChild = pNode->GetNodeItem(XFA_NODEITEM_FirstChild)) {
       switch (pChild->GetClassID()) {
-        case XFA_ELEMENT_Text:
-          eType = XFA_ELEMENT_Text;
+        case XFA_Element::Text:
+          eType = XFA_Element::Text;
           return pChild->GetInteger(XFA_ATTRIBUTE_MaxChars);
-        case XFA_ELEMENT_ExData: {
-          eType = XFA_ELEMENT_ExData;
+        case XFA_Element::ExData: {
+          eType = XFA_Element::ExData;
           int32_t iMax = pChild->GetInteger(XFA_ATTRIBUTE_MaxLength);
           return iMax < 0 ? 0 : iMax;
         }
         default:
           break;
       }
     }
   }
   return 0;
 }
 
 FX_BOOL CXFA_WidgetData::GetFracDigits(int32_t& iFracDigits) {
-  if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_ELEMENT_Value)) {
-    if (CXFA_Node* pChild = pNode->GetChild(0, XFA_ELEMENT_Decimal))
+  if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_Element::Value)) {
+    if (CXFA_Node* pChild = pNode->GetChild(0, XFA_Element::Decimal))
       return pChild->TryInteger(XFA_ATTRIBUTE_FracDigits, iFracDigits);
   }
   iFracDigits = -1;
   return FALSE;
 }
 
 FX_BOOL CXFA_WidgetData::GetLeadDigits(int32_t& iLeadDigits) {
-  if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_ELEMENT_Value)) {
-    if (CXFA_Node* pChild = pNode->GetChild(0, XFA_ELEMENT_Decimal))
+  if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_Element::Value)) {
+    if (CXFA_Node* pChild = pNode->GetChild(0, XFA_Element::Decimal))
       return pChild->TryInteger(XFA_ATTRIBUTE_LeadDigits, iLeadDigits);
   }
   iLeadDigits = -1;
   return FALSE;
 }
 
 FX_BOOL CXFA_WidgetData::SetValue(const CFX_WideString& wsValue,
                                   XFA_VALUEPICTURE eValueType) {
   if (wsValue.IsEmpty()) {
     SyncValue(wsValue, true);
     return TRUE;
   }
   m_bPreNull = m_bIsNull;
   m_bIsNull = FALSE;
   CFX_WideString wsNewText(wsValue);
   CFX_WideString wsPicture;
   GetPictureContent(wsPicture, eValueType);
   FX_BOOL bValidate = TRUE;
   FX_BOOL bSyncData = FALSE;
   CXFA_Node* pNode = GetUIChild();
   if (!pNode)
     return TRUE;
 
-  XFA_ELEMENT uiType = pNode->GetClassID();
+  XFA_Element uiType = pNode->GetClassID();
   if (!wsPicture.IsEmpty()) {
     CXFA_LocaleMgr* pLocalMgr = m_pNode->GetDocument()->GetLocalMgr();
     IFX_Locale* pLocale = GetLocal();
     CXFA_LocaleValue widgetValue = XFA_GetLocaleValue(this);
     bValidate =
         widgetValue.ValidateValue(wsValue, wsPicture, pLocale, &wsPicture);
     if (bValidate) {
       widgetValue = CXFA_LocaleValue(widgetValue.GetType(), wsNewText,
                                      wsPicture, pLocale, pLocalMgr);
       wsNewText = widgetValue.GetValue();
-      if (uiType == XFA_ELEMENT_NumericEdit) {
+      if (uiType == XFA_Element::NumericEdit) {
         int32_t iLeadDigits = 0;
         int32_t iFracDigits = 0;
         GetLeadDigits(iLeadDigits);
         GetFracDigits(iFracDigits);
         wsNewText = NumericLimit(wsNewText, iLeadDigits, iFracDigits);
       }
       bSyncData = TRUE;
     }
   } else {
-    if (uiType == XFA_ELEMENT_NumericEdit) {
+    if (uiType == XFA_Element::NumericEdit) {
       if (wsNewText != FX_WSTRC(L"0")) {
         int32_t iLeadDigits = 0;
         int32_t iFracDigits = 0;
         GetLeadDigits(iLeadDigits);
         GetFracDigits(iFracDigits);
         wsNewText = NumericLimit(wsNewText, iLeadDigits, iFracDigits);
       }
       bSyncData = TRUE;
     }
   }
-  if (uiType != XFA_ELEMENT_NumericEdit || bSyncData)
+  if (uiType != XFA_Element::NumericEdit || bSyncData)
     SyncValue(wsNewText, true);
 
   return bValidate;
 }
 
 FX_BOOL CXFA_WidgetData::GetPictureContent(CFX_WideString& wsPicture,
                                            XFA_VALUEPICTURE ePicture) {
   if (ePicture == XFA_VALUEPICTURE_Raw)
     return FALSE;
 
   CXFA_LocaleValue widgetValue = XFA_GetLocaleValue(this);
   switch (ePicture) {
     case XFA_VALUEPICTURE_Display: {
-      if (CXFA_Node* pFormat = m_pNode->GetChild(0, XFA_ELEMENT_Format)) {
-        if (CXFA_Node* pPicture = pFormat->GetChild(0, XFA_ELEMENT_Picture)) {
+      if (CXFA_Node* pFormat = m_pNode->GetChild(0, XFA_Element::Format)) {
+        if (CXFA_Node* pPicture = pFormat->GetChild(0, XFA_Element::Picture)) {
           if (pPicture->TryContent(wsPicture))
             return TRUE;
         }
       }
       CFX_WideString wsDataPicture, wsTimePicture;
       IFX_Locale* pLocale = GetLocal();
       if (!pLocale)
         return FALSE;
 
       uint32_t dwType = widgetValue.GetType();
@@ skipping 16 matching lines @@
         case XFA_VT_DECIMAL:
         case XFA_VT_FLOAT:
           break;
         default:
           break;
       }
       return TRUE;
     }
 
     case XFA_VALUEPICTURE_Edit: {
-      CXFA_Node* pUI = m_pNode->GetChild(0, XFA_ELEMENT_Ui);
+      CXFA_Node* pUI = m_pNode->GetChild(0, XFA_Element::Ui);
       if (pUI) {
-        if (CXFA_Node* pPicture = pUI->GetChild(0, XFA_ELEMENT_Picture)) {
+        if (CXFA_Node* pPicture = pUI->GetChild(0, XFA_Element::Picture)) {
           if (pPicture->TryContent(wsPicture))
             return TRUE;
         }
       }
       {
         CFX_WideString wsDataPicture, wsTimePicture;
         IFX_Locale* pLocale = GetLocal();
         if (!pLocale) {
           return FALSE;
         }
@@ skipping 58 matching lines @@
 
   if (eValueType == XFA_VALUEPICTURE_Display)
     GetItemLabel(wsValue.AsStringC(), wsValue);
 
   CFX_WideString wsPicture;
   GetPictureContent(wsPicture, eValueType);
   CXFA_Node* pNode = GetUIChild();
   if (!pNode)
     return TRUE;
 
-  XFA_ELEMENT uiType = GetUIChild()->GetClassID();
+  XFA_Element uiType = GetUIChild()->GetClassID();
   switch (uiType) {
-    case XFA_ELEMENT_ChoiceList: {
+    case XFA_Element::ChoiceList: {
       if (eValueType == XFA_VALUEPICTURE_Display) {
         int32_t iSelItemIndex = GetSelectedItem(0);
         if (iSelItemIndex >= 0) {
           GetChoiceListItem(wsValue, iSelItemIndex);
           wsPicture.clear();
         }
       }
     } break;
-    case XFA_ELEMENT_NumericEdit:
+    case XFA_Element::NumericEdit:
       if (eValueType != XFA_VALUEPICTURE_Raw && wsPicture.IsEmpty()) {
         IFX_Locale* pLocale = GetLocal();
         if (eValueType == XFA_VALUEPICTURE_Display && pLocale) {
           CFX_WideString wsOutput;
           NormalizeNumStr(wsValue, wsOutput);
           FormatNumStr(wsOutput, pLocale, wsOutput);
           wsValue = wsOutput;
         }
       }
       break;
@@ skipping 64 matching lines @@
   if (wsValue.IsEmpty())
     return TRUE;
 
   CFX_WideString wsPicture;
   GetPictureContent(wsPicture, XFA_VALUEPICTURE_DataBind);
   if (wsPicture.IsEmpty())
     return TRUE;
 
   if (IFX_Locale* pLocale = GetLocal()) {
     ASSERT(GetNode());
-    CXFA_Node* pNodeValue = GetNode()->GetChild(0, XFA_ELEMENT_Value);
+    CXFA_Node* pNodeValue = GetNode()->GetChild(0, XFA_Element::Value);
     if (!pNodeValue)
       return FALSE;
 
     CXFA_Node* pValueChild = pNodeValue->GetNodeItem(XFA_NODEITEM_FirstChild);
     if (!pValueChild)
       return FALSE;
 
     int32_t iVTType = XFA_VT_NULL;
-    XFA_ELEMENT eType = pValueChild->GetClassID();
+    XFA_Element eType = pValueChild->GetClassID();
     switch (eType) {
-      case XFA_ELEMENT_Decimal:
+      case XFA_Element::Decimal:
         iVTType = XFA_VT_DECIMAL;
         break;
-      case XFA_ELEMENT_Float:
+      case XFA_Element::Float:
         iVTType = XFA_VT_FLOAT;
         break;
-      case XFA_ELEMENT_Date:
+      case XFA_Element::Date:
         iVTType = XFA_VT_DATE;
         break;
-      case XFA_ELEMENT_Time:
+      case XFA_Element::Time:
         iVTType = XFA_VT_TIME;
         break;
-      case XFA_ELEMENT_DateTime:
+      case XFA_Element::DateTime:
         iVTType = XFA_VT_DATETIME;
         break;
-      case XFA_ELEMENT_Boolean:
+      case XFA_Element::Boolean:
         iVTType = XFA_VT_BOOLEAN;
         break;
-      case XFA_ELEMENT_Integer:
+      case XFA_Element::Integer:
         iVTType = XFA_VT_INTEGER;
         break;
-      case XFA_ELEMENT_Text:
+      case XFA_Element::Text:
         iVTType = XFA_VT_TEXT;
         break;
       default:
         iVTType = XFA_VT_NULL;
         break;
     }
     CXFA_LocaleMgr* pLocalMgr = GetNode()->GetDocument()->GetLocalMgr();
     CXFA_LocaleValue widgetValue(iVTType, wsValue, pLocalMgr);
     switch (widgetValue.GetType()) {
       case XFA_VT_DATE: {
@@ skipping 96 matching lines @@
   CXFA_WidgetData* pContainerWidgetData = m_pNode->GetContainerWidgetData();
   if (pContainerWidgetData)
     pContainerWidgetData->GetFormatDataValue(wsValue, wsFormatValue);
 
   m_pNode->SetContent(wsValue, wsFormatValue, bNotify);
 }
 
 void CXFA_WidgetData::InsertListTextItem(CXFA_Node* pItems,
                                          const CFX_WideString& wsText,
                                          int32_t nIndex) {
-  CXFA_Node* pText = pItems->CreateSamePacketNode(XFA_ELEMENT_Text);
+  CXFA_Node* pText = pItems->CreateSamePacketNode(XFA_Element::Text);
   pItems->InsertChild(nIndex, pText);
   pText->SetContent(wsText, wsText, FALSE, FALSE, FALSE);
 }
 
 CFX_WideString CXFA_WidgetData::NumericLimit(const CFX_WideString& wsValue,
                                              int32_t iLead,
                                              int32_t iTread) const {
   if ((iLead == -1) && (iTread == -1))
     return wsValue;
 
@@ skipping 27 matching lines @@
         }
       }
     } else if (wc == L'.') {
       iTread_ = 0;
       iLead = -1;
     }
     wsRet += wc;
   }
   return wsRet;
 }