Convert XFA_ELEMENT to an enum class

xfa/fxfa/app/xfa_ffwidgetacc.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "xfa/fxfa/app/xfa_ffwidgetacc.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 181 matching lines @@
 }
 FX_BOOL CXFA_WidgetAcc::ProcessValueChanged() {
   m_pDocView->AddValidateWidget(this);
   m_pDocView->AddCalculateWidgetAcc(this);
   m_pDocView->RunCalculateWidgets();
   m_pDocView->RunValidate();
   return TRUE;
 }
 void CXFA_WidgetAcc::ResetData() {
   CFX_WideString wsValue;
-  XFA_ELEMENT eUIType = (XFA_ELEMENT)GetUIType();
+  XFA_Element eUIType = GetUIType();
   switch (eUIType) {
-    case XFA_ELEMENT_ImageEdit: {
+    case XFA_Element::ImageEdit: {
       CXFA_Value imageValue = GetDefaultValue();
       CXFA_Image image = imageValue.GetImage();
       CFX_WideString wsContentType, wsHref;
       if (image) {
         image.GetContent(wsValue);
         image.GetContentType(wsContentType);
         image.GetHref(wsHref);
       }
       SetImageEdit(wsContentType, wsHref, wsValue);
     } break;
-    case XFA_ELEMENT_ExclGroup: {
+    case XFA_Element::ExclGroup: {
       CXFA_Node* pNextChild = m_pNode->GetNodeItem(
           XFA_NODEITEM_FirstChild, XFA_ObjectType::ContainerNode);
       while (pNextChild) {
         CXFA_Node* pChild = pNextChild;
         CXFA_WidgetAcc* pAcc =
             static_cast<CXFA_WidgetAcc*>(pChild->GetWidgetData());
         if (!pAcc) {
           continue;
         }
         CXFA_Value defValue(NULL);
         if (wsValue.IsEmpty() && (defValue = pAcc->GetDefaultValue())) {
           defValue.GetChildValueContent(wsValue);
           SetValue(wsValue, XFA_VALUEPICTURE_Raw);
           pAcc->SetValue(wsValue, XFA_VALUEPICTURE_Raw);
         } else {
-          CXFA_Node* pItems = pChild->GetChild(0, XFA_ELEMENT_Items);
+          CXFA_Node* pItems = pChild->GetChild(0, XFA_Element::Items);
           if (!pItems) {
             continue;
           }
           CFX_WideString itemText;
-          if (pItems->CountChildren(XFA_ELEMENT_UNKNOWN) > 1) {
-            itemText = pItems->GetChild(1, XFA_ELEMENT_UNKNOWN)->GetContent();
+          if (pItems->CountChildren(XFA_Element::Unknown) > 1) {
+            itemText = pItems->GetChild(1, XFA_Element::Unknown)->GetContent();
           }
           pAcc->SetValue(itemText, XFA_VALUEPICTURE_Raw);
         }
         pNextChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling,
                                          XFA_ObjectType::ContainerNode);
       }
     } break;
-    case XFA_ELEMENT_ChoiceList:
+    case XFA_Element::ChoiceList:
       ClearAllSelections();
     default:
       if (CXFA_Value defValue = GetDefaultValue()) {
         defValue.GetChildValueContent(wsValue);
       }
       SetValue(wsValue, XFA_VALUEPICTURE_Raw);
       break;
   }
 }
 void CXFA_WidgetAcc::SetImageEdit(const CFX_WideString& wsContentType,
@@ skipping 18 matching lines @@
     pHrefNode->SetCData(XFA_ATTRIBUTE_Value, wsHref);
   } else {
     CFDE_XMLNode* pXMLNode = pBind->GetXMLMappingNode();
     ASSERT(pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element);
     static_cast<CFDE_XMLElement*>(pXMLNode)->SetString(L"href", wsHref);
   }
 }
 
 CXFA_WidgetAcc* CXFA_WidgetAcc::GetExclGroup() {
   CXFA_Node* pExcl = m_pNode->GetNodeItem(XFA_NODEITEM_Parent);
-  if (!pExcl || pExcl->GetClassID() != XFA_ELEMENT_ExclGroup) {
+  if (!pExcl || pExcl->GetClassID() != XFA_Element::ExclGroup) {
     return NULL;
   }
   return static_cast<CXFA_WidgetAcc*>(pExcl->GetWidgetData());
 }
 CXFA_FFDocView* CXFA_WidgetAcc::GetDocView() {
   return m_pDocView;
 }
 CXFA_FFDoc* CXFA_WidgetAcc::GetDoc() {
   return m_pDocView->GetDoc();
 }
 CXFA_FFApp* CXFA_WidgetAcc::GetApp() {
   return GetDoc()->GetApp();
 }
 IXFA_AppProvider* CXFA_WidgetAcc::GetAppProvider() {
   return GetApp()->GetAppProvider();
 }
 int32_t CXFA_WidgetAcc::ProcessEvent(int32_t iActivity,
                                      CXFA_EventParam* pEventParam) {
-  if (GetClassID() == XFA_ELEMENT_Draw) {
+  if (GetClassID() == XFA_Element::Draw) {
     return XFA_EVENTERROR_NotExist;
   }
   int32_t iRet = XFA_EVENTERROR_NotExist;
   CXFA_NodeArray eventArray;
   int32_t iCounts =
       GetEventByActivity(iActivity, eventArray, pEventParam->m_bIsFormReady);
   for (int32_t i = 0; i < iCounts; i++) {
     CXFA_Event event(eventArray[i]);
     int32_t result = ProcessEvent(event, pEventParam);
     if (i == 0) {
       iRet = result;
     } else if (result == XFA_EVENTERROR_Success) {
       iRet = result;
     }
   }
   return iRet;
 }
 int32_t CXFA_WidgetAcc::ProcessEvent(CXFA_Event& event,
                                      CXFA_EventParam* pEventParam) {
-  if (!event) {
+  if (!event)
     return XFA_EVENTERROR_NotExist;
-  }
+
   switch (event.GetEventType()) {
-    case XFA_ELEMENT_Execute:
+    case XFA_Element::Execute:
       break;
-    case XFA_ELEMENT_Script: {
+    case XFA_Element::Script: {
       CXFA_Script script = event.GetScript();
       return ExecuteScript(script, pEventParam);
     } break;
-    case XFA_ELEMENT_SignData:
+    case XFA_Element::SignData:
       break;
-    case XFA_ELEMENT_Submit: {
+    case XFA_Element::Submit: {
       CXFA_Submit submit = event.GetSubmit();
       return GetDoc()->GetDocProvider()->SubmitData(GetDoc(), submit);
     }
     default:
       break;
   }
   return XFA_EVENTERROR_NotExist;
 }
 
 int32_t CXFA_WidgetAcc::ProcessCalculate() {
-  if (GetClassID() == XFA_ELEMENT_Draw)
+  if (GetClassID() == XFA_Element::Draw)
     return XFA_EVENTERROR_NotExist;
 
   CXFA_Calculate calc = GetCalculate();
   if (!calc)
     return XFA_EVENTERROR_NotExist;
   if (GetNode()->IsUserInteractive())
     return XFA_EVENTERROR_Disabled;
 
   CXFA_EventParam EventParam;
   EventParam.m_eType = XFA_EVENT_Calculate;
@@ skipping 205 matching lines @@
     pAppProvider->LoadString(XFA_IDS_ValidateError, wsError);
     wsMessage.Format(wsError.c_str(), wsCaptionName.c_str());
     return;
   }
   CFX_WideString wsWarning;
   pAppProvider->LoadString(XFA_IDS_ValidateWarning, wsWarning);
   wsMessage.Format(wsWarning.c_str(), wsCaptionName.c_str(),
                    wsCaptionName.c_str());
 }
 int32_t CXFA_WidgetAcc::ProcessValidate(int32_t iFlags) {
-  if (GetClassID() == XFA_ELEMENT_Draw) {
+  if (GetClassID() == XFA_Element::Draw) {
     return XFA_EVENTERROR_NotExist;
   }
   CXFA_Validate validate = GetValidate();
   if (!validate) {
     return XFA_EVENTERROR_NotExist;
   }
   FX_BOOL bInitDoc = validate.GetNode()->NeedsInitApp();
   FX_BOOL bStatus =
       m_pDocView->GetLayoutStatus() < XFA_DOCVIEW_LAYOUTSTATUS_End;
   int32_t iFormat = 0;
@@ skipping 121 matching lines @@
     pLayout = pWidget->GetNext();
   } else {
     pLayout = m_pDocView->GetXFALayout()->GetLayoutItem(m_pNode);
   }
   return static_cast<CXFA_FFWidget*>(pLayout);
 }
 void CXFA_WidgetAcc::UpdateUIDisplay(CXFA_FFWidget* pExcept) {
   CXFA_FFWidget* pWidget = NULL;
   while ((pWidget = GetNextWidget(pWidget)) != nullptr) {
     if (pWidget == pExcept || !pWidget->IsLoaded() ||
-        (GetUIType() != XFA_ELEMENT_CheckButton && pWidget->IsFocused())) {
+        (GetUIType() != XFA_Element::CheckButton && pWidget->IsFocused())) {
       continue;
     }
     pWidget->UpdateFWLData();
     pWidget->AddInvalidateRect();
   }
 }
 
 void CXFA_WidgetAcc::CalcCaptionSize(CFX_SizeF& szCap) {
   CXFA_Caption caption = GetCaption();
   if (!caption || caption.GetPresence() != XFA_ATTRIBUTEENUM_Visible) {
     return;
   }
   LoadCaption();
-  XFA_ELEMENT eUIType = (XFA_ELEMENT)GetUIType();
+  XFA_Element eUIType = GetUIType();
   int32_t iCapPlacement = caption.GetPlacementType();
   FX_FLOAT fCapReserve = caption.GetReserve();
   const bool bVert = iCapPlacement == XFA_ATTRIBUTEENUM_Top ||
                      iCapPlacement == XFA_ATTRIBUTEENUM_Bottom;
   const bool bReserveExit = fCapReserve > 0.01;
   CXFA_TextLayout* pCapTextLayout =
       static_cast<CXFA_FieldLayoutData*>(m_pLayoutData.get())
           ->m_pCapTextLayout.get();
   if (pCapTextLayout) {
-    if (!bVert && eUIType != XFA_ELEMENT_Button) {
+    if (!bVert && eUIType != XFA_Element::Button) {
       szCap.x = fCapReserve;
     }
     CFX_SizeF minSize;
     pCapTextLayout->CalcSize(minSize, szCap, szCap);
     if (bReserveExit) {
       bVert ? szCap.y = fCapReserve : szCap.x = fCapReserve;
     }
   } else {
     FX_FLOAT fFontSize = 10.0f;
     if (CXFA_Font font = caption.GetFont()) {
@@ skipping 107 matching lines @@
   CXFA_FieldLayoutData* layoutData =
       static_cast<CXFA_FieldLayoutData*>(m_pLayoutData.get());
   if (!layoutData->m_pTextOut) {
     layoutData->m_pTextOut.reset(new CFDE_TextOut);
     CFDE_TextOut* pTextOut = layoutData->m_pTextOut.get();
     pTextOut->SetFont(GetFDEFont());
     pTextOut->SetFontSize(fFontSize);
     pTextOut->SetLineBreakTolerance(fFontSize * 0.2f);
     pTextOut->SetLineSpace(GetLineHeight());
     uint32_t dwStyles = FDE_TTOSTYLE_LastLineHeight;
-    if (GetUIType() == XFA_ELEMENT_TextEdit && IsMultiLine()) {
+    if (GetUIType() == XFA_Element::TextEdit && IsMultiLine()) {
       dwStyles |= FDE_TTOSTYLE_LineWrap;
     }
     pTextOut->SetStyles(dwStyles);
   }
   layoutData->m_pTextOut->CalcLogicSize(wsText.c_str(), wsText.GetLength(),
                                         size);
 }
 FX_BOOL CXFA_WidgetAcc::CalculateTextEditAutoSize(CFX_SizeF& size) {
   if (size.x > 0) {
     CFX_SizeF szOrz = size;
@@ skipping 203 matching lines @@
     FX_FLOAT fTopInset, fBottomInset;
     mgWidget.GetTopInset(fTopInset);
     mgWidget.GetBottomInset(fBottomInset);
     fHeightCalc -= fTopInset + fBottomInset;
   }
   return fHeightCalc;
 }
 void CXFA_WidgetAcc::StartWidgetLayout(FX_FLOAT& fCalcWidth,
                                        FX_FLOAT& fCalcHeight) {
   InitLayoutData();
-  XFA_ELEMENT eUIType = GetUIType();
-  if (eUIType == XFA_ELEMENT_Text) {
+  XFA_Element eUIType = GetUIType();
+  if (eUIType == XFA_Element::Text) {
     m_pLayoutData->m_fWidgetHeight = -1;
     GetHeight(m_pLayoutData->m_fWidgetHeight);
     StartTextLayout(fCalcWidth, fCalcHeight);
     return;
   }
   if (fCalcWidth > 0 && fCalcHeight > 0) {
     return;
   }
   m_pLayoutData->m_fWidgetHeight = -1;
   FX_FLOAT fWidth = 0;
   if (fCalcWidth > 0 && fCalcHeight < 0) {
     if (!GetHeight(fCalcHeight)) {
       CalculateAccWidthAndHeight(eUIType, fCalcWidth, fCalcHeight);
     }
     m_pLayoutData->m_fWidgetHeight = fCalcHeight;
     return;
   }
   if (fCalcWidth < 0 && fCalcHeight < 0) {
     if (!GetWidth(fWidth) || !GetHeight(fCalcHeight)) {
       CalculateAccWidthAndHeight(eUIType, fWidth, fCalcHeight);
     }
     fCalcWidth = fWidth;
   }
   m_pLayoutData->m_fWidgetHeight = fCalcHeight;
 }
-void CXFA_WidgetAcc::CalculateAccWidthAndHeight(XFA_ELEMENT eUIType,
+void CXFA_WidgetAcc::CalculateAccWidthAndHeight(XFA_Element eUIType,
                                                 FX_FLOAT& fWidth,
                                                 FX_FLOAT& fCalcHeight) {
   CFX_SizeF sz(fWidth, m_pLayoutData->m_fWidgetHeight);
   switch (eUIType) {
-    case XFA_ELEMENT_Barcode:
-    case XFA_ELEMENT_ChoiceList:
-    case XFA_ELEMENT_Signature:
+    case XFA_Element::Barcode:
+    case XFA_Element::ChoiceList:
+    case XFA_Element::Signature:
       CalculateFieldAutoSize(sz);
       break;
-    case XFA_ELEMENT_ImageEdit:
+    case XFA_Element::ImageEdit:
       CalculateImageEditAutoSize(sz);
       break;
-    case XFA_ELEMENT_Button:
+    case XFA_Element::Button:
       CalculatePushButtonAutoSize(sz);
       break;
-    case XFA_ELEMENT_CheckButton:
+    case XFA_Element::CheckButton:
       CalculateCheckButtonAutoSize(sz);
       break;
-    case XFA_ELEMENT_DateTimeEdit:
-    case XFA_ELEMENT_NumericEdit:
-    case XFA_ELEMENT_PasswordEdit:
-    case XFA_ELEMENT_TextEdit:
+    case XFA_Element::DateTimeEdit:
+    case XFA_Element::NumericEdit:
+    case XFA_Element::PasswordEdit:
+    case XFA_Element::TextEdit:
       CalculateTextEditAutoSize(sz);
       break;
-    case XFA_ELEMENT_Image:
+    case XFA_Element::Image:
       CalculateImageAutoSize(sz);
       break;
-    case XFA_ELEMENT_Arc:
-    case XFA_ELEMENT_Line:
-    case XFA_ELEMENT_Rectangle:
-    case XFA_ELEMENT_Subform:
-    case XFA_ELEMENT_ExclGroup:
+    case XFA_Element::Arc:
+    case XFA_Element::Line:
+    case XFA_Element::Rectangle:
+    case XFA_Element::Subform:
+    case XFA_Element::ExclGroup:
       CalculateWidgetAutoSize(sz);
       break;
     default:
       break;
   }
   fWidth = sz.x;
   m_pLayoutData->m_fWidgetHeight = sz.y;
   fCalcHeight = sz.y;
 }
 FX_BOOL CXFA_WidgetAcc::FindSplitPos(int32_t iBlockIndex,
                                      FX_FLOAT& fCalcHeight) {
-  XFA_ELEMENT eUIType = (XFA_ELEMENT)GetUIType();
-  if (eUIType == XFA_ELEMENT_Subform) {
+  XFA_Element eUIType = GetUIType();
+  if (eUIType == XFA_Element::Subform) {
     return FALSE;
   }
-  if (eUIType != XFA_ELEMENT_Text && eUIType != XFA_ELEMENT_TextEdit &&
-      eUIType != XFA_ELEMENT_NumericEdit &&
-      eUIType != XFA_ELEMENT_PasswordEdit) {
+  if (eUIType != XFA_Element::Text && eUIType != XFA_Element::TextEdit &&
+      eUIType != XFA_Element::NumericEdit &&
+      eUIType != XFA_Element::PasswordEdit) {
     fCalcHeight = 0;
     return TRUE;
   }
   FX_FLOAT fTopInset = 0;
   FX_FLOAT fBottomInset = 0;
   if (iBlockIndex == 0) {
     CXFA_Margin mgWidget = GetMargin();
     if (mgWidget) {
       mgWidget.GetTopInset(fTopInset);
       mgWidget.GetBottomInset(fBottomInset);
     }
     CFX_RectF rtUIMargin;
     GetUIMargin(rtUIMargin);
     fTopInset += rtUIMargin.top;
     fBottomInset += rtUIMargin.width;
   }
-  if (eUIType == XFA_ELEMENT_Text) {
+  if (eUIType == XFA_Element::Text) {
     FX_FLOAT fHeight = fCalcHeight;
     if (iBlockIndex == 0) {
       fCalcHeight = fCalcHeight - fTopInset;
       if (fCalcHeight < 0) {
         fCalcHeight = 0;
       }
     }
     CXFA_TextLayout* pTextLayout =
         static_cast<CXFA_TextLayoutData*>(m_pLayoutData.get())->GetTextLayout();
     pTextLayout->DoLayout(iBlockIndex, fCalcHeight, fCalcHeight,
@@ skipping 190 matching lines @@
     }
   }
   fCalcHeight = 0;
   return TRUE;
 }
 void CXFA_WidgetAcc::InitLayoutData() {
   if (m_pLayoutData) {
     return;
   }
   switch (GetUIType()) {
-    case XFA_ELEMENT_Text:
+    case XFA_Element::Text:
       m_pLayoutData.reset(new CXFA_TextLayoutData);
       return;
-    case XFA_ELEMENT_TextEdit:
+    case XFA_Element::TextEdit:
       m_pLayoutData.reset(new CXFA_TextEditData);
       return;
-    case XFA_ELEMENT_Image:
+    case XFA_Element::Image:
       m_pLayoutData.reset(new CXFA_ImageLayoutData);
       return;
-    case XFA_ELEMENT_ImageEdit:
+    case XFA_Element::ImageEdit:
       m_pLayoutData.reset(new CXFA_ImageEditData);
       return;
     default:
       break;
   }
-  if (GetClassID() == XFA_ELEMENT_Field) {
+  if (GetClassID() == XFA_Element::Field) {
     m_pLayoutData.reset(new CXFA_FieldLayoutData);
     return;
   }
   m_pLayoutData.reset(new CXFA_WidgetLayoutData);
 }
 
 void CXFA_WidgetAcc::StartTextLayout(FX_FLOAT& fCalcWidth,
                                      FX_FLOAT& fCalcHeight) {
   LoadText();
   CXFA_TextLayout* pTextLayout =
@@ skipping 128 matching lines @@
 }
 FX_ARGB CXFA_WidgetAcc::GetTextColor() {
   if (CXFA_Font font = GetFont()) {
     return font.GetColor();
   }
   return 0xFF000000;
 }
 CXFA_Node* CXFA_TextProvider::GetTextNode(FX_BOOL& bRichText) {
   bRichText = FALSE;
   if (m_pTextNode) {
-    if (m_pTextNode->GetClassID() == XFA_ELEMENT_ExData) {
+    if (m_pTextNode->GetClassID() == XFA_Element::ExData) {
       CFX_WideString wsContentType;
       m_pTextNode->GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType,
                                 FALSE);
       if (wsContentType == FX_WSTRC(L"text/html")) {
         bRichText = TRUE;
       }
     }
     return m_pTextNode;
   }
   if (m_eType == XFA_TEXTPROVIDERTYPE_Text) {
     CXFA_Node* pElementNode = m_pWidgetAcc->GetNode();
-    CXFA_Node* pValueNode = pElementNode->GetChild(0, XFA_ELEMENT_Value);
+    CXFA_Node* pValueNode = pElementNode->GetChild(0, XFA_Element::Value);
     if (!pValueNode) {
       return NULL;
     }
     CXFA_Node* pChildNode = pValueNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-    if (pChildNode && pChildNode->GetClassID() == XFA_ELEMENT_ExData) {
+    if (pChildNode && pChildNode->GetClassID() == XFA_Element::ExData) {
       CFX_WideString wsContentType;
       pChildNode->GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, FALSE);
       if (wsContentType == FX_WSTRC(L"text/html")) {
         bRichText = TRUE;
       }
     }
     return pChildNode;
   } else if (m_eType == XFA_TEXTPROVIDERTYPE_Datasets) {
     CXFA_Node* pBind = m_pWidgetAcc->GetDatasets();
     CFDE_XMLNode* pXMLNode = pBind->GetXMLMappingNode();
     ASSERT(pXMLNode);
     for (CFDE_XMLNode* pXMLChild =
              pXMLNode->GetNodeItem(CFDE_XMLNode::FirstChild);
          pXMLChild;
          pXMLChild = pXMLChild->GetNodeItem(CFDE_XMLNode::NextSibling)) {
       if (pXMLChild->GetType() == FDE_XMLNODE_Element) {
         CFDE_XMLElement* pElement = static_cast<CFDE_XMLElement*>(pXMLChild);
         if (XFA_RecognizeRichText(pElement)) {
           bRichText = TRUE;
         }
       }
     }
     return pBind;
   } else if (m_eType == XFA_TEXTPROVIDERTYPE_Caption) {
     CXFA_Node* pCaptionNode =
-        m_pWidgetAcc->GetNode()->GetChild(0, XFA_ELEMENT_Caption);
+        m_pWidgetAcc->GetNode()->GetChild(0, XFA_Element::Caption);
     if (pCaptionNode == NULL) {
       return NULL;
     }
-    CXFA_Node* pValueNode = pCaptionNode->GetChild(0, XFA_ELEMENT_Value);
+    CXFA_Node* pValueNode = pCaptionNode->GetChild(0, XFA_Element::Value);
     if (pValueNode == NULL) {
       return NULL;
     }
     CXFA_Node* pChildNode = pValueNode->GetNodeItem(XFA_NODEITEM_FirstChild);
-    if (pChildNode && pChildNode->GetClassID() == XFA_ELEMENT_ExData) {
+    if (pChildNode && pChildNode->GetClassID() == XFA_Element::ExData) {
       CFX_WideString wsContentType;
       pChildNode->GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, FALSE);
       if (wsContentType == FX_WSTRC(L"text/html")) {
         bRichText = TRUE;
       }
     }
     return pChildNode;
   }
   CXFA_Node* pItemNode =
-      m_pWidgetAcc->GetNode()->GetChild(0, XFA_ELEMENT_Items);
+      m_pWidgetAcc->GetNode()->GetChild(0, XFA_Element::Items);
   if (pItemNode == NULL) {
     return NULL;
   }
   CXFA_Node* pNode = pItemNode->GetNodeItem(XFA_NODEITEM_FirstChild);
   while (pNode) {
     CFX_WideStringC wsName;
     pNode->TryCData(XFA_ATTRIBUTE_Name, wsName);
     if (m_eType == XFA_TEXTPROVIDERTYPE_Rollover &&
         wsName == FX_WSTRC(L"rollover")) {
       return pNode;
     }
     if (m_eType == XFA_TEXTPROVIDERTYPE_Down && wsName == FX_WSTRC(L"down")) {
       return pNode;
     }
     pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling);
   }
   return NULL;
 }
 CXFA_Para CXFA_TextProvider::GetParaNode() {
   if (m_eType == XFA_TEXTPROVIDERTYPE_Text) {
     return m_pWidgetAcc->GetPara();
   }
-  CXFA_Node* pNode = m_pWidgetAcc->GetNode()->GetChild(0, XFA_ELEMENT_Caption);
-  return CXFA_Para(pNode->GetChild(0, XFA_ELEMENT_Para));
+  CXFA_Node* pNode = m_pWidgetAcc->GetNode()->GetChild(0, XFA_Element::Caption);
+  return CXFA_Para(pNode->GetChild(0, XFA_Element::Para));
 }
 CXFA_Font CXFA_TextProvider::GetFontNode() {
   if (m_eType == XFA_TEXTPROVIDERTYPE_Text) {
     return m_pWidgetAcc->GetFont();
   }
-  CXFA_Node* pNode = m_pWidgetAcc->GetNode()->GetChild(0, XFA_ELEMENT_Caption);
-  pNode = pNode->GetChild(0, XFA_ELEMENT_Font);
+  CXFA_Node* pNode = m_pWidgetAcc->GetNode()->GetChild(0, XFA_Element::Caption);
+  pNode = pNode->GetChild(0, XFA_Element::Font);
   if (pNode) {
     return CXFA_Font(pNode);
   }
   return m_pWidgetAcc->GetFont();
 }
 FX_BOOL CXFA_TextProvider::IsCheckButtonAndAutoWidth() {
-  XFA_ELEMENT eType = m_pWidgetAcc->GetUIType();
-  if (eType == XFA_ELEMENT_CheckButton) {
+  XFA_Element eType = m_pWidgetAcc->GetUIType();
+  if (eType == XFA_Element::CheckButton) {
     FX_FLOAT fWidth = 0;
     return !m_pWidgetAcc->GetWidth(fWidth);
   }
   return FALSE;
 }
 FX_BOOL CXFA_TextProvider::GetEmbbedObj(FX_BOOL bURI,
                                         FX_BOOL bRaw,
                                         const CFX_WideString& wsAttr,
                                         CFX_WideString& wsValue) {
   if (m_eType != XFA_TEXTPROVIDERTYPE_Text) {
@@ skipping 16 matching lines @@
     if (pIDNode) {
       pEmbAcc = static_cast<CXFA_WidgetAcc*>(pIDNode->GetWidgetData());
     }
     if (pEmbAcc) {
       pEmbAcc->GetValue(wsValue, XFA_VALUEPICTURE_Display);
       return TRUE;
     }
   }
   return FALSE;
 }