Remove IFDE_XML* classes.

xfa/fxfa/app/xfa_textlayout.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "xfa/fxfa/app/xfa_textlayout.h"
 
 #include <algorithm>
 
 #include "core/fxcrt/include/fx_ext.h"
 #include "xfa/fde/fde_pen.h"
+#include "xfa/fde/xml/fde_xml_imp.h"
 #include "xfa/fgas/crt/fgas_algorithm.h"
 #include "xfa/fgas/crt/fgas_codepage.h"
 #include "xfa/fxfa/app/xfa_ffapp.h"
 #include "xfa/fxfa/app/xfa_ffdoc.h"
 #include "xfa/fxfa/app/xfa_fontmgr.h"
 
 CXFA_CSSTagProvider::~CXFA_CSSTagProvider() {
   FX_POSITION pos = m_Attributes.GetStartPosition();
   while (pos) {
     CFX_WideString *pName = NULL, *pValue = NULL;
@@ skipping 34 matching lines @@
 }
 CXFA_TextParser::~CXFA_TextParser() {
   if (m_pUASheet)
     m_pUASheet->Release();
   if (m_pSelector)
     m_pSelector->Release();
   if (m_pAllocator)
     m_pAllocator->Release();
   FX_POSITION ps = m_mapXMLNodeToParseContext.GetStartPosition();
   while (ps) {
-    IFDE_XMLNode* pXMLNode;
+    CFDE_XMLNode* pXMLNode;
     CXFA_TextParseContext* pParseContext;
     m_mapXMLNodeToParseContext.GetNextAssoc(ps, pXMLNode, pParseContext);
     if (pParseContext)
       FXTARGET_DeleteWith(CXFA_TextParseContext, m_pAllocator, pParseContext);
   }
   m_mapXMLNodeToParseContext.RemoveAll();
 }
 void CXFA_TextParser::Reset() {
   FX_POSITION ps = m_mapXMLNodeToParseContext.GetStartPosition();
   while (ps) {
-    IFDE_XMLNode* pXMLNode;
+    CFDE_XMLNode* pXMLNode;
     CXFA_TextParseContext* pParseContext;
     m_mapXMLNodeToParseContext.GetNextAssoc(ps, pXMLNode, pParseContext);
     if (pParseContext)
       FXTARGET_DeleteWith(CXFA_TextParseContext, m_pAllocator, pParseContext);
   }
   m_mapXMLNodeToParseContext.RemoveAll();
   if (m_pAllocator) {
     m_pAllocator->Release();
     m_pAllocator = NULL;
   }
@@ skipping 114 matching lines @@
     IFDE_CSSBoundaryStyle* pBoundarytyle = pParentStyle->GetBoundaryStyles();
     const FDE_CSSRECT* pRect = pBoundarytyle->GetMarginWidth();
     if (pRect) {
       pBoundarytyle = pNewStyle->GetBoundaryStyles();
       pBoundarytyle->SetMarginWidth(*pRect);
     }
   }
   return pNewStyle;
 }
 IFDE_CSSComputedStyle* CXFA_TextParser::ComputeStyle(
-    IFDE_XMLNode* pXMLNode,
+    CFDE_XMLNode* pXMLNode,
     IFDE_CSSComputedStyle* pParentStyle) {
   CXFA_TextParseContext* pContext = static_cast<CXFA_TextParseContext*>(
       m_mapXMLNodeToParseContext.GetValueAt(pXMLNode));
   if (!pContext)
     return nullptr;
   pContext->m_pParentStyle = pParentStyle;
   pParentStyle->AddRef();
   CXFA_CSSTagProvider tagProvider;
   ParseTagInfo(pXMLNode, tagProvider);
   if (tagProvider.m_bContent)
     return nullptr;
   IFDE_CSSComputedStyle* pStyle = CreateStyle(pParentStyle);
   IFDE_CSSAccelerator* pCSSAccel = m_pSelector->InitAccelerator();
   pCSSAccel->OnEnterTag(&tagProvider);
   m_pSelector->ComputeStyle(&tagProvider, pContext->GetDecls(),
                             pContext->CountDecls(), pStyle);
   pCSSAccel->OnLeaveTag(&tagProvider);
   return pStyle;
 }
-void CXFA_TextParser::DoParse(IFDE_XMLNode* pXMLContainer,
+void CXFA_TextParser::DoParse(CFDE_XMLNode* pXMLContainer,
                               IXFA_TextProvider* pTextProvider) {
   if (pXMLContainer == NULL || pTextProvider == NULL || m_pAllocator) {
     return;
   }
   m_pAllocator =
       FX_CreateAllocator(FX_ALLOCTYPE_Fixed, 32, sizeof(CXFA_CSSTagProvider));
   InitCSSData(pTextProvider);
   IFDE_CSSComputedStyle* pRootStyle = CreateRootStyle(pTextProvider);
   ParseRichText(pXMLContainer, pRootStyle);
   pRootStyle->Release();
 }
-void CXFA_TextParser::ParseRichText(IFDE_XMLNode* pXMLNode,
+void CXFA_TextParser::ParseRichText(CFDE_XMLNode* pXMLNode,
                                     IFDE_CSSComputedStyle* pParentStyle) {
   if (pXMLNode == NULL) {
     return;
   }
   CXFA_CSSTagProvider tagProvider;
   ParseTagInfo(pXMLNode, tagProvider);
   if (!tagProvider.m_bTagAviliable) {
     return;
   }
   IFDE_CSSComputedStyle* pNewStyle = NULL;
@@ skipping 15 matching lines @@
                                 pNewStyle);
       pCSSAccel->OnLeaveTag(&tagProvider);
       if (iMatchedDecls > 0) {
         pTextContext->SetDecls(ppMatchDecls, iMatchedDecls);
       }
       eDisplay = pNewStyle->GetPositionStyles()->GetDisplay();
     }
     pTextContext->SetDisplay(eDisplay);
     m_mapXMLNodeToParseContext.SetAt(pXMLNode, pTextContext);
   }
-  for (IFDE_XMLNode* pXMLChild =
-           pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild);
+  for (CFDE_XMLNode* pXMLChild =
+           pXMLNode->GetNodeItem(CFDE_XMLNode::FirstChild);
        pXMLChild;
-       pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+       pXMLChild = pXMLChild->GetNodeItem(CFDE_XMLNode::NextSibling)) {
     ParseRichText(pXMLChild, pNewStyle);
   }
   if (pNewStyle)
     pNewStyle->Release();
 }
-void CXFA_TextParser::ParseTagInfo(IFDE_XMLNode* pXMLNode,
+void CXFA_TextParser::ParseTagInfo(CFDE_XMLNode* pXMLNode,
                                    CXFA_CSSTagProvider& tagProvider) {
   static const uint32_t s_XFATagName[] = {
       0x61,       0x62,       0x69,       0x70,       0x0001f714,
       0x00022a55, 0x000239bb, 0x00025881, 0x0bd37faa, 0x0bd37fb8,
       0xa73e3af2, 0xb182eaae, 0xdb8ac455,
   };
   CFX_WideString wsName;
   if (pXMLNode->GetType() == FDE_XMLNODE_Element) {
-    IFDE_XMLElement* pXMLElement = (IFDE_XMLElement*)pXMLNode;
+    CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLNode);
     pXMLElement->GetLocalTagName(wsName);
     tagProvider.SetTagNameObj(wsName);
     uint32_t dwHashCode =
         FX_HashCode_String_GetW(wsName, wsName.GetLength(), TRUE);
     static const int32_t s_iCount = sizeof(s_XFATagName) / sizeof(uint32_t);
     CFX_DSPATemplate<uint32_t> lookup;
     tagProvider.m_bTagAviliable =
         lookup.Lookup(dwHashCode, s_XFATagName, s_iCount) > -1;
     CFX_WideString wsValue;
     pXMLElement->GetString(FX_WSTRC(L"style").GetPtr(), wsValue);
@@ skipping 74 matching lines @@
     return pStyle->GetFontStyles()->GetFontSize();
 
   CXFA_Font font = pTextProvider->GetFontNode();
   if (font) {
     return font.GetFontSize();
   }
   return 10;
 }
 int32_t CXFA_TextParser::GetHorScale(IXFA_TextProvider* pTextProvider,
                                      IFDE_CSSComputedStyle* pStyle,
-                                     IFDE_XMLNode* pXMLNode) const {
+                                     CFDE_XMLNode* pXMLNode) const {
   if (pStyle) {
     CFX_WideString wsValue;
     if (pStyle->GetCustomStyle(FX_WSTRC(L"xfa-font-horizontal-scale"),
                                wsValue)) {
       return wsValue.GetInteger();
     }
     while (pXMLNode) {
       CXFA_TextParseContext* pContext = static_cast<CXFA_TextParseContext*>(
           m_mapXMLNodeToParseContext.GetValueAt(pXMLNode));
       if (pContext && pContext->m_pParentStyle &&
           pContext->m_pParentStyle->GetCustomStyle(
               FX_WSTRC(L"xfa-font-horizontal-scale"), wsValue)) {
         return wsValue.GetInteger();
       }
-      pXMLNode = pXMLNode->GetNodeItem(IFDE_XMLNode::Parent);
+      pXMLNode = pXMLNode->GetNodeItem(CFDE_XMLNode::Parent);
     }
   }
   if (CXFA_Font font = pTextProvider->GetFontNode()) {
     return static_cast<int32_t>(font.GetHorizontalScale());
   }
   return 100;
 }
 int32_t CXFA_TextParser::GetVerScale(IXFA_TextProvider* pTextProvider,
                                      IFDE_CSSComputedStyle* pStyle) const {
   if (pStyle) {
@@ skipping 88 matching lines @@
     } else {
       fLineHeight = std::min(fLineHeight, fFontSize);
     }
   } else if (fLineHeight < 0.1f) {
     fLineHeight = GetFontSize(pTextProvider, pStyle) * 1.2f;
   }
   fLineHeight *= fVerScale;
   return fLineHeight;
 }
 FX_BOOL CXFA_TextParser::GetEmbbedObj(IXFA_TextProvider* pTextProvider,
-                                      IFDE_XMLNode* pXMLNode,
+                                      CFDE_XMLNode* pXMLNode,
                                       CFX_WideString& wsValue) {
   wsValue.Empty();
   if (pXMLNode == NULL) {
     return FALSE;
   }
   FX_BOOL bRet = FALSE;
   if (pXMLNode->GetType() == FDE_XMLNODE_Element) {
-    IFDE_XMLElement* pElement = (IFDE_XMLElement*)pXMLNode;
+    CFDE_XMLElement* pElement = static_cast<CFDE_XMLElement*>(pXMLNode);
     CFX_WideString wsAttr;
     pElement->GetString(FX_WSTRC(L"xfa:embed").GetPtr(), wsAttr);
     if (wsAttr.IsEmpty()) {
       return FALSE;
     }
     if (wsAttr.GetAt(0) == L'#') {
       wsAttr.Delete(0);
     }
     CFX_WideString ws;
     pElement->GetString(FX_WSTRC(L"xfa:embedType").GetPtr(), ws);
@@ skipping 15 matching lines @@
     }
     FX_BOOL bRaw = (ws == FX_WSTRC(L"raw"));
     if (!bRaw && ws != FX_WSTRC(L"formatted")) {
       return FALSE;
     }
     bRet = pTextProvider->GetEmbbedObj(bURI, bRaw, wsAttr, wsValue);
   }
   return bRet;
 }
 CXFA_TextParseContext* CXFA_TextParser::GetParseContextFromMap(
-    IFDE_XMLNode* pXMLNode) {
+    CFDE_XMLNode* pXMLNode) {
   return (CXFA_TextParseContext*)m_mapXMLNodeToParseContext.GetValueAt(
       pXMLNode);
 }
 enum XFA_TABSTOPSSTATUS {
   XFA_TABSTOPSSTATUS_Error,
   XFA_TABSTOPSSTATUS_EOS,
   XFA_TABSTOPSSTATUS_None,
   XFA_TABSTOPSSTATUS_Alignment,
   XFA_TABSTOPSSTATUS_StartLeader,
   XFA_TABSTOPSSTATUS_Leader,
@@ skipping 132 matching lines @@
 void CXFA_TextLayout::GetTextDataNode() {
   if (m_pTextProvider == NULL) {
     return;
   }
   CXFA_Node* pNode = m_pTextProvider->GetTextNode(m_bRichText);
   if (pNode && m_bRichText) {
     m_textParser.Reset();
   }
   m_pTextDataNode = pNode;
 }
-IFDE_XMLNode* CXFA_TextLayout::GetXMLContainerNode() {
-  IFDE_XMLNode* pXMLContainer = NULL;
+CFDE_XMLNode* CXFA_TextLayout::GetXMLContainerNode() {
+  CFDE_XMLNode* pXMLContainer = NULL;
   if (m_bRichText) {
-    IFDE_XMLNode* pXMLRoot = m_pTextDataNode->GetXMLMappingNode();
+    CFDE_XMLNode* pXMLRoot = m_pTextDataNode->GetXMLMappingNode();
     if (!pXMLRoot) {
       return pXMLContainer;
     }
-    for (IFDE_XMLNode* pXMLChild =
-             pXMLRoot->GetNodeItem(IFDE_XMLNode::FirstChild);
+    for (CFDE_XMLNode* pXMLChild =
+             pXMLRoot->GetNodeItem(CFDE_XMLNode::FirstChild);
          pXMLChild;
-         pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+         pXMLChild = pXMLChild->GetNodeItem(CFDE_XMLNode::NextSibling)) {
       if (pXMLChild->GetType() == FDE_XMLNODE_Element) {
-        IFDE_XMLElement* pXMLElement = (IFDE_XMLElement*)pXMLChild;
+        CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLChild);
         CFX_WideString wsTag;
         pXMLElement->GetLocalTagName(wsTag);
         if (wsTag.Equal(FX_WSTRC(L"body")) || wsTag.Equal(FX_WSTRC(L"html"))) {
           pXMLContainer = pXMLChild;
           break;
         }
       }
     }
   }
   return pXMLContainer;
@@ skipping 58 matching lines @@
     m_pBreak->SetCharSpace(font.GetLetterSpacing());
   }
   FX_FLOAT fFontSize = m_textParser.GetFontSize(m_pTextProvider, NULL);
   m_pBreak->SetFontSize(fFontSize);
   m_pBreak->SetFont(m_textParser.GetFont(m_pTextProvider, NULL));
   m_pBreak->SetLineBreakTolerance(fFontSize * 0.2f);
 }
 void CXFA_TextLayout::InitBreak(IFDE_CSSComputedStyle* pStyle,
                                 FDE_CSSDISPLAY eDisplay,
                                 FX_FLOAT fLineWidth,
-                                IFDE_XMLNode* pXMLNode,
+                                CFDE_XMLNode* pXMLNode,
                                 IFDE_CSSComputedStyle* pParentStyle) {
   if (pStyle == NULL) {
     InitBreak(fLineWidth);
     return;
   }
   IFDE_CSSParagraphStyle* pParaStyle = pStyle->GetParagraphStyles();
   if (eDisplay == FDE_CSSDISPLAY_Block || eDisplay == FDE_CSSDISPLAY_ListItem) {
     int32_t iAlign = FX_RTFLINEALIGNMENT_Left;
     switch (pParaStyle->GetTextAlign()) {
       case FDE_CSSTEXTALIGN_Right:
@@ skipping 289 matching lines @@
     if (iCount == 0 && m_pLoader->m_fStartLineOffset < 0.1f) {
       UpdateAlign(szText.y, fLinePos);
     }
   } else if (m_pTextDataNode) {
     iBlock *= 2;
     if (iBlock < iCount - 2) {
       m_pLoader->m_iTotalLines = m_Blocks.ElementAt(iBlock + 1);
     }
     m_pBreak->Reset();
     if (m_bRichText) {
-      IFDE_XMLNode* pContainerNode = GetXMLContainerNode();
+      CFDE_XMLNode* pContainerNode = GetXMLContainerNode();
       if (!pContainerNode) {
         return TRUE;
       }
-      IFDE_XMLNode* pXMLNode = m_pLoader->m_pXMLNode;
+      CFDE_XMLNode* pXMLNode = m_pLoader->m_pXMLNode;
       if (pXMLNode == NULL) {
         return TRUE;
       }
-      IFDE_XMLNode* pSaveXMLNode = m_pLoader->m_pXMLNode;
+      CFDE_XMLNode* pSaveXMLNode = m_pLoader->m_pXMLNode;
       for (; pXMLNode;
-           pXMLNode = pXMLNode->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+           pXMLNode = pXMLNode->GetNodeItem(CFDE_XMLNode::NextSibling)) {
         FX_BOOL bFlag = LoadRichText(pXMLNode, szText, fLinePos,
                                      m_pLoader->m_pParentStyle, TRUE);
         if (!bFlag) {
           break;
         }
       }
       while (pXMLNode == NULL) {
-        pXMLNode = pSaveXMLNode->GetNodeItem(IFDE_XMLNode::Parent);
+        pXMLNode = pSaveXMLNode->GetNodeItem(CFDE_XMLNode::Parent);
         if (pXMLNode == pContainerNode) {
           break;
         }
         FX_BOOL bFlag =
             LoadRichText(pXMLNode, szText, fLinePos, m_pLoader->m_pParentStyle,
                          TRUE, NULL, FALSE);
         if (!bFlag) {
           break;
         }
         pSaveXMLNode = pXMLNode;
-        pXMLNode = pXMLNode->GetNodeItem(IFDE_XMLNode::NextSibling);
+        pXMLNode = pXMLNode->GetNodeItem(CFDE_XMLNode::NextSibling);
         if (!pXMLNode) {
           continue;
         }
         for (; pXMLNode;
-             pXMLNode = pXMLNode->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+             pXMLNode = pXMLNode->GetNodeItem(CFDE_XMLNode::NextSibling)) {
           FX_BOOL bFlag = LoadRichText(pXMLNode, szText, fLinePos,
                                        m_pLoader->m_pParentStyle, TRUE);
           if (!bFlag) {
             break;
           }
         }
       }
     } else {
       pNode = m_pLoader->m_pNode;
       if (pNode == NULL) {
@@ skipping 145 matching lines @@
                                 FX_FLOAT& fLinePos,
                                 FX_BOOL bSavePieces) {
   if (m_pAllocator == NULL) {
     m_pAllocator = FX_CreateAllocator(FX_ALLOCTYPE_Static, 256, 0);
   }
   GetTextDataNode();
   if (m_pTextDataNode == NULL) {
     return TRUE;
   }
   if (m_bRichText) {
-    IFDE_XMLNode* pXMLContainer = GetXMLContainerNode();
+    CFDE_XMLNode* pXMLContainer = GetXMLContainerNode();
     if (pXMLContainer) {
       if (!m_textParser.IsParsed()) {
         m_textParser.DoParse(pXMLContainer, m_pTextProvider);
       }
       IFDE_CSSComputedStyle* pRootStyle =
           m_textParser.CreateRootStyle(m_pTextProvider);
       LoadRichText(pXMLContainer, szText, fLinePos, pRootStyle, bSavePieces);
       pRootStyle->Release();
     }
   } else {
@@ skipping 25 matching lines @@
   }
   CFX_WideString wsText = pNode->GetContent();
   wsText.TrimRight(L" ");
   FX_BOOL bRet = AppendChar(wsText, fLinePos, fSpaceAbove, bSavePieces);
   if (bRet && m_pLoader) {
     m_pLoader->m_pNode = pNode;
   } else {
     EndBreak(FX_RTFBREAK_ParagraphBreak, fLinePos, bSavePieces);
   }
 }
-FX_BOOL CXFA_TextLayout::LoadRichText(IFDE_XMLNode* pXMLNode,
+FX_BOOL CXFA_TextLayout::LoadRichText(CFDE_XMLNode* pXMLNode,
                                       const CFX_SizeF& szText,
                                       FX_FLOAT& fLinePos,
                                       IFDE_CSSComputedStyle* pParentStyle,
                                       FX_BOOL bSavePieces,
                                       CXFA_LinkUserData* pLinkData,
                                       FX_BOOL bEndBreak,
                                       FX_BOOL bIsOl,
                                       int32_t iLiCount) {
   if (pXMLNode == NULL) {
     return FALSE;
   }
   CXFA_TextParseContext* pContext =
       m_textParser.GetParseContextFromMap(pXMLNode);
   FDE_CSSDISPLAY eDisplay = FDE_CSSDISPLAY_None;
   FX_BOOL bContentNode = FALSE;
   FX_FLOAT fSpaceBelow = 0;
   IFDE_CSSComputedStyle* pStyle = NULL;
   CFX_WideString wsName;
   if (bEndBreak) {
     FX_BOOL bCurOl = FALSE;
     FX_BOOL bCurLi = FALSE;
-    IFDE_XMLElement* pElement = NULL;
+    CFDE_XMLElement* pElement = NULL;
     if (pContext) {
       if (m_bBlockContinue ||
           (m_pLoader && pXMLNode == m_pLoader->m_pXMLNode)) {
         m_bBlockContinue = TRUE;
       }
       if (pXMLNode->GetType() == FDE_XMLNODE_Text) {
         bContentNode = TRUE;
       } else if (pXMLNode->GetType() == FDE_XMLNODE_Element) {
-        pElement = (IFDE_XMLElement*)pXMLNode;
+        pElement = static_cast<CFDE_XMLElement*>(pXMLNode);
         pElement->GetLocalTagName(wsName);
       }
       if (wsName == FX_WSTRC(L"ol")) {
         bIsOl = TRUE;
         bCurOl = TRUE;
       }
       if (m_bBlockContinue || bContentNode == FALSE) {
         eDisplay = pContext->GetDisplay();
         if (eDisplay != FDE_CSSDISPLAY_Block &&
             eDisplay != FDE_CSSDISPLAY_Inline &&
@@ skipping 26 matching lines @@
                 wsLinkContent.GetBuffer(wsLinkContent.GetLength()));
             wsLinkContent.ReleaseBuffer(wsLinkContent.GetLength());
           }
         }
         int32_t iTabCount =
             m_textParser.CountTabs(bContentNode ? pParentStyle : pStyle);
         FX_BOOL bSpaceRun =
             m_textParser.IsSpaceRun(bContentNode ? pParentStyle : pStyle);
         CFX_WideString wsText;
         if (bContentNode && iTabCount == 0) {
-          ((IFDE_XMLText*)pXMLNode)->GetText(wsText);
+          static_cast<CFDE_XMLText*>(pXMLNode)->GetText(wsText);
         } else if (wsName == FX_WSTRC(L"br")) {
           wsText = L'\n';
         } else if (wsName == FX_WSTRC(L"li")) {
           bCurLi = TRUE;
           if (bIsOl) {
             wsText.Format(L"%d.  ", iLiCount);
           } else {
             wsText = 0x00B7 + FX_WSTRC(L"  ");
           }
         } else if (!bContentNode) {
@@ skipping 48 matching lines @@
               if (pStyle)
                 pStyle->Release();
               return FALSE;
             }
             return TRUE;
           }
         }
       }
     }
     FX_BOOL ret = TRUE;
-    for (IFDE_XMLNode* pChildNode =
-             pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild);
+    for (CFDE_XMLNode* pChildNode =
+             pXMLNode->GetNodeItem(CFDE_XMLNode::FirstChild);
          pChildNode;
-         pChildNode = pChildNode->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+         pChildNode = pChildNode->GetNodeItem(CFDE_XMLNode::NextSibling)) {
       if (bCurOl) {
         iLiCount++;
       }
       ret = LoadRichText(pChildNode, szText, fLinePos,
                          pContext ? pStyle : pParentStyle, bSavePieces,
                          pLinkData, TRUE, bIsOl, iLiCount);
       if (ret == FALSE) {
         return FALSE;
       }
     }
@@ skipping 27 matching lines @@
           pLinkData->Release();
           pLinkData = nullptr;
         }
       }
       if (IsEnd(bSavePieces)) {
         if (pStyle) {
           pStyle->Release();
         }
         if (m_pLoader && m_pLoader->m_iTotalLines > -1) {
           m_pLoader->m_pXMLNode =
-              pXMLNode->GetNodeItem(IFDE_XMLNode::NextSibling);
+              pXMLNode->GetNodeItem(CFDE_XMLNode::NextSibling);
           m_pLoader->m_pParentStyle = pParentStyle;
         }
         return FALSE;
       }
     }
   }
   if (pStyle)
     pStyle->Release();
   return TRUE;
 }
@@ skipping 421 matching lines @@
   tr.iLength = iLength;
   tr.fFontSize = pPiece->fFontSize;
   tr.iBidiLevel = pPiece->iBidiLevel;
   tr.iCharRotation = 0;
   tr.wLineBreakChar = L'\n';
   tr.iVerticalScale = pPiece->iVerScale;
   tr.dwLayoutStyles = FX_RTFLAYOUTSTYLE_ExpandTab;
   tr.iHorizontalScale = pPiece->iHorScale;
   return TRUE;
 }