| // 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/cfde_path.h" |
| #include "xfa/fde/css/fde_csscache.h" |
| #include "xfa/fde/css/fde_cssstyleselector.h" |
| #include "xfa/fde/fde_gedevice.h" |
| #include "xfa/fde/fde_object.h" |
| #include "xfa/fde/xml/fde_xml_imp.h" |
| #include "xfa/fgas/crt/fgas_codepage.h" |
| #include "xfa/fxfa/app/xfa_ffwidgetacc.h" |
| #include "xfa/fxfa/include/xfa_ffapp.h" |
| #include "xfa/fxfa/include/xfa_ffdoc.h" |
| #include "xfa/fxfa/include/xfa_fontmgr.h" |
| |
| CXFA_CSSTagProvider::CXFA_CSSTagProvider() |
| : m_bTagAvailable(FALSE), m_bContent(FALSE) {} |
| |
| CXFA_CSSTagProvider::~CXFA_CSSTagProvider() {} |
| |
| XFA_TextPiece::XFA_TextPiece() |
| : pszText(nullptr), pFont(nullptr), pLinkData(nullptr) {} |
| |
| XFA_TextPiece::~XFA_TextPiece() { |
| if (pLinkData) |
| pLinkData->Release(); |
| } |
| |
| CXFA_TextParseContext::CXFA_TextParseContext() |
| : m_pParentStyle(nullptr), |
| m_ppMatchedDecls(nullptr), |
| m_dwMatchedDecls(0), |
| m_eDisplay(FDE_CSSDISPLAY_None) {} |
| |
| CXFA_TextParseContext::~CXFA_TextParseContext() { |
| if (m_pParentStyle) |
| m_pParentStyle->Release(); |
| FX_Free(m_ppMatchedDecls); |
| } |
| |
| void CXFA_TextParseContext::SetDecls(const CFDE_CSSDeclaration** ppDeclArray, |
| int32_t iDeclCount) { |
| if (iDeclCount <= 0 || !ppDeclArray) |
| return; |
| |
| m_dwMatchedDecls = iDeclCount; |
| m_ppMatchedDecls = FX_Alloc(CFDE_CSSDeclaration*, iDeclCount); |
| FXSYS_memcpy(m_ppMatchedDecls, ppDeclArray, |
| iDeclCount * sizeof(CFDE_CSSDeclaration*)); |
| } |
| |
| CXFA_TextParser::CXFA_TextParser() : m_pUASheet(nullptr) {} |
| |
| CXFA_TextParser::~CXFA_TextParser() { |
| if (m_pUASheet) |
| m_pUASheet->Release(); |
| |
| FX_POSITION ps = m_mapXMLNodeToParseContext.GetStartPosition(); |
| while (ps) { |
| CFDE_XMLNode* pXMLNode; |
| CXFA_TextParseContext* pParseContext; |
| m_mapXMLNodeToParseContext.GetNextAssoc(ps, pXMLNode, pParseContext); |
| if (pParseContext) |
| FXTARGET_DeleteWith(CXFA_TextParseContext, m_pAllocator.get(), |
| pParseContext); |
| } |
| m_mapXMLNodeToParseContext.RemoveAll(); |
| } |
| void CXFA_TextParser::Reset() { |
| FX_POSITION ps = m_mapXMLNodeToParseContext.GetStartPosition(); |
| while (ps) { |
| CFDE_XMLNode* pXMLNode; |
| CXFA_TextParseContext* pParseContext; |
| m_mapXMLNodeToParseContext.GetNextAssoc(ps, pXMLNode, pParseContext); |
| if (pParseContext) |
| FXTARGET_DeleteWith(CXFA_TextParseContext, m_pAllocator.get(), |
| pParseContext); |
| } |
| m_mapXMLNodeToParseContext.RemoveAll(); |
| m_pAllocator.reset(); |
| } |
| void CXFA_TextParser::InitCSSData(CXFA_TextProvider* pTextProvider) { |
| if (!pTextProvider) |
| return; |
| |
| if (!m_pSelector) { |
| CXFA_FFDoc* pDoc = pTextProvider->GetDocNode(); |
| IFGAS_FontMgr* pFontMgr = pDoc->GetApp()->GetFDEFontMgr(); |
| ASSERT(pFontMgr); |
| m_pSelector.reset(new CFDE_CSSStyleSelector); |
| 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) { |
| m_pUASheet = LoadDefaultSheetStyle(); |
| m_pSelector->SetStyleSheet(FDE_CSSSTYLESHEETGROUP_UserAgent, m_pUASheet); |
| m_pSelector->UpdateStyleIndex(FDE_CSSMEDIATYPE_ALL); |
| } |
| } |
| |
| CXFA_LoaderContext::CXFA_LoaderContext() |
| : m_bSaveLineHeight(FALSE), |
| m_fWidth(0), |
| m_fHeight(0), |
| m_fLastPos(0), |
| m_fStartLineOffset(0), |
| m_iChar(0), |
| m_iTotalLines(-1), |
| m_pXMLNode(nullptr), |
| m_pNode(nullptr), |
| m_pParentStyle(nullptr), |
| m_dwFlags(0) {} |
| |
| CXFA_LoaderContext::~CXFA_LoaderContext() {} |
| |
| 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( |
| CXFA_TextProvider* pTextProvider) { |
| CXFA_Font font = pTextProvider->GetFontNode(); |
| CXFA_Para para = pTextProvider->GetParaNode(); |
| IFDE_CSSComputedStyle* pStyle = m_pSelector->CreateComputedStyle(nullptr); |
| 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 hAlign = FDE_CSSTEXTALIGN_Left; |
| switch (para.GetHorizontalAlign()) { |
| case XFA_ATTRIBUTEENUM_Center: |
| hAlign = FDE_CSSTEXTALIGN_Center; |
| break; |
| case XFA_ATTRIBUTEENUM_Right: |
| hAlign = FDE_CSSTEXTALIGN_Right; |
| break; |
| case XFA_ATTRIBUTEENUM_Justify: |
| hAlign = FDE_CSSTEXTALIGN_Justify; |
| break; |
| case XFA_ATTRIBUTEENUM_JustifyAll: |
| hAlign = FDE_CSSTEXTALIGN_JustifyAll; |
| break; |
| } |
| pParaStyle->SetTextAlign(hAlign); |
| 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); |
| uint32_t 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); |
| ASSERT(pNewStyle); |
| if (pParentStyle) { |
| IFDE_CSSParagraphStyle* pParaStyle = pParentStyle->GetParagraphStyles(); |
| uint32_t 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( |
| 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->Retain(); |
| CXFA_CSSTagProvider tagProvider; |
| ParseTagInfo(pXMLNode, tagProvider); |
| if (tagProvider.m_bContent) |
| return nullptr; |
| IFDE_CSSComputedStyle* pStyle = CreateStyle(pParentStyle); |
| CFDE_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, |
| CXFA_TextProvider* pTextProvider) { |
| if (!pXMLContainer || !pTextProvider || m_pAllocator) { |
| return; |
| } |
| m_pAllocator.reset(IFX_MemoryAllocator::Create(FX_ALLOCTYPE_Fixed, 32, |
| sizeof(CXFA_CSSTagProvider))); |
| InitCSSData(pTextProvider); |
| IFDE_CSSComputedStyle* pRootStyle = CreateRootStyle(pTextProvider); |
| ParseRichText(pXMLContainer, pRootStyle); |
| pRootStyle->Release(); |
| } |
| void CXFA_TextParser::ParseRichText(CFDE_XMLNode* pXMLNode, |
| IFDE_CSSComputedStyle* pParentStyle) { |
| if (!pXMLNode) |
| return; |
| |
| CXFA_CSSTagProvider tagProvider; |
| ParseTagInfo(pXMLNode, tagProvider); |
| if (!tagProvider.m_bTagAvailable) |
| return; |
| |
| IFDE_CSSComputedStyle* pNewStyle = nullptr; |
| if ((tagProvider.GetTagName() != FX_WSTRC(L"body")) || |
| (tagProvider.GetTagName() != FX_WSTRC(L"html"))) { |
| CXFA_TextParseContext* pTextContext = |
| FXTARGET_NewWith(m_pAllocator.get()) CXFA_TextParseContext; |
| FDE_CSSDISPLAY eDisplay = FDE_CSSDISPLAY_Inline; |
| if (!tagProvider.m_bContent) { |
| pNewStyle = CreateStyle(pParentStyle); |
| CFDE_CSSAccelerator* pCSSAccel = m_pSelector->InitAccelerator(); |
| pCSSAccel->OnEnterTag(&tagProvider); |
| CFDE_CSSDeclarationArray DeclArray; |
| int32_t iMatchedDecls = |
| m_pSelector->MatchDeclarations(&tagProvider, DeclArray); |
| const CFDE_CSSDeclaration** ppMatchDecls = |
| const_cast<const CFDE_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 (CFDE_XMLNode* pXMLChild = |
| pXMLNode->GetNodeItem(CFDE_XMLNode::FirstChild); |
| pXMLChild; |
| pXMLChild = pXMLChild->GetNodeItem(CFDE_XMLNode::NextSibling)) { |
| ParseRichText(pXMLChild, pNewStyle); |
| } |
| if (pNewStyle) |
| pNewStyle->Release(); |
| } |
| |
| bool CXFA_TextParser::TagValidate(const CFX_WideString& wsName) const { |
| static const uint32_t s_XFATagName[] = { |
| 0x61, // a |
| 0x62, // b |
| 0x69, // i |
| 0x70, // p |
| 0x0001f714, // br |
| 0x00022a55, // li |
| 0x000239bb, // ol |
| 0x00025881, // ul |
| 0x0bd37faa, // sub |
| 0x0bd37fb8, // sup |
| 0xa73e3af2, // span |
| 0xb182eaae, // body |
| 0xdb8ac455, // html |
| }; |
| static const int32_t s_iCount = FX_ArraySize(s_XFATagName); |
| |
| return std::binary_search(s_XFATagName, s_XFATagName + s_iCount, |
| FX_HashCode_GetW(wsName.AsStringC(), true)); |
| } |
| |
| void CXFA_TextParser::ParseTagInfo(CFDE_XMLNode* pXMLNode, |
| CXFA_CSSTagProvider& tagProvider) { |
| CFX_WideString wsName; |
| if (pXMLNode->GetType() == FDE_XMLNODE_Element) { |
| CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLNode); |
| pXMLElement->GetLocalTagName(wsName); |
| tagProvider.SetTagNameObj(wsName); |
| tagProvider.m_bTagAvailable = TagValidate(wsName); |
| |
| CFX_WideString wsValue; |
| pXMLElement->GetString(L"style", wsValue); |
| if (!wsValue.IsEmpty()) { |
| tagProvider.SetAttribute(L"style", wsValue); |
| } |
| } else if (pXMLNode->GetType() == FDE_XMLNODE_Text) { |
| tagProvider.m_bTagAvailable = TRUE; |
| tagProvider.m_bContent = TRUE; |
| } |
| } |
| |
| int32_t CXFA_TextParser::GetVAlign(CXFA_TextProvider* pTextProvider) const { |
| CXFA_Para para = pTextProvider->GetParaNode(); |
| return para ? para.GetVerticalAlign() : XFA_ATTRIBUTEENUM_Top; |
| } |
| |
| FX_FLOAT CXFA_TextParser::GetTabInterval(IFDE_CSSComputedStyle* pStyle) const { |
| CFX_WideString wsValue; |
| if (pStyle && pStyle->GetCustomStyle(FX_WSTRC(L"tab-interval"), wsValue)) |
| return CXFA_Measurement(wsValue.AsStringC()).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; |
| } |
| CFGAS_GEFont* 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()) { |
| 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(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(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(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(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(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(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(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(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(CXFA_TextProvider* pTextProvider, |
| CFDE_XMLNode* pXMLNode, |
| CFX_WideString& wsValue) { |
| wsValue.clear(); |
| if (!pXMLNode) { |
| return FALSE; |
| } |
| FX_BOOL bRet = FALSE; |
| if (pXMLNode->GetType() == FDE_XMLNODE_Element) { |
| CFDE_XMLElement* pElement = static_cast<CFDE_XMLElement*>(pXMLNode); |
| CFX_WideString wsAttr; |
| pElement->GetString(L"xfa:embed", wsAttr); |
| if (wsAttr.IsEmpty()) { |
| return FALSE; |
| } |
| if (wsAttr.GetAt(0) == L'#') { |
| wsAttr.Delete(0); |
| } |
| CFX_WideString ws; |
| pElement->GetString(L"xfa:embedType", 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.clear(); |
| pElement->GetString(L"xfa:embedMode", 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( |
| 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, |
| XFA_TABSTOPSSTATUS_Location, |
| }; |
| FX_BOOL CXFA_TextParser::GetTabstops( |
| IFDE_CSSComputedStyle* pStyle, |
| CXFA_TextTabstopsContext* pTabstopContext) { |
| if (!pStyle || !pTabstopContext) { |
| 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.c_str(); |
| 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 == ' ') { |
| uint32_t dwHashCode = FX_HashCode_GetW(wsAlign.AsStringC(), true); |
| CXFA_Measurement ms(CFX_WideStringC(pTabStops + iLast, iCur - iLast)); |
| FX_FLOAT fPos = ms.ToUnit(XFA_UNIT_Pt); |
| pTabstopContext->Append(dwHashCode, fPos); |
| wsAlign.clear(); |
| eStatus = XFA_TABSTOPSSTATUS_None; |
| } |
| iCur++; |
| break; |
| default: |
| break; |
| } |
| } |
| if (!wsAlign.IsEmpty()) { |
| uint32_t dwHashCode = FX_HashCode_GetW(wsAlign.AsStringC(), 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(CXFA_TextProvider* pTextProvider) |
| : m_bHasBlock(FALSE), |
| m_pTextProvider(pTextProvider), |
| m_pTextDataNode(nullptr), |
| m_bRichText(FALSE), |
| m_iLines(0), |
| m_fMaxWidth(0), |
| m_bBlockContinue(TRUE) { |
| ASSERT(m_pTextProvider); |
| } |
| CXFA_TextLayout::~CXFA_TextLayout() { |
| m_textParser.Reset(); |
| 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.get(), pLine); |
| } |
| m_pieceLines.RemoveAll(); |
| m_pBreak.reset(); |
| m_pAllocator.reset(); |
| } |
| const CXFA_PieceLineArray* CXFA_TextLayout::GetPieceLines() { |
| return &m_pieceLines; |
| } |
| void CXFA_TextLayout::GetTextDataNode() { |
| if (!m_pTextProvider) { |
| return; |
| } |
| CXFA_Node* pNode = m_pTextProvider->GetTextNode(m_bRichText); |
| if (pNode && m_bRichText) { |
| m_textParser.Reset(); |
| } |
| m_pTextDataNode = pNode; |
| } |
| CFDE_XMLNode* CXFA_TextLayout::GetXMLContainerNode() { |
| CFDE_XMLNode* pXMLContainer = nullptr; |
| if (m_bRichText) { |
| CFDE_XMLNode* pXMLRoot = m_pTextDataNode->GetXMLMappingNode(); |
| if (!pXMLRoot) { |
| return pXMLContainer; |
| } |
| for (CFDE_XMLNode* pXMLChild = |
| pXMLRoot->GetNodeItem(CFDE_XMLNode::FirstChild); |
| pXMLChild; |
| pXMLChild = pXMLChild->GetNodeItem(CFDE_XMLNode::NextSibling)) { |
| if (pXMLChild->GetType() == FDE_XMLNODE_Element) { |
| CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLChild); |
| CFX_WideString wsTag; |
| pXMLElement->GetLocalTagName(wsTag); |
| if (wsTag == FX_WSTRC(L"body") || wsTag == FX_WSTRC(L"html")) { |
| pXMLContainer = pXMLChild; |
| break; |
| } |
| } |
| } |
| } |
| return pXMLContainer; |
| } |
| CFX_RTFBreak* CXFA_TextLayout::CreateBreak(FX_BOOL bDefault) { |
| uint32_t dwStyle = FX_RTFLAYOUTSTYLE_ExpandTab; |
| if (!bDefault) { |
| dwStyle |= FX_RTFLAYOUTSTYLE_Pagination; |
| } |
| CFX_RTFBreak* pBreak = new CFX_RTFBreak(0); |
| pBreak->SetLayoutStyles(dwStyle); |
| pBreak->SetLineBreakChar(L'\n'); |
| pBreak->SetLineBreakTolerance(1); |
| pBreak->SetFont(m_textParser.GetFont(m_pTextProvider, nullptr)); |
| pBreak->SetFontSize(m_textParser.GetFontSize(m_pTextProvider, nullptr)); |
| 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, nullptr); |
| m_pBreak->SetFontSize(fFontSize); |
| m_pBreak->SetFont(m_textParser.GetFont(m_pTextProvider, nullptr)); |
| m_pBreak->SetLineBreakTolerance(fFontSize * 0.2f); |
| } |
| void CXFA_TextLayout::InitBreak(IFDE_CSSComputedStyle* pStyle, |
| FDE_CSSDISPLAY eDisplay, |
| FX_FLOAT fLineWidth, |
| CFDE_XMLNode* pXMLNode, |
| IFDE_CSSComputedStyle* pParentStyle) { |
| if (!pStyle) { |
| 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) |
| m_pTabstopContext.reset(new CXFA_TextTabstopsContext); |
| m_textParser.GetTabstops(pStyle, m_pTabstopContext.get()); |
| 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.clear(); |
| if (m_bRichText) { |
| } else { |
| wsText = m_pTextDataNode->GetContent(); |
| } |
| return wsText.GetLength(); |
| } |
| FX_FLOAT CXFA_TextLayout::GetLayoutHeight() { |
| if (!m_pLoader) { |
| 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) |
| m_pLoader.reset(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) { |
| 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.GetVAlign(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; |
| |
| m_pBreak.reset(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, nullptr); |
| |
| m_pTabstopContext.reset(); |
| 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.reset(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); |
| m_pTabstopContext.reset(); |
| if (fHeight) |
| *fHeight = fLinePos; |
| return TRUE; |
| } |
| |
| FX_BOOL CXFA_TextLayout::Layout(int32_t iBlock) { |
| if (!m_pLoader || 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 = nullptr; |
| 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.reset(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) { |
| CFDE_XMLNode* pContainerNode = GetXMLContainerNode(); |
| if (!pContainerNode) { |
| return TRUE; |
| } |
| CFDE_XMLNode* pXMLNode = m_pLoader->m_pXMLNode; |
| if (!pXMLNode) |
| return TRUE; |
| CFDE_XMLNode* pSaveXMLNode = m_pLoader->m_pXMLNode; |
| for (; pXMLNode; |
| pXMLNode = pXMLNode->GetNodeItem(CFDE_XMLNode::NextSibling)) { |
| if (!LoadRichText(pXMLNode, szText, fLinePos, m_pLoader->m_pParentStyle, |
| TRUE)) { |
| break; |
| } |
| } |
| while (!pXMLNode) { |
| pXMLNode = pSaveXMLNode->GetNodeItem(CFDE_XMLNode::Parent); |
| if (pXMLNode == pContainerNode) |
| break; |
| if (!LoadRichText(pXMLNode, szText, fLinePos, m_pLoader->m_pParentStyle, |
| TRUE, nullptr, FALSE)) { |
| break; |
| } |
| pSaveXMLNode = pXMLNode; |
| pXMLNode = pXMLNode->GetNodeItem(CFDE_XMLNode::NextSibling); |
| if (!pXMLNode) |
| continue; |
| for (; pXMLNode; |
| pXMLNode = pXMLNode->GetNodeItem(CFDE_XMLNode::NextSibling)) { |
| if (!LoadRichText(pXMLNode, szText, fLinePos, |
| m_pLoader->m_pParentStyle, TRUE)) { |
| break; |
| } |
| } |
| } |
| } else { |
| pNode = m_pLoader->m_pNode; |
| if (!pNode) |
| return TRUE; |
| LoadText(pNode, szText, fLinePos, TRUE); |
| } |
| } |
| if (iBlock == iCount) { |
| m_pTabstopContext.reset(); |
| m_pLoader.reset(); |
| } |
| 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) { |
| if (!pFxDevice) |
| return FALSE; |
| |
| std::unique_ptr<CFDE_RenderDevice> pDevice( |
| new CFDE_RenderDevice(pFxDevice, FALSE)); |
| pDevice->SaveState(); |
| pDevice->SetClipRect(rtClip); |
| |
| std::unique_ptr<CFDE_Brush> pSolidBrush(new CFDE_Brush); |
| std::unique_ptr<CFDE_Pen> pPen(new CFDE_Pen); |
| if (m_pieceLines.GetSize() == 0) { |
| int32_t iBlockCount = CountBlocks(); |
| for (int32_t i = 0; i < iBlockCount; i++) { |
| Layout(i); |
| } |
| } |
| FXTEXT_CHARPOS* pCharPos = nullptr; |
| 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.get(), pSolidBrush.get(), pPieceLine, j, pCharPos, |
| tmDoc2Device); |
| } |
| for (j = 0; j < iPieces; j++) { |
| RenderPath(pDevice.get(), pPen.get(), pPieceLine, j, pCharPos, |
| tmDoc2Device); |
| } |
| } |
| pDevice->RestoreState(); |
| FX_Free(pCharPos); |
| return iPieceLines; |
| } |
| void CXFA_TextLayout::UpdateAlign(FX_FLOAT fHeight, FX_FLOAT fBottom) { |
| fHeight -= fBottom; |
| if (fHeight < 0.1f) { |
| return; |
| } |
| switch (m_textParser.GetVAlign(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) { |
| m_pAllocator.reset( |
| IFX_MemoryAllocator::Create(FX_ALLOCTYPE_Static, 256, 0)); |
| } |
| GetTextDataNode(); |
| if (!m_pTextDataNode) |
| return TRUE; |
| |
| if (m_bRichText) { |
| 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 { |
| 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(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) { |
| 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 = nullptr; |
| CFX_WideString wsName; |
| if (bEndBreak) { |
| FX_BOOL bCurOl = FALSE; |
| FX_BOOL bCurLi = FALSE; |
| CFDE_XMLElement* pElement = nullptr; |
| 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 = 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 && |
| 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; |
| ASSERT(pElement); |
| pElement->GetString(L"href", wsLinkContent); |
| if (!wsLinkContent.IsEmpty()) { |
| pLinkData = FXTARGET_NewWith(m_pAllocator.get()) CXFA_LinkUserData( |
| m_pAllocator.get(), |
| 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) { |
| 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) { |
| 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 || m_pLoader->m_iChar == 0) { |
| if (pLinkData) { |
| pLinkData->Retain(); |
| } |
| CXFA_TextUserData* pUserData = FXTARGET_NewWith(m_pAllocator.get()) |
| CXFA_TextUserData(m_pAllocator.get(), |
| 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 (CFDE_XMLNode* pChildNode = |
| pXMLNode->GetNodeItem(CFDE_XMLNode::FirstChild); |
| pChildNode; |
| 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; |
| } |
| } |
| 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) { |
| uint32_t 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(CFDE_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) { |
| uint32_t 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(uint32_t 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 || m_pTabstopContext->m_iTabCount == 0) { |
| return; |
| } |
| if (!pStyle || !pPieceLine) { |
| 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); |
| uint32_t dwAlign = pTabstops->dwAlign; |
| if (dwAlign == FX_HashCode_GetW(L"center", false)) { |
| fLeft = pPiece->rtPiece.width / 2.0f; |
| } else if (dwAlign == FX_HashCode_GetW(L"right", false) || |
| dwAlign == FX_HashCode_GetW(L"before", false)) { |
| fLeft = pPiece->rtPiece.width; |
| } else if (dwAlign == FX_HashCode_GetW(L"decimal", false)) { |
| 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(uint32_t dwStatus, |
| FX_FLOAT& fLinePos, |
| FX_BOOL bSavePieces, |
| FX_BOOL bEndBreak) { |
| int32_t iPieces = m_pBreak->CountBreakPieces(); |
| if (iPieces < 1) { |
| return; |
| } |
| IFDE_CSSComputedStyle* pStyle = nullptr; |
| if (bSavePieces) { |
| CXFA_PieceLine* pPieceLine = |
| FXTARGET_NewWith(m_pAllocator.get()) 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.get()) 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->Retain(); |
| pTP->pLinkData = pUserData->m_pLinkData; |
| } else { |
| pTP->pLinkData = nullptr; |
| } |
| 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->Retain(); |
| } |
| 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(CFDE_RenderDevice* pDevice, |
| CFDE_Brush* 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(CFDE_RenderDevice* pDevice, |
| CFDE_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); |
| std::unique_ptr<CFDE_Path> pPath(new CFDE_Path); |
| int32_t iChars = GetDisplayPos(pPiece, pCharPos); |
| if (iChars > 0) { |
| CFX_PointF pt1, pt2; |
| FX_FLOAT fEndY = pCharPos[0].m_OriginY + 1.05f; |
| 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 (int32_t 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)) { |
| return; |
| } |
| 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) { |
| return; |
| } |
| 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) { |
| return; |
| } |
| FX_FLOAT fOrgX = 0.0f, fEndX = 0.0f; |
| pPiece = pPieceLine->m_textPieces.GetAt(iPiecePrev); |
| iChars = GetDisplayPos(pPiece, pCharPos); |
| if (iChars < 1) { |
| return; |
| } |
| 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) { |
| return; |
| } |
| fEndX = pCharPos[0].m_OriginX; |
| CFX_PointF pt1, pt2; |
| pt1.x = fOrgX, pt2.x = fEndX; |
| FX_FLOAT fEndY = pCharPos[0].m_OriginY + 1.05f; |
| 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; |
| for (int32_t i = 0; i < pPiece->iLineThrough; i++) { |
| pt1.y = pt2.y = fEndY; |
| pPath->AddLine(pt1, pt2); |
| fEndY += 2.0f; |
| } |
| } |
| pDevice->DrawPath(pPen, 1, pPath.get(), &tmDoc2Device); |
| } |
| |
| int32_t CXFA_TextLayout::GetDisplayPos(const XFA_TextPiece* pPiece, |
| FXTEXT_CHARPOS* pCharPos, |
| FX_BOOL bCharCode) { |
| if (!pPiece) { |
| 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; |
| } |
| |
| CXFA_LinkUserData::CXFA_LinkUserData(IFX_MemoryAllocator* pAllocator, |
| FX_WCHAR* pszText) |
| : m_pAllocator(pAllocator), m_dwRefCount(1), m_wsURLContent(pszText) {} |
| |
| CXFA_LinkUserData::~CXFA_LinkUserData() {} |
| |
| uint32_t CXFA_LinkUserData::Retain() { |
| return ++m_dwRefCount; |
| } |
| |
| uint32_t CXFA_LinkUserData::Release() { |
| uint32_t dwRefCount = --m_dwRefCount; |
| if (dwRefCount <= 0) |
| FXTARGET_DeleteWith(CXFA_LinkUserData, m_pAllocator, this); |
| return dwRefCount; |
| } |
| |
| const FX_WCHAR* CXFA_LinkUserData::GetLinkURL() { |
| return m_wsURLContent.c_str(); |
| } |
| |
| CXFA_TextUserData::CXFA_TextUserData(IFX_MemoryAllocator* pAllocator, |
| IFDE_CSSComputedStyle* pStyle) |
| : m_pStyle(pStyle), |
| m_pLinkData(nullptr), |
| m_pAllocator(pAllocator), |
| m_dwRefCount(0) { |
| ASSERT(m_pAllocator); |
| if (m_pStyle) |
| m_pStyle->Retain(); |
| } |
| |
| CXFA_TextUserData::CXFA_TextUserData(IFX_MemoryAllocator* pAllocator, |
| IFDE_CSSComputedStyle* pStyle, |
| CXFA_LinkUserData* pLinkData) |
| : m_pStyle(pStyle), |
| m_pLinkData(pLinkData), |
| m_pAllocator(pAllocator), |
| m_dwRefCount(0) { |
| ASSERT(m_pAllocator); |
| if (m_pStyle) |
| m_pStyle->Retain(); |
| } |
| |
| CXFA_TextUserData::~CXFA_TextUserData() { |
| if (m_pStyle) |
| m_pStyle->Release(); |
| if (m_pLinkData) |
| m_pLinkData->Release(); |
| } |
| |
| uint32_t CXFA_TextUserData::Retain() { |
| return ++m_dwRefCount; |
| } |
| |
| uint32_t CXFA_TextUserData::Release() { |
| uint32_t dwRefCount = --m_dwRefCount; |
| if (dwRefCount == 0) |
| FXTARGET_DeleteWith(CXFA_TextUserData, m_pAllocator, this); |
| return dwRefCount; |
| } |
| |
| CXFA_PieceLine::CXFA_PieceLine() {} |
| |
| CXFA_PieceLine::~CXFA_PieceLine() {} |
| |
| CXFA_TextTabstopsContext::CXFA_TextTabstopsContext() |
| : m_iTabCount(0), |
| m_iTabIndex(-1), |
| m_bTabstops(FALSE), |
| m_fTabWidth(0), |
| m_fLeft(0) {} |
| |
| CXFA_TextTabstopsContext::~CXFA_TextTabstopsContext() {} |
| |
| void CXFA_TextTabstopsContext::Append(uint32_t dwAlign, FX_FLOAT fTabstops) { |
| int32_t i = 0; |
| for (i = 0; i < m_iTabCount; i++) { |
| XFA_TABSTOPS* pTabstop = m_tabstops.GetDataPtr(i); |
| if (fTabstops < pTabstop->fTabstops) { |
| break; |
| } |
| } |
| m_tabstops.InsertSpaceAt(i, 1); |
| XFA_TABSTOPS tabstop; |
| tabstop.dwAlign = dwAlign; |
| tabstop.fTabstops = fTabstops; |
| m_tabstops.SetAt(i, tabstop); |
| m_iTabCount++; |
| } |
| |
| void CXFA_TextTabstopsContext::RemoveAll() { |
| m_tabstops.RemoveAll(); |
| m_iTabCount = 0; |
| } |
| |
| void CXFA_TextTabstopsContext::Reset() { |
| m_iTabIndex = -1; |
| m_bTabstops = FALSE; |
| m_fTabWidth = 0; |
| m_fLeft = 0; |
| } |
