Remove IXFA_* interfaces.

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"
+#include "xfa/fxfa/app/xfa_ffwidgetacc.h"
+#include "xfa/include/fxfa/xfa_ffapp.h"
+#include "xfa/include/fxfa/xfa_ffdoc.h"
+#include "xfa/include/fxfa/xfa_fontmgr.h"
 
 CXFA_CSSTagProvider::~CXFA_CSSTagProvider() {
   FX_POSITION pos = m_Attributes.GetStartPosition();
   while (pos) {
     CFX_WideString *pName = NULL, *pValue = NULL;
     m_Attributes.GetNextAssoc(pos, (void*&)pName, (void*&)pValue);
     delete pName;
     delete pValue;
   }
 }
@@ skipping 52 matching lines @@
     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;
   }
 }
-void CXFA_TextParser::InitCSSData(IXFA_TextProvider* pTextProvider) {
+void CXFA_TextParser::InitCSSData(CXFA_TextProvider* pTextProvider) {
   if (pTextProvider == NULL) {
     return;
   }
   if (m_pSelector == NULL) {
     CXFA_FFDoc* pDoc = pTextProvider->GetDocNode();
     IFX_FontMgr* pFontMgr = pDoc->GetApp()->GetFDEFontMgr();
     FXSYS_assert(pFontMgr);
     m_pSelector = IFDE_CSSStyleSelector::Create();
     m_pSelector->SetFontMgr(pFontMgr);
     FX_FLOAT fFontSize = 10;
@@ skipping 16 matching lines @@
       L"ol,ul{padding-left:33px}ol{list-style-type:decimal}ol,ul{margin-top:0;"
       L"margin-bottom:0}ul,ol{margin:1.12em 0}"
       L"a{color:#0000ff;text-decoration:underline}b{font-weight:bolder}i{font-"
       L"style:italic}"
       L"sup{vertical-align:+15em;font-size:.66em}sub{vertical-align:-15em;font-"
       L"size:.66em}";
   return IFDE_CSSStyleSheet::LoadFromBuffer(
       CFX_WideString(), s_pStyle, FXSYS_wcslen(s_pStyle), FX_CODEPAGE_UTF8);
 }
 IFDE_CSSComputedStyle* CXFA_TextParser::CreateRootStyle(
-    IXFA_TextProvider* pTextProvider) {
+    CXFA_TextProvider* pTextProvider) {
   CXFA_Font font = pTextProvider->GetFontNode();
   CXFA_Para para = pTextProvider->GetParaNode();
   IFDE_CSSComputedStyle* pStyle = m_pSelector->CreateComputedStyle(NULL);
   IFDE_CSSFontStyle* pFontStyle = pStyle->GetFontStyles();
   IFDE_CSSParagraphStyle* pParaStyle = pStyle->GetParagraphStyles();
   FX_FLOAT fLineHeight = 0, fFontSize = 10;
   if (para) {
     fLineHeight = para.GetLineHeight();
     FDE_CSSLENGTH indent;
     indent.Set(FDE_CSSLENGTHUNIT_Point, para.GetTextIndent());
@@ skipping 86 matching lines @@
     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(CFDE_XMLNode* pXMLContainer,
-                              IXFA_TextProvider* pTextProvider) {
+                              CXFA_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();
 }
@@ skipping 63 matching lines @@
     CFX_WideString wsValue;
     pXMLElement->GetString(FX_WSTRC(L"style").GetPtr(), wsValue);
     if (!wsValue.IsEmpty()) {
       tagProvider.SetAttribute(FX_WSTRC(L"style"), wsValue);
     }
   } else if (pXMLNode->GetType() == FDE_XMLNODE_Text) {
     tagProvider.m_bTagAviliable = TRUE;
     tagProvider.m_bContent = TRUE;
   }
 }
-int32_t CXFA_TextParser::GetVAlgin(IXFA_TextProvider* pTextProvider) const {
+int32_t CXFA_TextParser::GetVAlgin(CXFA_TextProvider* pTextProvider) const {
   int32_t iAlign = XFA_ATTRIBUTEENUM_Top;
   CXFA_Para para = pTextProvider->GetParaNode();
   if (para) {
     iAlign = para.GetVerticalAlign();
   }
   return iAlign;
 }
 FX_FLOAT CXFA_TextParser::GetTabInterval(IFDE_CSSComputedStyle* pStyle) const {
   CFX_WideString wsValue;
   if (pStyle && pStyle->GetCustomStyle(FX_WSTRC(L"tab-interval"), wsValue)) {
@@ skipping 10 matching lines @@
   return 0;
 }
 FX_BOOL CXFA_TextParser::IsSpaceRun(IFDE_CSSComputedStyle* pStyle) const {
   CFX_WideString wsValue;
   if (pStyle && pStyle->GetCustomStyle(FX_WSTRC(L"xfa-spacerun"), wsValue)) {
     wsValue.MakeLower();
     return wsValue == FX_WSTRC(L"yes");
   }
   return FALSE;
 }
-IFX_Font* CXFA_TextParser::GetFont(IXFA_TextProvider* pTextProvider,
+IFX_Font* CXFA_TextParser::GetFont(CXFA_TextProvider* pTextProvider,
                                    IFDE_CSSComputedStyle* pStyle) const {
   CFX_WideStringC wsFamily = FX_WSTRC(L"Courier");
   uint32_t dwStyle = 0;
   CXFA_Font font = pTextProvider->GetFontNode();
   if (font) {
     font.GetTypeface(wsFamily);
     if (font.IsBold()) {
       dwStyle |= FX_FONTSTYLE_Bold;
     }
     if (font.IsItalic()) {
@@ skipping 11 matching lines @@
       dwStyle |= FX_FONTSTYLE_Bold;
     }
     if (pFontStyle->GetFontStyle() == FDE_CSSFONTSTYLE_Italic) {
       dwStyle |= FX_FONTSTYLE_Italic;
     }
   }
   CXFA_FFDoc* pDoc = pTextProvider->GetDocNode();
   CXFA_FontMgr* pFontMgr = pDoc->GetApp()->GetXFAFontMgr();
   return pFontMgr->GetFont(pDoc, wsFamily, dwStyle);
 }
-FX_FLOAT CXFA_TextParser::GetFontSize(IXFA_TextProvider* pTextProvider,
+FX_FLOAT CXFA_TextParser::GetFontSize(CXFA_TextProvider* pTextProvider,
                                       IFDE_CSSComputedStyle* pStyle) const {
   if (pStyle)
     return pStyle->GetFontStyles()->GetFontSize();
 
   CXFA_Font font = pTextProvider->GetFontNode();
   if (font) {
     return font.GetFontSize();
   }
   return 10;
 }
-int32_t CXFA_TextParser::GetHorScale(IXFA_TextProvider* pTextProvider,
+int32_t CXFA_TextParser::GetHorScale(CXFA_TextProvider* pTextProvider,
                                      IFDE_CSSComputedStyle* pStyle,
                                      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(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,
+int32_t CXFA_TextParser::GetVerScale(CXFA_TextProvider* pTextProvider,
                                      IFDE_CSSComputedStyle* pStyle) const {
   if (pStyle) {
     CFX_WideString wsValue;
     if (pStyle->GetCustomStyle(FX_WSTRC(L"xfa-font-vertical-scale"), wsValue)) {
       return wsValue.GetInteger();
     }
   }
   if (CXFA_Font font = pTextProvider->GetFontNode()) {
     return (int32_t)font.GetVerticalScale();
   }
   return 100;
 }
-void CXFA_TextParser::GetUnderline(IXFA_TextProvider* pTextProvider,
+void CXFA_TextParser::GetUnderline(CXFA_TextProvider* pTextProvider,
                                    IFDE_CSSComputedStyle* pStyle,
                                    int32_t& iUnderline,
                                    int32_t& iPeriod) const {
   iUnderline = 0;
   iPeriod = XFA_ATTRIBUTEENUM_All;
   if (pStyle) {
     uint32_t dwDecoration = pStyle->GetParagraphStyles()->GetTextDecoration();
     if (dwDecoration & FDE_CSSTEXTDECORATION_Double) {
       iUnderline = 2;
     } else if (dwDecoration & FDE_CSSTEXTDECORATION_Underline) {
       iUnderline = 1;
     }
     CFX_WideString wsValue;
     if (pStyle->GetCustomStyle(FX_WSTRC(L"underlinePeriod"), wsValue)) {
       if (wsValue == FX_WSTRC(L"word")) {
         iPeriod = XFA_ATTRIBUTEENUM_Word;
       }
     } else if (CXFA_Font font = pTextProvider->GetFontNode()) {
       iPeriod = font.GetUnderlinePeriod();
     }
   } else {
     CXFA_Font font = pTextProvider->GetFontNode();
     if (font) {
       iUnderline = font.GetUnderline();
       iPeriod = font.GetUnderlinePeriod();
     }
   }
 }
-void CXFA_TextParser::GetLinethrough(IXFA_TextProvider* pTextProvider,
+void CXFA_TextParser::GetLinethrough(CXFA_TextProvider* pTextProvider,
                                      IFDE_CSSComputedStyle* pStyle,
                                      int32_t& iLinethrough) const {
   if (pStyle) {
     uint32_t dwDecoration = pStyle->GetParagraphStyles()->GetTextDecoration();
     iLinethrough = (dwDecoration & FDE_CSSTEXTDECORATION_LineThrough) ? 1 : 0;
   } else {
     CXFA_Font font = pTextProvider->GetFontNode();
     if (font) {
       iLinethrough = font.GetLineThrough();
     }
   }
 }
-FX_ARGB CXFA_TextParser::GetColor(IXFA_TextProvider* pTextProvider,
+FX_ARGB CXFA_TextParser::GetColor(CXFA_TextProvider* pTextProvider,
                                   IFDE_CSSComputedStyle* pStyle) const {
   if (pStyle)
     return pStyle->GetFontStyles()->GetColor();
 
   if (CXFA_Font font = pTextProvider->GetFontNode())
     return font.GetColor();
 
   return 0xFF000000;
 }
-FX_FLOAT CXFA_TextParser::GetBaseline(IXFA_TextProvider* pTextProvider,
+FX_FLOAT CXFA_TextParser::GetBaseline(CXFA_TextProvider* pTextProvider,
                                       IFDE_CSSComputedStyle* pStyle) const {
   if (pStyle) {
     IFDE_CSSParagraphStyle* pParaStyle = pStyle->GetParagraphStyles();
     if (pParaStyle->GetVerticalAlign() == FDE_CSSVERTICALALIGN_Number) {
       return pParaStyle->GetNumberVerticalAlign();
     }
   } else if (CXFA_Font font = pTextProvider->GetFontNode()) {
     return font.GetBaselineShift();
   }
   return 0;
 }
-FX_FLOAT CXFA_TextParser::GetLineHeight(IXFA_TextProvider* pTextProvider,
+FX_FLOAT CXFA_TextParser::GetLineHeight(CXFA_TextProvider* pTextProvider,
                                         IFDE_CSSComputedStyle* pStyle,
                                         FX_BOOL bFirst,
                                         FX_FLOAT fVerScale) const {
   FX_FLOAT fLineHeight = 0;
   if (pStyle) {
     fLineHeight = pStyle->GetParagraphStyles()->GetLineHeight();
   } else if (CXFA_Para para = pTextProvider->GetParaNode()) {
     fLineHeight = para.GetLineHeight();
   }
   if (bFirst) {
     FX_FLOAT fFontSize = GetFontSize(pTextProvider, pStyle);
     if (fLineHeight < 0.1f) {
       fLineHeight = fFontSize;
     } 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,
+FX_BOOL CXFA_TextParser::GetEmbbedObj(CXFA_TextProvider* pTextProvider,
                                       CFDE_XMLNode* pXMLNode,
                                       CFX_WideString& wsValue) {
   wsValue.Empty();
   if (pXMLNode == NULL) {
     return FALSE;
   }
   FX_BOOL bRet = FALSE;
   if (pXMLNode->GetType() == FDE_XMLNODE_Element) {
     CFDE_XMLElement* pElement = static_cast<CFDE_XMLElement*>(pXMLNode);
     CFX_WideString wsAttr;
@@ skipping 128 matching lines @@
   }
   if (!wsAlign.IsEmpty()) {
     uint32_t dwHashCode =
         FX_HashCode_String_GetW(wsAlign, wsAlign.GetLength(), TRUE);
     CXFA_Measurement ms(CFX_WideStringC(pTabStops + iLast, iCur - iLast));
     FX_FLOAT fPos = ms.ToUnit(XFA_UNIT_Pt);
     pTabstopContext->Append(dwHashCode, fPos);
   }
   return TRUE;
 }
-CXFA_TextLayout::CXFA_TextLayout(IXFA_TextProvider* pTextProvider)
+CXFA_TextLayout::CXFA_TextLayout(CXFA_TextProvider* pTextProvider)
     : m_bHasBlock(FALSE),
       m_pTextProvider(pTextProvider),
       m_pTextDataNode(nullptr),
       m_bRichText(FALSE),
       m_pAllocator(nullptr),
       m_pBreak(nullptr),
       m_pLoader(nullptr),
       m_iLines(0),
       m_fMaxWidth(0),
       m_pTabstopContext(nullptr),
@@ skipping 1315 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;
 }