Update GetClassID to GetElementType

xfa/fxfa/parser/xfa_layout_itemlayout.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_layout_itemlayout.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 55 matching lines @@
       m_fUsedSize(0),
       m_pPageMgr(pPageMgr),
       m_bBreakPending(TRUE),
       m_fLastRowWidth(0),
       m_fLastRowY(0),
       m_fWidthLimite(0),
       m_bUseInheriated(FALSE),
       m_ePreProcessRs(XFA_ItemLayoutProcessorResult_Done),
       m_bHasAvailHeight(TRUE) {
   ASSERT(m_pFormNode && (m_pFormNode->IsContainerNode() ||
-                         m_pFormNode->GetClassID() == XFA_Element::Form));
+                         m_pFormNode->GetElementType() == XFA_Element::Form));
   m_pOldLayoutItem =
       (CXFA_ContentLayoutItem*)m_pFormNode->GetUserData(XFA_LAYOUTITEMKEY);
 }
 
 CXFA_ItemLayoutProcessor::~CXFA_ItemLayoutProcessor() {}
 
 CXFA_ContentLayoutItem* CXFA_ItemLayoutProcessor::CreateContentLayoutItem(
     CXFA_Node* pFormNode) {
   if (!pFormNode) {
     return NULL;
@@ skipping 106 matching lines @@
 }
 static XFA_ATTRIBUTEENUM XFA_ItemLayoutProcessor_GetLayout(
     CXFA_Node* pFormNode,
     FX_BOOL& bRootForceTb) {
   bRootForceTb = FALSE;
   XFA_ATTRIBUTEENUM eLayoutMode;
   if (pFormNode->TryEnum(XFA_ATTRIBUTE_Layout, eLayoutMode, FALSE)) {
     return eLayoutMode;
   }
   CXFA_Node* pParentNode = pFormNode->GetNodeItem(XFA_NODEITEM_Parent);
-  if (pParentNode && pParentNode->GetClassID() == XFA_Element::Form) {
+  if (pParentNode && pParentNode->GetElementType() == XFA_Element::Form) {
     bRootForceTb = TRUE;
     return XFA_ATTRIBUTEENUM_Tb;
   }
   return XFA_ATTRIBUTEENUM_Position;
 }
 static FX_BOOL XFA_ExistContainerKeep(CXFA_Node* pCurNode, FX_BOOL bPreFind) {
   if (pCurNode == NULL || !XFA_ItemLayoutProcessor_IsTakingSpace(pCurNode)) {
     return FALSE;
   }
   XFA_NODEITEM eItemType = XFA_NODEITEM_PrevSibling;
@@ skipping 166 matching lines @@
   }
 }
 void CXFA_ItemLayoutProcessor::SplitLayoutItem(FX_FLOAT fSplitPos) {
   ASSERT(m_pLayoutItem);
   SplitLayoutItem(m_pLayoutItem, NULL, fSplitPos);
 }
 
 CXFA_ContainerLayoutItem* CXFA_LayoutItem::GetPage() const {
   for (CXFA_LayoutItem* pCurNode = const_cast<CXFA_LayoutItem*>(this); pCurNode;
        pCurNode = pCurNode->m_pParent) {
-    if (pCurNode->m_pFormNode->GetClassID() == XFA_Element::PageArea)
+    if (pCurNode->m_pFormNode->GetElementType() == XFA_Element::PageArea)
       return static_cast<CXFA_ContainerLayoutItem*>(pCurNode);
   }
   return nullptr;
 }
 
 CXFA_Node* CXFA_LayoutItem::GetFormNode() const {
   return m_pFormNode;
 }
 
 void CXFA_LayoutItem::GetRect(CFX_RectF& rtLayout, FX_BOOL bRelative) const {
@@ skipping 10 matching lines @@
         sPos += pContent->m_sPos;
         if (CXFA_Node* pMarginNode =
                 pLayoutItem->m_pFormNode->GetFirstChildByClass(
                     XFA_Element::Margin)) {
           sPos += CFX_PointF(pMarginNode->GetMeasure(XFA_ATTRIBUTE_LeftInset)
                                  .ToUnit(XFA_UNIT_Pt),
                              pMarginNode->GetMeasure(XFA_ATTRIBUTE_TopInset)
                                  .ToUnit(XFA_UNIT_Pt));
         }
       } else {
-        if (pLayoutItem->m_pFormNode->GetClassID() ==
+        if (pLayoutItem->m_pFormNode->GetElementType() ==
             XFA_Element::ContentArea) {
           sPos +=
               CFX_PointF(pLayoutItem->m_pFormNode->GetMeasure(XFA_ATTRIBUTE_X)
                              .ToUnit(XFA_UNIT_Pt),
                          pLayoutItem->m_pFormNode->GetMeasure(XFA_ATTRIBUTE_Y)
                              .ToUnit(XFA_UNIT_Pt));
           break;
-        } else if (pLayoutItem->m_pFormNode->GetClassID() ==
+        } else if (pLayoutItem->m_pFormNode->GetElementType() ==
                    XFA_Element::PageArea) {
           break;
         }
       }
     }
   }
   rtLayout.Set(sPos.x, sPos.y, sSize.x, sSize.y);
 }
 
 CXFA_LayoutItem* CXFA_LayoutItem::GetParent() const {
@@ skipping 165 matching lines @@
     CXFA_Node*& pCurActionNode,
     XFA_ItemLayoutProcessorStages& nCurStage,
     FX_BOOL bBreakBefore) {
   FX_BOOL bFindRs = FALSE;
   for (CXFA_Node* pBreakNode = pContainerNode; pBreakNode;
        pBreakNode = pBreakNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     XFA_ATTRIBUTE eAttributeType = XFA_ATTRIBUTE_Before;
     if (!bBreakBefore) {
       eAttributeType = XFA_ATTRIBUTE_After;
     }
-    switch (pBreakNode->GetClassID()) {
+    switch (pBreakNode->GetElementType()) {
       case XFA_Element::BreakBefore: {
         if (bBreakBefore) {
           pCurActionNode = pBreakNode;
           nCurStage = XFA_ItemLayoutProcessorStages_BreakBefore;
           bFindRs = TRUE;
         }
       } break;
       case XFA_Element::BreakAfter: {
         if (!bBreakBefore) {
           pCurActionNode = pBreakNode;
@@ skipping 74 matching lines @@
     }
     case XFA_ItemLayoutProcessorStages_None: {
       pCurActionNode = XFA_LAYOUT_INVALIDNODE;
       case XFA_ItemLayoutProcessorStages_BookendLeader:
         for (CXFA_Node* pBookendNode =
                  pCurActionNode == XFA_LAYOUT_INVALIDNODE
                      ? pEntireContainer->GetNodeItem(XFA_NODEITEM_FirstChild)
                      : pCurActionNode->GetNodeItem(XFA_NODEITEM_NextSibling);
              pBookendNode; pBookendNode = pBookendNode->GetNodeItem(
                                XFA_NODEITEM_NextSibling)) {
-          switch (pBookendNode->GetClassID()) {
+          switch (pBookendNode->GetElementType()) {
             case XFA_Element::Bookend:
             case XFA_Element::Break:
               pCurActionNode = pBookendNode;
               nCurStage = XFA_ItemLayoutProcessorStages_BookendLeader;
               return;
             default:
               break;
           }
         }
     }
@@ skipping 82 matching lines @@
     }
     NoMoreChildContainer : {
       pCurActionNode = XFA_LAYOUT_INVALIDNODE;
       case XFA_ItemLayoutProcessorStages_BookendTrailer:
         for (CXFA_Node* pBookendNode =
                  pCurActionNode == XFA_LAYOUT_INVALIDNODE
                      ? pEntireContainer->GetNodeItem(XFA_NODEITEM_FirstChild)
                      : pCurActionNode->GetNodeItem(XFA_NODEITEM_NextSibling);
              pBookendNode; pBookendNode = pBookendNode->GetNodeItem(
                                XFA_NODEITEM_NextSibling)) {
-          switch (pBookendNode->GetClassID()) {
+          switch (pBookendNode->GetElementType()) {
             case XFA_Element::Bookend:
             case XFA_Element::Break:
               pCurActionNode = pBookendNode;
               nCurStage = XFA_ItemLayoutProcessorStages_BookendTrailer;
               return;
             default:
               break;
           }
         }
     }
@@ skipping 70 matching lines @@
 static inline void XFA_ItemLayoutProcessor_CalculateContainerSpecfiedSize(
     CXFA_Node* pFormNode,
     FX_FLOAT& fContainerWidth,
     FX_FLOAT& fContainerHeight,
     FX_BOOL& bContainerWidthAutoSize,
     FX_BOOL& bContainerHeightAutoSize) {
   fContainerWidth = 0;
   fContainerHeight = 0;
   bContainerWidthAutoSize = TRUE;
   bContainerHeightAutoSize = TRUE;
-  XFA_Element eClassID = pFormNode->GetClassID();
+  XFA_Element eClassID = pFormNode->GetElementType();
   CXFA_Measurement mTmpValue;
   if (bContainerWidthAutoSize && (eClassID == XFA_Element::Subform ||
                                   eClassID == XFA_Element::ExclGroup) &&
       pFormNode->TryMeasure(XFA_ATTRIBUTE_W, mTmpValue, FALSE) &&
       mTmpValue.GetValue() > XFA_LAYOUT_FLOAT_PERCISION) {
     fContainerWidth = mTmpValue.ToUnit(XFA_UNIT_Pt);
     bContainerWidthAutoSize = FALSE;
   }
   if (bContainerHeightAutoSize && (eClassID == XFA_Element::Subform ||
                                    eClassID == XFA_Element::ExclGroup) &&
@@ skipping 136 matching lines @@
   XFA_ItemLayoutProcessorStages nCurChildNodeStage =
       XFA_ItemLayoutProcessorStages_None;
   CXFA_LayoutItem* pBeforeItem = NULL;
   for (XFA_ItemLayoutProcessor_GotoNextContainerNode(
            pCurChildNode, nCurChildNodeStage, pFormNode, FALSE);
        pCurChildNode; XFA_ItemLayoutProcessor_GotoNextContainerNode(
            pCurChildNode, nCurChildNodeStage, pFormNode, FALSE)) {
     if (nCurChildNodeStage != XFA_ItemLayoutProcessorStages_Container) {
       continue;
     }
-    if (pCurChildNode->GetClassID() == XFA_Element::Variables) {
+    if (pCurChildNode->GetElementType() == XFA_Element::Variables) {
       continue;
     }
     CXFA_ItemLayoutProcessor* pProcessor =
         new CXFA_ItemLayoutProcessor(pCurChildNode, NULL);
     pProcessor->DoLayout(FALSE, XFA_LAYOUT_FLOAT_MAX);
     if (!pProcessor->HasLayoutItem()) {
       delete pProcessor;
       continue;
     }
     FX_FLOAT fWidth, fHeight;
     pProcessor->GetCurrentComponentSize(fWidth, fHeight);
     FX_FLOAT fAbsoluteX = 0, fAbsoluteY = 0;
     CalculatePositionedContainerPos(pCurChildNode, fWidth, fHeight, fAbsoluteX,
                                     fAbsoluteY);
     pProcessor->SetCurrentComponentPos(fAbsoluteX, fAbsoluteY);
     CXFA_LayoutItem* pProcessItem = pProcessor->ExtractLayoutItem();
     if (pBeforeItem == NULL) {
       pPageAreaLayoutItem->AddHeadChild(pProcessItem);
     } else {
       pPageAreaLayoutItem->InsertChild(pBeforeItem, pProcessItem);
     }
     pBeforeItem = pProcessItem;
     delete pProcessor;
   }
   pBeforeItem = NULL;
   CXFA_LayoutItem* pLayoutItem = pPageAreaLayoutItem->m_pFirstChild;
   while (pLayoutItem) {
     if (!pLayoutItem->IsContentLayoutItem() ||
-        pLayoutItem->m_pFormNode->GetClassID() != XFA_Element::Draw) {
+        pLayoutItem->m_pFormNode->GetElementType() != XFA_Element::Draw) {
       pLayoutItem = pLayoutItem->m_pNextSibling;
       continue;
     }
-    if (pLayoutItem->m_pFormNode->GetClassID() == XFA_Element::Draw) {
+    if (pLayoutItem->m_pFormNode->GetElementType() == XFA_Element::Draw) {
       CXFA_LayoutItem* pNextLayoutItem = pLayoutItem->m_pNextSibling;
       pPageAreaLayoutItem->RemoveChild(pLayoutItem);
       if (pBeforeItem == NULL) {
         pPageAreaLayoutItem->AddHeadChild(pLayoutItem);
       } else {
         pPageAreaLayoutItem->InsertChild(pBeforeItem, pLayoutItem);
       }
       pBeforeItem = pLayoutItem;
       pLayoutItem = pNextLayoutItem;
     }
@@ skipping 18 matching lines @@
   if (m_pCurChildNode == XFA_LAYOUT_INVALIDNODE) {
     XFA_ItemLayoutProcessor_GotoNextContainerNode(
         m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, FALSE);
   }
   int32_t iColIndex = 0;
   for (; m_pCurChildNode; XFA_ItemLayoutProcessor_GotoNextContainerNode(
            m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, FALSE)) {
     if (m_nCurChildNodeStage != XFA_ItemLayoutProcessorStages_Container) {
       continue;
     }
-    if (m_pCurChildNode->GetClassID() == XFA_Element::Variables) {
+    if (m_pCurChildNode->GetElementType() == XFA_Element::Variables) {
       continue;
     }
     CXFA_ItemLayoutProcessor* pProcessor =
         new CXFA_ItemLayoutProcessor(m_pCurChildNode, m_pPageMgr);
     if (pContext && pContext->m_prgSpecifiedColumnWidths) {
       int32_t iColSpan = m_pCurChildNode->GetInteger(XFA_ATTRIBUTE_ColSpan);
       if (iColSpan <=
           pContext->m_prgSpecifiedColumnWidths->GetSize() - iColIndex) {
         pContext->m_fCurColumnWidth = 0;
         pContext->m_bCurColumnWidthAvaiable = TRUE;
@@ skipping 27 matching lines @@
     }
     pProcessor->SetCurrentComponentPos(fAbsoluteX, fAbsoluteY);
     if (bContainerWidthAutoSize) {
       FX_FLOAT fChildSuppliedWidth = fAbsoluteX + fWidth;
       if (bChangeParentSize) {
         if (fContentCalculatedWidth < fChildSuppliedWidth) {
           fContentCalculatedWidth = fChildSuppliedWidth;
         }
       } else {
         if (fHiddenContentCalculatedWidth < fChildSuppliedWidth &&
-            m_pCurChildNode->GetClassID() != XFA_Element::Subform) {
+            m_pCurChildNode->GetElementType() != XFA_Element::Subform) {
           fHiddenContentCalculatedWidth = fChildSuppliedWidth;
         }
       }
     }
     if (bContainerHeightAutoSize) {
       FX_FLOAT fChildSuppliedHeight = fAbsoluteY + fHeight;
       if (bChangeParentSize) {
         if (fContentCalculatedHeight < fChildSuppliedHeight) {
           fContentCalculatedHeight = fChildSuppliedHeight;
         }
       } else {
         if (fHiddenContentCalculatedHeight < fChildSuppliedHeight &&
-            m_pCurChildNode->GetClassID() != XFA_Element::Subform) {
+            m_pCurChildNode->GetElementType() != XFA_Element::Subform) {
           fHiddenContentCalculatedHeight = fChildSuppliedHeight;
         }
       }
     }
     m_pLayoutItem->AddChild(pProcessor->ExtractLayoutItem());
     delete pProcessor;
   }
   XFA_VERSION eVersion = m_pFormNode->GetDocument()->GetCurVersionMode();
   if (fContentCalculatedWidth == 0 && eVersion < XFA_VERSION_207) {
     fContentCalculatedWidth = fHiddenContentCalculatedWidth;
   }
   if (fContentCalculatedHeight == 0 && eVersion < XFA_VERSION_207) {
     fContentCalculatedHeight = fHiddenContentCalculatedHeight;
   }
   XFA_ItemLayoutProcessor_CalculateContainerComponentSizeFromContentSize(
       m_pFormNode, bContainerWidthAutoSize, fContentCalculatedWidth,
       fContainerWidth, bContainerHeightAutoSize, fContentCalculatedHeight,
       fContainerHeight);
   SetCurrentComponentSize(fContainerWidth, fContainerHeight);
 }
 static inline void XFA_ItemLayoutProcessor_UpdateWidgetSize(
     CXFA_ContentLayoutItem* pLayoutItem,
     FX_FLOAT& fWidth,
     FX_FLOAT& fHeight) {
   CXFA_Node* pNode = pLayoutItem->m_pFormNode;
   ASSERT(pNode);
-  XFA_Element eClassID = pNode->GetClassID();
+  XFA_Element eClassID = pNode->GetElementType();
   switch (eClassID) {
     case XFA_Element::Subform:
     case XFA_Element::Area:
     case XFA_Element::ExclGroup:
     case XFA_Element::SubformSet: {
       if (fWidth < -XFA_LAYOUT_FLOAT_PERCISION) {
         fWidth = pLayoutItem->m_sSize.x;
       }
       if (fHeight < -XFA_LAYOUT_FLOAT_PERCISION) {
         fHeight = pLayoutItem->m_sSize.y;
@@ skipping 220 matching lines @@
   }
   int32_t iRowCount = 0, iColCount = 0;
   {
     CFX_ArrayTemplate<CXFA_ContentLayoutItem*> rgRowItems;
     CFX_ArrayTemplate<int32_t> rgRowItemsSpan;
     CFX_ArrayTemplate<FX_FLOAT> rgRowItemsWidth;
     for (CXFA_ContentLayoutItem* pLayoutChild =
              (CXFA_ContentLayoutItem*)m_pLayoutItem->m_pFirstChild;
          pLayoutChild;
          pLayoutChild = (CXFA_ContentLayoutItem*)pLayoutChild->m_pNextSibling) {
-      if (pLayoutChild->m_pFormNode->GetClassID() != XFA_Element::Subform) {
+      if (pLayoutChild->m_pFormNode->GetElementType() != XFA_Element::Subform) {
         continue;
       }
       if (!XFA_ItemLayoutProcessor_IsTakingSpace(pLayoutChild->m_pFormNode)) {
         continue;
       }
       XFA_ATTRIBUTEENUM eLayout =
           pLayoutChild->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Layout);
       if (eLayout != XFA_ATTRIBUTEENUM_Row &&
           eLayout != XFA_ATTRIBUTEENUM_Rl_row) {
         continue;
@@ skipping 68 matching lines @@
     }
   }
   FX_FLOAT fCurrentRowY = 0;
   for (CXFA_ContentLayoutItem* pLayoutChild =
            (CXFA_ContentLayoutItem*)m_pLayoutItem->m_pFirstChild;
        pLayoutChild;
        pLayoutChild = (CXFA_ContentLayoutItem*)pLayoutChild->m_pNextSibling) {
     if (!XFA_ItemLayoutProcessor_IsTakingSpace(pLayoutChild->m_pFormNode)) {
       continue;
     }
-    if (pLayoutChild->m_pFormNode->GetClassID() == XFA_Element::Subform) {
+    if (pLayoutChild->m_pFormNode->GetElementType() == XFA_Element::Subform) {
       XFA_ATTRIBUTEENUM eSubformLayout =
           pLayoutChild->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Layout);
       if (eSubformLayout == XFA_ATTRIBUTEENUM_Row ||
           eSubformLayout == XFA_ATTRIBUTEENUM_Rl_row) {
         XFA_ItemLayoutProcessor_RelocateTableRowCells(
             pLayoutChild, m_rgSpecifiedColumnWidths, eSubformLayout);
       }
     }
     pLayoutChild->m_sPos.y = fCurrentRowY;
     if (bContainerWidthAutoSize) {
@@ skipping 340 matching lines @@
 void CXFA_ItemLayoutProcessor::ProcessUnUseOverFlow(
     CXFA_Node* pLeaderNode,
     CXFA_Node* pTrailerNode,
     CXFA_ContentLayoutItem* pTrailerItem,
     CXFA_Node* pFormNode) {
   ProcessUnUseBinds(pLeaderNode);
   ProcessUnUseBinds(pTrailerNode);
   if (pFormNode == NULL) {
     return;
   }
-  if (pFormNode->GetClassID() == XFA_Element::Overflow ||
-      pFormNode->GetClassID() == XFA_Element::Break) {
+  if (pFormNode->GetElementType() == XFA_Element::Overflow ||
+      pFormNode->GetElementType() == XFA_Element::Break) {
     pFormNode = pFormNode->GetNodeItem(XFA_NODEITEM_Parent);
   }
   if (pLeaderNode && pFormNode) {
     pFormNode->RemoveChild(pLeaderNode);
   }
   if (pTrailerNode && pFormNode) {
     pFormNode->RemoveChild(pTrailerNode);
   }
   if (pTrailerItem) {
     XFA_ReleaseLayoutItem(pTrailerItem);
@@ skipping 538 matching lines @@
             CXFA_ContentLayoutItem* pItem = m_arrayKeepItems.GetAt(iIndex);
             m_pLayoutItem->RemoveChild(pItem);
             fContentCalculatedHeight -= pItem->m_sSize.y;
           }
           CXFA_Node *pLeaderNode = NULL, *pTrailerNode = NULL;
           FX_BOOL bCreatePage = FALSE;
           if (bUseBreakControl && m_pPageMgr &&
               m_pPageMgr->ProcessBreakBeforeOrAfter(m_pCurChildNode, TRUE,
                                                     pLeaderNode, pTrailerNode,
                                                     bCreatePage) &&
-              m_pFormNode->GetClassID() != XFA_Element::Form && bCreatePage) {
+              m_pFormNode->GetElementType() != XFA_Element::Form &&

[Lei Zhang, 2016/06/23 05:04:19]

Wow, the conditionals just keep coming.

+              bCreatePage) {
             if (JudgeLeaderOrTrailerForOccur(pLeaderNode)) {
               XFA_ItemLayoutProcessor_AddPendingNode(this, pLeaderNode, TRUE);
             }
             if (JudgeLeaderOrTrailerForOccur(pTrailerNode)) {
-              if (m_pFormNode->GetNodeItem(XFA_NODEITEM_Parent)->GetClassID() ==
-                      XFA_Element::Form &&
+              if (m_pFormNode->GetNodeItem(XFA_NODEITEM_Parent)
+                          ->GetElementType() == XFA_Element::Form &&
                   m_pLayoutItem == NULL) {
                 XFA_ItemLayoutProcessor_AddPendingNode(this, pTrailerNode,
                                                        TRUE);
               } else {
                 std::unique_ptr<CXFA_ItemLayoutProcessor> pTempProcessor(
                     new CXFA_ItemLayoutProcessor(pTrailerNode, nullptr));
                 XFA_ItemLayoutProcessor_InsertFlowedItem(
                     this, pTempProcessor.get(), bContainerWidthAutoSize,
                     bContainerHeightAutoSize, fContainerHeight, eFlowStrategy,
                     uCurHAlignState, rgCurLineLayoutItems, FALSE,
                     XFA_LAYOUT_FLOAT_MAX, XFA_LAYOUT_FLOAT_MAX, fContentCurRowY,
                     fContentWidthLimit, fContentCurRowAvailWidth,
                     fContentCurRowHeight, bAddedItemInRow, bForceEndPage,
                     pContext);
               }
             }
             XFA_ItemLayoutProcessor_GotoNextContainerNode(
                 m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, TRUE);
             bForceEndPage = TRUE;
             bIsManualBreak = TRUE;
             goto SuspendAndCreateNewRow;

[Lei Zhang, 2016/06/23 05:04:19]

Gah!

           }
         } break;
         case XFA_ItemLayoutProcessorStages_BreakAfter: {
           CXFA_Node *pLeaderNode = NULL, *pTrailerNode = NULL;
           FX_BOOL bCreatePage = FALSE;
           if (bUseBreakControl && m_pPageMgr &&
               m_pPageMgr->ProcessBreakBeforeOrAfter(m_pCurChildNode, FALSE,
                                                     pLeaderNode, pTrailerNode,
                                                     bCreatePage) &&
-              m_pFormNode->GetClassID() != XFA_Element::Form) {
+              m_pFormNode->GetElementType() != XFA_Element::Form) {
             if (JudgeLeaderOrTrailerForOccur(pTrailerNode)) {
               std::unique_ptr<CXFA_ItemLayoutProcessor> pTempProcessor(
                   new CXFA_ItemLayoutProcessor(pTrailerNode, nullptr));
               XFA_ItemLayoutProcessor_InsertFlowedItem(
                   this, pTempProcessor.get(), bContainerWidthAutoSize,
                   bContainerHeightAutoSize, fContainerHeight, eFlowStrategy,
                   uCurHAlignState, rgCurLineLayoutItems, FALSE,
                   XFA_LAYOUT_FLOAT_MAX, XFA_LAYOUT_FLOAT_MAX, fContentCurRowY,
                   fContentWidthLimit, fContentCurRowAvailWidth,
                   fContentCurRowHeight, bAddedItemInRow, bForceEndPage,
@@ skipping 82 matching lines @@
                     pContext) != XFA_ItemLayoutProcessorResult_Done) {
               goto SuspendAndCreateNewRow;
             } else {
               delete pProcessor;
               pProcessor = NULL;
             }
           }
         } break;
         case XFA_ItemLayoutProcessorStages_Container:
           ASSERT(m_pCurChildNode->IsContainerNode());
-          if (m_pCurChildNode->GetClassID() == XFA_Element::Variables) {
+          if (m_pCurChildNode->GetElementType() == XFA_Element::Variables) {
             break;
           }
           if (fContentCurRowY >= fHeightLimit + XFA_LAYOUT_FLOAT_PERCISION &&
               XFA_ItemLayoutProcessor_IsTakingSpace(m_pCurChildNode)) {
             bForceEndPage = TRUE;
             goto SuspendAndCreateNewRow;
           }
           if (m_pCurChildNode->IsContainerNode()) {
             FX_BOOL bNewRow = FALSE;
             if (m_pCurChildPreprocessor) {
@@ skipping 240 matching lines @@
   if (bContainerHeightAutoSize) {
     FX_FLOAT fChildSuppliedHeight = fContentCurRowY;
     if (fContentCalculatedHeight < fChildSuppliedHeight) {
       fContentCalculatedHeight = fChildSuppliedHeight;
     }
   }
   return TRUE;
 }
 CXFA_Node* CXFA_ItemLayoutProcessor::GetSubformSetParent(
     CXFA_Node* pSubformSet) {
-  if (pSubformSet && pSubformSet->GetClassID() == XFA_Element::SubformSet) {
+  if (pSubformSet && pSubformSet->GetElementType() == XFA_Element::SubformSet) {
     CXFA_Node* pParent = pSubformSet->GetNodeItem(XFA_NODEITEM_Parent);
     while (pParent) {
-      if (pParent->GetClassID() != XFA_Element::SubformSet) {
+      if (pParent->GetElementType() != XFA_Element::SubformSet) {
         return pParent;
       }
       pParent = pParent->GetNodeItem(XFA_NODEITEM_Parent);
     }
   }
   return pSubformSet;
 }
 void CXFA_ItemLayoutProcessor::DoLayoutField() {
   if (m_pLayoutItem)
     return;
@@ skipping 16 matching lines @@
     fWidth = fHeight;
     fHeight = fTmp;
   }
   SetCurrentComponentSize(fWidth, fHeight);
 }
 XFA_ItemLayoutProcessorResult CXFA_ItemLayoutProcessor::DoLayout(
     FX_BOOL bUseBreakControl,
     FX_FLOAT fHeightLimit,
     FX_FLOAT fRealHeight,
     CXFA_LayoutContext* pContext) {
-  XFA_Element eClassID = m_pFormNode->GetClassID();
+  XFA_Element eClassID = m_pFormNode->GetElementType();
   switch (eClassID) {
     case XFA_Element::Subform:
     case XFA_Element::Area:
     case XFA_Element::ExclGroup:
     case XFA_Element::SubformSet: {
       FX_BOOL bRootForceTb = FALSE;
       CXFA_Node* pLayoutNode = GetSubformSetParent(m_pFormNode);
       XFA_ATTRIBUTEENUM eLayoutStrategy =
           XFA_ItemLayoutProcessor_GetLayout(pLayoutNode, bRootForceTb);
       switch (eLayoutStrategy) {
@@ skipping 62 matching lines @@
   if (iMax < 0)
     return TRUE;
 
   int32_t iCount = m_PendingNodesCount[pTemplate];
   if (iCount >= iMax)
     return FALSE;
 
   m_PendingNodesCount[pTemplate] = iCount + 1;
   return TRUE;
 }