Move xfa/src up to xfa/.

This CL moves the xfa/src files up to the xfa/ directory and fixes the includes,
include guards, and build files.

R=tsepez@chromium.org

Review URL: https://codereview.chromium.org/1803723002 .

1 files changed, 2001 insertions, 0 deletions

diff --git a/xfa/fxfa/app/xfa_textlayout.cpp b/xfa/fxfa/app/xfa_textlayout.cpp
new file mode 100644
index 0000000000..05316f8784
--- /dev/null
+++ b/xfa/fxfa/app/xfa_textlayout.cpp
@@ -0,0 +1,2001 @@
+// 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/include/fxcrt/fx_ext.h"
+#include "xfa/fde/fde_pen.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;
+    m_Attributes.GetNextAssoc(pos, (void*&)pName, (void*&)pValue);
+    delete pName;
+    delete pValue;
+  }
+}
+void CXFA_CSSTagProvider::GetNextAttribute(FX_POSITION& pos,
+                                           CFX_WideStringC& wsAttr,
+                                           CFX_WideStringC& wsValue) {
+  if (pos == NULL) {
+    return;
+  }
+  CFX_WideString* pName = NULL;
+  CFX_WideString* pValue = NULL;
+  m_Attributes.GetNextAssoc(pos, (void*&)pName, (void*&)pValue);
+  wsAttr = *pName;
+  wsValue = *pValue;
+}
+void CXFA_CSSTagProvider::SetAttribute(const CFX_WideString& wsAttr,
+                                       const CFX_WideString& wsValue) {
+  CFX_WideString* pName = new CFX_WideString();
+  CFX_WideString* pValue = new CFX_WideString();
+  *pName = wsAttr;
+  *pValue = wsValue;
+  m_Attributes.SetAt(pName, pValue);
+}
+void CXFA_TextParseContext::SetDecls(const IFDE_CSSDeclaration** ppDeclArray,
+                                     int32_t iDeclCount) {
+  if (iDeclCount <= 0 || ppDeclArray == NULL) {
+    return;
+  }
+  m_dwMatchedDecls = iDeclCount;
+  m_ppMatchedDecls = FX_Alloc(IFDE_CSSDeclaration*, iDeclCount);
+  FXSYS_memcpy(m_ppMatchedDecls, ppDeclArray,
+               iDeclCount * sizeof(IFDE_CSSDeclaration*));
+}
+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;
+    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;
+    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;
+  }
+}
+void CXFA_TextParser::InitCSSData(IXFA_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;
+    CXFA_Font font = pTextProvider->GetFontNode();
+    if (font) {
+      fFontSize = font.GetFontSize();
+    }
+    m_pSelector->SetDefFontSize(fFontSize);
+  }
+  if (m_pUASheet == NULL) {
+    m_pUASheet = LoadDefaultSheetStyle();
+    m_pSelector->SetStyleSheet(FDE_CSSSTYLESHEETGROUP_UserAgent, m_pUASheet);
+    m_pSelector->UpdateStyleIndex(FDE_CSSMEDIATYPE_ALL);
+  }
+}
+IFDE_CSSStyleSheet* CXFA_TextParser::LoadDefaultSheetStyle() {
+  static const FX_WCHAR s_pStyle[] =
+      L"html,body,ol,p,ul{display:block}"
+      L"li{display:list-item}"
+      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_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());
+    pParaStyle->SetTextIndent(indent);
+    FDE_CSSTEXTALIGN hAlgin = FDE_CSSTEXTALIGN_Left;
+    switch (para.GetHorizontalAlign()) {
+      case XFA_ATTRIBUTEENUM_Center:
+        hAlgin = FDE_CSSTEXTALIGN_Center;
+        break;
+      case XFA_ATTRIBUTEENUM_Right:
+        hAlgin = FDE_CSSTEXTALIGN_Right;
+        break;
+      case XFA_ATTRIBUTEENUM_Justify:
+        hAlgin = FDE_CSSTEXTALIGN_Justify;
+        break;
+      case XFA_ATTRIBUTEENUM_JustifyAll:
+        hAlgin = FDE_CSSTEXTALIGN_JustifyAll;
+        break;
+    }
+    pParaStyle->SetTextAlign(hAlgin);
+    FDE_CSSRECT rtMarginWidth;
+    rtMarginWidth.left.Set(FDE_CSSLENGTHUNIT_Point, para.GetMarginLeft());
+    rtMarginWidth.top.Set(FDE_CSSLENGTHUNIT_Point, para.GetSpaceAbove());
+    rtMarginWidth.right.Set(FDE_CSSLENGTHUNIT_Point, para.GetMarginRight());
+    rtMarginWidth.bottom.Set(FDE_CSSLENGTHUNIT_Point, para.GetSpaceBelow());
+    pStyle->GetBoundaryStyles()->SetMarginWidth(rtMarginWidth);
+  }
+  if (font) {
+    pFontStyle->SetColor(font.GetColor());
+    pFontStyle->SetFontStyle(font.IsItalic() ? FDE_CSSFONTSTYLE_Italic
+                                             : FDE_CSSFONTSTYLE_Normal);
+    pFontStyle->SetFontWeight(font.IsBold() ? FXFONT_FW_BOLD
+                                            : FXFONT_FW_NORMAL);
+    pParaStyle->SetNumberVerticalAlign(-font.GetBaselineShift());
+    fFontSize = font.GetFontSize();
+    FDE_CSSLENGTH letterSpacing;
+    letterSpacing.Set(FDE_CSSLENGTHUNIT_Point, font.GetLetterSpacing());
+    pParaStyle->SetLetterSpacing(letterSpacing);
+    FX_DWORD dwDecoration = 0;
+    if (font.GetLineThrough() > 0) {
+      dwDecoration |= FDE_CSSTEXTDECORATION_LineThrough;
+    }
+    if (font.GetUnderline() > 1) {
+      dwDecoration |= FDE_CSSTEXTDECORATION_Double;
+    } else if (font.GetUnderline() > 0) {
+      dwDecoration |= FDE_CSSTEXTDECORATION_Underline;
+    }
+    pParaStyle->SetTextDecoration(dwDecoration);
+  }
+  pParaStyle->SetLineHeight(fLineHeight);
+  pFontStyle->SetFontSize(fFontSize);
+  return pStyle;
+}
+IFDE_CSSComputedStyle* CXFA_TextParser::CreateStyle(
+    IFDE_CSSComputedStyle* pParentStyle) {
+  IFDE_CSSComputedStyle* pNewStyle =
+      m_pSelector->CreateComputedStyle(pParentStyle);
+  FXSYS_assert(pNewStyle);
+  if (pParentStyle) {
+    IFDE_CSSParagraphStyle* pParaStyle = pParentStyle->GetParagraphStyles();
+    FX_DWORD dwDecoration = pParaStyle->GetTextDecoration();
+    FX_FLOAT fBaseLine = 0;
+    if (pParaStyle->GetVerticalAlign() == FDE_CSSVERTICALALIGN_Number) {
+      fBaseLine = pParaStyle->GetNumberVerticalAlign();
+    }
+    pParaStyle = pNewStyle->GetParagraphStyles();
+    pParaStyle->SetTextDecoration(dwDecoration);
+    pParaStyle->SetNumberVerticalAlign(fBaseLine);
+    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,
+    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,
+                              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,
+                                    IFDE_CSSComputedStyle* pParentStyle) {
+  if (pXMLNode == NULL) {
+    return;
+  }
+  CXFA_CSSTagProvider tagProvider;
+  ParseTagInfo(pXMLNode, tagProvider);
+  if (!tagProvider.m_bTagAviliable) {
+    return;
+  }
+  IFDE_CSSComputedStyle* pNewStyle = NULL;
+  if ((tagProvider.GetTagName() != FX_WSTRC(L"body")) ||
+      (tagProvider.GetTagName() != FX_WSTRC(L"html"))) {
+    CXFA_TextParseContext* pTextContext =
+        FXTARGET_NewWith(m_pAllocator) CXFA_TextParseContext;
+    FDE_CSSDISPLAY eDisplay = FDE_CSSDISPLAY_Inline;
+    if (!tagProvider.m_bContent) {
+      pNewStyle = CreateStyle(pParentStyle);
+      IFDE_CSSAccelerator* pCSSAccel = m_pSelector->InitAccelerator();
+      pCSSAccel->OnEnterTag(&tagProvider);
+      CFDE_CSSDeclarationArray DeclArray;
+      int32_t iMatchedDecls =
+          m_pSelector->MatchDeclarations(&tagProvider, DeclArray);
+      const IFDE_CSSDeclaration** ppMatchDecls =
+          (const IFDE_CSSDeclaration**)DeclArray.GetData();
+      m_pSelector->ComputeStyle(&tagProvider, ppMatchDecls, iMatchedDecls,
+                                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);
+       pXMLChild;
+       pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+    ParseRichText(pXMLChild, pNewStyle);
+  }
+  if (pNewStyle)
+    pNewStyle->Release();
+}
+void CXFA_TextParser::ParseTagInfo(IFDE_XMLNode* pXMLNode,
+                                   CXFA_CSSTagProvider& tagProvider) {
+  static const FX_DWORD 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;
+    pXMLElement->GetLocalTagName(wsName);
+    tagProvider.SetTagNameObj(wsName);
+    FX_DWORD dwHashCode =
+        FX_HashCode_String_GetW(wsName, wsName.GetLength(), TRUE);
+    static const int32_t s_iCount = sizeof(s_XFATagName) / sizeof(FX_DWORD);
+    CFX_DSPATemplate<FX_DWORD> lookup;
+    tagProvider.m_bTagAviliable =
+        lookup.Lookup(dwHashCode, s_XFATagName, s_iCount) > -1;
+    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 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)) {
+    CXFA_Measurement ms(wsValue);
+    return ms.ToUnit(XFA_UNIT_Pt);
+  }
+  return 36;
+}
+int32_t CXFA_TextParser::CountTabs(IFDE_CSSComputedStyle* pStyle) const {
+  CFX_WideString wsValue;
+  if (pStyle && pStyle->GetCustomStyle(FX_WSTRC(L"xfa-tab-count"), wsValue)) {
+    return wsValue.GetInteger();
+  }
+  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,
+                                   IFDE_CSSComputedStyle* pStyle) const {
+  CFX_WideStringC wsFamily = FX_WSTRC(L"Courier");
+  FX_DWORD dwStyle = 0;
+  CXFA_Font font = pTextProvider->GetFontNode();
+  if (font) {
+    font.GetTypeface(wsFamily);
+    if (font.IsBold()) {
+      dwStyle |= FX_FONTSTYLE_Bold;
+    }
+    if (font.IsItalic()) {
+      dwStyle |= FX_FONTSTYLE_Italic;
+    }
+  }
+  if (pStyle) {
+    IFDE_CSSFontStyle* pFontStyle = pStyle->GetFontStyles();
+    int32_t iCount = pFontStyle->CountFontFamilies();
+    if (iCount > 0) {
+      wsFamily = pFontStyle->GetFontFamily(iCount - 1);
+    }
+    dwStyle = 0;
+    if (pFontStyle->GetFontWeight() > FXFONT_FW_NORMAL) {
+      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,
+                                      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,
+                                     IFDE_CSSComputedStyle* pStyle,
+                                     IFDE_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);
+    }
+  }
+  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) {
+    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,
+                                   IFDE_CSSComputedStyle* pStyle,
+                                   int32_t& iUnderline,
+                                   int32_t& iPeriod) const {
+  iUnderline = 0;
+  iPeriod = XFA_ATTRIBUTEENUM_All;
+  if (pStyle) {
+    FX_DWORD 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,
+                                     IFDE_CSSComputedStyle* pStyle,
+                                     int32_t& iLinethrough) const {
+  if (pStyle) {
+    FX_DWORD 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,
+                                  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,
+                                      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,
+                                        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,
+                                      IFDE_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;
+    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);
+    if (ws.IsEmpty()) {
+      ws = L"som";
+    } else {
+      ws.MakeLower();
+    }
+    FX_BOOL bURI = (ws == FX_WSTRC(L"uri"));
+    if (!bURI && ws != FX_WSTRC(L"som")) {
+      return FALSE;
+    }
+    ws.Empty();
+    pElement->GetString(FX_WSTRC(L"xfa:embedMode").GetPtr(), ws);
+    if (ws.IsEmpty()) {
+      ws = L"formatted";
+    } else {
+      ws.MakeLower();
+    }
+    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) {
+  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,
+  XFA_TABSTOPSSTATUS_Location,
+};
+FX_BOOL CXFA_TextParser::GetTabstops(
+    IFDE_CSSComputedStyle* pStyle,
+    CXFA_TextTabstopsContext* pTabstopContext) {
+  if (pStyle == NULL || pTabstopContext == NULL) {
+    return FALSE;
+  }
+  CFX_WideString wsValue;
+  if (!pStyle->GetCustomStyle(FX_WSTRC(L"xfa-tab-stops"), wsValue) &&
+      !pStyle->GetCustomStyle(FX_WSTRC(L"tab-stops"), wsValue)) {
+    return FALSE;
+  }
+  int32_t iLength = wsValue.GetLength();
+  const FX_WCHAR* pTabStops = wsValue;
+  int32_t iCur = 0;
+  int32_t iLast = 0;
+  CFX_WideString wsAlign;
+  XFA_TABSTOPSSTATUS eStatus = XFA_TABSTOPSSTATUS_None;
+  FX_WCHAR ch;
+  while (iCur < iLength) {
+    ch = pTabStops[iCur];
+    switch (eStatus) {
+      case XFA_TABSTOPSSTATUS_None:
+        if (ch <= ' ') {
+          iCur++;
+        } else {
+          eStatus = XFA_TABSTOPSSTATUS_Alignment;
+          iLast = iCur;
+        }
+        break;
+      case XFA_TABSTOPSSTATUS_Alignment:
+        if (ch == ' ') {
+          wsAlign = CFX_WideStringC(pTabStops + iLast, iCur - iLast);
+          eStatus = XFA_TABSTOPSSTATUS_StartLeader;
+          iCur++;
+          while (iCur < iLength && pTabStops[iCur] <= ' ') {
+            iCur++;
+          }
+          iLast = iCur;
+        } else {
+          iCur++;
+        }
+        break;
+      case XFA_TABSTOPSSTATUS_StartLeader:
+        if (ch != 'l') {
+          eStatus = XFA_TABSTOPSSTATUS_Location;
+        } else {
+          int32_t iCount = 0;
+          while (iCur < iLength) {
+            ch = pTabStops[iCur];
+            iCur++;
+            if (ch == '(') {
+              iCount++;
+            } else if (ch == ')') {
+              iCount--;
+              if (iCount == 0) {
+                break;
+              }
+            }
+          }
+          while (iCur < iLength && pTabStops[iCur] <= ' ') {
+            iCur++;
+          }
+          iLast = iCur;
+          eStatus = XFA_TABSTOPSSTATUS_Location;
+        }
+        break;
+      case XFA_TABSTOPSSTATUS_Location:
+        if (ch == ' ') {
+          FX_DWORD 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);
+          wsAlign.Empty();
+          eStatus = XFA_TABSTOPSSTATUS_None;
+        }
+        iCur++;
+        break;
+      default:
+        break;
+    }
+  }
+  if (!wsAlign.IsEmpty()) {
+    FX_DWORD 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)
+    : 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),
+      m_bBlockContinue(TRUE) {
+  FXSYS_assert(m_pTextProvider);
+}
+CXFA_TextLayout::~CXFA_TextLayout() {
+  m_textParser.Reset();
+  delete m_pLoader;
+  delete m_pTabstopContext;
+  Unload();
+}
+void CXFA_TextLayout::Unload() {
+  int32_t iCount = m_pieceLines.GetSize();
+  for (int32_t i = 0; i < iCount; i++) {
+    CXFA_PieceLine* pLine = m_pieceLines.GetAt(i);
+    FXTARGET_DeleteWith(CXFA_PieceLine, m_pAllocator, pLine);
+  }
+  m_pieceLines.RemoveAll();
+  if (m_pBreak) {
+    m_pBreak->Release();
+    m_pBreak = NULL;
+  }
+  if (m_pAllocator) {
+    m_pAllocator->Release();
+    m_pAllocator = NULL;
+  }
+}
+const CXFA_PieceLineArray* CXFA_TextLayout::GetPieceLines() {
+  return &m_pieceLines;
+}
+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;
+  if (m_bRichText) {
+    IFDE_XMLNode* pXMLRoot = m_pTextDataNode->GetXMLMappingNode();
+    if (!pXMLRoot) {
+      return pXMLContainer;
+    }
+    for (IFDE_XMLNode* pXMLChild =
+             pXMLRoot->GetNodeItem(IFDE_XMLNode::FirstChild);
+         pXMLChild;
+         pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+      if (pXMLChild->GetType() == FDE_XMLNODE_Element) {
+        IFDE_XMLElement* pXMLElement = (IFDE_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;
+}
+IFX_RTFBreak* CXFA_TextLayout::CreateBreak(FX_BOOL bDefault) {
+  FX_DWORD dwStyle = FX_RTFLAYOUTSTYLE_ExpandTab;
+  if (!bDefault) {
+    dwStyle |= FX_RTFLAYOUTSTYLE_Pagination;
+  }
+  IFX_RTFBreak* pBreak = IFX_RTFBreak::Create(0);
+  pBreak->SetLayoutStyles(dwStyle);
+  pBreak->SetLineBreakChar(L'\n');
+  pBreak->SetLineBreakTolerance(1);
+  pBreak->SetFont(m_textParser.GetFont(m_pTextProvider, NULL));
+  pBreak->SetFontSize(m_textParser.GetFontSize(m_pTextProvider, NULL));
+  return pBreak;
+}
+void CXFA_TextLayout::InitBreak(FX_FLOAT fLineWidth) {
+  CXFA_Font font = m_pTextProvider->GetFontNode();
+  CXFA_Para para = m_pTextProvider->GetParaNode();
+  FX_FLOAT fStart = 0;
+  FX_FLOAT fStartPos = 0;
+  if (para) {
+    int32_t iAlign = FX_RTFLINEALIGNMENT_Left;
+    switch (para.GetHorizontalAlign()) {
+      case XFA_ATTRIBUTEENUM_Center:
+        iAlign = FX_RTFLINEALIGNMENT_Center;
+        break;
+      case XFA_ATTRIBUTEENUM_Right:
+        iAlign = FX_RTFLINEALIGNMENT_Right;
+        break;
+      case XFA_ATTRIBUTEENUM_Justify:
+        iAlign = FX_RTFLINEALIGNMENT_Justified;
+        break;
+      case XFA_ATTRIBUTEENUM_JustifyAll:
+        iAlign = FX_RTFLINEALIGNMENT_Distributed;
+        break;
+    }
+    m_pBreak->SetAlignment(iAlign);
+    fStart = para.GetMarginLeft();
+    if (m_pTextProvider->IsCheckButtonAndAutoWidth()) {
+      if (iAlign != FX_RTFLINEALIGNMENT_Left) {
+        fLineWidth -= para.GetMarginRight();
+      }
+    } else {
+      fLineWidth -= para.GetMarginRight();
+    }
+    if (fLineWidth < 0) {
+      fLineWidth = fStart;
+    }
+    fStartPos = fStart;
+    FX_FLOAT fIndent = para.GetTextIndent();
+    if (fIndent > 0) {
+      fStartPos += fIndent;
+    }
+  }
+  m_pBreak->SetLineBoundary(fStart, fLineWidth);
+  m_pBreak->SetLineStartPos(fStartPos);
+  if (font) {
+    m_pBreak->SetHorizontalScale((int32_t)font.GetHorizontalScale());
+    m_pBreak->SetVerticalScale((int32_t)font.GetVerticalScale());
+    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,
+                                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:
+        iAlign = FX_RTFLINEALIGNMENT_Right;
+        break;
+      case FDE_CSSTEXTALIGN_Center:
+        iAlign = FX_RTFLINEALIGNMENT_Center;
+        break;
+      case FDE_CSSTEXTALIGN_Justify:
+        iAlign = FX_RTFLINEALIGNMENT_Justified;
+        break;
+      case FDE_CSSTEXTALIGN_JustifyAll:
+        iAlign = FX_RTFLINEALIGNMENT_Distributed;
+        break;
+      default:
+        break;
+    }
+    m_pBreak->SetAlignment(iAlign);
+    FX_FLOAT fStart = 0;
+    const FDE_CSSRECT* pRect = pStyle->GetBoundaryStyles()->GetMarginWidth();
+    const FDE_CSSRECT* pPaddingRect =
+        pStyle->GetBoundaryStyles()->GetPaddingWidth();
+    if (pRect) {
+      fStart = pRect->left.GetValue();
+      fLineWidth -= pRect->right.GetValue();
+      if (pPaddingRect) {
+        fStart += pPaddingRect->left.GetValue();
+        fLineWidth -= pPaddingRect->right.GetValue();
+      }
+      if (eDisplay == FDE_CSSDISPLAY_ListItem) {
+        const FDE_CSSRECT* pParRect =
+            pParentStyle->GetBoundaryStyles()->GetMarginWidth();
+        const FDE_CSSRECT* pParPaddingRect =
+            pParentStyle->GetBoundaryStyles()->GetPaddingWidth();
+        if (pParRect) {
+          fStart += pParRect->left.GetValue();
+          fLineWidth -= pParRect->right.GetValue();
+          if (pParPaddingRect) {
+            fStart += pParPaddingRect->left.GetValue();
+            fLineWidth -= pParPaddingRect->right.GetValue();
+          }
+        }
+        FDE_CSSRECT pNewRect;
+        pNewRect.left.Set(FDE_CSSLENGTHUNIT_Point, fStart);
+        pNewRect.right.Set(FDE_CSSLENGTHUNIT_Point, pRect->right.GetValue());
+        pNewRect.top.Set(FDE_CSSLENGTHUNIT_Point, pRect->top.GetValue());
+        pNewRect.bottom.Set(FDE_CSSLENGTHUNIT_Point, pRect->bottom.GetValue());
+        pStyle->GetBoundaryStyles()->SetMarginWidth(pNewRect);
+      }
+    }
+    m_pBreak->SetLineBoundary(fStart, fLineWidth);
+    FX_FLOAT fIndent = pParaStyle->GetTextIndent().GetValue();
+    if (fIndent > 0) {
+      fStart += fIndent;
+    }
+    m_pBreak->SetLineStartPos(fStart);
+    m_pBreak->SetTabWidth(m_textParser.GetTabInterval(pStyle));
+    if (m_pTabstopContext == NULL) {
+      m_pTabstopContext = new CXFA_TextTabstopsContext;
+    }
+    m_textParser.GetTabstops(pStyle, m_pTabstopContext);
+    for (int32_t i = 0; i < m_pTabstopContext->m_iTabCount; i++) {
+      XFA_TABSTOPS* pTab = m_pTabstopContext->m_tabstops.GetDataPtr(i);
+      m_pBreak->AddPositionedTab(pTab->fTabstops);
+    }
+  }
+  FX_FLOAT fFontSize = m_textParser.GetFontSize(m_pTextProvider, pStyle);
+  m_pBreak->SetFontSize(fFontSize);
+  m_pBreak->SetLineBreakTolerance(fFontSize * 0.2f);
+  m_pBreak->SetFont(m_textParser.GetFont(m_pTextProvider, pStyle));
+  m_pBreak->SetHorizontalScale(
+      m_textParser.GetHorScale(m_pTextProvider, pStyle, pXMLNode));
+  m_pBreak->SetVerticalScale(m_textParser.GetVerScale(m_pTextProvider, pStyle));
+  m_pBreak->SetCharSpace(pParaStyle->GetLetterSpacing().GetValue());
+}
+int32_t CXFA_TextLayout::GetText(CFX_WideString& wsText) {
+  GetTextDataNode();
+  wsText.Empty();
+  if (m_bRichText) {
+  } else {
+    wsText = m_pTextDataNode->GetContent();
+  }
+  return wsText.GetLength();
+}
+FX_FLOAT CXFA_TextLayout::GetLayoutHeight() {
+  if (m_pLoader == NULL) {
+    return 0;
+  }
+  int32_t iCount = m_pLoader->m_lineHeights.GetSize();
+  if (iCount == 0 && m_pLoader->m_fWidth > 0) {
+    CFX_SizeF szMax(m_pLoader->m_fWidth, m_pLoader->m_fHeight);
+    CFX_SizeF szDef;
+    m_pLoader->m_bSaveLineHeight = TRUE;
+    m_pLoader->m_fLastPos = 0;
+    CalcSize(szMax, szMax, szDef);
+    m_pLoader->m_bSaveLineHeight = FALSE;
+    return szDef.y;
+  }
+  FX_FLOAT fHeight = m_pLoader->m_fHeight;
+  if (fHeight < 0.1f) {
+    fHeight = 0;
+    for (int32_t i = 0; i < iCount; i++) {
+      fHeight += m_pLoader->m_lineHeights.ElementAt(i);
+    }
+  }
+  return fHeight;
+}
+FX_FLOAT CXFA_TextLayout::StartLayout(FX_FLOAT fWidth) {
+  if (m_pLoader == NULL) {
+    m_pLoader = new CXFA_LoaderContext;
+  }
+  if (fWidth < 0 || (m_pLoader->m_fWidth > -1 &&
+                     FXSYS_fabs(fWidth - m_pLoader->m_fWidth) > 0)) {
+    m_pLoader->m_lineHeights.RemoveAll();
+    m_Blocks.RemoveAll();
+    Unload();
+    m_pLoader->m_fStartLineOffset = 0;
+  }
+  m_pLoader->m_fWidth = fWidth;
+  if (fWidth < 0) {
+    CFX_SizeF szMax;
+    CFX_SizeF szDef;
+    m_pLoader->m_bSaveLineHeight = TRUE;
+    m_pLoader->m_fLastPos = 0;
+    CalcSize(szMax, szMax, szDef);
+    m_pLoader->m_bSaveLineHeight = FALSE;
+    fWidth = szDef.x;
+  }
+  return fWidth;
+}
+FX_BOOL CXFA_TextLayout::DoLayout(int32_t iBlockIndex,
+                                  FX_FLOAT& fCalcHeight,
+                                  FX_FLOAT fContentAreaHeight,
+                                  FX_FLOAT fTextHeight) {
+  if (m_pLoader == NULL) {
+    return FALSE;
+  }
+  int32_t iBlockCount = m_Blocks.GetSize();
+  FX_FLOAT fHeight = fTextHeight;
+  if (fHeight < 0) {
+    fHeight = GetLayoutHeight();
+  }
+  m_pLoader->m_fHeight = fHeight;
+  if (fContentAreaHeight < 0) {
+    return FALSE;
+  }
+  m_bHasBlock = TRUE;
+  if (iBlockCount == 0 && fHeight > 0) {
+    fHeight = fTextHeight - GetLayoutHeight();
+    if (fHeight > 0) {
+      int32_t iAlign = m_textParser.GetVAlgin(m_pTextProvider);
+      if (iAlign == XFA_ATTRIBUTEENUM_Middle) {
+        fHeight /= 2.0f;
+      } else if (iAlign != XFA_ATTRIBUTEENUM_Bottom) {
+        fHeight = 0;
+      }
+      m_pLoader->m_fStartLineOffset = fHeight;
+    }
+  }
+  FX_FLOAT fLinePos = m_pLoader->m_fStartLineOffset;
+  int32_t iLineIndex = 0;
+  if (iBlockCount > 1) {
+    if (iBlockCount >= (iBlockIndex + 1) * 2) {
+      iLineIndex = m_Blocks.ElementAt(iBlockIndex * 2);
+    } else {
+      iLineIndex = m_Blocks.ElementAt(iBlockCount - 1) +
+                   m_Blocks.ElementAt(iBlockCount - 2);
+    }
+    if (m_pLoader->m_BlocksHeight.GetSize() > 0) {
+      for (int32_t i = 0; i < iBlockIndex; i++) {
+        fLinePos -= m_pLoader->m_BlocksHeight.ElementAt(i * 2 + 1);
+      }
+    }
+  }
+  int32_t iCount = m_pLoader->m_lineHeights.GetSize();
+  int32_t i = 0;
+  for (i = iLineIndex; i < iCount; i++) {
+    FX_FLOAT fLineHeight = m_pLoader->m_lineHeights.ElementAt(i);
+    if ((i == iLineIndex) && (fLineHeight - fContentAreaHeight > 0.001)) {
+      fCalcHeight = 0;
+      return TRUE;
+    }
+    if (fLinePos + fLineHeight - fContentAreaHeight > 0.001) {
+      if (iBlockCount >= (iBlockIndex + 1) * 2) {
+        m_Blocks.SetAt(iBlockIndex * 2, iLineIndex);
+        m_Blocks.SetAt(iBlockIndex * 2 + 1, i - iLineIndex);
+      } else {
+        m_Blocks.Add(iLineIndex);
+        m_Blocks.Add(i - iLineIndex);
+      }
+      if (i == iLineIndex) {
+        if (fCalcHeight <= fLinePos) {
+          if (m_pLoader->m_BlocksHeight.GetSize() > iBlockIndex * 2 &&
+              (m_pLoader->m_BlocksHeight.GetAt(iBlockIndex * 2) ==
+               iBlockIndex)) {
+            m_pLoader->m_BlocksHeight.SetAt(iBlockIndex * 2 + 1, fCalcHeight);
+          } else {
+            m_pLoader->m_BlocksHeight.Add((FX_FLOAT)iBlockIndex);
+            m_pLoader->m_BlocksHeight.Add(fCalcHeight);
+          }
+        }
+        return TRUE;
+      }
+      fCalcHeight = fLinePos;
+      return TRUE;
+    }
+    fLinePos += fLineHeight;
+  }
+  return FALSE;
+}
+int32_t CXFA_TextLayout::CountBlocks() const {
+  int32_t iCount = m_Blocks.GetSize() / 2;
+  return iCount > 0 ? iCount : 1;
+}
+FX_BOOL CXFA_TextLayout::CalcSize(const CFX_SizeF& minSize,
+                                  const CFX_SizeF& maxSize,
+                                  CFX_SizeF& defaultSize) {
+  defaultSize.x = maxSize.x;
+  if (defaultSize.x < 1) {
+    defaultSize.x = 0xFFFF;
+  }
+  if (m_pBreak)
+    m_pBreak->Release();
+
+  m_pBreak = CreateBreak(FALSE);
+  FX_FLOAT fLinePos = 0;
+  m_iLines = 0;
+  m_fMaxWidth = 0;
+  Loader(defaultSize, fLinePos, FALSE);
+  if (fLinePos < 0.1f) {
+    fLinePos = m_textParser.GetFontSize(m_pTextProvider, NULL);
+  }
+  if (m_pTabstopContext) {
+    delete m_pTabstopContext;
+    m_pTabstopContext = NULL;
+  }
+  defaultSize = CFX_SizeF(m_fMaxWidth, fLinePos);
+  return TRUE;
+}
+FX_BOOL CXFA_TextLayout::Layout(const CFX_SizeF& size, FX_FLOAT* fHeight) {
+  if (size.x < 1) {
+    return FALSE;
+  }
+  Unload();
+  m_pBreak = CreateBreak(TRUE);
+  if (m_pLoader) {
+    m_pLoader->m_iTotalLines = -1;
+    m_pLoader->m_iChar = 0;
+  }
+  m_iLines = 0;
+  FX_FLOAT fLinePos = 0;
+  Loader(size, fLinePos, TRUE);
+  UpdateAlign(size.y, fLinePos);
+  if (m_pTabstopContext) {
+    delete m_pTabstopContext;
+    m_pTabstopContext = NULL;
+  }
+  if (fHeight) {
+    *fHeight = fLinePos;
+  }
+  return TRUE;
+}
+FX_BOOL CXFA_TextLayout::Layout(int32_t iBlock) {
+  if (m_pLoader == NULL || iBlock < 0 || iBlock >= CountBlocks()) {
+    return FALSE;
+  }
+  if (m_pLoader->m_fWidth < 1) {
+    return FALSE;
+  }
+  m_pLoader->m_iTotalLines = -1;
+  m_iLines = 0;
+  FX_FLOAT fLinePos = 0;
+  CXFA_Node* pNode = NULL;
+  CFX_SizeF szText(m_pLoader->m_fWidth, m_pLoader->m_fHeight);
+  int32_t iCount = m_Blocks.GetSize();
+  int32_t iBlocksHeightCount = m_pLoader->m_BlocksHeight.GetSize();
+  iBlocksHeightCount /= 2;
+  if (iBlock < iBlocksHeightCount) {
+    return TRUE;
+  }
+  if (iBlock == iBlocksHeightCount) {
+    Unload();
+    m_pBreak = CreateBreak(TRUE);
+    fLinePos = m_pLoader->m_fStartLineOffset;
+    for (int32_t i = 0; i < iBlocksHeightCount; i++) {
+      fLinePos -= m_pLoader->m_BlocksHeight.ElementAt(i * 2 + 1);
+    }
+    m_pLoader->m_iChar = 0;
+    if (iCount > 1) {
+      m_pLoader->m_iTotalLines = m_Blocks.ElementAt(iBlock * 2 + 1);
+    }
+    Loader(szText, fLinePos, TRUE);
+    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();
+      if (!pContainerNode) {
+        return TRUE;
+      }
+      IFDE_XMLNode* pXMLNode = m_pLoader->m_pXMLNode;
+      if (pXMLNode == NULL) {
+        return TRUE;
+      }
+      IFDE_XMLNode* pSaveXMLNode = m_pLoader->m_pXMLNode;
+      for (; pXMLNode;
+           pXMLNode = pXMLNode->GetNodeItem(IFDE_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);
+        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);
+        if (!pXMLNode) {
+          continue;
+        }
+        for (; pXMLNode;
+             pXMLNode = pXMLNode->GetNodeItem(IFDE_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) {
+        return TRUE;
+      }
+      LoadText(pNode, szText, fLinePos, TRUE);
+    }
+  }
+  if (iBlock == iCount) {
+    delete m_pTabstopContext;
+    m_pTabstopContext = nullptr;
+    delete m_pLoader;
+    m_pLoader = nullptr;
+  }
+  return TRUE;
+}
+void CXFA_TextLayout::ItemBlocks(const CFX_RectF& rtText, int32_t iBlockIndex) {
+  if (!m_pLoader) {
+    return;
+  }
+  int32_t iCountHeight = m_pLoader->m_lineHeights.GetSize();
+  if (iCountHeight == 0) {
+    return;
+  }
+  FX_BOOL bEndItem = TRUE;
+  int32_t iBlockCount = m_Blocks.GetSize();
+  FX_FLOAT fLinePos = m_pLoader->m_fStartLineOffset;
+  int32_t iLineIndex = 0;
+  if (iBlockIndex > 0) {
+    int32_t iBlockHeightCount = m_pLoader->m_BlocksHeight.GetSize();
+    iBlockHeightCount /= 2;
+    if (iBlockHeightCount >= iBlockIndex) {
+      for (int32_t i = 0; i < iBlockIndex; i++) {
+        fLinePos -= m_pLoader->m_BlocksHeight.ElementAt(i * 2 + 1);
+      }
+    } else {
+      fLinePos = 0;
+    }
+    iLineIndex = m_Blocks.ElementAt(iBlockCount - 1) +
+                 m_Blocks.ElementAt(iBlockCount - 2);
+  }
+  int32_t i = 0;
+  for (i = iLineIndex; i < iCountHeight; i++) {
+    FX_FLOAT fLineHeight = m_pLoader->m_lineHeights.ElementAt(i);
+    if (fLinePos + fLineHeight - rtText.height > 0.001) {
+      m_Blocks.Add(iLineIndex);
+      m_Blocks.Add(i - iLineIndex);
+      bEndItem = FALSE;
+      break;
+    }
+    fLinePos += fLineHeight;
+  }
+  if (iCountHeight > 0 && (i - iLineIndex) > 0 && bEndItem) {
+    m_Blocks.Add(iLineIndex);
+    m_Blocks.Add(i - iLineIndex);
+  }
+}
+FX_BOOL CXFA_TextLayout::DrawString(CFX_RenderDevice* pFxDevice,
+                                    const CFX_Matrix& tmDoc2Device,
+                                    const CFX_RectF& rtClip,
+                                    int32_t iBlock) {
+  IFDE_RenderDevice* pDevice = IFDE_RenderDevice::Create(pFxDevice);
+  if (pDevice == NULL) {
+    return FALSE;
+  }
+  FDE_HDEVICESTATE state = pDevice->SaveState();
+  pDevice->SetClipRect(rtClip);
+  IFDE_SolidBrush* pSolidBrush =
+      (IFDE_SolidBrush*)IFDE_Brush::Create(FDE_BRUSHTYPE_Solid);
+  IFDE_Pen* pPen = IFDE_Pen::Create();
+  FXSYS_assert(pDevice);
+  FXSYS_assert(pSolidBrush);
+  FXSYS_assert(pPen);
+  if (m_pieceLines.GetSize() == 0) {
+    int32_t iBlockCount = CountBlocks();
+    for (int32_t i = 0; i < iBlockCount; i++) {
+      Layout(i);
+    }
+  }
+  FXTEXT_CHARPOS* pCharPos = NULL;
+  int32_t iCharCount = 0;
+  int32_t iLineStart = 0;
+  int32_t iPieceLines = m_pieceLines.GetSize();
+  int32_t iCount = m_Blocks.GetSize();
+  if (iCount > 0) {
+    iBlock *= 2;
+    if (iBlock < iCount) {
+      iLineStart = m_Blocks.ElementAt(iBlock);
+      iPieceLines = m_Blocks.ElementAt(iBlock + 1);
+    } else {
+      iPieceLines = 0;
+    }
+  }
+  for (int32_t i = 0; i < iPieceLines; i++) {
+    if (i + iLineStart >= m_pieceLines.GetSize()) {
+      break;
+    }
+    CXFA_PieceLine* pPieceLine = m_pieceLines.GetAt(i + iLineStart);
+    int32_t iPieces = pPieceLine->m_textPieces.GetSize();
+    int32_t j = 0;
+    for (j = 0; j < iPieces; j++) {
+      const XFA_TextPiece* pPiece = pPieceLine->m_textPieces.GetAt(j);
+      int32_t iChars = pPiece->iChars;
+      if (iCharCount < iChars) {
+        FX_Free(pCharPos);
+        pCharPos = FX_Alloc(FXTEXT_CHARPOS, iChars);
+        iCharCount = iChars;
+      }
+      FXSYS_memset(pCharPos, 0, iCharCount * sizeof(FXTEXT_CHARPOS));
+      RenderString(pDevice, pSolidBrush, pPieceLine, j, pCharPos, tmDoc2Device);
+    }
+    for (j = 0; j < iPieces; j++) {
+      RenderPath(pDevice, pPen, pPieceLine, j, pCharPos, tmDoc2Device);
+    }
+  }
+  pDevice->RestoreState(state);
+  FX_Free(pCharPos);
+  pSolidBrush->Release();
+  pPen->Release();
+  pDevice->Release();
+  return iPieceLines;
+}
+void CXFA_TextLayout::UpdateAlign(FX_FLOAT fHeight, FX_FLOAT fBottom) {
+  fHeight -= fBottom;
+  if (fHeight < 0.1f) {
+    return;
+  }
+  switch (m_textParser.GetVAlgin(m_pTextProvider)) {
+    case XFA_ATTRIBUTEENUM_Middle:
+      fHeight /= 2.0f;
+      break;
+    case XFA_ATTRIBUTEENUM_Bottom:
+      break;
+    default:
+      return;
+  }
+  int32_t iCount = m_pieceLines.GetSize();
+  for (int32_t i = 0; i < iCount; i++) {
+    CXFA_PieceLine* pPieceLine = m_pieceLines.GetAt(i);
+    int32_t iPieces = pPieceLine->m_textPieces.GetSize();
+    for (int32_t j = 0; j < iPieces; j++) {
+      XFA_TextPiece* pPiece = pPieceLine->m_textPieces.GetAt(j);
+      CFX_RectF& rect = pPiece->rtPiece;
+      rect.top += fHeight;
+    }
+  }
+}
+FX_BOOL CXFA_TextLayout::Loader(const CFX_SizeF& szText,
+                                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();
+    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 {
+    LoadText(m_pTextDataNode, szText, fLinePos, bSavePieces);
+  }
+  return TRUE;
+}
+void CXFA_TextLayout::LoadText(CXFA_Node* pNode,
+                               const CFX_SizeF& szText,
+                               FX_FLOAT& fLinePos,
+                               FX_BOOL bSavePieces) {
+  InitBreak(szText.x);
+  CXFA_Para para = m_pTextProvider->GetParaNode();
+  FX_FLOAT fSpaceAbove = 0;
+  if (para) {
+    fSpaceAbove = para.GetSpaceAbove();
+    if (fSpaceAbove < 0.1f) {
+      fSpaceAbove = 0;
+    }
+    int32_t verAlign = para.GetVerticalAlign();
+    switch (verAlign) {
+      case XFA_ATTRIBUTEENUM_Top:
+      case XFA_ATTRIBUTEENUM_Middle:
+      case XFA_ATTRIBUTEENUM_Bottom: {
+        fLinePos += fSpaceAbove;
+        break;
+      }
+    }
+  }
+  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,
+                                      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;
+    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->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 &&
+            eDisplay != FDE_CSSDISPLAY_ListItem) {
+          return TRUE;
+        }
+        pStyle = m_textParser.ComputeStyle(pXMLNode, pParentStyle);
+        InitBreak(bContentNode ? pParentStyle : pStyle, eDisplay, szText.x,
+                  pXMLNode, pParentStyle);
+        if ((eDisplay == FDE_CSSDISPLAY_Block ||
+             eDisplay == FDE_CSSDISPLAY_ListItem) &&
+            pStyle &&
+            (wsName.IsEmpty() ||
+             (wsName != FX_WSTRC(L"body") && wsName != FX_WSTRC(L"html") &&
+              wsName != FX_WSTRC(L"ol") && wsName != FX_WSTRC(L"ul")))) {
+          const FDE_CSSRECT* pRect =
+              pStyle->GetBoundaryStyles()->GetMarginWidth();
+          if (pRect) {
+            fLinePos += pRect->top.GetValue();
+            fSpaceBelow = pRect->bottom.GetValue();
+          }
+        }
+        if (wsName == FX_WSTRC(L"a")) {
+          CFX_WideString wsLinkContent;
+          FXSYS_assert(pElement);
+          pElement->GetString(FX_WSTRC(L"href").GetPtr(), wsLinkContent);
+          if (!wsLinkContent.IsEmpty()) {
+            pLinkData = FXTARGET_NewWith(m_pAllocator) CXFA_LinkUserData(
+                m_pAllocator,
+                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);
+        } 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) {
+          if (iTabCount > 0) {
+            while (iTabCount-- > 0)
+              wsText += L'\t';
+          } else {
+            m_textParser.GetEmbbedObj(m_pTextProvider, pXMLNode, wsText);
+          }
+        }
+        int32_t iLength = wsText.GetLength();
+        if (iLength > 0 && bContentNode && !bSpaceRun) {
+          ProcessText(wsText);
+        }
+        if (m_pLoader) {
+          if (wsText.GetLength() > 0 &&
+              (m_pLoader->m_dwFlags & XFA_LOADERCNTXTFLG_FILTERSPACE)) {
+            wsText.TrimLeft(0x20);
+          }
+          if (FDE_CSSDISPLAY_Block == eDisplay) {
+            m_pLoader->m_dwFlags |= XFA_LOADERCNTXTFLG_FILTERSPACE;
+          } else if (FDE_CSSDISPLAY_Inline == eDisplay &&
+                     (m_pLoader->m_dwFlags & XFA_LOADERCNTXTFLG_FILTERSPACE)) {
+            m_pLoader->m_dwFlags &= ~XFA_LOADERCNTXTFLG_FILTERSPACE;
+          } else if (wsText.GetLength() > 0 &&
+                     (0x20 == wsText.GetAt(wsText.GetLength() - 1))) {
+            m_pLoader->m_dwFlags |= XFA_LOADERCNTXTFLG_FILTERSPACE;
+          } else if (wsText.GetLength() != 0) {
+            m_pLoader->m_dwFlags &= ~XFA_LOADERCNTXTFLG_FILTERSPACE;
+          }
+        }
+        if (wsText.GetLength() > 0) {
+          if (m_pLoader == NULL || m_pLoader->m_iChar == 0) {
+            if (pLinkData) {
+              pLinkData->AddRef();
+            }
+            CXFA_TextUserData* pUserData = FXTARGET_NewWith(m_pAllocator)
+                CXFA_TextUserData(m_pAllocator,
+                                  bContentNode ? pParentStyle : pStyle,
+                                  pLinkData);
+            m_pBreak->SetUserData(pUserData);
+          }
+          if (AppendChar(wsText, fLinePos, 0, bSavePieces)) {
+            if (m_pLoader) {
+              m_pLoader->m_dwFlags &= ~XFA_LOADERCNTXTFLG_FILTERSPACE;
+            }
+            if (IsEnd(bSavePieces)) {
+              if (m_pLoader && m_pLoader->m_iTotalLines > -1) {
+                m_pLoader->m_pXMLNode = pXMLNode;
+                m_pLoader->m_pParentStyle = pParentStyle;
+              }
+              if (pStyle)
+                pStyle->Release();
+              return FALSE;
+            }
+            return TRUE;
+          }
+        }
+      }
+    }
+    FX_BOOL ret = TRUE;
+    for (IFDE_XMLNode* pChildNode =
+             pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild);
+         pChildNode;
+         pChildNode = pChildNode->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+      if (bCurOl) {
+        iLiCount++;
+      }
+      ret = LoadRichText(pChildNode, szText, fLinePos,
+                         pContext ? pStyle : pParentStyle, bSavePieces,
+                         pLinkData, TRUE, bIsOl, iLiCount);
+      if (ret == FALSE) {
+        return FALSE;
+      }
+    }
+    if (m_pLoader) {
+      if (FDE_CSSDISPLAY_Block == eDisplay) {
+        m_pLoader->m_dwFlags |= XFA_LOADERCNTXTFLG_FILTERSPACE;
+      }
+    }
+    if (bCurLi) {
+      EndBreak(FX_RTFBREAK_LineBreak, fLinePos, bSavePieces);
+    }
+  } else {
+    if (pContext) {
+      eDisplay = pContext->GetDisplay();
+    }
+  }
+  if (m_bBlockContinue) {
+    if (pContext && !bContentNode) {
+      FX_DWORD dwStatus = (eDisplay == FDE_CSSDISPLAY_Block)
+                              ? FX_RTFBREAK_ParagraphBreak
+                              : FX_RTFBREAK_PieceBreak;
+      EndBreak(dwStatus, fLinePos, bSavePieces);
+      if (eDisplay == FDE_CSSDISPLAY_Block) {
+        fLinePos += fSpaceBelow;
+        if (m_pTabstopContext) {
+          m_pTabstopContext->RemoveAll();
+        }
+      }
+      if (wsName == FX_WSTRC(L"a")) {
+        if (pLinkData) {
+          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);
+          m_pLoader->m_pParentStyle = pParentStyle;
+        }
+        return FALSE;
+      }
+    }
+  }
+  if (pStyle)
+    pStyle->Release();
+  return TRUE;
+}
+FX_BOOL CXFA_TextLayout::AppendChar(const CFX_WideString& wsText,
+                                    FX_FLOAT& fLinePos,
+                                    FX_FLOAT fSpaceAbove,
+                                    FX_BOOL bSavePieces) {
+  FX_DWORD dwStatus = 0;
+  int32_t iChar = 0;
+  if (m_pLoader) {
+    iChar = m_pLoader->m_iChar;
+  }
+  int32_t iLength = wsText.GetLength();
+  for (int32_t i = iChar; i < iLength; i++) {
+    FX_WCHAR wch = wsText.GetAt(i);
+    if (wch == 0xA0) {
+      wch = 0x20;
+    }
+    if ((dwStatus = m_pBreak->AppendChar(wch)) > FX_RTFBREAK_PieceBreak) {
+      AppendTextLine(dwStatus, fLinePos, bSavePieces);
+      if (IsEnd(bSavePieces)) {
+        if (m_pLoader)
+          m_pLoader->m_iChar = i;
+        return TRUE;
+      }
+      if (dwStatus == FX_RTFBREAK_ParagraphBreak && m_bRichText) {
+        fLinePos += fSpaceAbove;
+      }
+    }
+  }
+  if (m_pLoader) {
+    m_pLoader->m_iChar = 0;
+  }
+  return FALSE;
+}
+FX_BOOL CXFA_TextLayout::IsEnd(FX_BOOL bSavePieces) {
+  if (!bSavePieces) {
+    return FALSE;
+  }
+  if (m_pLoader && m_pLoader->m_iTotalLines > 0) {
+    return m_iLines >= m_pLoader->m_iTotalLines;
+  }
+  return FALSE;
+}
+void CXFA_TextLayout::ProcessText(CFX_WideString& wsText) {
+  int32_t iLen = wsText.GetLength();
+  if (iLen == 0) {
+    return;
+  }
+  FX_WCHAR* psz = wsText.GetBuffer(iLen);
+  int32_t iTrimLeft = 0;
+  FX_WCHAR wch = 0, wPrev = 0;
+  for (int32_t i = 0; i < iLen; i++) {
+    wch = psz[i];
+    if (wch < 0x20) {
+      wch = 0x20;
+    }
+    if (wch == 0x20 && wPrev == 0x20) {
+      continue;
+    }
+    wPrev = wch;
+    psz[iTrimLeft++] = wch;
+  }
+  wsText.ReleaseBuffer(iLen);
+  wsText = wsText.Left(iTrimLeft);
+}
+void CXFA_TextLayout::EndBreak(FX_DWORD dwStatus,
+                               FX_FLOAT& fLinePos,
+                               FX_BOOL bSavePieces) {
+  dwStatus = m_pBreak->EndBreak(dwStatus);
+  if (dwStatus > FX_RTFBREAK_PieceBreak) {
+    AppendTextLine(dwStatus, fLinePos, bSavePieces, TRUE);
+  }
+}
+void CXFA_TextLayout::DoTabstops(IFDE_CSSComputedStyle* pStyle,
+                                 CXFA_PieceLine* pPieceLine) {
+  if (m_pTabstopContext == NULL || m_pTabstopContext->m_iTabCount == 0) {
+    return;
+  }
+  if (pStyle == NULL || pPieceLine == NULL) {
+    return;
+  }
+  int32_t iPieces = pPieceLine->m_textPieces.GetSize();
+  if (iPieces == 0) {
+    return;
+  }
+  XFA_TextPiece* pPiece = pPieceLine->m_textPieces.GetAt(iPieces - 1);
+  int32_t& iTabstopsIndex = m_pTabstopContext->m_iTabIndex;
+  int32_t iCount = m_textParser.CountTabs(pStyle);
+  if (iTabstopsIndex > m_pTabstopContext->m_iTabCount - 1) {
+    return;
+  }
+  if (iCount > 0) {
+    iTabstopsIndex++;
+    m_pTabstopContext->m_bTabstops = TRUE;
+    FX_FLOAT fRight = 0;
+    if (iPieces > 1) {
+      XFA_TextPiece* p = pPieceLine->m_textPieces.GetAt(iPieces - 2);
+      fRight = p->rtPiece.right();
+    }
+    m_pTabstopContext->m_fTabWidth =
+        pPiece->rtPiece.width + pPiece->rtPiece.left - fRight;
+  } else if (iTabstopsIndex > -1) {
+    FX_FLOAT fLeft = 0;
+    if (m_pTabstopContext->m_bTabstops) {
+      XFA_TABSTOPS* pTabstops =
+          m_pTabstopContext->m_tabstops.GetDataPtr(iTabstopsIndex);
+      FX_DWORD dwAlgin = pTabstops->dwAlign;
+      if (dwAlgin == FX_HashCode_String_GetW(L"center", 6)) {
+        fLeft = pPiece->rtPiece.width / 2.0f;
+      } else if (dwAlgin == FX_HashCode_String_GetW(L"right", 5) ||
+                 dwAlgin == FX_HashCode_String_GetW(L"before", 6)) {
+        fLeft = pPiece->rtPiece.width;
+      } else if (dwAlgin == FX_HashCode_String_GetW(L"decimal", 7)) {
+        int32_t iChars = pPiece->iChars;
+        for (int32_t i = 0; i < iChars; i++) {
+          if (pPiece->pszText[i] == L'.') {
+            break;
+          }
+          fLeft += pPiece->pWidths[i] / 20000.0f;
+        }
+      }
+      m_pTabstopContext->m_fLeft =
+          std::min(fLeft, m_pTabstopContext->m_fTabWidth);
+      m_pTabstopContext->m_bTabstops = FALSE;
+      m_pTabstopContext->m_fTabWidth = 0;
+    }
+    pPiece->rtPiece.left -= m_pTabstopContext->m_fLeft;
+  }
+}
+void CXFA_TextLayout::AppendTextLine(FX_DWORD dwStatus,
+                                     FX_FLOAT& fLinePos,
+                                     FX_BOOL bSavePieces,
+                                     FX_BOOL bEndBreak) {
+  int32_t iPieces = m_pBreak->CountBreakPieces();
+  if (iPieces < 1) {
+    return;
+  }
+  IFDE_CSSComputedStyle* pStyle = NULL;
+  if (bSavePieces) {
+    CXFA_PieceLine* pPieceLine = FXTARGET_NewWith(m_pAllocator) CXFA_PieceLine;
+    m_pieceLines.Add(pPieceLine);
+    if (m_pTabstopContext) {
+      m_pTabstopContext->Reset();
+    }
+    FX_FLOAT fLineStep = 0, fBaseLine = 0;
+    int32_t i = 0;
+    for (i = 0; i < iPieces; i++) {
+      const CFX_RTFPiece* pPiece = m_pBreak->GetBreakPiece(i);
+      CXFA_TextUserData* pUserData = (CXFA_TextUserData*)pPiece->m_pUserData;
+      if (pUserData)
+        pStyle = pUserData->m_pStyle;
+      FX_FLOAT fVerScale = pPiece->m_iVerticalScale / 100.0f;
+      XFA_TextPiece* pTP = FXTARGET_NewWith(m_pAllocator) XFA_TextPiece();
+      pTP->pszText =
+          (FX_WCHAR*)m_pAllocator->Alloc(pPiece->m_iChars * sizeof(FX_WCHAR));
+      pTP->pWidths =
+          (int32_t*)m_pAllocator->Alloc(pPiece->m_iChars * sizeof(int32_t));
+      pTP->iChars = pPiece->m_iChars;
+      pPiece->GetString(pTP->pszText);
+      pPiece->GetWidths(pTP->pWidths);
+      pTP->iBidiLevel = pPiece->m_iBidiLevel;
+      pTP->iHorScale = pPiece->m_iHorizontalScale;
+      pTP->iVerScale = pPiece->m_iVerticalScale;
+      m_textParser.GetUnderline(m_pTextProvider, pStyle, pTP->iUnderline,
+                                pTP->iPeriod);
+      m_textParser.GetLinethrough(m_pTextProvider, pStyle, pTP->iLineThrough);
+      pTP->dwColor = m_textParser.GetColor(m_pTextProvider, pStyle);
+      pTP->pFont = m_textParser.GetFont(m_pTextProvider, pStyle);
+      pTP->fFontSize = m_textParser.GetFontSize(m_pTextProvider, pStyle);
+      pTP->rtPiece.left = pPiece->m_iStartPos / 20000.0f;
+      pTP->rtPiece.width = pPiece->m_iWidth / 20000.0f;
+      pTP->rtPiece.height = (FX_FLOAT)pPiece->m_iFontSize * fVerScale / 20.0f;
+      FX_FLOAT fBaseLineTemp =
+          m_textParser.GetBaseline(m_pTextProvider, pStyle);
+      pTP->rtPiece.top = fBaseLineTemp;
+      pPieceLine->m_textPieces.Add(pTP);
+      FX_FLOAT fLineHeight = m_textParser.GetLineHeight(
+          m_pTextProvider, pStyle, m_iLines == 0, fVerScale);
+      if (fBaseLineTemp > 0) {
+        FX_FLOAT fLineHeightTmp = fBaseLineTemp + pTP->rtPiece.height;
+        if (fLineHeight < fLineHeightTmp) {
+          fLineHeight = fLineHeightTmp;
+        } else {
+          fBaseLineTemp = 0;
+        }
+      } else if (fBaseLine < -fBaseLineTemp) {
+        fBaseLine = -fBaseLineTemp;
+      }
+      fLineStep = std::max(fLineStep, fLineHeight);
+      if (pUserData && pUserData->m_pLinkData) {
+        pUserData->m_pLinkData->AddRef();
+        pTP->pLinkData = pUserData->m_pLinkData;
+      } else {
+        pTP->pLinkData = NULL;
+      }
+      DoTabstops(pStyle, pPieceLine);
+    }
+    for (i = 0; i < iPieces; i++) {
+      XFA_TextPiece* pTP = pPieceLine->m_textPieces.GetAt(i);
+      FX_FLOAT& fTop = pTP->rtPiece.top;
+      FX_FLOAT fBaseLineTemp = fTop;
+      fTop = fLinePos + fLineStep - pTP->rtPiece.height - fBaseLineTemp;
+      fTop = std::max(0.0f, fTop);
+    }
+    fLinePos += fLineStep + fBaseLine;
+  } else {
+    FX_FLOAT fLineStep = 0;
+    FX_FLOAT fLineWidth = 0;
+    for (int32_t i = 0; i < iPieces; i++) {
+      const CFX_RTFPiece* pPiece = m_pBreak->GetBreakPiece(i);
+      CXFA_TextUserData* pUserData = (CXFA_TextUserData*)pPiece->m_pUserData;
+      if (pUserData)
+        pStyle = pUserData->m_pStyle;
+      FX_FLOAT fVerScale = pPiece->m_iVerticalScale / 100.0f;
+      FX_FLOAT fBaseLine = m_textParser.GetBaseline(m_pTextProvider, pStyle);
+      FX_FLOAT fLineHeight = m_textParser.GetLineHeight(
+          m_pTextProvider, pStyle, m_iLines == 0, fVerScale);
+      if (fBaseLine > 0) {
+        FX_FLOAT fLineHeightTmp =
+            fBaseLine + (FX_FLOAT)pPiece->m_iFontSize * fVerScale / 20.0f;
+        if (fLineHeight < fLineHeightTmp) {
+          fLineHeight = fLineHeightTmp;
+        }
+      }
+      fLineStep = std::max(fLineStep, fLineHeight);
+      fLineWidth += pPiece->m_iWidth / 20000.0f;
+    }
+    fLinePos += fLineStep;
+    m_fMaxWidth = std::max(m_fMaxWidth, fLineWidth);
+    if (m_pLoader && m_pLoader->m_bSaveLineHeight) {
+      FX_FLOAT fHeight = fLinePos - m_pLoader->m_fLastPos;
+      m_pLoader->m_fLastPos = fLinePos;
+      m_pLoader->m_lineHeights.Add(fHeight);
+    }
+  }
+  if (pStyle) {
+    pStyle->AddRef();
+  }
+  m_pBreak->ClearBreakPieces();
+  if (dwStatus == FX_RTFBREAK_ParagraphBreak) {
+    m_pBreak->Reset();
+    if (!pStyle && bEndBreak) {
+      CXFA_Para para = m_pTextProvider->GetParaNode();
+      if (para) {
+        FX_FLOAT fStartPos = para.GetMarginLeft();
+        FX_FLOAT fIndent = para.GetTextIndent();
+        if (fIndent > 0) {
+          fStartPos += fIndent;
+        }
+        FX_FLOAT fSpaceBelow = para.GetSpaceBelow();
+        if (fSpaceBelow < 0.1f) {
+          fSpaceBelow = 0;
+        }
+        m_pBreak->SetLineStartPos(fStartPos);
+        fLinePos += fSpaceBelow;
+      }
+    }
+  }
+  if (pStyle) {
+    FX_FLOAT fStart = 0;
+    const FDE_CSSRECT* pRect = pStyle->GetBoundaryStyles()->GetMarginWidth();
+    if (pRect) {
+      fStart = pRect->left.GetValue();
+    }
+    FX_FLOAT fTextIndent =
+        pStyle->GetParagraphStyles()->GetTextIndent().GetValue();
+    if (fTextIndent < 0) {
+      fStart -= fTextIndent;
+    }
+    m_pBreak->SetLineStartPos(fStart);
+    pStyle->Release();
+  }
+  m_iLines++;
+}
+void CXFA_TextLayout::RenderString(IFDE_RenderDevice* pDevice,
+                                   IFDE_SolidBrush* pBrush,
+                                   CXFA_PieceLine* pPieceLine,
+                                   int32_t iPiece,
+                                   FXTEXT_CHARPOS* pCharPos,
+                                   const CFX_Matrix& tmDoc2Device) {
+  const XFA_TextPiece* pPiece = pPieceLine->m_textPieces.GetAt(iPiece);
+  int32_t iCount = GetDisplayPos(pPiece, pCharPos);
+  if (iCount > 0) {
+    pBrush->SetColor(pPiece->dwColor);
+    pDevice->DrawString(pBrush, pPiece->pFont, pCharPos, iCount,
+                        pPiece->fFontSize, &tmDoc2Device);
+  }
+  pPieceLine->m_charCounts.Add(iCount);
+}
+void CXFA_TextLayout::RenderPath(IFDE_RenderDevice* pDevice,
+                                 IFDE_Pen* pPen,
+                                 CXFA_PieceLine* pPieceLine,
+                                 int32_t iPiece,
+                                 FXTEXT_CHARPOS* pCharPos,
+                                 const CFX_Matrix& tmDoc2Device) {
+  XFA_TextPiece* pPiece = pPieceLine->m_textPieces.GetAt(iPiece);
+  FX_BOOL bNoUnderline = pPiece->iUnderline < 1 || pPiece->iUnderline > 2;
+  FX_BOOL bNoLineThrough = pPiece->iLineThrough < 1 || pPiece->iLineThrough > 2;
+  if (bNoUnderline && bNoLineThrough) {
+    return;
+  }
+  pPen->SetColor(pPiece->dwColor);
+  IFDE_Path* pPath = IFDE_Path::Create();
+  int32_t iChars = GetDisplayPos(pPiece, pCharPos);
+  if (iChars > 0) {
+    CFX_PointF pt1, pt2;
+    FX_FLOAT fEndY = pCharPos[0].m_OriginY + 1.05f;
+    int32_t i = 0;
+    if (pPiece->iPeriod == XFA_ATTRIBUTEENUM_Word) {
+      for (int32_t i = 0; i < pPiece->iUnderline; i++) {
+        for (int32_t j = 0; j < iChars; j++) {
+          pt1.x = pCharPos[j].m_OriginX;
+          pt2.x =
+              pt1.x + pCharPos[j].m_FontCharWidth * pPiece->fFontSize / 1000.0f;
+          pt1.y = pt2.y = fEndY;
+          pPath->AddLine(pt1, pt2);
+        }
+        fEndY += 2.0f;
+      }
+    } else {
+      pt1.x = pCharPos[0].m_OriginX;
+      pt2.x =
+          pCharPos[iChars - 1].m_OriginX +
+          pCharPos[iChars - 1].m_FontCharWidth * pPiece->fFontSize / 1000.0f;
+      for (int32_t i = 0; i < pPiece->iUnderline; i++) {
+        pt1.y = pt2.y = fEndY;
+        pPath->AddLine(pt1, pt2);
+        fEndY += 2.0f;
+      }
+    }
+    fEndY = pCharPos[0].m_OriginY - pPiece->rtPiece.height * 0.25f;
+    pt1.x = pCharPos[0].m_OriginX;
+    pt2.x = pCharPos[iChars - 1].m_OriginX +
+            pCharPos[iChars - 1].m_FontCharWidth * pPiece->fFontSize / 1000.0f;
+    for (i = 0; i < pPiece->iLineThrough; i++) {
+      pt1.y = pt2.y = fEndY;
+      pPath->AddLine(pt1, pt2);
+      fEndY += 2.0f;
+    }
+  } else {
+    if (bNoLineThrough &&
+        (bNoUnderline || pPiece->iPeriod != XFA_ATTRIBUTEENUM_All)) {
+      goto XFA_RenderPathRet;
+    }
+    int32_t iCharsTmp = 0;
+    int32_t iPiecePrev = iPiece, iPieceNext = iPiece;
+    while (iPiecePrev > 0) {
+      iPiecePrev--;
+      iCharsTmp = pPieceLine->m_charCounts.GetAt(iPiecePrev);
+      if (iCharsTmp > 0) {
+        break;
+      }
+    }
+    if (iCharsTmp == 0) {
+      goto XFA_RenderPathRet;
+    }
+    iCharsTmp = 0;
+    int32_t iPieces = pPieceLine->m_textPieces.GetSize();
+    while (iPieceNext < iPieces - 1) {
+      iPieceNext++;
+      iCharsTmp = pPieceLine->m_charCounts.GetAt(iPieceNext);
+      if (iCharsTmp > 0) {
+        break;
+      }
+    }
+    if (iCharsTmp == 0) {
+      goto XFA_RenderPathRet;
+    }
+    FX_FLOAT fOrgX = 0.0f, fEndX = 0.0f;
+    pPiece = pPieceLine->m_textPieces.GetAt(iPiecePrev);
+    iChars = GetDisplayPos(pPiece, pCharPos);
+    if (iChars < 1) {
+      goto XFA_RenderPathRet;
+    }
+    fOrgX = pCharPos[iChars - 1].m_OriginX +
+            pCharPos[iChars - 1].m_FontCharWidth * pPiece->fFontSize / 1000.0f;
+    pPiece = pPieceLine->m_textPieces.GetAt(iPieceNext);
+    iChars = GetDisplayPos(pPiece, pCharPos);
+    if (iChars < 1) {
+      goto XFA_RenderPathRet;
+    }
+    fEndX = pCharPos[0].m_OriginX;
+    CFX_PointF pt1, pt2;
+    pt1.x = fOrgX, pt2.x = fEndX;
+    FX_FLOAT fEndY = pCharPos[0].m_OriginY + 1.05f;
+    int32_t i = 0;
+    for (i = 0; i < pPiece->iUnderline; i++) {
+      pt1.y = pt2.y = fEndY;
+      pPath->AddLine(pt1, pt2);
+      fEndY += 2.0f;
+    }
+    fEndY = pCharPos[0].m_OriginY - pPiece->rtPiece.height * 0.25f;
+    for (i = 0; i < pPiece->iLineThrough; i++) {
+      pt1.y = pt2.y = fEndY;
+      pPath->AddLine(pt1, pt2);
+      fEndY += 2.0f;
+    }
+  }
+  pDevice->DrawPath(pPen, 1, pPath, &tmDoc2Device);
+XFA_RenderPathRet:
+  pPath->Release();
+}
+int32_t CXFA_TextLayout::GetDisplayPos(const XFA_TextPiece* pPiece,
+                                       FXTEXT_CHARPOS* pCharPos,
+                                       FX_BOOL bCharCode) {
+  if (pPiece == NULL) {
+    return 0;
+  }
+  FX_RTFTEXTOBJ tr;
+  if (!ToRun(pPiece, tr)) {
+    return 0;
+  }
+  return m_pBreak->GetDisplayPos(&tr, pCharPos, bCharCode);
+}
+FX_BOOL CXFA_TextLayout::ToRun(const XFA_TextPiece* pPiece, FX_RTFTEXTOBJ& tr) {
+  int32_t iLength = pPiece->iChars;
+  if (iLength < 1) {
+    return FALSE;
+  }
+  tr.pStr = pPiece->pszText;
+  tr.pFont = pPiece->pFont;
+  tr.pRect = &pPiece->rtPiece;
+  tr.pWidths = pPiece->pWidths;
+  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;
+}