Update GetClassID to GetElementType

xfa/fxfa/parser/xfa_object_imp.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/parser/xfa_object.h"
 
 #include <memory>
 
@@ skipping 38 matching lines @@
 
 void XFA_DataNodeDeleteBindItem(void* pData) {
   delete static_cast<CXFA_NodeArray*>(pData);
 }
 
 XFA_MAPDATABLOCKCALLBACKINFO deleteBindItemCallBack = {
     XFA_DataNodeDeleteBindItem, nullptr};
 
 }  // namespace
 
-CXFA_Object::CXFA_Object(CXFA_Document* pDocument, XFA_ObjectType type)
-    : m_pDocument(pDocument), m_objectType(type) {}
+CXFA_Object::CXFA_Object(CXFA_Document* pDocument,
+                         XFA_ObjectType objectType,
+                         XFA_Element elementType)
+    : m_pDocument(pDocument),
+      m_objectType(objectType),
+      m_elementType(elementType) {}
 
 CXFA_Object::~CXFA_Object() {}
 
 void CXFA_Object::GetClassName(CFX_WideStringC& wsName) const {
-  wsName = XFA_GetElementByID(GetClassID())->pName;
+  wsName = XFA_GetElementByID(GetElementType())->pName;
 }
 
 uint32_t CXFA_Object::GetClassHashCode() const {
-  return XFA_GetElementByID(GetClassID())->uHash;
+  return XFA_GetElementByID(GetElementType())->uHash;
 }
 
-XFA_Element CXFA_Object::GetClassID() const {
-  if (IsNode())
-    return AsNode()->GetClassID();
-  if (IsOrdinaryObject())
-    return AsOrdinaryObject()->GetClassID();
-  if (IsNodeList())
-    return AsNodeList()->GetClassID();
-  if (IsOrdinaryList())
-    return XFA_Element::List;
-  ASSERT(FALSE);
-  return XFA_Element::Unknown;
+XFA_Element CXFA_Object::GetElementType() const {
+  return m_elementType;
 }
 
 void CXFA_Object::Script_ObjectClass_ClassName(CFXJSE_Value* pValue,
                                                FX_BOOL bSetting,
                                                XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     CFX_WideStringC className;
     GetClassName(className);
     pValue->SetString(
         FX_UTF8Encode(className.c_str(), className.GetLength()).AsStringC());
@@ skipping 16 matching lines @@
       FX_UTF8Encode(wsMessage.c_str(), wsMessage.GetLength()).AsStringC());
 }
 
 XFA_MAPMODULEDATA::XFA_MAPMODULEDATA() {}
 
 XFA_MAPMODULEDATA::~XFA_MAPMODULEDATA() {}
 
 CXFA_Node::CXFA_Node(CXFA_Document* pDoc,
                      uint16_t ePacket,
                      XFA_Element eElement)
-    : CXFA_Object(pDoc, XFA_GetElementObjectType(eElement)),
+    : CXFA_Object(pDoc, XFA_GetElementObjectType(eElement), eElement),
       m_pNext(nullptr),
       m_pChild(nullptr),
       m_pLastChild(nullptr),
       m_pParent(nullptr),
       m_pXMLNode(nullptr),
-      m_eNodeClass(eElement),
       m_ePacket(ePacket),
       m_uNodeFlags(XFA_NodeFlag_None),
       m_dwNameHash(0),
       m_pAuxNode(nullptr),
       m_pMapModuleData(nullptr) {
   ASSERT(m_pDocument);
 }
 
 CXFA_Node::~CXFA_Node() {
   ASSERT(!m_pParent);
   RemoveMapModuleKey();
   CXFA_Node* pNode = m_pChild;
   while (pNode) {
     CXFA_Node* pNext = pNode->m_pNext;
     pNode->m_pParent = nullptr;
     delete pNode;
     pNode = pNext;
   }
   if (m_pXMLNode && IsOwnXMLNode())
     m_pXMLNode->Release();
 }
 
 CXFA_Node* CXFA_Node::Clone(FX_BOOL bRecursive) {
   CXFA_Document* pFactory = m_pDocument->GetParser()->GetFactory();
-  CXFA_Node* pClone = pFactory->CreateNode(m_ePacket, m_eNodeClass);
+  CXFA_Node* pClone = pFactory->CreateNode(m_ePacket, m_elementType);
   if (!pClone)
     return nullptr;
 
   MergeAllData(pClone);
   pClone->UpdateNameHash();
   if (IsNeedSavingXMLNode()) {
     CFDE_XMLNode* pCloneXML = nullptr;
     if (IsAttributeInXML()) {
       CFX_WideString wsName;
       GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE);
@@ skipping 86 matching lines @@
 int32_t CXFA_Node::GetNodeList(CXFA_NodeArray& nodes,
                                uint32_t dwTypeFilter,
                                XFA_Element eElementFilter,
                                int32_t iLevel) {
   if (--iLevel < 0) {
     return nodes.GetSize();
   }
   if (eElementFilter != XFA_Element::Unknown) {
     CXFA_Node* pChild = m_pChild;
     while (pChild) {
-      if (pChild->GetClassID() == eElementFilter) {
+      if (pChild->GetElementType() == eElementFilter) {
         nodes.Add(pChild);
         if (iLevel > 0) {
           GetNodeList(nodes, dwTypeFilter, eElementFilter, iLevel);
         }
       }
       pChild = pChild->m_pNext;
     }
   } else if (dwTypeFilter ==
              (XFA_NODEFILTER_Children | XFA_NODEFILTER_Properties)) {
     CXFA_Node* pChild = m_pChild;
     while (pChild) {
       nodes.Add(pChild);
       if (iLevel > 0) {
         GetNodeList(nodes, dwTypeFilter, eElementFilter, iLevel);
       }
       pChild = pChild->m_pNext;
     }
   } else if (dwTypeFilter != 0) {
     bool bFilterChildren = !!(dwTypeFilter & XFA_NODEFILTER_Children);
     bool bFilterProperties = !!(dwTypeFilter & XFA_NODEFILTER_Properties);
     bool bFilterOneOfProperties =
         !!(dwTypeFilter & XFA_NODEFILTER_OneOfProperty);
     CXFA_Node* pChild = m_pChild;
     while (pChild) {
       const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement(
-          GetClassID(), pChild->GetClassID(), XFA_XDPPACKET_UNKNOWN);
+          GetElementType(), pChild->GetElementType(), XFA_XDPPACKET_UNKNOWN);
       if (pProperty) {
         if (bFilterProperties) {
           nodes.Add(pChild);
         } else if (bFilterOneOfProperties &&
                    (pProperty->uFlags & XFA_PROPERTYFLAG_OneOf)) {
           nodes.Add(pChild);
         } else if (bFilterChildren &&
-                   (pChild->GetClassID() == XFA_Element::Variables ||
-                    pChild->GetClassID() == XFA_Element::PageSet)) {
+                   (pChild->GetElementType() == XFA_Element::Variables ||
+                    pChild->GetElementType() == XFA_Element::PageSet)) {
           nodes.Add(pChild);
         }
       } else if (bFilterChildren) {
         nodes.Add(pChild);
       }
       pChild = pChild->m_pNext;
     }
     if (bFilterOneOfProperties && nodes.GetSize() < 1) {
       int32_t iProperties = 0;
       const XFA_PROPERTY* pProperty =
-          XFA_GetElementProperties(GetClassID(), iProperties);
+          XFA_GetElementProperties(GetElementType(), iProperties);
       if (!pProperty || iProperties < 1)
         return 0;
       for (int32_t i = 0; i < iProperties; i++) {
         if (pProperty[i].uFlags & XFA_PROPERTYFLAG_DefaultOneOf) {
           CXFA_Document* pFactory = m_pDocument->GetParser()->GetFactory();
           const XFA_PACKETINFO* pPacket = XFA_GetPacketByID(GetPacketID());
           CXFA_Node* pNewNode =
               pFactory->CreateNode(pPacket, pProperty[i].eName);
           if (!pNewNode)
             break;
@@ skipping 12 matching lines @@
                                            uint32_t dwFlags) {
   CXFA_Document* pFactory = m_pDocument->GetParser()->GetFactory();
   CXFA_Node* pNode = pFactory->CreateNode(m_ePacket, eElement);
   pNode->SetFlag(dwFlags, true);
   return pNode;
 }
 
 CXFA_Node* CXFA_Node::CloneTemplateToForm(FX_BOOL bRecursive) {
   ASSERT(m_ePacket == XFA_XDPPACKET_Template);
   CXFA_Document* pFactory = m_pDocument->GetParser()->GetFactory();
-  CXFA_Node* pClone = pFactory->CreateNode(XFA_XDPPACKET_Form, m_eNodeClass);
+  CXFA_Node* pClone = pFactory->CreateNode(XFA_XDPPACKET_Form, m_elementType);
   if (!pClone)
     return nullptr;
 
   pClone->SetTemplateNode(this);
   pClone->UpdateNameHash();
   pClone->SetXMLMappingNode(GetXMLMappingNode());
   if (bRecursive) {
     for (CXFA_Node* pChild = GetNodeItem(XFA_NODEITEM_FirstChild); pChild;
          pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
       pClone->InsertChild(pChild->CloneTemplateToForm(bRecursive));
@@ skipping 91 matching lines @@
          GetObject(XFA_ATTRIBUTE_BindingNode);
 }
 
 CXFA_WidgetData* CXFA_Node::GetWidgetData() {
   return (CXFA_WidgetData*)GetObject(XFA_ATTRIBUTE_WidgetData);
 }
 
 CXFA_WidgetData* CXFA_Node::GetContainerWidgetData() {
   if (GetPacketID() != XFA_XDPPACKET_Form)
     return nullptr;
-  XFA_Element classID = GetClassID();
+  XFA_Element classID = GetElementType();
   if (classID == XFA_Element::ExclGroup)
     return nullptr;
   CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
-  if (pParentNode && pParentNode->GetClassID() == XFA_Element::ExclGroup)
+  if (pParentNode && pParentNode->GetElementType() == XFA_Element::ExclGroup)
     return nullptr;
 
   if (classID == XFA_Element::Field) {
     CXFA_WidgetData* pFieldWidgetData = GetWidgetData();
     if (pFieldWidgetData &&
         pFieldWidgetData->GetChoiceListOpen() ==
             XFA_ATTRIBUTEENUM_MultiSelect) {
       return nullptr;
     } else {
       CFX_WideString wsPicture;
@@ skipping 21 matching lines @@
         if (!wsPicture.IsEmpty())
           break;
         pFieldWidgetData = nullptr;
       }
       return pFieldWidgetData;
     }
   }
   CXFA_Node* pGrandNode =
       pParentNode ? pParentNode->GetNodeItem(XFA_NODEITEM_Parent) : nullptr;
   CXFA_Node* pValueNode =
-      (pParentNode && pParentNode->GetClassID() == XFA_Element::Value)
+      (pParentNode && pParentNode->GetElementType() == XFA_Element::Value)
           ? pParentNode
           : nullptr;
   if (!pValueNode) {
-    pValueNode = (pGrandNode && pGrandNode->GetClassID() == XFA_Element::Value)
-                     ? pGrandNode
-                     : nullptr;
+    pValueNode =
+        (pGrandNode && pGrandNode->GetElementType() == XFA_Element::Value)
+            ? pGrandNode
+            : nullptr;
   }
   CXFA_Node* pParentOfValueNode =
       pValueNode ? pValueNode->GetNodeItem(XFA_NODEITEM_Parent) : nullptr;
   return pParentOfValueNode ? pParentOfValueNode->GetContainerWidgetData()
                             : nullptr;
 }
 
 FX_BOOL CXFA_Node::GetLocaleName(CFX_WideString& wsLocaleName) {
   CXFA_Node* pForm = GetDocument()->GetXFAObject(XFA_HASHCODE_Form)->AsNode();
   CXFA_Node* pTopSubform = pForm->GetFirstChildByClass(XFA_Element::Subform);
@@ skipping 18 matching lines @@
   }
   IFX_Locale* pLocale = GetDocument()->GetLocalMgr()->GetDefLocale();
   if (pLocale) {
     wsLocaleName = pLocale->GetName();
     return TRUE;
   }
   return FALSE;
 }
 
 XFA_ATTRIBUTEENUM CXFA_Node::GetIntact() {
-  XFA_Element eElement = GetClassID();
+  XFA_Element eElement = GetElementType();
   CXFA_Node* pKeep = GetFirstChildByClass(XFA_Element::Keep);
   XFA_ATTRIBUTEENUM eLayoutType = GetEnum(XFA_ATTRIBUTE_Layout);
   if (pKeep) {
     XFA_ATTRIBUTEENUM eIntact;
     if (pKeep->TryEnum(XFA_ATTRIBUTE_Intact, eIntact, FALSE)) {
       if (eIntact == XFA_ATTRIBUTEENUM_None &&
           eLayoutType == XFA_ATTRIBUTEENUM_Row &&
           m_pDocument->GetCurVersionMode() < XFA_VERSION_208) {
         CXFA_Node* pPreviewRow = GetNodeItem(XFA_NODEITEM_PrevSibling,
                                              XFA_ObjectType::ContainerNode);
@@ skipping 28 matching lines @@
         case XFA_ATTRIBUTEENUM_Table:
         case XFA_ATTRIBUTEENUM_Lr_tb:
         case XFA_ATTRIBUTEENUM_Rl_tb:
           return XFA_ATTRIBUTEENUM_None;
         default:
           break;
       }
       break;
     case XFA_Element::Field: {
       CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
-      if (!pParentNode || pParentNode->GetClassID() == XFA_Element::PageArea)
+      if (!pParentNode ||
+          pParentNode->GetElementType() == XFA_Element::PageArea)
         return XFA_ATTRIBUTEENUM_ContentArea;
       if (pParentNode->GetIntact() == XFA_ATTRIBUTEENUM_None) {
         XFA_ATTRIBUTEENUM eParLayout =
             pParentNode->GetEnum(XFA_ATTRIBUTE_Layout);
         if (eParLayout == XFA_ATTRIBUTEENUM_Position ||
             eParLayout == XFA_ATTRIBUTEENUM_Row ||
             eParLayout == XFA_ATTRIBUTEENUM_Table) {
           return XFA_ATTRIBUTEENUM_None;
         }
         XFA_VERSION version = m_pDocument->GetCurVersionMode();
@@ skipping 30 matching lines @@
   if (iLength != 1) {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"resolveNode");
     return;
   }
   CFX_WideString wsExpression =
       CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext)
     return;
   CXFA_Node* refNode = this;
-  if (refNode->GetClassID() == XFA_Element::Xfa)
+  if (refNode->GetElementType() == XFA_Element::Xfa)
     refNode = ToNode(pScriptContext->GetThisObject());
   uint32_t dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes |
                     XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent |
                     XFA_RESOLVENODE_Siblings;
   XFA_RESOLVENODE_RS resoveNodeRS;
   int32_t iRet = pScriptContext->ResolveObjects(
       refNode, wsExpression.AsStringC(), resoveNodeRS, dwFlag);
   if (iRet < 1) {
     pArguments->GetReturnValue()->SetNull();
     return;
@@ skipping 25 matching lines @@
   }
   CFX_WideString wsExpression =
       CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   CFXJSE_Value* pValue = pArguments->GetReturnValue();
   if (!pValue)
     return;
   uint32_t dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes |
                     XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent |
                     XFA_RESOLVENODE_Siblings;
   CXFA_Node* refNode = this;
-  if (refNode->GetClassID() == XFA_Element::Xfa)
+  if (refNode->GetElementType() == XFA_Element::Xfa)
     refNode = ToNode(m_pDocument->GetScriptContext()->GetThisObject());
   Script_Som_ResolveNodeList(pValue, wsExpression, dwFlag, refNode);
 }
 
 void CXFA_Node::Script_Som_ResolveNodeList(CFXJSE_Value* pValue,
                                            CFX_WideString wsExpression,
                                            uint32_t dwFlag,
                                            CXFA_Node* refNode) {
   CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext)
@@ skipping 314 matching lines @@
         pNewChild->SetFlag(XFA_NodeFlag_Initialized, true);
         pNewChild = pItem;
       }
       while (pChild) {
         CXFA_Node* pItem = pChild->GetNodeItem(XFA_NODEITEM_NextSibling);
         RemoveChild(pChild);
         pFakeRoot->InsertChild(pChild);
         pChild = pItem;
       }
       if (GetPacketID() == XFA_XDPPACKET_Form &&
-          GetClassID() == XFA_Element::ExData) {
+          GetElementType() == XFA_Element::ExData) {
         CFDE_XMLNode* pTempXMLNode = GetXMLMappingNode();
         SetXMLMappingNode(pFakeXMLRoot);
         SetFlag(XFA_NodeFlag_OwnXMLNode, false);
         if (pTempXMLNode && !pTempXMLNode->GetNodeItem(CFDE_XMLNode::Parent)) {
           pFakeXMLRoot = pTempXMLNode;
         } else {
           pFakeXMLRoot = nullptr;
         }
       }
       MoveBufferMapData(pFakeRoot, this, XFA_CalcData, TRUE);
@@ skipping 138 matching lines @@
   else
     pValue->SetBoolean(IsContainerNode());
 }
 
 void CXFA_Node::Script_NodeClass_IsNull(CFXJSE_Value* pValue,
                                         FX_BOOL bSetting,
                                         XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
-    if (GetClassID() == XFA_Element::Subform) {
+    if (GetElementType() == XFA_Element::Subform) {
       pValue->SetBoolean(FALSE);
       return;
     }
     CFX_WideString strValue;
     pValue->SetBoolean(!TryContent(strValue) || strValue.IsEmpty());
   }
 }
 
 void CXFA_Node::Script_NodeClass_OneOfChild(CFXJSE_Value* pValue,
                                             FX_BOOL bSetting,
@@ skipping 93 matching lines @@
   if (!pNotify)
     return;
 
   uint32_t dwPacket = GetPacketID();
   if (!(dwPacket & XFA_XDPPACKET_Form)) {
     pNotify->OnValueChanged(this, eAttribute, this, this);
     return;
   }
 
   bool bNeedFindContainer = false;
-  XFA_Element eType = GetClassID();
+  XFA_Element eType = GetElementType();
   switch (eType) {
     case XFA_Element::Caption:
       bNeedFindContainer = true;
       pNotify->OnValueChanged(this, eAttribute, this,
                               GetNodeItem(XFA_NODEITEM_Parent));
       break;
     case XFA_Element::Font:
     case XFA_Element::Para: {
       bNeedFindContainer = true;
       CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
-      if (pParentNode->GetClassID() == XFA_Element::Caption) {
+      if (pParentNode->GetElementType() == XFA_Element::Caption) {
         pNotify->OnValueChanged(this, eAttribute, pParentNode,
                                 pParentNode->GetNodeItem(XFA_NODEITEM_Parent));
       } else {
         pNotify->OnValueChanged(this, eAttribute, this, pParentNode);
       }
     } break;
     case XFA_Element::Margin: {
       bNeedFindContainer = true;
       CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
-      XFA_Element eParentType = pParentNode->GetClassID();
+      XFA_Element eParentType = pParentNode->GetElementType();
       if (pParentNode->IsContainerNode()) {
         pNotify->OnValueChanged(this, eAttribute, this, pParentNode);
       } else if (eParentType == XFA_Element::Caption) {
         pNotify->OnValueChanged(this, eAttribute, pParentNode,
                                 pParentNode->GetNodeItem(XFA_NODEITEM_Parent));
       } else {
         CXFA_Node* pNode = pParentNode->GetNodeItem(XFA_NODEITEM_Parent);
-        if (pNode && pNode->GetClassID() == XFA_Element::Ui) {
+        if (pNode && pNode->GetElementType() == XFA_Element::Ui) {
           pNotify->OnValueChanged(this, eAttribute, pNode,
                                   pNode->GetNodeItem(XFA_NODEITEM_Parent));
         }
       }
     } break;
     case XFA_Element::Comb: {
       CXFA_Node* pEditNode = GetNodeItem(XFA_NODEITEM_Parent);
-      XFA_Element eUIType = pEditNode->GetClassID();
+      XFA_Element eUIType = pEditNode->GetElementType();
       if (pEditNode && (eUIType == XFA_Element::DateTimeEdit ||
                         eUIType == XFA_Element::NumericEdit ||
                         eUIType == XFA_Element::TextEdit)) {
         CXFA_Node* pUINode = pEditNode->GetNodeItem(XFA_NODEITEM_Parent);
         if (pUINode) {
           pNotify->OnValueChanged(this, eAttribute, pUINode,
                                   pUINode->GetNodeItem(XFA_NODEITEM_Parent));
         }
       }
     } break;
@@ skipping 39 matching lines @@
     case XFA_Element::Sharpxml:
     case XFA_Element::SharpxHTML: {
       CXFA_Node* pTextNode = GetNodeItem(XFA_NODEITEM_Parent);
       if (!pTextNode) {
         return;
       }
       CXFA_Node* pValueNode = pTextNode->GetNodeItem(XFA_NODEITEM_Parent);
       if (!pValueNode) {
         return;
       }
-      XFA_Element eNodeType = pValueNode->GetClassID();
+      XFA_Element eNodeType = pValueNode->GetElementType();
       if (eNodeType == XFA_Element::Value) {
         bNeedFindContainer = true;
         CXFA_Node* pNode = pValueNode->GetNodeItem(XFA_NODEITEM_Parent);
         if (pNode && pNode->IsContainerNode()) {
           if (bScriptModify) {
             pValueNode = pNode;
           }
           pNotify->OnValueChanged(this, eAttribute, pValueNode, pNode);
         } else {
           pNotify->OnValueChanged(this, eAttribute, pNode,
@@ skipping 24 matching lines @@
     }
   }
 }
 
 void CXFA_Node::Script_Attribute_String(CFXJSE_Value* pValue,
                                         FX_BOOL bSetting,
                                         XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     CFX_WideString wsValue = pValue->ToWideString();
     SetAttribute(eAttribute, wsValue.AsStringC(), true);
-    if (eAttribute == XFA_ATTRIBUTE_Use && GetClassID() == XFA_Element::Desc) {
+    if (eAttribute == XFA_ATTRIBUTE_Use &&
+        GetElementType() == XFA_Element::Desc) {
       CXFA_Node* pTemplateNode =
           ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Template));
       CXFA_Node* pProtoRoot =
           pTemplateNode->GetFirstChildByClass(XFA_Element::Subform)
               ->GetFirstChildByClass(XFA_Element::Proto);
 
       CFX_WideString wsID;
       CFX_WideString wsSOM;
       if (!wsValue.IsEmpty()) {
         if (wsValue[0] == '#') {
@@ skipping 148 matching lines @@
     if (!pWidgetData) {
       pValue->SetInteger(0);
       return;
     }
     pValue->SetInteger(pWidgetData->CountChoiceListItems(TRUE));
   }
 }
 void CXFA_Node::Script_Som_DefaultValue(CFXJSE_Value* pValue,
                                         FX_BOOL bSetting,
                                         XFA_ATTRIBUTE eAttribute) {
-  XFA_Element classID = GetClassID();
+  XFA_Element classID = GetElementType();
   if (classID == XFA_Element::Field) {
     Script_Field_DefaultValue(pValue, bSetting, eAttribute);
     return;
   } else if (classID == XFA_Element::Draw) {
     Script_Draw_DefaultValue(pValue, bSetting, eAttribute);
     return;
   } else if (classID == XFA_Element::Boolean) {
     Script_Boolean_Value(pValue, bSetting, eAttribute);
     return;
   }
@@ skipping 308 matching lines @@
       pWidgetData->m_bIsNull = TRUE;
     } else {
       pWidgetData->m_bPreNull = pWidgetData->m_bIsNull;
       pWidgetData->m_bIsNull = FALSE;
     }
     CFX_WideString wsNewText;
     if (!(pValue && (pValue->IsNull() || pValue->IsUndefined())))
       wsNewText = pValue->ToWideString();
 
     CXFA_Node* pUIChild = pWidgetData->GetUIChild();
-    if (pUIChild->GetClassID() == XFA_Element::NumericEdit) {
+    if (pUIChild->GetElementType() == XFA_Element::NumericEdit) {
       int32_t iLeadDigits = 0;
       int32_t iFracDigits = 0;
       pWidgetData->GetLeadDigits(iLeadDigits);
       pWidgetData->GetFracDigits(iFracDigits);
       wsNewText =
           pWidgetData->NumericLimit(wsNewText, iLeadDigits, iFracDigits);
     }
     CXFA_WidgetData* pContainerWidgetData = GetContainerWidgetData();
     CFX_WideString wsFormatText(wsNewText);
     if (pContainerWidgetData) {
       pContainerWidgetData->GetFormatDataValue(wsNewText, wsFormatText);
     }
     SetScriptContent(wsNewText, wsFormatText, true, TRUE);
   } else {
     CFX_WideString content = GetScriptContent(TRUE);
     if (content.IsEmpty()) {
       pValue->SetNull();
     } else {
       CXFA_Node* pUIChild = pWidgetData->GetUIChild();
-      XFA_Element eUI = pUIChild->GetClassID();
+      XFA_Element eUI = pUIChild->GetElementType();
       CXFA_Value defVal = pWidgetData->GetFormValue();
       CXFA_Node* pNode = defVal.GetNode()->GetNodeItem(XFA_NODEITEM_FirstChild);
-      if (pNode && pNode->GetClassID() == XFA_Element::Decimal) {
+      if (pNode && pNode->GetElementType() == XFA_Element::Decimal) {
         if (eUI == XFA_Element::NumericEdit &&
             (pNode->GetInteger(XFA_ATTRIBUTE_FracDigits) == -1)) {
           pValue->SetString(
               FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC());
         } else {
           CFX_Decimal decimal(content.AsStringC());
           pValue->SetFloat((FX_FLOAT)(double)decimal);
         }
-      } else if (pNode && pNode->GetClassID() == XFA_Element::Integer) {
+      } else if (pNode && pNode->GetElementType() == XFA_Element::Integer) {
         pValue->SetInteger(FXSYS_wtoi(content.c_str()));
-      } else if (pNode && pNode->GetClassID() == XFA_Element::Boolean) {
+      } else if (pNode && pNode->GetElementType() == XFA_Element::Boolean) {
         pValue->SetBoolean(FXSYS_wtoi(content.c_str()) == 0 ? FALSE : TRUE);
-      } else if (pNode && pNode->GetClassID() == XFA_Element::Float) {
+      } else if (pNode && pNode->GetElementType() == XFA_Element::Float) {
         CFX_Decimal decimal(content.AsStringC());
         pValue->SetFloat((FX_FLOAT)(double)decimal);
       } else {
         pValue->SetString(
             FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC());
       }
     }
   }
 }
 void CXFA_Node::Script_Field_EditValue(CFXJSE_Value* pValue,
@@ skipping 429 matching lines @@
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate");
   }
 }
 static CXFA_Node* XFA_ScriptInstanceManager_GetItem(CXFA_Node* pInstMgrNode,
                                                     int32_t iIndex) {
   ASSERT(pInstMgrNode);
   int32_t iCount = 0;
   uint32_t dwNameHash = 0;
   for (CXFA_Node* pNode = pInstMgrNode->GetNodeItem(XFA_NODEITEM_NextSibling);
        pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    XFA_Element eCurType = pNode->GetClassID();
+    XFA_Element eCurType = pNode->GetElementType();
     if (eCurType == XFA_Element::InstanceManager) {
       break;
     }
     if ((eCurType != XFA_Element::Subform) &&
         (eCurType != XFA_Element::SubformSet)) {
       continue;
     }
     if (iCount == 0) {
       CFX_WideStringC wsName = pNode->GetCData(XFA_ATTRIBUTE_Name);
       CFX_WideStringC wsInstName = pInstMgrNode->GetCData(XFA_ATTRIBUTE_Name);
@@ skipping 15 matching lines @@
 }
 void CXFA_Node::Script_Som_InstanceIndex(CFXJSE_Value* pValue,
                                          FX_BOOL bSetting,
                                          XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     int32_t iTo = pValue->ToInteger();
     int32_t iFrom = Subform_and_SubformSet_InstanceIndex();
     CXFA_Node* pManagerNode = nullptr;
     for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode;
          pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
-      if (pNode->GetClassID() == XFA_Element::InstanceManager) {
+      if (pNode->GetElementType() == XFA_Element::InstanceManager) {
         pManagerNode = pNode;
         break;
       }
     }
     if (pManagerNode) {
       pManagerNode->InstanceManager_MoveInstance(iTo, iFrom);
       CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
       if (!pNotify) {
         return;
       }
       CXFA_Node* pToInstance =
           XFA_ScriptInstanceManager_GetItem(pManagerNode, iTo);
-      if (pToInstance && pToInstance->GetClassID() == XFA_Element::Subform) {
+      if (pToInstance &&
+          pToInstance->GetElementType() == XFA_Element::Subform) {
         pNotify->RunSubformIndexChange(pToInstance);
       }
       CXFA_Node* pFromInstance =
           XFA_ScriptInstanceManager_GetItem(pManagerNode, iFrom);
       if (pFromInstance &&
-          pFromInstance->GetClassID() == XFA_Element::Subform) {
+          pFromInstance->GetElementType() == XFA_Element::Subform) {
         pNotify->RunSubformIndexChange(pFromInstance);
       }
     }
   } else {
     pValue->SetInteger(Subform_and_SubformSet_InstanceIndex());
   }
 }
 void CXFA_Node::Script_Subform_InstanceManager(CFXJSE_Value* pValue,
                                                FX_BOOL bSetting,
                                                XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     CFX_WideStringC wsName = GetCData(XFA_ATTRIBUTE_Name);
     CXFA_Node* pInstanceMgr = nullptr;
     for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode;
          pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
-      if (pNode->GetClassID() == XFA_Element::InstanceManager) {
+      if (pNode->GetElementType() == XFA_Element::InstanceManager) {
         CFX_WideStringC wsInstMgrName = pNode->GetCData(XFA_ATTRIBUTE_Name);
         if (wsInstMgrName.GetLength() >= 1 && wsInstMgrName.GetAt(0) == '_' &&
             wsInstMgrName.Mid(1) == wsName) {
           pInstanceMgr = pNode;
         }
         break;
       }
     }
     if (pInstanceMgr) {
       pValue->Assign(
@@ skipping 72 matching lines @@
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getInvalidObjects");
   }
 }
 int32_t CXFA_Node::Subform_and_SubformSet_InstanceIndex() {
   int32_t index = 0;
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
-    if ((pNode->GetClassID() == XFA_Element::Subform) ||
-        (pNode->GetClassID() == XFA_Element::SubformSet)) {
+    if ((pNode->GetElementType() == XFA_Element::Subform) ||
+        (pNode->GetElementType() == XFA_Element::SubformSet)) {
       index++;
     } else {
       break;
     }
   }
   return index;
 }
 void CXFA_Node::Script_Template_FormNodes(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
@@ skipping 132 matching lines @@
   }
   CXFA_Occur nodeOccur(GetOccurNode());
   pValue->SetInteger(nodeOccur.GetMin());
 }
 static int32_t XFA_ScriptInstanceManager_GetCount(CXFA_Node* pInstMgrNode) {
   ASSERT(pInstMgrNode);
   int32_t iCount = 0;
   uint32_t dwNameHash = 0;
   for (CXFA_Node* pNode = pInstMgrNode->GetNodeItem(XFA_NODEITEM_NextSibling);
        pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    XFA_Element eCurType = pNode->GetClassID();
+    XFA_Element eCurType = pNode->GetElementType();
     if (eCurType == XFA_Element::InstanceManager) {
       break;
     }
     if ((eCurType != XFA_Element::Subform) &&
         (eCurType != XFA_Element::SubformSet)) {
       continue;
     }
     if (iCount == 0) {
       CFX_WideStringC wsName = pNode->GetCData(XFA_ATTRIBUTE_Name);
       CFX_WideStringC wsInstName = pInstMgrNode->GetCData(XFA_ATTRIBUTE_Name);
@@ skipping 270 matching lines @@
     return;
   }
   int32_t iFrom = pArguments->GetInt32(0);
   int32_t iTo = pArguments->GetInt32(1);
   InstanceManager_MoveInstance(iTo, iFrom);
   CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
   if (!pNotify) {
     return;
   }
   CXFA_Node* pToInstance = XFA_ScriptInstanceManager_GetItem(this, iTo);
-  if (pToInstance && pToInstance->GetClassID() == XFA_Element::Subform) {
+  if (pToInstance && pToInstance->GetElementType() == XFA_Element::Subform) {
     pNotify->RunSubformIndexChange(pToInstance);
   }
   CXFA_Node* pFromInstance = XFA_ScriptInstanceManager_GetItem(this, iFrom);
-  if (pFromInstance && pFromInstance->GetClassID() == XFA_Element::Subform) {
+  if (pFromInstance &&
+      pFromInstance->GetElementType() == XFA_Element::Subform) {
     pNotify->RunSubformIndexChange(pFromInstance);
   }
 }
 void CXFA_Node::Script_InstanceManager_RemoveInstance(
     CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc != 1) {
     pArguments->GetReturnValue()->SetUndefined();
     return;
   }
   int32_t iIndex = pArguments->GetInt32(0);
   int32_t iCount = XFA_ScriptInstanceManager_GetCount(this);
   if (iIndex < 0 || iIndex >= iCount) {
     ThrowException(XFA_IDS_INDEX_OUT_OF_BOUNDS);
     return;
   }
   CXFA_Occur nodeOccur(GetOccurNode());
   int32_t iMin = nodeOccur.GetMin();
   if (iCount - 1 < iMin) {
     ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"min");
     return;
   }
   CXFA_Node* pRemoveInstance = XFA_ScriptInstanceManager_GetItem(this, iIndex);
   XFA_ScriptInstanceManager_RemoveItem(this, pRemoveInstance);
   CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
   if (pNotify) {
     for (int32_t i = iIndex; i < iCount - 1; i++) {
       CXFA_Node* pSubformInstance = XFA_ScriptInstanceManager_GetItem(this, i);
       if (pSubformInstance &&
-          pSubformInstance->GetClassID() == XFA_Element::Subform) {
+          pSubformInstance->GetElementType() == XFA_Element::Subform) {
         pNotify->RunSubformIndexChange(pSubformInstance);
       }
     }
   }
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
   if (!pLayoutPro) {
     return;
   }
   pLayoutPro->AddChangedContainer(
       ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form)));
@@ skipping 107 matching lines @@
         CFX_WideString(wsInstManagerName.IsEmpty() ? wsInstManagerName
                                                    : wsInstManagerName.Mid(1));
     uint32_t dInstanceNameHash =
         FX_HashCode_GetW(wsInstanceName.AsStringC(), false);
     CXFA_Node* pPrevSibling =
         (iDesired == 0) ? this
                         : XFA_ScriptInstanceManager_GetItem(this, iDesired - 1);
     while (iCount > iDesired) {
       CXFA_Node* pRemoveInstance =
           pPrevSibling->GetNodeItem(XFA_NODEITEM_NextSibling);
-      if (pRemoveInstance->GetClassID() != XFA_Element::Subform &&
-          pRemoveInstance->GetClassID() != XFA_Element::SubformSet) {
+      if (pRemoveInstance->GetElementType() != XFA_Element::Subform &&
+          pRemoveInstance->GetElementType() != XFA_Element::SubformSet) {
         continue;
       }
-      if (pRemoveInstance->GetClassID() == XFA_Element::InstanceManager) {
+      if (pRemoveInstance->GetElementType() == XFA_Element::InstanceManager) {
         ASSERT(FALSE);
         break;
       }
       if (pRemoveInstance->GetNameHash() == dInstanceNameHash) {
         XFA_ScriptInstanceManager_RemoveItem(this, pRemoveInstance);
         iCount--;
       }
     }
   } else if (iDesired > iCount) {
     while (iCount < iDesired) {
@@ skipping 395 matching lines @@
 };
 void* XFA_GetMapKey_Custom(const CFX_WideStringC& wsKey) {
   uint32_t dwKey = FX_HashCode_GetW(wsKey, false);
   return (void*)(uintptr_t)((dwKey << 1) | XFA_KEYTYPE_Custom);
 }
 void* XFA_GetMapKey_Element(XFA_Element eElement, XFA_ATTRIBUTE eAttribute) {
   return (void*)(uintptr_t)((static_cast<int32_t>(eElement) << 16) |
                             (eAttribute << 8) | XFA_KEYTYPE_Element);
 }
 FX_BOOL CXFA_Node::HasAttribute(XFA_ATTRIBUTE eAttr, FX_BOOL bCanInherit) {
-  void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
+  void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr);
   return HasMapModuleKey(pKey, bCanInherit);
 }
 FX_BOOL CXFA_Node::SetAttribute(XFA_ATTRIBUTE eAttr,
                                 const CFX_WideStringC& wsValue,
                                 bool bNotify) {
   const XFA_ATTRIBUTEINFO* pAttr = XFA_GetAttributeByID(eAttr);
   if (!pAttr)
     return FALSE;
 
   XFA_ATTRIBUTETYPE eType = pAttr->eType;
   if (eType == XFA_ATTRIBUTETYPE_NOTSURE) {
     const XFA_NOTSUREATTRIBUTE* pNotsure =
-        XFA_GetNotsureAttribute(GetClassID(), pAttr->eName);
+        XFA_GetNotsureAttribute(GetElementType(), pAttr->eName);
     eType = pNotsure ? pNotsure->eType : XFA_ATTRIBUTETYPE_Cdata;
   }
   switch (eType) {
     case XFA_ATTRIBUTETYPE_Enum: {
       const XFA_ATTRIBUTEENUMINFO* pEnum = XFA_GetAttributeEnumByName(wsValue);
       return SetEnum(pAttr->eName,
                      pEnum ? pEnum->eName
                            : (XFA_ATTRIBUTEENUM)(intptr_t)(pAttr->pDefValue),
                      bNotify);
     } break;
@@ skipping 16 matching lines @@
 FX_BOOL CXFA_Node::GetAttribute(XFA_ATTRIBUTE eAttr,
                                 CFX_WideString& wsValue,
                                 FX_BOOL bUseDefault) {
   const XFA_ATTRIBUTEINFO* pAttr = XFA_GetAttributeByID(eAttr);
   if (!pAttr) {
     return FALSE;
   }
   XFA_ATTRIBUTETYPE eType = pAttr->eType;
   if (eType == XFA_ATTRIBUTETYPE_NOTSURE) {
     const XFA_NOTSUREATTRIBUTE* pNotsure =
-        XFA_GetNotsureAttribute(GetClassID(), pAttr->eName);
+        XFA_GetNotsureAttribute(GetElementType(), pAttr->eName);
     eType = pNotsure ? pNotsure->eType : XFA_ATTRIBUTETYPE_Cdata;
   }
   switch (eType) {
     case XFA_ATTRIBUTETYPE_Enum: {
       XFA_ATTRIBUTEENUM eValue;
       if (!TryEnum(pAttr->eName, eValue, bUseDefault)) {
         return FALSE;
       }
       wsValue = XFA_GetAttributeEnumByID(eValue)->pName;
       return TRUE;
@@ skipping 89 matching lines @@
   void* pValue = nullptr;
   if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Enum, bUseDefault, pValue))
     return FALSE;
   eValue = (XFA_ATTRIBUTEENUM)(uintptr_t)pValue;
   return TRUE;
 }
 
 FX_BOOL CXFA_Node::SetMeasure(XFA_ATTRIBUTE eAttr,
                               CXFA_Measurement mValue,
                               bool bNotify) {
-  void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
+  void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr);
   OnChanging(eAttr, bNotify);
   SetMapModuleBuffer(pKey, &mValue, sizeof(CXFA_Measurement));
   OnChanged(eAttr, bNotify, FALSE);
   return TRUE;
 }
 
 FX_BOOL CXFA_Node::TryMeasure(XFA_ATTRIBUTE eAttr,
                               CXFA_Measurement& mValue,
                               FX_BOOL bUseDefault) const {
-  void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
+  void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr);
   void* pValue;
   int32_t iBytes;
   if (GetMapModuleBuffer(pKey, pValue, iBytes) && iBytes == sizeof(mValue)) {
     FXSYS_memcpy(&mValue, pValue, sizeof(mValue));
     return TRUE;
   }
   if (bUseDefault &&
-      XFA_GetAttributeDefaultValue(pValue, GetClassID(), eAttr,
+      XFA_GetAttributeDefaultValue(pValue, GetElementType(), eAttr,
                                    XFA_ATTRIBUTETYPE_Measure, m_ePacket)) {
     FXSYS_memcpy(&mValue, pValue, sizeof(mValue));
     return TRUE;
   }
   return FALSE;
 }
 
 CXFA_Measurement CXFA_Node::GetMeasure(XFA_ATTRIBUTE eAttr) const {
   CXFA_Measurement mValue;
   return TryMeasure(eAttr, mValue, TRUE) ? mValue : CXFA_Measurement();
 }
 
 FX_BOOL CXFA_Node::SetCData(XFA_ATTRIBUTE eAttr,
                             const CFX_WideString& wsValue,
                             bool bNotify,
                             FX_BOOL bScriptModify) {
-  void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
+  void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr);
   OnChanging(eAttr, bNotify);
   if (eAttr == XFA_ATTRIBUTE_Value) {
     CFX_WideString* pClone = new CFX_WideString(wsValue);
     SetUserData(pKey, pClone, &deleteWideStringCallBack);
   } else {
     SetMapModuleString(pKey, wsValue.AsStringC());
     if (eAttr == XFA_ATTRIBUTE_Name)
       UpdateNameHash();
   }
   OnChanged(eAttr, bNotify, bScriptModify);
 
   if (!IsNeedSavingXMLNode() || eAttr == XFA_ATTRIBUTE_QualifiedName ||
       eAttr == XFA_ATTRIBUTE_BindingNode) {
     return TRUE;
   }
 
-  if (eAttr == XFA_ATTRIBUTE_Name && (m_eNodeClass == XFA_Element::DataValue ||
-                                      m_eNodeClass == XFA_Element::DataGroup)) {
+  if (eAttr == XFA_ATTRIBUTE_Name &&
+      (m_elementType == XFA_Element::DataValue ||
+       m_elementType == XFA_Element::DataGroup)) {
     return TRUE;
   }
 
   if (eAttr == XFA_ATTRIBUTE_Value) {
     FDE_XMLNODETYPE eXMLType = m_pXMLNode->GetType();
     switch (eXMLType) {
       case FDE_XMLNODE_Element:
         if (IsAttributeInXML()) {
           static_cast<CFDE_XMLElement*>(m_pXMLNode)
               ->SetString(CFX_WideString(GetCData(XFA_ATTRIBUTE_QualifiedName)),
@@ skipping 36 matching lines @@
     }
     static_cast<CFDE_XMLElement*>(m_pXMLNode)->SetString(wsAttrName, wsValue);
   }
   return TRUE;
 }
 
 FX_BOOL CXFA_Node::SetAttributeValue(const CFX_WideString& wsValue,
                                      const CFX_WideString& wsXMLValue,
                                      bool bNotify,
                                      FX_BOOL bScriptModify) {
-  void* pKey = XFA_GetMapKey_Element(GetClassID(), XFA_ATTRIBUTE_Value);
+  void* pKey = XFA_GetMapKey_Element(GetElementType(), XFA_ATTRIBUTE_Value);
   OnChanging(XFA_ATTRIBUTE_Value, bNotify);
   CFX_WideString* pClone = new CFX_WideString(wsValue);
   SetUserData(pKey, pClone, &deleteWideStringCallBack);
   OnChanged(XFA_ATTRIBUTE_Value, bNotify, bScriptModify);
   if (IsNeedSavingXMLNode()) {
     FDE_XMLNODETYPE eXMLType = m_pXMLNode->GetType();
     switch (eXMLType) {
       case FDE_XMLNODE_Element:
         if (IsAttributeInXML()) {
           static_cast<CFDE_XMLElement*>(m_pXMLNode)
@@ skipping 25 matching lines @@
       default:
         ASSERT(0);
     }
   }
   return TRUE;
 }
 FX_BOOL CXFA_Node::TryCData(XFA_ATTRIBUTE eAttr,
                             CFX_WideString& wsValue,
                             FX_BOOL bUseDefault,
                             FX_BOOL bProto) {
-  void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
+  void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr);
   if (eAttr == XFA_ATTRIBUTE_Value) {
     CFX_WideString* pStr = (CFX_WideString*)GetUserData(pKey, bProto);
     if (pStr) {
       wsValue = *pStr;
       return TRUE;
     }
   } else {
     CFX_WideStringC wsValueC;
     if (GetMapModuleString(pKey, wsValueC)) {
       wsValue = wsValueC;
       return TRUE;
     }
   }
   if (!bUseDefault) {
     return FALSE;
   }
   void* pValue = nullptr;
-  if (XFA_GetAttributeDefaultValue(pValue, GetClassID(), eAttr,
+  if (XFA_GetAttributeDefaultValue(pValue, GetElementType(), eAttr,
                                    XFA_ATTRIBUTETYPE_Cdata, m_ePacket)) {
     wsValue = (const FX_WCHAR*)pValue;
     return TRUE;
   }
   return FALSE;
 }
 FX_BOOL CXFA_Node::TryCData(XFA_ATTRIBUTE eAttr,
                             CFX_WideStringC& wsValue,
                             FX_BOOL bUseDefault,
                             FX_BOOL bProto) {
-  void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
+  void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr);
   if (eAttr == XFA_ATTRIBUTE_Value) {
     CFX_WideString* pStr = (CFX_WideString*)GetUserData(pKey, bProto);
     if (pStr) {
       wsValue = pStr->AsStringC();
       return TRUE;
     }
   } else {
     if (GetMapModuleString(pKey, wsValue)) {
       return TRUE;
     }
   }
   if (!bUseDefault) {
     return FALSE;
   }
   void* pValue = nullptr;
-  if (XFA_GetAttributeDefaultValue(pValue, GetClassID(), eAttr,
+  if (XFA_GetAttributeDefaultValue(pValue, GetElementType(), eAttr,
                                    XFA_ATTRIBUTETYPE_Cdata, m_ePacket)) {
     wsValue = (CFX_WideStringC)(const FX_WCHAR*)pValue;
     return TRUE;
   }
   return FALSE;
 }
 FX_BOOL CXFA_Node::SetObject(XFA_ATTRIBUTE eAttr,
                              void* pData,
                              XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) {
-  void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
+  void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr);
   return SetUserData(pKey, pData, pCallbackInfo);
 }
 FX_BOOL CXFA_Node::TryObject(XFA_ATTRIBUTE eAttr, void*& pData) {
-  void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
+  void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr);
   pData = GetUserData(pKey);
   return pData != nullptr;
 }
 FX_BOOL CXFA_Node::SetValue(XFA_ATTRIBUTE eAttr,
                             XFA_ATTRIBUTETYPE eType,
                             void* pValue,
                             bool bNotify) {
-  void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
+  void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr);
   OnChanging(eAttr, bNotify);
   SetMapModuleValue(pKey, pValue);
   OnChanged(eAttr, bNotify, FALSE);
   if (IsNeedSavingXMLNode()) {
     ASSERT(m_pXMLNode->GetType() == FDE_XMLNODE_Element);
     const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttr);
     if (pInfo) {
       switch (eType) {
         case XFA_ATTRIBUTETYPE_Enum:
           static_cast<CFDE_XMLElement*>(m_pXMLNode)
@@ skipping 14 matching lines @@
           ASSERT(0);
       }
     }
   }
   return TRUE;
 }
 FX_BOOL CXFA_Node::GetValue(XFA_ATTRIBUTE eAttr,
                             XFA_ATTRIBUTETYPE eType,
                             FX_BOOL bUseDefault,
                             void*& pValue) {
-  void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
+  void* pKey = XFA_GetMapKey_Element(GetElementType(), eAttr);
   if (GetMapModuleValue(pKey, pValue)) {
     return TRUE;
   }
   if (!bUseDefault) {
     return FALSE;
   }
-  return XFA_GetAttributeDefaultValue(pValue, GetClassID(), eAttr, eType,
+  return XFA_GetAttributeDefaultValue(pValue, GetElementType(), eAttr, eType,
                                       m_ePacket);
 }
 static void XFA_DefaultFreeData(void* pData) {}
 static XFA_MAPDATABLOCKCALLBACKINFO gs_XFADefaultFreeData = {
     XFA_DefaultFreeData, nullptr};
 FX_BOOL CXFA_Node::SetUserData(void* pKey,
                                void* pData,
                                XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) {
   SetMapModuleBuffer(pKey, &pData, sizeof(void*),
                      pCallbackInfo ? pCallbackInfo : &gs_XFADefaultFreeData);
@@ skipping 83 matching lines @@
           CXFA_NodeArray nodeArray;
           pBind->GetBindItems(nodeArray);
           for (int32_t i = 0; i < nodeArray.GetSize(); i++) {
             if (nodeArray[i] != this) {
               nodeArray[i]->SetScriptContent(wsContent, wsContent, bNotify,
                                              bScriptModify, FALSE);
             }
           }
         }
         break;
-      } else if (GetClassID() == XFA_Element::ExclGroup) {
+      } else if (GetElementType() == XFA_Element::ExclGroup) {
         pNode = this;
       } else {
         CXFA_Node* pValue = GetProperty(0, XFA_Element::Value);
         CXFA_Node* pChildValue = pValue->GetNodeItem(XFA_NODEITEM_FirstChild);
         ASSERT(pChildValue);
         pChildValue->SetScriptContent(wsContent, wsContent, bNotify,
                                       bScriptModify, FALSE);
       }
       pBindNode = GetBindData();
       if (pBindNode && bSyncData) {
         pBindNode->SetScriptContent(wsContent, wsXMLValue, bNotify,
                                     bScriptModify, FALSE);
         CXFA_NodeArray nodeArray;
         pBindNode->GetBindItems(nodeArray);
         for (int32_t i = 0; i < nodeArray.GetSize(); i++) {
           if (nodeArray[i] != this) {
             nodeArray[i]->SetScriptContent(wsContent, wsContent, bNotify, true,
                                            FALSE);
           }
         }
       }
       pBindNode = nullptr;
       break;
     }
     case XFA_ObjectType::ContentNode: {
       CFX_WideString wsContentType;
-      if (GetClassID() == XFA_Element::ExData) {
+      if (GetElementType() == XFA_Element::ExData) {
         GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, FALSE);
         if (wsContentType == FX_WSTRC(L"text/html")) {
           wsContentType = FX_WSTRC(L"");
           SetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType.AsStringC());
         }
       }
       CXFA_Node* pContentRawDataNode = GetNodeItem(XFA_NODEITEM_FirstChild);
       if (!pContentRawDataNode) {
         pContentRawDataNode = CreateSamePacketNode(
             (wsContentType == FX_WSTRC(L"text/xml")) ? XFA_Element::Sharpxml
                                                      : XFA_Element::Sharptext);
         InsertChild(pContentRawDataNode);
       }
       return pContentRawDataNode->SetScriptContent(
           wsContent, wsXMLValue, bNotify, bScriptModify, bSyncData);
     } break;
     case XFA_ObjectType::NodeC:
     case XFA_ObjectType::TextNode:
       pNode = this;
       break;
     case XFA_ObjectType::NodeV:
       pNode = this;
       if (bSyncData && GetPacketID() == XFA_XDPPACKET_Form) {
         CXFA_Node* pParent = GetNodeItem(XFA_NODEITEM_Parent);
         if (pParent) {
           pParent = pParent->GetNodeItem(XFA_NODEITEM_Parent);
         }
-        if (pParent && pParent->GetClassID() == XFA_Element::Value) {
+        if (pParent && pParent->GetElementType() == XFA_Element::Value) {
           pParent = pParent->GetNodeItem(XFA_NODEITEM_Parent);
           if (pParent && pParent->IsContainerNode()) {
             pBindNode = pParent->GetBindData();
             if (pBindNode) {
               pBindNode->SetScriptContent(wsContent, wsXMLValue, bNotify,
                                           bScriptModify, FALSE);
             }
           }
         }
       }
       break;
     default:
-      if (GetClassID() == XFA_Element::DataValue) {
+      if (GetElementType() == XFA_Element::DataValue) {
         pNode = this;
         pBindNode = this;
       }
       break;
   }
   if (pNode) {
     SetAttributeValue(wsContent, wsXMLValue, bNotify, bScriptModify);
     if (pBindNode && bSyncData) {
       CXFA_NodeArray nodeArray;
       pBindNode->GetBindItems(nodeArray);
@@ skipping 20 matching lines @@
 }
 CFX_WideString CXFA_Node::GetContent() {
   return GetScriptContent();
 }
 FX_BOOL CXFA_Node::TryContent(CFX_WideString& wsContent,
                               FX_BOOL bScriptModify,
                               FX_BOOL bProto) {
   CXFA_Node* pNode = nullptr;
   switch (GetObjectType()) {
     case XFA_ObjectType::ContainerNode:
-      if (GetClassID() == XFA_Element::ExclGroup) {
+      if (GetElementType() == XFA_Element::ExclGroup) {
         pNode = this;
       } else {
         CXFA_Node* pValue = GetChild(0, XFA_Element::Value);
         if (!pValue) {
           return FALSE;
         }
         CXFA_Node* pChildValue = pValue->GetNodeItem(XFA_NODEITEM_FirstChild);
         if (pChildValue && XFA_FieldIsMultiListBox(this)) {
           pChildValue->SetAttribute(XFA_ATTRIBUTE_ContentType,
                                     FX_WSTRC(L"text/xml"));
         }
         return pChildValue
                    ? pChildValue->TryContent(wsContent, bScriptModify, bProto)
                    : FALSE;
       }
       break;
     case XFA_ObjectType::ContentNode: {
       CXFA_Node* pContentRawDataNode = GetNodeItem(XFA_NODEITEM_FirstChild);
       if (!pContentRawDataNode) {
         XFA_Element element = XFA_Element::Sharptext;
-        if (GetClassID() == XFA_Element::ExData) {
+        if (GetElementType() == XFA_Element::ExData) {
           CFX_WideString wsContentType;
           GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, FALSE);
           if (wsContentType == FX_WSTRC(L"text/html")) {
             element = XFA_Element::SharpxHTML;
           } else if (wsContentType == FX_WSTRC(L"text/xml")) {
             element = XFA_Element::Sharpxml;
           }
         }
         pContentRawDataNode = CreateSamePacketNode(element);
         InsertChild(pContentRawDataNode);
       }
       return pContentRawDataNode->TryContent(wsContent, bScriptModify, bProto);
     }
     case XFA_ObjectType::NodeC:
     case XFA_ObjectType::NodeV:
     case XFA_ObjectType::TextNode:
       pNode = this;
     default:
-      if (GetClassID() == XFA_Element::DataValue) {
+      if (GetElementType() == XFA_Element::DataValue) {
         pNode = this;
       }
       break;
   }
   if (pNode) {
     if (bScriptModify) {
       CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
       if (pScriptContext) {
         m_pDocument->GetScriptContext()->AddNodesOfRunScript(this);
       }
@@ skipping 21 matching lines @@
     case XFA_XDPPACKET_SourceSet:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_SourceSet));
     case XFA_XDPPACKET_Xdc:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Xdc));
     default:
       return this;
   }
 }
 FX_BOOL CXFA_Node::TryNamespace(CFX_WideString& wsNamespace) {
   wsNamespace.clear();
-  if (IsModelNode() || GetClassID() == XFA_Element::Packet) {
+  if (IsModelNode() || GetElementType() == XFA_Element::Packet) {
     CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (!pXMLNode || pXMLNode->GetType() != FDE_XMLNODE_Element) {
       return FALSE;
     }
     static_cast<CFDE_XMLElement*>(pXMLNode)->GetNamespaceURI(wsNamespace);
     return TRUE;
   } else if (GetPacketID() == XFA_XDPPACKET_Datasets) {
     CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (!pXMLNode) {
       return FALSE;
     }
     if (pXMLNode->GetType() != FDE_XMLNODE_Element) {
       return TRUE;
     }
-    if (GetClassID() == XFA_Element::DataValue &&
+    if (GetElementType() == XFA_Element::DataValue &&
         GetEnum(XFA_ATTRIBUTE_Contains) == XFA_ATTRIBUTEENUM_MetaData) {
       return XFA_FDEExtension_ResolveNamespaceQualifier(
           static_cast<CFDE_XMLElement*>(pXMLNode),
           GetCData(XFA_ATTRIBUTE_QualifiedName), wsNamespace);
     }
     static_cast<CFDE_XMLElement*>(pXMLNode)->GetNamespaceURI(wsNamespace);
     return TRUE;
   } else {
     CXFA_Node* pModelNode = GetModelNode();
     return pModelNode->TryNamespace(wsNamespace);
   }
 }
 CXFA_Node* CXFA_Node::GetProperty(int32_t index,
                                   XFA_Element eProperty,
                                   FX_BOOL bCreateProperty) {
-  XFA_Element eElement = GetClassID();
+  XFA_Element eElement = GetElementType();
   uint32_t dwPacket = GetPacketID();
   const XFA_PROPERTY* pProperty =
       XFA_GetPropertyOfElement(eElement, eProperty, dwPacket);
   if (!pProperty || index >= pProperty->uOccur)
     return nullptr;
 
   CXFA_Node* pNode = m_pChild;
   int32_t iCount = 0;
   for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetClassID() == eProperty) {
+    if (pNode->GetElementType() == eProperty) {
       iCount++;
       if (iCount > index) {
         return pNode;
       }
     }
   }
   if (!bCreateProperty)
     return nullptr;
 
   if (pProperty->uFlags & XFA_PROPERTYFLAG_OneOf) {
     pNode = m_pChild;
     for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
       const XFA_PROPERTY* pExistProperty =
-          XFA_GetPropertyOfElement(eElement, pNode->GetClassID(), dwPacket);
+          XFA_GetPropertyOfElement(eElement, pNode->GetElementType(), dwPacket);
       if (pExistProperty && (pExistProperty->uFlags & XFA_PROPERTYFLAG_OneOf))
         return nullptr;
     }
   }
   CXFA_Document* pFactory = m_pDocument->GetParser()->GetFactory();
   const XFA_PACKETINFO* pPacket = XFA_GetPacketByID(dwPacket);
   CXFA_Node* pNewNode = nullptr;
   for (; iCount <= index; iCount++) {
     pNewNode = pFactory->CreateNode(pPacket, eProperty);
     if (!pNewNode)
       return nullptr;
     InsertChild(pNewNode, nullptr);
     pNewNode->SetFlag(XFA_NodeFlag_Initialized, true);
   }
   return pNewNode;
 }
 int32_t CXFA_Node::CountChildren(XFA_Element eElement, FX_BOOL bOnlyChild) {
   CXFA_Node* pNode = m_pChild;
   int32_t iCount = 0;
   for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetClassID() == eElement || eElement == XFA_Element::Unknown) {
+    if (pNode->GetElementType() == eElement ||
+        eElement == XFA_Element::Unknown) {
       if (bOnlyChild) {
         const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement(
-            GetClassID(), pNode->GetClassID(), XFA_XDPPACKET_UNKNOWN);
+            GetElementType(), pNode->GetElementType(), XFA_XDPPACKET_UNKNOWN);
         if (pProperty) {
           continue;
         }
       }
       iCount++;
     }
   }
   return iCount;
 }
 CXFA_Node* CXFA_Node::GetChild(int32_t index,
                                XFA_Element eElement,
                                FX_BOOL bOnlyChild) {
   ASSERT(index > -1);
   CXFA_Node* pNode = m_pChild;
   int32_t iCount = 0;
   for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetClassID() == eElement || eElement == XFA_Element::Unknown) {
+    if (pNode->GetElementType() == eElement ||
+        eElement == XFA_Element::Unknown) {
       if (bOnlyChild) {
         const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement(
-            GetClassID(), pNode->GetClassID(), XFA_XDPPACKET_UNKNOWN);
+            GetElementType(), pNode->GetElementType(), XFA_XDPPACKET_UNKNOWN);
         if (pProperty) {
           continue;
         }
       }
       iCount++;
       if (iCount > index) {
         return pNode;
       }
     }
   }
@@ skipping 164 matching lines @@
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetNameHash() == dwNameHash) {
       return pNode;
     }
   }
   return nullptr;
 }
 CXFA_Node* CXFA_Node::GetFirstChildByClass(XFA_Element eElement) const {
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_FirstChild); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetClassID() == eElement) {
+    if (pNode->GetElementType() == eElement) {
       return pNode;
     }
   }
   return nullptr;
 }
 CXFA_Node* CXFA_Node::GetNextSameNameSibling(uint32_t dwNameHash) const {
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_NextSibling); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetNameHash() == dwNameHash) {
       return pNode;
     }
   }
   return nullptr;
 }
 CXFA_Node* CXFA_Node::GetNextSameNameSibling(
     const CFX_WideStringC& wsNodeName) const {
   return GetNextSameNameSibling(FX_HashCode_GetW(wsNodeName, false));
 }
 CXFA_Node* CXFA_Node::GetNextSameClassSibling(XFA_Element eElement) const {
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_NextSibling); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetClassID() == eElement) {
+    if (pNode->GetElementType() == eElement) {
       return pNode;
     }
   }
   return nullptr;
 }
 int32_t CXFA_Node::GetNodeSameNameIndex() const {
   CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext) {
     return -1;
   }
@@ skipping 10 matching lines @@
   CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext) {
     return;
   }
   pScriptContext->GetSomExpression(this, wsSOMExpression);
 }
 CXFA_Node* CXFA_Node::GetInstanceMgrOfSubform() {
   CXFA_Node* pInstanceMgr = nullptr;
   if (m_ePacket == XFA_XDPPACKET_Form) {
     CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
-    if (!pParentNode || pParentNode->GetClassID() == XFA_Element::Area) {
+    if (!pParentNode || pParentNode->GetElementType() == XFA_Element::Area) {
       return pInstanceMgr;
     }
     for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode;
          pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
-      XFA_Element eType = pNode->GetClassID();
+      XFA_Element eType = pNode->GetElementType();
       if ((eType == XFA_Element::Subform || eType == XFA_Element::SubformSet) &&
           pNode->m_dwNameHash != m_dwNameHash) {
         break;
       }
       if (eType == XFA_Element::InstanceManager) {
         CFX_WideStringC wsName = GetCData(XFA_ATTRIBUTE_Name);
         CFX_WideStringC wsInstName = pNode->GetCData(XFA_ATTRIBUTE_Name);
         if (wsInstName.GetLength() > 0 && wsInstName.GetAt(0) == '_' &&
             wsInstName.Mid(1) == wsName) {
           pInstanceMgr = pNode;
@@ skipping 78 matching lines @@
     } else if (validFlags == 3) {
       if (eElementType == XFA_Element::Subform) {
         iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
                                              FALSE, FALSE);
       }
     } else if (validFlags == 4) {
       if (eElementType == XFA_Element::ExclGroup ||
           eElementType == XFA_Element::Field) {
         CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
         if (pParentNode &&
-            pParentNode->GetClassID() == XFA_Element::ExclGroup) {
+            pParentNode->GetElementType() == XFA_Element::ExclGroup) {
           iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
                                                FALSE, FALSE);
         }
         iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
                                              FALSE, FALSE);
       }
     } else if (validFlags == 5) {
       if (eElementType == XFA_Element::Field) {
         iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
                                              FALSE, FALSE);
       }
     } else if (validFlags == 6) {
       CXFA_WidgetData* pWidgetData = GetWidgetData();
       if (pWidgetData) {
         CXFA_Node* pUINode = pWidgetData->GetUIChild();
-        if (pUINode->m_eNodeClass == XFA_Element::Signature) {
+        if (pUINode->m_elementType == XFA_Element::Signature) {
           iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
                                                FALSE, FALSE);
         }
       }
     } else if (validFlags == 7) {
       CXFA_WidgetData* pWidgetData = GetWidgetData();
       if (pWidgetData) {
         CXFA_Node* pUINode = pWidgetData->GetUIChild();
-        if ((pUINode->m_eNodeClass == XFA_Element::ChoiceList) &&
+        if ((pUINode->m_elementType == XFA_Element::ChoiceList) &&
             (!pWidgetData->IsListBox())) {
           iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
                                                FALSE, FALSE);
         }
       }
     }
   }
   return iRet;
 }
 void CXFA_Node::UpdateNameHash() {
   const XFA_NOTSUREATTRIBUTE* pNotsure =
-      XFA_GetNotsureAttribute(GetClassID(), XFA_ATTRIBUTE_Name);
+      XFA_GetNotsureAttribute(GetElementType(), XFA_ATTRIBUTE_Name);
   CFX_WideStringC wsName;
   if (!pNotsure || pNotsure->eType == XFA_ATTRIBUTETYPE_Cdata) {
     wsName = GetCData(XFA_ATTRIBUTE_Name);
     m_dwNameHash = FX_HashCode_GetW(wsName, false);
   } else if (pNotsure->eType == XFA_ATTRIBUTETYPE_Enum) {
     wsName = XFA_GetAttributeEnumByID(GetEnum(XFA_ATTRIBUTE_Name))->pName;
     m_dwNameHash = FX_HashCode_GetW(wsName, false);
   }
 }
 CFDE_XMLNode* CXFA_Node::CreateXMLMappingNode() {
   if (!m_pXMLNode) {
     CFX_WideString wsTag(GetCData(XFA_ATTRIBUTE_Name));
     m_pXMLNode = new CFDE_XMLElement(wsTag);
     SetFlag(XFA_NodeFlag_OwnXMLNode, false);
   }
   return m_pXMLNode;
 }
 FX_BOOL CXFA_Node::IsNeedSavingXMLNode() {
   return m_pXMLNode && (GetPacketID() == XFA_XDPPACKET_Datasets ||
-                        GetClassID() == XFA_Element::Xfa);
+                        GetElementType() == XFA_Element::Xfa);
 }
 
 XFA_MAPMODULEDATA* CXFA_Node::CreateMapModuleData() {
   if (!m_pMapModuleData)
     m_pMapModuleData = new XFA_MAPMODULEDATA;
   return m_pMapModuleData;
 }
 
 XFA_MAPMODULEDATA* CXFA_Node::GetMapModuleData() const {
   return m_pMapModuleData;
@@ skipping 184 matching lines @@
   }
 }
 void CXFA_Node::MoveBufferMapData(CXFA_Node* pDstModule, void* pKey) {
   if (!pDstModule) {
     return;
   }
   FX_BOOL bNeedMove = TRUE;
   if (!pKey) {
     bNeedMove = FALSE;
   }
-  if (pDstModule->GetClassID() != GetClassID()) {
+  if (pDstModule->GetElementType() != GetElementType()) {
     bNeedMove = FALSE;
   }
   XFA_MAPMODULEDATA* pSrcModuleData = nullptr;
   XFA_MAPMODULEDATA* pDstModuleData = nullptr;
   if (bNeedMove) {
     pSrcModuleData = GetMapModuleData();
     if (!pSrcModuleData) {
       bNeedMove = FALSE;
     }
     pDstModuleData = pDstModule->CreateMapModuleData();
@@ skipping 31 matching lines @@
          pSrcChild = pSrcChild->GetNodeItem(XFA_NODEITEM_NextSibling),
          pDstChild = pDstChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
       MoveBufferMapData(pSrcChild, pDstChild, pKey, TRUE);
     }
   }
   pSrcModule->MoveBufferMapData(pDstModule, pKey);
 }
 
 CXFA_OrdinaryObject::CXFA_OrdinaryObject(CXFA_Document* pDocument,
                                          XFA_Element eElement)
-    : CXFA_Object(pDocument, XFA_ObjectType::OrdinaryObject) {
-  m_eNodeClass = eElement;
-}
+    : CXFA_Object(pDocument, XFA_ObjectType::OrdinaryObject, eElement) {}
 
 CXFA_OrdinaryObject::~CXFA_OrdinaryObject() {}
 
-XFA_Element CXFA_OrdinaryObject::GetClassID() const {
-  return m_eNodeClass;
-}
-
 CXFA_ThisProxy::CXFA_ThisProxy(CXFA_Node* pThisNode, CXFA_Node* pScriptNode)
-    : CXFA_Object(pThisNode->GetDocument(), XFA_ObjectType::VariablesThis),
+    : CXFA_Object(pThisNode->GetDocument(),
+                  XFA_ObjectType::VariablesThis,
+                  XFA_Element::Unknown),
       m_pThisNode(NULL),
       m_pScriptNode(NULL) {
   m_pThisNode = pThisNode;
   m_pScriptNode = pScriptNode;
 }
 
 CXFA_ThisProxy::~CXFA_ThisProxy() {}
 
 CXFA_Node* CXFA_ThisProxy::GetThisNode() const {
   return m_pThisNode;
 }
 
 CXFA_Node* CXFA_ThisProxy::GetScriptNode() const {
   return m_pScriptNode;
 }
 
 CXFA_NodeList::CXFA_NodeList(CXFA_Document* pDocument)
-    : CXFA_Object(pDocument, XFA_ObjectType::NodeList) {
+    : CXFA_Object(pDocument, XFA_ObjectType::NodeList, XFA_Element::NodeList) {
   m_pDocument->GetScriptContext()->AddToCacheList(
       std::unique_ptr<CXFA_NodeList>(this));
 }
+
 CXFA_NodeList::~CXFA_NodeList() {}
-XFA_Element CXFA_NodeList::GetClassID() const {
-  return XFA_Element::NodeList;
-}
+
 CXFA_Node* CXFA_NodeList::NamedItem(const CFX_WideStringC& wsName) {
   uint32_t dwHashCode = FX_HashCode_GetW(wsName, false);
   int32_t iCount = GetLength();
   for (int32_t i = 0; i < iCount; i++) {
     CXFA_Node* ret = Item(i);
     if (dwHashCode == ret->GetNameHash())
       return ret;
   }
   return nullptr;
 }
@@ skipping 126 matching lines @@
   return nullptr;
 }
 CXFA_AttachNodeList::CXFA_AttachNodeList(CXFA_Document* pDocument,
                                          CXFA_Node* pAttachNode)
     : CXFA_NodeList(pDocument) {
   m_pAttachNode = pAttachNode;
 }
 int32_t CXFA_AttachNodeList::GetLength() {
   return m_pAttachNode->CountChildren(
       XFA_Element::Unknown,
-      m_pAttachNode->GetClassID() == XFA_Element::Subform);
+      m_pAttachNode->GetElementType() == XFA_Element::Subform);
 }
 FX_BOOL CXFA_AttachNodeList::Append(CXFA_Node* pNode) {
   CXFA_Node* pParent = pNode->GetNodeItem(XFA_NODEITEM_Parent);
   if (pParent) {
     pParent->RemoveChild(pNode);
   }
   return m_pAttachNode->InsertChild(pNode);
 }
 FX_BOOL CXFA_AttachNodeList::Insert(CXFA_Node* pNewNode,
                                     CXFA_Node* pBeforeNode) {
   CXFA_Node* pParent = pNewNode->GetNodeItem(XFA_NODEITEM_Parent);
   if (pParent) {
     pParent->RemoveChild(pNewNode);
   }
   return m_pAttachNode->InsertChild(pNewNode, pBeforeNode);
 }
 FX_BOOL CXFA_AttachNodeList::Remove(CXFA_Node* pNode) {
   return m_pAttachNode->RemoveChild(pNode);
 }
 CXFA_Node* CXFA_AttachNodeList::Item(int32_t iIndex) {
   return m_pAttachNode->GetChild(
       iIndex, XFA_Element::Unknown,
-      m_pAttachNode->GetClassID() == XFA_Element::Subform);
+      m_pAttachNode->GetElementType() == XFA_Element::Subform);
 }