Cleanup some variable namings.

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 25 matching lines @@
 void XFA_CopyWideString(void*& pData) {
   if (pData) {
     CFX_WideString* pNewData = new CFX_WideString(*(CFX_WideString*)pData);
     pData = pNewData;
   }
 }
 
 XFA_MAPDATABLOCKCALLBACKINFO deleteWideStringCallBack = {XFA_DeleteWideString,
                                                          XFA_CopyWideString};
 
-XFA_ObjectType XFA_GetElementObjectType(XFA_Element eElement) {
-  return XFA_GetElementByID(eElement)->eObjectType;
+XFA_ObjectType XFA_GetElementObjectType(XFA_Element eType) {
+  return XFA_GetElementByID(eType)->eObjectType;
 }
 
 void XFA_DataNodeDeleteBindItem(void* pData) {
   delete static_cast<CXFA_NodeArray*>(pData);
 }
 
 XFA_MAPDATABLOCKCALLBACKINFO deleteBindItemCallBack = {
     XFA_DataNodeDeleteBindItem, nullptr};
 
 }  // namespace
@@ skipping 43 matching lines @@
   wsMessage.FormatV(wsFormat.c_str(), arg_ptr);
   va_end(arg_ptr);
   FXJSE_ThrowMessage(
       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), eElement),
+CXFA_Node::CXFA_Node(CXFA_Document* pDoc, uint16_t ePacket, XFA_Element eType)
+    : CXFA_Object(pDoc, XFA_GetElementObjectType(eType), eType),
       m_pNext(nullptr),
       m_pChild(nullptr),
       m_pLastChild(nullptr),
       m_pParent(nullptr),
       m_pXMLNode(nullptr),
       m_ePacket(ePacket),
       m_uNodeFlags(XFA_NodeFlag_None),
       m_dwNameHash(0),
       m_pAuxNode(nullptr),
       m_pMapModuleData(nullptr) {
@@ skipping 108 matching lines @@
       }
       break;
     default:
       break;
   }
   return pNode;
 }
 
 int32_t CXFA_Node::GetNodeList(CXFA_NodeArray& nodes,
                                uint32_t dwTypeFilter,
-                               XFA_Element eElementFilter,
+                               XFA_Element eTypeFilter,
                                int32_t iLevel) {
   if (--iLevel < 0) {
     return nodes.GetSize();
   }
-  if (eElementFilter != XFA_Element::Unknown) {
+  if (eTypeFilter != XFA_Element::Unknown) {
     CXFA_Node* pChild = m_pChild;
     while (pChild) {
-      if (pChild->GetElementType() == eElementFilter) {
+      if (pChild->GetElementType() == eTypeFilter) {
         nodes.Add(pChild);
         if (iLevel > 0) {
-          GetNodeList(nodes, dwTypeFilter, eElementFilter, iLevel);
+          GetNodeList(nodes, dwTypeFilter, eTypeFilter, 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);
+        GetNodeList(nodes, dwTypeFilter, eTypeFilter, 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) {
@@ skipping 33 matching lines @@
           pNewNode->SetFlag(XFA_NodeFlag_Initialized, true);
           nodes.Add(pNewNode);
           break;
         }
       }
     }
   }
   return nodes.GetSize();
 }
 
-CXFA_Node* CXFA_Node::CreateSamePacketNode(XFA_Element eElement,
+CXFA_Node* CXFA_Node::CreateSamePacketNode(XFA_Element eType,
                                            uint32_t dwFlags) {
   CXFA_Document* pFactory = m_pDocument->GetParser()->GetFactory();
-  CXFA_Node* pNode = pFactory->CreateNode(m_ePacket, eElement);
+  CXFA_Node* pNode = pFactory->CreateNode(m_ePacket, eType);
   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_elementType);
   if (!pClone)
     return nullptr;
@@ skipping 99 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 = GetElementType();
-  if (classID == XFA_Element::ExclGroup)
+  XFA_Element eType = GetElementType();
+  if (eType == XFA_Element::ExclGroup)
     return nullptr;
   CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
   if (pParentNode && pParentNode->GetElementType() == XFA_Element::ExclGroup)
     return nullptr;
 
-  if (classID == XFA_Element::Field) {
+  if (eType == XFA_Element::Field) {
     CXFA_WidgetData* pFieldWidgetData = GetWidgetData();
     if (pFieldWidgetData &&
         pFieldWidgetData->GetChoiceListOpen() ==
             XFA_ATTRIBUTEENUM_MultiSelect) {
       return nullptr;
     } else {
       CFX_WideString wsPicture;
       if (pFieldWidgetData) {
         pFieldWidgetData->GetPictureContent(wsPicture,
                                             XFA_VALUEPICTURE_DataBind);
@@ skipping 64 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 = 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 11 matching lines @@
           if (pNode && pNode->TryEnum(XFA_ATTRIBUTE_Next, eValue, FALSE) &&
               (eValue == XFA_ATTRIBUTEENUM_ContentArea ||
                eValue == XFA_ATTRIBUTEENUM_PageArea)) {
             return XFA_ATTRIBUTEENUM_ContentArea;
           }
         }
       }
       return eIntact;
     }
   }
-  switch (eElement) {
+  switch (GetElementType()) {
     case XFA_Element::Subform:
       switch (eLayoutType) {
         case XFA_ATTRIBUTEENUM_Position:
         case XFA_ATTRIBUTEENUM_Row:
           return XFA_ATTRIBUTEENUM_ContentArea;
         case XFA_ATTRIBUTEENUM_Tb:
         case XFA_ATTRIBUTEENUM_Table:
         case XFA_ATTRIBUTEENUM_Lr_tb:
         case XFA_ATTRIBUTEENUM_Rl_tb:
           return XFA_ATTRIBUTEENUM_None;
@@ skipping 702 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 = GetElementType();
-  switch (eType) {
+  switch (GetElementType()) {
     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->GetElementType() == XFA_Element::Caption) {
@@ skipping 75 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->GetElementType();
-      if (eNodeType == XFA_Element::Value) {
+      XFA_Element eType = pValueNode->GetElementType();
+      if (eType == 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,
                                   pNode->GetNodeItem(XFA_NODEITEM_Parent));
         }
       } else {
-        if (eNodeType == XFA_Element::Items) {
+        if (eType == XFA_Element::Items) {
           CXFA_Node* pNode = pValueNode->GetNodeItem(XFA_NODEITEM_Parent);
           if (pNode && pNode->IsContainerNode()) {
             pNotify->OnValueChanged(this, eAttribute, pValueNode, pNode);
           }
         }
       }
     } break;
     default:
       break;
   }
@@ skipping 180 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 = GetElementType();
-  if (classID == XFA_Element::Field) {
+  XFA_Element eType = GetElementType();
+  if (eType == XFA_Element::Field) {
     Script_Field_DefaultValue(pValue, bSetting, eAttribute);
     return;
-  } else if (classID == XFA_Element::Draw) {
+  }
+  if (eType == XFA_Element::Draw) {
     Script_Draw_DefaultValue(pValue, bSetting, eAttribute);
     return;
-  } else if (classID == XFA_Element::Boolean) {
+  }
+  if (eType == XFA_Element::Boolean) {
     Script_Boolean_Value(pValue, bSetting, eAttribute);
     return;
   }
   if (bSetting) {
     CFX_WideString wsNewValue;
     if (!(pValue && (pValue->IsNull() || pValue->IsUndefined())))
       wsNewValue = pValue->ToWideString();
 
     CFX_WideString wsFormatValue(wsNewValue);
     CXFA_WidgetData* pContainerWidgetData = nullptr;
@@ skipping 18 matching lines @@
       }
     } else if (GetPacketID() == XFA_XDPPACKET_Form) {
       pContainerWidgetData = GetContainerWidgetData();
     }
     if (pContainerWidgetData) {
       pContainerWidgetData->GetFormatDataValue(wsNewValue, wsFormatValue);
     }
     SetScriptContent(wsNewValue, wsFormatValue, true, TRUE);
   } else {
     CFX_WideString content = GetScriptContent(TRUE);
-    if (content.IsEmpty() && classID != XFA_Element::Text &&
-        classID != XFA_Element::SubmitUrl) {
+    if (content.IsEmpty() && eType != XFA_Element::Text &&
+        eType != XFA_Element::SubmitUrl) {
       pValue->SetNull();
-    } else if (classID == XFA_Element::Integer) {
+    } else if (eType == XFA_Element::Integer) {
       pValue->SetInteger(FXSYS_wtoi(content.c_str()));
-    } else if (classID == XFA_Element::Float ||
-               classID == XFA_Element::Decimal) {
+    } else if (eType == XFA_Element::Float || eType == XFA_Element::Decimal) {
       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_Som_DefaultValue_Read(CFXJSE_Value* pValue,
                                              FX_BOOL bSetting,
@@ skipping 276 matching lines @@
     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->GetElementType();
       CXFA_Value defVal = pWidgetData->GetFormValue();
       CXFA_Node* pNode = defVal.GetNode()->GetNodeItem(XFA_NODEITEM_FirstChild);
       if (pNode && pNode->GetElementType() == XFA_Element::Decimal) {
-        if (eUI == XFA_Element::NumericEdit &&
+        if (pUIChild->GetElementType() == 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->GetElementType() == XFA_Element::Integer) {
         pValue->SetInteger(FXSYS_wtoi(content.c_str()));
       } else if (pNode && pNode->GetElementType() == XFA_Element::Boolean) {
@@ skipping 1629 matching lines @@
                                       FX_BOOL bSetting,
                                       XFA_ATTRIBUTE eAttribute) {}
 enum XFA_KEYTYPE {
   XFA_KEYTYPE_Custom,
   XFA_KEYTYPE_Element,
 };
 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) |
+void* XFA_GetMapKey_Element(XFA_Element eType, XFA_ATTRIBUTE eAttribute) {
+  return (void*)(uintptr_t)((static_cast<int32_t>(eType) << 16) |
                             (eAttribute << 8) | XFA_KEYTYPE_Element);
 }
 FX_BOOL CXFA_Node::HasAttribute(XFA_ATTRIBUTE eAttr, FX_BOOL bCanInherit) {
   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);
@@ skipping 735 matching lines @@
     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 = GetElementType();
+  XFA_Element eType = GetElementType();
   uint32_t dwPacket = GetPacketID();
   const XFA_PROPERTY* pProperty =
-      XFA_GetPropertyOfElement(eElement, eProperty, dwPacket);
+      XFA_GetPropertyOfElement(eType, 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->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->GetElementType(), dwPacket);
+          XFA_GetPropertyOfElement(eType, 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) {
+int32_t CXFA_Node::CountChildren(XFA_Element eType, FX_BOOL bOnlyChild) {
   CXFA_Node* pNode = m_pChild;
   int32_t iCount = 0;
   for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetElementType() == eElement ||
-        eElement == XFA_Element::Unknown) {
+    if (pNode->GetElementType() == eType || eType == XFA_Element::Unknown) {
       if (bOnlyChild) {
         const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement(
             GetElementType(), pNode->GetElementType(), XFA_XDPPACKET_UNKNOWN);
         if (pProperty) {
           continue;
         }
       }
       iCount++;
     }
   }
   return iCount;
 }
 CXFA_Node* CXFA_Node::GetChild(int32_t index,
-                               XFA_Element eElement,
+                               XFA_Element eType,
                                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->GetElementType() == eElement ||
-        eElement == XFA_Element::Unknown) {
+    if (pNode->GetElementType() == eType || eType == XFA_Element::Unknown) {
       if (bOnlyChild) {
         const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement(
             GetElementType(), pNode->GetElementType(), XFA_XDPPACKET_UNKNOWN);
         if (pProperty) {
           continue;
         }
       }
       iCount++;
       if (iCount > index) {
         return pNode;
@@ skipping 164 matching lines @@
 }
 CXFA_Node* CXFA_Node::GetFirstChildByName(uint32_t dwNameHash) const {
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_FirstChild); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetNameHash() == dwNameHash) {
       return pNode;
     }
   }
   return nullptr;
 }
-CXFA_Node* CXFA_Node::GetFirstChildByClass(XFA_Element eElement) const {
+CXFA_Node* CXFA_Node::GetFirstChildByClass(XFA_Element eType) const {
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_FirstChild); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetElementType() == eElement) {
+    if (pNode->GetElementType() == eType) {
       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 {
+CXFA_Node* CXFA_Node::GetNextSameClassSibling(XFA_Element eType) const {
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_NextSibling); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pNode->GetElementType() == eElement) {
+    if (pNode->GetElementType() == eType) {
       return pNode;
     }
   }
   return nullptr;
 }
 int32_t CXFA_Node::GetNodeSameNameIndex() const {
   CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext) {
     return -1;
   }
@@ skipping 89 matching lines @@
 
 void CXFA_Node::OnChanged(XFA_ATTRIBUTE eAttr,
                           bool bNotify,
                           FX_BOOL bScriptModify) {
   if (bNotify && IsInitialized()) {
     Script_Attribute_SendAttributeChangeMessage(eAttr, bScriptModify);
   }
 }
 
 int32_t CXFA_Node::execSingleEventByName(const CFX_WideStringC& wsEventName,
-                                         XFA_Element eElementType) {
+                                         XFA_Element eType) {
   int32_t iRet = XFA_EVENTERROR_NotExist;
   const XFA_ExecEventParaInfo* eventParaInfo =
       GetEventParaInfoByName(wsEventName);
   if (eventParaInfo) {
     uint32_t validFlags = eventParaInfo->m_validFlags;
     CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
     if (!pNotify) {
       return iRet;
     }
     if (validFlags == 1) {
       iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType);
     } else if (validFlags == 2) {
       iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
                                            FALSE, FALSE);
     } else if (validFlags == 3) {
-      if (eElementType == XFA_Element::Subform) {
+      if (eType == 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) {
+      if (eType == XFA_Element::ExclGroup || eType == XFA_Element::Field) {
         CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
         if (pParentNode &&
             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) {
+      if (eType == 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_elementType == XFA_Element::Signature) {
           iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
                                                FALSE, FALSE);
@@ skipping 482 matching lines @@
   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->GetElementType() == XFA_Element::Subform);
 }