From 267c6f2ac71f92999e969232431ba04678e7437e Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Mon, 15 Apr 2024 07:54:39 +0200 Subject: Adding upstream version 4:24.2.0. Signed-off-by: Daniel Baumann --- sw/source/core/text/EnhancedPDFExportHelper.cxx | 3061 ++++++++++++++++ sw/source/core/text/SwGrammarMarkUp.cxx | 145 + sw/source/core/text/atrhndl.hxx | 117 + sw/source/core/text/atrstck.cxx | 851 +++++ sw/source/core/text/frmcrsr.cxx | 1691 +++++++++ sw/source/core/text/frmform.cxx | 2299 ++++++++++++ sw/source/core/text/frminf.cxx | 291 ++ sw/source/core/text/frmpaint.cxx | 810 +++++ sw/source/core/text/guess.cxx | 761 ++++ sw/source/core/text/guess.hxx | 65 + sw/source/core/text/inftxt.cxx | 2150 ++++++++++++ sw/source/core/text/inftxt.hxx | 811 +++++ sw/source/core/text/itradj.cxx | 852 +++++ sw/source/core/text/itratr.cxx | 1632 +++++++++ sw/source/core/text/itratr.hxx | 112 + sw/source/core/text/itrcrsr.cxx | 2023 +++++++++++ sw/source/core/text/itrform2.cxx | 3321 ++++++++++++++++++ sw/source/core/text/itrform2.hxx | 245 ++ sw/source/core/text/itrpaint.cxx | 807 +++++ sw/source/core/text/itrpaint.hxx | 71 + sw/source/core/text/itrtxt.cxx | 465 +++ sw/source/core/text/itrtxt.hxx | 341 ++ sw/source/core/text/noteurl.cxx | 25 + sw/source/core/text/pordrop.hxx | 107 + sw/source/core/text/porexp.cxx | 317 ++ sw/source/core/text/porexp.hxx | 78 + sw/source/core/text/porfld.cxx | 1462 ++++++++ sw/source/core/text/porfld.hxx | 285 ++ sw/source/core/text/porfly.cxx | 423 +++ sw/source/core/text/porfly.hxx | 95 + sw/source/core/text/porftn.hxx | 104 + sw/source/core/text/porglue.cxx | 285 ++ sw/source/core/text/porglue.hxx | 93 + sw/source/core/text/porhyph.hxx | 88 + sw/source/core/text/porlay.cxx | 2996 ++++++++++++++++ sw/source/core/text/porlay.hxx | 352 ++ sw/source/core/text/porlin.cxx | 358 ++ sw/source/core/text/porlin.hxx | 220 ++ sw/source/core/text/pormulti.cxx | 2635 ++++++++++++++ sw/source/core/text/pormulti.hxx | 256 ++ sw/source/core/text/porref.cxx | 75 + sw/source/core/text/porref.hxx | 45 + sw/source/core/text/porrst.cxx | 949 +++++ sw/source/core/text/porrst.hxx | 222 ++ sw/source/core/text/portab.hxx | 111 + sw/source/core/text/portox.cxx | 77 + sw/source/core/text/portox.hxx | 46 + sw/source/core/text/portxt.cxx | 925 +++++ sw/source/core/text/portxt.hxx | 104 + sw/source/core/text/possiz.hxx | 72 + sw/source/core/text/redlnitr.cxx | 1201 +++++++ sw/source/core/text/redlnitr.hxx | 135 + sw/source/core/text/txtcache.cxx | 193 ++ sw/source/core/text/txtcache.hxx | 65 + sw/source/core/text/txtdrop.cxx | 1093 ++++++ sw/source/core/text/txtfld.cxx | 715 ++++ sw/source/core/text/txtfly.cxx | 1493 ++++++++ sw/source/core/text/txtfrm.cxx | 4219 +++++++++++++++++++++++ sw/source/core/text/txtftn.cxx | 1590 +++++++++ sw/source/core/text/txthyph.cxx | 582 ++++ sw/source/core/text/txtinit.cxx | 60 + sw/source/core/text/txtpaint.cxx | 113 + sw/source/core/text/txtpaint.hxx | 126 + sw/source/core/text/txttab.cxx | 663 ++++ sw/source/core/text/widorp.cxx | 673 ++++ sw/source/core/text/widorp.hxx | 88 + sw/source/core/text/wrong.cxx | 938 +++++ sw/source/core/text/xmldump.cxx | 203 ++ 68 files changed, 49876 insertions(+) create mode 100644 sw/source/core/text/EnhancedPDFExportHelper.cxx create mode 100644 sw/source/core/text/SwGrammarMarkUp.cxx create mode 100644 sw/source/core/text/atrhndl.hxx create mode 100644 sw/source/core/text/atrstck.cxx create mode 100644 sw/source/core/text/frmcrsr.cxx create mode 100644 sw/source/core/text/frmform.cxx create mode 100644 sw/source/core/text/frminf.cxx create mode 100644 sw/source/core/text/frmpaint.cxx create mode 100644 sw/source/core/text/guess.cxx create mode 100644 sw/source/core/text/guess.hxx create mode 100644 sw/source/core/text/inftxt.cxx create mode 100644 sw/source/core/text/inftxt.hxx create mode 100644 sw/source/core/text/itradj.cxx create mode 100644 sw/source/core/text/itratr.cxx create mode 100644 sw/source/core/text/itratr.hxx create mode 100644 sw/source/core/text/itrcrsr.cxx create mode 100644 sw/source/core/text/itrform2.cxx create mode 100644 sw/source/core/text/itrform2.hxx create mode 100644 sw/source/core/text/itrpaint.cxx create mode 100644 sw/source/core/text/itrpaint.hxx create mode 100644 sw/source/core/text/itrtxt.cxx create mode 100644 sw/source/core/text/itrtxt.hxx create mode 100644 sw/source/core/text/noteurl.cxx create mode 100644 sw/source/core/text/pordrop.hxx create mode 100644 sw/source/core/text/porexp.cxx create mode 100644 sw/source/core/text/porexp.hxx create mode 100644 sw/source/core/text/porfld.cxx create mode 100644 sw/source/core/text/porfld.hxx create mode 100644 sw/source/core/text/porfly.cxx create mode 100644 sw/source/core/text/porfly.hxx create mode 100644 sw/source/core/text/porftn.hxx create mode 100644 sw/source/core/text/porglue.cxx create mode 100644 sw/source/core/text/porglue.hxx create mode 100644 sw/source/core/text/porhyph.hxx create mode 100644 sw/source/core/text/porlay.cxx create mode 100644 sw/source/core/text/porlay.hxx create mode 100644 sw/source/core/text/porlin.cxx create mode 100644 sw/source/core/text/porlin.hxx create mode 100644 sw/source/core/text/pormulti.cxx create mode 100644 sw/source/core/text/pormulti.hxx create mode 100644 sw/source/core/text/porref.cxx create mode 100644 sw/source/core/text/porref.hxx create mode 100644 sw/source/core/text/porrst.cxx create mode 100644 sw/source/core/text/porrst.hxx create mode 100644 sw/source/core/text/portab.hxx create mode 100644 sw/source/core/text/portox.cxx create mode 100644 sw/source/core/text/portox.hxx create mode 100644 sw/source/core/text/portxt.cxx create mode 100644 sw/source/core/text/portxt.hxx create mode 100644 sw/source/core/text/possiz.hxx create mode 100644 sw/source/core/text/redlnitr.cxx create mode 100644 sw/source/core/text/redlnitr.hxx create mode 100644 sw/source/core/text/txtcache.cxx create mode 100644 sw/source/core/text/txtcache.hxx create mode 100644 sw/source/core/text/txtdrop.cxx create mode 100644 sw/source/core/text/txtfld.cxx create mode 100644 sw/source/core/text/txtfly.cxx create mode 100644 sw/source/core/text/txtfrm.cxx create mode 100644 sw/source/core/text/txtftn.cxx create mode 100644 sw/source/core/text/txthyph.cxx create mode 100644 sw/source/core/text/txtinit.cxx create mode 100644 sw/source/core/text/txtpaint.cxx create mode 100644 sw/source/core/text/txtpaint.hxx create mode 100644 sw/source/core/text/txttab.cxx create mode 100644 sw/source/core/text/widorp.cxx create mode 100644 sw/source/core/text/widorp.hxx create mode 100644 sw/source/core/text/wrong.cxx create mode 100644 sw/source/core/text/xmldump.cxx (limited to 'sw/source/core/text') diff --git a/sw/source/core/text/EnhancedPDFExportHelper.cxx b/sw/source/core/text/EnhancedPDFExportHelper.cxx new file mode 100644 index 0000000000..499dcc2417 --- /dev/null +++ b/sw/source/core/text/EnhancedPDFExportHelper.cxx @@ -0,0 +1,3061 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "porfld.hxx" +#include "pormulti.hxx" +#include +#include "itrpaint.hxx" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include + +using namespace ::com::sun::star; + +#if OSL_DEBUG_LEVEL > 1 + +static std::vector< sal_uInt16 > aStructStack; + +void lcl_DBGCheckStack() +{ + /* NonStructElement = 0 Document = 1 Part = 2 + * Article = 3 Section = 4 Division = 5 + * BlockQuote = 6 Caption = 7 TOC = 8 + * TOCI = 9 Index = 10 Paragraph = 11 + * Heading = 12 H1-6 = 13 - 18 List = 19 + * ListItem = 20 LILabel = 21 LIBody = 22 + * Table = 23 TableRow = 24 TableHeader = 25 + * TableData = 26 Span = 27 Quote = 28 + * Note = 29 Reference = 30 BibEntry = 31 + * Code = 32 Link = 33 Figure = 34 + * Formula = 35 Form = 36 Continued frame = 99 + */ + + sal_uInt16 nElement; + for ( const auto& rItem : aStructStack ) + { + nElement = rItem; + } + (void)nElement; +}; + +#endif + +typedef std::set< tools::Long, lt_TableColumn > TableColumnsMapEntry; +typedef std::pair< SwRect, sal_Int32 > IdMapEntry; +typedef std::vector< IdMapEntry > LinkIdMap; +typedef std::map< const SwTable*, TableColumnsMapEntry > TableColumnsMap; +typedef std::map< const SwNumberTreeNode*, sal_Int32 > NumListIdMap; +typedef std::map< const SwNumberTreeNode*, sal_Int32 > NumListBodyIdMap; +typedef std::set FrameTagSet; + +struct SwEnhancedPDFState +{ + TableColumnsMap m_TableColumnsMap; + LinkIdMap m_LinkIdMap; + NumListIdMap m_NumListIdMap; + NumListBodyIdMap m_NumListBodyIdMap; + FrameTagSet m_FrameTagSet; + + LanguageType m_eLanguageDefault; + + struct Span + { + FontLineStyle eUnderline; + FontLineStyle eOverline; + FontStrikeout eStrikeout; + FontEmphasisMark eFontEmphasis; + short nEscapement; + SwFontScript nScript; + LanguageType nLang; + OUString StyleName; + }; + + ::std::optional m_oCurrentSpan; + ::std::optional m_oCurrentLink; + + SwEnhancedPDFState(LanguageType const eLanguageDefault) + : m_eLanguageDefault(eLanguageDefault) + { + } +}; + +namespace +{ +// ODF Style Names: +const char aTableHeadingName[] = "Table Heading"; +const char aQuotations[] = "Quotations"; +const char aCaption[] = "Caption"; +const char aHeading[] = "Heading"; +const char aQuotation[] = "Quotation"; +const char aSourceText[] = "Source Text"; + +// PDF Tag Names: +constexpr OUStringLiteral aDocumentString = u"Document"; +constexpr OUString aDivString = u"Div"_ustr; +constexpr OUStringLiteral aSectString = u"Sect"; +constexpr OUStringLiteral aHString = u"H"; +constexpr OUStringLiteral aH1String = u"H1"; +constexpr OUStringLiteral aH2String = u"H2"; +constexpr OUStringLiteral aH3String = u"H3"; +constexpr OUStringLiteral aH4String = u"H4"; +constexpr OUStringLiteral aH5String = u"H5"; +constexpr OUStringLiteral aH6String = u"H6"; +constexpr OUStringLiteral aH7String = u"H7"; +constexpr OUStringLiteral aH8String = u"H8"; +constexpr OUStringLiteral aH9String = u"H9"; +constexpr OUStringLiteral aH10String = u"H10"; +constexpr OUStringLiteral aListString = u"L"; +constexpr OUStringLiteral aListItemString = u"LI"; +constexpr OUStringLiteral aListLabelString = u"Lbl"; +constexpr OUString aListBodyString = u"LBody"_ustr; +constexpr OUStringLiteral aBlockQuoteString = u"BlockQuote"; +constexpr OUString aCaptionString = u"Caption"_ustr; +constexpr OUStringLiteral aIndexString = u"Index"; +constexpr OUStringLiteral aTOCString = u"TOC"; +constexpr OUStringLiteral aTOCIString = u"TOCI"; +constexpr OUStringLiteral aTableString = u"Table"; +constexpr OUStringLiteral aTRString = u"TR"; +constexpr OUStringLiteral aTDString = u"TD"; +constexpr OUStringLiteral aTHString = u"TH"; +constexpr OUStringLiteral aBibEntryString = u"BibEntry"; +constexpr OUStringLiteral aQuoteString = u"Quote"; +constexpr OUString aSpanString = u"Span"_ustr; +constexpr OUStringLiteral aCodeString = u"Code"; +constexpr OUStringLiteral aFigureString = u"Figure"; +constexpr OUStringLiteral aFormulaString = u"Formula"; +constexpr OUString aLinkString = u"Link"_ustr; +constexpr OUStringLiteral aNoteString = u"Note"; + +// returns true if first paragraph in cell frame has 'table heading' style +bool lcl_IsHeadlineCell( const SwCellFrame& rCellFrame ) +{ + bool bRet = false; + + const SwContentFrame *pCnt = rCellFrame.ContainsContent(); + if ( pCnt && pCnt->IsTextFrame() ) + { + SwTextNode const*const pTextNode = static_cast(pCnt)->GetTextNodeForParaProps(); + const SwFormat* pTextFormat = pTextNode->GetFormatColl(); + + OUString sStyleName; + SwStyleNameMapper::FillProgName( pTextFormat->GetName(), sStyleName, SwGetPoolIdFromName::TxtColl ); + bRet = sStyleName == aTableHeadingName; + } + + // tdf#153935 wild guessing for 1st row based on table autoformat + if (!bRet && !rCellFrame.GetUpper()->GetPrev()) + { + SwTable const*const pTable(rCellFrame.FindTabFrame()->GetTable()); + assert(pTable); + OUString const& rStyleName(pTable->GetTableStyleName()); + if (!rStyleName.isEmpty()) + { + if (SwTableAutoFormat const*const pTableAF = + pTable->GetFrameFormat()->GetDoc()->GetTableStyles().FindAutoFormat(rStyleName)) + { + bRet |= pTableAF->HasHeaderRow(); + } + } + } + + return bRet; +} + +// List all frames for which the NonStructElement tag is set: +bool lcl_IsInNonStructEnv( const SwFrame& rFrame ) +{ + bool bRet = false; + + if ( nullptr != rFrame.FindFooterOrHeader() && + !rFrame.IsHeaderFrame() && !rFrame.IsFooterFrame() ) + { + bRet = true; + } + else if ( rFrame.IsInTab() && !rFrame.IsTabFrame() ) + { + const SwTabFrame* pTabFrame = rFrame.FindTabFrame(); + if ( rFrame.GetUpper() != pTabFrame && + pTabFrame->IsFollow() && pTabFrame->IsInHeadline( rFrame ) ) + bRet = true; + } + + return bRet; +} + +// Generate key from frame for reopening tags: +void const* lcl_GetKeyFromFrame( const SwFrame& rFrame ) +{ + void const* pKey = nullptr; + + if ( rFrame.IsPageFrame() ) + pKey = static_cast(&(static_cast(rFrame).GetFormat()->getIDocumentSettingAccess())); + else if ( rFrame.IsTextFrame() ) + pKey = static_cast(static_cast(rFrame).GetTextNodeFirst()); + else if ( rFrame.IsSctFrame() ) + pKey = static_cast(static_cast(rFrame).GetSection()); + else if ( rFrame.IsTabFrame() ) + pKey = static_cast(static_cast(rFrame).GetTable()); + else if ( rFrame.IsRowFrame() ) + pKey = static_cast(static_cast(rFrame).GetTabLine()); + else if ( rFrame.IsCellFrame() ) + { + const SwTabFrame* pTabFrame = rFrame.FindTabFrame(); + const SwTable* pTable = pTabFrame->GetTable(); + pKey = static_cast(& static_cast(rFrame).GetTabBox()->FindStartOfRowSpan(*pTable)); + } + else if (rFrame.IsFootnoteFrame()) + { + pKey = static_cast(static_cast(rFrame).GetAttr()); + } + + return pKey; +} + +bool lcl_HasPreviousParaSameNumRule(SwTextFrame const& rTextFrame, const SwTextNode& rNode) +{ + bool bRet = false; + SwNodeIndex aIdx( rNode ); + const SwDoc& rDoc = rNode.GetDoc(); + const SwNodes& rNodes = rDoc.GetNodes(); + const SwNode* pNode = &rNode; + const SwNumRule* pNumRule = rNode.GetNumRule(); + + while (pNode != rNodes.DocumentSectionStartNode(const_cast(static_cast(&rNode))) ) + { + sw::GotoPrevLayoutTextFrame(aIdx, rTextFrame.getRootFrame()); + + if (aIdx.GetNode().IsTextNode()) + { + const SwTextNode *const pPrevTextNd = sw::GetParaPropsNode( + *rTextFrame.getRootFrame(), *aIdx.GetNode().GetTextNode()); + const SwNumRule * pPrevNumRule = pPrevTextNd->GetNumRule(); + + // We find the previous text node. Now check, if the previous text node + // has the same numrule like rNode: + if ( (pPrevNumRule == pNumRule) && + (!pPrevTextNd->IsOutline() == !rNode.IsOutline())) + bRet = true; + + break; + } + + pNode = &aIdx.GetNode(); + } + return bRet; +} + +bool lcl_TryMoveToNonHiddenField(SwEditShell& rShell, const SwTextNode& rNd, const SwFormatField& rField) +{ + // 1. Check if the whole paragraph is hidden + // 2. Move to the field + // 3. Check for hidden text attribute + if(rNd.IsHidden()) + return false; + if(!rShell.GotoFormatField(rField) || rShell.IsInHiddenRange(/*bSelect=*/false)) + { + rShell.SwCursorShell::ClearMark(); + return false; + } + return true; +}; + +// tdf#157816: try to check if the rectangle contains actual text +::std::vector GetCursorRectsContainingText(SwCursorShell const& rShell) +{ + ::std::vector ret; + SwRects rects; + rShell.GetLayout()->CalcFrameRects(*rShell.GetCursor_(), rects, SwRootFrame::RectsMode::NoAnchoredFlys); + for (SwRect const& rRect : rects) + { + Point center(rRect.Center()); + SwSpecialPos special; + SwCursorMoveState cms(CursorMoveState::NONE); + cms.m_pSpecialPos = &special; + cms.m_bFieldInfo = true; + SwPosition pos(rShell.GetDoc()->GetNodes()); + auto const [pStart, pEnd] = rShell.GetCursor_()->StartEnd(); + if (rShell.GetLayout()->GetModelPositionForViewPoint(&pos, center, &cms) + && *pStart <= pos && pos <= *pEnd) + { + SwRect charRect; + if (rShell.GetCurrFrame(false)->GetCharRect(charRect, pos, &cms, false) + && rRect.Overlaps(charRect)) + { + ret.push_back(rRect); + } + } + // reset stupid static var that may have gotten set now + SwTextCursor::SetRightMargin(false); // WTF is this crap + } + return ret; +} + +} // end namespace + +SwTaggedPDFHelper::SwTaggedPDFHelper( const Num_Info* pNumInfo, + const Frame_Info* pFrameInfo, + const Por_Info* pPorInfo, + OutputDevice const & rOut ) + : m_nEndStructureElement( 0 ), + m_nRestoreCurrentTag( -1 ), + mpNumInfo( pNumInfo ), + mpFrameInfo( pFrameInfo ), + mpPorInfo( pPorInfo ) +{ + mpPDFExtOutDevData = + dynamic_cast< vcl::PDFExtOutDevData*>( rOut.GetExtOutDevData() ); + + if ( !(mpPDFExtOutDevData && mpPDFExtOutDevData->GetIsExportTaggedPDF()) ) + return; + +#if OSL_DEBUG_LEVEL > 1 + sal_Int32 nCurrentStruct = mpPDFExtOutDevData->GetCurrentStructureElement(); + lcl_DBGCheckStack(); +#endif + if ( mpNumInfo ) + BeginNumberedListStructureElements(); + else if ( mpFrameInfo ) + BeginBlockStructureElements(); + else if ( mpPorInfo ) + BeginInlineStructureElements(); + else + BeginTag( vcl::PDFWriter::NonStructElement, OUString() ); + +#if OSL_DEBUG_LEVEL > 1 + nCurrentStruct = mpPDFExtOutDevData->GetCurrentStructureElement(); + lcl_DBGCheckStack(); + (void)nCurrentStruct; +#endif +} + +SwTaggedPDFHelper::~SwTaggedPDFHelper() +{ + if ( !(mpPDFExtOutDevData && mpPDFExtOutDevData->GetIsExportTaggedPDF()) ) + return; + +#if OSL_DEBUG_LEVEL > 1 + sal_Int32 nCurrentStruct = mpPDFExtOutDevData->GetCurrentStructureElement(); + lcl_DBGCheckStack(); +#endif + EndStructureElements(); + +#if OSL_DEBUG_LEVEL > 1 + nCurrentStruct = mpPDFExtOutDevData->GetCurrentStructureElement(); + lcl_DBGCheckStack(); + (void)nCurrentStruct; +#endif +} + +void const* SwDrawContact::GetPDFAnchorStructureElementKey(SdrObject const& rObj) +{ + SwFrame const*const pAnchorFrame(GetAnchoredObj(&rObj)->GetAnchorFrame()); + return pAnchorFrame ? lcl_GetKeyFromFrame(*pAnchorFrame) : nullptr; +} + +bool SwTaggedPDFHelper::CheckReopenTag() +{ + bool bRet = false; + void const* pReopenKey(nullptr); + bool bContinue = false; // in some cases we just have to reopen a tag without early returning + + if ( mpFrameInfo ) + { + const SwFrame& rFrame = mpFrameInfo->mrFrame; + const SwFrame* pKeyFrame = nullptr; + + // Reopen an existing structure element if + // - rFrame is not the first page frame (reopen Document tag) + // - rFrame is a follow frame (reopen Master tag) + // - rFrame is a fly frame anchored at content (reopen Anchor paragraph tag) + // - rFrame is a fly frame anchored at page (reopen Document tag) + // - rFrame is a follow flow row (reopen TableRow tag) + // - rFrame is a cell frame in a follow flow row (reopen TableData tag) + if ( ( rFrame.IsPageFrame() && static_cast(rFrame).GetPrev() ) || + ( rFrame.IsFlowFrame() && SwFlowFrame::CastFlowFrame(&rFrame)->IsFollow() ) || + (rFrame.IsFootnoteFrame() && static_cast(rFrame).GetMaster()) || + ( rFrame.IsRowFrame() && rFrame.IsInFollowFlowRow() ) || + ( rFrame.IsCellFrame() && const_cast(rFrame).GetPrevCellLeaf() ) ) + { + pKeyFrame = &rFrame; + } + else if (rFrame.IsFlyFrame() && !mpFrameInfo->m_isLink) + { + const SwFormatAnchor& rAnchor = + static_cast(&rFrame)->GetFormat()->GetAnchor(); + if ((RndStdIds::FLY_AT_PARA == rAnchor.GetAnchorId()) || + (RndStdIds::FLY_AT_CHAR == rAnchor.GetAnchorId()) || + (RndStdIds::FLY_AT_PAGE == rAnchor.GetAnchorId())) + { + pKeyFrame = static_cast(rFrame).GetAnchorFrame(); + bContinue = true; + } + } + + if ( pKeyFrame ) + { + void const*const pKey = lcl_GetKeyFromFrame(*pKeyFrame); + FrameTagSet& rFrameTagSet(mpPDFExtOutDevData->GetSwPDFState()->m_FrameTagSet); + if (rFrameTagSet.find(pKey) != rFrameTagSet.end() + || rFrame.IsFlyFrame()) // for hell layer flys + { + pReopenKey = pKey; + } + } + } + + if (pReopenKey) + { + // note: it would be possible to get rid of the SetCurrentStructureElement() + // - which is quite ugly - for most cases by recreating the parents until the + // current ancestor, but there are special cases cell frame rowspan > 1 follow + // and footnote frame follow where the parent of the follow is different from + // the parent of the first one, and so in PDFExtOutDevData the wrong parent + // would be restored and used for next elements. + m_nRestoreCurrentTag = mpPDFExtOutDevData->GetCurrentStructureElement(); + sal_Int32 const id = mpPDFExtOutDevData->EnsureStructureElement(pReopenKey); + mpPDFExtOutDevData->SetCurrentStructureElement(id); + + bRet = true; + } + + return bRet && !bContinue; +} + +void SwTaggedPDFHelper::CheckRestoreTag() const +{ + if ( m_nRestoreCurrentTag != -1 ) + { + mpPDFExtOutDevData->SetCurrentStructureElement( m_nRestoreCurrentTag ); + +#if OSL_DEBUG_LEVEL > 1 + aStructStack.pop_back(); +#endif + } +} + +void SwTaggedPDFHelper::OpenTagImpl(void const*const pKey) +{ + sal_Int32 const id = mpPDFExtOutDevData->EnsureStructureElement(pKey); + mpPDFExtOutDevData->BeginStructureElement(id); + ++m_nEndStructureElement; + +#if OSL_DEBUG_LEVEL > 1 + aStructStack.push_back( 99 ); +#endif +} + +sal_Int32 SwTaggedPDFHelper::BeginTagImpl(void const*const pKey, + vcl::PDFWriter::StructElement const eType, const OUString& rString) +{ + // write new tag + const sal_Int32 nId = mpPDFExtOutDevData->EnsureStructureElement(pKey); + mpPDFExtOutDevData->InitStructureElement(nId, eType, rString); + mpPDFExtOutDevData->BeginStructureElement(nId); + ++m_nEndStructureElement; + +#if OSL_DEBUG_LEVEL > 1 + aStructStack.push_back( o3tl::narrowing(eType) ); +#endif + + return nId; +} + +void SwTaggedPDFHelper::BeginTag( vcl::PDFWriter::StructElement eType, const OUString& rString ) +{ + void const* pKey(nullptr); + + if (mpFrameInfo) + { + const SwFrame& rFrame = mpFrameInfo->mrFrame; + + if ( ( rFrame.IsPageFrame() && !static_cast(rFrame).GetPrev() ) || + ( rFrame.IsFlowFrame() && !SwFlowFrame::CastFlowFrame(&rFrame)->IsFollow() && SwFlowFrame::CastFlowFrame(&rFrame)->HasFollow() ) || + rFrame.IsSctFrame() || // all of them, so that opening parent sections works + ( rFrame.IsTextFrame() && rFrame.GetDrawObjs() ) || + (rFrame.IsFootnoteFrame() && static_cast(rFrame).GetFollow()) || + ( rFrame.IsRowFrame() && rFrame.IsInSplitTableRow() ) || + ( rFrame.IsCellFrame() && const_cast(rFrame).GetNextCellLeaf() ) ) + { + pKey = lcl_GetKeyFromFrame(rFrame); + + if (pKey) + { + FrameTagSet& rFrameTagSet(mpPDFExtOutDevData->GetSwPDFState()->m_FrameTagSet); + assert(rFrameTagSet.find(pKey) == rFrameTagSet.end()); + rFrameTagSet.emplace(pKey); + } + } + } + + sal_Int32 const nId = BeginTagImpl(pKey, eType, rString); + + // Store the id of the current structure element if + // - it is a list structure element + // - it is a list body element with children + // - rFrame is the first page frame + // - rFrame is a master frame + // - rFrame has objects anchored to it + // - rFrame is a row frame or cell frame in a split table row + + if ( mpNumInfo ) + { + const SwTextFrame& rTextFrame = mpNumInfo->mrFrame; + SwTextNode const*const pTextNd = rTextFrame.GetTextNodeForParaProps(); + const SwNodeNum* pNodeNum = pTextNd->GetNum(rTextFrame.getRootFrame()); + + if ( vcl::PDFWriter::List == eType ) + { + NumListIdMap& rNumListIdMap(mpPDFExtOutDevData->GetSwPDFState()->m_NumListIdMap); + rNumListIdMap[ pNodeNum ] = nId; + } + else if ( vcl::PDFWriter::LIBody == eType ) + { + NumListBodyIdMap& rNumListBodyIdMap(mpPDFExtOutDevData->GetSwPDFState()->m_NumListBodyIdMap); + rNumListBodyIdMap[ pNodeNum ] = nId; + } + } + + SetAttributes( eType ); +} + +void SwTaggedPDFHelper::EndTag() +{ + mpPDFExtOutDevData->EndStructureElement(); + +#if OSL_DEBUG_LEVEL > 1 + aStructStack.pop_back(); +#endif +} + +namespace { + + // link the link annotation to the link structured element + void LinkLinkLink(vcl::PDFExtOutDevData & rPDFExtOutDevData, SwRect const& rRect) + { + const LinkIdMap& rLinkIdMap(rPDFExtOutDevData.GetSwPDFState()->m_LinkIdMap); + const Point aCenter = rRect.Center(); + auto aIter = std::find_if(rLinkIdMap.begin(), rLinkIdMap.end(), + [&aCenter](const IdMapEntry& rEntry) { return rEntry.first.Contains(aCenter); }); + if (aIter != rLinkIdMap.end()) + { + sal_Int32 nLinkId = (*aIter).second; + rPDFExtOutDevData.SetStructureAttributeNumerical(vcl::PDFWriter::LinkAnnotation, nLinkId); + } + } +} + +// Sets the attributes according to the structure type. +void SwTaggedPDFHelper::SetAttributes( vcl::PDFWriter::StructElement eType ) +{ + sal_Int32 nVal; + + /* + * ATTRIBUTES FOR BLSE + */ + if ( mpFrameInfo ) + { + vcl::PDFWriter::StructAttributeValue eVal; + const SwFrame* pFrame = &mpFrameInfo->mrFrame; + SwRectFnSet aRectFnSet(pFrame); + + bool bPlacement = false; + bool bWritingMode = false; + bool bSpaceBefore = false; + bool bSpaceAfter = false; + bool bStartIndent = false; + bool bEndIndent = false; + bool bTextIndent = false; + bool bTextAlign = false; + bool bWidth = false; + bool bHeight = false; + bool bBox = false; + bool bRowSpan = false; + bool bAltText = false; + + // Check which attributes to set: + + switch ( eType ) + { + case vcl::PDFWriter::Document : + bWritingMode = true; + break; + + case vcl::PDFWriter::Note: + bPlacement = true; + break; + + case vcl::PDFWriter::Table : + bPlacement = + bWritingMode = + bSpaceBefore = + bSpaceAfter = + bStartIndent = + bEndIndent = + bWidth = + bHeight = + bBox = true; + break; + + case vcl::PDFWriter::TableRow : + bPlacement = + bWritingMode = true; + break; + + case vcl::PDFWriter::TableHeader : + mpPDFExtOutDevData->SetStructureAttribute(vcl::PDFWriter::Scope, vcl::PDFWriter::Column); + [[fallthrough]]; + case vcl::PDFWriter::TableData : + bPlacement = + bWritingMode = + bWidth = + bHeight = + bRowSpan = true; + break; + + case vcl::PDFWriter::Caption: + if (pFrame->IsSctFrame()) + { + break; + } + [[fallthrough]]; + case vcl::PDFWriter::H1 : + case vcl::PDFWriter::H2 : + case vcl::PDFWriter::H3 : + case vcl::PDFWriter::H4 : + case vcl::PDFWriter::H5 : + case vcl::PDFWriter::H6 : + case vcl::PDFWriter::Paragraph : + case vcl::PDFWriter::Heading : + case vcl::PDFWriter::BlockQuote : + + bPlacement = + bWritingMode = + bSpaceBefore = + bSpaceAfter = + bStartIndent = + bEndIndent = + bTextIndent = + bTextAlign = true; + break; + + case vcl::PDFWriter::Formula : + case vcl::PDFWriter::Figure : + bAltText = + bPlacement = + bWidth = + bHeight = + bBox = true; + break; + + case vcl::PDFWriter::Division: + if (pFrame->IsFlyFrame()) // this can be something else too + { + bAltText = true; + bBox = true; + } + break; + + case vcl::PDFWriter::NonStructElement: + if (pFrame->IsHeaderFrame() || pFrame->IsFooterFrame()) + { + // ISO 14289-1:2014, Clause: 7.8 + mpPDFExtOutDevData->SetStructureAttribute(vcl::PDFWriter::Type, vcl::PDFWriter::Pagination); + mpPDFExtOutDevData->SetStructureAttribute(vcl::PDFWriter::Subtype, + pFrame->IsHeaderFrame() + ? vcl::PDFWriter::Header + : vcl::PDFWriter::Footer); + } + break; + + default : + break; + } + + // Set the attributes: + + if ( bPlacement ) + { + eVal = vcl::PDFWriter::TableHeader == eType || + vcl::PDFWriter::TableData == eType ? + vcl::PDFWriter::Inline : + vcl::PDFWriter::Block; + + mpPDFExtOutDevData->SetStructureAttribute( vcl::PDFWriter::Placement, eVal ); + } + + if ( bWritingMode ) + { + eVal = pFrame->IsVertical() ? + vcl::PDFWriter::TbRl : + pFrame->IsRightToLeft() ? + vcl::PDFWriter::RlTb : + vcl::PDFWriter::LrTb; + + if ( vcl::PDFWriter::LrTb != eVal ) + mpPDFExtOutDevData->SetStructureAttribute( vcl::PDFWriter::WritingMode, eVal ); + } + + if ( bSpaceBefore ) + { + nVal = aRectFnSet.GetTopMargin(*pFrame); + if ( 0 != nVal ) + mpPDFExtOutDevData->SetStructureAttributeNumerical( vcl::PDFWriter::SpaceBefore, nVal ); + } + + if ( bSpaceAfter ) + { + nVal = aRectFnSet.GetBottomMargin(*pFrame); + if ( 0 != nVal ) + mpPDFExtOutDevData->SetStructureAttributeNumerical( vcl::PDFWriter::SpaceAfter, nVal ); + } + + if ( bStartIndent ) + { + nVal = aRectFnSet.GetLeftMargin(*pFrame); + if ( 0 != nVal ) + mpPDFExtOutDevData->SetStructureAttributeNumerical( vcl::PDFWriter::StartIndent, nVal ); + } + + if ( bEndIndent ) + { + nVal = aRectFnSet.GetRightMargin(*pFrame); + if ( 0 != nVal ) + mpPDFExtOutDevData->SetStructureAttributeNumerical( vcl::PDFWriter::EndIndent, nVal ); + } + + if ( bTextIndent ) + { + OSL_ENSURE( pFrame->IsTextFrame(), "Frame type <-> tag attribute mismatch" ); + const SvxFirstLineIndentItem& rFirstLine( + static_cast(pFrame)->GetTextNodeForParaProps()->GetSwAttrSet().GetFirstLineIndent()); + nVal = rFirstLine.GetTextFirstLineOffset(); + if ( 0 != nVal ) + mpPDFExtOutDevData->SetStructureAttributeNumerical( vcl::PDFWriter::TextIndent, nVal ); + } + + if ( bTextAlign ) + { + OSL_ENSURE( pFrame->IsTextFrame(), "Frame type <-> tag attribute mismatch" ); + const SwAttrSet& aSet = static_cast(pFrame)->GetTextNodeForParaProps()->GetSwAttrSet(); + const SvxAdjust nAdjust = aSet.GetAdjust().GetAdjust(); + if ( SvxAdjust::Block == nAdjust || SvxAdjust::Center == nAdjust || + ( (pFrame->IsRightToLeft() && SvxAdjust::Left == nAdjust) || + (!pFrame->IsRightToLeft() && SvxAdjust::Right == nAdjust) ) ) + { + eVal = SvxAdjust::Block == nAdjust ? + vcl::PDFWriter::Justify : + SvxAdjust::Center == nAdjust ? + vcl::PDFWriter::Center : + vcl::PDFWriter::End; + + mpPDFExtOutDevData->SetStructureAttribute( vcl::PDFWriter::TextAlign, eVal ); + } + } + + // ISO 14289-1:2014, Clause: 7.3 + // ISO 14289-1:2014, Clause: 7.7 + // For images (but not embedded objects), an ObjectInfoPrimitive2D is + // created, but it's not evaluated by VclMetafileProcessor2D any more; + // that would require producing StructureTagPrimitive2D here but that + // looks impossible so instead duplicate the code that sets the Alt + // text here again. + if (bAltText) + { + SwFlyFrameFormat const& rFly(*static_cast(pFrame)->GetFormat()); + OUString const sep( + (rFly.GetObjTitle().isEmpty() || rFly.GetObjDescription().isEmpty()) + ? OUString() : OUString(" - ")); + OUString const altText(rFly.GetObjTitle() + sep + rFly.GetObjDescription()); + if (!altText.isEmpty()) + { + mpPDFExtOutDevData->SetAlternateText(altText); + } + } + + if ( bWidth ) + { + nVal = aRectFnSet.GetWidth(pFrame->getFrameArea()); + mpPDFExtOutDevData->SetStructureAttributeNumerical( vcl::PDFWriter::Width, nVal ); + } + + if ( bHeight ) + { + nVal = aRectFnSet.GetHeight(pFrame->getFrameArea()); + mpPDFExtOutDevData->SetStructureAttributeNumerical( vcl::PDFWriter::Height, nVal ); + } + + if ( bBox ) + { + // BBox only for non-split tables: + if ( vcl::PDFWriter::Table != eType || + ( pFrame->IsTabFrame() && + !static_cast(pFrame)->IsFollow() && + !static_cast(pFrame)->HasFollow() ) ) + { + mpPDFExtOutDevData->SetStructureBoundingBox(pFrame->getFrameArea().SVRect()); + } + } + + if ( bRowSpan ) + { + if ( pFrame->IsCellFrame() ) + { + const SwCellFrame* pThisCell = static_cast(pFrame); + nVal = pThisCell->GetTabBox()->getRowSpan(); + if ( nVal > 1 ) + mpPDFExtOutDevData->SetStructureAttributeNumerical( vcl::PDFWriter::RowSpan, nVal ); + + // calculate colspan: + const SwTabFrame* pTabFrame = pThisCell->FindTabFrame(); + const SwTable* pTable = pTabFrame->GetTable(); + + SwRectFnSet fnRectX(pTabFrame); + + const TableColumnsMapEntry& rCols(mpPDFExtOutDevData->GetSwPDFState()->m_TableColumnsMap[pTable]); + + const tools::Long nLeft = fnRectX.GetLeft(pThisCell->getFrameArea()); + const tools::Long nRight = fnRectX.GetRight(pThisCell->getFrameArea()); + const TableColumnsMapEntry::const_iterator aLeftIter = rCols.find( nLeft ); + const TableColumnsMapEntry::const_iterator aRightIter = rCols.find( nRight ); + + OSL_ENSURE( aLeftIter != rCols.end() && aRightIter != rCols.end(), "Colspan trouble" ); + if ( aLeftIter != rCols.end() && aRightIter != rCols.end() ) + { + nVal = std::distance( aLeftIter, aRightIter ); + if ( nVal > 1 ) + mpPDFExtOutDevData->SetStructureAttributeNumerical( vcl::PDFWriter::ColSpan, nVal ); + } + } + } + + if (mpFrameInfo->m_isLink) + { + SwRect const aRect(mpFrameInfo->mrFrame.getFrameArea()); + LinkLinkLink(*mpPDFExtOutDevData, aRect); + } + } + + /* + * ATTRIBUTES FOR ILSE + */ + else if ( mpPorInfo ) + { + const SwLinePortion* pPor = &mpPorInfo->mrPor; + const SwTextPaintInfo& rInf = mpPorInfo->mrTextPainter.GetInfo(); + + bool bActualText = false; + bool bBaselineShift = false; + bool bTextDecorationType = false; + bool bLinkAttribute = false; + bool bLanguage = false; + + // Check which attributes to set: + + switch ( eType ) + { + case vcl::PDFWriter::Span : + case vcl::PDFWriter::Quote : + case vcl::PDFWriter::Code : + if( PortionType::HyphenStr == pPor->GetWhichPor() || PortionType::SoftHyphenStr == pPor->GetWhichPor() || + PortionType::Hyphen == pPor->GetWhichPor() || PortionType::SoftHyphen == pPor->GetWhichPor() ) + bActualText = true; + else + { + bBaselineShift = + bTextDecorationType = + bLanguage = true; + } + break; + + case vcl::PDFWriter::Link : + bTextDecorationType = + bBaselineShift = + bLinkAttribute = + bLanguage = true; + break; + + case vcl::PDFWriter::BibEntry : + bTextDecorationType = + bBaselineShift = + bLinkAttribute = + bLanguage = true; + break; + + case vcl::PDFWriter::RT: + { + SwRubyPortion const*const pRuby(static_cast(pPor)); + vcl::PDFWriter::StructAttributeValue nAlign = {}; + switch (pRuby->GetAdjustment()) + { + case text::RubyAdjust_LEFT: + nAlign = vcl::PDFWriter::RStart; + break; + case text::RubyAdjust_CENTER: + nAlign = vcl::PDFWriter::RCenter; + break; + case text::RubyAdjust_RIGHT: + nAlign = vcl::PDFWriter::REnd; + break; + case text::RubyAdjust_BLOCK: + nAlign = vcl::PDFWriter::RJustify; + break; + case text::RubyAdjust_INDENT_BLOCK: + nAlign = vcl::PDFWriter::RDistribute; + break; + default: + assert(false); + break; + } + ::std::optional oPos; + switch (pRuby->GetRubyPosition()) + { + case RubyPosition::ABOVE: + oPos = vcl::PDFWriter::RBefore; + break; + case RubyPosition::BELOW: + oPos = vcl::PDFWriter::RAfter; + break; + case RubyPosition::RIGHT: + break; // no such thing??? + } + mpPDFExtOutDevData->SetStructureAttribute(vcl::PDFWriter::RubyAlign, nAlign); + if (oPos) + { + mpPDFExtOutDevData->SetStructureAttribute(vcl::PDFWriter::RubyPosition, *oPos); + } + } + break; + + default: + break; + } + + if ( bActualText ) + { + OUString aActualText; + if (pPor->GetWhichPor() == PortionType::SoftHyphen || pPor->GetWhichPor() == PortionType::Hyphen) + aActualText = OUString(u'\x00ad'); // soft hyphen + else + aActualText = rInf.GetText().copy(sal_Int32(rInf.GetIdx()), sal_Int32(pPor->GetLen())); + mpPDFExtOutDevData->SetActualText( aActualText ); + } + + if ( bBaselineShift ) + { + // TODO: Calculate correct values! + nVal = rInf.GetFont()->GetEscapement(); + if ( nVal > 0 ) nVal = 33; + else if ( nVal < 0 ) nVal = -33; + + if ( 0 != nVal ) + { + nVal = nVal * pPor->Height() / 100; + mpPDFExtOutDevData->SetStructureAttributeNumerical( vcl::PDFWriter::BaselineShift, nVal ); + } + } + + if ( bTextDecorationType ) + { + if ( LINESTYLE_NONE != rInf.GetFont()->GetUnderline() ) + mpPDFExtOutDevData->SetStructureAttribute( vcl::PDFWriter::TextDecorationType, vcl::PDFWriter::Underline ); + if ( LINESTYLE_NONE != rInf.GetFont()->GetOverline() ) + mpPDFExtOutDevData->SetStructureAttribute( vcl::PDFWriter::TextDecorationType, vcl::PDFWriter::Overline ); + if ( STRIKEOUT_NONE != rInf.GetFont()->GetStrikeout() ) + mpPDFExtOutDevData->SetStructureAttribute( vcl::PDFWriter::TextDecorationType, vcl::PDFWriter::LineThrough ); + if ( FontEmphasisMark::NONE != rInf.GetFont()->GetEmphasisMark() ) + mpPDFExtOutDevData->SetStructureAttribute( vcl::PDFWriter::TextDecorationType, vcl::PDFWriter::Overline ); + } + + if ( bLanguage ) + { + + const LanguageType nCurrentLanguage = rInf.GetFont()->GetLanguage(); + const LanguageType nDefaultLang(mpPDFExtOutDevData->GetSwPDFState()->m_eLanguageDefault); + + if ( nDefaultLang != nCurrentLanguage ) + mpPDFExtOutDevData->SetStructureAttributeNumerical( vcl::PDFWriter::Language, static_cast(nCurrentLanguage) ); + } + + if ( bLinkAttribute ) + { + SwRect aPorRect; + rInf.CalcRect( *pPor, &aPorRect ); + LinkLinkLink(*mpPDFExtOutDevData, aPorRect); + } + } + else if (mpNumInfo && eType == vcl::PDFWriter::List) + { + SwTextFrame const& rFrame(mpNumInfo->mrFrame); + SwTextNode const& rNode(*rFrame.GetTextNodeForParaProps()); + SwNumRule const*const pNumRule = rNode.GetNumRule(); + assert(pNumRule); // was required for List + + auto ToPDFListNumbering = [](SvxNumberFormat const& rFormat) { + switch (rFormat.GetNumberingType()) + { + case css::style::NumberingType::CHARS_UPPER_LETTER: + return vcl::PDFWriter::UpperAlpha; + case css::style::NumberingType::CHARS_LOWER_LETTER: + return vcl::PDFWriter::LowerAlpha; + case css::style::NumberingType::ROMAN_UPPER: + return vcl::PDFWriter::UpperRoman; + case css::style::NumberingType::ROMAN_LOWER: + return vcl::PDFWriter::LowerRoman; + case css::style::NumberingType::ARABIC: + return vcl::PDFWriter::Decimal; + case css::style::NumberingType::CHAR_SPECIAL: + switch (rFormat.GetBulletChar()) + { + case u'\u2022': case u'\uE12C': case u'\uE01E': case u'\uE437': + return vcl::PDFWriter::Disc; + case u'\u2218': case u'\u25CB': case u'\u25E6': + return vcl::PDFWriter::Circle; + case u'\u25A0': case u'\u25AA': case u'\uE00A': + return vcl::PDFWriter::Square; + default: + return vcl::PDFWriter::NONE; + } + default: // the other 50 types + return vcl::PDFWriter::NONE; + } + }; + + // Note: for every level, BeginNumberedListStructureElements() produces + // a separate List element, so even though in PDF this is limited to + // the whole List we can just export the current level here. + vcl::PDFWriter::StructAttributeValue const value( + ToPDFListNumbering(pNumRule->Get(rNode.GetActualListLevel()))); + // ISO 14289-1:2014, Clause: 7.6 + mpPDFExtOutDevData->SetStructureAttribute(vcl::PDFWriter::ListNumbering, value); + } +} + +void SwTaggedPDFHelper::BeginNumberedListStructureElements() +{ + OSL_ENSURE( mpNumInfo, "List without mpNumInfo?" ); + if ( !mpNumInfo ) + return; + + const SwFrame& rFrame = mpNumInfo->mrFrame; + assert(rFrame.IsTextFrame()); + const SwTextFrame& rTextFrame = static_cast(rFrame); + + // Lowers of NonStructureElements should not be considered: + if (lcl_IsInNonStructEnv(rTextFrame)) + return; + + // do it for the first one in the follow chain that has content + for (SwFlowFrame const* pPrecede = rTextFrame.GetPrecede(); pPrecede; pPrecede = pPrecede->GetPrecede()) + { + SwTextFrame const*const pText(static_cast(pPrecede)); + if (!pText->HasPara() || pText->GetPara()->HasContentPortions()) + { + return; + } + } + + const SwTextNode *const pTextNd = rTextFrame.GetTextNodeForParaProps(); + const SwNumRule* pNumRule = pTextNd->GetNumRule(); + const SwNodeNum* pNodeNum = pTextNd->GetNum(rTextFrame.getRootFrame()); + + const bool bNumbered = !pTextNd->IsOutline() && pNodeNum && pNodeNum->GetParent() && pNumRule; + + // Check, if we have to reopen a list or a list body: + // First condition: + // Paragraph is numbered/bulleted + if ( !bNumbered ) + return; + + const SwNumberTreeNode* pParent = pNodeNum->GetParent(); + const bool bSameNumbering = lcl_HasPreviousParaSameNumRule(rTextFrame, *pTextNd); + + // Second condition: current numbering is not 'interrupted' + if ( bSameNumbering ) + { + sal_Int32 nReopenTag = -1; + + // Two cases: + // 1. We have to reopen an existing list body tag: + // - If the current node is either the first child of its parent + // and its level > 1 or + // - Numbering should restart at the current node and its level > 1 + // - The current item has no label + const bool bNewSubListStart = pParent->GetParent() && (pParent->IsFirst( pNodeNum ) || pTextNd->IsListRestart() ); + const bool bNoLabel = !pTextNd->IsCountedInList() && !pTextNd->IsListRestart(); + if ( bNewSubListStart || bNoLabel ) + { + // Fine, we try to reopen the appropriate list body + NumListBodyIdMap& rNumListBodyIdMap(mpPDFExtOutDevData->GetSwPDFState()->m_NumListBodyIdMap); + + if ( bNewSubListStart ) + { + // The list body tag associated with the parent has to be reopened + // to start a new list inside the list body + NumListBodyIdMap::const_iterator aIter; + + do + aIter = rNumListBodyIdMap.find( pParent ); + while ( aIter == rNumListBodyIdMap.end() && nullptr != ( pParent = pParent->GetParent() ) ); + + if ( aIter != rNumListBodyIdMap.end() ) + nReopenTag = (*aIter).second; + } + else // if(bNoLabel) + { + // The list body tag of a 'counted' predecessor has to be reopened + const SwNumberTreeNode* pPrevious = pNodeNum->GetPred(true); + while ( pPrevious ) + { + if ( pPrevious->IsCounted()) + { + // get id of list body tag + const NumListBodyIdMap::const_iterator aIter = rNumListBodyIdMap.find( pPrevious ); + if ( aIter != rNumListBodyIdMap.end() ) + { + nReopenTag = (*aIter).second; + break; + } + } + pPrevious = pPrevious->GetPred(true); + } + } + } + // 2. We have to reopen an existing list tag: + else if ( !pParent->IsFirst( pNodeNum ) && !pTextNd->IsListRestart() ) + { + // any other than the first node in a list level has to reopen the current + // list. The current list is associated in a map with the first child of the list: + NumListIdMap& rNumListIdMap(mpPDFExtOutDevData->GetSwPDFState()->m_NumListIdMap); + + // Search backwards and check if any of the previous nodes has a list associated with it: + const SwNumberTreeNode* pPrevious = pNodeNum->GetPred(true); + while ( pPrevious ) + { + // get id of list tag + const NumListIdMap::const_iterator aIter = rNumListIdMap.find( pPrevious ); + if ( aIter != rNumListIdMap.end() ) + { + nReopenTag = (*aIter).second; + break; + } + + pPrevious = pPrevious->GetPred(true); + } + } + + if ( -1 != nReopenTag ) + { + m_nRestoreCurrentTag = mpPDFExtOutDevData->GetCurrentStructureElement(); + mpPDFExtOutDevData->SetCurrentStructureElement( nReopenTag ); + +#if OSL_DEBUG_LEVEL > 1 + aStructStack.push_back( 99 ); +#endif + } + } + else + { + // clear list maps in case a list has been interrupted + NumListIdMap& rNumListIdMap(mpPDFExtOutDevData->GetSwPDFState()->m_NumListIdMap); + rNumListIdMap.clear(); + NumListBodyIdMap& rNumListBodyIdMap(mpPDFExtOutDevData->GetSwPDFState()->m_NumListBodyIdMap); + rNumListBodyIdMap.clear(); + } + + // New tags: + const bool bNewListTag = (pNodeNum->GetParent()->IsFirst( pNodeNum ) || pTextNd->IsListRestart() || !bSameNumbering); + const bool bNewItemTag = bNewListTag || pTextNd->IsCountedInList(); // If the text node is not counted, we do not start a new list item: + + if ( bNewListTag ) + BeginTag( vcl::PDFWriter::List, aListString ); + + if ( bNewItemTag ) + { + BeginTag( vcl::PDFWriter::ListItem, aListItemString ); + assert(rTextFrame.GetPara()); + // check whether to open LBody now or delay until after Lbl + if (!rTextFrame.GetPara()->HasNumberingPortion(SwParaPortion::OnlyNumbering)) + { + BeginTag(vcl::PDFWriter::LIBody, aListBodyString); + } + } +} + +void SwTaggedPDFHelper::BeginBlockStructureElements() +{ + const SwFrame* pFrame = &mpFrameInfo->mrFrame; + + // Lowers of NonStructureElements should not be considered: + + if (lcl_IsInNonStructEnv(*pFrame) && !pFrame->IsFlyFrame()) + return; + + // Check if we have to reopen an existing structure element. + // This has to be done e.g., if pFrame is a follow frame. + if ( CheckReopenTag() ) + return; + + sal_uInt16 nPDFType = USHRT_MAX; + OUString aPDFType; + + switch ( pFrame->GetType() ) + { + /* + * GROUPING ELEMENTS + */ + + case SwFrameType::Page : + + // Document: Document + + nPDFType = vcl::PDFWriter::Document; + aPDFType = aDocumentString; + break; + + case SwFrameType::Header : + case SwFrameType::Footer : + + // Header, Footer: NonStructElement + + nPDFType = vcl::PDFWriter::NonStructElement; + break; + + case SwFrameType::FtnCont : + + // Footnote container: Division + + nPDFType = vcl::PDFWriter::Division; + aPDFType = aDivString; + break; + + case SwFrameType::Ftn : + + // Footnote frame: Note + + // Note: vcl::PDFWriter::Note is actually a ILSE. Nevertheless + // we treat it like a grouping element! + nPDFType = vcl::PDFWriter::Note; + aPDFType = aNoteString; + break; + + case SwFrameType::Section : + + // Section: TOX, Index, or Sect + + { + const SwSection* pSection = + static_cast(pFrame)->GetSection(); + + // open all parent sections, so that the SEs of sections + // are nested in the same way as their SwSectionNodes + std::vector parents; + for (SwSection const* pParent = pSection->GetParent(); + pParent != nullptr; pParent = pParent->GetParent()) + { + parents.push_back(pParent); + } + for (auto it = parents.rbegin(); it != parents.rend(); ++it) + { + // key is the SwSection - see lcl_GetKeyFromFrame() + OpenTagImpl(*it); + } + + FrameTagSet& rFrameTagSet(mpPDFExtOutDevData->GetSwPDFState()->m_FrameTagSet); + if (rFrameTagSet.find(pSection) != rFrameTagSet.end()) + { + // special case: section may have *multiple* master frames, + // when it is interrupted by nested section - reopen! + OpenTagImpl(pSection); + break; + } + else if (SectionType::ToxHeader == pSection->GetType()) + { + nPDFType = vcl::PDFWriter::Caption; + aPDFType = aCaptionString; + } + else if (SectionType::ToxContent == pSection->GetType()) + { + const SwTOXBase* pTOXBase = pSection->GetTOXBase(); + if ( pTOXBase ) + { + if ( TOX_INDEX == pTOXBase->GetType() ) + { + nPDFType = vcl::PDFWriter::Index; + aPDFType = aIndexString; + } + else + { + nPDFType = vcl::PDFWriter::TOC; + aPDFType = aTOCString; + } + } + } + else if ( SectionType::Content == pSection->GetType() ) + { + nPDFType = vcl::PDFWriter::Section; + aPDFType = aSectString; + } + } + break; + + /* + * BLOCK-LEVEL STRUCTURE ELEMENTS + */ + + case SwFrameType::Txt : + { + SwTextFrame const& rTextFrame(*static_cast(pFrame)); + const SwTextNode *const pTextNd(rTextFrame.GetTextNodeForParaProps()); + + // lazy open LBody after Lbl + if (!pTextNd->IsOutline() + && rTextFrame.GetPara()->HasNumberingPortion(SwParaPortion::OnlyNumbering)) + { + sal_Int32 const nId = BeginTagImpl(nullptr, vcl::PDFWriter::LIBody, aListBodyString); + SwNodeNum const*const pNodeNum(pTextNd->GetNum(rTextFrame.getRootFrame())); + NumListBodyIdMap& rNumListBodyIdMap(mpPDFExtOutDevData->GetSwPDFState()->m_NumListBodyIdMap); + rNumListBodyIdMap[ pNodeNum ] = nId; + } + + const SwFormat* pTextFormat = pTextNd->GetFormatColl(); + const SwFormat* pParentTextFormat = pTextFormat ? pTextFormat->DerivedFrom() : nullptr; + + OUString sStyleName; + OUString sParentStyleName; + + if ( pTextFormat) + SwStyleNameMapper::FillProgName( pTextFormat->GetName(), sStyleName, SwGetPoolIdFromName::TxtColl ); + if ( pParentTextFormat) + SwStyleNameMapper::FillProgName( pParentTextFormat->GetName(), sParentStyleName, SwGetPoolIdFromName::TxtColl ); + + // This is the default. If the paragraph could not be mapped to + // any of the standard pdf tags, we write a user defined tag + // with role = P + nPDFType = vcl::PDFWriter::Paragraph; + aPDFType = sStyleName; + + // Quotations: BlockQuote + + if (sStyleName == aQuotations) + { + nPDFType = vcl::PDFWriter::BlockQuote; + aPDFType = aBlockQuoteString; + } + + // Caption: Caption + + else if (sStyleName == aCaption) + { + nPDFType = vcl::PDFWriter::Caption; + aPDFType = aCaptionString; + } + + // Caption: Caption + + else if (sParentStyleName == aCaption) + { + nPDFType = vcl::PDFWriter::Caption; + aPDFType = sStyleName + aCaptionString; + } + + // Heading: H + + else if (sStyleName == aHeading) + { + nPDFType = vcl::PDFWriter::Heading; + aPDFType = aHString; + } + + // Heading: H1 - H6 + + if (int nRealLevel = pTextNd->GetAttrOutlineLevel() - 1; + nRealLevel >= 0 + && !pTextNd->IsInRedlines() + && sw::IsParaPropsNode(*pFrame->getRootFrame(), *pTextNd)) + { + switch(nRealLevel) + { + case 0 : + aPDFType = aH1String; + break; + case 1 : + aPDFType = aH2String; + break; + case 2 : + aPDFType = aH3String; + break; + case 3 : + aPDFType = aH4String; + break; + case 4 : + aPDFType = aH5String; + break; + case 5: + aPDFType = aH6String; + break; + case 6: + aPDFType = aH7String; + break; + case 7: + aPDFType = aH8String; + break; + case 8: + aPDFType = aH9String; + break; + case 9: + aPDFType = aH10String; + break; + default: + assert(false); + break; + } + + // PDF/UA allows unlimited headings, but PDF only up to H6 + // ... and apparently the extra H7.. must be declared in + // RoleMap, or veraPDF complains. + nRealLevel = std::min(nRealLevel, 5); + nPDFType = o3tl::narrowing(vcl::PDFWriter::H1 + nRealLevel); + } + + // Section: TOCI + + else if ( pFrame->IsInSct() ) + { + const SwSectionFrame* pSctFrame = pFrame->FindSctFrame(); + const SwSection* pSection = pSctFrame->GetSection(); + + if ( SectionType::ToxContent == pSection->GetType() ) + { + const SwTOXBase* pTOXBase = pSection->GetTOXBase(); + if ( pTOXBase && TOX_INDEX != pTOXBase->GetType() ) + { + // Special case: Open additional TOCI tag: + BeginTagImpl(nullptr, vcl::PDFWriter::TOCI, aTOCIString); + } + } + } + } + break; + + case SwFrameType::Tab : + + // TabFrame: Table + + nPDFType = vcl::PDFWriter::Table; + aPDFType = aTableString; + + { + // set up table column data: + const SwTabFrame* pTabFrame = static_cast(pFrame); + const SwTable* pTable = pTabFrame->GetTable(); + + TableColumnsMap& rTableColumnsMap(mpPDFExtOutDevData->GetSwPDFState()->m_TableColumnsMap); + const TableColumnsMap::const_iterator aIter = rTableColumnsMap.find( pTable ); + + if ( aIter == rTableColumnsMap.end() ) + { + SwRectFnSet aRectFnSet(pTabFrame); + TableColumnsMapEntry& rCols = rTableColumnsMap[ pTable ]; + + const SwTabFrame* pMasterFrame = pTabFrame->IsFollow() ? pTabFrame->FindMaster( true ) : pTabFrame; + + while ( pMasterFrame ) + { + const SwRowFrame* pRowFrame = static_cast(pMasterFrame->GetLower()); + + while ( pRowFrame ) + { + const SwFrame* pCellFrame = pRowFrame->GetLower(); + + const tools::Long nLeft = aRectFnSet.GetLeft(pCellFrame->getFrameArea()); + rCols.insert( nLeft ); + + while ( pCellFrame ) + { + const tools::Long nRight = aRectFnSet.GetRight(pCellFrame->getFrameArea()); + rCols.insert( nRight ); + pCellFrame = pCellFrame->GetNext(); + } + pRowFrame = static_cast(pRowFrame->GetNext()); + } + pMasterFrame = pMasterFrame->GetFollow(); + } + } + } + + break; + + /* + * TABLE ELEMENTS + */ + + case SwFrameType::Row : + + // RowFrame: TR + + if ( !static_cast(pFrame)->IsRepeatedHeadline() ) + { + nPDFType = vcl::PDFWriter::TableRow; + aPDFType = aTRString; + } + else + { + nPDFType = vcl::PDFWriter::NonStructElement; + } + break; + + case SwFrameType::Cell : + + // CellFrame: TH, TD + + { + const SwTabFrame* pTable = static_cast(pFrame)->FindTabFrame(); + if ( pTable->IsInHeadline( *pFrame ) || lcl_IsHeadlineCell( *static_cast(pFrame) ) ) + { + nPDFType = vcl::PDFWriter::TableHeader; + aPDFType = aTHString; + } + else + { + nPDFType = vcl::PDFWriter::TableData; + aPDFType = aTDString; + } + } + break; + + /* + * ILLUSTRATION + */ + + case SwFrameType::Fly : + + // FlyFrame: Figure, Formula, Control + // fly in content or fly at page + if (mpFrameInfo->m_isLink) + { // tdf#154939 additional inner link element for flys + nPDFType = vcl::PDFWriter::Link; + aPDFType = aLinkString; + } + else + { + const SwFlyFrame* pFly = static_cast(pFrame); + if (pFly->GetAnchorFrame()->FindFooterOrHeader() != nullptr + || pFly->GetFrameFormat().GetAttrSet().Get(RES_DECORATIVE).GetValue()) + { + nPDFType = vcl::PDFWriter::NonStructElement; + } + else if (pFly->Lower() && pFly->Lower()->IsNoTextFrame()) + { + bool bFormula = false; + + const SwNoTextFrame* pNoTextFrame = static_cast(pFly->Lower()); + SwOLENode* pOLENd = const_cast(pNoTextFrame->GetNode()->GetOLENode()); + if ( pOLENd ) + { + SwOLEObj& aOLEObj = pOLENd->GetOLEObj(); + uno::Reference< embed::XEmbeddedObject > aRef = aOLEObj.GetOleRef(); + if ( aRef.is() ) + { + bFormula = 0 != SotExchange::IsMath( SvGlobalName( aRef->getClassID() ) ); + } + } + if ( bFormula ) + { + nPDFType = vcl::PDFWriter::Formula; + aPDFType = aFormulaString; + } + else + { + nPDFType = vcl::PDFWriter::Figure; + aPDFType = aFigureString; + } + } + else + { + nPDFType = vcl::PDFWriter::Division; + aPDFType = aDivString; + } + } + break; + + default: break; + } + + if ( USHRT_MAX != nPDFType ) + { + BeginTag( static_cast(nPDFType), aPDFType ); + } +} + +void SwTaggedPDFHelper::EndStructureElements() +{ + if (mpFrameInfo != nullptr) + { + if (mpPDFExtOutDevData->GetSwPDFState()->m_oCurrentSpan) + { // close span at end of paragraph + mpPDFExtOutDevData->GetSwPDFState()->m_oCurrentSpan.reset(); + ++m_nEndStructureElement; + } + if (mpPDFExtOutDevData->GetSwPDFState()->m_oCurrentLink) + { // close link at end of paragraph + mpPDFExtOutDevData->GetSwPDFState()->m_oCurrentLink.reset(); + ++m_nEndStructureElement; + } + } + + while ( m_nEndStructureElement > 0 ) + { + EndTag(); + --m_nEndStructureElement; + } + + CheckRestoreTag(); +} + +void SwTaggedPDFHelper::EndCurrentLink(OutputDevice const& rOut) +{ + vcl::PDFExtOutDevData *const pPDFExtOutDevData( + dynamic_cast(rOut.GetExtOutDevData())); + if (pPDFExtOutDevData && pPDFExtOutDevData->GetSwPDFState()->m_oCurrentLink) + { + pPDFExtOutDevData->GetSwPDFState()->m_oCurrentLink.reset(); + pPDFExtOutDevData->EndStructureElement(); +#if OSL_DEBUG_LEVEL > 1 + aStructStack.pop_back(); +#endif + } +} + +void SwTaggedPDFHelper::EndCurrentAll() +{ + if (mpPDFExtOutDevData->GetSwPDFState()->m_oCurrentSpan) + { + mpPDFExtOutDevData->GetSwPDFState()->m_oCurrentSpan.reset(); + } + if (mpPDFExtOutDevData->GetSwPDFState()->m_oCurrentLink) + { + mpPDFExtOutDevData->GetSwPDFState()->m_oCurrentLink.reset(); + } +} + +void SwTaggedPDFHelper::EndCurrentSpan() +{ + mpPDFExtOutDevData->GetSwPDFState()->m_oCurrentSpan.reset(); + EndTag(); // close span +} + +void SwTaggedPDFHelper::CreateCurrentSpan( + SwTextPaintInfo const& rInf, OUString const& rStyleName) +{ + assert(!mpPDFExtOutDevData->GetSwPDFState()->m_oCurrentSpan); + mpPDFExtOutDevData->GetSwPDFState()->m_oCurrentSpan.emplace( + SwEnhancedPDFState::Span{ + rInf.GetFont()->GetUnderline(), + rInf.GetFont()->GetOverline(), + rInf.GetFont()->GetStrikeout(), + rInf.GetFont()->GetEmphasisMark(), + rInf.GetFont()->GetEscapement(), + rInf.GetFont()->GetActual(), + rInf.GetFont()->GetLanguage(), + rStyleName}); + // leave it open to let next portion decide to merge or close + --m_nEndStructureElement; +} + +bool SwTaggedPDFHelper::CheckContinueSpan( + SwTextPaintInfo const& rInf, std::u16string_view const rStyleName, + SwTextAttr const*const pInetFormatAttr) +{ + // for now, don't create span inside of link - this should be very rare + // situation and it looks complicated to implement. + assert(!mpPDFExtOutDevData->GetSwPDFState()->m_oCurrentSpan + || !mpPDFExtOutDevData->GetSwPDFState()->m_oCurrentLink); + if (mpPDFExtOutDevData->GetSwPDFState()->m_oCurrentLink) + { + if (pInetFormatAttr && pInetFormatAttr == *mpPDFExtOutDevData->GetSwPDFState()->m_oCurrentLink) + { + return true; + } + else + { + mpPDFExtOutDevData->GetSwPDFState()->m_oCurrentLink.reset(); + EndTag(); + return false; + } + } + if (mpPDFExtOutDevData->GetSwPDFState()->m_oCurrentSpan && pInetFormatAttr) + { + EndCurrentSpan(); + return false; + } + + if (!mpPDFExtOutDevData->GetSwPDFState()->m_oCurrentSpan) + return false; + + SwEnhancedPDFState::Span const& rCurrent(*mpPDFExtOutDevData->GetSwPDFState()->m_oCurrentSpan); + + bool const ret(rCurrent.eUnderline == rInf.GetFont()->GetUnderline() + && rCurrent.eOverline == rInf.GetFont()->GetOverline() + && rCurrent.eStrikeout == rInf.GetFont()->GetStrikeout() + && rCurrent.eFontEmphasis == rInf.GetFont()->GetEmphasisMark() + && rCurrent.nEscapement == rInf.GetFont()->GetEscapement() + && rCurrent.nScript == rInf.GetFont()->GetActual() + && rCurrent.nLang == rInf.GetFont()->GetLanguage() + && rCurrent.StyleName == rStyleName); + if (!ret) + { + EndCurrentSpan(); + } + return ret; +} + +void SwTaggedPDFHelper::BeginInlineStructureElements() +{ + const SwLinePortion* pPor = &mpPorInfo->mrPor; + const SwTextPaintInfo& rInf = mpPorInfo->mrTextPainter.GetInfo(); + const SwTextFrame* pFrame = rInf.GetTextFrame(); + + // Lowers of NonStructureElements should not be considered: + + if ( lcl_IsInNonStructEnv( *pFrame ) ) + return; + + std::pair const pos( + pFrame->MapViewToModel(rInf.GetIdx())); + SwTextAttr const*const pInetFormatAttr = + pos.first->GetTextAttrAt(pos.second, RES_TXTATR_INETFMT); + + OUString sStyleName; + if (!pInetFormatAttr) + { + std::vector const charAttrs( + pos.first->GetTextAttrsAt(pos.second, RES_TXTATR_CHARFMT)); + // TODO: handle more than 1 char style? + const SwCharFormat* pCharFormat = (charAttrs.size()) + ? (*charAttrs.begin())->GetCharFormat().GetCharFormat() : nullptr; + if (pCharFormat) + SwStyleNameMapper::FillProgName( pCharFormat->GetName(), sStyleName, SwGetPoolIdFromName::TxtColl ); + } + + // note: ILSE may be nested, so only end the span if needed to start new one + bool const isContinueSpan(CheckContinueSpan(rInf, sStyleName, pInetFormatAttr)); + + sal_uInt16 nPDFType = USHRT_MAX; + OUString aPDFType; + + switch ( pPor->GetWhichPor() ) + { + case PortionType::Hyphen : + case PortionType::SoftHyphen : + // Check for alternative spelling: + case PortionType::HyphenStr : + case PortionType::SoftHyphenStr : + nPDFType = vcl::PDFWriter::Span; + aPDFType = aSpanString; + break; + + case PortionType::Fly: + // if a link is split by a fly overlap, then there will be multiple + // annotations for the link, and hence there must be multiple SEs, + // so every annotation has its own SE. + if (mpPDFExtOutDevData->GetSwPDFState()->m_oCurrentLink) + { + mpPDFExtOutDevData->GetSwPDFState()->m_oCurrentLink.reset(); + EndTag(); + } + break; + + case PortionType::Lay : + case PortionType::Text : + case PortionType::Para : + { + // Check for Link: + if( pInetFormatAttr ) + { + if (!isContinueSpan) + { + nPDFType = vcl::PDFWriter::Link; + aPDFType = aLinkString; + assert(!mpPDFExtOutDevData->GetSwPDFState()->m_oCurrentLink); + mpPDFExtOutDevData->GetSwPDFState()->m_oCurrentLink.emplace(pInetFormatAttr); + // leave it open to let next portion decide to merge or close + --m_nEndStructureElement; + } + } + // Check for Quote/Code character style: + else if (sStyleName == aQuotation) + { + if (!isContinueSpan) + { + nPDFType = vcl::PDFWriter::Quote; + aPDFType = aQuoteString; + CreateCurrentSpan(rInf, sStyleName); + } + } + else if (sStyleName == aSourceText) + { + if (!isContinueSpan) + { + nPDFType = vcl::PDFWriter::Code; + aPDFType = aCodeString; + CreateCurrentSpan(rInf, sStyleName); + } + } + else if (!isContinueSpan) + { + const LanguageType nCurrentLanguage = rInf.GetFont()->GetLanguage(); + const SwFontScript nFont = rInf.GetFont()->GetActual(); + const LanguageType nDefaultLang(mpPDFExtOutDevData->GetSwPDFState()->m_eLanguageDefault); + + if ( LINESTYLE_NONE != rInf.GetFont()->GetUnderline() || + LINESTYLE_NONE != rInf.GetFont()->GetOverline() || + STRIKEOUT_NONE != rInf.GetFont()->GetStrikeout() || + FontEmphasisMark::NONE != rInf.GetFont()->GetEmphasisMark() || + 0 != rInf.GetFont()->GetEscapement() || + SwFontScript::Latin != nFont || + nCurrentLanguage != nDefaultLang || + !sStyleName.isEmpty()) + { + nPDFType = vcl::PDFWriter::Span; + if (!sStyleName.isEmpty()) + aPDFType = sStyleName; + else + aPDFType = aSpanString; + CreateCurrentSpan(rInf, sStyleName); + } + } + } + break; + + case PortionType::Footnote : + nPDFType = vcl::PDFWriter::Link; + aPDFType = aLinkString; + break; + + case PortionType::Field : + { + // check field type: + TextFrameIndex const nIdx = static_cast(pPor)->IsFollow() + ? rInf.GetIdx() - TextFrameIndex(1) + : rInf.GetIdx(); + const SwTextAttr* pHint = mpPorInfo->mrTextPainter.GetAttr( nIdx ); + if ( pHint && RES_TXTATR_FIELD == pHint->Which() ) + { + const SwField* pField = pHint->GetFormatField().GetField(); + if ( SwFieldIds::GetRef == pField->Which() ) + { + nPDFType = vcl::PDFWriter::Link; + aPDFType = aLinkString; + } + else if ( SwFieldIds::TableOfAuthorities == pField->Which() ) + { + nPDFType = vcl::PDFWriter::BibEntry; + aPDFType = aBibEntryString; + } + } + } + break; + + case PortionType::Multi: + { + SwMultiPortion const*const pMulti(static_cast(pPor)); + if (pMulti->IsRuby()) + { + EndCurrentAll(); + switch (mpPorInfo->m_Mode) + { + case 0: + nPDFType = vcl::PDFWriter::Ruby; + aPDFType = "Ruby"; + break; + case 1: + nPDFType = vcl::PDFWriter::RT; + aPDFType = "RT"; + break; + case 2: + nPDFType = vcl::PDFWriter::RB; + aPDFType = "RB"; + break; + } + } + else if (pMulti->IsDouble()) + { + EndCurrentAll(); + switch (mpPorInfo->m_Mode) + { + case 0: + nPDFType = vcl::PDFWriter::Warichu; + aPDFType = "Warichu"; + break; + case 1: + nPDFType = vcl::PDFWriter::WP; + aPDFType = "WP"; + break; + case 2: + nPDFType = vcl::PDFWriter::WT; + aPDFType = "WT"; + break; + } + } + } + break; + + + // for FootnoteNum, is called twice: outer generates Lbl, inner Link + case PortionType::FootnoteNum: + assert(!isContinueSpan); // is at start + if (mpPorInfo->m_Mode == 0) + { // tdf#152218 link both directions + nPDFType = vcl::PDFWriter::Link; + aPDFType = aLinkString; + break; + } + [[fallthrough]]; + case PortionType::Number: + case PortionType::Bullet: + case PortionType::GrfNum: + assert(!isContinueSpan); // is at start + if (mpPorInfo->m_Mode == 1) + { // only works for multiple lines via wrapper from PaintSwFrame + nPDFType = vcl::PDFWriter::LILabel; + aPDFType = aListLabelString; + } + break; + + case PortionType::Tab : + case PortionType::TabRight : + case PortionType::TabCenter : + case PortionType::TabDecimal : + nPDFType = vcl::PDFWriter::NonStructElement; + break; + default: break; + } + + if ( USHRT_MAX != nPDFType ) + { + BeginTag( static_cast(nPDFType), aPDFType ); + } +} + +bool SwTaggedPDFHelper::IsExportTaggedPDF( const OutputDevice& rOut ) +{ + vcl::PDFExtOutDevData* pPDFExtOutDevData = dynamic_cast< vcl::PDFExtOutDevData*>( rOut.GetExtOutDevData() ); + return pPDFExtOutDevData && pPDFExtOutDevData->GetIsExportTaggedPDF(); +} + +SwEnhancedPDFExportHelper::SwEnhancedPDFExportHelper( SwEditShell& rSh, + OutputDevice& rOut, + const OUString& rPageRange, + bool bSkipEmptyPages, + bool bEditEngineOnly, + const SwPrintData& rPrintData ) + : mrSh( rSh ), + mrOut( rOut ), + mbSkipEmptyPages( bSkipEmptyPages ), + mbEditEngineOnly( bEditEngineOnly ), + mrPrintData( rPrintData ) +{ + if ( !rPageRange.isEmpty() ) + mpRangeEnum.reset( new StringRangeEnumerator( rPageRange, 0, mrSh.GetPageCount()-1 ) ); + + if ( mbSkipEmptyPages ) + { + maPageNumberMap.resize( mrSh.GetPageCount() ); + const SwPageFrame* pCurrPage = + static_cast( mrSh.GetLayout()->Lower() ); + sal_Int32 nPageNumber = 0; + for ( size_t i = 0, n = maPageNumberMap.size(); i < n && pCurrPage; ++i ) + { + if ( pCurrPage->IsEmptyPage() ) + maPageNumberMap[i] = -1; + else + maPageNumberMap[i] = nPageNumber++; + + pCurrPage = static_cast( pCurrPage->GetNext() ); + } + } + +#if OSL_DEBUG_LEVEL > 1 + aStructStack.clear(); +#endif + + const sal_Int16 nScript = SvtLanguageOptions::GetI18NScriptTypeOfLanguage( GetAppLanguage() ); + TypedWhichId nLangRes = RES_CHRATR_LANGUAGE; + + if ( i18n::ScriptType::ASIAN == nScript ) + nLangRes = RES_CHRATR_CJK_LANGUAGE; + else if ( i18n::ScriptType::COMPLEX == nScript ) + nLangRes = RES_CHRATR_CTL_LANGUAGE; + + const SvxLanguageItem& rLangItem = mrSh.GetDoc()->GetDefault( nLangRes ); + auto const eLanguageDefault = rLangItem.GetLanguage(); + + EnhancedPDFExport(eLanguageDefault); +} + +SwEnhancedPDFExportHelper::~SwEnhancedPDFExportHelper() +{ +} + +tools::Rectangle SwEnhancedPDFExportHelper::SwRectToPDFRect(const SwPageFrame* pCurrPage, + const tools::Rectangle& rRectangle) const +{ + if (!::sw::IsShrinkPageForPostIts(mrSh, mrPrintData)) // tdf#148729 + { + return rRectangle; + } + //the page has been scaled by 75% and vertically centered, so adjust these + //rectangles equivalently + tools::Rectangle aRect(rRectangle); + Size aRectSize(aRect.GetSize()); + double fScale = 0.75; + aRectSize.setWidth( aRectSize.Width() * fScale ); + aRectSize.setHeight( aRectSize.Height() * fScale ); + tools::Long nOrigHeight = pCurrPage->getFrameArea().Height(); + tools::Long nNewHeight = nOrigHeight*fScale; + tools::Long nShiftY = (nOrigHeight-nNewHeight)/2; + aRect.SetLeft( aRect.Left() * fScale ); + aRect.SetTop( aRect.Top() * fScale ); + aRect.Move(0, nShiftY); + aRect.SetSize(aRectSize); + return aRect; +} + +void SwEnhancedPDFExportHelper::EnhancedPDFExport(LanguageType const eLanguageDefault) +{ + vcl::PDFExtOutDevData* pPDFExtOutDevData = + dynamic_cast< vcl::PDFExtOutDevData*>( mrOut.GetExtOutDevData() ); + + if ( !pPDFExtOutDevData ) + return; + + // set the document locale + + lang::Locale const aDocLocale( LanguageTag(eLanguageDefault).getLocale() ); + pPDFExtOutDevData->SetDocumentLocale( aDocLocale ); + + // Prepare the output device: + + mrOut.Push( vcl::PushFlags::MAPMODE ); + MapMode aMapMode( mrOut.GetMapMode() ); + aMapMode.SetMapUnit( MapUnit::MapTwip ); + mrOut.SetMapMode( aMapMode ); + + // Create new cursor and lock the view: + + SwDoc* pDoc = mrSh.GetDoc(); + mrSh.SwCursorShell::Push(); + mrSh.SwCursorShell::ClearMark(); + const bool bOldLockView = mrSh.IsViewLocked(); + mrSh.LockView( true ); + + if ( !mbEditEngineOnly ) + { + assert(pPDFExtOutDevData->GetSwPDFState() == nullptr); + pPDFExtOutDevData->SetSwPDFState(new SwEnhancedPDFState(eLanguageDefault)); + + // POSTITS + + if ( pPDFExtOutDevData->GetIsExportNotes() ) + { + std::vector vpFields; + mrSh.GetFieldType(SwFieldIds::Postit, OUString())->GatherFields(vpFields); + for(auto pFormatField : vpFields) + { + const SwTextNode* pTNd = pFormatField->GetTextField()->GetpTextNode(); + OSL_ENSURE(nullptr != pTNd, "Enhanced pdf export - text node is missing"); + if(!lcl_TryMoveToNonHiddenField(mrSh, *pTNd, *pFormatField)) + continue; + // Link Rectangle + const SwRect& rNoteRect = mrSh.GetCharRect(); + const SwPageFrame* pCurrPage = static_cast(mrSh.GetLayout()->Lower()); + + // Link PageNums + std::vector aNotePageNums = CalcOutputPageNums(rNoteRect); + for (sal_Int32 aNotePageNum : aNotePageNums) + { + + // Use the NumberFormatter to get the date string: + const SwPostItField* pField = static_cast(pFormatField->GetField()); + SvNumberFormatter* pNumFormatter = pDoc->GetNumberFormatter(); + const Date aDateDiff(pField->GetDate() - pNumFormatter->GetNullDate()); + const sal_uLong nFormat = pNumFormatter->GetStandardFormat(SvNumFormatType::DATE, pField->GetLanguage()); + OUString sDate; + const Color* pColor; + pNumFormatter->GetOutputString(aDateDiff.GetDate(), nFormat, sDate, &pColor); + + vcl::PDFNote aNote; + // The title should consist of the author and the date: + aNote.Title = pField->GetPar1() + ", " + sDate + ", " + (pField->GetResolved() ? SwResId(STR_RESOLVED) : ""); + // Guess what the contents contains... + aNote.Contents = pField->GetText(); + + // Link Export + tools::Rectangle aRect(SwRectToPDFRect(pCurrPage, rNoteRect.SVRect())); + pPDFExtOutDevData->CreateNote(aRect, aNote, aNotePageNum); + } + mrSh.SwCursorShell::ClearMark(); + } + } + + // HYPERLINKS + + SwGetINetAttrs aArr; + mrSh.GetINetAttrs( aArr ); + for( auto &rAttr : aArr ) + { + SwGetINetAttr* p = &rAttr; + OSL_ENSURE( nullptr != p, "Enhanced pdf export - SwGetINetAttr is missing" ); + + const SwTextNode* pTNd = p->rINetAttr.GetpTextNode(); + OSL_ENSURE( nullptr != pTNd, "Enhanced pdf export - text node is missing" ); + + // 1. Check if the whole paragraph is hidden + // 2. Move to the hyperlink + // 3. Check for hidden text attribute + if ( !pTNd->IsHidden() && + mrSh.GotoINetAttr( p->rINetAttr ) && + !mrSh.IsInHiddenRange(/*bSelect=*/false) ) + { + // Select the hyperlink: + mrSh.SwCursorShell::Right( 1, SwCursorSkipMode::Chars ); + if ( mrSh.SwCursorShell::SelectTextAttr( RES_TXTATR_INETFMT, true ) ) + { + // First, we create the destination, because there may be more + // than one link to this destination: + OUString aURL( INetURLObject::decode( + p->rINetAttr.GetINetFormat().GetValue(), + INetURLObject::DecodeMechanism::Unambiguous ) ); + + // We have to distinguish between internal and real URLs + const bool bInternal = '#' == aURL[0]; + + // GetCursor_() is a SwShellCursor, which is derived from + // SwSelPaintRects, therefore the rectangles of the current + // selection can be easily obtained: + // Note: We make a copy of the rectangles, because they may + // be deleted again in JumpToSwMark. + SwRects const aTmp(GetCursorRectsContainingText(mrSh)); + OSL_ENSURE( !aTmp.empty(), "Enhanced pdf export - rectangles are missing" ); + OUString const altText(mrSh.GetSelText()); + + const SwPageFrame* pSelectionPage = + static_cast( mrSh.GetLayout()->Lower() ); + + // Create the destination for internal links: + sal_Int32 nDestId = -1; + if ( bInternal ) + { + aURL = aURL.copy( 1 ); + mrSh.SwCursorShell::ClearMark(); + if (! JumpToSwMark( &mrSh, aURL )) + { + continue; // target deleted + } + + // Destination Rectangle + const SwRect& rDestRect = mrSh.GetCharRect(); + + const SwPageFrame* pCurrPage = + static_cast( mrSh.GetLayout()->Lower() ); + + // Destination PageNum + const sal_Int32 nDestPageNum = CalcOutputPageNum( rDestRect ); + + // Destination Export + if ( -1 != nDestPageNum ) + { + tools::Rectangle aRect(SwRectToPDFRect(pCurrPage, rDestRect.SVRect())); + nDestId = pPDFExtOutDevData->CreateDest(aRect, nDestPageNum); + } + } + + if ( !bInternal || -1 != nDestId ) + { + // #i44368# Links in Header/Footer + const bool bHeaderFooter = pDoc->IsInHeaderFooter( *pTNd ); + + // Create links for all selected rectangles: + const size_t nNumOfRects = aTmp.size(); + for ( size_t i = 0; i < nNumOfRects; ++i ) + { + // Link Rectangle + const SwRect& rLinkRect( aTmp[ i ] ); + + // Link PageNums + std::vector aLinkPageNums = CalcOutputPageNums( rLinkRect ); + + for (sal_Int32 aLinkPageNum : aLinkPageNums) + { + // Link Export + tools::Rectangle aRect(SwRectToPDFRect(pSelectionPage, rLinkRect.SVRect())); + const sal_Int32 nLinkId = + pPDFExtOutDevData->CreateLink(aRect, altText, aLinkPageNum); + + // Store link info for tagged pdf output: + const IdMapEntry aLinkEntry( rLinkRect, nLinkId ); + pPDFExtOutDevData->GetSwPDFState()->m_LinkIdMap.push_back(aLinkEntry); + + // Connect Link and Destination: + if ( bInternal ) + pPDFExtOutDevData->SetLinkDest( nLinkId, nDestId ); + else + pPDFExtOutDevData->SetLinkURL( nLinkId, aURL ); + + // #i44368# Links in Header/Footer + if ( bHeaderFooter ) + MakeHeaderFooterLinks(*pPDFExtOutDevData, *pTNd, rLinkRect, nDestId, aURL, bInternal, altText); + } + } + } + } + } + mrSh.SwCursorShell::ClearMark(); + } + + // HYPERLINKS (Graphics, Frames, OLEs ) + + for(sw::SpzFrameFormat* pFrameFormat: *pDoc->GetSpzFrameFormats()) + { + const SwFormatURL* pItem; + if ( RES_DRAWFRMFMT != pFrameFormat->Which() && + GetFrameOfModify(mrSh.GetLayout(), *pFrameFormat, SwFrameType::Fly) && + (pItem = pFrameFormat->GetAttrSet().GetItemIfSet( RES_URL )) ) + { + const SwPageFrame* pCurrPage = + static_cast( mrSh.GetLayout()->Lower() ); + + OUString aURL( pItem->GetURL() ); + if (aURL.isEmpty()) + continue; + const bool bInternal = '#' == aURL[0]; + + // Create the destination for internal links: + sal_Int32 nDestId = -1; + if ( bInternal ) + { + aURL = aURL.copy( 1 ); + mrSh.SwCursorShell::ClearMark(); + if (! JumpToSwMark( &mrSh, aURL )) + { + continue; // target deleted + } + + // Destination Rectangle + const SwRect& rDestRect = mrSh.GetCharRect(); + + pCurrPage = static_cast( mrSh.GetLayout()->Lower() ); + + // Destination PageNum + const sal_Int32 nDestPageNum = CalcOutputPageNum( rDestRect ); + + // Destination Export + if ( -1 != nDestPageNum ) + { + tools::Rectangle aRect(SwRectToPDFRect(pCurrPage, rDestRect.SVRect())); + nDestId = pPDFExtOutDevData->CreateDest(aRect, nDestPageNum); + } + } + + if ( !bInternal || -1 != nDestId ) + { + Point aNullPt; + const SwRect aLinkRect = pFrameFormat->FindLayoutRect( false, &aNullPt ); + OUString const formatName(pFrameFormat->GetName()); + // Link PageNums + std::vector aLinkPageNums = CalcOutputPageNums( aLinkRect ); + + // Link Export + for (sal_Int32 aLinkPageNum : aLinkPageNums) + { + tools::Rectangle aRect(SwRectToPDFRect(pCurrPage, aLinkRect.SVRect())); + const sal_Int32 nLinkId = + pPDFExtOutDevData->CreateLink(aRect, formatName, aLinkPageNum); + + // Store link info for tagged pdf output: + const IdMapEntry aLinkEntry(aLinkRect, nLinkId); + pPDFExtOutDevData->GetSwPDFState()->m_LinkIdMap.push_back(aLinkEntry); + + // Connect Link and Destination: + if ( bInternal ) + pPDFExtOutDevData->SetLinkDest( nLinkId, nDestId ); + else + pPDFExtOutDevData->SetLinkURL( nLinkId, aURL ); + + // #i44368# Links in Header/Footer + const SwFormatAnchor &rAnch = pFrameFormat->GetAnchor(); + if (RndStdIds::FLY_AT_PAGE != rAnch.GetAnchorId()) + { + const SwNode* pAnchorNode = rAnch.GetAnchorNode(); + if ( pAnchorNode && pDoc->IsInHeaderFooter( *pAnchorNode ) ) + { + const SwTextNode* pTNd = pAnchorNode->GetTextNode(); + if ( pTNd ) + MakeHeaderFooterLinks(*pPDFExtOutDevData, *pTNd, aLinkRect, nDestId, aURL, bInternal, formatName); + } + } + } + } + } + else if (pFrameFormat->Which() == RES_DRAWFRMFMT) + { + // Turn media shapes into Screen annotations. + if (SdrObject* pObject = pFrameFormat->FindRealSdrObject()) + { + SwRect aSnapRect(pObject->GetSnapRect()); + std::vector aScreenPageNums = CalcOutputPageNums(aSnapRect); + if (aScreenPageNums.empty()) + continue; + + uno::Reference xShape(pObject->getUnoShape(), uno::UNO_QUERY); + if (xShape->getShapeType() == "com.sun.star.drawing.MediaShape") + { + uno::Reference xShapePropSet(xShape, uno::UNO_QUERY); + OUString title; + xShapePropSet->getPropertyValue("Title") >>= title; + OUString description; + xShapePropSet->getPropertyValue("Description") >>= description; + OUString const altText(title.isEmpty() + ? description + : description.isEmpty() + ? title + : OUString::Concat(title) + OUString::Concat("\n") + OUString::Concat(description)); + + OUString aMediaURL; + xShapePropSet->getPropertyValue("MediaURL") >>= aMediaURL; + if (!aMediaURL.isEmpty()) + { + OUString const mimeType(xShapePropSet->getPropertyValue("MediaMimeType").get()); + const SwPageFrame* pCurrPage = mrSh.GetLayout()->GetPageAtPos(aSnapRect.Center()); + tools::Rectangle aPDFRect(SwRectToPDFRect(pCurrPage, aSnapRect.SVRect())); + for (sal_Int32 nScreenPageNum : aScreenPageNums) + { + sal_Int32 nScreenId = pPDFExtOutDevData->CreateScreen(aPDFRect, altText, mimeType, nScreenPageNum, pObject); + if (aMediaURL.startsWith("vnd.sun.star.Package:")) + { + // Embedded media. + OUString aTempFileURL; + xShapePropSet->getPropertyValue("PrivateTempFileURL") >>= aTempFileURL; + pPDFExtOutDevData->SetScreenStream(nScreenId, aTempFileURL); + } + else + // Linked media. + pPDFExtOutDevData->SetScreenURL(nScreenId, aMediaURL); + } + } + } + } + } + mrSh.SwCursorShell::ClearMark(); + } + + // REFERENCES + + std::vector vpFields; + mrSh.GetFieldType( SwFieldIds::GetRef, OUString() )->GatherFields(vpFields); + for(auto pFormatField : vpFields ) + { + if( pFormatField->GetTextField() && pFormatField->IsFieldInDoc() ) + { + const SwTextNode* pTNd = pFormatField->GetTextField()->GetpTextNode(); + OSL_ENSURE( nullptr != pTNd, "Enhanced pdf export - text node is missing" ); + if(!lcl_TryMoveToNonHiddenField(mrSh, *pTNd, *pFormatField)) + continue; + // Select the field: + mrSh.SwCursorShell::SetMark(); + mrSh.SwCursorShell::Right( 1, SwCursorSkipMode::Chars ); + + // Link Rectangles + SwRects const aTmp(GetCursorRectsContainingText(mrSh)); + OSL_ENSURE( !aTmp.empty(), "Enhanced pdf export - rectangles are missing" ); + + mrSh.SwCursorShell::ClearMark(); + + // Destination Rectangle + const SwGetRefField* pField = static_cast(pFormatField->GetField()); + const OUString& rRefName = pField->GetSetRefName(); + mrSh.GotoRefMark( rRefName, pField->GetSubType(), pField->GetSeqNo(), pField->GetFlags() ); + const SwRect& rDestRect = mrSh.GetCharRect(); + + const SwPageFrame* pCurrPage = static_cast( mrSh.GetLayout()->Lower() ); + + // Destination PageNum + const sal_Int32 nDestPageNum = CalcOutputPageNum( rDestRect ); + + if ( -1 != nDestPageNum ) + { + // Destination Export + tools::Rectangle aRect(SwRectToPDFRect(pCurrPage, rDestRect.SVRect())); + const sal_Int32 nDestId = pPDFExtOutDevData->CreateDest(aRect, nDestPageNum); + + // #i44368# Links in Header/Footer + const bool bHeaderFooter = pDoc->IsInHeaderFooter( *pTNd ); + OUString const content(pField->ExpandField(true, mrSh.GetLayout())); + + // Create links for all selected rectangles: + const size_t nNumOfRects = aTmp.size(); + for ( size_t i = 0; i < nNumOfRects; ++i ) + { + // Link rectangle + const SwRect& rLinkRect( aTmp[ i ] ); + + // Link PageNums + std::vector aLinkPageNums = CalcOutputPageNums( rLinkRect ); + + for (sal_Int32 aLinkPageNum : aLinkPageNums) + { + // Link Export + aRect = SwRectToPDFRect(pCurrPage, rLinkRect.SVRect()); + const sal_Int32 nLinkId = + pPDFExtOutDevData->CreateLink(aRect, content, aLinkPageNum); + + // Store link info for tagged pdf output: + const IdMapEntry aLinkEntry( rLinkRect, nLinkId ); + pPDFExtOutDevData->GetSwPDFState()->m_LinkIdMap.push_back(aLinkEntry); + + // Connect Link and Destination: + pPDFExtOutDevData->SetLinkDest( nLinkId, nDestId ); + + // #i44368# Links in Header/Footer + if ( bHeaderFooter ) + { + MakeHeaderFooterLinks(*pPDFExtOutDevData, *pTNd, rLinkRect, nDestId, "", true, content); + } + } + } + } + } + mrSh.SwCursorShell::ClearMark(); + } + + ExportAuthorityEntryLinks(); + + // FOOTNOTES + + const size_t nFootnoteCount = pDoc->GetFootnoteIdxs().size(); + for ( size_t nIdx = 0; nIdx < nFootnoteCount; ++nIdx ) + { + // Set cursor to text node that contains the footnote: + const SwTextFootnote* pTextFootnote = pDoc->GetFootnoteIdxs()[ nIdx ]; + SwTextNode& rTNd = const_cast(pTextFootnote->GetTextNode()); + + mrSh.GetCursor_()->GetPoint()->Assign(rTNd, pTextFootnote->GetStart()); + + // 1. Check if the whole paragraph is hidden + // 2. Check for hidden text attribute + if (rTNd.GetTextNode()->IsHidden() || mrSh.IsInHiddenRange(/*bSelect=*/false) + || (mrSh.GetLayout()->IsHideRedlines() + && sw::IsFootnoteDeleted(pDoc->getIDocumentRedlineAccess(), *pTextFootnote))) + { + continue; + } + + SwCursorSaveState aSaveState( *mrSh.GetCursor_() ); + + // Select the footnote: + mrSh.SwCursorShell::SetMark(); + mrSh.SwCursorShell::Right( 1, SwCursorSkipMode::Chars ); + + // Link Rectangle + SwRects aTmp; + aTmp.insert( aTmp.begin(), mrSh.SwCursorShell::GetCursor_()->begin(), mrSh.SwCursorShell::GetCursor_()->end() ); + OSL_ENSURE( !aTmp.empty(), "Enhanced pdf export - rectangles are missing" ); + + mrSh.GetCursor_()->RestoreSavePos(); + mrSh.SwCursorShell::ClearMark(); + + if (aTmp.empty()) + continue; + + const SwRect aLinkRect( aTmp[ 0 ] ); + + // Goto footnote text: + if ( mrSh.GotoFootnoteText() ) + { + // Destination Rectangle + const SwRect& rDestRect = mrSh.GetCharRect(); + const sal_Int32 nDestPageNum = CalcOutputPageNum( rDestRect ); + if ( -1 != nDestPageNum ) + { + const SwPageFrame* pCurrPage = static_cast( mrSh.GetLayout()->Lower() ); + // Destination PageNum + tools::Rectangle aRect = SwRectToPDFRect(pCurrPage, rDestRect.SVRect()); + // Back link rectangle calculation + const SwPageFrame* fnBodyPage = pCurrPage->getRootFrame()->GetPageByPageNum(nDestPageNum+1); + SwRect fnSymbolRect; + if (fnBodyPage->IsVertical()){ + tools::Long fnSymbolTop = fnBodyPage->GetTopMargin() + fnBodyPage->getFrameArea().Top(); + tools::Long symbolHeight = rDestRect.Top() - fnSymbolTop; + fnSymbolRect = SwRect(rDestRect.Pos().X(),fnSymbolTop,rDestRect.Width(),symbolHeight); + } else { + if (fnBodyPage->IsRightToLeft()){ + tools::Long fnSymbolRight = fnBodyPage->getFrameArea().Right() - fnBodyPage->GetRightMargin(); + tools::Long symbolWidth = fnSymbolRight - rDestRect.Right(); + fnSymbolRect = SwRect(rDestRect.Pos().X(),rDestRect.Pos().Y(),symbolWidth,rDestRect.Height()); + } else { + tools::Long fnSymbolLeft = fnBodyPage->GetLeftMargin() + fnBodyPage->getFrameArea().Left(); + tools::Long symbolWidth = rDestRect.Left() - fnSymbolLeft; + fnSymbolRect = SwRect(fnSymbolLeft,rDestRect.Pos().Y(),symbolWidth,rDestRect.Height()); + } + } + tools::Rectangle aFootnoteSymbolRect = SwRectToPDFRect(pCurrPage, fnSymbolRect.SVRect()); + + OUString const numStrSymbol(pTextFootnote->GetFootnote().GetViewNumStr(*pDoc, mrSh.GetLayout(), true)); + OUString const numStrRef(pTextFootnote->GetFootnote().GetViewNumStr(*pDoc, mrSh.GetLayout(), false)); + + // Export back link + const sal_Int32 nBackLinkId = pPDFExtOutDevData->CreateLink(aFootnoteSymbolRect, numStrSymbol, nDestPageNum); + // Destination Export + const sal_Int32 nDestId = pPDFExtOutDevData->CreateDest(aRect, nDestPageNum); + mrSh.GotoFootnoteAnchor(); + // Link PageNums + sal_Int32 aLinkPageNum = CalcOutputPageNum( aLinkRect ); + pCurrPage = static_cast( mrSh.GetLayout()->Lower() ); + // Link Export + aRect = SwRectToPDFRect(pCurrPage, aLinkRect.SVRect()); + const sal_Int32 nLinkId = pPDFExtOutDevData->CreateLink(aRect, numStrRef, aLinkPageNum); + // Back link destination Export + const sal_Int32 nBackDestId = pPDFExtOutDevData->CreateDest(aRect, aLinkPageNum); + // Store link info for tagged pdf output: + const IdMapEntry aLinkEntry( aLinkRect, nLinkId ); + pPDFExtOutDevData->GetSwPDFState()->m_LinkIdMap.push_back(aLinkEntry); + + // Store backlink info for tagged pdf output: + const IdMapEntry aBackLinkEntry( aFootnoteSymbolRect, nBackLinkId ); + pPDFExtOutDevData->GetSwPDFState()->m_LinkIdMap.push_back(aBackLinkEntry); + // Connect Links and Destinations: + pPDFExtOutDevData->SetLinkDest( nLinkId, nDestId ); + pPDFExtOutDevData->SetLinkDest( nBackLinkId, nBackDestId ); + } + } + } + + // OUTLINE + + if( pPDFExtOutDevData->GetIsExportBookmarks() ) + { + typedef std::pair< sal_Int8, sal_Int32 > StackEntry; + std::stack< StackEntry > aOutlineStack; + aOutlineStack.push( StackEntry( -1, -1 ) ); // push default value + + const SwOutlineNodes::size_type nOutlineCount = + mrSh.getIDocumentOutlineNodesAccess()->getOutlineNodesCount(); + for ( SwOutlineNodes::size_type i = 0; i < nOutlineCount; ++i ) + { + // Check if outline is hidden + const SwTextNode* pTNd = mrSh.GetNodes().GetOutLineNds()[ i ]->GetTextNode(); + OSL_ENSURE( nullptr != pTNd, "Enhanced pdf export - text node is missing" ); + + if ( pTNd->IsHidden() || + !sw::IsParaPropsNode(*mrSh.GetLayout(), *pTNd) || + // #i40292# Skip empty outlines: + pTNd->GetText().isEmpty()) + continue; + + // Get parent id from stack: + const sal_Int8 nLevel = static_cast(mrSh.getIDocumentOutlineNodesAccess()->getOutlineLevel( i )); + sal_Int8 nLevelOnTopOfStack = aOutlineStack.top().first; + while ( nLevelOnTopOfStack >= nLevel && + nLevelOnTopOfStack != -1 ) + { + aOutlineStack.pop(); + nLevelOnTopOfStack = aOutlineStack.top().first; + } + const sal_Int32 nParent = aOutlineStack.top().second; + + // Destination rectangle + mrSh.GotoOutline(i); + const SwRect& rDestRect = mrSh.GetCharRect(); + + const SwPageFrame* pCurrPage = + static_cast( mrSh.GetLayout()->Lower() ); + + // Destination PageNum + const sal_Int32 nDestPageNum = CalcOutputPageNum( rDestRect ); + + if ( -1 != nDestPageNum ) + { + // Destination Export + tools::Rectangle aRect(SwRectToPDFRect(pCurrPage, rDestRect.SVRect())); + const sal_Int32 nDestId = + pPDFExtOutDevData->CreateDest(aRect, nDestPageNum); + + // Outline entry text + const OUString& rEntry = mrSh.getIDocumentOutlineNodesAccess()->getOutlineText( + i, mrSh.GetLayout(), true, false, false ); + + // Create a new outline item: + const sal_Int32 nOutlineId = + pPDFExtOutDevData->CreateOutlineItem( nParent, rEntry, nDestId ); + + // Push current level and nOutlineId on stack: + aOutlineStack.push( StackEntry( nLevel, nOutlineId ) ); + } + } + } + + if( pPDFExtOutDevData->GetIsExportNamedDestinations() ) + { + // #i56629# the iteration to convert the OOo bookmark (#bookmark) + // into PDF named destination, see section 8.2.1 in PDF 1.4 spec + // We need: + // 1. a name for the destination, formed from the standard OOo bookmark name + // 2. the destination, obtained from where the bookmark destination lies + IDocumentMarkAccess* const pMarkAccess = mrSh.GetDoc()->getIDocumentMarkAccess(); + for(IDocumentMarkAccess::const_iterator_t ppMark = pMarkAccess->getBookmarksBegin(); + ppMark != pMarkAccess->getBookmarksEnd(); + ++ppMark) + { + //get the name + const ::sw::mark::IMark* pBkmk = *ppMark; + mrSh.SwCursorShell::ClearMark(); + const OUString& sBkName = pBkmk->GetName(); + + //jump to it + if (! JumpToSwMark( &mrSh, sBkName )) + { + continue; + } + + // Destination Rectangle + const SwRect& rDestRect = mrSh.GetCharRect(); + + const SwPageFrame* pCurrPage = + static_cast( mrSh.GetLayout()->Lower() ); + + // Destination PageNum + const sal_Int32 nDestPageNum = CalcOutputPageNum( rDestRect ); + + // Destination Export + if ( -1 != nDestPageNum ) + { + tools::Rectangle aRect(SwRectToPDFRect(pCurrPage, rDestRect.SVRect())); + pPDFExtOutDevData->CreateNamedDest(sBkName, aRect, nDestPageNum); + } + } + mrSh.SwCursorShell::ClearMark(); + //<--- i56629 + } + } + else + { + + // LINKS FROM EDITENGINE + + std::vector< vcl::PDFExtOutDevBookmarkEntry >& rBookmarks = pPDFExtOutDevData->GetBookmarks(); + for ( const auto& rBookmark : rBookmarks ) + { + OUString aBookmarkName( rBookmark.aBookmark ); + const bool bInternal = '#' == aBookmarkName[0]; + if ( bInternal ) + { + aBookmarkName = aBookmarkName.copy( 1 ); + JumpToSwMark( &mrSh, aBookmarkName ); + + // Destination Rectangle + const SwRect& rDestRect = mrSh.GetCharRect(); + + const SwPageFrame* pCurrPage = + static_cast( mrSh.GetLayout()->Lower() ); + + // Destination PageNum + const sal_Int32 nDestPageNum = CalcOutputPageNum( rDestRect ); + + if ( -1 != nDestPageNum ) + { + tools::Rectangle aRect(SwRectToPDFRect(pCurrPage, rDestRect.SVRect())); + if ( rBookmark.nLinkId != -1 ) + { + // Destination Export + const sal_Int32 nDestId = pPDFExtOutDevData->CreateDest(aRect, nDestPageNum); + + // Connect Link and Destination: + pPDFExtOutDevData->SetLinkDest( rBookmark.nLinkId, nDestId ); + } + else + { + pPDFExtOutDevData->DescribeRegisteredDest(rBookmark.nDestId, aRect, nDestPageNum); + } + } + } + else + pPDFExtOutDevData->SetLinkURL( rBookmark.nLinkId, aBookmarkName ); + } + rBookmarks.clear(); + assert(pPDFExtOutDevData->GetSwPDFState()); + delete pPDFExtOutDevData->GetSwPDFState(); + pPDFExtOutDevData->SetSwPDFState(nullptr); + } + + // Restore view, cursor, and outdev: + mrSh.LockView( bOldLockView ); + mrSh.SwCursorShell::Pop(SwCursorShell::PopMode::DeleteCurrent); + mrOut.Pop(); +} + +void SwEnhancedPDFExportHelper::ExportAuthorityEntryLinks() +{ + auto pPDFExtOutDevData = dynamic_cast(mrOut.GetExtOutDevData()); + if (!pPDFExtOutDevData) + { + return; + } + + // Create PDF destinations for bibliography table entries + std::vector> vDestinations; + // string is the row node text, sal_Int32 is number of the destination + // Note: This way of iterating doesn't seem to take into account TOXes + // that are in a frame, probably in some other cases too + { + mrSh.GotoPage(1); + while (mrSh.GotoNextTOXBase()) + { + const SwTOXBase* pIteratedTOX = nullptr; + while ((pIteratedTOX = mrSh.GetCurTOX()) != nullptr + && pIteratedTOX->GetType() == TOX_AUTHORITIES) + { + if (const SwNode& rCurrentNode = mrSh.GetCursor()->GetPoint()->GetNode(); + rCurrentNode.GetNodeType() == SwNodeType::Text) + { + if (mrSh.GetCursor()->GetPoint()->GetNode().FindSectionNode()->GetSection().GetType() + == SectionType::ToxContent) // this checks it's not a heading + { + // Destination Rectangle + const SwRect& rDestRect = mrSh.GetCharRect(); + + const SwPageFrame* pCurrPage = + static_cast( mrSh.GetLayout()->Lower() ); + + // Destination PageNum + const sal_Int32 nDestPageNum = CalcOutputPageNum( rDestRect ); + + // Destination Export + if ( -1 != nDestPageNum ) + { + tools::Rectangle aRect(SwRectToPDFRect(pCurrPage, rDestRect.SVRect())); + const sal_Int32 nDestId = pPDFExtOutDevData->CreateDest(aRect, nDestPageNum); + const OUString* vNodeText = &static_cast(&rCurrentNode)->GetText(); + vDestinations.emplace_back(pIteratedTOX, vNodeText, nDestId); + } + } + } + if (!mrSh.MovePara(GoNextPara, fnParaStart)) + { // Cursor is stuck in the TOX due to document ending immediately afterwards + break; + } + } + } + } + + // Generate links to matching entries in the bibliography tables + std::vector aFields; + SwFieldType* pType = mrSh.GetFieldType(SwFieldIds::TableOfAuthorities, OUString()); + if (!pType) + { + return; + } + + pType->GatherFields(aFields); + const auto pPageFrame = static_cast(mrSh.GetLayout()->Lower()); + for (const auto pFormatField : aFields) + { + if (!pFormatField->GetTextField() || !pFormatField->IsFieldInDoc()) + { + continue; + } + + const auto& rAuthorityField + = *static_cast(pFormatField->GetField()); + + if (auto targetType = rAuthorityField.GetTargetType(); + targetType == SwAuthorityField::TargetType::UseDisplayURL + || targetType == SwAuthorityField::TargetType::UseTargetURL) + { + // Since the target type specifies to use an URL, link to it + const OUString& rURL = rAuthorityField.GetAbsoluteURL(); + if (rURL.getLength() == 0) + { + continue; + } + + const SwTextNode& rTextNode = pFormatField->GetTextField()->GetTextNode(); + if (!lcl_TryMoveToNonHiddenField(mrSh, rTextNode, *pFormatField)) + { + continue; + } + + OUString const content(rAuthorityField.ExpandField(true, mrSh.GetLayout())); + + // Select the field. + mrSh.SwCursorShell::SetMark(); + mrSh.SwCursorShell::Right(1, SwCursorSkipMode::Chars); + + // Create the links. + SwRects const rects(GetCursorRectsContainingText(mrSh)); + for (const auto& rLinkRect : rects) + { + for (const auto& rLinkPageNum : CalcOutputPageNums(rLinkRect)) + { + tools::Rectangle aRect(SwRectToPDFRect(pPageFrame, rLinkRect.SVRect())); + sal_Int32 nLinkId = pPDFExtOutDevData->CreateLink(aRect, content, rLinkPageNum); + IdMapEntry aLinkEntry(rLinkRect, nLinkId); + pPDFExtOutDevData->GetSwPDFState()->m_LinkIdMap.push_back(aLinkEntry); + pPDFExtOutDevData->SetLinkURL(nLinkId, rURL); + } + } + mrSh.SwCursorShell::ClearMark(); + } + else if (targetType == SwAuthorityField::TargetType::BibliographyTableRow) + { + // As the target type specifies, try linking to a bibliography table row + sal_Int32 nDestId = -1; + + std::unordered_map vFormattedFieldStrings; + for (const auto& rDestinationTuple : vDestinations) + { + if (vFormattedFieldStrings.find(std::get<0>(rDestinationTuple)) + == vFormattedFieldStrings.end()) + vFormattedFieldStrings.emplace(std::get<0>(rDestinationTuple), + rAuthorityField.GetAuthority(mrSh.GetLayout(), + &std::get<0>(rDestinationTuple)->GetTOXForm())); + + if (vFormattedFieldStrings.at(std::get<0>(rDestinationTuple)) == *std::get<1>(rDestinationTuple)) + { + nDestId = std::get<2>(rDestinationTuple); + break; + } + } + + if (nDestId == -1) + continue; + + const SwTextNode& rTextNode = pFormatField->GetTextField()->GetTextNode(); + if (!lcl_TryMoveToNonHiddenField(mrSh, rTextNode, *pFormatField)) + { + continue; + } + + OUString const content(rAuthorityField.ExpandField(true, mrSh.GetLayout())); + + // Select the field. + mrSh.SwCursorShell::SetMark(); + mrSh.SwCursorShell::Right(1, SwCursorSkipMode::Chars); + + // Create the links. + SwRects const rects(GetCursorRectsContainingText(mrSh)); + for (const auto& rLinkRect : rects) + { + for (const auto& rLinkPageNum : CalcOutputPageNums(rLinkRect)) + { + tools::Rectangle aRect(SwRectToPDFRect(pPageFrame, rLinkRect.SVRect())); + sal_Int32 nLinkId = pPDFExtOutDevData->CreateLink(aRect, content, rLinkPageNum); + IdMapEntry aLinkEntry(rLinkRect, nLinkId); + pPDFExtOutDevData->GetSwPDFState()->m_LinkIdMap.push_back(aLinkEntry); + pPDFExtOutDevData->SetLinkDest(nLinkId, nDestId); + } + } + mrSh.SwCursorShell::ClearMark(); + } + } +} + +// Returns the page number in the output pdf on which the given rect is located. +// If this page is duplicated, method will return first occurrence of it. +sal_Int32 SwEnhancedPDFExportHelper::CalcOutputPageNum( const SwRect& rRect ) const +{ + std::vector< sal_Int32 > aPageNums = CalcOutputPageNums( rRect ); + if ( !aPageNums.empty() ) + return aPageNums[0]; + return -1; +} + +// Returns a vector of the page numbers in the output pdf on which the given +// rect is located. There can be many such pages since StringRangeEnumerator +// allows duplication of its entries. +std::vector< sal_Int32 > SwEnhancedPDFExportHelper::CalcOutputPageNums( + const SwRect& rRect ) const +{ + std::vector< sal_Int32 > aPageNums; + + // Document page number. + sal_Int32 nPageNumOfRect = mrSh.GetPageNumAndSetOffsetForPDF( mrOut, rRect ); + if ( nPageNumOfRect < 0 ) + return aPageNums; + + // What will be the page numbers of page nPageNumOfRect in the output pdf? + if ( mpRangeEnum ) + { + if ( mbSkipEmptyPages ) + // Map the page number to the range without empty pages. + nPageNumOfRect = maPageNumberMap[ nPageNumOfRect ]; + + if ( mpRangeEnum->hasValue( nPageNumOfRect ) ) + { + sal_Int32 nOutputPageNum = 0; + StringRangeEnumerator::Iterator aIter = mpRangeEnum->begin(); + StringRangeEnumerator::Iterator aEnd = mpRangeEnum->end(); + for ( ; aIter != aEnd; ++aIter ) + { + if ( *aIter == nPageNumOfRect ) + aPageNums.push_back( nOutputPageNum ); + ++nOutputPageNum; + } + } + } + else + { + if ( mbSkipEmptyPages ) + { + sal_Int32 nOutputPageNum = 0; + for ( size_t i = 0; i < maPageNumberMap.size(); ++i ) + { + if ( maPageNumberMap[i] >= 0 ) // is not empty? + { + if ( i == static_cast( nPageNumOfRect ) ) + { + aPageNums.push_back( nOutputPageNum ); + break; + } + ++nOutputPageNum; + } + } + } + else + aPageNums.push_back( nPageNumOfRect ); + } + + return aPageNums; +} + +void SwEnhancedPDFExportHelper::MakeHeaderFooterLinks( vcl::PDFExtOutDevData& rPDFExtOutDevData, + const SwTextNode& rTNd, + const SwRect& rLinkRect, + sal_Int32 nDestId, + const OUString& rURL, + bool bInternal, + OUString const& rContent) const +{ + // We assume, that the primary link has just been exported. Therefore + // the offset of the link rectangle calculates as follows: + const Point aOffset = rLinkRect.Pos() + mrOut.GetMapMode().GetOrigin(); + + SwIterator aIter(rTNd); + for ( SwTextFrame* pTmpFrame = aIter.First(); pTmpFrame; pTmpFrame = aIter.Next() ) + { + // Add offset to current page: + const SwPageFrame* pPageFrame = pTmpFrame->FindPageFrame(); + SwRect aHFLinkRect( rLinkRect ); + aHFLinkRect.Pos() = pPageFrame->getFrameArea().Pos() + aOffset; + + // #i97135# the gcc_x64 optimizer gets aHFLinkRect != rLinkRect wrong + // fool it by comparing the position only (the width and height are the + // same anyway) + if ( aHFLinkRect.Pos() != rLinkRect.Pos() ) + { + // Link PageNums + std::vector aHFLinkPageNums = CalcOutputPageNums( aHFLinkRect ); + + for (sal_Int32 aHFLinkPageNum : aHFLinkPageNums) + { + // Link Export + tools::Rectangle aRect(SwRectToPDFRect(pPageFrame, aHFLinkRect.SVRect())); + const sal_Int32 nHFLinkId = + rPDFExtOutDevData.CreateLink(aRect, rContent, aHFLinkPageNum); + + // Connect Link and Destination: + if ( bInternal ) + rPDFExtOutDevData.SetLinkDest( nHFLinkId, nDestId ); + else + rPDFExtOutDevData.SetLinkURL( nHFLinkId, rURL ); + } + } + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/SwGrammarMarkUp.cxx b/sw/source/core/text/SwGrammarMarkUp.cxx new file mode 100644 index 0000000000..53fd4b13c0 --- /dev/null +++ b/sw/source/core/text/SwGrammarMarkUp.cxx @@ -0,0 +1,145 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include + +SwGrammarMarkUp::~SwGrammarMarkUp() +{ +} + +SwWrongList* SwGrammarMarkUp::Clone() +{ + SwWrongList* pClone = new SwGrammarMarkUp(); + pClone->CopyFrom( *this ); + return pClone; +} + +void SwGrammarMarkUp::CopyFrom( const SwWrongList& rCopy ) +{ + maSentence = static_cast(rCopy).maSentence; + SwWrongList::CopyFrom( rCopy ); +} + +void SwGrammarMarkUp::MoveGrammar( sal_Int32 nPos, sal_Int32 nDiff ) +{ + Move( nPos, nDiff ); + if( maSentence.empty() ) + return; + auto pIter = std::find_if(maSentence.begin(), maSentence.end(), + [nPos](const sal_Int32& rPos) { return rPos >= nPos; }); + const sal_Int32 nEnd = nDiff < 0 ? nPos-nDiff : nPos; + while( pIter != maSentence.end() ) + { + if( *pIter >= nEnd ) + *pIter += nDiff; + else + *pIter = nPos; + ++pIter; + } +} + +std::unique_ptr SwGrammarMarkUp::SplitGrammarList( sal_Int32 nSplitPos ) +{ + std::unique_ptr pNew( static_cast(SplitList( nSplitPos ).release()) ); + if( maSentence.empty() ) + return pNew; + auto pIter = std::find_if(maSentence.begin(), maSentence.end(), + [nSplitPos](const sal_Int32& rPos) { return rPos >= nSplitPos; }); + if( pIter != maSentence.begin() ) + { + if( !pNew ) { + pNew.reset(new SwGrammarMarkUp()); + pNew->SetInvalid( 0, COMPLETE_STRING ); + } + pNew->maSentence.insert( pNew->maSentence.begin(), maSentence.begin(), pIter ); + maSentence.erase( maSentence.begin(), pIter ); + } + return pNew; +} + +void SwGrammarMarkUp::JoinGrammarList( SwGrammarMarkUp* pNext, sal_Int32 nInsertPos ) +{ + JoinList( pNext, nInsertPos ); + if (pNext) + { + if( pNext->maSentence.empty() ) + return; + for( auto& rPos : pNext->maSentence ) + { + rPos += nInsertPos; + } + maSentence.insert( maSentence.end(), pNext->maSentence.begin(), pNext->maSentence.end() ); + } +} + +void SwGrammarMarkUp::ClearGrammarList( sal_Int32 nSentenceEnd ) +{ + if( COMPLETE_STRING == nSentenceEnd ) { + ClearList(); + maSentence.clear(); + Validate(); + } else if( GetBeginInv() <= nSentenceEnd ) { + std::vector< sal_Int32 >::iterator pIter = maSentence.begin(); + sal_Int32 nStart = 0; + while( pIter != maSentence.end() && *pIter < GetBeginInv() ) + { + nStart = *pIter; + ++pIter; + } + auto pLast = std::find_if(pIter, maSentence.end(), + [nSentenceEnd](const sal_Int32& rPos) { return rPos > nSentenceEnd; }); + maSentence.erase( pIter, pLast ); + RemoveEntry( nStart, nSentenceEnd ); + SetInvalid( nSentenceEnd + 1, COMPLETE_STRING ); + } +} + +void SwGrammarMarkUp::setSentence( sal_Int32 nStart ) +{ + auto pIter = std::find_if(maSentence.begin(), maSentence.end(), + [nStart](const sal_Int32& rPos) { return rPos >= nStart; }); + if( pIter == maSentence.end() || *pIter > nStart ) + maSentence.insert( pIter, nStart ); +} + +sal_Int32 SwGrammarMarkUp::getSentenceStart( sal_Int32 nPos ) +{ + if( maSentence.empty() ) + return 0; + auto pIter = std::find_if(maSentence.begin(), maSentence.end(), + [nPos](const sal_Int32& rPos) { return rPos >= nPos; }); + if( pIter != maSentence.begin() ) + --pIter; + if( pIter != maSentence.end() && *pIter < nPos ) + return *pIter; + return 0; +} + +sal_Int32 SwGrammarMarkUp::getSentenceEnd( sal_Int32 nPos ) +{ + if( maSentence.empty() ) + return COMPLETE_STRING; + auto pIter = std::find_if(maSentence.begin(), maSentence.end(), + [nPos](const sal_Int32& rPos) { return rPos > nPos; }); + if( pIter != maSentence.end() ) + return *pIter; + return COMPLETE_STRING; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/atrhndl.hxx b/sw/source/core/text/atrhndl.hxx new file mode 100644 index 0000000000..851615325a --- /dev/null +++ b/sw/source/core/text/atrhndl.hxx @@ -0,0 +1,117 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once +#define NUM_ATTRIBUTE_STACKS 45 + +#include +#include + +class SwTextAttr; +class SwAttrSet; +class IDocumentSettingAccess; +class SwViewShell; +class SfxPoolItem; +extern const sal_uInt8 StackPos[]; + +/** + * Used by Attribute Iterators to organize attributes on stacks to + * find the valid attribute in each category + */ +class SwAttrHandler +{ +private: + std::vector m_aAttrStack[NUM_ATTRIBUTE_STACKS]; // stack collection + const SfxPoolItem* m_pDefaultArray[ NUM_DEFAULT_VALUES ]; + const IDocumentSettingAccess* m_pIDocumentSettingAccess; + const SwViewShell* m_pShell; + + // This is the base font for the paragraph. It is stored in order to have + // a template, if we have to restart the attribute evaluation + std::optional m_oFnt; + + bool m_bVertLayout; + bool m_bVertLayoutLRBT; + + const SwTextAttr* GetTop(sal_uInt16 nStack); + void RemoveFromStack(sal_uInt16 nWhich, const SwTextAttr& rAttr); + + // change font according to pool item + void FontChg(const SfxPoolItem& rItem, SwFont& rFnt, bool bPush ); + + // push attribute to specified stack, returns true, if attribute has + // been pushed on top of stack (important for stacks containing different + // attributes with different priority and redlining) + bool Push( const SwTextAttr& rAttr, const SfxPoolItem& rItem ); + + // apply top attribute on stack to font + void ActivateTop( SwFont& rFnt, sal_uInt16 nStackPos ); + +public: + // Ctor + SwAttrHandler(); + ~SwAttrHandler(); + + // set default attributes to values in rAttrSet or from cache + void Init( const SwAttrSet& rAttrSet, + const IDocumentSettingAccess& rIDocumentSettingAccess ); + void Init( const SfxPoolItem** pPoolItem, const SwAttrSet* pAttrSet, + const IDocumentSettingAccess& rIDocumentSettingAccess, + const SwViewShell* pShell, SwFont& rFnt, + bool bVertLayout, bool bVertLayoutLRBT ); + + bool IsVertLayout() const { return m_bVertLayout; } + + // remove everything from internal stacks, keep default data + void Reset( ); + + // insert specified attribute and change font + void PushAndChg( const SwTextAttr& rAttr, SwFont& rFnt ); + + // remove specified attribute and reset font + void PopAndChg( const SwTextAttr& rAttr, SwFont& rFnt ); + void Pop( const SwTextAttr& rAttr ); + + // apply script dependent attributes + // void ChangeScript( SwFont& rFnt, const sal_uInt8 nScr ); + + // do not call these if you only used the small init function + inline void ResetFont( SwFont& rFnt ) const; + inline const SwFont* GetFont() const; + + void GetDefaultAscentAndHeight(SwViewShell const * pShell, + OutputDevice const & rOut, + sal_uInt16& nAscent, + sal_uInt16& nHeight) const; +}; + +inline void SwAttrHandler::ResetFont( SwFont& rFnt ) const +{ + OSL_ENSURE(m_oFnt, "ResetFont without a font"); + if (m_oFnt) + rFnt = *m_oFnt; +}; + +inline const SwFont* SwAttrHandler::GetFont() const +{ + return m_oFnt ? &*m_oFnt : nullptr; +}; + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/atrstck.cxx b/sw/source/core/text/atrstck.cxx new file mode 100644 index 0000000000..048878292f --- /dev/null +++ b/sw/source/core/text/atrstck.cxx @@ -0,0 +1,851 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include "atrhndl.hxx" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/** + * Attribute to Stack Mapping + * + * Attributes applied to a text are pushed on different stacks. For each + * stack, the top most attribute on the stack is valid. Because some + * kinds of attributes have to be pushed to the same stacks we map their + * ids to stack ids + * Attention: The first NUM_DEFAULT_VALUES ( defined in swfntcch.hxx ) + * are stored in the defaultitem-cache, if you add one, you have to increase + * NUM_DEFAULT_VALUES. + * Also adjust NUM_ATTRIBUTE_STACKS in atrhndl.hxx. + */ +const sal_uInt8 StackPos[ RES_TXTATR_WITHEND_END - RES_CHRATR_BEGIN + 1 ] = +{ + 0, // // 0 + 1, // RES_CHRATR_CASEMAP = RES_CHRATR_BEGIN // 1 + 0, // RES_CHRATR_CHARSETCOLOR, // 2 + 2, // RES_CHRATR_COLOR, // 3 + 3, // RES_CHRATR_CONTOUR, // 4 + 4, // RES_CHRATR_CROSSEDOUT, // 5 + 5, // RES_CHRATR_ESCAPEMENT, // 6 + 6, // RES_CHRATR_FONT, // 7 + 7, // RES_CHRATR_FONTSIZE, // 8 + 8, // RES_CHRATR_KERNING, // 9 + 9, // RES_CHRATR_LANGUAGE, // 10 + 10, // RES_CHRATR_POSTURE, // 11 + 0, // RES_CHRATR_UNUSED1, // 12 + 11, // RES_CHRATR_SHADOWED, // 13 + 12, // RES_CHRATR_UNDERLINE, // 14 + 13, // RES_CHRATR_WEIGHT, // 15 + 14, // RES_CHRATR_WORDLINEMODE, // 16 + 15, // RES_CHRATR_AUTOKERN, // 17 + 16, // RES_CHRATR_BLINK, // 18 + 17, // RES_CHRATR_NOHYPHEN, // 19 + 0, // RES_CHRATR_UNUSED2, // 20 + 18, // RES_CHRATR_BACKGROUND, // 21 + 19, // RES_CHRATR_CJK_FONT, // 22 + 20, // RES_CHRATR_CJK_FONTSIZE, // 23 + 21, // RES_CHRATR_CJK_LANGUAGE, // 24 + 22, // RES_CHRATR_CJK_POSTURE, // 25 + 23, // RES_CHRATR_CJK_WEIGHT, // 26 + 24, // RES_CHRATR_CTL_FONT, // 27 + 25, // RES_CHRATR_CTL_FONTSIZE, // 28 + 26, // RES_CHRATR_CTL_LANGUAGE, // 29 + 27, // RES_CHRATR_CTL_POSTURE, // 30 + 28, // RES_CHRATR_CTL_WEIGHT, // 31 + 29, // RES_CHRATR_ROTATE, // 32 + 30, // RES_CHRATR_EMPHASIS_MARK, // 33 + 31, // RES_CHRATR_TWO_LINES, // 34 + 32, // RES_CHRATR_SCALEW, // 35 + 33, // RES_CHRATR_RELIEF, // 36 + 34, // RES_CHRATR_HIDDEN, // 37 + 35, // RES_CHRATR_OVERLINE, // 38 + 0, // RES_CHRATR_RSID, // 39 + 36, // RES_CHRATR_BOX, // 40 + 37, // RES_CHRATR_SHADOW, // 41 + 38, // RES_CHRATR_HIGHLIGHT, // 42 + 0, // RES_CHRATR_GRABBAG, // 43 + 0, // RES_CHRATR_BIDIRTL, // 44 + 0, // RES_CHRATR_IDCTHINT, // 45 + 39, // RES_TXTATR_REFMARK, // 46 + 40, // RES_TXTATR_TOXMARK, // 47 + 41, // RES_TXTATR_META, // 48 + 41, // RES_TXTATR_METAFIELD, // 49 + 0, // RES_TXTATR_AUTOFMT, // 50 + 0, // RES_TXTATR_INETFMT // 51 + 0, // RES_TXTATR_CHARFMT, // 52 + 42, // RES_TXTATR_CJK_RUBY, // 53 + 0, // RES_TXTATR_UNKNOWN_CONTAINER, // 54 + 43, // RES_TXTATR_INPUTFIELD // 55 + 44, // RES_TXTATR_CONTENTCONTROL // 56 +}; + +namespace CharFormat +{ + +/// Returns the item set associated with a character/inet/auto style +const SfxItemSet* GetItemSet( const SfxPoolItem& rAttr ) +{ + const SfxItemSet* pSet = nullptr; + + if ( RES_TXTATR_AUTOFMT == rAttr.Which() ) + { + pSet = rAttr.StaticWhichCast(RES_TXTATR_AUTOFMT).GetStyleHandle().get(); + } + else + { + // Get the attributes from the template + const SwCharFormat* pFormat = RES_TXTATR_INETFMT == rAttr.Which() ? + rAttr.StaticWhichCast(RES_TXTATR_INETFMT).GetTextINetFormat()->GetCharFormat() : + static_cast(rAttr).GetCharFormat(); + if( pFormat ) + { + pSet = &pFormat->GetAttrSet(); + } + } + + return pSet; +} + +/// Extracts pool item of type nWhich from rAttr +const SfxPoolItem* GetItem( const SwTextAttr& rAttr, sal_uInt16 nWhich ) +{ + if ( RES_TXTATR_INETFMT == rAttr.Which() || + RES_TXTATR_CHARFMT == rAttr.Which() || + RES_TXTATR_AUTOFMT == rAttr.Which() ) + { + const SfxItemSet* pSet = CharFormat::GetItemSet( rAttr.GetAttr() ); + if ( !pSet ) return nullptr; + + bool bInParent = RES_TXTATR_AUTOFMT != rAttr.Which(); + const SfxPoolItem* pItem; + bool bRet = SfxItemState::SET == pSet->GetItemState( nWhich, bInParent, &pItem ); + + return bRet ? pItem : nullptr; + } + + return ( nWhich == rAttr.Which() ) ? &rAttr.GetAttr() : nullptr; +} + +/// Checks if item is included in character/inet/auto style +bool IsItemIncluded( const sal_uInt16 nWhich, const SwTextAttr *pAttr ) +{ + bool bRet = false; + + const SfxItemSet* pItemSet = CharFormat::GetItemSet( pAttr->GetAttr() ); + if ( pItemSet ) + bRet = SfxItemState::SET == pItemSet->GetItemState( nWhich ); + + return bRet; +} +} + +/** + * The color of hyperlinks is taken from the associated character attribute, + * depending on its 'visited' state. There are actually two cases, which + * should override the colors from the character attribute: + * 1. We never take the 'visited' color during printing/pdf export/preview + * 2. The user has chosen to override these colors in the view options + */ +static bool lcl_ChgHyperLinkColor( const SwTextAttr& rAttr, + const SfxPoolItem& rItem, + const SwViewShell* pShell, + Color* pColor ) +{ + if ( !pShell || + RES_TXTATR_INETFMT != rAttr.Which() || + RES_CHRATR_COLOR != rItem.Which() ) + return false; + + // #i15455# + // 1. case: + // We do not want to show visited links: + // (printing, pdf export, page preview) + + SwTextINetFormat & rINetAttr(const_cast( + static_txtattr_cast(rAttr))); + if ( pShell->GetOut()->GetOutDevType() == OUTDEV_PRINTER || + pShell->GetViewOptions()->IsPDFExport() || + pShell->GetViewOptions()->IsPagePreview() ) + { + if (rINetAttr.IsVisited()) + { + if ( pColor ) + { + // take color from character format 'unvisited link' + rINetAttr.SetVisited(false); + const SwCharFormat* pTmpFormat = rINetAttr.GetCharFormat(); + if (const SvxColorItem* pItem = pTmpFormat->GetItemIfSet(RES_CHRATR_COLOR)) + *pColor = pItem->GetValue(); + rINetAttr.SetVisited(true); + } + return true; + } + + return false; + } + + // 2. case: + // We do not want to apply the color set in the hyperlink + // attribute, instead we take the colors from the view options: + + if ( pShell->GetWin() && + ( + (rINetAttr.IsVisited() && pShell->GetViewOptions()->IsVisitedLinks()) || + (!rINetAttr.IsVisited() && pShell->GetViewOptions()->IsLinks()) + ) + ) + { + if ( pColor ) + { + if (rINetAttr.IsVisited()) + { + // take color from view option 'visited link color' + *pColor = pShell->GetViewOptions()->GetVisitedLinksColor(); + } + else + { + // take color from view option 'unvisited link color' + *pColor = pShell->GetViewOptions()->GetLinksColor(); + } + } + return true; + } + + return false; +} + +SwAttrHandler::SwAttrHandler() + : m_pIDocumentSettingAccess(nullptr) + , m_pShell(nullptr) + , m_bVertLayout(false) + , m_bVertLayoutLRBT(false) +{ + memset( m_pDefaultArray, 0, NUM_DEFAULT_VALUES * sizeof(SfxPoolItem*) ); +} + +SwAttrHandler::~SwAttrHandler() +{ +} + +void SwAttrHandler::Init( const SwAttrSet& rAttrSet, + const IDocumentSettingAccess& rIDocumentSettingAcces ) +{ + m_pIDocumentSettingAccess = &rIDocumentSettingAcces; + m_pShell = nullptr; + + for ( sal_uInt16 i = RES_CHRATR_BEGIN; i < RES_CHRATR_END; i++ ) + m_pDefaultArray[ StackPos[ i ] ] = &rAttrSet.Get( i ); +} + +void SwAttrHandler::Init( const SfxPoolItem** pPoolItem, const SwAttrSet* pAS, + const IDocumentSettingAccess& rIDocumentSettingAcces, + const SwViewShell* pSh, + SwFont& rFnt, bool bVL, bool bVertLayoutLRBT ) +{ + // initialize default array + memcpy( m_pDefaultArray, pPoolItem, + NUM_DEFAULT_VALUES * sizeof(SfxPoolItem*) ); + + m_pIDocumentSettingAccess = &rIDocumentSettingAcces; + m_pShell = pSh; + + // do we have to apply additional paragraph attributes? + m_bVertLayout = bVL; + m_bVertLayoutLRBT = bVertLayoutLRBT; + + if ( pAS && pAS->Count() ) + { + SfxItemIter aIter( *pAS ); + sal_uInt16 nWhich; + const SfxPoolItem* pItem = aIter.GetCurItem(); + do + { + nWhich = pItem->Which(); + if (isCHRATR(nWhich)) + { + m_pDefaultArray[ StackPos[ nWhich ] ] = pItem; + FontChg( *pItem, rFnt, true ); + } + + pItem = aIter.NextItem(); + } while (pItem); + } + + // It is possible, that Init is called more than once, e.g., in a + // SwTextFrame::FormatOnceMore situation or (since sw_redlinehide) + // from SwAttrIter::Seek(); in the latter case SwTextSizeInfo::m_pFnt + // is an alias of m_pFnt so it must not be deleted! + if (m_oFnt) + *m_oFnt = rFnt; + else + m_oFnt.emplace(rFnt); +} + +void SwAttrHandler::Reset( ) +{ + for (auto& i : m_aAttrStack) + i.clear(); +} + +void SwAttrHandler::PushAndChg( const SwTextAttr& rAttr, SwFont& rFnt ) +{ + // these special attributes in fact represent a collection of attributes + // they have to be pushed to each stack they belong to + if ( RES_TXTATR_INETFMT == rAttr.Which() || + RES_TXTATR_CHARFMT == rAttr.Which() || + RES_TXTATR_AUTOFMT == rAttr.Which() ) + { + const SfxItemSet* pSet = CharFormat::GetItemSet( rAttr.GetAttr() ); + if ( !pSet ) return; + + for ( sal_uInt16 i = RES_CHRATR_BEGIN; i < RES_CHRATR_END; i++) + { + const SfxPoolItem* pItem; + bool bRet = SfxItemState::SET == pSet->GetItemState( i, rAttr.Which() != RES_TXTATR_AUTOFMT, &pItem ); + + if ( bRet ) + { + // we push rAttr onto the appropriate stack + if ( Push( rAttr, *pItem ) ) + { + // we let pItem change rFnt + Color aColor; + if (lcl_ChgHyperLinkColor(rAttr, *pItem, m_pShell, &aColor)) + { + SvxColorItem aItemNext( aColor, RES_CHRATR_COLOR ); + FontChg( aItemNext, rFnt, true ); + } + else + FontChg( *pItem, rFnt, true ); + } + } + } + } + // this is the usual case, we have a basic attribute, push it onto the + // stack and change the font + else + { + if ( Push( rAttr, rAttr.GetAttr() ) ) + // we let pItem change rFnt + FontChg( rAttr.GetAttr(), rFnt, true ); + } +} + +const SwTextAttr* SwAttrHandler::GetTop(sal_uInt16 nStack) +{ + return m_aAttrStack[nStack].empty() ? nullptr : m_aAttrStack[nStack].back(); +} + +bool SwAttrHandler::Push( const SwTextAttr& rAttr, const SfxPoolItem& rItem ) +{ + OSL_ENSURE( rItem.Which() < RES_TXTATR_WITHEND_END, + "I do not want this attribute, nWhich >= RES_TXTATR_WITHEND_END" ); + + // robust + if ( RES_TXTATR_WITHEND_END <= rItem.Which() ) + return false; + + const sal_uInt16 nStack = StackPos[ rItem.Which() ]; + + // attributes originating from redlining have highest priority + // second priority are hyperlink attributes, which have a color replacement + const SwTextAttr* pTopAttr = GetTop(nStack); + if ( !pTopAttr + || rAttr.IsPriorityAttr() + || ( !pTopAttr->IsPriorityAttr() + && !lcl_ChgHyperLinkColor(*pTopAttr, rItem, m_pShell, nullptr))) + { + m_aAttrStack[nStack].push_back(&rAttr); + return true; + } + + const auto it = m_aAttrStack[nStack].end() - 1; + m_aAttrStack[nStack].insert(it, &rAttr); + return false; +} + +void SwAttrHandler::RemoveFromStack(sal_uInt16 nWhich, const SwTextAttr& rAttr) +{ + auto& rStack = m_aAttrStack[StackPos[nWhich]]; + const auto it = std::find(rStack.begin(), rStack.end(), &rAttr); + if (it != rStack.end()) + rStack.erase(it); +} + +void SwAttrHandler::PopAndChg( const SwTextAttr& rAttr, SwFont& rFnt ) +{ + if ( RES_TXTATR_WITHEND_END <= rAttr.Which() ) + return; // robust + + // these special attributes in fact represent a collection of attributes + // they have to be removed from each stack they belong to + if ( RES_TXTATR_INETFMT == rAttr.Which() || + RES_TXTATR_CHARFMT == rAttr.Which() || + RES_TXTATR_AUTOFMT == rAttr.Which() ) + { + const SfxItemSet* pSet = CharFormat::GetItemSet( rAttr.GetAttr() ); + if ( !pSet ) return; + + for ( sal_uInt16 i = RES_CHRATR_BEGIN; i < RES_CHRATR_END; i++) + { + const SfxPoolItem* pItem; + bool bRet = SfxItemState::SET == pSet->GetItemState( i, RES_TXTATR_AUTOFMT != rAttr.Which(), &pItem ); + if ( bRet ) + { + // we remove rAttr from the appropriate stack + RemoveFromStack(i, rAttr); + // reset font according to attribute on top of stack + // or default value + ActivateTop( rFnt, i ); + } + } + } + // this is the usual case, we have a basic attribute, remove it from the + // stack and reset the font + else + { + RemoveFromStack(rAttr.Which(), rAttr); + // reset font according to attribute on top of stack + // or default value + ActivateTop( rFnt, rAttr.Which() ); + } +} + +/// Only used during redlining +void SwAttrHandler::Pop( const SwTextAttr& rAttr ) +{ + OSL_ENSURE( rAttr.Which() < RES_TXTATR_WITHEND_END, + "I do not have this attribute, nWhich >= RES_TXTATR_WITHEND_END" ); + + if ( rAttr.Which() < RES_TXTATR_WITHEND_END ) + { + RemoveFromStack(rAttr.Which(), rAttr); + } +} + +void SwAttrHandler::ActivateTop( SwFont& rFnt, const sal_uInt16 nAttr ) +{ + OSL_ENSURE( nAttr < RES_TXTATR_WITHEND_END, + "I cannot activate this attribute, nWhich >= RES_TXTATR_WITHEND_END" ); + + const sal_uInt16 nStackPos = StackPos[ nAttr ]; + const SwTextAttr* pTopAt = GetTop(nStackPos); + if ( pTopAt ) + { + const SfxPoolItem* pItemNext(nullptr); + + // check if top attribute is collection of attributes + if ( RES_TXTATR_INETFMT == pTopAt->Which() || + RES_TXTATR_CHARFMT == pTopAt->Which() || + RES_TXTATR_AUTOFMT == pTopAt->Which() ) + { + const SfxItemSet* pSet = CharFormat::GetItemSet( pTopAt->GetAttr() ); + if (pSet) + pSet->GetItemState( nAttr, RES_TXTATR_AUTOFMT != pTopAt->Which(), &pItemNext ); + } + + if (pItemNext) + { + Color aColor; + if (lcl_ChgHyperLinkColor(*pTopAt, *pItemNext, m_pShell, &aColor)) + { + SvxColorItem aItemNext( aColor, RES_CHRATR_COLOR ); + FontChg( aItemNext, rFnt, false ); + } + else + FontChg( *pItemNext, rFnt, false ); + } + else + FontChg( pTopAt->GetAttr(), rFnt, false ); + } + + // default value has to be set, we only have default values for char attribs + else if ( nStackPos < NUM_DEFAULT_VALUES ) + FontChg( *m_pDefaultArray[ nStackPos ], rFnt, false ); + else if ( RES_TXTATR_REFMARK == nAttr ) + rFnt.GetRef()--; + else if ( RES_TXTATR_TOXMARK == nAttr ) + rFnt.GetTox()--; + else if ( (RES_TXTATR_META == nAttr) || (RES_TXTATR_METAFIELD == nAttr) ) + { + rFnt.GetMeta()--; + } + else if (nAttr == RES_TXTATR_CONTENTCONTROL) + { + rFnt.GetContentControl()--; + } + else if ( RES_TXTATR_CJK_RUBY == nAttr ) + { + // ruby stack has no more attributes + // check, if a rotation attribute has to be applied + const sal_uInt16 nTwoLineStack = StackPos[ RES_CHRATR_TWO_LINES ]; + bool bTwoLineAct = false; + const SwTextAttr* pTwoLineAttr = GetTop(nTwoLineStack); + + if ( pTwoLineAttr ) + { + const auto& rTwoLineItem = *CharFormat::GetItem( *pTwoLineAttr, RES_CHRATR_TWO_LINES ); + bTwoLineAct = rTwoLineItem.GetValue(); + } + else + bTwoLineAct = m_pDefaultArray[ nTwoLineStack ]->StaticWhichCast(RES_CHRATR_TWO_LINES).GetValue(); + + if ( bTwoLineAct ) + return; + + // eventually, a rotate attribute has to be activated + const sal_uInt16 nRotateStack = StackPos[ RES_CHRATR_ROTATE ]; + const SwTextAttr* pRotateAttr = GetTop(nRotateStack); + + if ( pRotateAttr ) + { + const auto& rRotateItem = *CharFormat::GetItem( *pRotateAttr, RES_CHRATR_ROTATE ); + rFnt.SetVertical( rRotateItem.GetValue(), m_bVertLayout ); + } + else + rFnt.SetVertical( m_pDefaultArray[ nRotateStack ]->StaticWhichCast(RES_CHRATR_ROTATE).GetValue(), m_bVertLayout ); + } + else if ( RES_TXTATR_INPUTFIELD == nAttr ) + rFnt.GetInputField()--; +} + +/** + * When popping an attribute from the stack, the top more remaining + * attribute in the stack becomes valid. The following function change + * a font depending on the stack id. + */ +void SwAttrHandler::FontChg(const SfxPoolItem& rItem, SwFont& rFnt, bool bPush ) +{ + switch ( rItem.Which() ) + { + case RES_CHRATR_CASEMAP : + rFnt.SetCaseMap( rItem.StaticWhichCast(RES_CHRATR_CASEMAP).GetCaseMap() ); + break; + case RES_CHRATR_COLOR : + rFnt.SetColor( rItem.StaticWhichCast(RES_CHRATR_COLOR).GetValue() ); + break; + case RES_CHRATR_CONTOUR : + rFnt.SetOutline( rItem.StaticWhichCast(RES_CHRATR_CONTOUR).GetValue() ); + break; + case RES_CHRATR_CROSSEDOUT : + rFnt.SetStrikeout( rItem.StaticWhichCast(RES_CHRATR_CROSSEDOUT).GetStrikeout() ); + break; + case RES_CHRATR_ESCAPEMENT : + rFnt.SetEscapement( rItem.StaticWhichCast(RES_CHRATR_ESCAPEMENT).GetEsc() ); + rFnt.SetProportion( rItem.StaticWhichCast(RES_CHRATR_ESCAPEMENT).GetProportionalHeight() ); + break; + case RES_CHRATR_FONT : + { + auto& rFontItem = rItem.StaticWhichCast(RES_CHRATR_FONT); + rFnt.SetName( rFontItem.GetFamilyName(), SwFontScript::Latin ); + rFnt.SetStyleName( rFontItem.GetStyleName(), SwFontScript::Latin ); + rFnt.SetFamily( rFontItem.GetFamily(), SwFontScript::Latin ); + rFnt.SetPitch( rFontItem.GetPitch(), SwFontScript::Latin ); + rFnt.SetCharSet( rFontItem.GetCharSet(), SwFontScript::Latin ); + break; + } + case RES_CHRATR_FONTSIZE : + rFnt.SetSize(Size(0, rItem.StaticWhichCast(RES_CHRATR_FONTSIZE).GetHeight() ), SwFontScript::Latin ); + break; + case RES_CHRATR_KERNING : + rFnt.SetFixKerning( rItem.StaticWhichCast(RES_CHRATR_KERNING).GetValue() ); + break; + case RES_CHRATR_LANGUAGE : + rFnt.SetLanguage( rItem.StaticWhichCast(RES_CHRATR_LANGUAGE).GetLanguage(), SwFontScript::Latin ); + break; + case RES_CHRATR_POSTURE : + rFnt.SetItalic( rItem.StaticWhichCast(RES_CHRATR_POSTURE).GetPosture(), SwFontScript::Latin ); + break; + case RES_CHRATR_SHADOWED : + rFnt.SetShadow( rItem.StaticWhichCast(RES_CHRATR_SHADOWED).GetValue() ); + break; + case RES_CHRATR_UNDERLINE : + { + const sal_uInt16 nStackPos = StackPos[ RES_CHRATR_HIDDEN ]; + const SwTextAttr* pTopAt = GetTop(nStackPos); + + const SfxPoolItem* pTmpItem = pTopAt ? + CharFormat::GetItem( *pTopAt, RES_CHRATR_HIDDEN ) : + m_pDefaultArray[ nStackPos ]; + + if ((m_pShell && !m_pShell->GetWin()) || + (pTmpItem && !pTmpItem->StaticWhichCast(RES_CHRATR_HIDDEN).GetValue()) ) + { + rFnt.SetUnderline( rItem.StaticWhichCast(RES_CHRATR_UNDERLINE).GetLineStyle() ); + rFnt.SetUnderColor( rItem.StaticWhichCast(RES_CHRATR_UNDERLINE).GetColor() ); + } + break; + } + case RES_CHRATR_BOX: + { + const SvxBoxItem& aBoxItem = rItem.StaticWhichCast(RES_CHRATR_BOX); + rFnt.SetTopBorder( aBoxItem.GetTop() ); + rFnt.SetBottomBorder( aBoxItem.GetBottom() ); + rFnt.SetRightBorder( aBoxItem.GetRight() ); + rFnt.SetLeftBorder( aBoxItem.GetLeft() ); + rFnt.SetTopBorderDist( aBoxItem.GetDistance(SvxBoxItemLine::TOP) ); + rFnt.SetBottomBorderDist( aBoxItem.GetDistance(SvxBoxItemLine::BOTTOM) ); + rFnt.SetRightBorderDist( aBoxItem.GetDistance(SvxBoxItemLine::RIGHT) ); + rFnt.SetLeftBorderDist( aBoxItem.GetDistance(SvxBoxItemLine::LEFT) ); + break; + } + case RES_CHRATR_SHADOW: + { + const SvxShadowItem& aShadowItem = rItem.StaticWhichCast(RES_CHRATR_SHADOW); + rFnt.SetShadowColor( aShadowItem.GetColor() ); + rFnt.SetShadowWidth( aShadowItem.GetWidth() ); + rFnt.SetShadowLocation( aShadowItem.GetLocation() ); + break; + } + case RES_CHRATR_OVERLINE : + rFnt.SetOverline( rItem.StaticWhichCast(RES_CHRATR_OVERLINE).GetLineStyle() ); + rFnt.SetOverColor( rItem.StaticWhichCast(RES_CHRATR_OVERLINE).GetColor() ); + break; + case RES_CHRATR_WEIGHT : + rFnt.SetWeight( rItem.StaticWhichCast(RES_CHRATR_WEIGHT).GetWeight(), SwFontScript::Latin ); + break; + case RES_CHRATR_WORDLINEMODE : + rFnt.SetWordLineMode( rItem.StaticWhichCast(RES_CHRATR_WORDLINEMODE).GetValue() ); + break; + case RES_CHRATR_AUTOKERN : + if( rItem.StaticWhichCast(RES_CHRATR_AUTOKERN).GetValue() ) + { + rFnt.SetAutoKern( (!m_pIDocumentSettingAccess || + !m_pIDocumentSettingAccess->get(DocumentSettingId::KERN_ASIAN_PUNCTUATION)) ? + FontKerning::FontSpecific : + FontKerning::Asian ); + } + else + rFnt.SetAutoKern( FontKerning::NONE ); + break; + case RES_CHRATR_BACKGROUND : + rFnt.SetBackColor(rItem.StaticWhichCast(RES_CHRATR_BACKGROUND).GetColor()); + break; + case RES_CHRATR_HIGHLIGHT : + rFnt.SetHighlightColor( rItem.StaticWhichCast(RES_CHRATR_HIGHLIGHT).GetColor() ); + break; + case RES_CHRATR_CJK_FONT : + { + auto& rFontItem = rItem.StaticWhichCast(RES_CHRATR_CJK_FONT); + rFnt.SetName( rFontItem.GetFamilyName(), SwFontScript::CJK ); + rFnt.SetStyleName( rFontItem.GetStyleName(), SwFontScript::CJK ); + rFnt.SetFamily( rFontItem.GetFamily(), SwFontScript::CJK ); + rFnt.SetPitch( rFontItem.GetPitch(), SwFontScript::CJK ); + rFnt.SetCharSet( rFontItem.GetCharSet(), SwFontScript::CJK ); + break; + } + case RES_CHRATR_CJK_FONTSIZE : + rFnt.SetSize(Size( 0, rItem.StaticWhichCast(RES_CHRATR_CJK_FONTSIZE).GetHeight()), SwFontScript::CJK); + break; + case RES_CHRATR_CJK_LANGUAGE : + rFnt.SetLanguage( rItem.StaticWhichCast(RES_CHRATR_CJK_LANGUAGE).GetLanguage(), SwFontScript::CJK ); + break; + case RES_CHRATR_CJK_POSTURE : + rFnt.SetItalic( rItem.StaticWhichCast(RES_CHRATR_CJK_POSTURE).GetPosture(), SwFontScript::CJK ); + break; + case RES_CHRATR_CJK_WEIGHT : + rFnt.SetWeight( rItem.StaticWhichCast(RES_CHRATR_CJK_WEIGHT).GetWeight(), SwFontScript::CJK ); + break; + case RES_CHRATR_CTL_FONT : + { + auto& rFontItem = rItem.StaticWhichCast(RES_CHRATR_CTL_FONT); + rFnt.SetName( rFontItem.GetFamilyName(), SwFontScript::CTL ); + rFnt.SetStyleName( rFontItem.GetStyleName(), SwFontScript::CTL ); + rFnt.SetFamily( rFontItem.GetFamily(), SwFontScript::CTL ); + rFnt.SetPitch( rFontItem.GetPitch(), SwFontScript::CTL ); + rFnt.SetCharSet( rFontItem.GetCharSet(), SwFontScript::CTL ); + break; + } + case RES_CHRATR_CTL_FONTSIZE : + rFnt.SetSize(Size(0, rItem.StaticWhichCast(RES_CHRATR_CTL_FONTSIZE).GetHeight() ), SwFontScript::CTL); + break; + case RES_CHRATR_CTL_LANGUAGE : + rFnt.SetLanguage( rItem.StaticWhichCast(RES_CHRATR_CTL_LANGUAGE).GetLanguage(), SwFontScript::CTL ); + break; + case RES_CHRATR_CTL_POSTURE : + rFnt.SetItalic( rItem.StaticWhichCast(RES_CHRATR_CTL_POSTURE).GetPosture(), SwFontScript::CTL ); + break; + case RES_CHRATR_CTL_WEIGHT : + rFnt.SetWeight( rItem.StaticWhichCast(RES_CHRATR_CTL_WEIGHT).GetWeight(), SwFontScript::CTL ); + break; + case RES_CHRATR_EMPHASIS_MARK : + rFnt.SetEmphasisMark( rItem.StaticWhichCast(RES_CHRATR_EMPHASIS_MARK).GetEmphasisMark() ); + break; + case RES_CHRATR_SCALEW : + rFnt.SetPropWidth( rItem.StaticWhichCast(RES_CHRATR_SCALEW).GetValue() ); + break; + case RES_CHRATR_RELIEF : + rFnt.SetRelief( rItem.StaticWhichCast(RES_CHRATR_RELIEF).GetValue() ); + break; + case RES_CHRATR_HIDDEN : + if (m_pShell && m_pShell->GetWin()) + { + if ( rItem.StaticWhichCast(RES_CHRATR_HIDDEN).GetValue() ) + rFnt.SetUnderline( LINESTYLE_DOTTED ); + else + ActivateTop( rFnt, RES_CHRATR_UNDERLINE ); + } + break; + case RES_CHRATR_ROTATE : + { + // rotate attribute is applied, when: + // 1. ruby stack is empty and + // 2. top of two line stack ( or default attribute )is an + // deactivated two line attribute + const bool bRuby = + 0 != m_aAttrStack[ StackPos[ RES_TXTATR_CJK_RUBY ] ].size(); + + if ( bRuby ) + break; + + const sal_uInt16 nTwoLineStack = StackPos[ RES_CHRATR_TWO_LINES ]; + bool bTwoLineAct = false; + const SwTextAttr* pTwoLineAttr = GetTop(nTwoLineStack); + + if ( pTwoLineAttr ) + { + const auto& rTwoLineItem = *CharFormat::GetItem( *pTwoLineAttr, RES_CHRATR_TWO_LINES ); + bTwoLineAct = rTwoLineItem.GetValue(); + } + else + bTwoLineAct = m_pDefaultArray[ nTwoLineStack ]->StaticWhichCast(RES_CHRATR_TWO_LINES).GetValue(); + + if ( !bTwoLineAct ) + rFnt.SetVertical( rItem.StaticWhichCast(RES_CHRATR_ROTATE).GetValue(), m_bVertLayout, m_bVertLayoutLRBT ); + + break; + } + case RES_CHRATR_TWO_LINES : + { + bool bRuby = 0 != + m_aAttrStack[ StackPos[ RES_TXTATR_CJK_RUBY ] ].size(); + + // two line is activated, if + // 1. no ruby attribute is set and + // 2. attribute is active + if ( !bRuby && rItem.StaticWhichCast(RES_CHRATR_TWO_LINES).GetValue() ) + { + rFnt.SetVertical( 0_deg10, m_bVertLayout ); + break; + } + + // a deactivating two line attribute is on top of stack, + // check if rotate attribute has to be enabled + if ( bRuby ) + break; + + const sal_uInt16 nRotateStack = StackPos[ RES_CHRATR_ROTATE ]; + const SwTextAttr* pRotateAttr = GetTop(nRotateStack); + + if ( pRotateAttr ) + { + const auto& rRotateItem = *CharFormat::GetItem( *pRotateAttr, RES_CHRATR_ROTATE ); + rFnt.SetVertical( rRotateItem.GetValue(), m_bVertLayout ); + } + else + rFnt.SetVertical(m_pDefaultArray[ nRotateStack ]->StaticWhichCast(RES_CHRATR_ROTATE).GetValue(), m_bVertLayout); + break; + } + case RES_TXTATR_CJK_RUBY : + rFnt.SetVertical( 0_deg10, m_bVertLayout ); + break; + case RES_TXTATR_REFMARK : + if ( bPush ) + rFnt.GetRef()++; + else + rFnt.GetRef()--; + break; + case RES_TXTATR_TOXMARK : + if ( bPush ) + rFnt.GetTox()++; + else + rFnt.GetTox()--; + break; + case RES_TXTATR_META: + case RES_TXTATR_METAFIELD: + if ( bPush ) + rFnt.GetMeta()++; + else + rFnt.GetMeta()--; + break; + case RES_TXTATR_CONTENTCONTROL: + if (bPush) + { + rFnt.GetContentControl()++; + } + else + { + rFnt.GetContentControl()--; + } + break; + case RES_TXTATR_INPUTFIELD : + if ( bPush ) + rFnt.GetInputField()++; + else + rFnt.GetInputField()--; + break; + } +} + +/// Takes the default font and calculated the ascent and height +void SwAttrHandler::GetDefaultAscentAndHeight( SwViewShell const * pShell, OutputDevice const & rOut, + sal_uInt16& nAscent, sal_uInt16& nHeight ) const +{ + OSL_ENSURE(m_oFnt, "No font available for GetDefaultAscentAndHeight"); + + if (m_oFnt) + { + SwFont aFont( *m_oFnt ); + nHeight = aFont.GetHeight( pShell, rOut ); + nAscent = aFont.GetAscent( pShell, rOut ); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/frmcrsr.cxx b/sw/source/core/text/frmcrsr.cxx new file mode 100644 index 0000000000..d7f7a2cab9 --- /dev/null +++ b/sw/source/core/text/frmcrsr.cxx @@ -0,0 +1,1691 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "pormulti.hxx" +#include +#include +#include + +#include + +#include +#include "inftxt.hxx" +#include "itrtxt.hxx" +#include +#include +#include +#include + +#define MIN_OFFSET_STEP 10 + +using namespace ::com::sun::star; + +/* + * - SurvivalKit: For how long do we get past the last char of the line. + * - RightMargin abstains from adjusting position with -1 + * - GetCharRect returns a GetEndCharRect for CursorMoveState::RightMargin + * - GetEndCharRect sets bRightMargin to true + * - SwTextCursor::bRightMargin is set to false by CharCursorToLine + */ + +namespace +{ + +SwTextFrame *GetAdjFrameAtPos( SwTextFrame *pFrame, const SwPosition &rPos, + const bool bRightMargin, const bool bNoScroll = true ) +{ + // RightMargin in the last master line + TextFrameIndex const nOffset = pFrame->MapModelToViewPos(rPos); + SwTextFrame *pFrameAtPos = pFrame; + if( !bNoScroll || pFrame->GetFollow() ) + { + pFrameAtPos = pFrame->GetFrameAtPos( rPos ); + if (nOffset < pFrameAtPos->GetOffset() && + !pFrameAtPos->IsFollow() ) + { + assert(pFrameAtPos->MapModelToViewPos(rPos) == nOffset); + TextFrameIndex nNew(nOffset); + if (nNew < TextFrameIndex(MIN_OFFSET_STEP)) + nNew = TextFrameIndex(0); + else + nNew -= TextFrameIndex(MIN_OFFSET_STEP); + sw_ChangeOffset( pFrameAtPos, nNew ); + } + } + while( pFrame != pFrameAtPos ) + { + pFrame = pFrameAtPos; + pFrame->GetFormatted(); + pFrameAtPos = pFrame->GetFrameAtPos( rPos ); + } + + if( nOffset && bRightMargin ) + { + while (pFrameAtPos && + pFrameAtPos->MapViewToModelPos(pFrameAtPos->GetOffset()) == rPos && + pFrameAtPos->IsFollow() ) + { + pFrameAtPos->GetFormatted(); + pFrameAtPos = pFrameAtPos->FindMaster(); + } + OSL_ENSURE( pFrameAtPos, "+GetCharRect: no frame with my rightmargin" ); + } + return pFrameAtPos ? pFrameAtPos : pFrame; +} + +} + +bool sw_ChangeOffset(SwTextFrame* pFrame, TextFrameIndex nNew) +{ + // Do not scroll in areas and outside of flies + OSL_ENSURE( !pFrame->IsFollow(), "Illegal Scrolling by Follow!" ); + if( pFrame->GetOffset() != nNew && !pFrame->IsInSct() ) + { + SwFlyFrame *pFly = pFrame->FindFlyFrame(); + // Attention: if e.g. in a column frame the size is still invalid + // we must not scroll around just like that + if ( ( pFly && pFly->isFrameAreaDefinitionValid() && + !pFly->GetNextLink() && !pFly->GetPrevLink() ) || + ( !pFly && pFrame->IsInTab() ) ) + { + SwViewShell* pVsh = pFrame->getRootFrame()->GetCurrShell(); + if( pVsh ) + { + if( pVsh->GetRingContainer().size() > 1 || + ( pFrame->GetDrawObjs() && pFrame->GetDrawObjs()->size() ) ) + { + if( !pFrame->GetOffset() ) + return false; + nNew = TextFrameIndex(0); + } + pFrame->SetOffset( nNew ); + pFrame->SetPara( nullptr ); + pFrame->GetFormatted(); + if( pFrame->getFrameArea().HasArea() ) + pFrame->getRootFrame()->GetCurrShell()->InvalidateWindows( pFrame->getFrameArea() ); + return true; + } + } + } + return false; +} + +SwTextFrame& SwTextFrame::GetFrameAtOfst(TextFrameIndex const nWhere) +{ + SwTextFrame* pRet = this; + while( pRet->HasFollow() && nWhere >= pRet->GetFollow()->GetOffset() ) + pRet = pRet->GetFollow(); + return *pRet; +} + +SwTextFrame *SwTextFrame::GetFrameAtPos( const SwPosition &rPos ) +{ + TextFrameIndex const nPos(MapModelToViewPos(rPos)); + SwTextFrame *pFoll = this; + while( pFoll->GetFollow() ) + { + if (nPos > pFoll->GetFollow()->GetOffset()) + pFoll = pFoll->GetFollow(); + else + { + if (nPos == pFoll->GetFollow()->GetOffset() + && !SwTextCursor::IsRightMargin() ) + pFoll = pFoll->GetFollow(); + else + break; + } + } + return pFoll; +} + +/* + * GetCharRect() returns the char's char line described by aPos. + * GetModelPositionForViewPoint() does the reverse: It goes from a document coordinate to + * a Pam. + * Both are virtual in the frame base class and thus are redefined here. + */ + +bool SwTextFrame::GetCharRect( SwRect& rOrig, const SwPosition &rPos, + SwCursorMoveState *pCMS, bool bAllowFarAway ) const +{ + OSL_ENSURE( ! IsVertical() || ! IsSwapped(),"SwTextFrame::GetCharRect with swapped frame" ); + + if (IsLocked()) + return false; + + // Find the right frame first. We need to keep in mind that: + // - the cached information could be invalid (GetPara() == 0) + // - we could have a Follow + // - the Follow chain grows dynamically; the one we end up in + // needs to be formatted + + // Optimisation: reading ahead saves us a GetAdjFrameAtPos + const bool bRightMargin = pCMS && ( CursorMoveState::RightMargin == pCMS->m_eState ); + const bool bNoScroll = pCMS && pCMS->m_bNoScroll; + SwTextFrame *pFrame = GetAdjFrameAtPos( const_cast(this), rPos, bRightMargin, + bNoScroll ); + pFrame->GetFormatted(); + + const SwFrame* pTmpFrame = pFrame->GetUpper(); + if (pTmpFrame->getFrameArea().Top() == FAR_AWAY && !bAllowFarAway) + return false; + + SwRectFnSet aRectFnSet(pFrame); + const SwTwips nUpperMaxY = aRectFnSet.GetPrtBottom(*pTmpFrame); + const SwTwips nFrameMaxY = aRectFnSet.GetPrtBottom(*pFrame); + + // nMaxY is an absolute value + SwTwips nMaxY = aRectFnSet.IsVert() ? + ( aRectFnSet.IsVertL2R() ? std::min( nFrameMaxY, nUpperMaxY ) : std::max( nFrameMaxY, nUpperMaxY ) ) : + std::min( nFrameMaxY, nUpperMaxY ); + + bool bRet = false; + + if ( pFrame->IsEmpty() || ! aRectFnSet.GetHeight(pFrame->getFramePrintArea()) ) + { + Point aPnt1 = pFrame->getFrameArea().Pos() + pFrame->getFramePrintArea().Pos(); + SwTextNode const*const pTextNd(GetTextNodeForParaProps()); + short nFirstOffset; + pTextNd->GetFirstLineOfsWithNum( nFirstOffset ); + + Point aPnt2; + if ( aRectFnSet.IsVert() ) + { + if( nFirstOffset > 0 ) + aPnt1.AdjustY(nFirstOffset ); + if ( aPnt1.X() < nMaxY && !aRectFnSet.IsVertL2R() ) + aPnt1.setX( nMaxY ); + aPnt2.setX( aPnt1.X() + pFrame->getFramePrintArea().Width() ); + aPnt2.setY( aPnt1.Y() ); + if( aPnt2.X() < nMaxY ) + aPnt2.setX( nMaxY ); + } + else + { + if( nFirstOffset > 0 ) + aPnt1.AdjustX(nFirstOffset ); + + if( aPnt1.Y() > nMaxY ) + aPnt1.setY( nMaxY ); + aPnt2.setX( aPnt1.X() ); + aPnt2.setY( aPnt1.Y() + pFrame->getFramePrintArea().Height() ); + if( aPnt2.Y() > nMaxY ) + aPnt2.setY( nMaxY ); + } + + rOrig = SwRect( aPnt1, aPnt2 ); + + if ( pCMS ) + { + pCMS->m_aRealHeight.setX( 0 ); + pCMS->m_aRealHeight.setY( aRectFnSet.IsVert() ? -rOrig.Width() : rOrig.Height() ); + } + + if ( pFrame->IsRightToLeft() ) + pFrame->SwitchLTRtoRTL( rOrig ); + + bRet = true; + } + else + { + if( !pFrame->HasPara() ) + return false; + + SwFrameSwapper aSwapper( pFrame, true ); + if ( aRectFnSet.IsVert() ) + nMaxY = pFrame->SwitchVerticalToHorizontal( nMaxY ); + + bool bGoOn = true; + TextFrameIndex const nOffset = MapModelToViewPos(rPos); + assert(nOffset != TextFrameIndex(COMPLETE_STRING)); // not going to end well + TextFrameIndex nNextOfst; + + do + { + { + SwTextSizeInfo aInf( pFrame ); + SwTextCursor aLine( pFrame, &aInf ); + nNextOfst = aLine.GetEnd(); + // See comment in AdjustFrame + // Include the line's last char? + if (bRightMargin) + aLine.GetEndCharRect( &rOrig, nOffset, pCMS, nMaxY ); + else + aLine.GetCharRect( &rOrig, nOffset, pCMS, nMaxY ); + bRet = true; + } + + if ( pFrame->IsRightToLeft() ) + pFrame->SwitchLTRtoRTL( rOrig ); + + if ( aRectFnSet.IsVert() ) + pFrame->SwitchHorizontalToVertical( rOrig ); + + if( pFrame->IsUndersized() && pCMS && !pFrame->GetNext() && + aRectFnSet.GetBottom(rOrig) == nUpperMaxY && + pFrame->GetOffset() < nOffset && + !pFrame->IsFollow() && !bNoScroll && + TextFrameIndex(pFrame->GetText().getLength()) != nNextOfst) + { + bGoOn = sw_ChangeOffset( pFrame, nNextOfst ); + } + else + bGoOn = false; + } while ( bGoOn ); + + if ( pCMS ) + { + if ( pFrame->IsRightToLeft() ) + { + if( pCMS->m_b2Lines && pCMS->m_p2Lines) + { + pFrame->SwitchLTRtoRTL( pCMS->m_p2Lines->aLine ); + pFrame->SwitchLTRtoRTL( pCMS->m_p2Lines->aPortion ); + } + } + + if ( aRectFnSet.IsVert() ) + { + if ( pCMS->m_bRealHeight ) + { + pCMS->m_aRealHeight.setY( -pCMS->m_aRealHeight.Y() ); + if ( pCMS->m_aRealHeight.Y() < 0 ) + { + // writing direction is from top to bottom + pCMS->m_aRealHeight.setX( rOrig.Width() - + pCMS->m_aRealHeight.X() + + pCMS->m_aRealHeight.Y() ); + } + } + if( pCMS->m_b2Lines && pCMS->m_p2Lines) + { + pFrame->SwitchHorizontalToVertical( pCMS->m_p2Lines->aLine ); + pFrame->SwitchHorizontalToVertical( pCMS->m_p2Lines->aPortion ); + } + } + + } + } + if( bRet ) + { + SwPageFrame *pPage = pFrame->FindPageFrame(); + OSL_ENSURE( pPage, "Text escaped from page?" ); + const SwTwips nOrigTop = aRectFnSet.GetTop(rOrig); + const SwTwips nPageTop = aRectFnSet.GetTop(pPage->getFrameArea()); + const SwTwips nPageBott = aRectFnSet.GetBottom(pPage->getFrameArea()); + + // We have the following situation: if the frame is in an invalid + // sectionframe, it's possible that the frame is outside the page. + // If we restrict the cursor position to the page area, we enforce + // the formatting of the page, of the section frame and the frame itself. + if( aRectFnSet.YDiff( nPageTop, nOrigTop ) > 0 ) + aRectFnSet.SetTop( rOrig, nPageTop ); + + if ( aRectFnSet.YDiff( nOrigTop, nPageBott ) > 0 ) + aRectFnSet.SetTop( rOrig, nPageBott ); + } + + return bRet; +} + +/* + * GetAutoPos() looks up the char's char line which is described by rPos + * and is used by the auto-positioned frame. + */ + +bool SwTextFrame::GetAutoPos( SwRect& rOrig, const SwPosition &rPos ) const +{ + if( IsHiddenNow() ) + return false; + + TextFrameIndex const nOffset = MapModelToViewPos(rPos); + SwTextFrame* pFrame = &(const_cast(this)->GetFrameAtOfst( nOffset )); + + pFrame->GetFormatted(); + const SwFrame* pTmpFrame = pFrame->GetUpper(); + + SwRectFnSet aRectFnSet(pTmpFrame); + SwTwips nUpperMaxY = aRectFnSet.GetPrtBottom(*pTmpFrame); + + // nMaxY is in absolute value + SwTwips nMaxY; + if ( aRectFnSet.IsVert() ) + { + if ( aRectFnSet.IsVertL2R() ) + nMaxY = std::min( SwTwips(aRectFnSet.GetPrtBottom(*pFrame)), nUpperMaxY ); + else + nMaxY = std::max( SwTwips(aRectFnSet.GetPrtBottom(*pFrame)), nUpperMaxY ); + } + else + nMaxY = std::min( SwTwips(aRectFnSet.GetPrtBottom(*pFrame)), nUpperMaxY ); + if ( pFrame->IsEmpty() || ! aRectFnSet.GetHeight(pFrame->getFramePrintArea()) ) + { + Point aPnt1 = pFrame->getFrameArea().Pos() + pFrame->getFramePrintArea().Pos(); + Point aPnt2; + if ( aRectFnSet.IsVert() ) + { + if ( aPnt1.X() < nMaxY && !aRectFnSet.IsVertL2R() ) + aPnt1.setX( nMaxY ); + + aPnt2.setX( aPnt1.X() + pFrame->getFramePrintArea().Width() ); + aPnt2.setY( aPnt1.Y() ); + if( aPnt2.X() < nMaxY ) + aPnt2.setX( nMaxY ); + } + else + { + if( aPnt1.Y() > nMaxY ) + aPnt1.setY( nMaxY ); + aPnt2.setX( aPnt1.X() ); + aPnt2.setY( aPnt1.Y() + pFrame->getFramePrintArea().Height() ); + if( aPnt2.Y() > nMaxY ) + aPnt2.setY( nMaxY ); + } + rOrig = SwRect( aPnt1, aPnt2 ); + return true; + } + else + { + if( !pFrame->HasPara() ) + return false; + + SwFrameSwapper aSwapper( pFrame, true ); + if ( aRectFnSet.IsVert() ) + nMaxY = pFrame->SwitchVerticalToHorizontal( nMaxY ); + + SwTextSizeInfo aInf( pFrame ); + SwTextCursor aLine( pFrame, &aInf ); + SwCursorMoveState aTmpState( CursorMoveState::SetOnlyText ); + aTmpState.m_bRealHeight = true; + aLine.GetCharRect( &rOrig, nOffset, &aTmpState, nMaxY ); + if( aTmpState.m_aRealHeight.X() >= 0 ) + { + rOrig.Pos().AdjustY(aTmpState.m_aRealHeight.X() ); + rOrig.Height( aTmpState.m_aRealHeight.Y() ); + } + + if ( pFrame->IsRightToLeft() ) + pFrame->SwitchLTRtoRTL( rOrig ); + + if ( aRectFnSet.IsVert() ) + pFrame->SwitchHorizontalToVertical( rOrig ); + + return true; + } +} + +/** determine top of line for given position in the text frame + + - Top of first paragraph line is the top of the printing area of the text frame + - If a proportional line spacing is applied use top of anchor character as + top of the line. +*/ +bool SwTextFrame::GetTopOfLine( SwTwips& _onTopOfLine, + const SwPosition& _rPos ) const +{ + bool bRet = true; + + // get position offset + TextFrameIndex const nOffset = MapModelToViewPos(_rPos); + + if (TextFrameIndex(GetText().getLength()) < nOffset) + { + bRet = false; + } + else + { + SwRectFnSet aRectFnSet(this); + if ( IsEmpty() || !aRectFnSet.GetHeight(getFramePrintArea()) ) + { + // consider upper space amount considered + // for previous frame and the page grid. + _onTopOfLine = aRectFnSet.GetPrtTop(*this); + } + else + { + // determine formatted text frame that contains the requested position + SwTextFrame* pFrame = &(const_cast(this)->GetFrameAtOfst( nOffset )); + pFrame->GetFormatted(); + aRectFnSet.Refresh(pFrame); + // If proportional line spacing is applied + // to the text frame, the top of the anchor character is also the + // top of the line. + // Otherwise the line layout determines the top of the line + const SvxLineSpacingItem& rSpace = GetAttrSet()->GetLineSpacing(); + if ( rSpace.GetInterLineSpaceRule() == SvxInterLineSpaceRule::Prop ) + { + SwRect aCharRect; + if ( GetAutoPos( aCharRect, _rPos ) ) + { + _onTopOfLine = aRectFnSet.GetTop(aCharRect); + } + else + { + bRet = false; + } + } + else + { + // assure that text frame is in a horizontal layout + SwFrameSwapper aSwapper( pFrame, true ); + // determine text line that contains the requested position + SwTextSizeInfo aInf( pFrame ); + SwTextCursor aLine( pFrame, &aInf ); + aLine.CharCursorToLine( nOffset ); + // determine top of line + _onTopOfLine = aLine.Y(); + if ( aRectFnSet.IsVert() ) + { + _onTopOfLine = pFrame->SwitchHorizontalToVertical( _onTopOfLine ); + } + } + } + } + + return bRet; +} + +// Minimum distance of non-empty lines is a little less than 2 cm +#define FILL_MIN_DIST 1100 + +struct SwFillData +{ + SwRect aFrame; + const SwCursorMoveState *pCMS; + SwPosition* pPos; + const Point& rPoint; + SwTwips nLineWidth; + bool bFirstLine : 1; + bool bInner : 1; + bool bColumn : 1; + bool bEmpty : 1; + SwFillData( const SwCursorMoveState *pC, SwPosition* pP, const SwRect& rR, + const Point& rPt ) : aFrame( rR ), pCMS( pC ), pPos( pP ), rPoint( rPt ), + nLineWidth( 0 ), bFirstLine( true ), bInner( false ), bColumn( false ), + bEmpty( true ){} + SwFillMode Mode() const { return pCMS->m_pFill->eMode; } + tools::Long X() const { return rPoint.X(); } + tools::Long Y() const { return rPoint.Y(); } + tools::Long Left() const { return aFrame.Left(); } + tools::Long Right() const { return aFrame.Right(); } + tools::Long Bottom() const { return aFrame.Bottom(); } + SwFillCursorPos &Fill() const { return *pCMS->m_pFill; } + void SetTab( sal_uInt16 nNew ) { pCMS->m_pFill->nTabCnt = nNew; } + void SetSpace( sal_uInt16 nNew ) { pCMS->m_pFill->nSpaceCnt = nNew; } + void SetSpaceOnly( sal_uInt16 nNew ) { pCMS->m_pFill->nSpaceOnlyCnt = nNew; } + void SetOrient( const sal_Int16 eNew ){ pCMS->m_pFill->eOrient = eNew; } +}; + +bool SwTextFrame::GetModelPositionForViewPoint_(SwPosition* pPos, const Point& rPoint, + const bool bChgFrame, SwCursorMoveState* pCMS ) const +{ + // GetModelPositionForViewPoint_ is called by GetModelPositionForViewPoint and GetKeyCursorOfst. + // Never just a return false. + + if( IsLocked() || IsHiddenNow() ) + return false; + + const_cast(this)->GetFormatted(); + + Point aOldPoint( rPoint ); + + if ( IsVertical() ) + { + SwitchVerticalToHorizontal( const_cast(rPoint) ); + const_cast(this)->SwapWidthAndHeight(); + } + + if ( IsRightToLeft() ) + SwitchRTLtoLTR( const_cast(rPoint) ); + + std::unique_ptr pFillData; + if ( pCMS && pCMS->m_pFill ) + pFillData.reset(new SwFillData( pCMS, pPos, getFrameArea(), rPoint )); + + if ( IsEmpty() ) + { + *pPos = MapViewToModelPos(TextFrameIndex(0)); + if( pCMS && pCMS->m_bFieldInfo ) + { + SwTwips nDiff = rPoint.X() - getFrameArea().Left() - getFramePrintArea().Left(); + if( nDiff > 50 || nDiff < 0 ) + pCMS->m_bPosCorr = true; + } + } + else + { + SwTextSizeInfo aInf( const_cast(this) ); + SwTextCursor aLine( const_cast(this), &aInf ); + + // See comment in AdjustFrame() + SwTwips nMaxY = getFrameArea().Top() + getFramePrintArea().Top() + getFramePrintArea().Height(); + aLine.TwipsToLine( rPoint.Y() ); + while( aLine.Y() + aLine.GetLineHeight() > nMaxY ) + { + if( !aLine.Prev() ) + break; + } + + if( aLine.GetDropLines() >= aLine.GetLineNr() && 1 != aLine.GetLineNr() + && rPoint.X() < aLine.FirstLeft() + aLine.GetDropLeft() ) + while( aLine.GetLineNr() > 1 ) + aLine.Prev(); + + TextFrameIndex nOffset = aLine.GetModelPositionForViewPoint(pPos, rPoint, bChgFrame, pCMS); + + if( pCMS && pCMS->m_eState == CursorMoveState::NONE && aLine.GetEnd() == nOffset ) + pCMS->m_eState = CursorMoveState::RightMargin; + + // pPos is a pure IN parameter and must not be evaluated. + // pIter->GetModelPositionForViewPoint returns from a nesting with COMPLETE_STRING. + // If SwTextIter::GetModelPositionForViewPoint calls GetModelPositionForViewPoint further by itself + // nNode changes the position. + // In such cases, pPos must not be calculated. + if (TextFrameIndex(COMPLETE_STRING) != nOffset) + { + *pPos = MapViewToModelPos(nOffset); + if( pFillData ) + { + if (TextFrameIndex(GetText().getLength()) > nOffset || + rPoint.Y() < getFrameArea().Top() ) + pFillData->bInner = true; + pFillData->bFirstLine = aLine.GetLineNr() < 2; + if (GetText().getLength()) + { + pFillData->bEmpty = false; + pFillData->nLineWidth = aLine.GetCurr()->Width(); + } + } + } + } + bool bChgFillData = false; + if( pFillData && FindPageFrame()->getFrameArea().Contains( aOldPoint ) ) + { + FillCursorPos( *pFillData ); + bChgFillData = true; + } + + if ( IsVertical() ) + { + if ( bChgFillData ) + SwitchHorizontalToVertical( pFillData->Fill().aCursor.Pos() ); + const_cast(this)->SwapWidthAndHeight(); + } + + if ( IsRightToLeft() && bChgFillData ) + { + SwitchLTRtoRTL( pFillData->Fill().aCursor.Pos() ); + const sal_Int16 eOrient = pFillData->pCMS->m_pFill->eOrient; + + if ( text::HoriOrientation::LEFT == eOrient ) + pFillData->SetOrient( text::HoriOrientation::RIGHT ); + else if ( text::HoriOrientation::RIGHT == eOrient ) + pFillData->SetOrient( text::HoriOrientation::LEFT ); + } + + const_cast(rPoint) = aOldPoint; + + return true; +} + +bool SwTextFrame::GetModelPositionForViewPoint(SwPosition* pPos, Point& rPoint, + SwCursorMoveState* pCMS, bool ) const +{ + const bool bChgFrame = !(pCMS && CursorMoveState::UpDown == pCMS->m_eState); + return GetModelPositionForViewPoint_( pPos, rPoint, bChgFrame, pCMS ); +} + +/* + * Layout-oriented cursor movement to the line start. + */ + +bool SwTextFrame::LeftMargin(SwPaM *pPam) const +{ + assert(GetMergedPara() || &pPam->GetPointNode() == static_cast(GetDep())); + + SwTextFrame *pFrame = GetAdjFrameAtPos( const_cast(this), *pPam->GetPoint(), + SwTextCursor::IsRightMargin() ); + pFrame->GetFormatted(); + TextFrameIndex nIndx; + if ( pFrame->IsEmpty() ) + nIndx = TextFrameIndex(0); + else + { + SwTextSizeInfo aInf( pFrame ); + SwTextCursor aLine( pFrame, &aInf ); + + aLine.CharCursorToLine(pFrame->MapModelToViewPos(*pPam->GetPoint())); + nIndx = aLine.GetStart(); + if( pFrame->GetOffset() && !pFrame->IsFollow() && !aLine.GetPrev() ) + { + sw_ChangeOffset(pFrame, TextFrameIndex(0)); + nIndx = TextFrameIndex(0); + } + } + *pPam->GetPoint() = pFrame->MapViewToModelPos(nIndx); + SwTextCursor::SetRightMargin( false ); + return true; +} + +/* + * To the line end: That's the position before the last char of the line. + * Exception: In the last line, it should be able to place the cursor after + * the last char in order to append text. + */ + +bool SwTextFrame::RightMargin(SwPaM *pPam, bool bAPI) const +{ + assert(GetMergedPara() || &pPam->GetPointNode() == static_cast(GetDep())); + + SwTextFrame *pFrame = GetAdjFrameAtPos( const_cast(this), *pPam->GetPoint(), + SwTextCursor::IsRightMargin() ); + pFrame->GetFormatted(); + TextFrameIndex nRightMargin(0); + if (!IsEmpty()) + { + SwTextSizeInfo aInf( pFrame ); + SwTextCursor aLine( pFrame, &aInf ); + + aLine.CharCursorToLine(MapModelToViewPos(*pPam->GetPoint())); + nRightMargin = aLine.GetStart() + aLine.GetCurr()->GetLen(); + + // We skip hard line breaks + if( aLine.GetCurr()->GetLen() && + CH_BREAK == aInf.GetText()[sal_Int32(nRightMargin) - 1]) + --nRightMargin; + else if( !bAPI && (aLine.GetNext() || pFrame->GetFollow()) ) + { + while( nRightMargin > aLine.GetStart() && + ' ' == aInf.GetText()[sal_Int32(nRightMargin) - 1]) + --nRightMargin; + } + } + *pPam->GetPoint() = pFrame->MapViewToModelPos(nRightMargin); + SwTextCursor::SetRightMargin( !bAPI ); + return true; +} + +// The following two methods try to put the Cursor into the next/successive +// line. If we do not have a preceding/successive line we forward the call +// to the base class. +// The Cursor's horizontal justification is done afterwards by the CursorShell. + +namespace { + +class SwSetToRightMargin +{ + bool m_bRight; + +public: + SwSetToRightMargin() + : m_bRight(false) + { + } + ~SwSetToRightMargin() { SwTextCursor::SetRightMargin(m_bRight); } + void SetRight(const bool bNew) { m_bRight = bNew; } +}; + +} + +bool SwTextFrame::UnitUp_( SwPaM *pPam, const SwTwips nOffset, + bool bSetInReadOnly ) const +{ + // Set the RightMargin if needed + SwSetToRightMargin aSet; + + if( IsInTab() && + pPam->GetPointNode().StartOfSectionNode() != + pPam->GetMarkNode().StartOfSectionNode() ) + { + // If the PaM is located within different boxes, we have a table selection, + // which is handled by the base class. + return SwContentFrame::UnitUp( pPam, nOffset, bSetInReadOnly ); + } + + const_cast(this)->GetFormatted(); + const TextFrameIndex nPos = MapModelToViewPos(*pPam->GetPoint()); + SwRect aCharBox; + + if( !IsEmpty() && !IsHiddenNow() ) + { + TextFrameIndex nFormat(COMPLETE_STRING); + do + { + if (nFormat != TextFrameIndex(COMPLETE_STRING) && !IsFollow()) + sw_ChangeOffset( const_cast(this), nFormat ); + + SwTextSizeInfo aInf( const_cast(this) ); + SwTextCursor aLine( const_cast(this), &aInf ); + + // Optimize away flys with no flow and IsDummy() + if( nPos ) + aLine.CharCursorToLine( nPos ); + else + aLine.Top(); + + const SwLineLayout *pPrevLine = aLine.GetPrevLine(); + const TextFrameIndex nStart = aLine.GetStart(); + aLine.GetCharRect( &aCharBox, nPos ); + + bool bSecondOfDouble = ( aInf.IsMulti() && ! aInf.IsFirstMulti() ); + bool bPrevLine = ( pPrevLine && pPrevLine != aLine.GetCurr() ); + + if( !pPrevLine && !bSecondOfDouble && GetOffset() && !IsFollow() ) + { + nFormat = GetOffset(); + TextFrameIndex nDiff = aLine.GetLength(); + if( !nDiff ) + nDiff = TextFrameIndex(MIN_OFFSET_STEP); + if( nFormat > nDiff ) + nFormat = nFormat - nDiff; + else + nFormat = TextFrameIndex(0); + continue; + } + + // We select the target line for the cursor, in case we are in a + // double line portion, prev line = curr line + if( bPrevLine && !bSecondOfDouble ) + { + aLine.PrevLine(); + while ( aLine.GetStart() == nStart && + nullptr != ( pPrevLine = aLine.GetPrevLine() ) && + pPrevLine != aLine.GetCurr() ) + aLine.PrevLine(); + } + + if ( bPrevLine || bSecondOfDouble ) + { + aCharBox.Width( aCharBox.SSize().Width() / 2 ); + aCharBox.Pos().setX( aCharBox.Pos().X() - 150 ); + + // See comment in SwTextFrame::GetModelPositionForViewPoint() +#if OSL_DEBUG_LEVEL > 0 + const SwNodeOffset nOldNode = pPam->GetPoint()->GetNodeIndex(); +#endif + // The node should not be changed + TextFrameIndex nTmpOfst = aLine.GetModelPositionForViewPoint(pPam->GetPoint(), + aCharBox.Pos(), false ); +#if OSL_DEBUG_LEVEL > 0 + OSL_ENSURE( nOldNode == pPam->GetPoint()->GetNodeIndex(), + "SwTextFrame::UnitUp: illegal node change" ); +#endif + + // We make sure that we move up. + if( nTmpOfst >= nStart && nStart && !bSecondOfDouble ) + { + nTmpOfst = nStart; + aSet.SetRight( true ); + } + *pPam->GetPoint() = MapViewToModelPos(nTmpOfst); + return true; + } + + if ( IsFollow() ) + { + aLine.GetCharRect( &aCharBox, nPos ); + aCharBox.Width( aCharBox.SSize().Width() / 2 ); + } + break; + } while ( true ); + } + /* If 'this' is a follow and a prev failed, we need to go to the + * last line of the master, which is us. + * Or: If we are a follow with follow, we need to get the master. + */ + if ( IsFollow() ) + { + const SwTextFrame *pTmpPrev = FindMaster(); + TextFrameIndex nOffs = GetOffset(); + if( pTmpPrev ) + { + SwViewShell *pSh = getRootFrame()->GetCurrShell(); + const bool bProtectedAllowed = pSh && pSh->GetViewOptions()->IsCursorInProtectedArea(); + const SwTextFrame *pPrevPrev = pTmpPrev; + // We skip protected frames and frames without content here + while( pPrevPrev && ( pPrevPrev->GetOffset() == nOffs || + ( !bProtectedAllowed && pPrevPrev->IsProtected() ) ) ) + { + pTmpPrev = pPrevPrev; + nOffs = pTmpPrev->GetOffset(); + if ( pPrevPrev->IsFollow() ) + pPrevPrev = pTmpPrev->FindMaster(); + else + pPrevPrev = nullptr; + } + if ( !pPrevPrev ) + return pTmpPrev->SwContentFrame::UnitUp( pPam, nOffset, bSetInReadOnly ); + aCharBox.Pos().setY( pPrevPrev->getFrameArea().Bottom() - 1 ); + return pPrevPrev->GetKeyCursorOfst( pPam->GetPoint(), aCharBox.Pos() ); + } + } + return SwContentFrame::UnitUp( pPam, nOffset, bSetInReadOnly ); +} + +// Used for Bidi. nPos is the logical position in the string, bLeft indicates +// if left arrow or right arrow was pressed. The return values are: +// nPos: the new visual position +// bLeft: whether the break iterator has to add or subtract from the +// current position +static void lcl_VisualMoveRecursion(const SwLineLayout& rCurrLine, TextFrameIndex nIdx, + TextFrameIndex & nPos, bool& bRight, + sal_uInt8& nCursorLevel, sal_uInt8 nDefaultDir ) +{ + const SwLinePortion* pPor = rCurrLine.GetFirstPortion(); + const SwLinePortion* pLast = nullptr; + + // What's the current portion? + while ( pPor && nIdx + pPor->GetLen() <= nPos ) + { + nIdx = nIdx + pPor->GetLen(); + pLast = pPor; + pPor = pPor->GetNextPortion(); + } + + if ( bRight ) + { + bool bRecurse = pPor && pPor->IsMultiPortion() && + static_cast(pPor)->IsBidi(); + + // 1. special case: at beginning of bidi portion + if ( bRecurse && nIdx == nPos ) + { + nPos = nPos + pPor->GetLen(); + + // leave bidi portion + if ( nCursorLevel != nDefaultDir ) + { + bRecurse = false; + } + else + // special case: + // buffer: abcXYZ123 in LTR paragraph + // view: abc123ZYX + // cursor is between c and X in the buffer and cursor level = 0 + nCursorLevel++; + } + + // 2. special case: at beginning of portion after bidi portion + else if ( pLast && pLast->IsMultiPortion() && + static_cast(pLast)->IsBidi() && nIdx == nPos ) + { + // enter bidi portion + if ( nCursorLevel != nDefaultDir ) + { + bRecurse = true; + nIdx = nIdx - pLast->GetLen(); + pPor = pLast; + } + } + + // Recursion + if ( bRecurse ) + { + const SwLineLayout& rLine = static_cast(pPor)->GetRoot(); + TextFrameIndex nTmpPos = nPos - nIdx; + bool bTmpForward = ! bRight; + sal_uInt8 nTmpCursorLevel = nCursorLevel; + lcl_VisualMoveRecursion(rLine, TextFrameIndex(0), nTmpPos, bTmpForward, + nTmpCursorLevel, nDefaultDir + 1 ); + + nPos = nTmpPos + nIdx; + bRight = bTmpForward; + nCursorLevel = nTmpCursorLevel; + } + + // go forward + else + { + bRight = true; + nCursorLevel = nDefaultDir; + } + + } + else + { + bool bRecurse = pPor && pPor->IsMultiPortion() && static_cast(pPor)->IsBidi(); + + // 1. special case: at beginning of bidi portion + if ( bRecurse && nIdx == nPos ) + { + // leave bidi portion + if ( nCursorLevel == nDefaultDir ) + { + bRecurse = false; + } + } + + // 2. special case: at beginning of portion after bidi portion + else if ( pLast && pLast->IsMultiPortion() && + static_cast(pLast)->IsBidi() && nIdx == nPos ) + { + nPos = nPos - pLast->GetLen(); + + // enter bidi portion + if ( nCursorLevel % 2 == nDefaultDir % 2 ) + { + bRecurse = true; + nIdx = nIdx - pLast->GetLen(); + pPor = pLast; + + // special case: + // buffer: abcXYZ123 in LTR paragraph + // view: abc123ZYX + // cursor is behind 3 in the buffer and cursor level = 2 + if ( nDefaultDir + 2 == nCursorLevel ) + nPos = nPos + pLast->GetLen(); + } + } + + // go forward + if ( bRecurse ) + { + const SwLineLayout& rLine = static_cast(pPor)->GetRoot(); + TextFrameIndex nTmpPos = nPos - nIdx; + bool bTmpForward = ! bRight; + sal_uInt8 nTmpCursorLevel = nCursorLevel; + lcl_VisualMoveRecursion(rLine, TextFrameIndex(0), nTmpPos, bTmpForward, + nTmpCursorLevel, nDefaultDir + 1 ); + + // special case: + // buffer: abcXYZ123 in LTR paragraph + // view: abc123ZYX + // cursor is between Z and 1 in the buffer and cursor level = 2 + if ( nTmpPos == pPor->GetLen() && nTmpCursorLevel == nDefaultDir + 1 ) + { + nTmpPos = nTmpPos - pPor->GetLen(); + nTmpCursorLevel = nDefaultDir; + bTmpForward = ! bTmpForward; + } + + nPos = nTmpPos + nIdx; + bRight = bTmpForward; + nCursorLevel = nTmpCursorLevel; + } + + // go backward + else + { + bRight = false; + nCursorLevel = nDefaultDir; + } + } +} + +void SwTextFrame::PrepareVisualMove(TextFrameIndex & nPos, sal_uInt8& nCursorLevel, + bool& bForward, bool bInsertCursor ) +{ + if( IsEmpty() || IsHiddenNow() ) + return; + + GetFormatted(); + + SwTextSizeInfo aInf(this); + SwTextCursor aLine(this, &aInf); + + if( nPos ) + aLine.CharCursorToLine( nPos ); + else + aLine.Top(); + + const SwLineLayout* pLine = aLine.GetCurr(); + const TextFrameIndex nStt = aLine.GetStart(); + const TextFrameIndex nLen = pLine->GetLen(); + + // We have to distinguish between an insert and overwrite cursor: + // The insert cursor position depends on the cursor level: + // buffer: abcXYZdef in LTR paragraph + // display: abcZYXdef + // If cursor is between c and X in the buffer and cursor level is 0, + // the cursor blinks between c and Z and -> sets the cursor between Z and Y. + // If the cursor level is 1, the cursor blinks between X and d and + // -> sets the cursor between d and e. + // The overwrite cursor simply travels to the next visual character. + if ( bInsertCursor ) + { + lcl_VisualMoveRecursion( *pLine, nStt, nPos, bForward, + nCursorLevel, IsRightToLeft() ? 1 : 0 ); + return; + } + + const sal_uInt8 nDefaultDir = static_cast(IsRightToLeft() ? UBIDI_RTL : UBIDI_LTR); + const bool bVisualRight = ( nDefaultDir == UBIDI_LTR && bForward ) || + ( nDefaultDir == UBIDI_RTL && ! bForward ); + + // Bidi functions from icu 2.0 + + const sal_Unicode* pLineString = GetText().getStr(); + + UErrorCode nError = U_ZERO_ERROR; + UBiDi* pBidi = ubidi_openSized( sal_Int32(nLen), 0, &nError ); + ubidi_setPara( pBidi, reinterpret_cast(pLineString), + sal_Int32(nLen), nDefaultDir, nullptr, &nError ); + + TextFrameIndex nTmpPos(0); + bool bOutOfBounds = false; + + if ( nPos < nStt + nLen ) + { + nTmpPos = TextFrameIndex(ubidi_getVisualIndex( pBidi, sal_Int32(nPos), &nError )); + + // visual indices are always LTR aligned + if ( bVisualRight ) + { + if (nTmpPos + TextFrameIndex(1) < nStt + nLen) + ++nTmpPos; + else + { + nPos = nDefaultDir == UBIDI_RTL ? TextFrameIndex(0) : nStt + nLen; + bOutOfBounds = true; + } + } + else + { + if ( nTmpPos ) + --nTmpPos; + else + { + nPos = nDefaultDir == UBIDI_RTL ? nStt + nLen : TextFrameIndex(0); + bOutOfBounds = true; + } + } + } + else + { + nTmpPos = nDefaultDir == UBIDI_LTR ? nPos - TextFrameIndex(1) : TextFrameIndex(0); + } + + if ( ! bOutOfBounds ) + { + nPos = TextFrameIndex(ubidi_getLogicalIndex( pBidi, sal_Int32(nTmpPos), &nError )); + + if ( bForward ) + { + if ( nPos ) + --nPos; + else + { + ++nPos; + bForward = ! bForward; + } + } + else + ++nPos; + } + + ubidi_close( pBidi ); +} + +bool SwTextFrame::UnitDown_(SwPaM *pPam, const SwTwips nOffset, + bool bSetInReadOnly ) const +{ + + if ( IsInTab() && + pPam->GetPointNode().StartOfSectionNode() != + pPam->GetMarkNode().StartOfSectionNode() ) + { + // If the PaM is located within different boxes, we have a table selection, + // which is handled by the base class. + return SwContentFrame::UnitDown( pPam, nOffset, bSetInReadOnly ); + } + const_cast(this)->GetFormatted(); + const TextFrameIndex nPos = MapModelToViewPos(*pPam->GetPoint()); + SwRect aCharBox; + const SwContentFrame *pTmpFollow = nullptr; + + if ( IsVertical() ) + const_cast(this)->SwapWidthAndHeight(); + + if ( !IsEmpty() && !IsHiddenNow() ) + { + TextFrameIndex nFormat(COMPLETE_STRING); + do + { + if (nFormat != TextFrameIndex(COMPLETE_STRING) && !IsFollow() && + !sw_ChangeOffset( const_cast(this), nFormat ) ) + break; + + SwTextSizeInfo aInf( const_cast(this) ); + SwTextCursor aLine( const_cast(this), &aInf ); + nFormat = aLine.GetEnd(); + + aLine.CharCursorToLine( nPos ); + + const SwLineLayout* pNextLine = aLine.GetNextLine(); + const TextFrameIndex nStart = aLine.GetStart(); + aLine.GetCharRect( &aCharBox, nPos ); + + bool bFirstOfDouble = ( aInf.IsMulti() && aInf.IsFirstMulti() ); + + if( pNextLine || bFirstOfDouble ) + { + aCharBox.Width( aCharBox.SSize().Width() / 2 ); +#if OSL_DEBUG_LEVEL > 0 + // See comment in SwTextFrame::GetModelPositionForViewPoint() + const SwNodeOffset nOldNode = pPam->GetPoint()->GetNodeIndex(); +#endif + if ( pNextLine && ! bFirstOfDouble ) + aLine.NextLine(); + + TextFrameIndex nTmpOfst = aLine.GetModelPositionForViewPoint( pPam->GetPoint(), + aCharBox.Pos(), false ); +#if OSL_DEBUG_LEVEL > 0 + OSL_ENSURE( nOldNode == pPam->GetPoint()->GetNodeIndex(), + "SwTextFrame::UnitDown: illegal node change" ); +#endif + + // We make sure that we move down. + if( nTmpOfst <= nStart && ! bFirstOfDouble ) + nTmpOfst = nStart + TextFrameIndex(1); + *pPam->GetPoint() = MapViewToModelPos(nTmpOfst); + + if ( IsVertical() ) + const_cast(this)->SwapWidthAndHeight(); + + return true; + } + pTmpFollow = GetFollow(); + if( nullptr != pTmpFollow ) + { // Skip protected follows + const SwContentFrame* pTmp = pTmpFollow; + SwViewShell *pSh = getRootFrame()->GetCurrShell(); + if( !pSh || !pSh->GetViewOptions()->IsCursorInProtectedArea() ) + { + while( pTmpFollow && pTmpFollow->IsProtected() ) + { + pTmp = pTmpFollow; + pTmpFollow = pTmpFollow->GetFollow(); + } + } + if( !pTmpFollow ) // Only protected ones left + { + if ( IsVertical() ) + const_cast(this)->SwapWidthAndHeight(); + return pTmp->SwContentFrame::UnitDown( pPam, nOffset, bSetInReadOnly ); + } + + aLine.GetCharRect( &aCharBox, nPos ); + aCharBox.Width( aCharBox.SSize().Width() / 2 ); + } + else if( !IsFollow() ) + { + TextFrameIndex nTmpLen(aInf.GetText().getLength()); + if( aLine.GetEnd() < nTmpLen ) + { + if( nFormat <= GetOffset() ) + { + nFormat = std::min(GetOffset() + TextFrameIndex(MIN_OFFSET_STEP), + nTmpLen ); + if( nFormat <= GetOffset() ) + break; + } + continue; + } + } + break; + } while( true ); + } + else + pTmpFollow = GetFollow(); + + if ( IsVertical() ) + const_cast(this)->SwapWidthAndHeight(); + + // We take a shortcut for follows + if( pTmpFollow ) + { + aCharBox.Pos().setY( pTmpFollow->getFrameArea().Top() + 1 ); + return static_cast(pTmpFollow)->GetKeyCursorOfst( pPam->GetPoint(), + aCharBox.Pos() ); + } + return SwContentFrame::UnitDown( pPam, nOffset, bSetInReadOnly ); +} + +bool SwTextFrame::UnitUp(SwPaM *pPam, const SwTwips nOffset, + bool bSetInReadOnly ) const +{ + /* We call ContentNode::GertFrame() in CursorSh::Up(). + * This _always returns the master. + * In order to not mess with cursor travelling, we correct here + * in SwTextFrame. + * We calculate UnitUp for pFrame. pFrame is either a master (= this) or a + * follow (!= this). + */ + const SwTextFrame *pFrame = GetAdjFrameAtPos( const_cast(this), *(pPam->GetPoint()), + SwTextCursor::IsRightMargin() ); + const bool bRet = pFrame->UnitUp_( pPam, nOffset, bSetInReadOnly ); + + // No SwTextCursor::SetRightMargin( false ); + // Instead we have a SwSetToRightMargin in UnitUp_ + return bRet; +} + +bool SwTextFrame::UnitDown(SwPaM *pPam, const SwTwips nOffset, + bool bSetInReadOnly ) const +{ + const SwTextFrame *pFrame = GetAdjFrameAtPos(const_cast(this), *(pPam->GetPoint()), + SwTextCursor::IsRightMargin() ); + const bool bRet = pFrame->UnitDown_( pPam, nOffset, bSetInReadOnly ); + SwTextCursor::SetRightMargin( false ); + return bRet; +} + +void SwTextFrame::FillCursorPos( SwFillData& rFill ) const +{ + if( !rFill.bColumn && GetUpper()->IsColBodyFrame() ) // ColumnFrames now with BodyFrame + { + const SwColumnFrame* pTmp = + static_cast(GetUpper()->GetUpper()->GetUpper()->Lower()); // The 1st column + // The first SwFrame in BodyFrame of the first column + const SwFrame* pFrame = static_cast(pTmp->Lower())->Lower(); + sal_uInt16 nNextCol = 0; + // In which column do we end up in? + while( rFill.X() > pTmp->getFrameArea().Right() && pTmp->GetNext() ) + { + pTmp = static_cast(pTmp->GetNext()); + if( static_cast(pTmp->Lower())->Lower() ) // ColumnFrames now with BodyFrame + { + pFrame = static_cast(pTmp->Lower())->Lower(); + nNextCol = 0; + } + else + ++nNextCol; // Empty columns require column breaks + } + if( pTmp != GetUpper()->GetUpper() ) // Did we end up in another column? + { + if( !pFrame ) + return; + if( nNextCol ) + { + while( pFrame->GetNext() ) + pFrame = pFrame->GetNext(); + } + else + { + while( pFrame->GetNext() && pFrame->getFrameArea().Bottom() < rFill.Y() ) + pFrame = pFrame->GetNext(); + } + // No filling, if the last frame in the targeted column does + // not contain a paragraph, but e.g. a table + if( pFrame->IsTextFrame() ) + { + rFill.Fill().nColumnCnt = nNextCol; + rFill.bColumn = true; + if( rFill.pPos ) + { + SwTextFrame const*const pTextFrame(static_cast(pFrame)); + *rFill.pPos = pTextFrame->MapViewToModelPos( + TextFrameIndex(pTextFrame->GetText().getLength())); + } + if( nNextCol ) + { + rFill.aFrame = pTmp->getFramePrintArea(); + rFill.aFrame += pTmp->getFrameArea().Pos(); + } + else + rFill.aFrame = pFrame->getFrameArea(); + static_cast(pFrame)->FillCursorPos( rFill ); + } + return; + } + } + std::unique_ptr pFnt; + SwTextFormatColl* pColl = GetTextNodeForParaProps()->GetTextColl(); + SwTwips nFirst = GetTextNodeForParaProps()->GetSwAttrSet().GetULSpace().GetLower(); + SwTwips nDiff = rFill.Y() - getFrameArea().Bottom(); + if( nDiff < nFirst ) + nDiff = -1; + else + pColl = &pColl->GetNextTextFormatColl(); + SwAttrSet aSet(const_cast(GetDoc()).GetAttrPool(), aTextFormatCollSetRange ); + const SwAttrSet* pSet = &pColl->GetAttrSet(); + SwViewShell *pSh = getRootFrame()->GetCurrShell(); + if (GetTextNodeForParaProps()->HasSwAttrSet()) + { + // sw_redlinehide: pSet is mostly used for para props, but there are + // accesses to char props via pFnt - why does it use only the node's + // props for this, and not hints? + aSet.Put( *GetTextNodeForParaProps()->GetpSwAttrSet() ); + aSet.SetParent( pSet ); + pSet = &aSet; + pFnt.reset(new SwFont( pSet, &GetDoc().getIDocumentSettingAccess() )); + } + else + { + SwFontAccess aFontAccess( pColl, pSh ); + pFnt.reset(new SwFont( aFontAccess.Get()->GetFont() )); + pFnt->CheckFontCacheId( pSh, pFnt->GetActual() ); + } + OutputDevice* pOut = pSh->GetOut(); + if( !pSh->GetViewOptions()->getBrowseMode() || pSh->GetViewOptions()->IsPrtFormat() ) + pOut = GetDoc().getIDocumentDeviceAccess().getReferenceDevice( true ); + + pFnt->SetFntChg( true ); + pFnt->ChgPhysFnt( pSh, *pOut ); + + SwTwips nLineHeight = pFnt->GetHeight( pSh, *pOut ); + + bool bFill = false; + if( nLineHeight ) + { + bFill = true; + const SvxULSpaceItem &rUL = pSet->GetULSpace(); + SwTwips nDist = std::max( rUL.GetLower(), rUL.GetUpper() ); + if( rFill.Fill().nColumnCnt ) + { + rFill.aFrame.Height( nLineHeight ); + nDiff = rFill.Y() - rFill.Bottom(); + nFirst = 0; + } + else if( nDist < nFirst ) + nFirst = nFirst - nDist; + else + nFirst = 0; + nDist = std::max( nDist, SwTwips(GetLineSpace()) ); + nDist += nLineHeight; + nDiff -= nFirst; + + if( nDiff > 0 ) + { + nDiff /= nDist; + rFill.Fill().nParaCnt = o3tl::narrowing(nDiff + 1); + rFill.nLineWidth = 0; + rFill.bInner = false; + rFill.bEmpty = true; + rFill.SetOrient( text::HoriOrientation::LEFT ); + } + else + nDiff = -1; + if( rFill.bInner ) + bFill = false; + else + { + const SvxTabStopItem &rRuler = pSet->GetTabStops(); + const SvxFirstLineIndentItem& rFirstLine(pSet->GetFirstLineIndent()); + const SvxTextLeftMarginItem& rTextLeftMargin(pSet->GetTextLeftMargin()); + const SvxRightMarginItem& rRightMargin(pSet->GetRightMargin()); + + SwRect &rRect = rFill.Fill().aCursor; + rRect.Top( rFill.Bottom() + (nDiff+1) * nDist - nLineHeight ); + if( nFirst && nDiff > -1 ) + rRect.Top( rRect.Top() + nFirst ); + rRect.Height( nLineHeight ); + SwTwips nLeft = rFill.Left() + rTextLeftMargin.GetLeft(rFirstLine) + + GetTextNodeForParaProps()->GetLeftMarginWithNum(); + SwTwips nRight = rFill.Right() - rRightMargin.GetRight(); + SwTwips nCenter = ( nLeft + nRight ) / 2; + rRect.Left( nLeft ); + if( SwFillMode::Margin == rFill.Mode() ) + { + if( rFill.bEmpty ) + { + rFill.SetOrient( text::HoriOrientation::LEFT ); + if( rFill.X() < nCenter ) + { + if( rFill.X() > ( nLeft + 2 * nCenter ) / 3 ) + { + rFill.SetOrient( text::HoriOrientation::CENTER ); + rRect.Left( nCenter ); + } + } + else if( rFill.X() > ( nRight + 2 * nCenter ) / 3 ) + { + rFill.SetOrient( text::HoriOrientation::RIGHT ); + rRect.Left( nRight ); + } + else + { + rFill.SetOrient( text::HoriOrientation::CENTER ); + rRect.Left( nCenter ); + } + } + else + bFill = false; + } + else + { + SwTwips nSpace = 0; + if( SwFillMode::Tab != rFill.Mode() ) + { + SwDrawTextInfo aDrawInf( pSh, *pOut, " ", 0, 2 ); + nSpace = pFnt->GetTextSize_( aDrawInf ).Width()/2; + } + if( rFill.X() >= nRight ) + { + if( SwFillMode::Indent != rFill.Mode() && ( rFill.bEmpty || + rFill.X() > rFill.nLineWidth + FILL_MIN_DIST ) ) + { + rFill.SetOrient( text::HoriOrientation::RIGHT ); + rRect.Left( nRight ); + } + else + bFill = false; + } + else if( SwFillMode::Indent == rFill.Mode() ) + { + SwTwips nIndent = rFill.X(); + if( !rFill.bEmpty || nIndent > nRight ) + bFill = false; + else + { + nIndent -= rFill.Left(); + if( nIndent >= 0 && nSpace ) + { + nIndent /= nSpace; + nIndent *= nSpace; + rFill.SetTab( sal_uInt16( nIndent ) ); + rRect.Left( nIndent + rFill.Left() ); + } + else + bFill = false; + } + } + else if( rFill.X() > nLeft ) + { + SwTwips nTextLeft = rFill.Left() + rTextLeftMargin.GetTextLeft() + + GetTextNodeForParaProps()->GetLeftMarginWithNum(true); + rFill.nLineWidth += rFill.bFirstLine ? nLeft : nTextLeft; + SwTwips nLeftTab; + SwTwips nRightTab = nLeft; + sal_uInt16 nSpaceCnt = 0; + sal_uInt16 nSpaceOnlyCnt = 0; + sal_uInt16 nTabCnt = 0; + sal_uInt16 nIdx = 0; + do + { + nLeftTab = nRightTab; + if( nIdx < rRuler.Count() ) + { + const SvxTabStop &rTabStop = rRuler.operator[](nIdx); + nRightTab = nTextLeft + rTabStop.GetTabPos(); + if( nLeftTab < nTextLeft && nRightTab > nTextLeft ) + nRightTab = nTextLeft; + else + ++nIdx; + if( nRightTab > rFill.nLineWidth ) + ++nTabCnt; + } + else + { + const SvxTabStopItem& rTab = + pSet->GetPool()->GetDefaultItem( RES_PARATR_TABSTOP ); + const SwTwips nDefTabDist = rTab[0].GetTabPos(); + nRightTab = nLeftTab - nTextLeft; + nRightTab /= nDefTabDist; + nRightTab = nRightTab * nDefTabDist + nTextLeft; + while ( nRightTab <= nLeftTab ) + nRightTab += nDefTabDist; + if( nRightTab > rFill.nLineWidth ) + ++nTabCnt; + while ( nRightTab < rFill.X() ) + { + nRightTab += nDefTabDist; + if( nRightTab > rFill.nLineWidth ) + ++nTabCnt; + } + if( nLeftTab < nRightTab - nDefTabDist ) + nLeftTab = nRightTab - nDefTabDist; + } + if( nRightTab > nRight ) + nRightTab = nRight; + } + while( rFill.X() > nRightTab ); + --nTabCnt; + if( SwFillMode::TabSpace == rFill.Mode() ) + { + if( nSpace > 0 ) + { + if( !nTabCnt ) + nLeftTab = rFill.nLineWidth; + while( nLeftTab < rFill.X() ) + { + nLeftTab += nSpace; + ++nSpaceCnt; + } + if( nSpaceCnt ) + { + nLeftTab -= nSpace; + --nSpaceCnt; + } + if( rFill.X() - nLeftTab > nRightTab - rFill.X() ) + { + nSpaceCnt = 0; + ++nTabCnt; + rRect.Left( nRightTab ); + } + else + { + if( rFill.X() - nLeftTab > nSpace/2 ) + { + ++nSpaceCnt; + rRect.Left( nLeftTab + nSpace ); + } + else + rRect.Left( nLeftTab ); + } + } + else if( rFill.X() - nLeftTab < nRightTab - rFill.X() ) + rRect.Left( nLeftTab ); + else + { + if( nRightTab >= nRight ) + { + rFill.SetOrient( text::HoriOrientation::RIGHT ); + rRect.Left( nRight ); + nTabCnt = 0; + nSpaceCnt = 0; + } + else + { + rRect.Left( nRightTab ); + ++nTabCnt; + } + } + } + else if( SwFillMode::Space == rFill.Mode() ) + { + SwTwips nLeftSpace = nLeft; + while( nLeftSpace < rFill.X() ) + { + nLeftSpace += nSpace; + ++nSpaceOnlyCnt; + } + rRect.Left( nLeftSpace ); + } + else + { + if( rFill.X() - nLeftTab < nRightTab - rFill.X() ) + rRect.Left( nLeftTab ); + else + { + if( nRightTab >= nRight ) + { + rFill.SetOrient( text::HoriOrientation::RIGHT ); + rRect.Left( nRight ); + nTabCnt = 0; + nSpaceCnt = 0; + } + else + { + rRect.Left( nRightTab ); + ++nTabCnt; + } + } + } + rFill.SetTab( nTabCnt ); + rFill.SetSpace( nSpaceCnt ); + rFill.SetSpaceOnly( nSpaceOnlyCnt ); + if( bFill ) + { + if( std::abs( rFill.X() - nCenter ) <= + std::abs( rFill.X() - rRect.Left() ) ) + { + rFill.SetOrient( text::HoriOrientation::CENTER ); + rFill.SetTab( 0 ); + rFill.SetSpace( 0 ); + rFill.SetSpaceOnly( 0 ); + rRect.Left( nCenter ); + } + if( !rFill.bEmpty ) + rFill.nLineWidth += FILL_MIN_DIST; + if( rRect.Left() < rFill.nLineWidth ) + bFill = false; + } + } + } + // Do we extend over the page's/column's/etc. lower edge? + const SwFrame* pUp = GetUpper(); + if( pUp->IsInSct() ) + { + if( pUp->IsSctFrame() ) + pUp = pUp->GetUpper(); + else if( pUp->IsColBodyFrame() && + pUp->GetUpper()->GetUpper()->IsSctFrame() ) + pUp = pUp->GetUpper()->GetUpper()->GetUpper(); + } + SwRectFnSet aRectFnSet(this); + SwTwips nLimit = aRectFnSet.GetPrtBottom(*pUp); + SwTwips nRectBottom = rRect.Bottom(); + if ( aRectFnSet.IsVert() ) + nRectBottom = SwitchHorizontalToVertical( nRectBottom ); + + if( aRectFnSet.YDiff( nLimit, nRectBottom ) < 0 ) + bFill = false; + else + rRect.Width( 1 ); + } + } + const_cast(rFill.pCMS)->m_bFillRet = bFill; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/frmform.cxx b/sw/source/core/text/frmform.cxx new file mode 100644 index 0000000000..76a1df5621 --- /dev/null +++ b/sw/source/core/text/frmform.cxx @@ -0,0 +1,2299 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "itrform2.hxx" +#include "widorp.hxx" +#include "txtcache.hxx" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// Tolerance in formatting and text output +#define SLOPPY_TWIPS 5 + +namespace { + +class FormatLevel +{ + static sal_uInt16 s_nLevel; +public: + FormatLevel() { ++s_nLevel; } + ~FormatLevel() { --s_nLevel; } + static sal_uInt16 GetLevel() { return s_nLevel; } + static bool LastLevel() { return 10 < s_nLevel; } +}; + +} + +sal_uInt16 FormatLevel::s_nLevel = 0; + +void ValidateText( SwFrame *pFrame ) // Friend of frame +{ + if ( ( ! pFrame->IsVertical() && + pFrame->getFrameArea().Width() == pFrame->GetUpper()->getFramePrintArea().Width() ) || + ( pFrame->IsVertical() && + pFrame->getFrameArea().Height() == pFrame->GetUpper()->getFramePrintArea().Height() ) ) + { + pFrame->setFrameAreaSizeValid(true); + } +} + +void SwTextFrame::ValidateFrame() +{ + vcl::RenderContext* pRenderContext = getRootFrame()->GetCurrShell()->GetOut(); + // Validate surroundings to avoid oscillation + SwSwapIfSwapped swap( this ); + + if ( !IsInFly() && !IsInTab() ) + { // Only validate 'this' when inside a fly, the rest should actually only be + // needed for footnotes, which do not exist in flys. + SwSectionFrame* pSct = FindSctFrame(); + if( pSct ) + { + if( !pSct->IsColLocked() ) + pSct->ColLock(); + else + pSct = nullptr; + } + + SwFrame *pUp = GetUpper(); + pUp->Calc(pRenderContext); + if( pSct ) + pSct->ColUnlock(); + } + ValidateText( this ); + + // We at least have to save the MustFit flag! + assert(HasPara() && "ResetPreps(), missing ParaPortion, SwCache bug?"); + SwParaPortion *pPara = GetPara(); + const bool bMustFit = pPara->IsPrepMustFit(); + ResetPreps(); + pPara->SetPrepMustFit( bMustFit ); +} + +// After a RemoveFootnote the BodyFrame and all Frames contained within it, need to be +// recalculated, so that the DeadLine is right. +// First we search outwards, on the way back we calculate everything. +static void ValidateBodyFrame_( SwFrame *pFrame ) +{ + vcl::RenderContext* pRenderContext = pFrame ? pFrame->getRootFrame()->GetCurrShell()->GetOut() : nullptr; + if( !pFrame || pFrame->IsCellFrame() ) + return; + + if( !pFrame->IsBodyFrame() && pFrame->GetUpper() ) + ValidateBodyFrame_( pFrame->GetUpper() ); + if( !pFrame->IsSctFrame() ) + pFrame->Calc(pRenderContext); + else + { + const bool bOld = static_cast(pFrame)->IsContentLocked(); + static_cast(pFrame)->SetContentLock( true ); + pFrame->Calc(pRenderContext); + if( !bOld ) + static_cast(pFrame)->SetContentLock( false ); + } +} + +void SwTextFrame::ValidateBodyFrame() +{ + SwSwapIfSwapped swap( this ); + + // See comment in ValidateFrame() + if ( !IsInFly() && !IsInTab() && + !( IsInSct() && FindSctFrame()->Lower()->IsColumnFrame() ) ) + ValidateBodyFrame_( GetUpper() ); +} + +bool SwTextFrame::GetDropRect_( SwRect &rRect ) const +{ + SwSwapIfNotSwapped swap(const_cast(this)); + + OSL_ENSURE( HasPara(), "SwTextFrame::GetDropRect_: try again next year." ); + SwTextSizeInfo aInf( const_cast(this) ); + SwTextMargin aLine( const_cast(this), &aInf ); + if( aLine.GetDropLines() ) + { + rRect.Top( aLine.Y() ); + rRect.Left( aLine.GetLineStart() ); + rRect.Height( aLine.GetDropHeight() ); + rRect.Width( aLine.GetDropLeft() ); + + if ( IsRightToLeft() ) + SwitchLTRtoRTL( rRect ); + + if ( IsVertical() ) + SwitchHorizontalToVertical( rRect ); + return true; + } + + return false; +} + +bool SwTextFrame::CalcFollow(TextFrameIndex const nTextOfst) +{ + vcl::RenderContext* pRenderContext = getRootFrame()->GetCurrShell()->GetOut(); + SwSwapIfSwapped swap( this ); + + OSL_ENSURE( HasFollow(), "CalcFollow: missing Follow." ); + + SwTextFrame* pMyFollow = GetFollow(); + + SwParaPortion *pPara = GetPara(); + const bool bFollowField = pPara && pPara->IsFollowField(); + + if( !pMyFollow->GetOffset() || pMyFollow->GetOffset() != nTextOfst || + bFollowField || pMyFollow->IsFieldFollow() || + ( pMyFollow->IsVertical() && !pMyFollow->getFramePrintArea().Width() ) || + ( ! pMyFollow->IsVertical() && !pMyFollow->getFramePrintArea().Height() ) ) + { +#if OSL_DEBUG_LEVEL > 0 + const SwFrame *pOldUp = GetUpper(); +#endif + + SwRectFnSet aRectFnSet(this); + SwTwips nOldBottom = aRectFnSet.GetBottom(GetUpper()->getFrameArea()); + SwTwips nMyPos = aRectFnSet.GetTop(getFrameArea()); + + const SwPageFrame *pPage = nullptr; + bool bOldInvaContent = true; + if ( !IsInFly() && GetNext() ) + { + pPage = FindPageFrame(); + // Minimize (reset if possible) invalidations: see below + bOldInvaContent = pPage->IsInvalidContent(); + } + + pMyFollow->SetOffset_( nTextOfst ); + pMyFollow->SetFieldFollow( bFollowField ); + if( HasFootnote() || pMyFollow->HasFootnote() ) + { + ValidateFrame(); + ValidateBodyFrame(); + if( pPara ) + { + pPara->GetReformat() = SwCharRange(); + pPara->SetDelta(0); + } + } + + // The footnote area must not get larger + SwSaveFootnoteHeight aSave( FindFootnoteBossFrame( true ), LONG_MAX ); + + pMyFollow->CalcFootnoteFlag(); + if ( !pMyFollow->GetNext() && !pMyFollow->HasFootnote() ) + nOldBottom = aRectFnSet.IsVert() ? 0 : LONG_MAX; + + // tdf#122892 check flag: + // 1. WidowsAndOrphans::FindWidows() determines follow is a widow + // 2. SwTextFrame::PrepWidows() calls SetPrepWidows() on master; + // if it can spare lines, master truncates one line + // 3. SwTextFrame::CalcPreps() on master (below); + // unless IsPrepMustFit(), if master hasn't shrunk via 2., it will SetWidow() + // 4. loop must exit then, because the follow didn't grow so nothing will ever change + while (!IsWidow()) + { + if( !FormatLevel::LastLevel() ) + { + // If the follow is contained within a column section or column + // frame, we need to calculate that first. This is because the + // FormatWidthCols() does not work if it is called from MakeAll + // of the _locked_ follow. + SwSectionFrame* pSct = pMyFollow->FindSctFrame(); + if( pSct && !pSct->IsAnLower( this ) ) + { + if( pSct->GetFollow() ) + pSct->SimpleFormat(); + else if( ( pSct->IsVertical() && !pSct->getFrameArea().Width() ) || + ( ! pSct->IsVertical() && !pSct->getFrameArea().Height() ) ) + break; + } + // i#11760 - Intrinsic format of follow is controlled. + if ( FollowFormatAllowed() ) + { + // i#11760 - No nested format of follows, if + // text frame is contained in a column frame. + // Thus, forbid intrinsic format of follow. + { + bool bIsFollowInColumn = false; + SwFrame* pFollowUpper = pMyFollow->GetUpper(); + while ( pFollowUpper ) + { + if ( pFollowUpper->IsColumnFrame() ) + { + bIsFollowInColumn = true; + break; + } + if ( pFollowUpper->IsPageFrame() || + pFollowUpper->IsFlyFrame() ) + { + break; + } + pFollowUpper = pFollowUpper->GetUpper(); + } + if ( bIsFollowInColumn ) + { + pMyFollow->ForbidFollowFormat(); + } + } + + pMyFollow->Calc(pRenderContext); + // The Follow can tell from its getFrameArea().Height() that something went wrong + OSL_ENSURE( !pMyFollow->GetPrev(), "SwTextFrame::CalcFollow: cheesy follow" ); + if( pMyFollow->GetPrev() ) + { + pMyFollow->Prepare(); + pMyFollow->Calc(pRenderContext); + OSL_ENSURE( !pMyFollow->GetPrev(), "SwTextFrame::CalcFollow: very cheesy follow" ); + } + + // i#11760 - Reset control flag for follow format. + pMyFollow->AllowFollowFormat(); + } + + // Make sure that the Follow gets painted + pMyFollow->SetCompletePaint(); + } + + pPara = GetPara(); + // As long as the Follow requests lines due to Orphans, it is + // passed these and is formatted again if possible + if( pPara && pPara->IsPrepWidows() ) + CalcPreps(); + else + break; + } + + if( HasFootnote() || pMyFollow->HasFootnote() ) + { + ValidateBodyFrame(); + ValidateFrame(); + if( pPara ) + { + pPara->GetReformat() = SwCharRange(); + pPara->SetDelta(0); + } + } + + if ( pPage && !bOldInvaContent ) + pPage->ValidateContent(); + +#if OSL_DEBUG_LEVEL > 0 + OSL_ENSURE( pOldUp == GetUpper(), "SwTextFrame::CalcFollow: heavy follow" ); +#endif + + const tools::Long nRemaining = + - aRectFnSet.BottomDist( GetUpper()->getFrameArea(), nOldBottom ); + if ( nRemaining > 0 && + nRemaining != ( aRectFnSet.IsVert() ? + nMyPos - getFrameArea().Right() : + getFrameArea().Top() - nMyPos ) ) + { + return true; + } + } + + return false; +} + +void SwTextFrame::MakePos() +{ + Point aOldPos = getFrameArea().Pos(); + SwFrame::MakePos(); + + // Recalc split flys if our position changed. + if (aOldPos != getFrameArea().Pos()) + { + // Find the master frame. + const SwTextFrame* pMaster = this; + while (pMaster->IsFollow()) + { + pMaster = pMaster->FindMaster(); + } + // Find which flys are effectively anchored to this frame. + for (const auto& pFly : pMaster->GetSplitFlyDrawObjs()) + { + SwTextFrame* pFlyAnchor = pFly->FindAnchorCharFrame(); + if (pFlyAnchor != this) + { + continue; + } + // Possibly this fly was positioned relative to us, invalidate its position now that our + // position is changed. + SwPageFrame* pPageFrame = pFly->FindPageFrame(); + bool bFlyNeedsPositioning = false; + bool bFlyPageMismatch = false; + if (pPageFrame) + { + // Was the position just adjusted to be inside the page frame? + bFlyNeedsPositioning = pFly->getFrameArea().Pos() == pPageFrame->getFrameArea().Pos(); + // Is the fly on a page different than the anchor frame? + bFlyPageMismatch = pPageFrame != FindPageFrame(); + } + if (bFlyNeedsPositioning || bFlyPageMismatch) + { + // Not really positioned, unlock the position once to allow a recalc. + pFly->UnlockPosition(); + } + pFly->InvalidatePos(); + } + } + + // Inform LOK clients about change in position of redlines (if any) + if(!comphelper::LibreOfficeKit::isActive()) + return; + + SwTextNode const* pTextNode = GetTextNodeFirst(); + const SwRedlineTable& rTable = pTextNode->getIDocumentRedlineAccess().GetRedlineTable(); + for (SwRedlineTable::size_type nRedlnPos = 0; nRedlnPos < rTable.size(); ++nRedlnPos) + { + SwRangeRedline* pRedln = rTable[nRedlnPos]; + if (pTextNode->GetIndex() == pRedln->GetPoint()->GetNode().GetIndex()) + { + pRedln->MaybeNotifyRedlinePositionModification(getFrameArea().Top()); + if (GetMergedPara() + && pRedln->GetType() == RedlineType::Delete + && pRedln->GetPoint()->GetNode() != pRedln->GetMark()->GetNode()) + { + pTextNode = pRedln->End()->GetNode().GetTextNode(); + } + } + } +} + +void SwTextFrame::AdjustFrame( const SwTwips nChgHght, bool bHasToFit ) +{ + vcl::RenderContext* pRenderContext = getRootFrame()->GetCurrShell()->GetOut(); + if( IsUndersized() ) + { + if( GetOffset() && !IsFollow() ) // A scrolled paragraph (undersized) + return; + SetUndersized( nChgHght == 0 || bHasToFit ); + } + + // AdjustFrame is called with a swapped frame during + // formatting but the frame is not swapped during FormatEmpty + SwSwapIfSwapped swap( this ); + SwRectFnSet aRectFnSet(this); + + // The Frame's size variable is incremented by Grow or decremented by Shrink. + // If the size cannot change, nothing should happen! + if( nChgHght >= 0) + { + SwTwips nChgHeight = nChgHght; + if( nChgHght && !bHasToFit ) + { + if( IsInFootnote() && !IsInSct() ) + { + SwTwips nReal = Grow( nChgHght, true ); + if( nReal < nChgHght ) + { + SwTwips nBot = aRectFnSet.YInc( aRectFnSet.GetBottom(getFrameArea()), + nChgHght - nReal ); + SwFrame* pCont = FindFootnoteFrame()->GetUpper(); + + if( aRectFnSet.BottomDist( pCont->getFrameArea(), nBot ) > 0 ) + { + SwFrameAreaDefinition::FrameAreaWriteAccess aFrm(*this); + aRectFnSet.AddBottom( aFrm, nChgHght ); + + SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*this); + + if( aRectFnSet.IsVert() ) + { + aPrt.AddWidth(nChgHght ); + } + else + { + aPrt.AddHeight(nChgHght ); + } + + return; + } + } + } + + Grow( nChgHght ); + + if ( IsInFly() ) + { + // If one of the Upper is a Fly, it's very likely that this fly changes its + // position by the Grow. Therefore, my position has to be corrected also or + // the check further down is not meaningful. + // The predecessors need to be calculated, so that the position can be + // calculated correctly. + if ( GetPrev() ) + { + SwFrame *pPre = GetUpper()->Lower(); + do + { pPre->Calc(pRenderContext); + pPre = pPre->GetNext(); + } while ( pPre && pPre != this ); + } + const Point aOldPos( getFrameArea().Pos() ); + MakePos(); + if ( aOldPos != getFrameArea().Pos() ) + { + InvalidateObjs(false); + } + } + nChgHeight = 0; + } + // A Grow() is always accepted by the Layout, even if the + // FixSize of the surrounding layout frame should not allow it. + // We text for this case and correct the values. + // The Frame must NOT be shrunk further than its size permits + // even in the case of an emergency. + SwTwips nRstHeight; + if ( IsVertical() ) + { + OSL_ENSURE( ! IsSwapped(),"Swapped frame while calculating nRstHeight" ); + + if ( IsVertLR() ) + nRstHeight = GetUpper()->getFrameArea().Left() + + GetUpper()->getFramePrintArea().Left() + + GetUpper()->getFramePrintArea().Width() + - getFrameArea().Left(); + else + nRstHeight = getFrameArea().Left() + getFrameArea().Width() - + ( GetUpper()->getFrameArea().Left() + GetUpper()->getFramePrintArea().Left() ); + } + else + nRstHeight = GetUpper()->getFrameArea().Top() + + GetUpper()->getFramePrintArea().Top() + + GetUpper()->getFramePrintArea().Height() + - getFrameArea().Top(); + + // We can get a bit of space in table cells, because there could be some + // left through a vertical alignment to the top. + // Assure that first lower in upper is the current one or is valid. + if ( IsInTab() && + ( GetUpper()->Lower() == this || + GetUpper()->Lower()->isFrameAreaDefinitionValid() ) ) + { + tools::Long nAdd = aRectFnSet.YDiff( aRectFnSet.GetTop(GetUpper()->Lower()->getFrameArea()), + aRectFnSet.GetPrtTop(*GetUpper()) ); + OSL_ENSURE( nAdd >= 0, "Ey" ); + nRstHeight += nAdd; + } + + // nRstHeight < 0 means that the TextFrame is located completely outside of its Upper. + // This can happen, if it's located within a FlyAtContentFrame, which changed sides by a + // Grow(). In such a case, it's wrong to execute the following Grow(). + // In the case of a bug, we end up with an infinite loop. + SwTwips nFrameHeight = aRectFnSet.GetHeight(getFrameArea()); + SwTwips nPrtHeight = aRectFnSet.GetHeight(getFramePrintArea()); + + if( nRstHeight < nFrameHeight ) + { + // It can be that I have the right size, but the Upper is too small and can get me some room + if( ( nRstHeight >= 0 || ( IsInFootnote() && IsInSct() ) ) && !bHasToFit ) + nRstHeight += GetUpper()->Grow( nFrameHeight - nRstHeight ); + // In column sections we do not want to get too big or else more areas are created by + // GetNextSctLeaf. Instead, we shrink and remember bUndersized, so that FormatWidthCols + // can calculate the right column size. + if ( nRstHeight < nFrameHeight ) + { + if( bHasToFit || !IsMoveable() || + ( IsInSct() && !FindSctFrame()->MoveAllowed(this) ) ) + { + SetUndersized( true ); + Shrink( std::min( ( nFrameHeight - nRstHeight), nPrtHeight ) ); + } + else + SetUndersized( false ); + } + } + else if( nChgHeight ) + { + if( nRstHeight - nFrameHeight < nChgHeight ) + nChgHeight = nRstHeight - nFrameHeight; + if( nChgHeight ) + Grow( nChgHeight ); + } + } + else + Shrink( -nChgHght ); +} + +css::uno::Sequence< css::style::TabStop > SwTextFrame::GetTabStopInfo( SwTwips CurrentPos ) +{ + SwTextFormatInfo aInf( getRootFrame()->GetCurrShell()->GetOut(), this ); + SwTextFormatter aLine( this, &aInf ); + SwTextCursor TextCursor( this, &aInf ); + const Point aCharPos( TextCursor.GetTopLeft() ); + + SwTwips nRight = aLine.Right(); + CurrentPos -= aCharPos.X(); + + // get current tab stop information stored in the Frame + const SvxTabStop *pTS = aLine.GetLineInfo().GetTabStop( CurrentPos, nRight ); + + if( !pTS ) + { + return {}; + } + + // copy tab stop information into a Sequence, which only contains one element. + css::style::TabStop ts; + ts.Position = pTS->GetTabPos(); + ts.DecimalChar = pTS->GetDecimal(); + ts.FillChar = pTS->GetFill(); + switch( pTS->GetAdjustment() ) + { + case SvxTabAdjust::Left : ts.Alignment = css::style::TabAlign_LEFT; break; + case SvxTabAdjust::Center : ts.Alignment = css::style::TabAlign_CENTER; break; + case SvxTabAdjust::Right : ts.Alignment = css::style::TabAlign_RIGHT; break; + case SvxTabAdjust::Decimal: ts.Alignment = css::style::TabAlign_DECIMAL; break; + case SvxTabAdjust::Default: ts.Alignment = css::style::TabAlign_DEFAULT; break; + default: break; // prevent warning + } + + return { ts }; +} + +// AdjustFollow expects the following situation: +// The SwTextIter points to the lower end of the Master, the Offset is set in the Follow. +// nOffset holds the Offset in the text string, from which the Master closes +// and the Follow starts. +// If it's 0, the FollowFrame is deleted. +void SwTextFrame::AdjustFollow_( SwTextFormatter &rLine, + const TextFrameIndex nOffset, const TextFrameIndex nEnd, + const sal_uInt8 nMode ) +{ + SwFrameSwapper aSwapper( this, false ); + + // We got the rest of the text mass: Delete all Follows + // DummyPortions() are a special case. + // Special cases are controlled by parameter . + bool bDontJoin = nMode & 1; + if( HasFollow() && !bDontJoin && nOffset == nEnd ) + { + while( GetFollow() ) + { + if( GetFollow()->IsLocked() ) + { + // this can happen when follow calls pMaster->GetFormatted() + SAL_INFO("sw.core", "+SwTextFrame::JoinFrame: Follow is locked." ); + return; + } + if (GetFollow()->IsDeleteForbidden()) + return; + + if (HasNonLastSplitFlyDrawObj()) + { + // If a fly frame is anchored to us that has a follow, then don't join the anchor. + // First those fly frames have to be joined. + return; + } + + JoinFrame(); + } + + return; + } + + // Dancing on the volcano: We'll just format the last line quickly + // for the QuoVadis stuff. + // The Offset can move of course: + const TextFrameIndex nNewOfst = (IsInFootnote() && (!GetIndNext() || HasFollow())) + ? rLine.FormatQuoVadis(nOffset) : nOffset; + + bool bHasNonLastSplitFlyDrawObj = false; + if (GetFollow() && GetOffset() == GetFollow()->GetOffset()) + { + bHasNonLastSplitFlyDrawObj = HasNonLastSplitFlyDrawObj(); + } + + if( !bDontJoin ) + { + // We steal text mass from our Follows + // It can happen that we have to join some of them + while( GetFollow() && GetFollow()->GetFollow() && + nNewOfst >= GetFollow()->GetFollow()->GetOffset() ) + { + if (bHasNonLastSplitFlyDrawObj) + { + // A non-last split fly is anchored to us, don't move content from the last frame to + // this one and don't join. + return; + } + + JoinFrame(); + } + } + + if (IsEmptyMasterWithSplitFly()) + { + // A split fly is anchored to us, don't move content from the follow frame to this one. + return; + } + + // The Offset moved + if( GetFollow() ) + { + if (!bDontJoin && bHasNonLastSplitFlyDrawObj) + { + // A non-last split fly is anchored to us, our follow is the last one in the text frame + // chain. No move of text from that follow to this text frame. + return; + } + + if ( nMode ) + GetFollow()->ManipOfst(TextFrameIndex(0)); + + if ( CalcFollow( nNewOfst ) ) // CalcFollow only at the end, we do a SetOffset there + rLine.SetOnceMore( true ); + } +} + +SwContentFrame *SwTextFrame::JoinFrame() +{ + OSL_ENSURE( GetFollow(), "+SwTextFrame::JoinFrame: no follow" ); + SwTextFrame *pFoll = GetFollow(); + + SwTextFrame *pNxt = pFoll->GetFollow(); + + // All footnotes of the to-be-destroyed Follow are relocated to us + TextFrameIndex nStart = pFoll->GetOffset(); + if ( pFoll->HasFootnote() ) + { + SwFootnoteBossFrame *pFootnoteBoss = nullptr; + SwFootnoteBossFrame *pEndBoss = nullptr; + SwTextNode const* pNode(nullptr); + sw::MergedAttrIter iter(*pFoll); + for (SwTextAttr const* pHt = iter.NextAttr(&pNode); pHt; pHt = iter.NextAttr(&pNode)) + { + if (RES_TXTATR_FTN == pHt->Which() + && nStart <= pFoll->MapModelToView(pNode, pHt->GetStart())) + { + if (pHt->GetFootnote().IsEndNote()) + { + if (!pEndBoss) + pEndBoss = pFoll->FindFootnoteBossFrame(); + SwFootnoteBossFrame::ChangeFootnoteRef( pFoll, static_cast(pHt), this ); + } + else + { + if (!pFootnoteBoss) + pFootnoteBoss = pFoll->FindFootnoteBossFrame( true ); + SwFootnoteBossFrame::ChangeFootnoteRef( pFoll, static_cast(pHt), this ); + } + SetFootnote( true ); + } + } + } + +#ifdef DBG_UTIL + else if ( pFoll->isFramePrintAreaValid() || + pFoll->isFrameAreaSizeValid() ) + { + pFoll->CalcFootnoteFlag(); + OSL_ENSURE( !pFoll->HasFootnote(), "Missing FootnoteFlag." ); + } +#endif + + pFoll->MoveFlyInCnt( this, nStart, TextFrameIndex(COMPLETE_STRING) ); + pFoll->SetFootnote( false ); + // i#27138 + // Notify accessibility paragraphs objects about changed CONTENT_FLOWS_FROM/_TO relation. + // Relation CONTENT_FLOWS_FROM for current next paragraph will change + // and relation CONTENT_FLOWS_TO for current previous paragraph, which + // is , will change. +#if !ENABLE_WASM_STRIP_ACCESSIBILITY + { + SwViewShell* pViewShell( pFoll->getRootFrame()->GetCurrShell() ); + if ( pViewShell && pViewShell->GetLayout() && + pViewShell->GetLayout()->IsAnyShellAccessible() ) + { + auto pNext = pFoll->FindNextCnt( true ); + pViewShell->InvalidateAccessibleParaFlowRelation( + pNext ? pNext->DynCastTextFrame() : nullptr, + this ); + } + } +#endif + + pFoll->Cut(); + SetFollow(pNxt); + SwFrame::DestroyFrame(pFoll); + return pNxt; +} + +void SwTextFrame::SplitFrame(TextFrameIndex const nTextPos) +{ + SwSwapIfSwapped swap( this ); + + // The Paste sends a Modify() to me + // I lock myself, so that my data does not disappear + TextFrameLockGuard aLock( this ); + SwTextFrame *const pNew = static_cast(GetTextNodeFirst()->MakeFrame(this)); + + pNew->SetFollow( GetFollow() ); + SetFollow( pNew ); + + pNew->Paste( GetUpper(), GetNext() ); + // i#27138 + // notify accessibility paragraphs objects about changed CONTENT_FLOWS_FROM/_TO relation. + // Relation CONTENT_FLOWS_FROM for current next paragraph will change + // and relation CONTENT_FLOWS_TO for current previous paragraph, which + // is , will change. +#if !ENABLE_WASM_STRIP_ACCESSIBILITY + { + SwViewShell* pViewShell( pNew->getRootFrame()->GetCurrShell() ); + if ( pViewShell && pViewShell->GetLayout() && + pViewShell->GetLayout()->IsAnyShellAccessible() ) + { + auto pNext = pNew->FindNextCnt( true ); + pViewShell->InvalidateAccessibleParaFlowRelation( + pNext ? pNext->DynCastTextFrame() : nullptr, + this ); + } + } +#endif + + // If footnotes end up in pNew bz our actions, we need + // to re-register them + if ( HasFootnote() ) + { + SwFootnoteBossFrame *pFootnoteBoss = nullptr; + SwFootnoteBossFrame *pEndBoss = nullptr; + SwTextNode const* pNode(nullptr); + sw::MergedAttrIter iter(*this); + for (SwTextAttr const* pHt = iter.NextAttr(&pNode); pHt; pHt = iter.NextAttr(&pNode)) + { + if (RES_TXTATR_FTN == pHt->Which() + && nTextPos <= MapModelToView(pNode, pHt->GetStart())) + { + if (pHt->GetFootnote().IsEndNote()) + { + if (!pEndBoss) + pEndBoss = FindFootnoteBossFrame(); + SwFootnoteBossFrame::ChangeFootnoteRef( this, static_cast(pHt), pNew ); + } + else + { + if (!pFootnoteBoss) + pFootnoteBoss = FindFootnoteBossFrame( true ); + SwFootnoteBossFrame::ChangeFootnoteRef( this, static_cast(pHt), pNew ); + } + pNew->SetFootnote( true ); + } + } + } + +#ifdef DBG_UTIL + else + { + CalcFootnoteFlag( nTextPos - TextFrameIndex(1) ); + OSL_ENSURE( !HasFootnote(), "Missing FootnoteFlag." ); + } +#endif + + MoveFlyInCnt( pNew, nTextPos, TextFrameIndex(COMPLETE_STRING) ); + + // No SetOffset or CalcFollow, because an AdjustFollow follows immediately anyways + + pNew->ManipOfst( nTextPos ); +} + +void SwTextFrame::SetOffset_(TextFrameIndex const nNewOfst) +{ + // We do not need to invalidate our Follow. + // We are a Follow, get formatted right away and call + // SetOffset() from there + mnOffset = nNewOfst; + SwParaPortion *pPara = GetPara(); + if( pPara ) + { + SwCharRange &rReformat = pPara->GetReformat(); + rReformat.Start() = TextFrameIndex(0); + rReformat.Len() = TextFrameIndex(GetText().getLength()); + pPara->SetDelta(sal_Int32(rReformat.Len())); + } + InvalidateSize(); +} + +bool SwTextFrame::CalcPreps() +{ + OSL_ENSURE( ! IsVertical() || ! IsSwapped(), "SwTextFrame::CalcPreps with swapped frame" ); + SwRectFnSet aRectFnSet(this); + + SwParaPortion *pPara = GetPara(); + if ( !pPara ) + return false; + const bool bPrep = pPara->IsPrep(); + const bool bPrepWidows = pPara->IsPrepWidows(); + const bool bPrepAdjust = pPara->IsPrepAdjust(); + const bool bPrepMustFit = pPara->IsPrepMustFit(); + ResetPreps(); + + bool bRet = false; + if( bPrep && !pPara->GetReformat().Len() ) + { + // PrepareHint::Widows means that the orphans rule got activated in the Follow. + // In unfortunate cases we could also have a PrepAdjust! + if( bPrepWidows ) + { + if( !GetFollow() ) + { + OSL_ENSURE( GetFollow(), "+SwTextFrame::CalcPreps: no credits" ); + return false; + } + + // We need to prepare for two cases: + // We were able to hand over a few lines to the Follow + // -> we need to shrink + // or we need to go on the next page + // -> we let our Frame become too big + + SwTwips nChgHeight = GetParHeight(); + if( nChgHeight >= aRectFnSet.GetHeight(getFramePrintArea()) ) + { + if( bPrepMustFit ) + { + GetFollow()->SetJustWidow( true ); + GetFollow()->Prepare(); + } + else if ( aRectFnSet.IsVert() ) + { + { + SwFrameAreaDefinition::FrameAreaWriteAccess aFrm(*this); + aFrm.Width( aFrm.Width() + aFrm.Left() ); + aFrm.Left( 0 ); + } + + { + SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*this); + aPrt.Width( aPrt.Width() + getFrameArea().Left() ); + } + + SetWidow( true ); + } + else + { + // nTmp should be very large, but not so large as to cause overflow later (e.g., + // GetFrameOfModify in sw/source/core/layout/frmtool.cxx calculates nCurrentDist + // from, among others, the square of aDiff.getY(), which can be close to nTmp); + // the previously used value TWIPS_MAX/2 (i.e., (LONG_MAX - 1)/2) depended on + // the range of 'long', while the value (SAL_MAX_INT32 - 1)/2 (which matches the + // old value on platforms where 'long' is 'sal_Int32') is empirically shown to + // be large enough in practice even on platforms where 'long' is 'sal_Int64': + SwTwips const nTmp = sw::WIDOW_MAGIC - (getFrameArea().Top()+10000); + SwTwips nDiff = nTmp - getFrameArea().Height(); + + { + SwFrameAreaDefinition::FrameAreaWriteAccess aFrm(*this); + aFrm.Height( nTmp ); + } + + { + SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*this); + aPrt.Height( aPrt.Height() + nDiff ); + } + + SetWidow( true ); + } + } + else + { + OSL_ENSURE( nChgHeight < aRectFnSet.GetHeight(getFramePrintArea()), + "+SwTextFrame::CalcPrep: want to shrink" ); + + nChgHeight = aRectFnSet.GetHeight(getFramePrintArea()) - nChgHeight; + + GetFollow()->SetJustWidow( true ); + GetFollow()->Prepare(); + Shrink( nChgHeight ); + SwRect &rRepaint = pPara->GetRepaint(); + + if ( aRectFnSet.IsVert() ) + { + SwRect aRepaint( getFrameArea().Pos() + getFramePrintArea().Pos(), getFramePrintArea().SSize() ); + SwitchVerticalToHorizontal( aRepaint ); + rRepaint.Chg( aRepaint.Pos(), aRepaint.SSize() ); + } + else + rRepaint.Chg( getFrameArea().Pos() + getFramePrintArea().Pos(), getFramePrintArea().SSize() ); + + if( 0 >= rRepaint.Width() ) + rRepaint.Width(1); + } + bRet = true; + } + else if ( bPrepAdjust ) + { + if ( HasFootnote() ) + { + if( !CalcPrepFootnoteAdjust() ) + { + if( bPrepMustFit ) + { + SwTextLineAccess aAccess( this ); + aAccess.GetPara()->SetPrepMustFit(true); + } + return false; + } + } + + { + SwSwapIfNotSwapped swap( this ); + + SwTextFormatInfo aInf( getRootFrame()->GetCurrShell()->GetOut(), this ); + SwTextFormatter aLine( this, &aInf ); + + WidowsAndOrphans aFrameBreak( this ); + // Whatever the attributes say: we split the paragraph in + // MustFit case if necessary + if( bPrepMustFit ) + { + aFrameBreak.SetKeep( false ); + aFrameBreak.ClrOrphLines(); + } + // Before calling FormatAdjust, we need to make sure + // that the lines protruding at the bottom get indeed + // truncated + bool bBreak = aFrameBreak.IsBreakNowWidAndOrp( aLine ); + bRet = true; + while( !bBreak && aLine.Next() ) + { + bBreak = aFrameBreak.IsBreakNowWidAndOrp( aLine ); + } + if( bBreak ) + { + // We run into troubles: when TruncLines is called, the + // conditions in IsInside change immediately such that + // IsBreakNow can return different results. + // For this reason, we tell rFrameBreak that the + // end is reached at the location of rLine. + // Let's see if it works ... + aLine.TruncLines(); + aFrameBreak.SetRstHeight( aLine ); + FormatAdjust( aLine, aFrameBreak, TextFrameIndex(aInf.GetText().getLength()), aInf.IsStop() ); + } + else + { + if( !GetFollow() ) + { + FormatAdjust( aLine, aFrameBreak, + TextFrameIndex(aInf.GetText().getLength()), aInf.IsStop() ); + } + else if ( !aFrameBreak.IsKeepAlways() ) + { + // We delete a line before the Master, because the Follow + // could hand over a line + const SwCharRange aFollowRg(GetFollow()->GetOffset(), TextFrameIndex(1)); + pPara->GetReformat() += aFollowRg; + // We should continue! + bRet = false; + } + } + } + + // A final check, if FormatAdjust() didn't help we need to + // truncate + if( bPrepMustFit ) + { + const SwTwips nMust = aRectFnSet.GetPrtBottom(*GetUpper()); + const SwTwips nIs = aRectFnSet.GetBottom(getFrameArea()); + + if( aRectFnSet.IsVert() && nIs < nMust ) + { + Shrink( nMust - nIs ); + + if( getFramePrintArea().Width() < 0 ) + { + SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*this); + aPrt.Width( 0 ); + } + + SetUndersized( true ); + } + else if ( ! aRectFnSet.IsVert() && nIs > nMust ) + { + Shrink( nIs - nMust ); + + if( getFramePrintArea().Height() < 0 ) + { + SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*this); + aPrt.Height( 0 ); + } + + SetUndersized( true ); + } + } + } + } + pPara->SetPrepMustFit( bPrepMustFit ); + return bRet; +} + +// Move the as-character objects - footnotes must be moved by RemoveFootnote! +void SwTextFrame::ChangeOffset( SwTextFrame* pFrame, TextFrameIndex nNew ) +{ + if( pFrame->GetOffset() < nNew ) + pFrame->MoveFlyInCnt( this, TextFrameIndex(0), nNew ); + else if( pFrame->GetOffset() > nNew ) + MoveFlyInCnt( pFrame, nNew, TextFrameIndex(COMPLETE_STRING) ); +} + +void SwTextFrame::FormatAdjust( SwTextFormatter &rLine, + WidowsAndOrphans &rFrameBreak, + TextFrameIndex const nStrLen, + const bool bDummy ) +{ + SwSwapIfNotSwapped swap( this ); + + SwParaPortion *pPara = rLine.GetInfo().GetParaPortion(); + + TextFrameIndex nEnd = rLine.GetStart(); + + const bool bHasToFit = pPara->IsPrepMustFit(); + + // The StopFlag is set by footnotes which want to go onto the next page + // Call base class method + // instead of method to get a break, + // even if due to widow rule no enough lines exists. + sal_uInt8 nNew = ( !GetFollow() && + nEnd < nStrLen && + ( rLine.IsStop() || + ( bHasToFit + ? ( rLine.GetLineNr() > 1 && + !rFrameBreak.IsInside( rLine ) ) + : rFrameBreak.IsBreakNow( rLine ) ) ) ) + ? 1 : 0; + + SwTextFormatInfo& rInf = rLine.GetInfo(); + if (nNew == 0 && !nStrLen && !rInf.GetTextFly().IsOn() && IsEmptyWithSplitFly()) + { + // Empty paragraph, so IsBreakNow() is not called, but we should split the fly portion and + // the paragraph marker. + nNew = 1; + } + + // i#84870 + // no split of text frame, which only contains an as-character anchored object + bool bOnlyContainsAsCharAnchoredObj = + !IsFollow() && nStrLen == TextFrameIndex(1) && + GetDrawObjs() && GetDrawObjs()->size() == 1 && + (*GetDrawObjs())[0]->GetFrameFormat().GetAnchor().GetAnchorId() == RndStdIds::FLY_AS_CHAR; + + // Still try split text frame if we have columns. + if (FindColFrame()) + bOnlyContainsAsCharAnchoredObj = false; + + if ( nNew && bOnlyContainsAsCharAnchoredObj ) + { + nNew = 0; + } + + if ( nNew ) + { + SplitFrame( nEnd ); + } + + const SwFrame *pBodyFrame = FindBodyFrame(); + + const tools::Long nBodyHeight = pBodyFrame ? ( IsVertical() ? + pBodyFrame->getFrameArea().Width() : + pBodyFrame->getFrameArea().Height() ) : 0; + + // If the current values have been calculated, show that they + // are valid now + pPara->GetReformat() = SwCharRange(); + bool bDelta = pPara->GetDelta() != 0; + pPara->SetDelta(0); + + if( rLine.IsStop() ) + { + rLine.TruncLines( true ); + nNew = 1; + } + + // FindBreak truncates the last line + if( !rFrameBreak.FindBreak( this, rLine, bHasToFit ) ) + { + // If we're done formatting, we set nEnd to the end. + // AdjustFollow might execute JoinFrame() because of this. + // Else, nEnd is the end of the last line in the Master. + TextFrameIndex nOld = nEnd; + // Make sure content from the last floating table anchor is not shifted to previous anchors. + if (!HasNonLastSplitFlyDrawObj()) + { + nEnd = rLine.GetEnd(); + } + if( GetFollow() ) + { + if( nNew && nOld < nEnd ) + RemoveFootnote( nOld, nEnd - nOld ); + ChangeOffset( GetFollow(), nEnd ); + if( !bDelta ) + GetFollow()->ManipOfst( nEnd ); + } + } + else + { // If we pass over lines, we must not call Join in Follows, instead we even + // need to create a Follow. + // We also need to do this if the whole mass of text remains in the Master, + // because a hard line break could necessitate another line (without text mass)! + TextFrameIndex const nOld(nEnd); + nEnd = rLine.GetEnd(); + if( GetFollow() ) + { + // Another case for not joining the follow: + // Text frame has no content, but a numbering. Then, do *not* join. + // Example of this case: When an empty, but numbered paragraph + // at the end of page is completely displaced by a fly frame. + // Thus, the text frame introduced a follow by a + // - see below. The follow then shows + // the numbering and must stay. + if ( GetFollow()->GetOffset() != nEnd || + GetFollow()->IsFieldFollow() || + (nStrLen == TextFrameIndex(0) && GetTextNodeForParaProps()->GetNumRule())) + { + nNew |= 3; + } + else if (FindTabFrame() && nEnd > TextFrameIndex(0) && + rLine.GetInfo().GetChar(nEnd - TextFrameIndex(1)) == CH_BREAK) + { + // We are in a table, the paragraph has a follow and the text + // ends with a hard line break. Don't join the follow just + // because the follow would have no content, we may still need it + // for the paragraph mark. + nNew |= 1; + } + // move footnotes if the follow is kept - if RemoveFootnote() is + // called in next format iteration, it will be with the *new* + // offset so no effect! + if (nNew && nOld < nEnd) + { + RemoveFootnote(nOld, nEnd - nOld); + } + ChangeOffset( GetFollow(), nEnd ); + + SwFlyAtContentFrame* pNonLastSplitFlyDrawObj = HasNonLastSplitFlyDrawObj(); + if (pNonLastSplitFlyDrawObj && !pNonLastSplitFlyDrawObj->IsWrapOnAllPages()) + { + // Make sure content from the last floating table anchor is not shifted to previous + // anchors, unless we're in the special "wrap on all pages" mode. + nEnd = TextFrameIndex(0); + } + + GetFollow()->ManipOfst( nEnd ); + } + else + { + const SwTextNode* pTextNode = GetTextNodeForParaProps(); + bool bHasVisibleNumRule = nStrLen == TextFrameIndex(0) && pTextNode->GetNumRule(); + + if (!pTextNode->HasVisibleNumberingOrBullet()) + { + bHasVisibleNumRule = false; + } + + // Only split frame, if the frame contains + // content or contains no content, but has a numbering. + // i#84870 - No split, if text frame only contains one + // as-character anchored object. + if ( !bOnlyContainsAsCharAnchoredObj && + (nStrLen > TextFrameIndex(0) || + bHasVisibleNumRule ) + ) + { + SplitFrame( nEnd ); + nNew |= 3; + } + } + // If the remaining height changed e.g by RemoveFootnote() we need to + // fill up in order to avoid oscillation. + if( bDummy && pBodyFrame && + nBodyHeight < ( IsVertical() ? + pBodyFrame->getFrameArea().Width() : + pBodyFrame->getFrameArea().Height() ) ) + rLine.MakeDummyLine(); + } + + // In AdjustFrame() we set ourselves via Grow/Shrink + // In AdjustFollow() we set our FollowFrame + + const SwTwips nDocPrtTop = getFrameArea().Top() + getFramePrintArea().Top(); + const SwTwips nOldHeight = getFramePrintArea().SSize().Height(); + SwTwips nChg = rLine.CalcBottomLine() - nDocPrtTop - nOldHeight; + + //#i84870# - no shrink of text frame, if it only contains one as-character anchored object. + if ( nChg < 0 && !bDelta && bOnlyContainsAsCharAnchoredObj ) + { + nChg = 0; + } + + // Vertical Formatting: + // The (rotated) repaint rectangle's x coordinate refers to the frame. + // If the frame grows (or shirks) the repaint rectangle cannot simply + // be rotated back after formatting, because we use the upper left point + // of the frame for rotation. This point changes when growing/shrinking. + + if ( IsVertical() && !IsVertLR() && nChg ) + { + SwRect &rRepaint = pPara->GetRepaint(); + rRepaint.Left( rRepaint.Left() - nChg ); + rRepaint.Width( rRepaint.Width() - nChg ); + } + + AdjustFrame( nChg, bHasToFit ); + + if( HasFollow() || IsInFootnote() ) + AdjustFollow_( rLine, nEnd, nStrLen, nNew ); + + pPara->SetPrepMustFit( false ); +} + +// bPrev is set whether Reformat.Start() was called because of Prev(). +// Else, we don't know whether we can limit the repaint or not. +bool SwTextFrame::FormatLine( SwTextFormatter &rLine, const bool bPrev ) +{ + OSL_ENSURE( ! IsVertical() || IsSwapped(), + "SwTextFrame::FormatLine( rLine, bPrev) with unswapped frame" ); + SwParaPortion *pPara = rLine.GetInfo().GetParaPortion(); + const SwLineLayout *pOldCur = rLine.GetCurr(); + const TextFrameIndex nOldLen = pOldCur->GetLen(); + const SwTwips nOldAscent = pOldCur->GetAscent(); + const SwTwips nOldHeight = pOldCur->Height(); + const SwTwips nOldWidth = pOldCur->Width() + pOldCur->GetHangingMargin(); + const bool bOldHyph = pOldCur->IsEndHyph(); + SwTwips nOldTop = 0; + SwTwips nOldBottom = 0; + if( rLine.GetCurr()->IsClipping() ) + rLine.CalcUnclipped( nOldTop, nOldBottom ); + + TextFrameIndex const nNewStart = rLine.FormatLine( rLine.GetStart() ); + + OSL_ENSURE( getFrameArea().Pos().Y() + getFramePrintArea().Pos().Y() == rLine.GetFirstPos(), + "SwTextFrame::FormatLine: frame leaves orbit." ); + OSL_ENSURE( rLine.GetCurr()->Height(), + "SwTextFrame::FormatLine: line height is zero" ); + + // The current line break object + const SwLineLayout *pNew = rLine.GetCurr(); + + bool bUnChg = nOldLen == pNew->GetLen() && + bOldHyph == pNew->IsEndHyph(); + if ( bUnChg && !bPrev ) + { + const tools::Long nWidthDiff = nOldWidth > pNew->Width() + ? nOldWidth - pNew->Width() + : pNew->Width() - nOldWidth; + + // we only declare a line as unchanged, if its main values have not + // changed and it is not the last line (!paragraph end symbol!) + bUnChg = nOldHeight == pNew->Height() && + nOldAscent == pNew->GetAscent() && + nWidthDiff <= SLOPPY_TWIPS && + pOldCur->GetNext(); + } + + // Calculate rRepaint + const SwTwips nBottom = rLine.Y() + rLine.GetLineHeight(); + SwRepaint &rRepaint = pPara->GetRepaint(); + if( bUnChg && rRepaint.Top() == rLine.Y() + && (bPrev || nNewStart <= pPara->GetReformat().Start()) + && (nNewStart < TextFrameIndex(GetText().getLength()))) + { + rRepaint.Top( nBottom ); + rRepaint.Height( 0 ); + } + else + { + if( nOldTop ) + { + if( nOldTop < rRepaint.Top() ) + rRepaint.Top( nOldTop ); + if( !rLine.IsUnclipped() || nOldBottom > rRepaint.Bottom() ) + { + rRepaint.Bottom( nOldBottom - 1 ); + rLine.SetUnclipped( true ); + } + } + if( rLine.GetCurr()->IsClipping() && rLine.IsFlyInCntBase() ) + { + SwTwips nTmpTop, nTmpBottom; + rLine.CalcUnclipped( nTmpTop, nTmpBottom ); + if( nTmpTop < rRepaint.Top() ) + rRepaint.Top( nTmpTop ); + if( !rLine.IsUnclipped() || nTmpBottom > rRepaint.Bottom() ) + { + rRepaint.Bottom( nTmpBottom - 1 ); + rLine.SetUnclipped( true ); + } + } + else + { + if( !rLine.IsUnclipped() || nBottom > rRepaint.Bottom() ) + { + rRepaint.Bottom( nBottom - 1 ); + rLine.SetUnclipped( false ); + } + } + SwTwips nRght = std::max( nOldWidth, pNew->Width() + + pNew->GetHangingMargin() ); + SwViewShell *pSh = getRootFrame()->GetCurrShell(); + const SwViewOption *pOpt = pSh ? pSh->GetViewOptions() : nullptr; + if( pOpt && (pOpt->IsParagraph() || pOpt->IsLineBreak()) ) + nRght += ( std::max( nOldAscent, pNew->GetAscent() ) ); + else + nRght += ( std::max( nOldAscent, pNew->GetAscent() ) / 4); + nRght += rLine.GetLeftMargin(); + if( rRepaint.GetOffset() || rRepaint.GetRightOfst() < nRght ) + rRepaint.SetRightOfst( nRght ); + + // Finally we enlarge the repaint rectangle if we found an underscore + // within our line. 40 Twips should be enough + const bool bHasUnderscore = + ( rLine.GetInfo().GetUnderScorePos() < nNewStart ); + if ( bHasUnderscore || rLine.GetCurr()->HasUnderscore() ) + rRepaint.Bottom( rRepaint.Bottom() + 40 ); + + const_cast(rLine.GetCurr())->SetUnderscore( bHasUnderscore ); + } + + // Calculating the good ol' nDelta + const sal_Int32 nDiff = sal_Int32(pNew->GetLen()) - sal_Int32(nOldLen); + pPara->SetDelta(pPara->GetDelta() - nDiff); + + // Stop! + if( rLine.IsStop() ) + return false; + + // Absolutely another line + if( rLine.IsNewLine() ) + return true; + + // Until the String's end? + if (nNewStart >= TextFrameIndex(GetText().getLength())) + return false; + + if( rLine.GetInfo().IsShift() ) + return true; + + // Reached the Reformat's end? + const TextFrameIndex nEnd = pPara->GetReformat().Start() + + pPara->GetReformat().Len(); + + if( nNewStart <= nEnd ) + return true; + + return 0 != pPara->GetDelta(); +} + +void SwTextFrame::Format_( SwTextFormatter &rLine, SwTextFormatInfo &rInf, + const bool bAdjust ) +{ + OSL_ENSURE( ! IsVertical() || IsSwapped(),"SwTextFrame::Format_ with unswapped frame" ); + + SwParaPortion *pPara = rLine.GetInfo().GetParaPortion(); + rLine.SetUnclipped( false ); + + const OUString & rString = GetText(); + const TextFrameIndex nStrLen(rString.getLength()); + + SwCharRange &rReformat = pPara->GetReformat(); + SwRepaint &rRepaint = pPara->GetRepaint(); + std::unique_ptr pFreeze; + + // Due to performance reasons we set rReformat to COMPLETE_STRING in Init() + // In this case we adjust rReformat + if( rReformat.Len() > nStrLen ) + rReformat.Len() = nStrLen; + + if( rReformat.Start() + rReformat.Len() > nStrLen ) + rReformat.Len() = nStrLen - rReformat.Start(); + + SwTwips nOldBottom; + if( GetOffset() && !IsFollow() ) + { + rLine.Bottom(); + nOldBottom = rLine.Y(); + rLine.Top(); + } + else + nOldBottom = 0; + rLine.CharToLine( rReformat.Start() ); + + // When inserting or removing a Space, words can be moved out of the edited + // line and into the preceding line, hence the preceding line must be + // formatted as well. + // Optimization: If rReformat starts after the first word of the line, + // this line cannot possibly influence the previous one. + // ...Turns out that unfortunately it can: Text size changes + FlyFrames; + // the feedback can affect multiple lines (Frames!)! + + // i#46560 + // FME: Yes, consider this case: "(word )" has to go to the next line + // because ")" is a forbidden character at the beginning of a line although + // "(word" would still fit on the previous line. Adding text right in front + // of ")" would not trigger a reformatting of the previous line. Adding 1 + // to the result of FindBrk() does not solve the problem in all cases, + // nevertheless it should be sufficient. + bool bPrev = rLine.GetPrev() && + (FindBrk(rString, rLine.GetStart(), rReformat.Start() + TextFrameIndex(1)) + // i#46560 + + TextFrameIndex(1) + >= rReformat.Start() || + rLine.GetCurr()->IsRest() ); + if( bPrev ) + { + while( rLine.Prev() ) + if( rLine.GetCurr()->GetLen() && !rLine.GetCurr()->IsRest() ) + { + if( !rLine.GetStart() ) + rLine.Top(); // So that NumDone doesn't get confused + break; + } + TextFrameIndex nNew = rLine.GetStart() + rLine.GetLength(); + if( nNew ) + { + --nNew; + if (CH_BREAK == rString[sal_Int32(nNew)]) + { + ++nNew; + rLine.Next(); + bPrev = false; + } + } + rReformat.Len() += rReformat.Start() - nNew; + rReformat.Start() = nNew; + } + + rRepaint.SetOffset( 0 ); + rRepaint.SetRightOfst( 0 ); + rRepaint.Chg( getFrameArea().Pos() + getFramePrintArea().Pos(), getFramePrintArea().SSize() ); + if( pPara->IsMargin() ) + rRepaint.Width( rRepaint.Width() + pPara->GetHangingMargin() ); + rRepaint.Top( rLine.Y() ); + if( 0 >= rRepaint.Width() ) + rRepaint.Width(1); + WidowsAndOrphans aFrameBreak( this, rInf.IsTest() ? 1 : 0 ); + + // rLine is now set to the first line which needs formatting. + // The bFirst flag makes sure that Next() is not called. + // The whole thing looks weird, but we need to make sure that + // rLine stops at the last non-fitting line when calling IsBreakNow. + bool bFirst = true; + bool bFormat = true; + + // The CharToLine() can also get us into the danger zone. + // In that case we need to walk back until rLine is set + // to the non-fitting line. Or else the mass of text is lost, + // because the Ofst was set wrongly in the Follow. + + bool bBreak = ( !pPara->IsPrepMustFit() || rLine.GetLineNr() > 1 ) + && aFrameBreak.IsBreakNowWidAndOrp( rLine ); + if( bBreak ) + { + bool bPrevDone = nullptr != rLine.Prev(); + while( bPrevDone && aFrameBreak.IsBreakNowWidAndOrp(rLine) ) + bPrevDone = nullptr != rLine.Prev(); + if( bPrevDone ) + { + aFrameBreak.SetKeep( false ); + rLine.Next(); + } + rLine.TruncLines(); + + // Play it safe + aFrameBreak.IsBreakNowWidAndOrp(rLine); + } + + /* Meaning if the following flags are set: + + Watch(End/Mid)Hyph: we need to format if we have a break at + the line end/Fly, as long as MaxHyph is reached + + Jump(End/Mid)Flag: the next line which has no break (line end/Fly), + needs to be formatted, because we could wrap now. This might have been + forbidden earlier by MaxHyph + + Watch(End/Mid)Hyph: if the last formatted line got a cutoff point, but + didn't have one before + + Jump(End/Mid)Hyph: if a cutoff point disappears + */ + bool bJumpEndHyph = false; + bool bWatchEndHyph = false; + bool bJumpMidHyph = false; + bool bWatchMidHyph = false; + + const SwAttrSet& rAttrSet = GetTextNodeForParaProps()->GetSwAttrSet(); + rInf.MaxHyph() = rAttrSet.GetHyphenZone().GetMaxHyphens(); + bool bMaxHyph = 0 != rInf.MaxHyph(); + if ( bMaxHyph ) + rLine.InitCntHyph(); + + if( IsFollow() && IsFieldFollow() && rLine.GetStart() == GetOffset() ) + { + SwTextFrame *pMaster = FindMaster(); + OSL_ENSURE( pMaster, "SwTextFrame::Format: homeless follow" ); + const SwLineLayout* pLine=nullptr; + if (pMaster) + { + if (!pMaster->HasPara()) + { // master could be locked because it's being formatted upstack + SAL_WARN("sw", "SwTextFrame::Format_: master not formatted!"); + } + else + { + SwTextSizeInfo aInf( pMaster ); + SwTextIter aMasterLine( pMaster, &aInf ); + aMasterLine.Bottom(); + pLine = aMasterLine.GetCurr(); + assert(aMasterLine.GetEnd() == GetOffset()); + } + } + SwLinePortion* pRest = pLine ? + rLine.MakeRestPortion(pLine, GetOffset()) : nullptr; + if( pRest ) + rInf.SetRest( pRest ); + else + SetFieldFollow( false ); + } + + /* Ad cancel criterion: + * In order to recognize, whether a line does not fit onto the page + * anymore, we need to format it. This overflow is removed again in + * e.g. AdjustFollow. + * Another complication: if we are the Master, we need to traverse + * the lines, because it could happen that one line can overflow + * from the Follow to the Master. + */ + do + { + if( bFirst ) + bFirst = false; + else + { + if ( bMaxHyph ) + { + if ( rLine.GetCurr()->IsEndHyph() ) + rLine.CntEndHyph()++; + else + rLine.CntEndHyph() = 0; + if ( rLine.GetCurr()->IsMidHyph() ) + rLine.CntMidHyph()++; + else + rLine.CntMidHyph() = 0; + } + if( !rLine.Next() ) + { + if( !bFormat ) + { + SwLinePortion* pRest = + rLine.MakeRestPortion( rLine.GetCurr(), rLine.GetEnd() ); + if( pRest ) + rInf.SetRest( pRest ); + } + rLine.Insert( new SwLineLayout() ); + rLine.Next(); + bFormat = true; + } + } + if ( !bFormat && bMaxHyph && + (bWatchEndHyph || bJumpEndHyph || bWatchMidHyph || bJumpMidHyph) ) + { + if ( rLine.GetCurr()->IsEndHyph() ) + { + if ( bWatchEndHyph ) + bFormat = ( rLine.CntEndHyph() == rInf.MaxHyph() ); + } + else + { + bFormat = bJumpEndHyph; + bWatchEndHyph = false; + bJumpEndHyph = false; + } + if ( rLine.GetCurr()->IsMidHyph() ) + { + if ( bWatchMidHyph && !bFormat ) + bFormat = ( rLine.CntEndHyph() == rInf.MaxHyph() ); + } + else + { + bFormat |= bJumpMidHyph; + bWatchMidHyph = false; + bJumpMidHyph = false; + } + } + if( bFormat ) + { + const bool bOldEndHyph = rLine.GetCurr()->IsEndHyph(); + const bool bOldMidHyph = rLine.GetCurr()->IsMidHyph(); + bFormat = FormatLine( rLine, bPrev ); + // There can only be one bPrev ... (???) + bPrev = false; + if ( bMaxHyph ) + { + if ( rLine.GetCurr()->IsEndHyph() != bOldEndHyph ) + { + bWatchEndHyph = !bOldEndHyph; + bJumpEndHyph = bOldEndHyph; + } + if ( rLine.GetCurr()->IsMidHyph() != bOldMidHyph ) + { + bWatchMidHyph = !bOldMidHyph; + bJumpMidHyph = bOldMidHyph; + } + } + } + + if( !rInf.IsNewLine() ) + { + if( !bFormat ) + bFormat = nullptr != rInf.GetRest(); + if( rInf.IsStop() || rInf.GetIdx() >= nStrLen ) + break; + if( !bFormat && ( !bMaxHyph || ( !bWatchEndHyph && + !bJumpEndHyph && !bWatchMidHyph && !bJumpMidHyph ) ) ) + { + if( GetFollow() ) + { + while( rLine.Next() ) + ; //Nothing + pFreeze.reset(new SwRepaint( rRepaint )); // to minimize painting + } + else + break; + } + } + bBreak = aFrameBreak.IsBreakNowWidAndOrp(rLine); + }while( !bBreak ); + + if( pFreeze ) + { + rRepaint = *pFreeze; + pFreeze.reset(); + } + + if( !rLine.IsStop() ) + { + // If we're finished formatting the text and we still + // have other line objects left, these are superfluous + // now because the text has gotten shorter. + bool bTruncLines = false; + if( rLine.GetStart() + rLine.GetLength() >= nStrLen && + rLine.GetCurr()->GetNext() ) + { + bTruncLines = true; + } + else if (GetMergedPara() && rLine.GetCurr()->GetNext()) + { + // We can also have superfluous lines with redlining in case the current line is shorter + // than the text length, but the total length of lines is still more than expected. + // Truncate in this case as well. + TextFrameIndex nLen(0); + for (const SwLineLayout* pLine = pPara; pLine; pLine = pLine->GetNext()) + { + nLen += pLine->GetLen(); + } + bTruncLines = nLen > nStrLen; + } + + if (bTruncLines) + { + rLine.TruncLines(); + rLine.SetTruncLines( true ); + } + } + + if( rInf.IsTest() ) + return; + + // FormatAdjust does not pay off at OnceMore + if( bAdjust || !rLine.GetDropFormat() || !rLine.CalcOnceMore() ) + { + FormatAdjust( rLine, aFrameBreak, nStrLen, rInf.IsStop() ); + } + if( rRepaint.HasArea() ) + SetRepaint(); + rLine.SetTruncLines( false ); + if( nOldBottom ) // We check whether paragraphs that need scrolling can + // be shrunk, so that they don't need scrolling anymore + { + rLine.Bottom(); + SwTwips nNewBottom = rLine.Y(); + if( nNewBottom < nOldBottom ) + SetOffset_(TextFrameIndex(0)); + } +} + +void SwTextFrame::FormatOnceMore( SwTextFormatter &rLine, SwTextFormatInfo &rInf ) +{ + OSL_ENSURE( ! IsVertical() || IsSwapped(), + "A frame is not swapped in SwTextFrame::FormatOnceMore" ); + + SwParaPortion *pPara = rLine.GetInfo().GetParaPortion(); + if( !pPara ) + return; + + // If necessary the pPara + sal_uInt16 nOld = static_cast(rLine).GetDropHeight(); + bool bShrink = false; + bool bGrow = false; + bool bGoOn = rLine.IsOnceMore(); + sal_uInt8 nGo = 0; + while( bGoOn ) + { + ++nGo; + rInf.Init(); + rLine.Top(); + if( !rLine.GetDropFormat() ) + rLine.SetOnceMore( false ); + SwCharRange aRange(TextFrameIndex(0), TextFrameIndex(rInf.GetText().getLength())); + pPara->GetReformat() = aRange; + Format_( rLine, rInf ); + + bGoOn = rLine.IsOnceMore(); + if( bGoOn ) + { + const sal_uInt16 nNew = static_cast(rLine).GetDropHeight(); + if( nOld == nNew ) + bGoOn = false; + else + { + if( nOld > nNew ) + bShrink = true; + else + bGrow = true; + + if( bShrink == bGrow || 5 < nGo ) + bGoOn = false; + + nOld = nNew; + } + + // If something went wrong, we need to reformat again + if( !bGoOn ) + { + rInf.CtorInitTextFormatInfo( getRootFrame()->GetCurrShell()->GetOut(), this ); + rLine.CtorInitTextFormatter( this, &rInf ); + rLine.SetDropLines( 1 ); + rLine.CalcDropHeight( 1 ); + SwCharRange aTmpRange(TextFrameIndex(0), TextFrameIndex(rInf.GetText().getLength())); + pPara->GetReformat() = aTmpRange; + Format_( rLine, rInf, true ); + // We paint everything ... + SetCompletePaint(); + } + } + } +} + +void SwTextFrame::FormatImpl(vcl::RenderContext* pRenderContext, SwParaPortion *pPara, + std::vector & rIntersectingObjs) +{ + const bool bIsEmpty = GetText().isEmpty(); + + if ( bIsEmpty ) + { + // Empty lines do not get tortured for very long: + // pPara is cleared, which is the same as: + // *pPara = SwParaPortion; + const bool bMustFit = pPara->IsPrepMustFit(); + pPara->Truncate(); + pPara->FormatReset(); + + // delete pSpaceAdd and pKanaComp + pPara->FinishSpaceAdd(); + pPara->FinishKanaComp(); + pPara->ResetFlags(); + pPara->SetPrepMustFit( bMustFit ); + } + + OSL_ENSURE( ! IsSwapped(), "A frame is swapped before Format_" ); + + if ( IsVertical() ) + SwapWidthAndHeight(); + + SwTextFormatInfo aInf( pRenderContext, this ); + SwTextFormatter aLine( this, &aInf ); + + HideAndShowObjects(); + + Format_( aLine, aInf ); + + if( aLine.IsOnceMore() ) + FormatOnceMore( aLine, aInf ); + + if (aInf.GetTextFly().IsOn()) + { + SwRect const aRect(aInf.GetTextFly().GetFrameArea()); + for (SwAnchoredObject *const pObj : aInf.GetTextFly().GetAnchoredObjList()) + { + if (!aInf.GetTextFly().AnchoredObjToRect(pObj, aRect).IsEmpty()) + { + rIntersectingObjs.push_back(pObj); + } + } + } + + if ( IsVertical() ) + SwapWidthAndHeight(); + + OSL_ENSURE( ! IsSwapped(), "A frame is swapped after Format_" ); + + if( 1 >= aLine.GetDropLines() ) + return; + + if( SvxAdjust::Left != aLine.GetAdjust() && + SvxAdjust::Block != aLine.GetAdjust() ) + { + aLine.CalcDropAdjust(); + aLine.SetPaintDrop( true ); + } + + if( aLine.IsPaintDrop() ) + { + aLine.CalcDropRepaint(); + aLine.SetPaintDrop( false ); + } +} + +// We calculate the text frame's size and send a notification. +// Shrink() or Grow() to adjust the frame's size to the changed required space. +void SwTextFrame::Format( vcl::RenderContext* pRenderContext, const SwBorderAttrs * ) +{ + SwRectFnSet aRectFnSet(this); + + CalcAdditionalFirstLineOffset(); + + // The range autopilot or the BASIC interface pass us TextFrames with + // a width <= 0 from time to time + if( aRectFnSet.GetWidth(getFramePrintArea()) <= 0 ) + { + // If MustFit is set, we shrink to the Upper's bottom edge if needed. + SwTextLineAccess aAccess( this ); + + if( aAccess.GetPara()->IsPrepMustFit() ) + { + const SwTwips nLimit = aRectFnSet.GetPrtBottom(*GetUpper()); + const SwTwips nDiff = - aRectFnSet.BottomDist( getFrameArea(), nLimit ); + if( nDiff > 0 ) + Shrink( nDiff ); + } + + tools::Long nFrameHeight = aRectFnSet.GetHeight(getFrameArea()); + const tools::Long nTop = aRectFnSet.GetTopMargin(*this); + + if( nTop > nFrameHeight ) + { + aRectFnSet.SetYMargins( *this, nFrameHeight, 0 ); + } + else if( aRectFnSet.GetHeight(getFramePrintArea()) < 0 ) + { + SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*this); + aRectFnSet.SetHeight( aPrt, 0 ); + } + + return; + } + + TextFrameIndex nStrLen(GetText().getLength()); + + if (HasNonLastSplitFlyDrawObj()) + { + // Non-last part of split fly anchor: consider this empty. + nStrLen = TextFrameIndex(0); + } + + if ( nStrLen || !FormatEmpty() ) + { + + SetEmpty( false ); + // In order to not get confused by nested Formats + FormatLevel aLevel; + if( 12 == FormatLevel::GetLevel() ) + return; + + // We could be possibly not allowed to alter the format information + if( IsLocked() ) + return; + + // Attention: Format() could be triggered by GetFormatted() + if( IsHiddenNow() ) + { + tools::Long nPrtHeight = aRectFnSet.GetHeight(getFramePrintArea()); + if( nPrtHeight ) + { + HideHidden(); + Shrink( nPrtHeight ); + } + else + { + // Assure that objects anchored + // at paragraph resp. at/as character inside paragraph + // are hidden. + HideAndShowObjects(); + } + ChgThisLines(); + return; + } + + // We do not want to be interrupted during formatting + TextFrameLockGuard aLock(this); + + // this is to ensure that the similar code in SwTextFrame::Format_ + // finds the master formatted in case it's needed + if (IsFollow() && IsFieldFollow()) + { + SwTextFrame *pMaster = FindMaster(); + assert(pMaster); + if (!pMaster->HasPara()) + { + pMaster->GetFormatted(); + } + if (!pMaster->HasPara()) + { // master could be locked because it's being formatted upstack + SAL_WARN("sw", "SwTextFrame::Format: failed to format master!"); + } + else + { + SwTextSizeInfo aInf( pMaster ); + SwTextIter aMasterLine( pMaster, &aInf ); + aMasterLine.Bottom(); + SetOffset(aMasterLine.GetEnd()); + } + } + + SwTextLineAccess aAccess( this ); + const bool bNew = !aAccess.IsAvailable(); + const bool bSetOffset = + (GetOffset() && GetOffset() > TextFrameIndex(GetText().getLength())); + + if( CalcPreps() ) + ; // nothing + // We return if already formatted, but if the TextFrame was just created + // and does not have any format information + else if( !bNew && !aAccess.GetPara()->GetReformat().Len() ) + { + if (GetTextNodeForParaProps()->GetSwAttrSet().GetRegister().GetValue()) + { + aAccess.GetPara()->SetPrepAdjust(); + aAccess.GetPara()->SetPrep(); + CalcPreps(); + } + SetWidow( false ); + } + else if( bSetOffset && IsFollow() ) + { + SwTextFrame *pMaster = FindMaster(); + OSL_ENSURE( pMaster, "SwTextFrame::Format: homeless follow" ); + if( pMaster ) + pMaster->Prepare( PrepareHint::FollowFollows ); + SwTwips nMaxY = aRectFnSet.GetPrtBottom(*GetUpper()); + + if( aRectFnSet.OverStep( getFrameArea(), nMaxY ) ) + { + aRectFnSet.SetLimit( *this, nMaxY ); + } + else if( aRectFnSet.BottomDist( getFrameArea(), nMaxY ) < 0 ) + { + SwFrameAreaDefinition::FrameAreaWriteAccess aFrm(*this); + aRectFnSet.AddBottom( aFrm, -aRectFnSet.GetHeight(aFrm) ); + } + } + else + { + // bSetOffset here means that we have the "red arrow situation" + if ( bSetOffset ) + SetOffset_(TextFrameIndex(0)); + + const bool bOrphan = IsWidow(); + const SwFootnoteBossFrame* pFootnoteBoss = HasFootnote() ? FindFootnoteBossFrame() : nullptr; + SwTwips nFootnoteHeight = 0; + if( pFootnoteBoss ) + { + const SwFootnoteContFrame* pCont = pFootnoteBoss->FindFootnoteCont(); + nFootnoteHeight = pCont ? aRectFnSet.GetHeight(pCont->getFrameArea()) : 0; + } + do + { + ::std::vector intersectingObjs; + ::std::vector nexts; + for (SwFrame const* pNext = GetNext(); pNext; pNext = pNext->GetNext()) + { + nexts.push_back(pNext); + } + FormatImpl(pRenderContext, aAccess.GetPara(), intersectingObjs); + if( pFootnoteBoss && nFootnoteHeight ) + { + const SwFootnoteContFrame* pCont = pFootnoteBoss->FindFootnoteCont(); + SwTwips nNewHeight = pCont ? aRectFnSet.GetHeight(pCont->getFrameArea()) : 0; + // If we lost some footnotes, we may have more space + // for our main text, so we have to format again ... + if( nNewHeight < nFootnoteHeight ) + { + nFootnoteHeight = nNewHeight; + continue; + } + } + if (!intersectingObjs.empty()) + { + // assumption is that FormatImpl() only moves frames + // in the next-chain to next page + SwPageFrame *const pPage(FindPageFrame()); + SwTextFrame * pLastMovedAnchor(nullptr); + auto lastIter(nexts.end()); + for (SwAnchoredObject *const pObj : intersectingObjs) + { + SwFrame *const pAnchor(pObj->AnchorFrame()); + SwPageFrame *const pAnchorPage(pAnchor->FindPageFrame()); + if (pAnchorPage != pPage) + { + auto const iter(::std::find(nexts.begin(), nexts.end(), pAnchor)); + if (iter != nexts.end()) + { + assert(pAnchor->IsTextFrame()); + // (can't check SwOszControl::IsInProgress()?) + // called in loop in FormatAnchorFrameAndItsPrevs() + if (static_cast(pAnchor)->IsJoinLocked() + // called in loop in SwFrame::PrepareMake() + || pAnchor->IsDeleteForbidden()) + { + // when called via FormatAnchorFrameAndItsPrevs(): + // don't do anything, caller will handle it + pLastMovedAnchor = nullptr; + break; + } + assert(pPage->GetPhyPageNum() < pAnchorPage->GetPhyPageNum()); // how could it move backward? + + if (!pLastMovedAnchor || iter < lastIter) + { + pLastMovedAnchor = static_cast(pAnchor); + lastIter = iter; + } + } + } + } + SwPageFrame const*const pPrevPage(static_cast(pPage->GetPrev())); + if (pLastMovedAnchor) + { + for (SwAnchoredObject *const pObj : intersectingObjs) + { + if (pObj->AnchorFrame() == pLastMovedAnchor) + { + SwPageFrame *const pAnchorPage(pLastMovedAnchor->FindPageFrame()); + SAL_INFO("sw.layout", "SwTextFrame::Format: move anchored " << pObj << " from " << pPage->GetPhyPageNum() << " to " << pAnchorPage->GetPhyPageNum()); + pObj->RegisterAtPage(*pAnchorPage); + // tdf#143239 if the position remains valid, it may not be + // positioned again so would remain on the wrong page! + pObj->InvalidateObjPos(); + ::Notify_Background(pObj->GetDrawObj(), pPage, + pObj->GetObjRect(), PrepareHint::FlyFrameLeave, false); + pObj->SetForceNotifyNewBackground(true); + } + } + if (GetFollow() // this frame was split + && (!pPrevPage // prev page is still valid + || (!pPrevPage->IsInvalid() + && (!pPrevPage->GetSortedObjs() || !pPrevPage->IsInvalidFly())))) + { // this seems a bit risky... + SwLayouter::InsertMovedFwdFrame(GetTextNodeFirst()->GetDoc(), + *pLastMovedAnchor, FindPageFrame()->GetPhyPageNum() + 1); + } + continue; // try again without the fly + } + } + break; + } while ( pFootnoteBoss ); + if( bOrphan ) + { + ValidateFrame(); + SetWidow( false ); + } + } + if( IsEmptyMaster() ) + { + SwFrame* pPre = GetPrev(); + if( pPre && + // i#10826 It's the first, it cannot keep! + pPre->GetIndPrev() && + pPre->GetAttrSet()->GetKeep().GetValue() ) + { + pPre->InvalidatePos(); + } + + if (IsEmptyMasterWithSplitFly()) + { + // A fly is anchored to us, reduce size, so we definitely still fit the current + // page. + SwFrameAreaDefinition::FrameAreaWriteAccess aFrm(*this); + aRectFnSet.SetHeight(aFrm, 0); + + SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*this); + aRectFnSet.SetTop(aPrt, 0); + aRectFnSet.SetHeight(aPrt, 0); + } + } + } + + ChgThisLines(); + + // the PrepMustFit should not survive a Format operation + SwParaPortion *pPara = GetPara(); + if ( pPara ) + pPara->SetPrepMustFit( false ); + + CalcBaseOfstForFly(); + CalcHeightOfLastLine(); // i#11860 - Adjust spacing implementation for + // object positioning - Compatibility to MS Word + // tdf#117982 -- Fix cell spacing hides content + // Check if the cell's content has greater size than the row height + if (IsInTab() && GetUpper() && ((GetUpper()->getFramePrintArea().Height() < getFramePrintArea().Height()) + || (getFramePrintArea().Height() <= 0))) + { + SAL_INFO("sw.core", "Warn: Cell content has greater size than cell height!"); + //get font size... + SwTwips aTmpHeight = getFrameArea().Height(); + //...and push it into the text frame + SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*this); + //if only bottom margin what we have: + if (GetTopMargin() == 0) + //set the frame to its original location + aPrt.SetTopAndHeight(0, aTmpHeight); + } +} + +// bForceQuickFormat is set if GetFormatted() has been called during the +// painting process. Actually I cannot imagine a situation which requires +// a full formatting of the paragraph during painting, on the other hand +// a full formatting can cause the invalidation of other layout frames, +// e.g., if there are footnotes in this paragraph, and invalid layout +// frames will not calculated during the painting. So I actually want to +// avoid a formatting during painting, but since I'm a coward, I'll only +// force the quick formatting in the situation of issue i29062. +bool SwTextFrame::FormatQuick( bool bForceQuickFormat ) +{ + OSL_ENSURE( ! IsVertical() || ! IsSwapped(), + "SwTextFrame::FormatQuick with swapped frame" ); + + if( IsEmpty() && FormatEmpty() ) + return true; + + // We're very picky: + if( HasPara() || IsWidow() || IsLocked() + || !isFrameAreaSizeValid() || + ( ( IsVertical() ? getFramePrintArea().Width() : getFramePrintArea().Height() ) && IsHiddenNow() ) ) + return false; + + SwTextLineAccess aAccess( this ); + SwParaPortion *pPara = aAccess.GetPara(); + if( !pPara ) + return false; + + SwFrameSwapper aSwapper( this, true ); + + TextFrameLockGuard aLock(this); + SwTextFormatInfo aInf( getRootFrame()->GetCurrShell()->GetOut(), this, false, true ); + if( 0 != aInf.MaxHyph() ) // Respect MaxHyphen! + return false; + + SwTextFormatter aLine( this, &aInf ); + + // DropCaps are too complicated ... + if( aLine.GetDropFormat() ) + return false; + + TextFrameIndex nStart = GetOffset(); + const TextFrameIndex nEnd = GetFollow() + ? GetFollow()->GetOffset() + : TextFrameIndex(aInf.GetText().getLength()); + + int nLoopProtection = 0; + do + { + TextFrameIndex nNewStart = aLine.FormatLine(nStart); + if (nNewStart == nStart) + ++nLoopProtection; + else + nLoopProtection = 0; + nStart = nNewStart; + const bool bWillEndlessInsert = nLoopProtection > 250; + SAL_WARN_IF(bWillEndlessInsert, "sw", "loop detection triggered"); + if ((!bWillEndlessInsert) // Check for special case: line is invisible, + // like in too thin table cell: tdf#66141 + && (aInf.IsNewLine() || (!aInf.IsStop() && nStart < nEnd))) + aLine.Insert( new SwLineLayout() ); + } while( aLine.Next() ); + + // Last exit: the heights need to match + Point aTopLeft( getFrameArea().Pos() ); + aTopLeft += getFramePrintArea().Pos(); + const SwTwips nNewHeight = aLine.Y() + aLine.GetLineHeight(); + const SwTwips nOldHeight = aTopLeft.Y() + getFramePrintArea().Height(); + + if( !bForceQuickFormat && nNewHeight != nOldHeight && !IsUndersized() ) + { + // Attention: This situation can occur due to FormatLevel==12. Don't panic! + TextFrameIndex const nStrt = GetOffset(); + InvalidateRange_( SwCharRange( nStrt, nEnd - nStrt) ); + return false; + } + + if (m_pFollow && nStart != static_cast(m_pFollow)->GetOffset()) + return false; // can be caused by e.g. Orphans + + // We made it! + + // Set repaint + pPara->GetRepaint().Pos( aTopLeft ); + pPara->GetRepaint().SSize( getFramePrintArea().SSize() ); + + // Delete reformat + pPara->GetReformat() = SwCharRange(); + pPara->SetDelta(0); + + return true; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/frminf.cxx b/sw/source/core/text/frminf.cxx new file mode 100644 index 0000000000..a123691db7 --- /dev/null +++ b/sw/source/core/text/frminf.cxx @@ -0,0 +1,291 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include + +#include +#include "itrtxt.hxx" + +TextFrameIndex SwTextMargin::GetTextStart() const +{ + const OUString &rText = GetInfo().GetText(); + const TextFrameIndex nEnd = m_nStart + m_pCurr->GetLen(); + + for (TextFrameIndex i = m_nStart; i < nEnd; ++i) + { + const sal_Unicode aChar = rText[sal_Int32(i)]; + if( CH_TAB != aChar && ' ' != aChar ) + return i; + } + return nEnd; +} + +TextFrameIndex SwTextMargin::GetTextEnd() const +{ + const OUString &rText = GetInfo().GetText(); + const TextFrameIndex nEnd = m_nStart + m_pCurr->GetLen(); + for (TextFrameIndex i = nEnd - TextFrameIndex(1); i >= m_nStart; --i) + { + const sal_Unicode aChar = rText[sal_Int32(i)]; + if( CH_TAB != aChar && CH_BREAK != aChar && ' ' != aChar ) + return i + TextFrameIndex(1); + } + return m_nStart; +} + +// Does the paragraph fit into one line? +bool SwTextFrameInfo::IsOneLine() const +{ + const SwLineLayout *pLay = m_pFrame->GetPara(); + if( !pLay ) + return false; + + // For follows false of course + if( m_pFrame->GetFollow() ) + return false; + + pLay = pLay->GetNext(); + while( pLay ) + { + if( pLay->GetLen() ) + return false; + pLay = pLay->GetNext(); + } + return true; +} + +// Is the line filled for X percent? +bool SwTextFrameInfo::IsFilled( const sal_uInt8 nPercent ) const +{ + const SwLineLayout *pLay = m_pFrame->GetPara(); + if( !pLay ) + return false; + + tools::Long nWidth = m_pFrame->getFramePrintArea().Width(); + nWidth *= nPercent; + nWidth /= 100; + return nWidth <= pLay->Width(); +} + +// Where does the text start (without whitespace)? (document global) +SwTwips SwTextFrameInfo::GetLineStart( const SwTextCursor &rLine ) +{ + const TextFrameIndex nTextStart = rLine.GetTextStart(); + if( rLine.GetStart() == nTextStart ) + return rLine.GetLineStart(); + + SwRect aRect; + const_cast(rLine).GetCharRect( &aRect, nTextStart ); + return aRect.Left(); +} + +// Where does the text start (without whitespace)? (relative in the Frame) +SwTwips SwTextFrameInfo::GetLineStart() const +{ + SwTextSizeInfo aInf( const_cast(m_pFrame) ); + SwTextCursor aLine( const_cast(m_pFrame), &aInf ); + return GetLineStart( aLine ) - m_pFrame->getFrameArea().Left() - m_pFrame->getFramePrintArea().Left(); +} + +// Calculates the character's position and returns the middle position +SwTwips SwTextFrameInfo::GetCharPos(TextFrameIndex const nChar, bool bCenter) const +{ + SwRectFnSet aRectFnSet(m_pFrame); + SwFrameSwapper aSwapper( m_pFrame, true ); + + SwTextSizeInfo aInf( const_cast(m_pFrame) ); + SwTextCursor aLine( const_cast(m_pFrame), &aInf ); + + SwTwips nStt, nNext; + SwRect aRect; + aLine.GetCharRect( &aRect, nChar ); + if ( aRectFnSet.IsVert() ) + m_pFrame->SwitchHorizontalToVertical( aRect ); + + nStt = aRectFnSet.GetLeft(aRect); + + if( !bCenter ) + return nStt - aRectFnSet.GetLeft(m_pFrame->getFrameArea()); + + aLine.GetCharRect( &aRect, nChar + TextFrameIndex(1) ); + if ( aRectFnSet.IsVert() ) + m_pFrame->SwitchHorizontalToVertical( aRect ); + + nNext = aRectFnSet.GetLeft(aRect); + + return (( nNext + nStt ) / 2 ) - aRectFnSet.GetLeft(m_pFrame->getFrameArea()); +} + +static void +AddRange(std::vector> & rRanges, + TextFrameIndex const nPos, TextFrameIndex const nLen) +{ + assert(rRanges.empty() || rRanges.back().second <= nPos); + if( nLen ) + { + if (!rRanges.empty() && nPos == rRanges.back().second) + { + rRanges.back().second += nLen; + } + else + { + rRanges.emplace_back(nPos, nPos + nLen); + } + } +} + +// Accumulates the whitespace at line start and end in the vector +void SwTextFrameInfo::GetSpaces( + std::vector> & rRanges, + bool const bWithLineBreak) const +{ + SwTextSizeInfo aInf( const_cast(m_pFrame) ); + SwTextMargin aLine( const_cast(m_pFrame), &aInf ); + bool bFirstLine = true; + do { + + if( aLine.GetCurr()->GetLen() ) + { + TextFrameIndex nPos = aLine.GetTextStart(); + // Do NOT include the blanks/tabs from the first line + // in the selection + if( !bFirstLine && nPos > aLine.GetStart() ) + AddRange( rRanges, aLine.GetStart(), nPos - aLine.GetStart() ); + + // Do NOT include the blanks/tabs from the last line + // in the selection + if( aLine.GetNext() ) + { + nPos = aLine.GetTextEnd(); + + if( nPos < aLine.GetEnd() ) + { + TextFrameIndex const nOff( !bWithLineBreak && CH_BREAK == + aLine.GetInfo().GetChar(aLine.GetEnd() - TextFrameIndex(1)) + ? 1 : 0 ); + AddRange( rRanges, nPos, aLine.GetEnd() - nPos - nOff ); + } + } + } + bFirstLine = false; + } + while( aLine.Next() ); +} + +// Is there a bullet/symbol etc. at the text position? +// Fonts: CharSet, SYMBOL and DONTKNOW +bool SwTextFrameInfo::IsBullet(TextFrameIndex const nTextStart) const +{ + SwTextSizeInfo aInf( const_cast(m_pFrame) ); + SwTextMargin aLine( const_cast(m_pFrame), &aInf ); + aInf.SetIdx( nTextStart ); + return aLine.IsSymbol( nTextStart ); +} + +// Get first line indent +// The precondition for a positive or negative first line indent: +// All lines (except for the first one) have the same left margin. +// We do not want to be so picky and work with a tolerance of TOLERANCE twips. +SwTwips SwTextFrameInfo::GetFirstIndent() const +{ + SwTextSizeInfo aInf( const_cast(m_pFrame) ); + SwTextCursor aLine( const_cast(m_pFrame), &aInf ); + const SwTwips nFirst = GetLineStart( aLine ); + const SwTwips TOLERANCE = 20; + + if( !aLine.Next() ) + return 0; + + SwTwips nLeft = GetLineStart( aLine ); + while( aLine.Next() ) + { + if( aLine.GetCurr()->GetLen() ) + { + const SwTwips nCurrLeft = GetLineStart( aLine ); + if( nLeft + TOLERANCE < nCurrLeft || + nLeft - TOLERANCE > nCurrLeft ) + return 0; + } + } + + // At first we only return +1, -1 and 0 + if( nLeft == nFirst ) + return 0; + + if( nLeft > nFirst ) + return -1; + + return 1; +} + +sal_Int32 SwTextFrameInfo::GetBigIndent(TextFrameIndex& rFndPos, + const SwTextFrame *pNextFrame ) const +{ + SwTextSizeInfo aInf( const_cast(m_pFrame) ); + SwTextCursor aLine( const_cast(m_pFrame), &aInf ); + SwTwips nNextIndent = 0; + + if( pNextFrame ) + { + // I'm a single line + SwTextSizeInfo aNxtInf( const_cast(pNextFrame) ); + SwTextCursor aNxtLine( const_cast(pNextFrame), &aNxtInf ); + nNextIndent = GetLineStart( aNxtLine ); + } + else + { + // I'm multi-line + if( aLine.Next() ) + { + nNextIndent = GetLineStart( aLine ); + aLine.Prev(); + } + } + + if( nNextIndent <= GetLineStart( aLine ) ) + return 0; + + const Point aPoint( nNextIndent, aLine.Y() ); + rFndPos = aLine.GetModelPositionForViewPoint( nullptr, aPoint, false ); + if (TextFrameIndex(1) >= rFndPos) + return 0; + + // Is on front of a non-space + const OUString& rText = aInf.GetText(); + sal_Unicode aChar = rText[sal_Int32(rFndPos)]; + if( CH_TAB == aChar || CH_BREAK == aChar || ' ' == aChar || + (( CH_TXTATR_BREAKWORD == aChar || CH_TXTATR_INWORD == aChar ) && + aInf.HasHint( rFndPos ) ) ) + return 0; + + // and after a space + aChar = rText[sal_Int32(rFndPos) - 1]; + if( CH_TAB != aChar && CH_BREAK != aChar && + ( ( CH_TXTATR_BREAKWORD != aChar && CH_TXTATR_INWORD != aChar ) || + !aInf.HasHint(rFndPos - TextFrameIndex(1))) && + // More than two Blanks! + (' ' != aChar || ' ' != rText[sal_Int32(rFndPos) - 2])) + return 0; + + SwRect aRect; + aLine.GetCharRect( &aRect, rFndPos ); + return static_cast(aRect.Left() - m_pFrame->getFrameArea().Left() - m_pFrame->getFramePrintArea().Left()); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/frmpaint.cxx b/sw/source/core/text/frmpaint.cxx new file mode 100644 index 0000000000..57458a0218 --- /dev/null +++ b/sw/source/core/text/frmpaint.cxx @@ -0,0 +1,810 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "itrpaint.hxx" +#include "txtpaint.hxx" +#include "txtcache.hxx" +#include +#include "redlnitr.hxx" +#include +#include +#include +#include +#include + +#include + +#include +#include + +#define REDLINE_DISTANCE 567/4 +#define REDLINE_MINDIST 567/10 + +using namespace ::com::sun::star; + +static bool bInitFont = true; + +namespace { + +class SwExtraPainter +{ + SwSaveClip m_aClip; + SwRect m_aRect; + const SwTextFrame* m_pTextFrame; + SwViewShell *m_pSh; + std::unique_ptr m_pFnt; + const SwLineNumberInfo &m_rLineInf; + SwTwips m_nX; + SwTwips m_nRedX; + sal_Int32 m_nLineNr; + sal_uInt16 m_nDivider; + bool m_bGoLeft; + bool IsClipChg() const { return m_aClip.IsChg(); } + + SwExtraPainter(const SwExtraPainter&) = delete; + SwExtraPainter& operator=(const SwExtraPainter&) = delete; + +public: + SwExtraPainter( const SwTextFrame *pFrame, SwViewShell *pVwSh, + const SwLineNumberInfo &rLnInf, const SwRect &rRct, + sal_Int16 eHor, bool bLnNm ); + SwFont* GetFont() const { return m_pFnt.get(); } + void IncLineNr() { ++m_nLineNr; } + bool HasNumber() const { + assert( m_rLineInf.GetCountBy() != 0 ); + if( m_rLineInf.GetCountBy() == 0 ) + return false; + return !( m_nLineNr % static_cast(m_rLineInf.GetCountBy()) ); + } + bool HasDivider() const { + assert( m_rLineInf.GetDividerCountBy() != 0 ); + if( !m_nDivider || m_rLineInf.GetDividerCountBy() == 0 ) + return false; + return !(m_nLineNr % m_rLineInf.GetDividerCountBy()); + } + + void PaintExtra( SwTwips nY, tools::Long nAsc, tools::Long nMax, bool bRed, const OUString* pRedlineText = nullptr ); + void PaintRedline( SwTwips nY, tools::Long nMax ); +}; + +} + +SwExtraPainter::SwExtraPainter( const SwTextFrame *pFrame, SwViewShell *pVwSh, + const SwLineNumberInfo &rLnInf, const SwRect &rRct, + sal_Int16 eHor, bool bLineNum ) + : m_aClip( pVwSh->GetWin() || pFrame->IsUndersized() ? pVwSh->GetOut() : nullptr ) + , m_aRect( rRct ) + , m_pTextFrame( pFrame ) + , m_pSh( pVwSh ) + , m_rLineInf( rLnInf ) + , m_nX(0) + , m_nRedX(0) + , m_nLineNr( 1 ) + , m_nDivider(0) + , m_bGoLeft(false) +{ + if( pFrame->IsUndersized() ) + { + SwTwips nBottom = pFrame->getFrameArea().Bottom(); + if( m_aRect.Bottom() > nBottom ) + m_aRect.Bottom( nBottom ); + } + std::optional oIsRightPage; + { + /* Initializes the Members necessary for line numbering: + + nDivider, how often do we want a substring; 0 == never + nX, line number's x position + pFnt, line number's font + nLineNr, the first line number + bLineNum is set back to false if the numbering is completely + outside of the paint rect + */ + m_nDivider = !m_rLineInf.GetDivider().isEmpty() ? m_rLineInf.GetDividerCountBy() : 0; + m_nX = pFrame->getFrameArea().Left(); + SwCharFormat* pFormat = m_rLineInf.GetCharFormat( const_cast(pFrame->GetDoc().getIDocumentStylePoolAccess()) ); + OSL_ENSURE( pFormat, "PaintExtraData without CharFormat" ); + m_pFnt.reset( new SwFont(&pFormat->GetAttrSet(), &pFrame->GetDoc().getIDocumentSettingAccess()) ); + m_pFnt->Invalidate(); + m_pFnt->ChgPhysFnt( m_pSh, *m_pSh->GetOut() ); + m_pFnt->SetVertical( 0_deg10, pFrame->IsVertical() ); + } + + if( bLineNum ) + { + m_nLineNr += pFrame->GetAllLines() - pFrame->GetThisLines(); + LineNumberPosition ePos = m_rLineInf.GetPos(); + if( ePos != LINENUMBER_POS_LEFT && ePos != LINENUMBER_POS_RIGHT ) + { + if( pFrame->FindPageFrame()->OnRightPage() ) + { + oIsRightPage = true; + ePos = ePos == LINENUMBER_POS_INSIDE ? + LINENUMBER_POS_LEFT : LINENUMBER_POS_RIGHT; + } + else + { + oIsRightPage = false; + ePos = ePos == LINENUMBER_POS_OUTSIDE ? + LINENUMBER_POS_LEFT : LINENUMBER_POS_RIGHT; + } + } + if( LINENUMBER_POS_LEFT == ePos ) + { + m_bGoLeft = true; + m_nX -= m_rLineInf.GetPosFromLeft(); + } + else + { + m_bGoLeft = false; + m_nX += pFrame->getFrameArea().Width() + m_rLineInf.GetPosFromLeft(); + } + } + if( eHor == text::HoriOrientation::NONE ) + return; + + if( text::HoriOrientation::INSIDE == eHor || text::HoriOrientation::OUTSIDE == eHor ) + { + if (!oIsRightPage.has_value()) + oIsRightPage = pFrame->FindPageFrame()->OnRightPage(); + if (*oIsRightPage) + eHor = eHor == text::HoriOrientation::INSIDE ? text::HoriOrientation::LEFT : text::HoriOrientation::RIGHT; + else + eHor = eHor == text::HoriOrientation::OUTSIDE ? text::HoriOrientation::LEFT : text::HoriOrientation::RIGHT; + } + const SwFrame* pTmpFrame = pFrame->FindTabFrame(); + if( !pTmpFrame ) + pTmpFrame = pFrame; + m_nRedX = text::HoriOrientation::LEFT == eHor ? pTmpFrame->getFrameArea().Left() - REDLINE_DISTANCE : + pTmpFrame->getFrameArea().Right() + REDLINE_DISTANCE; +} + +void SwExtraPainter::PaintExtra( SwTwips nY, tools::Long nAsc, tools::Long nMax, bool bRed, const OUString* pRedlineText ) +{ + const OUString aTmp( pRedlineText + // Tracked change is stronger than the line number + ? *pRedlineText + : ( HasNumber() + // Line number is stronger than the divider + ? m_rLineInf.GetNumType().GetNumStr( m_nLineNr ) + : m_rLineInf.GetDivider() ) ); + + // Get script type of line numbering: + m_pFnt->SetActual( SwScriptInfo::WhichFont(0, aTmp) ); + + if ( pRedlineText ) + { + m_pFnt->SetColor(NON_PRINTING_CHARACTER_COLOR); + // don't strike out text in Insertions In Margin mode + if ( !m_pSh->GetViewOptions()->IsShowChangesInMargin2() ) + m_pFnt->SetStrikeout( STRIKEOUT_SINGLE ); + m_pFnt->SetSize( Size( 0, 200), m_pFnt->GetActual() ); + } + + SwDrawTextInfo aDrawInf( m_pSh, *m_pSh->GetOut(), aTmp, 0, aTmp.getLength() ); + aDrawInf.SetSpace( 0 ); + aDrawInf.SetWrong( nullptr ); + aDrawInf.SetGrammarCheck( nullptr ); + aDrawInf.SetSmartTags( nullptr ); + aDrawInf.SetFrame( m_pTextFrame ); + aDrawInf.SetFont( m_pFnt.get() ); + aDrawInf.SetSnapToGrid( false ); + aDrawInf.SetIgnoreFrameRTL( true ); + + bool bTooBig = m_pFnt->GetSize( m_pFnt->GetActual() ).Height() > nMax && + m_pFnt->GetHeight( m_pSh, *m_pSh->GetOut() ) > nMax; + SwFont* pTmpFnt; + if( bTooBig ) + { + pTmpFnt = new SwFont( *GetFont() ); + if( nMax >= 20 ) + { + nMax *= 17; + nMax /= 20; + } + pTmpFnt->SetSize( Size( 0, nMax ), pTmpFnt->GetActual() ); + } + else + pTmpFnt = GetFont(); + Point aTmpPos( m_nX, nY ); + aTmpPos.AdjustY(nAsc ); + if ( pRedlineText ) + { + Size aSize = pTmpFnt->GetTextSize_( aDrawInf ); + aTmpPos.AdjustX( -(aSize.Width()) - 200 ); + } + bool bPaint = true; + if( !IsClipChg() ) + { + Size aSize = pTmpFnt->GetTextSize_( aDrawInf ); + if( m_bGoLeft ) + aTmpPos.AdjustX( -(aSize.Width()) ); + // calculate rectangle containing the line number + SwRect aRct( Point( aTmpPos.X(), + aTmpPos.Y() - pTmpFnt->GetAscent( m_pSh, *m_pSh->GetOut() ) + ), aSize ); + if( !m_aRect.Contains( aRct ) ) + { + if( aRct.Intersection( m_aRect ).IsEmpty() ) + bPaint = false; + else + m_aClip.ChgClip( m_aRect, m_pTextFrame ); + } + } + else if( m_bGoLeft ) + aTmpPos.AdjustX( -(pTmpFnt->GetTextSize_( aDrawInf ).Width()) ); + aDrawInf.SetPos( aTmpPos ); + if( bPaint ) + pTmpFnt->DrawText_( aDrawInf ); + + if( bTooBig ) + delete pTmpFnt; + if( bRed ) + { + tools::Long nDiff = m_bGoLeft ? m_nRedX - m_nX : m_nX - m_nRedX; + if( nDiff > REDLINE_MINDIST ) + PaintRedline( nY, nMax ); + } +} + +void SwExtraPainter::PaintRedline( SwTwips nY, tools::Long nMax ) +{ + Point aStart( m_nRedX, nY ); + Point aEnd( m_nRedX, nY + nMax ); + + if( !IsClipChg() ) + { + SwRect aRct( aStart, aEnd ); + if( !m_aRect.Contains( aRct ) ) + { + if( aRct.Intersection( m_aRect ).IsEmpty() ) + return; + m_aClip.ChgClip( m_aRect, m_pTextFrame ); + } + } + const Color aOldCol( m_pSh->GetOut()->GetLineColor() ); + m_pSh->GetOut()->SetLineColor( SW_MOD()->GetRedlineMarkColor() ); + + if ( m_pTextFrame->IsVertical() ) + { + m_pTextFrame->SwitchHorizontalToVertical( aStart ); + m_pTextFrame->SwitchHorizontalToVertical( aEnd ); + } + + m_pSh->GetOut()->DrawLine( aStart, aEnd ); + m_pSh->GetOut()->SetLineColor( aOldCol ); +} + +void SwTextFrame::PaintExtraData( const SwRect &rRect ) const +{ + if( getFrameArea().Top() > rRect.Bottom() || getFrameArea().Bottom() < rRect.Top() ) + return; + + PaintOutlineContentVisibilityButton(); + + SwDoc const& rDoc(GetDoc()); + const IDocumentRedlineAccess& rIDRA = rDoc.getIDocumentRedlineAccess(); + const SwLineNumberInfo &rLineInf = rDoc.GetLineNumberInfo(); + const SwFormatLineNumber &rLineNum = GetAttrSet()->GetLineNumber(); + bool bLineNum = !IsInTab() && rLineInf.IsPaintLineNumbers() && + ( !IsInFly() || rLineInf.IsCountInFlys() ) && rLineNum.IsCount(); + sal_Int16 eHor = static_cast(SW_MOD()->GetRedlineMarkPos()); + if (eHor != text::HoriOrientation::NONE + && (!IDocumentRedlineAccess::IsShowChanges(rIDRA.GetRedlineFlags()) + || getRootFrame()->IsHideRedlines())) + { + eHor = text::HoriOrientation::NONE; + } + bool bRedLine = eHor != text::HoriOrientation::NONE; + if ( !bLineNum && !bRedLine ) + return; + + if( IsLocked() || IsHiddenNow() || !getFramePrintArea().Height() ) + return; + SwViewShell *pSh = getRootFrame()->GetCurrShell(); + + SwSwapIfNotSwapped swap(const_cast(this)); + SwRect rOldRect( rRect ); + + if ( IsVertical() ) + SwitchVerticalToHorizontal( const_cast(rRect) ); + + SwLayoutModeModifier aLayoutModeModifier( *pSh->GetOut() ); + aLayoutModeModifier.Modify( false ); + + // #i16816# tagged pdf support + SwTaggedPDFHelper aTaggedPDFHelper( nullptr, nullptr, nullptr, *pSh->GetOut() ); + + SwExtraPainter aExtra( this, pSh, rLineInf, rRect, eHor, bLineNum ); + + if( HasPara() ) + { + TextFrameLockGuard aLock(const_cast(this)); + + SwTextLineAccess aAccess( this ); + aAccess.GetPara(); + + SwTextPaintInfo aInf( const_cast(this), rRect ); + + aLayoutModeModifier.Modify( false ); + + SwTextPainter aLine( const_cast(this), &aInf ); + bool bNoDummy = !aLine.GetNext(); // Only one empty line! + + while( aLine.Y() + aLine.GetLineHeight() <= rRect.Top() ) + { + if( !aLine.GetCurr()->IsDummy() && + ( rLineInf.IsCountBlankLines() || + aLine.GetCurr()->HasContent() ) ) + aExtra.IncLineNr(); + if( !aLine.Next() ) + { + const_cast(rRect) = rOldRect; + return; + } + } + + tools::Long nBottom = rRect.Bottom(); + + bool bNoPrtLine = 0 == GetMinPrtLine(); + if( !bNoPrtLine ) + { + while ( aLine.Y() < GetMinPrtLine() ) + { + if( ( rLineInf.IsCountBlankLines() || aLine.GetCurr()->HasContent() ) + && !aLine.GetCurr()->IsDummy() ) + aExtra.IncLineNr(); + if( !aLine.Next() ) + break; + } + bNoPrtLine = aLine.Y() >= GetMinPrtLine(); + } + const bool bIsShowChangesInMargin = pSh->GetViewOptions()->IsShowChangesInMargin(); + if( bNoPrtLine ) + { + do + { + if( bNoDummy || !aLine.GetCurr()->IsDummy() ) + { + bool bRed = bRedLine && aLine.GetCurr()->HasRedline(); + if( rLineInf.IsCountBlankLines() || aLine.GetCurr()->HasContent() ) + { + bool bRedInMargin = bIsShowChangesInMargin && bRed; + bool bNum = bLineNum && ( aExtra.HasNumber() || aExtra.HasDivider() ); + if( bRedInMargin || bNum ) + { + SwTwips nTmpHeight, nTmpAscent; + aLine.CalcAscentAndHeight( nTmpAscent, nTmpHeight ); + if ( bRedInMargin ) + { + const OUString* pRedlineText = aLine.GetCurr()->GetRedlineText(); + if( !pRedlineText->isEmpty() ) + { + aExtra.PaintExtra( aLine.Y(), nTmpAscent, + nTmpHeight, bRed, pRedlineText ); + bRed = false; + bNum = false; + } + } + if ( bNum ) + { + aExtra.PaintExtra( aLine.Y(), nTmpAscent, nTmpHeight, bRed ); + bRed = false; + } + } + aExtra.IncLineNr(); + } + if( bRed ) + aExtra.PaintRedline( aLine.Y(), aLine.GetLineHeight() ); + } + } while( aLine.Next() && aLine.Y() <= nBottom ); + } + } + else + { + if (SwRedlineTable::npos == rIDRA.GetRedlinePos(*GetTextNodeFirst(), RedlineType::Any)) + { + bRedLine = false; + } + + if( bLineNum && rLineInf.IsCountBlankLines() && + ( aExtra.HasNumber() || aExtra.HasDivider() ) ) + { + aExtra.PaintExtra( getFrameArea().Top()+getFramePrintArea().Top(), aExtra.GetFont() + ->GetAscent( pSh, *pSh->GetOut() ), getFramePrintArea().Height(), bRedLine ); + } + else if( bRedLine ) + aExtra.PaintRedline( getFrameArea().Top()+getFramePrintArea().Top(), getFramePrintArea().Height() ); + } + + const_cast(rRect) = rOldRect; + +} + +SwRect SwTextFrame::GetPaintSwRect() +{ + // finger layout + OSL_ENSURE( isFrameAreaPositionValid(), "+SwTextFrame::GetPaintSwRect: no Calc()" ); + + SwRect aRet( getFramePrintArea() ); + if ( IsEmpty() || !HasPara() ) + aRet += getFrameArea().Pos(); + else + { + // We return the right paint rect. Use the calculated PaintOfst as the + // left margin + SwRepaint& rRepaint = GetPara()->GetRepaint(); + tools::Long l; + + if ( IsVertLR() && !IsVertLRBT()) // mba: the following line was added, but we don't need it for the existing directions; kept for IsVertLR(), but should be checked + rRepaint.Chg( GetUpper()->getFrameArea().Pos() + GetUpper()->getFramePrintArea().Pos(), GetUpper()->getFramePrintArea().SSize() ); + + if( rRepaint.GetOffset() ) + rRepaint.Left( rRepaint.GetOffset() ); + + l = rRepaint.GetRightOfst(); + if( l && l > rRepaint.Right() ) + rRepaint.Right( l ); + rRepaint.SetOffset( 0 ); + aRet = rRepaint; + + // In case our left edge is the same as the body frame's left edge, + // then extend the rectangle to include the page margin as well, + // otherwise some font will be clipped. + SwLayoutFrame* pBodyFrame = GetUpper(); + if (pBodyFrame->IsBodyFrame() && aRet.Left() == (pBodyFrame->getFrameArea().Left() + pBodyFrame->getFramePrintArea().Left())) + if (SwLayoutFrame* pPageFrame = pBodyFrame->GetUpper()) + aRet.Left(pPageFrame->getFrameArea().Left()); + + if ( IsRightToLeft() ) + SwitchLTRtoRTL( aRet ); + + if ( IsVertical() ) + SwitchHorizontalToVertical( aRet ); + } + ResetRepaint(); + + return aRet; +} + +bool SwTextFrame::PaintEmpty( const SwRect &rRect, bool bCheck ) const +{ + PaintParagraphStylesHighlighting(); + + SwViewShell *pSh = getRootFrame()->GetCurrShell(); + if( pSh && ( pSh->GetViewOptions()->IsParagraph() || bInitFont ) ) + { + bInitFont = false; + SwTextFly aTextFly( this ); + aTextFly.SetTopRule(); + SwRect aRect; + if( bCheck && aTextFly.IsOn() && aTextFly.IsAnyObj( aRect ) ) + return false; + else if( pSh->GetWin() ) + { + std::unique_ptr pFnt; + RedlineType eRedline = RedlineType::None; + const SwTextNode& rTextNode = *GetTextNodeForParaProps(); + if ( rTextNode.HasSwAttrSet() ) + { + const SwAttrSet *pAttrSet = &( rTextNode.GetSwAttrSet() ); + pFnt.reset(new SwFont( pAttrSet, rTextNode.getIDocumentSettingAccess() )); + } + else + { + SwFontAccess aFontAccess( &rTextNode.GetAnyFormatColl(), pSh ); + pFnt.reset(new SwFont( aFontAccess.Get()->GetFont() )); + } + + const IDocumentRedlineAccess& rIDRA = rTextNode.getIDocumentRedlineAccess(); + if (IDocumentRedlineAccess::IsShowChanges(rIDRA.GetRedlineFlags()) + && !getRootFrame()->IsHideRedlines()) + { + const SwRedlineTable::size_type nRedlPos = rIDRA.GetRedlinePos( rTextNode, RedlineType::Any ); + if( SwRedlineTable::npos != nRedlPos ) + { + SwAttrHandler aAttrHandler; + aAttrHandler.Init( rTextNode.GetSwAttrSet(), + *rTextNode.getIDocumentSettingAccess() ); + SwRedlineItr aRedln(rTextNode, *pFnt, aAttrHandler, nRedlPos, SwRedlineItr::Mode::Show); + const SwRangeRedline* pRedline = rIDRA.GetRedlineTable()[nRedlPos]; + // show redlining only on the inserted/deleted empty paragraph, but not on the next one + if ( rTextNode.GetIndex() != pRedline->End()->GetNodeIndex() ) + eRedline = pRedline->GetType(); + // except if the next empty paragraph starts a new redline (e.g. deletion after insertion) + else if ( nRedlPos + 1 < rIDRA.GetRedlineTable().size() ) + { + const SwRangeRedline* pNextRedline = rIDRA.GetRedlineTable()[nRedlPos + 1]; + if ( rTextNode.GetIndex() == pNextRedline->Start()->GetNodeIndex() ) + eRedline = pNextRedline->GetType(); + } + } + } + + if( pSh->GetViewOptions()->IsParagraph() && getFramePrintArea().Height() ) + { + if( RTL_TEXTENCODING_SYMBOL == pFnt->GetCharSet( SwFontScript::Latin ) && + pFnt->GetName( SwFontScript::Latin ) != numfunc::GetDefBulletFontname() ) + { + pFnt->SetFamily( FAMILY_DONTKNOW, SwFontScript::Latin ); + pFnt->SetName( numfunc::GetDefBulletFontname(), SwFontScript::Latin ); + pFnt->SetStyleName(OUString(), SwFontScript::Latin); + pFnt->SetCharSet( RTL_TEXTENCODING_SYMBOL, SwFontScript::Latin ); + } + pFnt->SetVertical( 0_deg10, IsVertical() ); + SwFrameSwapper aSwapper( this, true ); + SwLayoutModeModifier aLayoutModeModifier( *pSh->GetOut() ); + aLayoutModeModifier.Modify( IsRightToLeft() ); + + pFnt->Invalidate(); + pFnt->ChgPhysFnt( pSh, *pSh->GetOut() ); + Point aPos = getFrameArea().Pos() + getFramePrintArea().Pos(); + + const SvxFirstLineIndentItem& rFirstLine( + GetTextNodeForParaProps()->GetSwAttrSet().GetFirstLineIndent()); + + if (0 < rFirstLine.GetTextFirstLineOffset()) + { + aPos.AdjustX(rFirstLine.GetTextFirstLineOffset()); + } + + std::unique_ptr> xClip; + if( IsUndersized() ) + { + xClip.reset(new SwSaveClip( pSh->GetOut() )); + xClip->ChgClip( rRect ); + } + + aPos.AdjustY(pFnt->GetAscent( pSh, *pSh->GetOut() ) ); + + if (GetTextNodeForParaProps()->GetSwAttrSet().GetParaGrid().GetValue() && + IsInDocBody() ) + { + SwTextGridItem const*const pGrid(GetGridItem(FindPageFrame())); + if ( pGrid ) + { + // center character in grid line + aPos.AdjustY(( pGrid->GetBaseHeight() - + pFnt->GetHeight( pSh, *pSh->GetOut() ) ) / 2 ); + + if ( ! pGrid->GetRubyTextBelow() ) + aPos.AdjustY(pGrid->GetRubyHeight() ); + } + } + + // Don't show the paragraph mark for collapsed paragraphs, when they are hidden + // No paragraph marker in the non-last part of a split fly anchor, either. + if ( EmptyHeight( ) > 1 && !HasNonLastSplitFlyDrawObj() ) + { + SwDrawTextInfo aDrawInf( pSh, *pSh->GetOut(), CH_PAR, 0, 1 ); + aDrawInf.SetPos( aPos ); + aDrawInf.SetSpace( 0 ); + aDrawInf.SetKanaComp( 0 ); + aDrawInf.SetWrong( nullptr ); + aDrawInf.SetGrammarCheck( nullptr ); + aDrawInf.SetSmartTags( nullptr ); + aDrawInf.SetFrame( this ); + aDrawInf.SetFont( pFnt.get() ); + aDrawInf.SetSnapToGrid( false ); + + // show redline color and settings drawing a background pilcrow, + // but keep also other formattings (with neutral pilcrow color) + if ( eRedline != RedlineType::None ) + { + pFnt->DrawText_( aDrawInf ); + if ( eRedline == RedlineType::Delete ) + pFnt->SetStrikeout( STRIKEOUT_NONE ); + else + pFnt->SetUnderline( LINESTYLE_NONE ); + } + + pFnt->SetColor(NON_PRINTING_CHARACTER_COLOR); + pFnt->DrawText_( aDrawInf ); + } + } + return true; + } + } + else + return true; + return false; +} + +void SwTextFrame::PaintSwFrame(vcl::RenderContext& rRenderContext, SwRect const& rRect, SwPrintData const*const) const +{ + ResetRepaint(); + + // #i16816# tagged pdf support + SwViewShell *pSh = getRootFrame()->GetCurrShell(); + + if( IsEmpty() && PaintEmpty( rRect, true ) ) + return; + + if( IsLocked() || IsHiddenNow() || ! getFramePrintArea().HasArea() ) + return; + + // It can happen that the IdleCollector withdrew my cached information + if( !HasPara() ) + { + OSL_ENSURE( isFrameAreaPositionValid(), "+SwTextFrame::PaintSwFrame: no Calc()" ); + + // #i29062# pass info that we are currently + // painting. + const_cast(this)->GetFormatted( true ); + if( IsEmpty() ) + { + PaintEmpty( rRect, false ); + return; + } + if( !HasPara() ) + { + OSL_ENSURE( false, "+SwTextFrame::PaintSwFrame: missing format information" ); + return; + } + } + + // tdf140219-2.odt text frame with only fly portions and a follow is not + // actually a paragraph - delay creating all structured elements to follow. + bool const isPDFTaggingEnabled(!HasFollow() || GetPara()->HasContentPortions()); + ::std::optional oTaggedPDFHelperNumbering; + if (isPDFTaggingEnabled) + { + Num_Info aNumInfo(*this); + oTaggedPDFHelperNumbering.emplace(&aNumInfo, nullptr, nullptr, rRenderContext); + } + + // Lbl unfortunately must be able to contain multiple numbering portions + // that may be on multiple lines of text (but apparently always in the + // master frame), so it gets complicated. + ::std::optional oTaggedLabel; + // Paragraph tag - if there is a list label, opening should be delayed. + ::std::optional oTaggedParagraph; + + if (isPDFTaggingEnabled + && (GetTextNodeForParaProps()->IsOutline() + || !GetPara()->HasNumberingPortion(SwParaPortion::FootnoteToo))) + { // no Lbl needed => open paragraph tag now + Frame_Info aFrameInfo(*this, false); + oTaggedParagraph.emplace(nullptr, &aFrameInfo, nullptr, rRenderContext); + } + + // We don't want to be interrupted while painting. + // Do that after thr Format()! + TextFrameLockGuard aLock(const_cast(this)); + + // We only paint the part of the TextFrame which changed, is within the + // range and was requested to paint. + // One could think that the area rRect _needs_ to be painted, although + // rRepaint is set. Indeed, we cannot avoid this problem from a formal + // perspective. Luckily we can assume rRepaint to be empty when we need + // paint the while Frame. + SwTextLineAccess aAccess( this ); + SwParaPortion *pPara = aAccess.GetPara(); + + SwRepaint &rRepaint = pPara->GetRepaint(); + + // Switch off recycling when in the FlyContentFrame. + // A DrawRect is called for repainting the line anyways. + if( rRepaint.GetOffset() ) + { + const SwFlyFrame *pFly = FindFlyFrame(); + if( pFly && pFly->IsFlyInContentFrame() ) + rRepaint.SetOffset( 0 ); + } + + // Ge the String for painting. The length is of special interest. + + // Rectangle + OSL_ENSURE( ! IsSwapped(), "A frame is swapped before Paint" ); + SwRect aOldRect( rRect ); + + { + SwSwapIfNotSwapped swap(const_cast(this)); + + if ( IsVertical() ) + SwitchVerticalToHorizontal( const_cast(rRect) ); + + if ( IsRightToLeft() ) + SwitchRTLtoLTR( const_cast(rRect) ); + + SwTextPaintInfo aInf( const_cast(this), rRect ); + sw::WrongListIterator iterWrong(*this, &SwTextNode::GetWrong); + sw::WrongListIterator iterGrammar(*this, &SwTextNode::GetGrammarCheck); + sw::WrongListIterator iterSmartTags(*this, &SwTextNode::GetSmartTags); + if (iterWrong.LooksUseful()) + { + aInf.SetWrongList( &iterWrong ); + } + if (iterGrammar.LooksUseful()) + { + aInf.SetGrammarCheckList( &iterGrammar ); + } + if (iterSmartTags.LooksUseful()) + { + aInf.SetSmartTags( &iterSmartTags ); + } + aInf.GetTextFly().SetTopRule(); + + SwTextPainter aLine( const_cast(this), &aInf ); + // Optimization: if no free flying Frame overlaps into our line, the + // SwTextFly just switches off + aInf.GetTextFly().Relax(); + + OutputDevice* pOut = aInf.GetOut(); + const bool bOnWin = pSh->GetWin() != nullptr; + + SwSaveClip aClip( bOnWin || IsUndersized() ? pOut : nullptr ); + + // Output loop: For each Line ... (which is still visible) ... + // adapt rRect (Top + 1, Bottom - 1) + // Because the Iterator attaches the Lines without a gap to each other + aLine.TwipsToLine( rRect.Top() + 1 ); + tools::Long nBottom = rRect.Bottom(); + + bool bNoPrtLine = 0 == GetMinPrtLine(); + if( !bNoPrtLine ) + { + while ( aLine.Y() < GetMinPrtLine() && aLine.Next() ) + ; + bNoPrtLine = aLine.Y() >= GetMinPrtLine(); + } + if( bNoPrtLine ) + { + do + { + aLine.DrawTextLine(rRect, aClip, IsUndersized(), oTaggedLabel, oTaggedParagraph, isPDFTaggingEnabled); + + } while( aLine.Next() && aLine.Y() <= nBottom ); + } + + // Once is enough: + if( aLine.IsPaintDrop() ) + aLine.PaintDropPortion(); + + if( rRepaint.HasArea() ) + rRepaint.Clear(); + } + + PaintParagraphStylesHighlighting(); + + const_cast(rRect) = aOldRect; + + OSL_ENSURE( ! IsSwapped(), "A frame is swapped after Paint" ); + + assert(!oTaggedLabel); // must have been closed if opened + assert(!isPDFTaggingEnabled || oTaggedParagraph || rRect.GetIntersection(getFrameArea()) != getFrameArea()); // must have been created during complete paint (PDF export is always complete paint) +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/guess.cxx b/sw/source/core/text/guess.cxx new file mode 100644 index 0000000000..3346fe345a --- /dev/null +++ b/sw/source/core/text/guess.cxx @@ -0,0 +1,761 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include +#include +#include "guess.hxx" +#include "inftxt.hxx" +#include +#include +#include +#include +#include +#include +#include +#include "porfld.hxx" +#include +#include +#include + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::i18n; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::linguistic2; + +namespace{ + +bool IsBlank(sal_Unicode ch) { return ch == CH_BLANK || ch == CH_FULL_BLANK || ch == CH_NB_SPACE || ch == CH_SIX_PER_EM; } + +// Used when spaces should not be counted in layout +// Returns adjusted cut position +TextFrameIndex AdjustCutPos(TextFrameIndex cutPos, TextFrameIndex& rBreakPos, + const SwTextFormatInfo& rInf) +{ + assert(cutPos >= rInf.GetIdx()); + TextFrameIndex x = rBreakPos = cutPos; + + // we step back until a non blank character has been found + // or there is only one more character left + while (x && x > rInf.GetIdx() + TextFrameIndex(1) && IsBlank(rInf.GetChar(--x))) + --rBreakPos; + + while (IsBlank(rInf.GetChar(cutPos))) + ++cutPos; + + return cutPos; +} + +bool hasBlanksInLine(const SwTextFormatInfo& rInf, TextFrameIndex end) +{ + for (auto x = rInf.GetLineStart(); x < end; ++x) + if (IsBlank(rInf.GetChar(x))) + return true; + return false; +} + +// Called for the last text run in a line; if it is block-adjusted, or center / right-adjusted +// with Word compatibility option set, and it has trailing spaces, then the function sets the +// values, and returns 'false' value that SwTextGuess::Guess should return, to create a +// trailing SwHolePortion. +bool maybeAdjustPositionsForBlockAdjust(TextFrameIndex& rCutPos, TextFrameIndex& rBreakPos, + TextFrameIndex& rBreakStart, sal_uInt16& rBreakWidth, + sal_uInt16& rExtraBlankWidth, sal_uInt16& rMaxSizeDiff, + const SwTextFormatInfo& rInf, const SwScriptInfo& rSI, + sal_uInt16 maxComp) +{ + const auto& adjObj = rInf.GetTextFrame()->GetTextNodeForParaProps()->GetSwAttrSet().GetAdjust(); + const SvxAdjust& adjust = adjObj.GetAdjust(); + if (adjust == SvxAdjust::Block) + { + if (rInf.DontBlockJustify()) + return true; // See tdf#106234 + } + else + { + // tdf#104668 space chars at the end should be cut if the compatibility option is enabled + if (!rInf.GetTextFrame()->GetDoc().getIDocumentSettingAccess().get( + DocumentSettingId::MS_WORD_COMP_TRAILING_BLANKS)) + return true; + // for LTR mode only + if (rInf.GetTextFrame()->IsRightToLeft()) + return true; + } + if (auto ch = rInf.GetChar(rCutPos); !ch) // end of paragraph - last line + { + if (adjust == SvxAdjust::Block) + { + // Check adjustment for last line + switch (adjObj.GetLastBlock()) + { + default: + return true; + case SvxAdjust::Center: // tdf#104668 + if (!rInf.GetTextFrame()->GetDoc().getIDocumentSettingAccess().get( + DocumentSettingId::MS_WORD_COMP_TRAILING_BLANKS)) + return true; + break; + case SvxAdjust::Block: + break; // OK - last line uses block-adjustment + } + } + } + else if (ch != CH_BREAK && !IsBlank(ch)) + return true; + + // tdf#57187: block-adjusted line shorter than full width, terminated by manual + // line break, must not use trailing spaces for adjustment + TextFrameIndex breakPos; + TextFrameIndex newCutPos = AdjustCutPos(rCutPos, breakPos, rInf); + + if (auto ch = rInf.GetChar(newCutPos); ch && ch != CH_BREAK) + return true; // next is neither line break nor paragraph end + if (breakPos == newCutPos) + return true; // no trailing whitespace + if (adjust == SvxAdjust::Block && adjObj.GetOneWord() != SvxAdjust::Block + && !hasBlanksInLine(rInf, breakPos)) + return true; // line can't block-adjust + + // Some trailing spaces actually found, and in case of block adjustment, the text portion + // itself has spaces to be able to block-adjust, or single word is allowed to adjust + rBreakStart = rCutPos = newCutPos; + rBreakPos = breakPos; + + rInf.GetTextSize(&rSI, rInf.GetIdx(), breakPos - rInf.GetIdx(), maxComp, rBreakWidth, + rMaxSizeDiff, rInf.GetCachedVclData().get()); + rInf.GetTextSize(&rSI, breakPos, rBreakStart - breakPos, maxComp, rExtraBlankWidth, + rMaxSizeDiff, rInf.GetCachedVclData().get()); + + return false; // require SwHolePortion creation +} + +} + +// provides information for line break calculation +// returns true if no line break has to be performed +// otherwise possible break or hyphenation position is determined +bool SwTextGuess::Guess( const SwTextPortion& rPor, SwTextFormatInfo &rInf, + const sal_uInt16 nPorHeight, sal_Int32 nSpacesInLine ) +{ + m_nCutPos = rInf.GetIdx(); + + // Empty strings are always 0 + if( !rInf.GetLen() || rInf.GetText().isEmpty() ) + return false; + + OSL_ENSURE( rInf.GetIdx() < TextFrameIndex(rInf.GetText().getLength()), + "+SwTextGuess::Guess: invalid SwTextFormatInfo" ); + + OSL_ENSURE( nPorHeight, "+SwTextGuess::Guess: no height" ); + + sal_uInt16 nMaxSizeDiff; + + const SwScriptInfo& rSI = rInf.GetParaPortion()->GetScriptInfo(); + + sal_uInt16 nMaxComp = ( SwFontScript::CJK == rInf.GetFont()->GetActual() ) && + rSI.CountCompChg() && + ! rInf.IsMulti() && + ! rPor.InFieldGrp() && + ! rPor.IsDropPortion() ? + 10000 : + 0 ; + + SwTwips nLineWidth = rInf.GetLineWidth(); + TextFrameIndex nMaxLen = TextFrameIndex(rInf.GetText().getLength()) - rInf.GetIdx(); + + const SvxAdjust& rAdjust = rInf.GetTextFrame()->GetTextNodeForParaProps()->GetSwAttrSet().GetAdjust().GetAdjust(); + + // allow up to 20% shrinking of the spaces + if ( nSpacesInLine ) + { + static constexpr OUStringLiteral STR_BLANK = u" "; + sal_Int16 nSpaceWidth = rInf.GetTextSize(STR_BLANK).Width(); + nLineWidth += nSpacesInLine * (nSpaceWidth/0.8 - nSpaceWidth); + } + + if ( rInf.GetLen() < nMaxLen ) + nMaxLen = rInf.GetLen(); + + if( !nMaxLen ) + return false; + + sal_uInt16 nItalic = 0; + if( ITALIC_NONE != rInf.GetFont()->GetItalic() && !rInf.NotEOL() ) + { + bool bAddItalic = true; + + // do not add extra italic value if we have an active character grid + if ( rInf.SnapToGrid() ) + { + SwTextGridItem const*const pGrid( + GetGridItem(rInf.GetTextFrame()->FindPageFrame())); + bAddItalic = !pGrid || GRID_LINES_CHARS != pGrid->GetGridType(); + } + + // do not add extra italic value for an isolated blank: + if (TextFrameIndex(1) == rInf.GetLen() && + CH_BLANK == rInf.GetText()[sal_Int32(rInf.GetIdx())]) + { + bAddItalic = false; + } + + if (rInf.GetTextFrame()->GetDoc().getIDocumentSettingAccess().get( + DocumentSettingId::TAB_OVER_MARGIN)) + { + // Content is allowed over the margin: in this case over-margin content caused by italic + // formatting is OK. + bAddItalic = false; + } + + nItalic = bAddItalic ? nPorHeight / 12 : 0; + + nLineWidth -= nItalic; + + // #i46524# LineBreak bug with italics + if ( nLineWidth < 0 ) nLineWidth = 0; + } + + const sal_Int32 nLeftRightBorderSpace = + (!rPor.GetJoinBorderWithNext() ? rInf.GetFont()->GetRightBorderSpace() : 0) + + (!rPor.GetJoinBorderWithPrev() ? rInf.GetFont()->GetLeftBorderSpace() : 0); + + nLineWidth -= nLeftRightBorderSpace; + + const bool bUnbreakableNumberings = rInf.GetTextFrame()->GetDoc() + .getIDocumentSettingAccess().get(DocumentSettingId::UNBREAKABLE_NUMBERINGS); + + // first check if everything fits to line + if ( ( nLineWidth * 2 > SwTwips(sal_Int32(nMaxLen)) * nPorHeight ) || + ( bUnbreakableNumberings && rPor.IsNumberPortion() ) ) + { + // call GetTextSize with maximum compression (for kanas) + rInf.GetTextSize( &rSI, rInf.GetIdx(), nMaxLen, + nMaxComp, m_nBreakWidth, nMaxSizeDiff ); + + if ( ( m_nBreakWidth <= nLineWidth ) || ( bUnbreakableNumberings && rPor.IsNumberPortion() ) ) + { + // portion fits to line + m_nCutPos = rInf.GetIdx() + nMaxLen; + bool bRet = rPor.InFieldGrp() + || maybeAdjustPositionsForBlockAdjust(m_nCutPos, m_nBreakPos, m_nBreakStart, + m_nBreakWidth, m_nExtraBlankWidth, + nMaxSizeDiff, rInf, rSI, nMaxComp); + if( nItalic && + (m_nCutPos >= TextFrameIndex(rInf.GetText().getLength()) || + // #i48035# Needed for CalcFitToContent + // if first line ends with a manual line break + rInf.GetText()[sal_Int32(m_nCutPos)] == CH_BREAK)) + m_nBreakWidth += nItalic; + + // save maximum width for later use + if ( nMaxSizeDiff ) + rInf.SetMaxWidthDiff( &rPor, nMaxSizeDiff ); + + m_nBreakWidth += nLeftRightBorderSpace; + + return bRet; + } + } + + bool bHyph = rInf.IsHyphenate() && !rInf.IsHyphForbud(); + TextFrameIndex nHyphPos(0); + + // nCutPos is the first character not fitting to the current line + // nHyphPos is the first character not fitting to the current line, + // considering an additional "-" for hyphenation + if( bHyph ) + { + // nHyphZone is the first character not fitting in the hyphenation zone, + // or 0, if the whole line in the hyphenation zone, + // or -1, if no hyphenation zone defined (i.e. it is 0) + sal_Int32 nHyphZone = -1; + const css::beans::PropertyValues & rHyphValues = rInf.GetHyphValues(); + assert( rHyphValues.getLength() > 5 && rHyphValues[5].Name == UPN_HYPH_ZONE ); + // hyphenation zone (distance from the line end in twips) + sal_uInt16 nTextHyphenZone; + if ( rHyphValues[5].Value >>= nTextHyphenZone ) + nHyphZone = nTextHyphenZone >= nLineWidth + ? 0 + : sal_Int32(rInf.GetTextBreak( nLineWidth - nTextHyphenZone, + nMaxLen, nMaxComp, rInf.GetCachedVclData().get() )); + + m_nCutPos = rInf.GetTextBreak( nLineWidth, nMaxLen, nMaxComp, nHyphPos, rInf.GetCachedVclData().get() ); + + // don't try to hyphenate in the hyphenation zone + if ( nHyphZone != -1 && TextFrameIndex(COMPLETE_STRING) != m_nCutPos ) + { + sal_Int32 nZonePos = sal_Int32(m_nCutPos); + // disable hyphenation, if there is a space within the hyphenation zone + // Note: for better interoperability, not fitting space character at + // rInf.GetIdx()[nHyphZone] always disables the hyphenation, don't need to calculate + // with its fitting part. Moreover, do not check double or more spaces there, they + // are accepted outside of the hyphenation zone, too. + for (; sal_Int32(rInf.GetIdx()) <= nZonePos && nHyphZone <= nZonePos; --nZonePos ) + { + sal_Unicode cChar = rInf.GetText()[nZonePos]; + if ( cChar == CH_BLANK || cChar == CH_FULL_BLANK || cChar == CH_SIX_PER_EM ) + { + bHyph = false; + } + } + } + + if (!rInf.GetTextFrame()->GetDoc().getIDocumentSettingAccess().get( + DocumentSettingId::HYPHENATE_URLS)) + { + // check URL from preceding space - similar to what AutoFormat does + const CharClass& rCC = GetAppCharClass(); + sal_Int32 begin(m_nCutPos == TextFrameIndex(COMPLETE_STRING) ? rInf.GetText().getLength() : sal_Int32(m_nCutPos)); + sal_Int32 end(begin); + for (; 0 < begin; --begin) + { + sal_Unicode cChar = rInf.GetText()[begin - 1]; + if (cChar == CH_BLANK || cChar == CH_FULL_BLANK || cChar == CH_SIX_PER_EM) + { + break; + } + } + for (; end < rInf.GetText().getLength(); ++end) + { + sal_Unicode cChar = rInf.GetText()[end]; + if (cChar == CH_BLANK || cChar == CH_FULL_BLANK || cChar == CH_SIX_PER_EM) + { + break; + } + } + if (!URIHelper::FindFirstURLInText(rInf.GetText(), begin, end, rCC).isEmpty()) + { + bHyph = false; + } + } + + // search start of the last word, if needed + if ( bHyph ) + { + // nLastWord is the space character before the last word + sal_Int32 nLastWord = rInf.GetText().getLength() - 1; + bool bHyphenationNoLastWord = false; + assert( rHyphValues.getLength() > 3 && rHyphValues[3].Name == UPN_HYPH_NO_LAST_WORD ); + if ( rHyphValues[3].Value >>= bHyphenationNoLastWord ) + { + // skip spaces after the last word + bool bCutBlank = false; + for (; sal_Int32(rInf.GetIdx()) <= nLastWord; --nLastWord ) + { + sal_Unicode cChar = rInf.GetText()[nLastWord]; + if ( cChar != CH_BLANK && cChar != CH_FULL_BLANK && cChar != CH_SIX_PER_EM ) + bCutBlank = true; + else if ( bCutBlank ) + break; + } + } + + // don't hyphenate the last word of the paragraph + if ( bHyphenationNoLastWord && sal_Int32(m_nCutPos) > nLastWord && + TextFrameIndex(COMPLETE_STRING) != m_nCutPos && + // if the last word is multiple line long, e.g. an URL, + // apply this only if the space before the word is there + // in the actual line, i.e. start the long word in a new + // line, but still allows to break its last parts + sal_Int32(rInf.GetIdx()) < nLastWord ) + { + m_nCutPos = TextFrameIndex(nLastWord); + } + } + + if ( !nHyphPos && rInf.GetIdx() ) + nHyphPos = rInf.GetIdx() - TextFrameIndex(1); + } + else + { + m_nCutPos = rInf.GetTextBreak( nLineWidth, nMaxLen, nMaxComp, rInf.GetCachedVclData().get() ); + +#if OSL_DEBUG_LEVEL > 1 + if ( TextFrameIndex(COMPLETE_STRING) != m_nCutPos ) + { + sal_uInt16 nMinSize; + rInf.GetTextSize( &rSI, rInf.GetIdx(), m_nCutPos - rInf.GetIdx(), + nMaxComp, nMinSize, nMaxSizeDiff ); + OSL_ENSURE( nMinSize <= nLineWidth, "What a Guess!!!" ); + } +#endif + } + + if( m_nCutPos > rInf.GetIdx() + nMaxLen ) + { + // second check if everything fits to line + m_nCutPos = m_nBreakPos = rInf.GetIdx() + nMaxLen - TextFrameIndex(1); + rInf.GetTextSize( &rSI, rInf.GetIdx(), nMaxLen, nMaxComp, + m_nBreakWidth, nMaxSizeDiff ); + + // The following comparison should always give true, otherwise + // there likely has been a pixel rounding error in GetTextBreak + if ( m_nBreakWidth <= nLineWidth ) + { + bool bRet = rPor.InFieldGrp() + || maybeAdjustPositionsForBlockAdjust(m_nCutPos, m_nBreakPos, m_nBreakStart, + m_nBreakWidth, m_nExtraBlankWidth, + nMaxSizeDiff, rInf, rSI, nMaxComp); + + if (nItalic && (m_nBreakPos + TextFrameIndex(1)) >= TextFrameIndex(rInf.GetText().getLength())) + m_nBreakWidth += nItalic; + + // save maximum width for later use + if ( nMaxSizeDiff ) + rInf.SetMaxWidthDiff( &rPor, nMaxSizeDiff ); + + m_nBreakWidth += nLeftRightBorderSpace; + + return bRet; + } + } + + // we have to trigger an underflow for a footnote portion + // which does not fit to the current line + if ( rPor.IsFootnotePortion() ) + { + m_nBreakPos = rInf.GetIdx(); + m_nCutPos = TextFrameIndex(-1); + return false; + } + + TextFrameIndex nPorLen(0); + // do not call the break iterator nCutPos is a blank + sal_Unicode cCutChar = rInf.GetChar(m_nCutPos); + if (IsBlank(cCutChar)) + { + m_nCutPos = m_nBreakStart = AdjustCutPos(m_nCutPos, m_nBreakPos, rInf); + nPorLen = m_nBreakPos - rInf.GetIdx(); + } + else + { + // New: We should have a look into the last portion, if it was a + // field portion. For this, we expand the text of the field portion + // into our string. If the line break position is inside of before + // the field portion, we trigger an underflow. + + TextFrameIndex nOldIdx = rInf.GetIdx(); + sal_Unicode cFieldChr = 0; + +#if OSL_DEBUG_LEVEL > 0 + OUString aDebugString; +#endif + + // be careful: a field portion can be both: 0x01 (common field) + // or 0x02 (the follow of a footnode) + if ( rInf.GetLast() && rInf.GetLast()->InFieldGrp() && + ! rInf.GetLast()->IsFootnotePortion() && + rInf.GetIdx() > rInf.GetLineStart() && + CH_TXTATR_BREAKWORD == + (cFieldChr = rInf.GetText()[sal_Int32(rInf.GetIdx()) - 1])) + { + SwFieldPortion* pField = static_cast(rInf.GetLast()); + OUString aText; + pField->GetExpText( rInf, aText ); + + if ( !aText.isEmpty() ) + { + m_nFieldDiff = TextFrameIndex(aText.getLength() - 1); + m_nCutPos = m_nCutPos + m_nFieldDiff; + nHyphPos = nHyphPos + m_nFieldDiff; + +#if OSL_DEBUG_LEVEL > 0 + aDebugString = rInf.GetText(); +#endif + + // this is pretty nutso... reverted at the end... + OUString& rOldText = const_cast (rInf.GetText()); + rOldText = rOldText.replaceAt(sal_Int32(rInf.GetIdx()) - 1, 1, aText); + rInf.SetIdx( rInf.GetIdx() + m_nFieldDiff ); + } + else + cFieldChr = 0; + } + + LineBreakHyphenationOptions aHyphOpt; + Reference< XHyphenator > xHyph; + if( bHyph ) + { + xHyph = ::GetHyphenator(); + aHyphOpt = LineBreakHyphenationOptions( xHyph, + rInf.GetHyphValues(), sal_Int32(nHyphPos)); + } + + // Get Language for break iterator. + // We have to switch the current language if we have a script + // change at nCutPos. Otherwise LATIN punctuation would never + // be allowed to be hanging punctuation. + // NEVER call GetLang if the string has been modified!!! + LanguageType aLang = rInf.GetFont()->GetLanguage(); + + // If we are inside a field portion, we use a temporary string which + // differs from the string at the textnode. Therefore we are not allowed + // to call the GetLang function. + if ( m_nCutPos && ! rPor.InFieldGrp() ) + { + const CharClass& rCC = GetAppCharClass(); + + // step back until a non-punctuation character is reached + TextFrameIndex nLangIndex = m_nCutPos; + + // If a field has been expanded right in front of us we do not + // step further than the beginning of the expanded field + // (which is the position of the field placeholder in our + // original string). + const TextFrameIndex nDoNotStepOver = CH_TXTATR_BREAKWORD == cFieldChr + ? rInf.GetIdx() - m_nFieldDiff - TextFrameIndex(1) + : TextFrameIndex(0); + + if ( nLangIndex > nDoNotStepOver && + TextFrameIndex(rInf.GetText().getLength()) == nLangIndex) + --nLangIndex; + + while ( nLangIndex > nDoNotStepOver && + !rCC.isLetterNumeric(rInf.GetText(), sal_Int32(nLangIndex))) + --nLangIndex; + + // last "real" character is not inside our current portion + // we have to check the script type of the last "real" character + if ( nLangIndex < rInf.GetIdx() ) + { + sal_uInt16 nScript = g_pBreakIt->GetRealScriptOfText( rInf.GetText(), + sal_Int32(nLangIndex)); + OSL_ENSURE( nScript, "Script is not between 1 and 4" ); + + // compare current script with script from last "real" character + if ( SwFontScript(nScript - 1) != rInf.GetFont()->GetActual() ) + { + aLang = rInf.GetTextFrame()->GetLangOfChar( + CH_TXTATR_BREAKWORD == cFieldChr + ? nDoNotStepOver + : nLangIndex, + nScript, true); + } + } + } + + const ForbiddenCharacters aForbidden( + *rInf.GetTextFrame()->GetDoc().getIDocumentSettingAccess().getForbiddenCharacters(aLang, true)); + + const bool bAllowHanging = rInf.IsHanging() && ! rInf.IsMulti() && + ! rInf.GetTextFrame()->IsInTab() && + ! rPor.InFieldGrp(); + + LineBreakUserOptions aUserOpt( + aForbidden.beginLine, aForbidden.endLine, + rInf.HasForbiddenChars(), bAllowHanging, false ); + + // !!! We must have a local copy of the locale, because inside + // getLineBreak the LinguEventListener can trigger a new formatting, + // which can corrupt the locale pointer inside pBreakIt. + const lang::Locale aLocale = g_pBreakIt->GetLocale( aLang ); + + // determines first possible line break from nCutPos to + // start index of current line + LineBreakResults aResult = g_pBreakIt->GetBreakIter()->getLineBreak( + rInf.GetText(), sal_Int32(m_nCutPos), aLocale, + sal_Int32(rInf.GetLineStart()), aHyphOpt, aUserOpt ); + + m_nBreakPos = TextFrameIndex(aResult.breakIndex); + + // if we are formatting multi portions we want to allow line breaks + // at the border between single line and multi line portion + // we have to be careful with footnote portions, they always come in + // with an index 0 + if ( m_nBreakPos < rInf.GetLineStart() && rInf.IsFirstMulti() && + ! rInf.IsFootnoteInside() ) + m_nBreakPos = rInf.GetLineStart(); + + m_nBreakStart = m_nBreakPos; + + bHyph = BreakType::HYPHENATION == aResult.breakType; + + if (bHyph && m_nBreakPos != TextFrameIndex(COMPLETE_STRING)) + { + // found hyphenation position within line + // nBreakPos is set to the hyphenation position + m_xHyphWord = aResult.rHyphenatedWord; + m_nBreakPos += TextFrameIndex(m_xHyphWord->getHyphenationPos() + 1); + + // if not in interactive mode, we have to break behind a soft hyphen + if ( ! rInf.IsInterHyph() && rInf.GetIdx() ) + { + sal_Int32 const nSoftHyphPos = + m_xHyphWord->getWord().indexOf( CHAR_SOFTHYPHEN ); + + if ( nSoftHyphPos >= 0 && + m_nBreakStart + TextFrameIndex(nSoftHyphPos) <= m_nBreakPos && + m_nBreakPos > rInf.GetLineStart() ) + m_nBreakPos = rInf.GetIdx() - TextFrameIndex(1); + } + + if( m_nBreakPos >= rInf.GetIdx() ) + { + nPorLen = m_nBreakPos - rInf.GetIdx(); + if ('-' == rInf.GetText()[ sal_Int32(m_nBreakPos) - 1 ]) + m_xHyphWord = nullptr; + } + } + else if ( !bHyph && m_nBreakPos >= rInf.GetLineStart() ) + { + OSL_ENSURE(sal_Int32(m_nBreakPos) != COMPLETE_STRING, "we should have found a break pos"); + + // found break position within line + m_xHyphWord = nullptr; + + // check, if break position is soft hyphen and an underflow + // has to be triggered + if( m_nBreakPos > rInf.GetLineStart() && rInf.GetIdx() && + CHAR_SOFTHYPHEN == rInf.GetText()[ sal_Int32(m_nBreakPos) - 1 ]) + { + m_nBreakPos = rInf.GetIdx() - TextFrameIndex(1); + } + + if( rAdjust != SvxAdjust::Left ) + { + // Delete any blanks at the end of a line, but be careful: + // If a field has been expanded, we do not want to delete any + // blanks inside the field portion. This would cause an unwanted + // underflow + TextFrameIndex nX = m_nBreakPos; + while( nX > rInf.GetLineStart() && + ( CH_TXTATR_BREAKWORD != cFieldChr || nX > rInf.GetIdx() ) && + ( CH_BLANK == rInf.GetChar( --nX ) || + CH_SIX_PER_EM == rInf.GetChar( nX ) || + CH_FULL_BLANK == rInf.GetChar( nX ) ) ) + m_nBreakPos = nX; + } + if( m_nBreakPos > rInf.GetIdx() ) + nPorLen = m_nBreakPos - rInf.GetIdx(); + } + else + { + // no line break found, setting nBreakPos to COMPLETE_STRING + // causes a break cut + m_nBreakPos = TextFrameIndex(COMPLETE_STRING); + OSL_ENSURE( m_nCutPos >= rInf.GetIdx(), "Deep cut" ); + nPorLen = m_nCutPos - rInf.GetIdx(); + } + + if (m_nBreakPos > m_nCutPos && m_nBreakPos != TextFrameIndex(COMPLETE_STRING)) + { + const TextFrameIndex nHangingLen = m_nBreakPos - m_nCutPos; + SwPosSize aTmpSize = rInf.GetTextSize( &rSI, m_nCutPos, nHangingLen ); + aTmpSize.Width(aTmpSize.Width() + nLeftRightBorderSpace); + OSL_ENSURE( !m_pHanging, "A hanging portion is hanging around" ); + m_pHanging.reset( new SwHangingPortion( std::move(aTmpSize) ) ); + m_pHanging->SetLen( nHangingLen ); + nPorLen = m_nCutPos - rInf.GetIdx(); + } + + // If we expanded a field, we must repair the original string. + // In case we do not trigger an underflow, we correct the nBreakPos + // value, but we cannot correct the nBreakStart value: + // If we have found a hyphenation position, nBreakStart can lie before + // the field. + if ( CH_TXTATR_BREAKWORD == cFieldChr ) + { + if ( m_nBreakPos < rInf.GetIdx() ) + m_nBreakPos = nOldIdx - TextFrameIndex(1); + else if (TextFrameIndex(COMPLETE_STRING) != m_nBreakPos) + { + OSL_ENSURE( m_nBreakPos >= m_nFieldDiff, "I've got field trouble!" ); + m_nBreakPos = m_nBreakPos - m_nFieldDiff; + } + + OSL_ENSURE( m_nCutPos >= rInf.GetIdx() && m_nCutPos >= m_nFieldDiff, + "I've got field trouble, part2!" ); + m_nCutPos = m_nCutPos - m_nFieldDiff; + + OUString& rOldText = const_cast (rInf.GetText()); + OUString aReplacement( cFieldChr ); + rOldText = rOldText.replaceAt(sal_Int32(nOldIdx) - 1, sal_Int32(m_nFieldDiff) + 1, aReplacement); + rInf.SetIdx( nOldIdx ); + +#if OSL_DEBUG_LEVEL > 0 + OSL_ENSURE( aDebugString == rInf.GetText(), + "Somebody, somebody, somebody put something in my string" ); +#endif + } + } + + if( nPorLen ) + { + rInf.GetTextSize( &rSI, rInf.GetIdx(), nPorLen, + nMaxComp, m_nBreakWidth, nMaxSizeDiff, + rInf.GetCachedVclData().get() ); + + // save maximum width for later use + if ( nMaxSizeDiff ) + rInf.SetMaxWidthDiff( &rPor, nMaxSizeDiff ); + + m_nBreakWidth += nItalic + nLeftRightBorderSpace; + } + else + m_nBreakWidth = 0; + + if (m_nBreakStart > rInf.GetIdx() + nPorLen + m_nFieldDiff) + { + rInf.GetTextSize(&rSI, rInf.GetIdx() + nPorLen, + m_nBreakStart - rInf.GetIdx() - nPorLen - m_nFieldDiff, nMaxComp, + m_nExtraBlankWidth, nMaxSizeDiff, rInf.GetCachedVclData().get()); + } + + if( m_pHanging ) + { + m_nBreakPos = m_nCutPos; + // Keep following SwBreakPortion in the same line. + if ( CH_BREAK == rInf.GetChar( m_nBreakPos + m_pHanging->GetLen() ) ) + return true; + } + + return false; +} + +// returns true if word at position nPos has a different spelling +// if hyphenated at this position (old german spelling) +bool SwTextGuess::AlternativeSpelling( const SwTextFormatInfo &rInf, + const TextFrameIndex nPos) +{ + // get word boundaries + Boundary aBound = g_pBreakIt->GetBreakIter()->getWordBoundary( + rInf.GetText(), sal_Int32(nPos), + g_pBreakIt->GetLocale( rInf.GetFont()->GetLanguage() ), + WordType::DICTIONARY_WORD, true ); + m_nBreakStart = TextFrameIndex(aBound.startPos); + sal_Int32 nWordLen = aBound.endPos - sal_Int32(m_nBreakStart); + + // if everything else fails, we want to cut at nPos + m_nCutPos = nPos; + + OUString const aText( rInf.GetText().copy(sal_Int32(m_nBreakStart), nWordLen) ); + + // check, if word has alternative spelling + Reference< XHyphenator > xHyph( ::GetHyphenator() ); + OSL_ENSURE( xHyph.is(), "Hyphenator is missing"); + //! subtract 1 since the UNO-interface is 0 based + m_xHyphWord = xHyph->queryAlternativeSpelling( aText, + g_pBreakIt->GetLocale( rInf.GetFont()->GetLanguage() ), + sal::static_int_cast(sal_Int32(nPos - m_nBreakStart)), + rInf.GetHyphValues() ); + return m_xHyphWord.is() && m_xHyphWord->isAlternativeSpelling(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/guess.hxx b/sw/source/core/text/guess.hxx new file mode 100644 index 0000000000..5a7a9ac1cf --- /dev/null +++ b/sw/source/core/text/guess.hxx @@ -0,0 +1,65 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once +#include + +#include "porrst.hxx" + +#include + +namespace com::sun::star::linguistic2 { class XHyphenatedWord; } + +class SwTextFormatInfo; + +class SwTextGuess +{ + css::uno::Reference< css::linguistic2::XHyphenatedWord > m_xHyphWord; + std::unique_ptr m_pHanging; // for hanging punctuation + TextFrameIndex m_nCutPos; // this character doesn't fit + TextFrameIndex m_nBreakStart; // start index of word containing line break + TextFrameIndex m_nBreakPos; // start index of break position + TextFrameIndex m_nFieldDiff; // absolute positions can be wrong if we + // a field in the text has been expanded + sal_uInt16 m_nBreakWidth; // width of the broken portion + sal_uInt16 m_nExtraBlankWidth; // width of spaces after the break +public: + SwTextGuess(): m_nCutPos(0), m_nBreakStart(0), + m_nBreakPos(0), m_nFieldDiff(0), m_nBreakWidth(0), m_nExtraBlankWidth(0) + { } + + // true, if current portion still fits to current line + bool Guess( const SwTextPortion& rPor, SwTextFormatInfo &rInf, + const sal_uInt16 nHeight, sal_Int32 nSpacesInLine = 0 ); + bool AlternativeSpelling( const SwTextFormatInfo &rInf, const TextFrameIndex nPos ); + + SwHangingPortion* GetHangingPortion() const { return m_pHanging.get(); } + SwHangingPortion* ReleaseHangingPortion() { return m_pHanging.release(); } + sal_uInt16 BreakWidth() const { return m_nBreakWidth; } + sal_uInt16 ExtraBlankWidth() const { return m_nExtraBlankWidth; } + TextFrameIndex CutPos() const { return m_nCutPos; } + TextFrameIndex BreakStart() const { return m_nBreakStart; } + TextFrameIndex BreakPos() const {return m_nBreakPos; } + TextFrameIndex FieldDiff() const {return m_nFieldDiff; } + const css::uno::Reference< css::linguistic2::XHyphenatedWord >& HyphWord() const + { return m_xHyphWord; } +}; + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/inftxt.cxx b/sw/source/core/text/inftxt.cxx new file mode 100644 index 0000000000..3d9121ef1e --- /dev/null +++ b/sw/source/core/text/inftxt.cxx @@ -0,0 +1,2150 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "inftxt.hxx" +#include +#include "porftn.hxx" +#include "porrst.hxx" +#include "itratr.hxx" +#include "portab.hxx" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace ::com::sun::star; +using namespace ::com::sun::star::linguistic2; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::beans; + +#define CHAR_UNDERSCORE u'_' +#define CHAR_LEFT_ARROW u'\x25C0' +#define CHAR_RIGHT_ARROW u'\x25B6' +#define CHAR_TAB u'\x2192' +#define CHAR_TAB_RTL u'\x2190' +#define CHAR_LINEBREAK u'\x21B5' +#define CHAR_LINEBREAK_RTL u'\x21B3' + +#define DRAW_SPECIAL_OPTIONS_CENTER 1 +#define DRAW_SPECIAL_OPTIONS_ROTATE 2 + +SwLineInfo::SwLineInfo() + : m_pSpace( nullptr ), + m_nVertAlign( SvxParaVertAlignItem::Align::Automatic ), + m_nDefTabStop( 0 ), + m_bListTabStopIncluded( false ), + m_nListTabStopPosition( 0 ) +{ +} + +SwLineInfo::~SwLineInfo() +{ +} + +void SwLineInfo::CtorInitLineInfo( const SwAttrSet& rAttrSet, + const SwTextNode& rTextNode ) +{ + m_oRuler.emplace( rAttrSet.GetTabStops() ); + if ( rTextNode.GetListTabStopPosition( m_nListTabStopPosition ) ) + { + m_bListTabStopIncluded = true; + + // insert the list tab stop into SvxTabItem instance + const SvxTabStop aListTabStop( m_nListTabStopPosition, + SvxTabAdjust::Left ); + m_oRuler->Insert( aListTabStop ); + + // remove default tab stops, which are before the inserted list tab stop + for ( sal_uInt16 i = 0; i < m_oRuler->Count(); i++ ) + { + if ( (*m_oRuler)[i].GetTabPos() < m_nListTabStopPosition && + (*m_oRuler)[i].GetAdjustment() == SvxTabAdjust::Default ) + { + m_oRuler->Remove(i); + continue; + } + } + } + + if ( !rTextNode.getIDocumentSettingAccess()->get(DocumentSettingId::TABS_RELATIVE_TO_INDENT) ) + { + // remove default tab stop at position 0 + for ( sal_uInt16 i = 0; i < m_oRuler->Count(); i++ ) + { + if ( (*m_oRuler)[i].GetTabPos() == 0 && + (*m_oRuler)[i].GetAdjustment() == SvxTabAdjust::Default ) + { + m_oRuler->Remove(i); + break; + } + } + } + + m_pSpace = &rAttrSet.GetLineSpacing(); + m_nVertAlign = rAttrSet.GetParaVertAlign().GetValue(); + m_nDefTabStop = USHRT_MAX; +} + +void SwTextInfo::CtorInitTextInfo( SwTextFrame *pFrame ) +{ + m_pPara = pFrame->GetPara(); + m_nTextStart = pFrame->GetOffset(); + if (!m_pPara) + { + SAL_WARN("sw.core", "+SwTextInfo::CTOR: missing paragraph information"); + pFrame->Format(pFrame->getRootFrame()->GetCurrShell()->GetOut()); + m_pPara = pFrame->GetPara(); + } +} + +SwTextInfo::SwTextInfo( const SwTextInfo &rInf ) + : m_pPara( const_cast(rInf).GetParaPortion() ) + , m_nTextStart( rInf.GetTextStart() ) +{ } + +#if OSL_DEBUG_LEVEL > 0 + +static void ChkOutDev( const SwTextSizeInfo &rInf ) +{ + if ( !rInf.GetVsh() ) + return; + + const OutputDevice* pOut = rInf.GetOut(); + const OutputDevice* pRef = rInf.GetRefDev(); + OSL_ENSURE( pOut && pRef, "ChkOutDev: invalid output devices" ); +} +#endif + +static TextFrameIndex GetMinLen( const SwTextSizeInfo &rInf ) +{ + const TextFrameIndex nTextLen(rInf.GetText().getLength()); + if (rInf.GetLen() == TextFrameIndex(COMPLETE_STRING)) + return nTextLen; + const TextFrameIndex nInfLen = rInf.GetIdx() + rInf.GetLen(); + return std::min(nTextLen, nInfLen); +} + +SwTextSizeInfo::SwTextSizeInfo() +: m_pKanaComp(nullptr) +, m_pVsh(nullptr) +, m_pOut(nullptr) +, m_pRef(nullptr) +, m_pFnt(nullptr) +, m_pUnderFnt(nullptr) +, m_pFrame(nullptr) +, m_pOpt(nullptr) +, m_pText(nullptr) +, m_nIdx(0) +, m_nLen(0) +, m_nMeasureLen(COMPLETE_STRING) +, m_nKanaIdx(0) +, m_bOnWin (false) +, m_bNotEOL (false) +, m_bURLNotify(false) +, m_bStopUnderflow(false) +, m_bFootnoteInside(false) +, m_bOtherThanFootnoteInside(false) +, m_bMulti(false) +, m_bFirstMulti(false) +, m_bRuby(false) +, m_bHanging(false) +, m_bScriptSpace(false) +, m_bForbiddenChars(false) +, m_bSnapToGrid(false) +, m_nDirection(0) +{} + +SwTextSizeInfo::SwTextSizeInfo( const SwTextSizeInfo &rNew ) + : SwTextInfo( rNew ), + m_pKanaComp(rNew.GetpKanaComp()), + m_pVsh(const_cast(rNew).GetVsh()), + m_pOut(const_cast(rNew).GetOut()), + m_pRef(const_cast(rNew).GetRefDev()), + m_pFnt(const_cast(rNew).GetFont()), + m_pUnderFnt(rNew.GetUnderFnt()), + m_pFrame(rNew.m_pFrame), + m_pOpt(&rNew.GetOpt()), + m_pText(&rNew.GetText()), + m_nIdx(rNew.GetIdx()), + m_nLen(rNew.GetLen()), + m_nMeasureLen(rNew.GetMeasureLen()), + m_nKanaIdx( rNew.GetKanaIdx() ), + m_bOnWin( rNew.OnWin() ), + m_bNotEOL( rNew.NotEOL() ), + m_bURLNotify( rNew.URLNotify() ), + m_bStopUnderflow( rNew.StopUnderflow() ), + m_bFootnoteInside( rNew.IsFootnoteInside() ), + m_bOtherThanFootnoteInside( rNew.IsOtherThanFootnoteInside() ), + m_bMulti( rNew.IsMulti() ), + m_bFirstMulti( rNew.IsFirstMulti() ), + m_bRuby( rNew.IsRuby() ), + m_bHanging( rNew.IsHanging() ), + m_bScriptSpace( rNew.HasScriptSpace() ), + m_bForbiddenChars( rNew.HasForbiddenChars() ), + m_bSnapToGrid( rNew.SnapToGrid() ), + m_nDirection( rNew.GetDirection() ) +{ +#if OSL_DEBUG_LEVEL > 0 + ChkOutDev( *this ); +#endif +} + +void SwTextSizeInfo::CtorInitTextSizeInfo( OutputDevice* pRenderContext, SwTextFrame *pFrame, + TextFrameIndex const nNewIdx) +{ + m_pKanaComp = nullptr; + m_nKanaIdx = 0; + m_pFrame = pFrame; + CtorInitTextInfo( m_pFrame ); + SwDoc const& rDoc(m_pFrame->GetDoc()); + m_pVsh = m_pFrame->getRootFrame()->GetCurrShell(); + + // Get the output and reference device + if ( m_pVsh ) + { + m_pOut = pRenderContext; + m_pRef = &m_pVsh->GetRefDev(); + m_bOnWin = m_pVsh->GetWin() || OUTDEV_WINDOW == m_pOut->GetOutDevType() || m_pVsh->isOutputToWindow(); + } + else + { + // Access via StarONE. We do not need a Shell or an active one. + if (rDoc.getIDocumentSettingAccess().get(DocumentSettingId::HTML_MODE)) + { + // We can only pick the AppWin here? (there's nothing better to pick?) + m_pOut = Application::GetDefaultDevice(); + } + else + m_pOut = rDoc.getIDocumentDeviceAccess().getPrinter(false); + + m_pRef = m_pOut; + } + +#if OSL_DEBUG_LEVEL > 0 + ChkOutDev( *this ); +#endif + + // Set default layout mode ( LTR or RTL ). + if ( m_pFrame->IsRightToLeft() ) + { + m_pOut->SetLayoutMode( vcl::text::ComplexTextLayoutFlags::BiDiStrong | vcl::text::ComplexTextLayoutFlags::BiDiRtl ); + m_pRef->SetLayoutMode( vcl::text::ComplexTextLayoutFlags::BiDiStrong | vcl::text::ComplexTextLayoutFlags::BiDiRtl ); + m_nDirection = DIR_RIGHT2LEFT; + } + else + { + m_pOut->SetLayoutMode( vcl::text::ComplexTextLayoutFlags::BiDiStrong ); + m_pRef->SetLayoutMode( vcl::text::ComplexTextLayoutFlags::BiDiStrong ); + m_nDirection = DIR_LEFT2RIGHT; + } + + // The Options + + m_pOpt = m_pVsh ? + m_pVsh->GetViewOptions() : + SW_MOD()->GetViewOption(rDoc.getIDocumentSettingAccess().get(DocumentSettingId::HTML_MODE)); // Options from Module, due to StarONE + + // bURLNotify is set if MakeGraphic prepares it + // TODO: Unwind + m_bURLNotify = pNoteURL && !m_bOnWin; + + SetSnapToGrid( m_pFrame->GetTextNodeForParaProps()->GetSwAttrSet().GetParaGrid().GetValue() && + m_pFrame->IsInDocBody() ); + + m_pFnt = nullptr; + m_pUnderFnt = nullptr; + m_pText = &m_pFrame->GetText(); + + m_nIdx = nNewIdx; + m_nLen = m_nMeasureLen = TextFrameIndex(COMPLETE_STRING); + m_bNotEOL = false; + m_bStopUnderflow = m_bFootnoteInside = m_bOtherThanFootnoteInside = false; + m_bMulti = m_bFirstMulti = m_bRuby = m_bHanging = m_bScriptSpace = + m_bForbiddenChars = false; + + SetLen( GetMinLen( *this ) ); +} + +SwTextSizeInfo::SwTextSizeInfo( const SwTextSizeInfo &rNew, const OUString* pText, + TextFrameIndex const nIndex) + : SwTextInfo( rNew ), + m_pKanaComp(rNew.GetpKanaComp()), + m_pVsh(const_cast(rNew).GetVsh()), + m_pOut(const_cast(rNew).GetOut()), + m_pRef(const_cast(rNew).GetRefDev()), + m_pFnt(const_cast(rNew).GetFont()), + m_pUnderFnt(rNew.GetUnderFnt()), + m_pFrame( rNew.m_pFrame ), + m_pOpt(&rNew.GetOpt()), + m_pText(pText), + m_nIdx(nIndex), + m_nLen(COMPLETE_STRING), + m_nMeasureLen(COMPLETE_STRING), + m_nKanaIdx( rNew.GetKanaIdx() ), + m_bOnWin( rNew.OnWin() ), + m_bNotEOL( rNew.NotEOL() ), + m_bURLNotify( rNew.URLNotify() ), + m_bStopUnderflow( rNew.StopUnderflow() ), + m_bFootnoteInside( rNew.IsFootnoteInside() ), + m_bOtherThanFootnoteInside( rNew.IsOtherThanFootnoteInside() ), + m_bMulti( rNew.IsMulti() ), + m_bFirstMulti( rNew.IsFirstMulti() ), + m_bRuby( rNew.IsRuby() ), + m_bHanging( rNew.IsHanging() ), + m_bScriptSpace( rNew.HasScriptSpace() ), + m_bForbiddenChars( rNew.HasForbiddenChars() ), + m_bSnapToGrid( rNew.SnapToGrid() ), + m_nDirection( rNew.GetDirection() ) +{ +#if OSL_DEBUG_LEVEL > 0 + ChkOutDev( *this ); +#endif + SetLen( GetMinLen( *this ) ); +} + +SwTextSizeInfo::SwTextSizeInfo(SwTextFrame *const pTextFrame, + TextFrameIndex const nIndex) + : m_bOnWin(false) +{ + CtorInitTextSizeInfo( pTextFrame->getRootFrame()->GetCurrShell()->GetOut(), pTextFrame, nIndex ); +} + +void SwTextSizeInfo::SelectFont() +{ + // The path needs to go via ChgPhysFnt or the FontMetricCache gets confused. + // In this case pLastMet has it's old value. + // Wrong: GetOut()->SetFont( GetFont()->GetFnt() ); + GetFont()->Invalidate(); + GetFont()->ChgPhysFnt( m_pVsh, *GetOut() ); +} + +void SwTextSizeInfo::NoteAnimation() const +{ + if( OnWin() ) + SwRootFrame::FlushVout(); + + OSL_ENSURE( m_pOut == m_pVsh->GetOut(), + "SwTextSizeInfo::NoteAnimation() changed m_pOut" ); +} + +SwPosSize SwTextSizeInfo::GetTextSize( OutputDevice* pOutDev, + const SwScriptInfo* pSI, + const OUString& rText, + const TextFrameIndex nIndex, + const TextFrameIndex nLength) const +{ + SwDrawTextInfo aDrawInf( m_pVsh, *pOutDev, pSI, rText, nIndex, nLength ); + aDrawInf.SetFrame( m_pFrame ); + aDrawInf.SetFont( m_pFnt ); + aDrawInf.SetSnapToGrid( SnapToGrid() ); + aDrawInf.SetKanaComp( 0 ); + return SwPosSize(m_pFnt->GetTextSize_( aDrawInf )); +} + +SwPosSize SwTextSizeInfo::GetTextSize() const +{ + const SwScriptInfo& rSI = + const_cast(GetParaPortion())->GetScriptInfo(); + + // in some cases, compression is not allowed or suppressed for + // performance reasons + sal_uInt16 nComp =( SwFontScript::CJK == GetFont()->GetActual() && + rSI.CountCompChg() && + ! IsMulti() ) ? + GetKanaComp() : + 0 ; + + SwDrawTextInfo aDrawInf( m_pVsh, *m_pOut, &rSI, *m_pText, m_nIdx, m_nLen ); + aDrawInf.SetMeasureLen( m_nMeasureLen ); + aDrawInf.SetFrame( m_pFrame ); + aDrawInf.SetFont( m_pFnt ); + aDrawInf.SetSnapToGrid( SnapToGrid() ); + aDrawInf.SetKanaComp( nComp ); + return SwPosSize(m_pFnt->GetTextSize_( aDrawInf )); +} + +void SwTextSizeInfo::GetTextSize( const SwScriptInfo* pSI, const TextFrameIndex nIndex, + const TextFrameIndex nLength, const sal_uInt16 nComp, + sal_uInt16& nMinSize, sal_uInt16& nMaxSizeDiff, + vcl::text::TextLayoutCache const*const pCache) const +{ + SwDrawTextInfo aDrawInf( m_pVsh, *m_pOut, pSI, *m_pText, nIndex, nLength, + 0, false, pCache); + aDrawInf.SetFrame( m_pFrame ); + aDrawInf.SetFont( m_pFnt ); + aDrawInf.SetSnapToGrid( SnapToGrid() ); + aDrawInf.SetKanaComp( nComp ); + SwPosSize aSize( m_pFnt->GetTextSize_( aDrawInf ) ); + nMaxSizeDiff = o3tl::narrowing(aDrawInf.GetKanaDiff()); + nMinSize = aSize.Width(); +} + +TextFrameIndex SwTextSizeInfo::GetTextBreak( const tools::Long nLineWidth, + const TextFrameIndex nMaxLen, + const sal_uInt16 nComp, + vcl::text::TextLayoutCache const*const pCache) const +{ + const SwScriptInfo& rScriptInfo = + const_cast(GetParaPortion())->GetScriptInfo(); + + OSL_ENSURE( m_pRef == m_pOut, "GetTextBreak is supposed to use the RefDev" ); + SwDrawTextInfo aDrawInf( m_pVsh, *m_pOut, &rScriptInfo, + *m_pText, GetIdx(), nMaxLen, 0, false, pCache ); + aDrawInf.SetFrame( m_pFrame ); + aDrawInf.SetFont( m_pFnt ); + aDrawInf.SetSnapToGrid( SnapToGrid() ); + aDrawInf.SetKanaComp( nComp ); + aDrawInf.SetHyphPos( nullptr ); + + return m_pFnt->GetTextBreak( aDrawInf, nLineWidth ); +} + +TextFrameIndex SwTextSizeInfo::GetTextBreak( const tools::Long nLineWidth, + const TextFrameIndex nMaxLen, + const sal_uInt16 nComp, + TextFrameIndex& rExtraCharPos, + vcl::text::TextLayoutCache const*const pCache) const +{ + const SwScriptInfo& rScriptInfo = + const_cast(GetParaPortion())->GetScriptInfo(); + + OSL_ENSURE( m_pRef == m_pOut, "GetTextBreak is supposed to use the RefDev" ); + SwDrawTextInfo aDrawInf( m_pVsh, *m_pOut, &rScriptInfo, + *m_pText, GetIdx(), nMaxLen, 0, false, pCache ); + aDrawInf.SetFrame( m_pFrame ); + aDrawInf.SetFont( m_pFnt ); + aDrawInf.SetSnapToGrid( SnapToGrid() ); + aDrawInf.SetKanaComp( nComp ); + aDrawInf.SetHyphPos( &rExtraCharPos ); + + return m_pFnt->GetTextBreak( aDrawInf, nLineWidth ); +} + +bool SwTextSizeInfo::HasHint(TextFrameIndex const nPos) const +{ + std::pair const pos(m_pFrame->MapViewToModel(nPos)); + return pos.first->GetTextAttrForCharAt(pos.second); +} + +void SwTextPaintInfo::CtorInitTextPaintInfo( OutputDevice* pRenderContext, SwTextFrame *pFrame, const SwRect &rPaint ) +{ + CtorInitTextSizeInfo( pRenderContext, pFrame, TextFrameIndex(0) ); + m_aTextFly.CtorInitTextFly( pFrame ); + m_aPaintRect = rPaint; + m_nSpaceIdx = 0; + m_pSpaceAdd = nullptr; + m_pWrongList = nullptr; + m_pGrammarCheckList = nullptr; + m_pSmartTags = nullptr; + m_pBrushItem = nullptr; +} + +SwTextPaintInfo::SwTextPaintInfo( const SwTextPaintInfo &rInf, const OUString* pText ) + : SwTextSizeInfo( rInf, pText ) + , m_pWrongList( rInf.GetpWrongList() ) + , m_pGrammarCheckList( rInf.GetGrammarCheckList() ) + , m_pSmartTags( rInf.GetSmartTags() ) + , m_pSpaceAdd( rInf.GetpSpaceAdd() ), + m_pBrushItem( rInf.GetBrushItem() ), + m_aTextFly( rInf.GetTextFly() ), + m_aPos( rInf.GetPos() ), + m_aPaintRect( rInf.GetPaintRect() ), + m_nSpaceIdx( rInf.GetSpaceIdx() ) +{ } + +SwTextPaintInfo::SwTextPaintInfo( const SwTextPaintInfo &rInf ) + : SwTextSizeInfo( rInf ) + , m_pWrongList( rInf.GetpWrongList() ) + , m_pGrammarCheckList( rInf.GetGrammarCheckList() ) + , m_pSmartTags( rInf.GetSmartTags() ) + , m_pSpaceAdd( rInf.GetpSpaceAdd() ), + m_pBrushItem( rInf.GetBrushItem() ), + m_aTextFly( rInf.GetTextFly() ), + m_aPos( rInf.GetPos() ), + m_aPaintRect( rInf.GetPaintRect() ), + m_nSpaceIdx( rInf.GetSpaceIdx() ) +{ } + +SwTextPaintInfo::SwTextPaintInfo( SwTextFrame *pFrame, const SwRect &rPaint ) +{ + CtorInitTextPaintInfo( pFrame->getRootFrame()->GetCurrShell()->GetOut(), pFrame, rPaint ); +} + +namespace +{ +/** + * Context class that captures the draw operations on rDrawInf's output device for transparency + * purposes. + */ +class SwTransparentTextGuard +{ + ScopedVclPtrInstance m_aContentVDev; + GDIMetaFile m_aContentMetafile; + MapMode m_aNewMapMode; + SwRect m_aPorRect; + SwTextPaintInfo& m_rPaintInf; + SwDrawTextInfo& m_rDrawInf; + +public: + SwTransparentTextGuard(const SwLinePortion& rPor, SwTextPaintInfo& rPaintInf, + SwDrawTextInfo& rDrawInf); + ~SwTransparentTextGuard(); +}; + +SwTransparentTextGuard::SwTransparentTextGuard(const SwLinePortion& rPor, + SwTextPaintInfo& rPaintInf, SwDrawTextInfo& rDrawInf) + : m_aNewMapMode(rPaintInf.GetOut()->GetMapMode()) + , m_rPaintInf(rPaintInf) + , m_rDrawInf(rDrawInf) +{ + rPaintInf.CalcRect(rPor, &m_aPorRect); + rDrawInf.SetOut(*m_aContentVDev); + m_aContentVDev->SetMapMode(rPaintInf.GetOut()->GetMapMode()); + m_aContentMetafile.Record(m_aContentVDev.get()); + m_aContentVDev->SetLineColor(rPaintInf.GetOut()->GetLineColor()); + m_aContentVDev->SetFillColor(rPaintInf.GetOut()->GetFillColor()); + m_aContentVDev->SetFont(rPaintInf.GetOut()->GetFont()); + m_aContentVDev->SetDrawMode(rPaintInf.GetOut()->GetDrawMode()); + m_aContentVDev->SetSettings(rPaintInf.GetOut()->GetSettings()); + m_aContentVDev->SetRefPoint(rPaintInf.GetOut()->GetRefPoint()); +} + +SwTransparentTextGuard::~SwTransparentTextGuard() +{ + m_aContentMetafile.Stop(); + m_aContentMetafile.WindStart(); + m_aNewMapMode.SetOrigin(m_aPorRect.TopLeft()); + m_aContentMetafile.SetPrefMapMode(m_aNewMapMode); + m_aContentMetafile.SetPrefSize(m_aPorRect.SSize()); + m_rDrawInf.SetOut(*m_rPaintInf.GetOut()); + Gradient aVCLGradient; + sal_uInt8 nTransPercentVcl = 255 - m_rPaintInf.GetFont()->GetColor().GetAlpha(); + const Color aTransColor(nTransPercentVcl, nTransPercentVcl, nTransPercentVcl); + aVCLGradient.SetStyle(css::awt::GradientStyle_LINEAR); + aVCLGradient.SetStartColor(aTransColor); + aVCLGradient.SetEndColor(aTransColor); + aVCLGradient.SetAngle(0_deg10); + aVCLGradient.SetBorder(0); + aVCLGradient.SetOfsX(0); + aVCLGradient.SetOfsY(0); + aVCLGradient.SetStartIntensity(100); + aVCLGradient.SetEndIntensity(100); + aVCLGradient.SetSteps(2); + m_rPaintInf.GetOut()->DrawTransparent(m_aContentMetafile, m_aPorRect.TopLeft(), + m_aPorRect.SSize(), aVCLGradient); +} +} + +void SwTextPaintInfo::DrawText_( const OUString &rText, const SwLinePortion &rPor, + TextFrameIndex const nStart, TextFrameIndex const nLength, + const bool bKern, const bool bWrong, + const bool bSmartTag, + const bool bGrammarCheck ) +{ + if( !nLength ) + return; + + // The SwScriptInfo is useless if we are inside a field portion + SwScriptInfo* pSI = nullptr; + if ( ! rPor.InFieldGrp() ) + pSI = &GetParaPortion()->GetScriptInfo(); + + // in some cases, kana compression is not allowed or suppressed for + // performance reasons + sal_uInt16 nComp = 0; + if ( ! IsMulti() ) + nComp = GetKanaComp(); + + bool bCfgIsAutoGrammar = false; + SvtLinguConfig().GetProperty( UPN_IS_GRAMMAR_AUTO ) >>= bCfgIsAutoGrammar; + const bool bBullet = OnWin() && GetOpt().IsBlank() && IsNoSymbol(); + const bool bTmpWrong = bWrong && OnWin() && GetOpt().IsOnlineSpell(); + const bool bTmpGrammarCheck = bGrammarCheck && OnWin() && bCfgIsAutoGrammar && GetOpt().IsOnlineSpell(); + const bool bTmpSmart = bSmartTag && OnWin() && !GetOpt().IsPagePreview() && SwSmartTagMgr::Get().IsSmartTagsEnabled(); + + OSL_ENSURE( GetParaPortion(), "No paragraph!"); + SwDrawTextInfo aDrawInf( m_pFrame->getRootFrame()->GetCurrShell(), *m_pOut, pSI, rText, nStart, nLength, + rPor.Width(), bBullet ); + + aDrawInf.SetUnderFnt( m_pUnderFnt ); + + const tools::Long nSpaceAdd = ( rPor.IsBlankPortion() || rPor.IsDropPortion() || + rPor.InNumberGrp() ) ? 0 : GetSpaceAdd(/*bShrink=*/true); + if ( nSpaceAdd ) + { + TextFrameIndex nCharCnt(0); + // #i41860# Thai justified alignment needs some + // additional information: + aDrawInf.SetNumberOfBlanks( rPor.InTextGrp() ? + static_cast(rPor).GetSpaceCnt( *this, nCharCnt ) : + TextFrameIndex(0) ); + } + + aDrawInf.SetSpace( nSpaceAdd ); + aDrawInf.SetKanaComp( nComp ); + + // the font is used to identify the current script via nActual + aDrawInf.SetFont( m_pFnt ); + // the frame is used to identify the orientation + aDrawInf.SetFrame( GetTextFrame() ); + // we have to know if the paragraph should snap to grid + aDrawInf.SetSnapToGrid( SnapToGrid() ); + // for underlining we must know when not to add extra space behind + // a character in justified mode + aDrawInf.SetSpaceStop( ! rPor.GetNextPortion() || + rPor.GetNextPortion()->InFixMargGrp() || + rPor.GetNextPortion()->IsHolePortion() ); + + // Draw text next to the left border + Point aFontPos(m_aPos); + if( m_pFnt->GetLeftBorder() && rPor.InTextGrp() && !static_cast(rPor).GetJoinBorderWithPrev() ) + { + const sal_uInt16 nLeftBorderSpace = m_pFnt->GetLeftBorderSpace(); + if ( GetTextFrame()->IsRightToLeft() ) + { + aFontPos.AdjustX( -nLeftBorderSpace ); + } + else + { + switch( m_pFnt->GetOrientation(GetTextFrame()->IsVertical()).get() ) + { + case 0 : + aFontPos.AdjustX(nLeftBorderSpace ); + break; + case 900 : + aFontPos.AdjustY( -nLeftBorderSpace ); + break; + case 1800 : + aFontPos.AdjustX( -nLeftBorderSpace ); + break; + case 2700 : + aFontPos.AdjustY(nLeftBorderSpace ); + break; + } + } + if( aFontPos.X() < 0 ) + aFontPos.setX( 0 ); + if( aFontPos.Y() < 0 ) + aFontPos.setY( 0 ); + } + + // Handle semi-transparent text if necessary. + std::unique_ptr> pTransparentText; + if (m_pFnt->GetColor() != COL_AUTO && m_pFnt->GetColor().IsTransparent()) + { + // if drawing to a backend that supports transparency for text color, then we don't need to use this + if (!m_bOnWin || !m_pOut->SupportsOperation(OutDevSupportType::TransparentText) || m_pOut->GetConnectMetaFile()) + pTransparentText.reset(new SwTransparentTextGuard(rPor, *this, aDrawInf)); + } + + if( GetTextFly().IsOn() ) + { + // aPos needs to be the TopLeft, because we cannot calculate the + // ClipRects otherwise + const Point aPoint( aFontPos.X(), aFontPos.Y() - rPor.GetAscent() ); + const Size aSize( rPor.Width(), rPor.Height() ); + aDrawInf.SetPos( aPoint ); + aDrawInf.SetSize( aSize ); + aDrawInf.SetAscent( rPor.GetAscent() ); + aDrawInf.SetKern( bKern ? rPor.Width() : 0 ); + aDrawInf.SetWrong( bTmpWrong ? m_pWrongList : nullptr ); + aDrawInf.SetGrammarCheck( bTmpGrammarCheck ? m_pGrammarCheckList : nullptr ); + aDrawInf.SetSmartTags( bTmpSmart ? m_pSmartTags : nullptr ); + GetTextFly().DrawTextOpaque( aDrawInf ); + } + else + { + aDrawInf.SetPos( aFontPos ); + if( bKern ) + m_pFnt->DrawStretchText_( aDrawInf ); + else + { + aDrawInf.SetWrong( bTmpWrong ? m_pWrongList : nullptr ); + aDrawInf.SetGrammarCheck( bTmpGrammarCheck ? m_pGrammarCheckList : nullptr ); + aDrawInf.SetSmartTags( bTmpSmart ? m_pSmartTags : nullptr ); + m_pFnt->DrawText_( aDrawInf ); + } + } +} + +void SwTextPaintInfo::CalcRect( const SwLinePortion& rPor, + SwRect* pRect, SwRect* pIntersect, + const bool bInsideBox ) const +{ + Size aSize( rPor.Width(), rPor.Height() ); + if( rPor.IsHangingPortion() ) + aSize.setWidth( static_cast(rPor).GetInnerWidth() ); + if( rPor.InSpaceGrp() && GetSpaceAdd() ) + { + SwTwips nAdd = rPor.CalcSpacing( GetSpaceAdd(), *this ); + if( rPor.InFieldGrp() && GetSpaceAdd() < 0 && nAdd ) + nAdd += GetSpaceAdd() / SPACING_PRECISION_FACTOR; + aSize.AdjustWidth(nAdd ); + } + + Point aPoint; + + if( IsRotated() ) + { + tools::Long nTmp = aSize.Width(); + aSize.setWidth( aSize.Height() ); + aSize.setHeight( nTmp ); + if ( 1 == GetDirection() ) + { + aPoint.setX( X() - rPor.GetAscent() ); + aPoint.setY( Y() - aSize.Height() ); + } + else + { + aPoint.setX( X() - rPor.Height() + rPor.GetAscent() ); + aPoint.setY( Y() ); + } + } + else + { + aPoint.setX( X() ); + if (GetTextFrame()->IsVertLR() && !GetTextFrame()->IsVertLRBT()) + aPoint.setY( Y() - rPor.Height() + rPor.GetAscent() ); + else + aPoint.setY( Y() - rPor.GetAscent() ); + } + + // Adjust x coordinate if we are inside a bidi portion + const bool bFrameDir = GetTextFrame()->IsRightToLeft(); + const bool bCounterDir = ( !bFrameDir && DIR_RIGHT2LEFT == GetDirection() ) || + ( bFrameDir && DIR_LEFT2RIGHT == GetDirection() ); + + if ( bCounterDir ) + aPoint.AdjustX( -(aSize.Width()) ); + + SwRect aRect( aPoint, aSize ); + + if ( GetTextFrame()->IsRightToLeft() ) + GetTextFrame()->SwitchLTRtoRTL( aRect ); + + if ( GetTextFrame()->IsVertical() ) + GetTextFrame()->SwitchHorizontalToVertical( aRect ); + + if( bInsideBox && rPor.InTextGrp() ) + { + const bool bJoinWithPrev = + static_cast(rPor).GetJoinBorderWithPrev(); + const bool bJoinWithNext = + static_cast(rPor).GetJoinBorderWithNext(); + const bool bIsVert = GetTextFrame()->IsVertical(); + const bool bIsVertLRBT = GetTextFrame()->IsVertLRBT(); + aRect.AddTop( GetFont()->CalcShadowSpace(SvxShadowItemSide::TOP, bIsVert, bIsVertLRBT, + bJoinWithPrev, bJoinWithNext)); + aRect.AddBottom( - GetFont()->CalcShadowSpace(SvxShadowItemSide::BOTTOM, bIsVert, bIsVertLRBT, + bJoinWithPrev, bJoinWithNext)); + aRect.AddLeft( GetFont()->CalcShadowSpace(SvxShadowItemSide::LEFT, bIsVert, bIsVertLRBT, + bJoinWithPrev, bJoinWithNext)); + aRect.AddRight( - GetFont()->CalcShadowSpace(SvxShadowItemSide::RIGHT, bIsVert, bIsVertLRBT, + bJoinWithPrev, bJoinWithNext)); + } + + if ( pRect ) + *pRect = aRect; + + if( aRect.HasArea() && pIntersect ) + { + ::SwAlignRect( aRect, GetVsh(), GetOut() ); + + if ( GetOut()->IsClipRegion() ) + { + SwRect aClip( GetOut()->GetClipRegion().GetBoundRect() ); + aRect.Intersection( aClip ); + } + + *pIntersect = aRect; + } +} + +/** + * Draws a special portion + * E.g.: line break portion, tab portion + * + * @param rPor The portion + * @param rRect The rectangle surrounding the character + * @param rCol Specify a color for the character + * @param bCenter Draw the character centered, otherwise left aligned + * @param bRotate Rotate the character if character rotation is set + */ +static void lcl_DrawSpecial( const SwTextPaintInfo& rTextPaintInfo, const SwLinePortion& rPor, + SwRect& rRect, const Color& rCol, sal_Unicode cChar, + sal_uInt8 nOptions ) +{ + bool bCenter = 0 != ( nOptions & DRAW_SPECIAL_OPTIONS_CENTER ); + bool bRotate = 0 != ( nOptions & DRAW_SPECIAL_OPTIONS_ROTATE ); + + // rRect is given in absolute coordinates + if ( rTextPaintInfo.GetTextFrame()->IsRightToLeft() ) + rTextPaintInfo.GetTextFrame()->SwitchRTLtoLTR( rRect ); + if ( rTextPaintInfo.GetTextFrame()->IsVertical() ) + rTextPaintInfo.GetTextFrame()->SwitchVerticalToHorizontal( rRect ); + + const SwFont* pOldFnt = rTextPaintInfo.GetFont(); + + // Font is generated only once: + static SwFont s_aFnt = [&]() + { + SwFont tmp( *pOldFnt ); + tmp.SetFamily( FAMILY_DONTKNOW, tmp.GetActual() ); + tmp.SetName( numfunc::GetDefBulletFontname(), tmp.GetActual() ); + tmp.SetStyleName(OUString(), tmp.GetActual()); + tmp.SetCharSet( RTL_TEXTENCODING_SYMBOL, tmp.GetActual() ); + return tmp; + }(); + + // Some of the current values are set at the font: + if ( ! bRotate ) + s_aFnt.SetVertical( 0_deg10, rTextPaintInfo.GetTextFrame()->IsVertical() ); + else + s_aFnt.SetVertical( pOldFnt->GetOrientation() ); + + s_aFnt.SetColor(rCol); + + Size aFontSize( 0, SPECIAL_FONT_HEIGHT ); + s_aFnt.SetSize( aFontSize, s_aFnt.GetActual() ); + + SwTextPaintInfo& rNonConstTextPaintInfo = const_cast(rTextPaintInfo); + + rNonConstTextPaintInfo.SetFont( &s_aFnt ); + + // The maximum width depends on the current orientation + const Degree10 nDir = s_aFnt.GetOrientation( rTextPaintInfo.GetTextFrame()->IsVertical() ); + SwTwips nMaxWidth; + if (nDir == 900_deg10 || nDir == 2700_deg10) + nMaxWidth = rRect.Height(); + else + { + assert(nDir == 0_deg10); //Unknown direction set at font + nMaxWidth = rRect.Width(); + } + + // check if char fits into rectangle + const OUString aTmp( cChar ); + aFontSize = rTextPaintInfo.GetTextSize( aTmp ).SvLSize(); + while ( aFontSize.Width() > nMaxWidth ) + { + SwTwips nFactor = ( 100 * aFontSize.Width() ) / nMaxWidth; + const SwTwips nOldWidth = aFontSize.Width(); + + // new height for font + const SwFontScript nAct = s_aFnt.GetActual(); + aFontSize.setHeight( ( 100 * s_aFnt.GetSize( nAct ).Height() ) / nFactor ); + aFontSize.setWidth( ( 100 * s_aFnt.GetSize( nAct).Width() ) / nFactor ); + + if ( !aFontSize.Width() && !aFontSize.Height() ) + break; + + s_aFnt.SetSize( aFontSize, nAct ); + + aFontSize = rTextPaintInfo.GetTextSize( aTmp ).SvLSize(); + + if ( aFontSize.Width() >= nOldWidth ) + break; + } + + const Point aOldPos( rTextPaintInfo.GetPos() ); + + // adjust values so that tab is vertically and horizontally centered + SwTwips nX = rRect.Left(); + SwTwips nY = rRect.Top(); + switch ( nDir.get() ) + { + case 0 : + if ( bCenter ) + nX += ( rRect.Width() - aFontSize.Width() ) / 2; + nY += ( rRect.Height() - aFontSize.Height() ) / 2 + rTextPaintInfo.GetAscent(); + break; + case 900 : + if ( bCenter ) + nX += ( rRect.Width() - aFontSize.Height() ) / 2 + rTextPaintInfo.GetAscent(); + nY += ( rRect.Height() + aFontSize.Width() ) / 2; + break; + case 2700 : + if ( bCenter ) + nX += ( rRect.Width() + aFontSize.Height() ) / 2 - rTextPaintInfo.GetAscent(); + nY += ( rRect.Height() - aFontSize.Width() ) / 2; + break; + } + + Point aTmpPos( nX, nY ); + rNonConstTextPaintInfo.SetPos( aTmpPos ); + sal_uInt16 nOldWidth = rPor.Width(); + const_cast(rPor).Width( o3tl::narrowing(aFontSize.Width()) ); + rTextPaintInfo.DrawText( aTmp, rPor ); + const_cast(rPor).Width( nOldWidth ); + rNonConstTextPaintInfo.SetFont( const_cast(pOldFnt) ); + rNonConstTextPaintInfo.SetPos( aOldPos ); +} + +void SwTextPaintInfo::DrawRect( const SwRect &rRect, bool bRetouche ) const +{ + if ( OnWin() || !bRetouche ) + { + if( m_aTextFly.IsOn() ) + const_cast(this)->GetTextFly(). + DrawFlyRect( m_pOut, rRect ); + else + m_pOut->DrawRect( rRect.SVRect() ); + } +} + +void SwTextPaintInfo::DrawTab( const SwLinePortion &rPor ) const +{ + if( !OnWin() ) + return; + + SwRect aRect; + CalcRect( rPor, &aRect ); + + if ( ! aRect.HasArea() ) + return; + + const sal_Unicode cChar = GetTextFrame()->IsRightToLeft() ? CHAR_TAB_RTL : CHAR_TAB; + const sal_uInt8 nOptions = DRAW_SPECIAL_OPTIONS_CENTER | DRAW_SPECIAL_OPTIONS_ROTATE; + + lcl_DrawSpecial( *this, rPor, aRect, NON_PRINTING_CHARACTER_COLOR, cChar, nOptions ); +} + +void SwTextPaintInfo::DrawLineBreak( const SwLinePortion &rPor ) const +{ + if( !OnWin() ) + return; + + SwLineBreakClear eClear = SwLineBreakClear::NONE; + if (rPor.IsBreakPortion()) + { + const auto& rBreakPortion = static_cast(rPor); + eClear = rBreakPortion.GetClear(); + } + + sal_uInt16 nOldWidth = rPor.Width(); + const_cast(rPor).Width( LINE_BREAK_WIDTH ); + + SwRect aRect; + CalcRect( rPor, &aRect ); + + if( aRect.HasArea() ) + { + const sal_Unicode cChar = GetTextFrame()->IsRightToLeft() ? + CHAR_LINEBREAK_RTL : CHAR_LINEBREAK; + const sal_uInt8 nOptions = 0; + + SwRect aTextRect(aRect); + if (eClear == SwLineBreakClear::LEFT || eClear == SwLineBreakClear::ALL) + aTextRect.AddLeft(30); + if (eClear == SwLineBreakClear::RIGHT || eClear == SwLineBreakClear::ALL) + aTextRect.AddRight(-30); + lcl_DrawSpecial( *this, rPor, aTextRect, NON_PRINTING_CHARACTER_COLOR, cChar, nOptions ); + + if (eClear != SwLineBreakClear::NONE) + { + // Paint indicator if this clear is left/right/all. + m_pOut->Push(vcl::PushFlags::LINECOLOR); + m_pOut->SetLineColor(NON_PRINTING_CHARACTER_COLOR); + if (eClear != SwLineBreakClear::RIGHT) + m_pOut->DrawLine(aRect.BottomLeft(), aRect.TopLeft()); + if (eClear != SwLineBreakClear::LEFT) + m_pOut->DrawLine(aRect.BottomRight(), aRect.TopRight()); + m_pOut->Pop(); + } + } + + const_cast(rPor).Width( nOldWidth ); +} + +void SwTextPaintInfo::DrawRedArrow( const SwLinePortion &rPor ) const +{ + Size aSize( SPECIAL_FONT_HEIGHT, SPECIAL_FONT_HEIGHT ); + SwRect aRect( static_cast(rPor).GetPos(), aSize ); + sal_Unicode cChar; + if( static_cast(rPor).IsLeft() ) + { + aRect.Pos().AdjustY(20 - GetAscent() ); + aRect.Pos().AdjustX(20 ); + if( aSize.Height() > rPor.Height() ) + aRect.Height( rPor.Height() ); + cChar = CHAR_LEFT_ARROW; + } + else + { + if( aSize.Height() > rPor.Height() ) + aRect.Height( rPor.Height() ); + aRect.Pos().AdjustY( -(aRect.Height() + 20) ); + aRect.Pos().AdjustX( -(aRect.Width() + 20) ); + cChar = CHAR_RIGHT_ARROW; + } + + if ( GetTextFrame()->IsVertical() ) + GetTextFrame()->SwitchHorizontalToVertical( aRect ); + + if( aRect.HasArea() ) + { + const sal_uInt8 nOptions = 0; + lcl_DrawSpecial( *this, rPor, aRect, COL_LIGHTRED, cChar, nOptions ); + } +} + +void SwTextPaintInfo::DrawPostIts( bool bScript ) const +{ + if( !OnWin() || !m_pOpt->IsPostIts() ) + return; + + Size aSize; + Point aTmp; + + const sal_uInt16 nPostItsWidth = SwViewOption::GetPostItsWidth( GetOut() ); + const sal_uInt16 nFontHeight = m_pFnt->GetHeight( m_pVsh, *GetOut() ); + const sal_uInt16 nFontAscent = m_pFnt->GetAscent( m_pVsh, *GetOut() ); + + switch ( m_pFnt->GetOrientation( GetTextFrame()->IsVertical() ).get() ) + { + case 0 : + aSize.setWidth( nPostItsWidth ); + aSize.setHeight( nFontHeight ); + aTmp.setX( m_aPos.X() ); + aTmp.setY( m_aPos.Y() - nFontAscent ); + break; + case 900 : + aSize.setHeight( nPostItsWidth ); + aSize.setWidth( nFontHeight ); + aTmp.setX( m_aPos.X() - nFontAscent ); + aTmp.setY( m_aPos.Y() ); + break; + case 2700 : + aSize.setHeight( nPostItsWidth ); + aSize.setWidth( nFontHeight ); + aTmp.setX( m_aPos.X() - nFontHeight + + nFontAscent ); + aTmp.setY( m_aPos.Y() ); + break; + } + + SwRect aTmpRect( aTmp, aSize ); + + if ( GetTextFrame()->IsRightToLeft() ) + GetTextFrame()->SwitchLTRtoRTL( aTmpRect ); + + if ( GetTextFrame()->IsVertical() ) + GetTextFrame()->SwitchHorizontalToVertical( aTmpRect ); + + GetOpt().PaintPostIts( const_cast(GetOut()), aTmpRect, bScript ); + +} + +void SwTextPaintInfo::DrawCheckBox(const SwFieldFormCheckboxPortion &rPor, bool bChecked) const +{ + SwRect aIntersect; + CalcRect( rPor, &aIntersect ); + if ( !aIntersect.HasArea() ) + return; + + if (OnWin() && GetOpt().IsFieldShadings() && + !GetOpt().IsPagePreview()) + { + OutputDevice* pOut = const_cast(GetOut()); + pOut->Push( vcl::PushFlags::LINECOLOR | vcl::PushFlags::FILLCOLOR ); + if( m_pFnt->GetHighlightColor() != COL_TRANSPARENT ) + pOut->SetFillColor(m_pFnt->GetHighlightColor()); + else + pOut->SetFillColor(GetOpt().GetFieldShadingsColor()); + pOut->SetLineColor(); + pOut->DrawRect( aIntersect.SVRect() ); + pOut->Pop(); + } + const int delta = 25; + tools::Rectangle r(aIntersect.Left()+delta, aIntersect.Top()+delta, aIntersect.Right()-delta, aIntersect.Bottom()-delta); + m_pOut->Push( vcl::PushFlags::LINECOLOR | vcl::PushFlags::FILLCOLOR ); + m_pOut->SetLineColor( Color(0, 0, 0)); + m_pOut->SetFillColor(); + m_pOut->DrawRect( r ); + if (bChecked) + { + m_pOut->DrawLine(r.TopLeft(), r.BottomRight()); + m_pOut->DrawLine(r.TopRight(), r.BottomLeft()); + } + m_pOut->Pop(); +} + +void SwTextPaintInfo::DrawBackground( const SwLinePortion &rPor, const Color *pColor ) const +{ + OSL_ENSURE( OnWin(), "SwTextPaintInfo::DrawBackground: printer pollution ?" ); + + SwRect aIntersect; + CalcRect( rPor, nullptr, &aIntersect, true ); + + if ( !aIntersect.HasArea() ) + return; + + OutputDevice* pOut = const_cast(GetOut()); + pOut->Push( vcl::PushFlags::LINECOLOR | vcl::PushFlags::FILLCOLOR ); + + if ( pColor ) + pOut->SetFillColor( *pColor ); + else + pOut->SetFillColor( GetOpt().GetFieldShadingsColor() ); + + pOut->SetLineColor(); + + DrawRect( aIntersect, true ); + pOut->Pop(); +} + +void SwTextPaintInfo::DrawBackBrush( const SwLinePortion &rPor ) const +{ + { + SwRect aIntersect; + CalcRect( rPor, &aIntersect, nullptr, true ); + if(aIntersect.HasArea()) + { + SwPosition const aPosition(m_pFrame->MapViewToModelPos(GetIdx())); + const ::sw::mark::IMark* pFieldmark = + m_pFrame->GetDoc().getIDocumentMarkAccess()->getInnerFieldmarkFor(aPosition); + bool bIsStartMark = (TextFrameIndex(1) == GetLen() + && CH_TXT_ATR_FIELDSTART == GetText()[sal_Int32(GetIdx())]); + if(pFieldmark) { + SAL_INFO("sw.core", "Found Fieldmark " << pFieldmark->ToString()); + } + if(bIsStartMark) + SAL_INFO("sw.core", "Found StartMark"); + if (OnWin() && (pFieldmark!=nullptr || bIsStartMark) && + GetOpt().IsFieldShadings() && + !GetOpt().IsPagePreview()) + { + OutputDevice* pOutDev = const_cast(GetOut()); + pOutDev->Push( vcl::PushFlags::LINECOLOR | vcl::PushFlags::FILLCOLOR ); + pOutDev->SetFillColor( GetOpt().GetFieldShadingsColor() ); + pOutDev->SetLineColor( ); + pOutDev->DrawRect( aIntersect.SVRect() ); + pOutDev->Pop(); + } + } + } + + SwRect aIntersect; + CalcRect( rPor, nullptr, &aIntersect, true ); + + if ( !aIntersect.HasArea() ) + return; + + OutputDevice* pTmpOut = const_cast(GetOut()); + + // #i16816# tagged pdf support + SwTaggedPDFHelper aTaggedPDFHelper( nullptr, nullptr, nullptr, *pTmpOut ); + + Color aFillColor; + + if( m_pFnt->GetHighlightColor() != COL_TRANSPARENT ) + { + aFillColor = m_pFnt->GetHighlightColor(); + } + else + { + if( !m_pFnt->GetBackColor() ) + return; + aFillColor = *m_pFnt->GetBackColor(); + } + + pTmpOut->Push( vcl::PushFlags::LINECOLOR | vcl::PushFlags::FILLCOLOR ); + + pTmpOut->SetFillColor(aFillColor); + pTmpOut->SetLineColor(); + + DrawRect( aIntersect, false ); + + pTmpOut->Pop(); +} + +void SwTextPaintInfo::DrawBorder( const SwLinePortion &rPor ) const +{ + SwRect aDrawArea; + CalcRect( rPor, &aDrawArea ); + if ( aDrawArea.HasArea() ) + { + PaintCharacterBorder(*m_pFnt, aDrawArea, GetTextFrame()->IsVertical(), + GetTextFrame()->IsVertLRBT(), rPor.GetJoinBorderWithPrev(), + rPor.GetJoinBorderWithNext()); + } +} + +namespace { + +bool HasValidPropertyValue(const uno::Any& rAny) +{ + if (bool bValue; rAny >>= bValue) + { + return true; + } + else if (OUString aValue; (rAny >>= aValue) && !(aValue.isEmpty())) + { + return true; + } + else if (awt::FontSlant eValue; rAny >>= eValue) + { + return true; + } + else if (tools::Long nValueLong; rAny >>= nValueLong) + { + return true; + } + else if (double fValue; rAny >>= fValue) + { + return true; + } + else if (short nValueShort; rAny >>= nValueShort) + { + return true; + } + else + return false; +} +} + +void SwTextPaintInfo::DrawCSDFHighlighting(const SwLinePortion &rPor) const +{ + // Don't use GetActiveView() as it does not work as expected when there are multiple open + // documents. + SwView* pView = SwTextFrame::GetView(); + if (!pView) + return; + + StylesHighlighterColorMap& rCharStylesColorMap = pView->GetStylesHighlighterCharColorMap(); + + if (rCharStylesColorMap.empty() && !pView->IsHighlightCharDF()) + return; + + SwRect aRect; + CalcRect(rPor, &aRect, nullptr, true); + if(!aRect.HasArea()) + return; + + SwTextFrame* pFrame = const_cast(GetTextFrame()); + if (!pFrame) + return; + + SwPosition aPosition(pFrame->MapViewToModelPos(GetIdx())); + SwPosition aMarkPosition(pFrame->MapViewToModelPos(GetIdx() + GetLen())); + + rtl::Reference xRange( + SwXTextRange::CreateXTextRange(pFrame->GetDoc(), aPosition, &aMarkPosition)); + + OUString sCurrentCharStyle; + xRange->getPropertyValue("CharStyleName") >>= sCurrentCharStyle; + + std::optional sCSNumberOrDF; // CS number or "df" or not used + std::optional aFillColor; + + // check for CS formatting, if not CS formatted check for direct character formatting + if (!sCurrentCharStyle.isEmpty()) + { + if (!rCharStylesColorMap.empty()) + { + OUString sCharStyleDisplayName; + sCharStyleDisplayName = SwStyleNameMapper::GetUIName(sCurrentCharStyle, + SwGetPoolIdFromName::ChrFmt); + if (!sCharStyleDisplayName.isEmpty() + && rCharStylesColorMap.find(sCharStyleDisplayName) + != rCharStylesColorMap.end()) + { + aFillColor = rCharStylesColorMap[sCharStyleDisplayName].first; + sCSNumberOrDF = OUString::number(rCharStylesColorMap[sCharStyleDisplayName].second); + } + } + } + // not character style formatted + else if (pView->IsHighlightCharDF()) + { + const std::vector aHiddenProperties{ UNO_NAME_RSID, + UNO_NAME_PARA_IS_NUMBERING_RESTART, + UNO_NAME_PARA_STYLE_NAME, + UNO_NAME_PARA_CONDITIONAL_STYLE_NAME, + UNO_NAME_PAGE_STYLE_NAME, + UNO_NAME_NUMBERING_START_VALUE, + UNO_NAME_NUMBERING_IS_NUMBER, + UNO_NAME_PARA_CONTINUEING_PREVIOUS_SUB_TREE, + UNO_NAME_CHAR_STYLE_NAME, + UNO_NAME_NUMBERING_LEVEL, + UNO_NAME_SORTED_TEXT_ID, + UNO_NAME_PARRSID, + UNO_NAME_CHAR_COLOR_THEME, + UNO_NAME_CHAR_COLOR_TINT_OR_SHADE }; + + SfxItemPropertySet const& rPropSet( + *aSwMapProvider.GetPropertySet(PROPERTY_MAP_CHAR_AUTO_STYLE)); + SfxItemPropertyMap const& rMap(rPropSet.getPropertyMap()); + + + const uno::Sequence aProperties + = xRange->getPropertySetInfo()->getProperties(); + + for (const beans::Property& rProperty : aProperties) + { + const OUString& rPropName = rProperty.Name; + + if (!rMap.hasPropertyByName(rPropName)) + continue; + + if (std::find(aHiddenProperties.begin(), aHiddenProperties.end(), rPropName) + != aHiddenProperties.end()) + continue; + + if (xRange->getPropertyState(rPropName) == beans::PropertyState_DIRECT_VALUE) + { + const uno::Any aAny = xRange->getPropertyValue(rPropName); + if (HasValidPropertyValue(aAny)) + { + sCSNumberOrDF = SwResId(STR_CHARACTER_DIRECT_FORMATTING_TAG); + aFillColor = COL_LIGHTGRAY; + break; + } + } + } + } + if (sCSNumberOrDF) + { + OutputDevice* pTmpOut = const_cast(GetOut()); + pTmpOut->Push(vcl::PushFlags::LINECOLOR | vcl::PushFlags::FILLCOLOR + | vcl::PushFlags::TEXTLAYOUTMODE | vcl::PushFlags::FONT); + + // draw a filled rectangle at the formatted CS or DF text + pTmpOut->SetFillColor(aFillColor.value()); + pTmpOut->SetLineColor(aFillColor.value()); + tools::Rectangle aSVRect(aRect.SVRect()); + pTmpOut->DrawRect(aSVRect); + + // calculate size and position for the CS number or "df" text and rectangle + tools::Long nWidth = pTmpOut->GetTextWidth(sCSNumberOrDF.value()); + tools::Long nHeight = pTmpOut->GetTextHeight(); + aSVRect.SetSize(Size(nWidth, nHeight)); + aSVRect.Move(-(nWidth / 1.5), -(nHeight / 1.5)); + + vcl::Font aFont(pTmpOut->GetFont()); + aFont.SetOrientation(Degree10(0)); + pTmpOut->SetFont(aFont); + + pTmpOut->SetLayoutMode(vcl::text::ComplexTextLayoutFlags::TextOriginLeft); + //pTmpOut->SetLayoutMode(vcl::text::ComplexTextLayoutFlags::BiDiStrong); + + pTmpOut->SetTextFillColor(aFillColor.value()); + pTmpOut->DrawText(aSVRect, sCSNumberOrDF.value(), DrawTextFlags::NONE); + + pTmpOut->Pop(); + } +} + +void SwTextPaintInfo::DrawViewOpt( const SwLinePortion &rPor, + PortionType nWhich, const Color *pColor ) const +{ + if( !OnWin() || IsMulti() ) + return; + + bool bDraw = false; + switch( nWhich ) + { + case PortionType::Footnote: + case PortionType::QuoVadis: + case PortionType::Number: + case PortionType::Field: + case PortionType::Hidden: + case PortionType::Tox: + case PortionType::Ref: + case PortionType::Meta: + case PortionType::ContentControl: + case PortionType::ControlChar: + if ( !GetOpt().IsPagePreview() + && !GetOpt().IsReadonly() + && GetOpt().IsFieldShadings() + && ( PortionType::Number != nWhich + || m_pFrame->GetTextNodeForParaProps()->HasMarkedLabel())) // #i27615# + { + bDraw = PortionType::Footnote != nWhich || m_pFrame->IsFootnoteAllowed(); + } + bDraw &= GetOpt().IsHardBlank(); + break; + case PortionType::Bookmark: + // no shading + break; + case PortionType::InputField: + // input field shading also in read-only mode + if ( !GetOpt().IsPagePreview() + && GetOpt().IsFieldShadings() ) + { + bDraw = true; + } + break; + case PortionType::Tab: + if ( GetOpt().IsTab() ) bDraw = true; + break; + case PortionType::SoftHyphen: + if ( GetOpt().IsSoftHyph() )bDraw = true; + break; + case PortionType::Blank: + if ( GetOpt().IsHardBlank())bDraw = true; + break; + default: + { + OSL_ENSURE( false, "SwTextPaintInfo::DrawViewOpt: don't know how to draw this" ); + break; + } + } + if ( bDraw ) + DrawBackground( rPor, pColor ); +} + +static void lcl_InitHyphValues( PropertyValues &rVals, + sal_Int16 nMinLeading, sal_Int16 nMinTrailing, + bool bNoCapsHyphenation, bool bNoLastWordHyphenation, + sal_Int16 nMinWordLength, sal_Int16 nTextHyphZone ) +{ + sal_Int32 nLen = rVals.getLength(); + + if (0 == nLen) // yet to be initialized? + { + rVals.realloc( 6 ); + PropertyValue *pVal = rVals.getArray(); + + pVal[0].Name = UPN_HYPH_MIN_LEADING; + pVal[0].Handle = UPH_HYPH_MIN_LEADING; + pVal[0].Value <<= nMinLeading; + + pVal[1].Name = UPN_HYPH_MIN_TRAILING; + pVal[1].Handle = UPH_HYPH_MIN_TRAILING; + pVal[1].Value <<= nMinTrailing; + + pVal[2].Name = UPN_HYPH_NO_CAPS; + pVal[2].Handle = UPH_HYPH_NO_CAPS; + pVal[2].Value <<= bNoCapsHyphenation; + + pVal[3].Name = UPN_HYPH_NO_LAST_WORD; + pVal[3].Handle = UPH_HYPH_NO_LAST_WORD; + pVal[3].Value <<= bNoLastWordHyphenation; + + pVal[4].Name = UPN_HYPH_MIN_WORD_LENGTH; + pVal[4].Handle = UPH_HYPH_MIN_WORD_LENGTH; + pVal[4].Value <<= nMinWordLength; + + pVal[5].Name = UPN_HYPH_ZONE; + pVal[5].Handle = UPH_HYPH_ZONE; + pVal[5].Value <<= nTextHyphZone; + } + else if (6 == nLen) // already initialized once? + { + PropertyValue *pVal = rVals.getArray(); + pVal[0].Value <<= nMinLeading; + pVal[1].Value <<= nMinTrailing; + pVal[2].Value <<= bNoCapsHyphenation; + pVal[3].Value <<= bNoLastWordHyphenation; + pVal[4].Value <<= nMinWordLength; + pVal[5].Value <<= nTextHyphZone; + } + else { + OSL_FAIL( "unexpected size of sequence" ); + } +} + +const PropertyValues & SwTextFormatInfo::GetHyphValues() const +{ + OSL_ENSURE( 6 == m_aHyphVals.getLength(), + "hyphenation values not yet initialized" ); + return m_aHyphVals; +} + +bool SwTextFormatInfo::InitHyph( const bool bAutoHyphen ) +{ + const SwAttrSet& rAttrSet = GetTextFrame()->GetTextNodeForParaProps()->GetSwAttrSet(); + SetHanging( rAttrSet.GetHangingPunctuation().GetValue() ); + SetScriptSpace( rAttrSet.GetScriptSpace().GetValue() ); + SetForbiddenChars( rAttrSet.GetForbiddenRule().GetValue() ); + const SvxHyphenZoneItem &rAttr = rAttrSet.GetHyphenZone(); + MaxHyph() = rAttr.GetMaxHyphens(); + const bool bAuto = bAutoHyphen || rAttr.IsHyphen(); + if( bAuto || m_bInterHyph ) + { + const sal_Int16 nMinimalLeading = std::max(rAttr.GetMinLead(), sal_uInt8(2)); + const sal_Int16 nMinimalTrailing = rAttr.GetMinTrail(); + const sal_Int16 nMinimalWordLength = rAttr.GetMinWordLength(); + const bool bNoCapsHyphenation = rAttr.IsNoCapsHyphenation(); + const bool bNoLastWordHyphenation = rAttr.IsNoLastWordHyphenation(); + const sal_Int16 nTextHyphZone = rAttr.GetTextHyphenZone(); + lcl_InitHyphValues( m_aHyphVals, nMinimalLeading, nMinimalTrailing, + bNoCapsHyphenation, bNoLastWordHyphenation, + nMinimalWordLength, nTextHyphZone ); + } + return bAuto; +} + +void SwTextFormatInfo::CtorInitTextFormatInfo( OutputDevice* pRenderContext, SwTextFrame *pNewFrame, const bool bNewInterHyph, + const bool bNewQuick, const bool bTst ) +{ + CtorInitTextPaintInfo( pRenderContext, pNewFrame, SwRect() ); + + m_bQuick = bNewQuick; + m_bInterHyph = bNewInterHyph; + + //! needs to be done in this order + m_bAutoHyph = InitHyph(); + + m_bIgnoreFly = false; + m_bFakeLineStart = false; + m_bShift = false; + m_bDropInit = false; + m_bTestFormat = bTst; + m_nLeft = 0; + m_nRight = 0; + m_nFirst = 0; + m_nRealWidth = 0; + m_nForcedLeftMargin = 0; + m_pRest = nullptr; + m_nLineHeight = 0; + m_nLineNetHeight = 0; + SetLineStart(TextFrameIndex(0)); + + SvtCTLOptions::TextNumerals const nTextNumerals( + SvtCTLOptions::GetCTLTextNumerals()); + // cannot cache for NUMERALS_CONTEXT because we need to know the string + // for the whole paragraph now + if (nTextNumerals != SvtCTLOptions::NUMERALS_CONTEXT) + { + // set digit mode to what will be used later to get same results + SwDigitModeModifier const m(*m_pRef, LANGUAGE_NONE /*dummy*/); + assert(m_pRef->GetDigitLanguage() != LANGUAGE_NONE); + SetCachedVclData(OutputDevice::CreateTextLayoutCache(*m_pText)); + } + + Init(); +} + +/** + * If the Hyphenator returns ERROR or the language is set to NOLANGUAGE + * we do not hyphenate. + * Else, we always hyphenate if we do interactive hyphenation. + * If we do not do interactive hyphenation, we only hyphenate if ParaFormat is + * set to automatic hyphenation. + */ +bool SwTextFormatInfo::IsHyphenate() const +{ + if( !m_bInterHyph && !m_bAutoHyph ) + return false; + + LanguageType eTmp = GetFont()->GetLanguage(); + // TODO: check for more ideographic langs w/o hyphenation as a concept + if ( LANGUAGE_DONTKNOW == eTmp || LANGUAGE_NONE == eTmp + || !MsLangId::usesHyphenation(eTmp) ) + return false; + + uno::Reference< XHyphenator > xHyph = ::GetHyphenator(); + if (!xHyph.is()) + return false; + + if (m_bInterHyph) + SvxSpellWrapper::CheckHyphLang( xHyph, eTmp ); + + if (!xHyph->hasLocale(g_pBreakIt->GetLocale(eTmp))) + { + SfxObjectShell* pShell = m_pFrame->GetDoc().GetDocShell(); + if (pShell) + { + pShell->AppendInfoBarWhenReady( + "hyphenationmissing", SwResId(STR_HYPH_MISSING), + SwResId(STR_HYPH_MISSING_DETAIL) + .replaceFirst("%1", LanguageTag::convertToBcp47( g_pBreakIt->GetLocale(eTmp))), + InfobarType::WARNING); + } + } + + return xHyph->hasLocale( g_pBreakIt->GetLocale(eTmp) ); +} + +const SwFormatDrop *SwTextFormatInfo::GetDropFormat() const +{ + const SwFormatDrop *pDrop = &GetTextFrame()->GetTextNodeForParaProps()->GetSwAttrSet().GetDrop(); + if( 1 >= pDrop->GetLines() || + ( !pDrop->GetChars() && !pDrop->GetWholeWord() ) ) + pDrop = nullptr; + return pDrop; +} + +void SwTextFormatInfo::Init() +{ + // Not initialized: pRest, nLeft, nRight, nFirst, nRealWidth + X(0); + m_bArrowDone = m_bFull = m_bFootnoteDone = m_bErgoDone = m_bNumDone = m_bNoEndHyph = + m_bNoMidHyph = m_bStop = m_bNewLine = m_bUnderflow = m_bTabOverflow = false; + + // generally we do not allow number portions in follows, except... + if ( GetTextFrame()->IsFollow() ) + { + const SwTextFrame* pMaster = GetTextFrame()->FindMaster(); + OSL_ENSURE(pMaster, "pTextFrame without Master"); + const SwLinePortion* pTmpPara = pMaster ? pMaster->GetPara() : nullptr; + + // there is a master for this follow and the master does not have + // any contents (especially it does not have a number portion) + m_bNumDone = ! pTmpPara || + ! static_cast(pTmpPara)->GetFirstPortion()->IsFlyPortion(); + } + + m_pRoot = nullptr; + m_pLast = nullptr; + m_pFly = nullptr; + m_pLastTab = nullptr; + m_pUnderflow = nullptr; + m_cTabDecimal = 0; + m_nWidth = m_nRealWidth; + m_nForcedLeftMargin = 0; + m_nSoftHyphPos = TextFrameIndex(0); + m_nUnderScorePos = TextFrameIndex(COMPLETE_STRING); + m_nLastBookmarkPos = TextFrameIndex(-1); + m_cHookChar = 0; + SetIdx(TextFrameIndex(0)); + SetLen(TextFrameIndex(GetText().getLength())); + SetPaintOfst(0); +} + +SwTextFormatInfo::SwTextFormatInfo(OutputDevice* pRenderContext, SwTextFrame *pFrame, const bool bInterHyphL, + const bool bQuickL, const bool bTst) +{ + CtorInitTextFormatInfo(pRenderContext, pFrame, bInterHyphL, bQuickL, bTst); +} + +/** + * There are a few differences between a copy constructor + * and the following constructor for multi-line formatting. + * The root is the first line inside the multi-portion, + * the line start is the actual position in the text, + * the line width is the rest width from the surrounding line + * and the bMulti and bFirstMulti-flag has to be set correctly. + */ +SwTextFormatInfo::SwTextFormatInfo( const SwTextFormatInfo& rInf, + SwLineLayout& rLay, SwTwips nActWidth ) : + SwTextPaintInfo( rInf ), + m_pRoot(&rLay), + m_pLast(&rLay), + m_pFly(nullptr), + m_pUnderflow(nullptr), + m_pRest(nullptr), + m_pLastTab(nullptr), + m_nSoftHyphPos(TextFrameIndex(0)), + m_nLineStart(rInf.GetIdx()), + m_nUnderScorePos(TextFrameIndex(COMPLETE_STRING)), + m_nLeft(rInf.m_nLeft), + m_nRight(rInf.m_nRight), + m_nFirst(rInf.m_nLeft), + m_nRealWidth(sal_uInt16(nActWidth)), + m_nWidth(m_nRealWidth), + m_nLineHeight(0), + m_nLineNetHeight(0), + m_nForcedLeftMargin(0), + m_bFull(false), + m_bFootnoteDone(true), + m_bErgoDone(true), + m_bNumDone(true), + m_bArrowDone(true), + m_bStop(false), + m_bNewLine(true), + m_bShift(false), + m_bUnderflow(false), + m_bInterHyph(false), + m_bAutoHyph(false), + m_bDropInit(false), + m_bQuick(rInf.m_bQuick), + m_bNoEndHyph(false), + m_bNoMidHyph(false), + m_bIgnoreFly(false), + m_bFakeLineStart(false), + m_bTabOverflow( false ), + m_bTestFormat(rInf.m_bTestFormat), + m_cTabDecimal(0), + m_cHookChar(0), + m_nMaxHyph(0) +{ + SetMulti( true ); + SetFirstMulti( rInf.IsFirstMulti() ); +} + +void SwTextFormatInfo::UpdateTabSeen(PortionType type) +{ + switch (type) + { + case PortionType::TabLeft: + m_eLastTabsSeen = TabSeen::Left; + break; + case PortionType::TabRight: + m_eLastTabsSeen = TabSeen::Right; + break; + case PortionType::TabCenter: + m_eLastTabsSeen = TabSeen::Center; + break; + case PortionType::TabDecimal: + m_eLastTabsSeen = TabSeen::Decimal; + break; + case PortionType::Break: + m_eLastTabsSeen = TabSeen::None; + break; + default: + break; + } +} + +void SwTextFormatInfo::SetLast(SwLinePortion* pNewLast) +{ + m_pLast = pNewLast; + assert(pNewLast); // We never pass nullptr here. If we start, then a check is needed below. + UpdateTabSeen(pNewLast->GetWhichPor()); +} + +bool SwTextFormatInfo::CheckFootnotePortion_( SwLineLayout const * pCurr ) +{ + const sal_uInt16 nHeight = pCurr->GetRealHeight(); + for( SwLinePortion *pPor = pCurr->GetNextPortion(); pPor; pPor = pPor->GetNextPortion() ) + { + if( pPor->IsFootnotePortion() && nHeight > static_cast(pPor)->Orig() ) + { + SetLineHeight( nHeight ); + SetLineNetHeight( pCurr->Height() ); + return true; + } + } + return false; +} + +TextFrameIndex SwTextFormatInfo::ScanPortionEnd(TextFrameIndex const nStart, + TextFrameIndex const nEnd) +{ + m_cHookChar = 0; + TextFrameIndex i = nStart; + + // Used for decimal tab handling: + const sal_Unicode cTabDec = GetLastTab() ? GetTabDecimal() : 0; + const sal_Unicode cThousandSep = ',' == cTabDec ? '.' : ','; + + // #i45951# German (Switzerland) uses ' as thousand separator + const sal_Unicode cThousandSep2 = ',' == cTabDec ? '.' : '\''; + + bool bNumFound = false; + const bool bTabCompat = GetTextFrame()->GetDoc().getIDocumentSettingAccess().get(DocumentSettingId::TAB_COMPAT); + + for( ; i < nEnd; ++i ) + { + const sal_Unicode cPos = GetChar( i ); + switch( cPos ) + { + case CH_TXTATR_BREAKWORD: + case CH_TXTATR_INWORD: + if( !HasHint( i )) + break; + [[fallthrough]]; + + case CHAR_SOFTHYPHEN: + case CHAR_HARDHYPHEN: + case CHAR_HARDBLANK: + case CH_TAB: + case CH_BREAK: + case CHAR_ZWSP : + case CHAR_WJ : + m_cHookChar = cPos; + return i; + + case CHAR_UNDERSCORE: + if (TextFrameIndex(COMPLETE_STRING) == m_nUnderScorePos) + m_nUnderScorePos = i; + break; + + default: + if ( cTabDec ) + { + if( cTabDec == cPos ) + { + OSL_ENSURE( cPos, "Unexpected end of string" ); + if( cPos ) // robust + { + m_cHookChar = cPos; + return i; + } + } + + // Compatibility: First non-digit character behind a + // a digit character becomes the hook character + if ( bTabCompat ) + { + if ( ( 0x2F < cPos && cPos < 0x3A ) || + ( bNumFound && ( cPos == cThousandSep || cPos == cThousandSep2 ) ) ) + { + bNumFound = true; + } + else + { + if ( bNumFound ) + { + m_cHookChar = cPos; + SetTabDecimal( cPos ); + return i; + } + } + } + } + } + } + + // Check if character *behind* the portion has + // to become the hook: + if (i == nEnd && i < TextFrameIndex(GetText().getLength()) && bNumFound) + { + const sal_Unicode cPos = GetChar( i ); + if ( cPos != cTabDec && cPos != cThousandSep && cPos !=cThousandSep2 && ( 0x2F >= cPos || cPos >= 0x3A ) ) + { + m_cHookChar = GetChar( i ); + SetTabDecimal( m_cHookChar ); + } + } + + return i; +} + +bool SwTextFormatInfo::LastKernPortion() +{ + if( GetLast() ) + { + if( GetLast()->IsKernPortion() ) + return true; + if( GetLast()->Width() || ( GetLast()->GetLen() && + !GetLast()->IsHolePortion() ) ) + return false; + } + SwLinePortion* pPor = GetRoot(); + SwLinePortion *pKern = nullptr; + while( pPor ) + { + if( pPor->IsKernPortion() ) + pKern = pPor; + else if( pPor->Width() || ( pPor->GetLen() && !pPor->IsHolePortion() ) ) + pKern = nullptr; + pPor = pPor->GetNextPortion(); + } + if( pKern ) + { + SetLast( pKern ); + return true; + } + return false; +} + +SwTwips SwTextFormatInfo::GetLineWidth() +{ + SwTwips nLineWidth = Width() - X(); + + const bool bTabOverMargin = GetTextFrame()->GetDoc().getIDocumentSettingAccess().get( + DocumentSettingId::TAB_OVER_MARGIN); + const bool bTabOverSpacing = GetTextFrame()->GetDoc().getIDocumentSettingAccess().get( + DocumentSettingId::TAB_OVER_SPACING); + if (!bTabOverMargin && !bTabOverSpacing) + return nLineWidth; + + SwTabPortion* pLastTab = GetLastTab(); + if (!pLastTab) + return nLineWidth; + + // Consider tab portions over the printing bounds of the text frame. + if (pLastTab->GetTabPos() <= Width()) + return nLineWidth; + + // Calculate the width that starts at the left (or in case of first line: + // first) margin, but ends after the right paragraph margin: + // + // +--------------------+ + // |LL| |RR| + // +--------------------+ + // ^ m_nLeftMargin (absolute) + // ^ nLeftMarginWidth (relative to m_nLeftMargin), X() is relative to this + // ^ right margin + // ^ paragraph right + // <--------------------> is GetTextFrame()->getFrameArea().Width() + // <--------------> is Width() + // <-----------------> is what we need to be able to compare to X() (nTextFrameWidth) + SwTwips nLeftMarginWidth = m_nLeftMargin - GetTextFrame()->getFrameArea().Left(); + SwTwips nTextFrameWidth = GetTextFrame()->getFrameArea().Width() - nLeftMarginWidth; + + // If there is one such tab portion, then text is allowed to use the full + // text frame area to the right (RR above, but not LL). + nLineWidth = nTextFrameWidth - X(); + + if (!bTabOverMargin) // thus bTabOverSpacing only + { + // right, center, decimal can back-fill all the available space - same as TabOverMargin + if (pLastTab->GetWhichPor() == PortionType::TabLeft) + nLineWidth = nTextFrameWidth - pLastTab->GetTabPos(); + } + return nLineWidth; +} + +SwTextSlot::SwTextSlot( + const SwTextSizeInfo *pNew, + const SwLinePortion *pPor, + bool bTextLen, + bool bExgLists, + OUString const & rCh ) + : pOldText(nullptr) + , m_pOldSmartTagList(nullptr) + , m_pOldGrammarCheckList(nullptr) + , nIdx(0) + , nLen(0) + , nMeasureLen(0) + , pInf(nullptr) +{ + if( rCh.isEmpty() ) + { + bOn = pPor->GetExpText( *pNew, aText ); + } + else + { + aText = rCh; + bOn = true; + } + + // The text is replaced ... + if( !bOn ) + return; + + pInf = const_cast(pNew); + nIdx = pInf->GetIdx(); + nLen = pInf->GetLen(); + nMeasureLen = pInf->GetMeasureLen(); + pOldText = &(pInf->GetText()); + m_pOldCachedVclData = pInf->GetCachedVclData(); + pInf->SetText( aText ); + pInf->SetIdx(TextFrameIndex(0)); + pInf->SetLen(bTextLen ? TextFrameIndex(pInf->GetText().getLength()) : pPor->GetLen()); + if (nMeasureLen != TextFrameIndex(COMPLETE_STRING)) + pInf->SetMeasureLen(TextFrameIndex(COMPLETE_STRING)); + + pInf->SetCachedVclData(nullptr); + + // ST2 + if ( !bExgLists ) + return; + + m_pOldSmartTagList = static_cast(pInf)->GetSmartTags(); + if (m_pOldSmartTagList) + { + std::pair pos(pNew->GetTextFrame()->MapViewToModel(nIdx)); + SwWrongList const*const pSmartTags(pos.first->GetSmartTags()); + if (pSmartTags) + { + const sal_uInt16 nPos = pSmartTags->GetWrongPos(pos.second); + const sal_Int32 nListPos = pSmartTags->Pos(nPos); + if (nListPos == pos.second && pSmartTags->SubList(nPos) != nullptr) + { + m_pTempIter.reset(new sw::WrongListIterator(*pSmartTags->SubList(nPos))); + static_cast(pInf)->SetSmartTags(m_pTempIter.get()); + } + else if (!m_pTempList && nPos < pSmartTags->Count() + && nListPos < pos.second && !aText.isEmpty()) + { + m_pTempList.reset(new SwWrongList( WRONGLIST_SMARTTAG )); + m_pTempList->Insert( OUString(), nullptr, 0, aText.getLength(), 0 ); + m_pTempIter.reset(new sw::WrongListIterator(*m_pTempList)); + static_cast(pInf)->SetSmartTags(m_pTempIter.get()); + } + else + static_cast(pInf)->SetSmartTags(nullptr); + } + else + static_cast(pInf)->SetSmartTags(nullptr); + } + m_pOldGrammarCheckList = static_cast(pInf)->GetGrammarCheckList(); + if (!m_pOldGrammarCheckList) + return; + + std::pair pos(pNew->GetTextFrame()->MapViewToModel(nIdx)); + SwWrongList const*const pGrammar(pos.first->GetGrammarCheck()); + if (pGrammar) + { + const sal_uInt16 nPos = pGrammar->GetWrongPos(pos.second); + const sal_Int32 nListPos = pGrammar->Pos(nPos); + if (nListPos == pos.second && pGrammar->SubList(nPos) != nullptr) + { + m_pTempIter.reset(new sw::WrongListIterator(*pGrammar->SubList(nPos))); + static_cast(pInf)->SetGrammarCheckList(m_pTempIter.get()); + } + else if (!m_pTempList && nPos < pGrammar->Count() + && nListPos < pos.second && !aText.isEmpty()) + { + m_pTempList.reset(new SwWrongList( WRONGLIST_GRAMMAR )); + m_pTempList->Insert( OUString(), nullptr, 0, aText.getLength(), 0 ); + m_pTempIter.reset(new sw::WrongListIterator(*m_pTempList)); + static_cast(pInf)->SetGrammarCheckList(m_pTempIter.get()); + } + else + static_cast(pInf)->SetGrammarCheckList(nullptr); + } + else + static_cast(pInf)->SetGrammarCheckList(nullptr); +} + +SwTextSlot::~SwTextSlot() +{ + if( !bOn ) + return; + + pInf->SetCachedVclData(m_pOldCachedVclData); + pInf->SetText( *pOldText ); + pInf->SetIdx( nIdx ); + pInf->SetLen( nLen ); + pInf->SetMeasureLen( nMeasureLen ); + + // ST2 + // Restore old smart tag list + if (m_pOldSmartTagList) + static_cast(pInf)->SetSmartTags(m_pOldSmartTagList); + if (m_pOldGrammarCheckList) + static_cast(pInf)->SetGrammarCheckList(m_pOldGrammarCheckList); +} + +SwFontSave::SwFontSave(const SwTextSizeInfo &rInf, SwFont *pNew, + SwAttrIter* pItr) + : pInf(nullptr) + , pFnt(pNew ? const_cast(rInf).GetFont() : nullptr) + , pIter(nullptr) +{ + if( !pFnt ) + return; + + pInf = &const_cast(rInf); + // In these cases we temporarily switch to the new font: + // 1. the fonts have a different magic number + // 2. they have different script types + // 3. their background colors differ (this is not covered by 1.) + if( pFnt->DifferentFontCacheId( pNew, pFnt->GetActual() ) || + pNew->GetActual() != pFnt->GetActual() || + ( ! pNew->GetBackColor() && pFnt->GetBackColor() ) || + ( pNew->GetBackColor() && ! pFnt->GetBackColor() ) || + ( pNew->GetBackColor() && pFnt->GetBackColor() && + ( *pNew->GetBackColor() != *pFnt->GetBackColor() ) ) ) + { + pNew->SetTransparent( true ); + pNew->SetAlign( ALIGN_BASELINE ); + pInf->SetFont( pNew ); + } + else + pFnt = nullptr; + pNew->Invalidate(); + pNew->ChgPhysFnt( pInf->GetVsh(), *pInf->GetOut() ); + if( pItr && pItr->GetFnt() == pFnt ) + { + pIter = pItr; + pIter->SetFnt( pNew ); + } +} + +SwFontSave::~SwFontSave() +{ + if( pFnt ) + { + // Reset SwFont + pFnt->Invalidate(); + pInf->SetFont( pFnt ); + if( pIter ) + { + pIter->SetFnt( pFnt ); + pIter->m_nPosition = COMPLETE_STRING; + } + } +} + +bool SwTextFormatInfo::ChgHyph( const bool bNew ) +{ + const bool bOld = m_bAutoHyph; + if( m_bAutoHyph != bNew ) + { + m_bAutoHyph = bNew; + InitHyph( bNew ); + // Set language in the Hyphenator + if( m_pFnt ) + m_pFnt->ChgPhysFnt( m_pVsh, *m_pOut ); + } + return bOld; +} + + +bool SwTextFormatInfo::CheckCurrentPosBookmark() +{ + if (m_nLastBookmarkPos != GetIdx()) + { + m_nLastBookmarkPos = GetIdx(); + return true; + } + else + { + return false; + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/inftxt.hxx b/sw/source/core/text/inftxt.hxx new file mode 100644 index 0000000000..2ddaee7b2e --- /dev/null +++ b/sw/source/core/text/inftxt.hxx @@ -0,0 +1,811 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#pragma once + +#include +#include +#include + +#include + +#include +#include +#include +#include +#include "porlay.hxx" +#include +#include +#include + +namespace com::sun::star::linguistic2 { class XHyphenatedWord; } + +class SvxBrushItem; +class SvxLineSpacingItem; +class SvxTabStop; +class SvxTabStopItem; +class SwFlyPortion; +class SwFormatDrop; +class SwLinePortion; +class SwTabPortion; +class SwViewOption; +class SwViewShell; +class SwAttrIter; +struct SwMultiCreator; +class SwMultiPortion; +namespace sw { class WrongListIterator; } + +#define ARROW_WIDTH 200 +#define DIR_LEFT2RIGHT 0 +#define DIR_BOTTOM2TOP 1 +#define DIR_RIGHT2LEFT 2 +#define DIR_TOP2BOTTOM 3 + +// Respects the attribute LineSpace when calculating the Height/Ascent +class SwLineInfo +{ + friend class SwTextIter; + + std::optional m_oRuler; + const SvxLineSpacingItem *m_pSpace; + SvxParaVertAlignItem::Align m_nVertAlign; + sal_uInt16 m_nDefTabStop; + bool m_bListTabStopIncluded; + tools::Long m_nListTabStopPosition; + + void CtorInitLineInfo( const SwAttrSet& rAttrSet, + const SwTextNode& rTextNode ); + + SwLineInfo(); + ~SwLineInfo(); +public: + // #i24363# tab stops relative to indent - returns the tab stop following nSearchPos or NULL + const SvxTabStop* GetTabStop(const SwTwips nSearchPos, SwTwips& nRight) const; + const SvxLineSpacingItem *GetLineSpacing() const { return m_pSpace; } + sal_uInt16 GetDefTabStop() const { return m_nDefTabStop; } + void SetDefTabStop( sal_uInt16 nNew ) const + { const_cast(this)->m_nDefTabStop = nNew; } + + // vertical alignment + SvxParaVertAlignItem::Align GetVertAlign() const { return m_nVertAlign; } + bool HasSpecialAlign( bool bVert ) const + { return bVert ? + ( SvxParaVertAlignItem::Align::Baseline != m_nVertAlign ) : + ( SvxParaVertAlignItem::Align::Baseline != m_nVertAlign && + SvxParaVertAlignItem::Align::Automatic != m_nVertAlign ); } + + sal_uInt16 NumberOfTabStops() const; + + bool IsListTabStopIncluded() const + { + return m_bListTabStopIncluded; + } + tools::Long GetListTabStopPosition() const + { + return m_nListTabStopPosition; + } +}; + +class SwTextInfo +{ + // Implementation in txthyph.cxx + friend void SetParaPortion( SwTextInfo *pInf, SwParaPortion *pRoot ); + SwParaPortion *m_pPara; + TextFrameIndex m_nTextStart; // TextOfst for Follows + +protected: + SwTextInfo() + : m_pPara(nullptr) + , m_nTextStart(0) + {} + +public: + void CtorInitTextInfo( SwTextFrame *pFrame ); + SwTextInfo( const SwTextInfo &rInf ); + explicit SwTextInfo( SwTextFrame *pFrame ) { CtorInitTextInfo( pFrame ); } + SwParaPortion *GetParaPortion() { return m_pPara; } + const SwParaPortion *GetParaPortion() const { return m_pPara; } + TextFrameIndex GetTextStart() const { return m_nTextStart; } +}; + +class SwTextSizeInfo : public SwTextInfo +{ +private: + typedef std::map< SwLinePortion const *, sal_uInt16 > SwTextPortionMap; + +protected: + // during formatting, a small database is built, mapping portion pointers + // to their maximum size (used for kana compression) + SwTextPortionMap m_aMaxWidth; + // for each line, an array of compression values is calculated + // this array is passed over to the info structure + std::deque* m_pKanaComp; + + SwViewShell *m_pVsh; + + // m_pOut is the output device, m_pRef is the device used for formatting + VclPtr m_pOut; + VclPtr m_pRef; + + // performance hack - this is only used by SwTextFormatInfo but + // because it's not even possible to dynamic_cast these things + // currently it has to be stored here + std::shared_ptr m_pCachedVclData; + + SwFont *m_pFnt; + SwUnderlineFont *m_pUnderFnt; // Font for underlining + SwTextFrame *m_pFrame; + const SwViewOption *m_pOpt; + const OUString *m_pText; + TextFrameIndex m_nIdx; + TextFrameIndex m_nLen; + TextFrameIndex m_nMeasureLen; + sal_uInt16 m_nKanaIdx; + bool m_bOnWin : 1; + bool m_bNotEOL : 1; + bool m_bURLNotify : 1; + bool m_bStopUnderflow : 1; // Underflow was stopped e.g. by a FlyPortion + bool m_bFootnoteInside : 1; // the current line contains a footnote + bool m_bOtherThanFootnoteInside : 1; // the current line contains another portion than a footnote portion. + // needed for checking keep together of footnote portion with previous portion + bool m_bMulti : 1; // inside a multiportion + bool m_bFirstMulti : 1; // this flag is used for two purposes: + // - the multiportion is the first lineportion + // - indicates, if we are currently in second + // line of multi portion + bool m_bRuby : 1; // during the formatting of a phonetic line + bool m_bHanging : 1; // formatting of hanging punctuation allowed + bool m_bScriptSpace : 1; // space between different scripts (Asian/Latin) + bool m_bForbiddenChars : 1; // Forbidden start/endline characters + bool m_bSnapToGrid : 1; // paragraph snaps to grid + sal_uInt8 m_nDirection : 2; // writing direction: 0/90/180/270 degree + +protected: + void CtorInitTextSizeInfo( OutputDevice* pRenderContext, SwTextFrame *pFrame, + TextFrameIndex nIdx); + SwTextSizeInfo(); +public: + SwTextSizeInfo( const SwTextSizeInfo &rInf ); + SwTextSizeInfo( const SwTextSizeInfo &rInf, const OUString* pText, + TextFrameIndex nIdx = TextFrameIndex(0) ); + SwTextSizeInfo(SwTextFrame *pTextFrame, TextFrameIndex nIndex = TextFrameIndex(0)); + + // GetMultiAttr returns the text attribute of the multiportion, + // if rPos is inside any multi-line part. + // rPos will set to the end of the multi-line part. + std::optional GetMultiCreator(TextFrameIndex &rPos, SwMultiPortion const* pM) const; + + bool OnWin() const { return m_bOnWin; } + void SetOnWin( const bool bNew ) { m_bOnWin = bNew; } + bool NotEOL() const { return m_bNotEOL; } + void SetNotEOL( const bool bNew ) { m_bNotEOL = bNew; } + bool URLNotify() const { return m_bURLNotify; } + bool StopUnderflow() const { return m_bStopUnderflow; } + void SetStopUnderflow( const bool bNew ) { m_bStopUnderflow = bNew; } + bool IsFootnoteInside() const { return m_bFootnoteInside; } + void SetFootnoteInside( const bool bNew ) { m_bFootnoteInside = bNew; } + bool IsOtherThanFootnoteInside() const { return m_bOtherThanFootnoteInside; } + void SetOtherThanFootnoteInside( const bool bNew ) { m_bOtherThanFootnoteInside = bNew; } + bool IsMulti() const { return m_bMulti; } + void SetMulti( const bool bNew ) { m_bMulti = bNew; } + bool IsFirstMulti() const { return m_bFirstMulti; } + void SetFirstMulti( const bool bNew ) { m_bFirstMulti = bNew; } + bool IsRuby() const { return m_bRuby; } + void SetRuby( const bool bNew ) { m_bRuby = bNew; } + bool IsHanging() const { return m_bHanging; } + void SetHanging( const bool bNew ) { m_bHanging = bNew; } + bool HasScriptSpace() const { return m_bScriptSpace; } + void SetScriptSpace( const bool bNew ) { m_bScriptSpace = bNew; } + bool HasForbiddenChars() const { return m_bForbiddenChars; } + void SetForbiddenChars( const bool bN ) { m_bForbiddenChars = bN; } + bool SnapToGrid() const { return m_bSnapToGrid; } + void SetSnapToGrid( const bool bN ) { m_bSnapToGrid = bN; } + sal_uInt8 GetDirection() const { return m_nDirection; } + void SetDirection( const sal_uInt8 nNew ) { m_nDirection = nNew; } + bool IsRotated() const { return ( 1 & m_nDirection ); } + + SwViewShell *GetVsh() { return m_pVsh; } + const SwViewShell *GetVsh() const { return m_pVsh; } + + vcl::RenderContext *GetOut() { return m_pOut; } + const vcl::RenderContext *GetOut() const { return m_pOut; } + void SetOut( OutputDevice* pNewOut ) { m_pOut = pNewOut; } + + vcl::RenderContext *GetRefDev() { return m_pRef; } + const vcl::RenderContext *GetRefDev() const { return m_pRef; } + + SwFont *GetFont() { return m_pFnt; } + const SwFont *GetFont() const { return m_pFnt; } + void SetFont( SwFont *pNew ) { m_pFnt = pNew; } + void SelectFont(); + void SetUnderFnt( SwUnderlineFont* pNew ) { m_pUnderFnt = pNew; } + SwUnderlineFont* GetUnderFnt() const { return m_pUnderFnt; } + + const SwViewOption &GetOpt() const { return *m_pOpt; } + const OUString &GetText() const { return *m_pText; } + sal_Unicode GetChar(TextFrameIndex const nPos) const { + if (m_pText && nPos < TextFrameIndex(m_pText->getLength())) return (*m_pText)[sal_Int32(nPos)]; + return 0; + } + + sal_uInt16 GetTextHeight() const; + + SwPosSize GetTextSize( OutputDevice* pOut, const SwScriptInfo* pSI, + const OUString& rText, TextFrameIndex nIdx, + TextFrameIndex nLen ) const; + SwPosSize GetTextSize() const; + void GetTextSize( const SwScriptInfo* pSI, TextFrameIndex nIdx, + TextFrameIndex nLen, const sal_uInt16 nComp, + sal_uInt16& nMinSize, sal_uInt16& nMaxSizeDiff, + vcl::text::TextLayoutCache const* = nullptr) const; + inline SwPosSize GetTextSize(const SwScriptInfo* pSI, TextFrameIndex nIdx, + TextFrameIndex nLen) const; + inline SwPosSize GetTextSize( const OUString &rText ) const; + + TextFrameIndex GetTextBreak( const tools::Long nLineWidth, + const TextFrameIndex nMaxLen, + const sal_uInt16 nComp, + vcl::text::TextLayoutCache const*) const; + TextFrameIndex GetTextBreak( const tools::Long nLineWidth, + const TextFrameIndex nMaxLen, + const sal_uInt16 nComp, + TextFrameIndex& rExtraCharPos, + vcl::text::TextLayoutCache const*) const; + + sal_uInt16 GetAscent() const; + sal_uInt16 GetHangingBaseline() const; + + TextFrameIndex GetIdx() const { return m_nIdx; } + void SetIdx(const TextFrameIndex nNew) { m_nIdx = nNew; } + TextFrameIndex GetLen() const { return m_nLen; } + void SetLen(const TextFrameIndex nNew) { m_nLen = nNew; } + TextFrameIndex GetMeasureLen() const { return m_nMeasureLen; } + void SetMeasureLen(const TextFrameIndex nNew) { m_nMeasureLen = nNew; } + void SetText( const OUString &rNew ){ m_pText = &rNew; } + + // No Bullets for the symbol font! + bool IsNoSymbol() const + { return RTL_TEXTENCODING_SYMBOL != m_pFnt->GetCharSet( m_pFnt->GetActual() ); } + + void NoteAnimation() const; + + // Home is where Your heart is... + SwTextFrame *GetTextFrame() { return m_pFrame; } + const SwTextFrame *GetTextFrame() const { return m_pFrame; } + + bool HasHint(TextFrameIndex nPos) const; + + // If Kana Compression is enabled, a minimum and maximum portion width + // is calculated. We format lines with minimal size and share remaining + // space among compressed kanas. + // During formatting, the maximum values of compressible portions are + // stored in m_aMaxWidth and discarded after a line has been formatted. + void SetMaxWidthDiff( const SwLinePortion *nKey, sal_uInt16 nVal ) + { + m_aMaxWidth.insert( std::make_pair( nKey, nVal ) ); + }; + sal_uInt16 GetMaxWidthDiff( const SwLinePortion *nKey ) + { + SwTextPortionMap::iterator it = m_aMaxWidth.find( nKey ); + + if( it != m_aMaxWidth.end() ) + return it->second; + else + return 0; + }; + void ResetMaxWidthDiff() + { + m_aMaxWidth.clear(); + }; + bool CompressLine() + { + return !m_aMaxWidth.empty(); + }; + + // Feature: Kana Compression + + sal_uInt16 GetKanaIdx() const { return m_nKanaIdx; } + void ResetKanaIdx(){ m_nKanaIdx = 0; } + void SetKanaIdx( sal_uInt16 nNew ) { m_nKanaIdx = nNew; } + void IncKanaIdx() { ++m_nKanaIdx; } + void SetKanaComp( std::deque *pNew ){ m_pKanaComp = pNew; } + std::deque* GetpKanaComp() const { return m_pKanaComp; } + sal_uInt16 GetKanaComp() const + { return ( m_pKanaComp && m_nKanaIdx < m_pKanaComp->size() ) + ? (*m_pKanaComp)[m_nKanaIdx] : 0; } + + const std::shared_ptr& GetCachedVclData() const + { + return m_pCachedVclData; + } + void SetCachedVclData(std::shared_ptr const& pCachedVclData) + { + m_pCachedVclData = pCachedVclData; + } +}; + +class SwTextPaintInfo : public SwTextSizeInfo +{ + sw::WrongListIterator *m_pWrongList; + sw::WrongListIterator *m_pGrammarCheckList; + sw::WrongListIterator *m_pSmartTags; + std::vector* m_pSpaceAdd; + const SvxBrushItem *m_pBrushItem; // For the background + SwTextFly m_aTextFly; // Calculate the FlyFrame + Point m_aPos; // Paint position + SwRect m_aPaintRect; // Original paint rect (from Layout paint) + + sal_uInt16 m_nSpaceIdx; + void DrawText_(const OUString &rText, const SwLinePortion &rPor, + const TextFrameIndex nIdx, const TextFrameIndex nLen, + const bool bKern, const bool bWrong = false, + const bool bSmartTag = false, + const bool bGrammarCheck = false ); + + SwTextPaintInfo &operator=(const SwTextPaintInfo&) = delete; + +protected: + SwTextPaintInfo() + : m_pWrongList(nullptr) + , m_pGrammarCheckList(nullptr) + , m_pSmartTags(nullptr) + , m_pSpaceAdd(nullptr) + , m_pBrushItem(nullptr) + , m_nSpaceIdx(0) + {} + +public: + SwTextPaintInfo( const SwTextPaintInfo &rInf ); + SwTextPaintInfo( const SwTextPaintInfo &rInf, const OUString* pText ); + + void CtorInitTextPaintInfo( OutputDevice* pRenderContext, SwTextFrame *pFrame, const SwRect &rPaint ); + + const SvxBrushItem *GetBrushItem() const { return m_pBrushItem; } + + SwTextPaintInfo( SwTextFrame *pFrame, const SwRect &rPaint ); + + SwTwips X() const { return m_aPos.X(); } + void X( const tools::Long nNew ) { m_aPos.setX(nNew); } + SwTwips Y() const { return m_aPos.Y(); } + void Y( const SwTwips nNew ) { m_aPos.setY(nNew); } + + SwTextFly& GetTextFly() { return m_aTextFly; } + const SwTextFly& GetTextFly() const { return m_aTextFly; } + inline void DrawText( const OUString &rText, const SwLinePortion &rPor, + TextFrameIndex nIdx = TextFrameIndex(0), + TextFrameIndex nLen = TextFrameIndex(COMPLETE_STRING), + const bool bKern = false) const; + inline void DrawText( const SwLinePortion &rPor, TextFrameIndex nLen, + const bool bKern = false ) const; + inline void DrawMarkedText( const SwLinePortion &rPor, TextFrameIndex nLen, + const bool bWrong, + const bool bSmartTags, + const bool bGrammarCheck ) const; + + void DrawRect( const SwRect &rRect, bool bRetouche ) const; + + void DrawTab( const SwLinePortion &rPor ) const; + void DrawLineBreak( const SwLinePortion &rPor ) const; + void DrawRedArrow( const SwLinePortion &rPor ) const; + void DrawPostIts( bool bScript ) const; + void DrawBackground( const SwLinePortion &rPor, const Color *pColor=nullptr ) const; + void DrawViewOpt( const SwLinePortion &rPor, PortionType nWhich, const Color *pColor=nullptr ) const; + void DrawBackBrush( const SwLinePortion &rPor ) const; + + /** + * Draw character border around a line portion. + * + * @param[in] rPor line portion around which border have to be drawn. + **/ + void DrawBorder( const SwLinePortion &rPor ) const; + + void DrawCheckBox(const SwFieldFormCheckboxPortion &rPor, bool bChecked) const; + + void DrawCSDFHighlighting(const SwLinePortion &rPor) const; + + /** + * Calculate the rectangular area where the portion takes place. + * @param[in] rPor portion for which the method specify the painting area + * @param[out] pRect whole area of the portion + * @param[out] pIntersect part of the portion area clipped by OutputDevice's clip region + * @param[in] bInsideBox area of portion's content, padding and border, but shadow + * is excluded (e.g. for background) + **/ + void CalcRect( const SwLinePortion& rPor, SwRect* pRect, + SwRect* pIntersect = nullptr, const bool bInsideBox = false ) const; + + inline SwTwips GetPaintOfst() const; + inline void SetPaintOfst( const SwTwips nNew ); + const Point &GetPos() const { return m_aPos; } + void SetPos( const Point &rNew ) { m_aPos = rNew; } + + const SwRect &GetPaintRect() const { return m_aPaintRect; } + + // STUFF FOR JUSTIFIED ALIGNMENT + + sal_uInt16 GetSpaceIdx() const { return m_nSpaceIdx; } + void ResetSpaceIdx(){m_nSpaceIdx = 0; } + void SetSpaceIdx( sal_uInt16 nNew ) { m_nSpaceIdx = nNew; } + void IncSpaceIdx() { ++m_nSpaceIdx; } + void RemoveFirstSpaceAdd() { m_pSpaceAdd->erase( m_pSpaceAdd->begin() ); } + tools::Long GetSpaceAdd( bool bShrink = false ) const + { return ( m_pSpaceAdd && m_nSpaceIdx < m_pSpaceAdd->size() && + // get shrink data only if asked explicitly, otherwise zero it + ( bShrink || (*m_pSpaceAdd)[m_nSpaceIdx] < LONG_MAX/2 ) ) + ? (*m_pSpaceAdd)[m_nSpaceIdx] : 0; } + + void SetpSpaceAdd( std::vector* pNew ){ m_pSpaceAdd = pNew; } + std::vector* GetpSpaceAdd() const { return m_pSpaceAdd; } + + void SetWrongList(sw::WrongListIterator *const pNew) { m_pWrongList = pNew; } + sw::WrongListIterator* GetpWrongList() const { return m_pWrongList; } + + void SetGrammarCheckList(sw::WrongListIterator *const pNew) { m_pGrammarCheckList = pNew; } + sw::WrongListIterator* GetGrammarCheckList() const { return m_pGrammarCheckList; } + + void SetSmartTags(sw::WrongListIterator *const pNew) { m_pSmartTags = pNew; } + sw::WrongListIterator* GetSmartTags() const { return m_pSmartTags; } +}; + +class SwTextFormatInfo : public SwTextPaintInfo +{ + // temporary arguments for hyphenation + css::beans::PropertyValues m_aHyphVals; + + SwLineLayout *m_pRoot; // The Root of the current line (pCurr) + SwLinePortion *m_pLast; // The last Portion + SwFlyPortion *m_pFly; // The following FlyPortion + SwLinePortion *m_pUnderflow; // Underflow: Last Portion + SwLinePortion *m_pRest; // The Rest is the start of the next Line + + SwTabPortion *m_pLastTab; // The _last_ TabPortion + + TextFrameIndex m_nSoftHyphPos; ///< SoftHyphPos for Hyphenation + TextFrameIndex m_nLineStart; ///< Current line start in rText + TextFrameIndex m_nUnderScorePos; ///< enlarge repaint if underscore has been found + TextFrameIndex m_nLastBookmarkPos; ///< need to check for bookmarks at every portion + // #i34348# Changed type from sal_uInt16 to SwTwips + SwTwips m_nLeft; // Left margin + SwTwips m_nRight; // Right margin + SwTwips m_nFirst; // EZE + /// First or left margin, depending on context. + SwTwips m_nLeftMargin = 0; + sal_uInt16 m_nRealWidth; // "real" line width + sal_uInt16 m_nWidth; // "virtual" line width + sal_uInt16 m_nLineHeight; // Final height after CalcLine + sal_uInt16 m_nLineNetHeight; // line height without spacing + sal_uInt16 m_nForcedLeftMargin; // Shift of left margin due to frame + + bool m_bFull : 1; // Line is full + bool m_bFootnoteDone : 1; // Footnote already formatted + bool m_bErgoDone : 1; // ErgoDone already formatted + bool m_bNumDone : 1; // bNumDone already formatted + bool m_bArrowDone : 1; // Arrow to the left for scrolling paragraphs + bool m_bStop : 1; // Cancel immediately, discarding the line + bool m_bNewLine : 1; // Format another line + bool m_bShift : 1; // Position change: Repaint until further notice + bool m_bUnderflow : 1; // Context: Underflow() ? + bool m_bInterHyph : 1; // Interactive hyphenation? + bool m_bAutoHyph : 1; // Automatic hyphenation? + bool m_bDropInit : 1; // Set DropWidth + bool m_bQuick : 1; // FormatQuick() + bool m_bNoEndHyph : 1; // Switch off hyphenation at the line end (due to MaxHyphens) + bool m_bNoMidHyph : 1; // Switch off hyphenation before flys (due to MaxHyphens) + bool m_bIgnoreFly : 1; // FitToContent ignores flys + bool m_bFakeLineStart : 1; // String has been replaced by field portion + // info structure only pretends that we are at + // the beginning of a line + bool m_bTabOverflow : 1; // Tabs are expanding after the end margin + bool m_bTestFormat : 1; // Test formatting from WouldFit, no notification etc. + + sal_Unicode m_cTabDecimal; // the current decimal delimiter + sal_Unicode m_cHookChar; // For tabs in fields etc. + sal_uInt8 m_nMaxHyph; // Max. line count of followup hyphenations + + // Used to stop justification after center/right/decimal tab stops - see tdf#tdf#106234 + enum class TabSeen + { + None, + Left, + Center, + Right, + Decimal, + } m_eLastTabsSeen = TabSeen::None; + + // Hyphenating ... + bool InitHyph( const bool bAuto = false ); + bool CheckFootnotePortion_( SwLineLayout const * pCurr ); + +public: + void CtorInitTextFormatInfo( OutputDevice* pRenderContext, SwTextFrame *pFrame, const bool bInterHyph = false, + const bool bQuick = false, const bool bTst = false ); + SwTextFormatInfo(OutputDevice* pRenderContext, SwTextFrame *pFrame, const bool bInterHyphL = false, + const bool bQuickL = false, const bool bTst = false); + + // For the formatting inside a double line in a line (multi-line portion) + // we need a modified text-format-info: + SwTextFormatInfo( const SwTextFormatInfo& rInf, SwLineLayout& rLay, + SwTwips nActWidth ); + + sal_uInt16 Width() const { return m_nWidth; } + void Width( const sal_uInt16 nNew ) { m_nWidth = nNew; } + void Init(); + + /** + * Returns the distance between the current horizontal position and the end + * of the line. + */ + SwTwips GetLineWidth(); + + // Returns the first changed position of the paragraph + inline TextFrameIndex GetReformatStart() const; + + // Margins + SwTwips Left() const { return m_nLeft; } + void Left( const SwTwips nNew ) { m_nLeft = nNew; } + SwTwips Right() const { return m_nRight; } + void Right( const SwTwips nNew ) { m_nRight = nNew; } + SwTwips First() const { return m_nFirst; } + void First( const SwTwips nNew ) { m_nFirst = nNew; } + void LeftMargin( const SwTwips nNew) { m_nLeftMargin = nNew; } + sal_uInt16 RealWidth() const { return m_nRealWidth; } + void RealWidth( const sal_uInt16 nNew ) { m_nRealWidth = nNew; } + sal_uInt16 ForcedLeftMargin() const { return m_nForcedLeftMargin; } + void ForcedLeftMargin( const sal_uInt16 nN ) { m_nForcedLeftMargin = nN; } + + sal_uInt8 &MaxHyph() { return m_nMaxHyph; } + const sal_uInt8 &MaxHyph() const { return m_nMaxHyph; } + + SwLineLayout *GetRoot() { return m_pRoot; } + const SwLineLayout *GetRoot() const { return m_pRoot; } + + void SetRoot( SwLineLayout *pNew ) { m_pRoot = pNew; } + SwLinePortion *GetLast() { return m_pLast; } + void SetLast(SwLinePortion* pNewLast); + bool IsFull() const { return m_bFull; } + void SetFull( const bool bNew ) { m_bFull = bNew; } + bool IsHyphForbud() const + { return m_pFly ? m_bNoMidHyph : m_bNoEndHyph; } + void ChkNoHyph( const sal_uInt8 bEnd, const sal_uInt8 bMid ) + { m_bNoEndHyph = (m_nMaxHyph && bEnd >= m_nMaxHyph); + m_bNoMidHyph = (m_nMaxHyph && bMid >= m_nMaxHyph); } + bool IsIgnoreFly() const { return m_bIgnoreFly; } + void SetIgnoreFly( const bool bNew ) { m_bIgnoreFly = bNew; } + bool IsFakeLineStart() const { return m_bFakeLineStart; } + void SetFakeLineStart( const bool bNew ) { m_bFakeLineStart = bNew; } + bool IsStop() const { return m_bStop; } + void SetStop( const bool bNew ) { m_bStop = bNew; } + SwLinePortion *GetRest() { return m_pRest; } + void SetRest( SwLinePortion *pNewRest ) { m_pRest = pNewRest; } + bool IsNewLine() const { return m_bNewLine; } + void SetNewLine( const bool bNew ) { m_bNewLine = bNew; } + bool IsShift() const { return m_bShift; } + void SetShift( const bool bNew ) { m_bShift = bNew; } + bool IsInterHyph() const { return m_bInterHyph; } + bool IsUnderflow() const { return m_bUnderflow; } + void ClrUnderflow() { m_bUnderflow = false; } + bool IsDropInit() const { return m_bDropInit; } + void SetDropInit( const bool bNew ) { m_bDropInit = bNew; } + bool IsQuick() const { return m_bQuick; } + bool IsTest() const { return m_bTestFormat; } + // see tdf#106234 + void UpdateTabSeen(PortionType); + bool DontBlockJustify() const + { + return m_eLastTabsSeen == TabSeen::Center || m_eLastTabsSeen == TabSeen::Right + || m_eLastTabsSeen == TabSeen::Decimal; + } + + TextFrameIndex GetLineStart() const { return m_nLineStart; } + void SetLineStart(TextFrameIndex const nNew) { m_nLineStart = nNew; } + + // these are used during fly calculation + sal_uInt16 GetLineHeight() const { return m_nLineHeight; } + void SetLineHeight( const sal_uInt16 nNew ) { m_nLineHeight = nNew; } + sal_uInt16 GetLineNetHeight() const { return m_nLineNetHeight; } + void SetLineNetHeight( const sal_uInt16 nNew ) { m_nLineNetHeight = nNew; } + + const SwLinePortion *GetUnderflow() const { return m_pUnderflow; } + SwLinePortion *GetUnderflow() { return m_pUnderflow; } + void SetUnderflow( SwLinePortion *pNew ) + { m_pUnderflow = pNew; m_bUnderflow = true; } + TextFrameIndex GetSoftHyphPos() const { return m_nSoftHyphPos; } + void SetSoftHyphPos(TextFrameIndex const nNew) { m_nSoftHyphPos = nNew; } + + inline void SetParaFootnote(); + + // FlyFrames + SwFlyPortion *GetFly() { return m_pFly; } + void SetFly( SwFlyPortion *pNew ) { m_pFly = pNew; } + + inline const SwAttrSet& GetCharAttr() const; + + // Tabs + SwTabPortion *GetLastTab() { return m_pLastTab; } + void SetLastTab( SwTabPortion *pNew ) { m_pLastTab = pNew; } + sal_Unicode GetTabDecimal() const { return m_cTabDecimal; } + void SetTabDecimal( const sal_Unicode cNew ) { m_cTabDecimal = cNew;} + + void ClearHookChar() { m_cHookChar = 0; } + void SetHookChar( const sal_Unicode cNew ) { m_cHookChar = cNew; } + sal_Unicode GetHookChar() const { return m_cHookChar; } + + // Done-Flags + bool IsFootnoteDone() const { return m_bFootnoteDone; } + void SetFootnoteDone( const bool bNew ) { m_bFootnoteDone = bNew; } + bool IsErgoDone() const { return m_bErgoDone; } + void SetErgoDone( const bool bNew ) { m_bErgoDone = bNew; } + bool IsNumDone() const { return m_bNumDone; } + void SetNumDone( const bool bNew ) { m_bNumDone = bNew; } + bool IsArrowDone() const { return m_bArrowDone; } + void SetArrowDone( const bool bNew ) { m_bArrowDone = bNew; } + + bool CheckCurrentPosBookmark(); + + // For SwTextPortion::Hyphenate + bool ChgHyph( const bool bNew ); + + // Should the hyphenate helper be discarded? + bool IsHyphenate() const; + TextFrameIndex GetUnderScorePos() const { return m_nUnderScorePos; } + void SetUnderScorePos(TextFrameIndex const nNew) { m_nUnderScorePos = nNew; } + + // Calls HyphenateWord() of Hyphenator + css::uno::Reference< css::linguistic2::XHyphenatedWord > + HyphWord( const OUString &rText, const sal_Int32 nMinTrail ); + const css::beans::PropertyValues & GetHyphValues() const; + + bool CheckFootnotePortion( SwLineLayout const * pCurr ) + { return IsFootnoteInside() && CheckFootnotePortion_( pCurr ); } + + // Dropcaps called by SwTextFormatter::CTOR + const SwFormatDrop *GetDropFormat() const; + + // Sets the last SwKernPortion as pLast, if it is followed by empty portions + bool LastKernPortion(); + + // Looks for tabs, TabDec, TXTATR and BRK from nIdx until nEnd. + // Return: Position; sets cHookChar if necessary + TextFrameIndex ScanPortionEnd(TextFrameIndex nStart, TextFrameIndex nEnd); + + void SetTabOverflow( bool bOverflow ) { m_bTabOverflow = bOverflow; } + bool IsTabOverflow() const { return m_bTabOverflow; } + +}; + +/** + * For the text replacement and restoration of SwTextSizeInfo. + * The way this is done is a bit of a hack: Although rInf is const we change it + * anyway. + * Because rInf is restored again in the DTOR, we can do this. + * You could call it a "logical const", if you wish. + */ +class SwTextSlot final +{ + OUString aText; + std::shared_ptr m_pOldCachedVclData; + const OUString *pOldText; + sw::WrongListIterator * m_pOldSmartTagList; + sw::WrongListIterator * m_pOldGrammarCheckList; + std::unique_ptr m_pTempList; + std::unique_ptr m_pTempIter; + TextFrameIndex nIdx; + TextFrameIndex nLen; + TextFrameIndex nMeasureLen; + bool bOn; + SwTextSizeInfo *pInf; + +public: + // The replacement string originates either from the portion via GetExpText() + // or from the rCh, if it is not empty. + SwTextSlot( const SwTextSizeInfo *pNew, const SwLinePortion *pPor, bool bTextLen, + bool bExgLists, OUString const & rCh = OUString() ); + ~SwTextSlot(); +}; + +class SwFontSave +{ + SwTextSizeInfo *pInf; + SwFont *pFnt; + SwAttrIter *pIter; +public: + SwFontSave( const SwTextSizeInfo &rInf, SwFont *pFnt, + SwAttrIter* pItr = nullptr ); + ~SwFontSave(); +}; + +inline sal_uInt16 SwTextSizeInfo::GetAscent() const +{ + assert(GetOut()); + return const_cast(GetFont())->GetAscent( m_pVsh, *GetOut() ); +} + +inline sal_uInt16 SwTextSizeInfo::GetTextHeight() const +{ + assert(GetOut()); + return const_cast(GetFont())->GetHeight( m_pVsh, *GetOut() ); +} + +inline sal_uInt16 SwTextSizeInfo::GetHangingBaseline() const +{ + assert(GetOut()); + return const_cast(GetFont())->GetHangingBaseline( m_pVsh, *GetOut() ); +} + +inline SwPosSize SwTextSizeInfo::GetTextSize( const OUString &rText ) const +{ + return GetTextSize(m_pOut, nullptr, rText, TextFrameIndex(0), TextFrameIndex(rText.getLength())); +} + +inline SwPosSize SwTextSizeInfo::GetTextSize( const SwScriptInfo* pSI, + TextFrameIndex const nNewIdx, + TextFrameIndex const nNewLen) const +{ + return GetTextSize( m_pOut, pSI, *m_pText, nNewIdx, nNewLen ); +} + +inline SwTwips SwTextPaintInfo::GetPaintOfst() const +{ + return GetParaPortion()->GetRepaint().GetOffset(); +} + +inline void SwTextPaintInfo::SetPaintOfst( const SwTwips nNew ) +{ + GetParaPortion()->GetRepaint().SetOffset( nNew ); +} + +inline void SwTextPaintInfo::DrawText( const OUString &rText, + const SwLinePortion &rPor, + const TextFrameIndex nStart, const TextFrameIndex nLength, + const bool bKern ) const +{ + const_cast(this)->DrawText_( rText, rPor, nStart, nLength, bKern ); +} + +inline void SwTextPaintInfo::DrawText( const SwLinePortion &rPor, + const TextFrameIndex nLength, const bool bKern ) const +{ + const_cast(this)->DrawText_( *m_pText, rPor, m_nIdx, nLength, bKern ); +} + +inline void SwTextPaintInfo::DrawMarkedText( const SwLinePortion &rPor, + const TextFrameIndex nLength, + const bool bWrong, + const bool bSmartTags, + const bool bGrammarCheck ) const +{ + const_cast(this)->DrawText_( *m_pText, rPor, m_nIdx, nLength, false/*bKern*/, bWrong, bSmartTags, bGrammarCheck ); +} + +inline TextFrameIndex SwTextFormatInfo::GetReformatStart() const +{ + return GetParaPortion()->GetReformat().Start(); +} + +inline const SwAttrSet& SwTextFormatInfo::GetCharAttr() const +{ + // sw_redlinehide: this is used for numbering/footnote number portions, so: + return GetTextFrame()->GetTextNodeForParaProps()->GetSwAttrSet(); +} + +inline void SwTextFormatInfo::SetParaFootnote() +{ + GetTextFrame()->SetFootnote( true ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/itradj.cxx b/sw/source/core/text/itradj.cxx new file mode 100644 index 0000000000..4dcaf03df1 --- /dev/null +++ b/sw/source/core/text/itradj.cxx @@ -0,0 +1,852 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include + +#include + +#include +#include + +#include "itrtxt.hxx" +#include "porglue.hxx" +#include "porlay.hxx" +#include "porfly.hxx" +#include "pormulti.hxx" +#include "portab.hxx" +#include + +#define MIN_TAB_WIDTH 60 + +using namespace ::com::sun::star; + +void SwTextAdjuster::FormatBlock( ) +{ + // Block format does not apply to the last line. + // And for tabs it doesn't exist out of tradition + // If we have Flys we continue. + + const SwLinePortion *pFly = nullptr; + + bool bSkip = !IsLastBlock() && + m_nStart + m_pCurr->GetLen() >= TextFrameIndex(GetInfo().GetText().getLength()); + + // Multi-line fields are tricky, because we need to check whether there are + // any other text portions in the paragraph. + if( bSkip ) + { + const SwLineLayout *pLay = m_pCurr->GetNext(); + while( pLay && !pLay->GetLen() ) + { + const SwLinePortion *pPor = m_pCurr->GetFirstPortion(); + while( pPor && bSkip ) + { + if( pPor->InTextGrp() ) + bSkip = false; + pPor = pPor->GetNextPortion(); + } + pLay = bSkip ? pLay->GetNext() : nullptr; + } + } + + if( bSkip ) + { + if( !GetInfo().GetParaPortion()->HasFly() ) + { + if( IsLastCenter() ) + CalcFlyAdjust( m_pCurr ); + m_pCurr->FinishSpaceAdd(); + return; + } + else + { + const SwLinePortion *pTmpFly = nullptr; + + // End at the last Fly + const SwLinePortion *pPos = m_pCurr->GetFirstPortion(); + while( pPos ) + { + // Look for the last Fly which has text coming after it: + if( pPos->IsFlyPortion() ) + pTmpFly = pPos; // Found a Fly + else if ( pTmpFly && pPos->InTextGrp() ) + { + pFly = pTmpFly; // A Fly with follow-up text! + pTmpFly = nullptr; + } + pPos = pPos->GetNextPortion(); + } + // End if we didn't find one + if( !pFly ) + { + if( IsLastCenter() ) + CalcFlyAdjust( m_pCurr ); + m_pCurr->FinishSpaceAdd(); + return; + } + } + } + + const TextFrameIndex nOldIdx = GetInfo().GetIdx(); + GetInfo().SetIdx( m_nStart ); + CalcNewBlock( m_pCurr, pFly ); + GetInfo().SetIdx( nOldIdx ); + GetInfo().GetParaPortion()->GetRepaint().SetOffset(0); +} + +static bool lcl_CheckKashidaPositions( SwScriptInfo& rSI, SwTextSizeInfo& rInf, SwTextIter& rItr, + sal_Int32& rKashidas, TextFrameIndex& nGluePortion) +{ + // i60594 validate Kashida justification + TextFrameIndex nIdx = rItr.GetStart(); + TextFrameIndex nEnd = rItr.GetEnd(); + + // Note on calling KashidaJustify(): + // Kashida positions may be marked as invalid. Therefore KashidaJustify may return the clean + // total number of kashida positions, or the number of kashida positions after some positions + // have been dropped. + // Here we want the clean total, which is OK: We have called ClearKashidaInvalid() before. + rKashidas = rSI.KashidaJustify(nullptr, nullptr, rItr.GetStart(), rItr.GetLength()); + + if (rKashidas <= 0) // nothing to do + return true; + + // kashida positions found in SwScriptInfo are not necessarily valid in every font + // if two characters are replaced by a ligature glyph, there will be no place for a kashida + std::vector aKashidaPos; + rSI.GetKashidaPositions(nIdx, rItr.GetLength(), aKashidaPos); + assert(aKashidaPos.size() >= o3tl::make_unsigned(rKashidas)); + std::vector aKashidaPosDropped(aKashidaPos.size()); + sal_Int32 nKashidaIdx = 0; + while ( rKashidas && nIdx < nEnd ) + { + rItr.SeekAndChgAttrIter( nIdx, rInf.GetOut() ); + TextFrameIndex nNext = rItr.GetNextAttr(); + + // is there also a script change before? + // if there is, nNext should point to the script change + TextFrameIndex const nNextScript = rSI.NextScriptChg( nIdx ); + if( nNextScript < nNext ) + nNext = nNextScript; + + if (nNext == TextFrameIndex(COMPLETE_STRING) || nNext > nEnd) + nNext = nEnd; + sal_Int32 nKashidasInAttr = rSI.KashidaJustify(nullptr, nullptr, nIdx, nNext - nIdx); + if (nKashidasInAttr > 0) + { + // Kashida glyph looks suspicious, skip Kashida justification + if ( rInf.GetOut()->GetMinKashida() <= 0 ) + { + return false; + } + + sal_Int32 nKashidasDropped = 0; + if ( !SwScriptInfo::IsArabicText( rInf.GetText(), nIdx, nNext - nIdx ) ) + { + nKashidasDropped = nKashidasInAttr; + rKashidas -= nKashidasDropped; + } + else + { + vcl::text::ComplexTextLayoutFlags nOldLayout = rInf.GetOut()->GetLayoutMode(); + rInf.GetOut()->SetLayoutMode ( nOldLayout | vcl::text::ComplexTextLayoutFlags::BiDiRtl ); + nKashidasDropped = rInf.GetOut()->ValidateKashidas( + rInf.GetText(), sal_Int32(nIdx), sal_Int32(nNext - nIdx), + nKashidasInAttr, + reinterpret_cast(aKashidaPos.data() + nKashidaIdx), + reinterpret_cast(aKashidaPosDropped.data())); + rInf.GetOut()->SetLayoutMode ( nOldLayout ); + if ( nKashidasDropped ) + { + rSI.MarkKashidasInvalid(nKashidasDropped, aKashidaPosDropped.data()); + rKashidas -= nKashidasDropped; + nGluePortion -= TextFrameIndex(nKashidasDropped); + } + } + nKashidaIdx += nKashidasInAttr; + } + nIdx = nNext; + } + + // return false if all kashidas have been eliminated + return (rKashidas > 0); +} + +static bool lcl_CheckKashidaWidth ( SwScriptInfo& rSI, SwTextSizeInfo& rInf, SwTextIter& rItr, sal_Int32& rKashidas, + TextFrameIndex& nGluePortion, const tools::Long nGluePortionWidth, tools::Long& nSpaceAdd ) +{ + // check kashida width + // if width is smaller than minimal kashida width allowed by fonts in the current line + // drop one kashida after the other until kashida width is OK + while (rKashidas) + { + bool bAddSpaceChanged = false; + TextFrameIndex nIdx = rItr.GetStart(); + TextFrameIndex nEnd = rItr.GetEnd(); + while ( nIdx < nEnd ) + { + rItr.SeekAndChgAttrIter( nIdx, rInf.GetOut() ); + TextFrameIndex nNext = rItr.GetNextAttr(); + + // is there also a script change before? + // if there is, nNext should point to the script change + TextFrameIndex const nNextScript = rSI.NextScriptChg( nIdx ); + if( nNextScript < nNext ) + nNext = nNextScript; + + if (nNext == TextFrameIndex(COMPLETE_STRING) || nNext > nEnd) + nNext = nEnd; + sal_Int32 nKashidasInAttr = rSI.KashidaJustify(nullptr, nullptr, nIdx, nNext - nIdx); + + tools::Long nFontMinKashida = rInf.GetOut()->GetMinKashida(); + if ( nFontMinKashida && nKashidasInAttr > 0 && SwScriptInfo::IsArabicText( rInf.GetText(), nIdx, nNext - nIdx ) ) + { + sal_Int32 nKashidasDropped = 0; + while ( rKashidas && nGluePortion && nKashidasInAttr > 0 && + nSpaceAdd / SPACING_PRECISION_FACTOR < nFontMinKashida ) + { + --nGluePortion; + --rKashidas; + --nKashidasInAttr; + ++nKashidasDropped; + if( !rKashidas || !nGluePortion ) // nothing left, return false to + return false; // do regular blank justification + + nSpaceAdd = nGluePortionWidth / sal_Int32(nGluePortion); + bAddSpaceChanged = true; + } + if( nKashidasDropped ) + rSI.MarkKashidasInvalid( nKashidasDropped, nIdx, nNext - nIdx ); + } + if ( bAddSpaceChanged ) + break; // start all over again + nIdx = nNext; + } + if ( !bAddSpaceChanged ) + break; // everything was OK + } + return true; +} + +// CalcNewBlock() must only be called _after_ CalcLine()! +// We always span between two RandPortions or FixPortions (Tabs and Flys). +// We count the Glues and call ExpandBlock. +void SwTextAdjuster::CalcNewBlock( SwLineLayout *pCurrent, + const SwLinePortion *pStopAt, SwTwips nReal, bool bSkipKashida ) +{ + OSL_ENSURE( GetInfo().IsMulti() || SvxAdjust::Block == GetAdjust(), + "CalcNewBlock: Why?" ); + OSL_ENSURE( pCurrent->Height(), "SwTextAdjuster::CalcBlockAdjust: missing CalcLine()" ); + + pCurrent->InitSpaceAdd(); + TextFrameIndex nGluePortion(0); + TextFrameIndex nCharCnt(0); + sal_uInt16 nSpaceIdx = 0; + + // i60591: hennerdrews + SwScriptInfo& rSI = GetInfo().GetParaPortion()->GetScriptInfo(); + SwTextSizeInfo aInf ( GetTextFrame() ); + SwTextIter aItr ( GetTextFrame(), &aInf ); + + if ( rSI.CountKashida() ) + { + while (aItr.GetCurr() != pCurrent && aItr.GetNext()) + aItr.Next(); + + if( bSkipKashida ) + { + rSI.SetNoKashidaLine ( aItr.GetStart(), aItr.GetLength()); + } + else + { + rSI.ClearKashidaInvalid ( aItr.GetStart(), aItr.GetLength() ); + rSI.ClearNoKashidaLine( aItr.GetStart(), aItr.GetLength() ); + } + } + + // Do not forget: CalcRightMargin() sets pCurrent->Width() to the line width! + if (!bSkipKashida) + CalcRightMargin( pCurrent, nReal ); + + // #i49277# + const bool bDoNotJustifyLinesWithManualBreak = + GetTextFrame()->GetDoc().getIDocumentSettingAccess().get(DocumentSettingId::DO_NOT_JUSTIFY_LINES_WITH_MANUAL_BREAK); + bool bDoNotJustifyTab = false; + + SwLinePortion *pPos = pCurrent->GetNextPortion(); + // calculate real text width for shrinking + tools::Long nBreakWidth = 0; + + while( pPos ) + { + if ( ( bDoNotJustifyLinesWithManualBreak || bDoNotJustifyTab ) && + pPos->IsBreakPortion() && !IsLastBlock() ) + { + pCurrent->FinishSpaceAdd(); + break; + } + + switch ( pPos->GetWhichPor() ) + { + case PortionType::TabCenter : + case PortionType::TabRight : + case PortionType::TabDecimal : + bDoNotJustifyTab = true; + break; + case PortionType::TabLeft : + case PortionType::Break: + bDoNotJustifyTab = false; + break; + default: break; + } + + if ( pPos->InTextGrp() ) + nGluePortion = nGluePortion + static_cast(pPos)->GetSpaceCnt( GetInfo(), nCharCnt ); + else if( pPos->IsMultiPortion() ) + { + SwMultiPortion* pMulti = static_cast(pPos); + // a multiportion with a tabulator inside breaks the text adjustment + // a ruby portion will not be stretched by text adjustment + // a double line portion takes additional space for each blank + // in the wider line + if( pMulti->HasTabulator() ) + { + if ( nSpaceIdx == pCurrent->GetLLSpaceAddCount() ) + pCurrent->SetLLSpaceAdd( 0, nSpaceIdx ); + + nSpaceIdx++; + nGluePortion = TextFrameIndex(0); + nCharCnt = TextFrameIndex(0); + } + else if( pMulti->IsDouble() ) + nGluePortion = nGluePortion + static_cast(pMulti)->GetSpaceCnt(); + else if ( pMulti->IsBidi() ) + nGluePortion = nGluePortion + static_cast(pMulti)->GetSpaceCnt( GetInfo() ); // i60594 + } + + if( pPos->InGlueGrp() ) + { + if( pPos->InFixMargGrp() ) + { + if ( nSpaceIdx == pCurrent->GetLLSpaceAddCount() ) + pCurrent->SetLLSpaceAdd( 0, nSpaceIdx ); + + const tools::Long nGluePortionWidth = static_cast(pPos)->GetPrtGlue() * + SPACING_PRECISION_FACTOR; + + sal_Int32 nKashidas = 0; + if( nGluePortion && rSI.CountKashida() && !bSkipKashida ) + { + // kashida positions found in SwScriptInfo are not necessarily valid in every font + // if two characters are replaced by a ligature glyph, there will be no place for a kashida + if ( !lcl_CheckKashidaPositions ( rSI, aInf, aItr, nKashidas, nGluePortion )) + { + // all kashida positions are invalid + // do regular blank justification + pCurrent->FinishSpaceAdd(); + GetInfo().SetIdx( m_nStart ); + CalcNewBlock( pCurrent, pStopAt, nReal, true ); + return; + } + } + + if( nGluePortion ) + { + tools::Long nSpaceAdd = nGluePortionWidth / sal_Int32(nGluePortion); + // shrink, if portions exceed the line width + tools::Long nSpaceSub = ( nBreakWidth > pCurrent->Width() ) + ? (nBreakWidth - pCurrent->Width()) * SPACING_PRECISION_FACTOR / + sal_Int32(nGluePortion) + LONG_MAX/2 + : 0; + + // i60594 + if( rSI.CountKashida() && !bSkipKashida ) + { + if( !lcl_CheckKashidaWidth( rSI, aInf, aItr, nKashidas, nGluePortion, nGluePortionWidth, nSpaceAdd )) + { + // no kashidas left + // do regular blank justification + pCurrent->FinishSpaceAdd(); + GetInfo().SetIdx( m_nStart ); + CalcNewBlock( pCurrent, pStopAt, nReal, true ); + return; + } + } + + pCurrent->SetLLSpaceAdd( nSpaceSub ? nSpaceSub : nSpaceAdd, nSpaceIdx ); + pPos->Width( static_cast(pPos)->GetFixWidth() ); + } + else if (IsOneBlock() && nCharCnt > TextFrameIndex(1)) + { + const tools::Long nSpaceAdd = - nGluePortionWidth / (sal_Int32(nCharCnt) - 1); + pCurrent->SetLLSpaceAdd( nSpaceAdd, nSpaceIdx ); + pPos->Width( static_cast(pPos)->GetFixWidth() ); + } + + nSpaceIdx++; + nGluePortion = TextFrameIndex(0); + nCharCnt = TextFrameIndex(0); + } + else + ++nGluePortion; + } + else + { + nBreakWidth += pPos->Width(); + } + GetInfo().SetIdx( GetInfo().GetIdx() + pPos->GetLen() ); + if ( pPos == pStopAt ) + { + pCurrent->SetLLSpaceAdd( 0, nSpaceIdx ); + break; + } + pPos = pPos->GetNextPortion(); + } +} + +SwTwips SwTextAdjuster::CalcKanaAdj( SwLineLayout* pCurrent ) +{ + OSL_ENSURE( pCurrent->Height(), "SwTextAdjuster::CalcBlockAdjust: missing CalcLine()" ); + OSL_ENSURE( !pCurrent->GetpKanaComp(), "pKanaComp already exists!!" ); + + pCurrent->SetKanaComp( std::make_unique>() ); + + const sal_uInt16 nNull = 0; + size_t nKanaIdx = 0; + tools::Long nKanaDiffSum = 0; + SwTwips nRepaintOfst = 0; + SwTwips nX = 0; + bool bNoCompression = false; + + // Do not forget: CalcRightMargin() sets pCurrent->Width() to the line width! + CalcRightMargin( pCurrent ); + + SwLinePortion* pPos = pCurrent->GetNextPortion(); + + while( pPos ) + { + if ( pPos->InTextGrp() ) + { + // get maximum portion width from info structure, calculated + // during text formatting + sal_uInt16 nMaxWidthDiff = GetInfo().GetMaxWidthDiff( pPos ); + + // check, if information is stored under other key + if ( !nMaxWidthDiff && pPos == pCurrent->GetFirstPortion() ) + nMaxWidthDiff = GetInfo().GetMaxWidthDiff( pCurrent ); + + // calculate difference between portion width and max. width + nKanaDiffSum += nMaxWidthDiff; + + // we store the beginning of the first compressible portion + // for repaint + if ( nMaxWidthDiff && !nRepaintOfst ) + nRepaintOfst = nX + GetLeftMargin(); + } + else if( pPos->InGlueGrp() && pPos->InFixMargGrp() ) + { + if ( nKanaIdx == pCurrent->GetKanaComp().size() ) + pCurrent->GetKanaComp().push_back( nNull ); + + tools::Long nRest; + + if ( pPos->InTabGrp() ) + { + nRest = ! bNoCompression && + ( pPos->Width() > MIN_TAB_WIDTH ) ? + pPos->Width() - MIN_TAB_WIDTH : + 0; + + // for simplifying the handling of left, right ... tabs, + // we do expand portions, which are lying behind + // those special tabs + bNoCompression = !pPos->IsTabLeftPortion(); + } + else + { + nRest = ! bNoCompression ? + static_cast(pPos)->GetPrtGlue() : + 0; + + bNoCompression = false; + } + + if( nKanaDiffSum ) + { + sal_uLong nCompress = ( 10000 * nRest ) / nKanaDiffSum; + + if ( nCompress >= 10000 ) + // kanas can be expanded to 100%, and there is still + // some space remaining + nCompress = 0; + + else + nCompress = 10000 - nCompress; + + ( pCurrent->GetKanaComp() )[ nKanaIdx ] = o3tl::narrowing(nCompress); + nKanaDiffSum = 0; + } + + nKanaIdx++; + } + + nX += pPos->Width(); + pPos = pPos->GetNextPortion(); + } + + // set portion width + nKanaIdx = 0; + sal_uInt16 nCompress = ( pCurrent->GetKanaComp() )[ nKanaIdx ]; + pPos = pCurrent->GetNextPortion(); + tools::Long nDecompress = 0; + + while( pPos ) + { + if ( pPos->InTextGrp() ) + { + const SwTwips nMinWidth = pPos->Width(); + + // get maximum portion width from info structure, calculated + // during text formatting + SwTwips nMaxWidthDiff = GetInfo().GetMaxWidthDiff( pPos ); + + // check, if information is stored under other key + if ( !nMaxWidthDiff && pPos == pCurrent->GetFirstPortion() ) + nMaxWidthDiff = GetInfo().GetMaxWidthDiff( pCurrent ); + pPos->Width( nMinWidth + + ( ( 10000 - nCompress ) * nMaxWidthDiff ) / 10000 ); + nDecompress += pPos->Width() - nMinWidth; + } + else if( pPos->InGlueGrp() && pPos->InFixMargGrp() ) + { + pPos->Width(pPos->Width() - nDecompress); + + if ( pPos->InTabGrp() ) + // set fix width to width + static_cast(pPos)->SetFixWidth( pPos->Width() ); + + if ( ++nKanaIdx < pCurrent->GetKanaComp().size() ) + nCompress = ( pCurrent->GetKanaComp() )[ nKanaIdx ]; + + nDecompress = 0; + } + pPos = pPos->GetNextPortion(); + } + + return nRepaintOfst; +} + +SwMarginPortion *SwTextAdjuster::CalcRightMargin( SwLineLayout *pCurrent, + SwTwips nReal ) +{ + tools::Long nRealWidth; + const sal_uInt16 nRealHeight = GetLineHeight(); + const sal_uInt16 nLineHeight = pCurrent->Height(); + + sal_uInt16 nPrtWidth = pCurrent->PrtWidth(); + SwLinePortion *pLast = pCurrent->FindLastPortion(); + + if( GetInfo().IsMulti() ) + nRealWidth = nReal; + else + { + nRealWidth = GetLineWidth(); + // For each FlyFrame extending into the right margin, we create a FlyPortion. + const tools::Long nLeftMar = GetLeftMargin(); + SwRect aCurrRect( nLeftMar + nPrtWidth, Y() + nRealHeight - nLineHeight, + nRealWidth - nPrtWidth, nLineHeight ); + + SwFlyPortion *pFly = CalcFlyPortion( nRealWidth, aCurrRect ); + while( pFly && tools::Long( nPrtWidth )< nRealWidth ) + { + pLast->Append( pFly ); + pLast = pFly; + if( pFly->GetFix() > nPrtWidth ) + pFly->Width( ( pFly->GetFix() - nPrtWidth) + pFly->Width() + 1); + nPrtWidth += pFly->Width() + 1; + aCurrRect.Left( nLeftMar + nPrtWidth ); + pFly = CalcFlyPortion( nRealWidth, aCurrRect ); + } + delete pFly; + } + + SwMarginPortion *pRight = new SwMarginPortion; + pLast->Append( pRight ); + + if( tools::Long( nPrtWidth )< nRealWidth ) + pRight->PrtWidth( sal_uInt16( nRealWidth - nPrtWidth ) ); + + // pCurrent->Width() is set to the real size, because we attach the + // MarginPortions. + // This trick gives miraculous results: + // If pCurrent->Width() == nRealWidth, then the adjustment gets overruled + // implicitly. GetLeftMarginAdjust() and IsJustified() think they have a + // line filled with chars. + + pCurrent->PrtWidth( sal_uInt16( nRealWidth ) ); + return pRight; +} + +void SwTextAdjuster::CalcFlyAdjust( SwLineLayout *pCurrent ) +{ + // 1) We insert a left margin: + SwMarginPortion *pLeft = pCurrent->CalcLeftMargin(); + SwGluePortion *pGlue = pLeft; // the last GluePortion + + // 2) We attach a right margin: + // CalcRightMargin also calculates a possible overlap with FlyFrames. + CalcRightMargin( pCurrent ); + + SwLinePortion *pPos = pLeft->GetNextPortion(); + TextFrameIndex nLen(0); + + // If we only have one line, the text portion is consecutive and we center, then ... + bool bComplete = TextFrameIndex(0) == m_nStart; + const bool bTabCompat = GetTextFrame()->GetDoc().getIDocumentSettingAccess().get(DocumentSettingId::TAB_COMPAT); + bool bMultiTab = false; + + while( pPos ) + { + if ( pPos->IsMultiPortion() && static_cast(pPos)->HasTabulator() ) + bMultiTab = true; + else if( pPos->InFixMargGrp() && + ( bTabCompat ? ! pPos->InTabGrp() : ! bMultiTab ) ) + { + // in tab compat mode we do not want to change tab portions + // in non tab compat mode we do not want to change margins if we + // found a multi portion with tabs + if( SvxAdjust::Right == GetAdjust() ) + static_cast(pPos)->MoveAllGlue( pGlue ); + else + { + // We set the first text portion to right-aligned and the last one + // to left-aligned. + // The first text portion gets the whole Glue, but only if we have + // more than one line. + if (bComplete && TextFrameIndex(GetInfo().GetText().getLength()) == nLen) + static_cast(pPos)->MoveHalfGlue( pGlue ); + else + { + if ( ! bTabCompat ) + { + if( pLeft == pGlue ) + { + // If we only have a left and right margin, the + // margins share the Glue. + if( nLen + pPos->GetLen() >= pCurrent->GetLen() ) + static_cast(pPos)->MoveHalfGlue( pGlue ); + else + static_cast(pPos)->MoveAllGlue( pGlue ); + } + else + { + // The last text portion retains its Glue. + if( !pPos->IsMarginPortion() ) + static_cast(pPos)->MoveHalfGlue( pGlue ); + } + } + else + static_cast(pPos)->MoveHalfGlue( pGlue ); + } + } + + pGlue = static_cast(pPos); + bComplete = false; + } + nLen = nLen + pPos->GetLen(); + pPos = pPos->GetNextPortion(); + } + + if( ! bTabCompat && ! bMultiTab && SvxAdjust::Right == GetAdjust() ) + // portions are moved to the right if possible + pLeft->AdjustRight( pCurrent ); +} + +void SwTextAdjuster::CalcAdjLine( SwLineLayout *pCurrent ) +{ + OSL_ENSURE( pCurrent->IsFormatAdj(), "CalcAdjLine: Why?" ); + + pCurrent->SetFormatAdj(false); + + SwParaPortion* pPara = GetInfo().GetParaPortion(); + + switch( GetAdjust() ) + { + case SvxAdjust::Right: + case SvxAdjust::Center: + { + CalcFlyAdjust( pCurrent ); + pPara->GetRepaint().SetOffset( 0 ); + break; + } + case SvxAdjust::Block: + { + FormatBlock(); + break; + } + default : return; + } +} + +// This is a quite complicated calculation: nCurrWidth is the width _before_ +// adding the word, that still fits onto the line! For this reason the FlyPortion's +// width is still correct if we get a deadlock-situation of: +// bFirstWord && !WORDFITS +SwFlyPortion *SwTextAdjuster::CalcFlyPortion( const tools::Long nRealWidth, + const SwRect &rCurrRect ) +{ + SwTextFly aTextFly( GetTextFrame() ); + + const sal_uInt16 nCurrWidth = m_pCurr->PrtWidth(); + SwFlyPortion *pFlyPortion = nullptr; + + SwRect aLineVert( rCurrRect ); + if ( GetTextFrame()->IsRightToLeft() ) + GetTextFrame()->SwitchLTRtoRTL( aLineVert ); + if ( GetTextFrame()->IsVertical() ) + GetTextFrame()->SwitchHorizontalToVertical( aLineVert ); + + // aFlyRect is document-global! + SwRect aFlyRect( aTextFly.GetFrame( aLineVert ) ); + + if ( GetTextFrame()->IsRightToLeft() ) + GetTextFrame()->SwitchRTLtoLTR( aFlyRect ); + if ( GetTextFrame()->IsVertical() ) + GetTextFrame()->SwitchVerticalToHorizontal( aFlyRect ); + + // If a Frame overlapps we open a Portion + if( aFlyRect.HasArea() ) + { + // aLocal is frame-local + SwRect aLocal( aFlyRect ); + aLocal.Pos( aLocal.Left() - GetLeftMargin(), aLocal.Top() ); + if( nCurrWidth > aLocal.Left() ) + aLocal.Left( nCurrWidth ); + + // If the rect is wider than the line, we adjust it to the right size + const tools::Long nLocalWidth = aLocal.Left() + aLocal.Width(); + if( nRealWidth < nLocalWidth ) + aLocal.Width( nRealWidth - aLocal.Left() ); + GetInfo().GetParaPortion()->SetFly(); + pFlyPortion = new SwFlyPortion( aLocal ); + pFlyPortion->Height( sal_uInt16( rCurrRect.Height() ) ); + // The Width could be smaller than the FixWidth, thus: + pFlyPortion->AdjFixWidth(); + } + return pFlyPortion; +} + +// CalcDropAdjust is called at the end by Format() if needed +void SwTextAdjuster::CalcDropAdjust() +{ + OSL_ENSURE( 1IsDummy() || NextLine() ) + { + // Adjust first + GetAdjusted(); + + SwLinePortion *pPor = m_pCurr->GetFirstPortion(); + + // 2) Make sure we include the ropPortion + // 3) pLeft is the GluePor preceding the DropPor + if( pPor->InGlueGrp() && pPor->GetNextPortion() + && pPor->GetNextPortion()->IsDropPortion() ) + { + const SwLinePortion *pDropPor = pPor->GetNextPortion(); + SwGluePortion *pLeft = static_cast( pPor ); + + // 4) pRight: Find the GluePor coming after the DropPor + pPor = pPor->GetNextPortion(); + while( pPor && !pPor->InFixMargGrp() ) + pPor = pPor->GetNextPortion(); + + SwGluePortion *pRight = ( pPor && pPor->InGlueGrp() ) ? + static_cast(pPor) : nullptr; + if( pRight && pRight != pLeft ) + { + // 5) Calculate nMinLeft. Who is the most to left? + const auto nDropLineStart = + GetLineStart() + pLeft->Width() + pDropPor->Width(); + auto nMinLeft = nDropLineStart; + for( sal_Int32 i = 1; i < GetDropLines(); ++i ) + { + if( NextLine() ) + { + // Adjust first + GetAdjusted(); + + pPor = m_pCurr->GetFirstPortion(); + const SwMarginPortion *pMar = pPor->IsMarginPortion() ? + static_cast(pPor) : nullptr; + if( !pMar ) + nMinLeft = 0; + else + { + const auto nLineStart = + GetLineStart() + pMar->Width(); + if( nMinLeft > nLineStart ) + nMinLeft = nLineStart; + } + } + } + + // 6) Distribute the Glue anew between pLeft and pRight + if( nMinLeft < nDropLineStart ) + { + // The Glue is always passed from pLeft to pRight, so that + // the text moves to the left. + const auto nGlue = nDropLineStart - nMinLeft; + if( !nMinLeft ) + pLeft->MoveAllGlue( pRight ); + else + pLeft->MoveGlue( pRight, nGlue ); + } + } + } + } + + if( nLineNumber != GetLineNr() ) + { + Top(); + while( nLineNumber != GetLineNr() && Next() ) + ; + } +} + +void SwTextAdjuster::CalcDropRepaint() +{ + Top(); + SwRepaint &rRepaint = GetInfo().GetParaPortion()->GetRepaint(); + if( rRepaint.Top() > Y() ) + rRepaint.Top( Y() ); + for( sal_Int32 i = 1; i < GetDropLines(); ++i ) + NextLine(); + const SwTwips nBottom = Y() + GetLineHeight() - 1; + if( rRepaint.Bottom() < nBottom ) + rRepaint.Bottom( nBottom ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/itratr.cxx b/sw/source/core/text/itratr.cxx new file mode 100644 index 0000000000..24203ecb53 --- /dev/null +++ b/sw/source/core/text/itratr.cxx @@ -0,0 +1,1632 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "itratr.hxx" +#include +#include +#include "redlnitr.hxx" +#include +#include +#include "itrtxt.hxx" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace ::com::sun::star::i18n; +using namespace ::com::sun::star; + +static sal_Int32 GetNextAttrImpl(SwTextNode const* pTextNode, + size_t nStartIndex, size_t nEndIndex, sal_Int32 nPosition); + +SwAttrIter::SwAttrIter(SwTextNode const * pTextNode) + : m_pViewShell(nullptr) + , m_pFont(nullptr) + , m_pScriptInfo(nullptr) + , m_pLastOut(nullptr) + , m_nChgCnt(0) + , m_nStartIndex(0) + , m_nEndIndex(0) + , m_nPosition(0) + , m_nPropFont(0) + , m_pTextNode(pTextNode) + , m_pMergedPara(nullptr) +{ + m_aFontCacheIds[SwFontScript::Latin] = m_aFontCacheIds[SwFontScript::CJK] = m_aFontCacheIds[SwFontScript::CTL] = nullptr; +} + +SwAttrIter::SwAttrIter(SwTextNode& rTextNode, SwScriptInfo& rScrInf, SwTextFrame const*const pFrame) + : m_pViewShell(nullptr) + , m_pFont(nullptr) + , m_pScriptInfo(nullptr) + , m_pLastOut(nullptr) + , m_nChgCnt(0) + , m_nPropFont(0) + , m_pTextNode(&rTextNode) + , m_pMergedPara(nullptr) +{ + CtorInitAttrIter(rTextNode, rScrInf, pFrame); +} + +void SwAttrIter::Chg( SwTextAttr const *pHt ) +{ + assert(pHt && m_pFont && "No attribute of font available for change"); + if( m_pRedline && m_pRedline->IsOn() ) + m_pRedline->ChangeTextAttr( m_pFont, *pHt, true ); + else + m_aAttrHandler.PushAndChg( *pHt, *m_pFont ); + m_nChgCnt++; +} + +void SwAttrIter::Rst( SwTextAttr const *pHt ) +{ + assert(pHt && m_pFont && "No attribute of font available for reset"); + // get top from stack after removing pHt + if( m_pRedline && m_pRedline->IsOn() ) + m_pRedline->ChangeTextAttr( m_pFont, *pHt, false ); + else + m_aAttrHandler.PopAndChg( *pHt, *m_pFont ); + m_nChgCnt--; +} + +SwAttrIter::~SwAttrIter() +{ + m_pRedline.reset(); + delete m_pFont; +} + +bool SwAttrIter::MaybeHasHints() const +{ + return nullptr != m_pTextNode->GetpSwpHints() || nullptr != m_pMergedPara; +} + +/** + * Returns the attribute for a position + * + * Only if the attribute is exactly at the position @param nPos and + * does not have an EndIndex + * + * We need this function for attributes which should alter formatting without + * changing the content of the string. + * Such "degenerated" attributes are e.g.: fields which retain expanded text and + * line-bound Frames. + * In order to avoid ambiguities between different such attributes, we insert a + * special character at the start of the string, when creating such an attribute. + * The Formatter later on encounters such a special character and retrieves the + * degenerate attribute via GetAttr(). + */ +SwTextAttr *SwAttrIter::GetAttr(TextFrameIndex const nPosition) const +{ + std::pair const pos( m_pMergedPara + ? sw::MapViewToModel(*m_pMergedPara, nPosition) + : std::make_pair(m_pTextNode, sal_Int32(nPosition))); + return pos.first->GetTextAttrForCharAt(pos.second); +} + +bool SwAttrIter::SeekAndChgAttrIter(TextFrameIndex const nNewPos, OutputDevice* pOut) +{ + std::pair const pos( m_pMergedPara + ? sw::MapViewToModel(*m_pMergedPara, nNewPos) + : std::make_pair(m_pTextNode, sal_Int32(nNewPos))); + bool bChg = m_nStartIndex && pos.first == m_pTextNode && pos.second == m_nPosition + ? m_pFont->IsFntChg() + : Seek( nNewPos ); + if ( m_pLastOut.get() != pOut ) + { + m_pLastOut = pOut; + m_pFont->SetFntChg( true ); + bChg = true; + } + if( bChg ) + { + // if the change counter is zero, we know the cache id of the wanted font + if ( !m_nChgCnt && !m_nPropFont ) + m_pFont->SetFontCacheId( m_aFontCacheIds[ m_pFont->GetActual() ], + m_aFontIdx[ m_pFont->GetActual() ], m_pFont->GetActual() ); + m_pFont->ChgPhysFnt( m_pViewShell, *pOut ); + } + + return bChg; +} + +bool SwAttrIter::IsSymbol(TextFrameIndex const nNewPos) +{ + Seek( nNewPos ); + if ( !m_nChgCnt && !m_nPropFont ) + m_pFont->SetFontCacheId( m_aFontCacheIds[ m_pFont->GetActual() ], + m_aFontIdx[ m_pFont->GetActual() ], m_pFont->GetActual() ); + return m_pFont->IsSymbol( m_pViewShell ); +} + +bool SwTextFrame::IsSymbolAt(TextFrameIndex const nPos) const +{ + SwTextInfo info(const_cast(this)); + SwTextIter iter(const_cast(this), &info); + return iter.IsSymbol(nPos); +} + +bool SwAttrIter::SeekStartAndChgAttrIter( OutputDevice* pOut, const bool bParaFont ) +{ + SwTextNode const*const pFirstTextNode(m_pMergedPara ? m_pMergedPara->pFirstNode : m_pTextNode); + if ( m_pRedline && m_pRedline->ExtOn() ) + m_pRedline->LeaveExtend(*m_pFont, pFirstTextNode->GetIndex(), 0); + + if (m_pTextNode != pFirstTextNode) + { + assert(m_pMergedPara); + m_pTextNode = m_pMergedPara->pFirstNode; + InitFontAndAttrHandler(*m_pMergedPara->pParaPropsNode, *m_pTextNode, + m_pMergedPara->mergedText, nullptr, nullptr); + } + + // reset font to its original state + m_aAttrHandler.Reset(); + m_aAttrHandler.ResetFont( *m_pFont ); + + m_nStartIndex = 0; + m_nEndIndex = 0; + m_nPosition = 0; + m_nChgCnt = 0; + if( m_nPropFont ) + m_pFont->SetProportion( m_nPropFont ); + if( m_pRedline ) + { + m_pRedline->Clear( m_pFont ); + if( !bParaFont ) + m_nChgCnt = m_nChgCnt + m_pRedline->Seek(*m_pFont, pFirstTextNode->GetIndex(), 0, COMPLETE_STRING); + else + m_pRedline->Reset(); + } + + SwpHints const*const pHints(m_pTextNode->GetpSwpHints()); + if (pHints && !bParaFont) + { + SwTextAttr *pTextAttr; + // While we've not reached the end of the StartArray && the TextAttribute starts at position 0... + while ((m_nStartIndex < pHints->Count()) && + !((pTextAttr = pHints->Get(m_nStartIndex))->GetStart())) + { + // open the TextAttributes + Chg( pTextAttr ); + m_nStartIndex++; + } + } + + bool bChg = m_pFont->IsFntChg(); + if ( m_pLastOut.get() != pOut ) + { + m_pLastOut = pOut; + m_pFont->SetFntChg( true ); + bChg = true; + } + if( bChg ) + { + // if the application counter is zero, we know the cache id of the wanted font + if ( !m_nChgCnt && !m_nPropFont ) + m_pFont->SetFontCacheId( m_aFontCacheIds[ m_pFont->GetActual() ], + m_aFontIdx[ m_pFont->GetActual() ], m_pFont->GetActual() ); + m_pFont->ChgPhysFnt( m_pViewShell, *pOut ); + } + return bChg; +} + +// AMA: New AttrIter Nov 94 +void SwAttrIter::SeekFwd(const sal_Int32 nOldPos, const sal_Int32 nNewPos) +{ + SwpHints const*const pHints(m_pTextNode->GetpSwpHints()); + SwTextAttr *pTextAttr; + const auto nHintsCount = pHints->Count(); + + if ( m_nStartIndex ) // If attributes have been opened at all ... + { + // Close attributes that are currently open, but stop at nNewPos+1 + + // As long as we've not yet reached the end of EndArray and the + // TextAttribute ends before or at the new position ... + while ((m_nEndIndex < nHintsCount) && + ((pTextAttr = pHints->GetSortedByEnd(m_nEndIndex))->GetAnyEnd() <= nNewPos)) + { + // Close the TextAttributes, whose StartPos were before or at + // the old nPos and are currently open + if (pTextAttr->GetStart() <= nOldPos) Rst( pTextAttr ); + m_nEndIndex++; + } + } + else // skip the not opened ends + { + while ((m_nEndIndex < nHintsCount) && + (pHints->GetSortedByEnd(m_nEndIndex)->GetAnyEnd() <= nNewPos)) + { + m_nEndIndex++; + } + } + + // As long as we've not yet reached the end of EndArray and the + // TextAttribute ends before or at the new position... + while ((m_nStartIndex < nHintsCount) && + ((pTextAttr = pHints->Get(m_nStartIndex))->GetStart() <= nNewPos)) + { + + // open the TextAttributes, whose ends lie behind the new position + if ( pTextAttr->GetAnyEnd() > nNewPos ) Chg( pTextAttr ); + m_nStartIndex++; + } + +} + +bool SwAttrIter::Seek(TextFrameIndex const nNewPos) +{ + // note: nNewPos isn't necessarily an index returned from GetNextAttr + std::pair const newPos( m_pMergedPara + ? sw::MapViewToModel(*m_pMergedPara, nNewPos) + : std::make_pair(m_pTextNode, sal_Int32(nNewPos))); + + if ( m_pRedline && m_pRedline->ExtOn() ) + m_pRedline->LeaveExtend(*m_pFont, newPos.first->GetIndex(), newPos.second); + if (m_pTextNode->GetIndex() < newPos.first->GetIndex()) + { + // Skipping to a different node - first seek until the end of this node + // to get rid of all hint items + if (m_pTextNode->GetpSwpHints()) + { + sal_Int32 nPos(m_nPosition); + do + { + sal_Int32 const nOldPos(nPos); + nPos = GetNextAttrImpl(m_pTextNode, m_nStartIndex, m_nEndIndex, nPos); + if (nPos <= m_pTextNode->Len()) + { + SeekFwd(nOldPos, nPos); + } + else + { + SeekFwd(nOldPos, m_pTextNode->Len()); + } + } + while (nPos < m_pTextNode->Len()); + } + // Unapply current para items: + // the SwAttrHandler doesn't appear to be capable of *unapplying* + // items at all; it can only apply a previously effective item. + // So do this by recreating the font from scratch. + // Apply new para items: + assert(m_pMergedPara); + InitFontAndAttrHandler(*m_pMergedPara->pParaPropsNode, *newPos.first, + m_pMergedPara->mergedText, nullptr, nullptr); + // reset to next + m_pTextNode = newPos.first; + m_nStartIndex = 0; + m_nEndIndex = 0; + m_nPosition = 0; + assert(m_pRedline); + } + + // sw_redlinehide: Seek(0) must move before the first character, which + // has a special case where the first node starts with delete redline. + if ((!nNewPos && !m_pMergedPara) + || newPos.first != m_pTextNode + || newPos.second < m_nPosition) + { + if (m_pMergedPara) + { + if (m_pTextNode != newPos.first) + { + m_pTextNode = newPos.first; + // sw_redlinehide: hope it's okay to use the current text node + // here; the AttrHandler shouldn't care about non-char items + InitFontAndAttrHandler(*m_pMergedPara->pParaPropsNode, *m_pTextNode, + m_pMergedPara->mergedText, nullptr, nullptr); + } + } + if (m_pMergedPara || m_pTextNode->GetpSwpHints()) + { + if( m_pRedline ) + m_pRedline->Clear( nullptr ); + + // reset font to its original state + m_aAttrHandler.Reset(); + m_aAttrHandler.ResetFont( *m_pFont ); + + if( m_nPropFont ) + m_pFont->SetProportion( m_nPropFont ); + m_nStartIndex = 0; + m_nEndIndex = 0; + m_nPosition = 0; + m_nChgCnt = 0; + + // Attention! + // resetting the font here makes it necessary to apply any + // changes for extended input directly to the font + if ( m_pRedline && m_pRedline->ExtOn() ) + { + m_pRedline->UpdateExtFont( *m_pFont ); + ++m_nChgCnt; + } + } + } + + if (m_pTextNode->GetpSwpHints()) + { + if (m_pMergedPara) + { + // iterate hint by hint: SeekFwd does not mix ends and starts, + // it always applies all the starts last, so it must be called once + // per position where hints start/end! + sal_Int32 nPos(m_nPosition); + do + { + sal_Int32 const nOldPos(nPos); + nPos = GetNextAttrImpl(m_pTextNode, m_nStartIndex, m_nEndIndex, nPos); + if (nPos <= newPos.second) + { + SeekFwd(nOldPos, nPos); + } + else + { + SeekFwd(nOldPos, newPos.second); + } + } + while (nPos < newPos.second); + } + else + { + SeekFwd(m_nPosition, newPos.second); + } + } + + m_pFont->SetActual( m_pScriptInfo->WhichFont(nNewPos) ); + + if( m_pRedline ) + m_nChgCnt = m_nChgCnt + m_pRedline->Seek(*m_pFont, m_pTextNode->GetIndex(), newPos.second, m_nPosition); + m_nPosition = newPos.second; + + if( m_nPropFont ) + m_pFont->SetProportion( m_nPropFont ); + + return m_pFont->IsFntChg(); +} + +static void InsertCharAttrs(SfxPoolItem const** pAttrs, SfxItemSet const& rItems) +{ + SfxItemIter iter(rItems); + for (SfxPoolItem const* pItem = iter.GetCurItem(); pItem; pItem = iter.NextItem()) + { + auto const nWhich(pItem->Which()); + if (isCHRATR(nWhich) && RES_CHRATR_RSID != nWhich) + { + pAttrs[nWhich - RES_CHRATR_BEGIN] = pItem; + } + else if (nWhich == RES_TXTATR_UNKNOWN_CONTAINER) + { + pAttrs[RES_CHRATR_END - RES_CHRATR_BEGIN] = pItem; + } + } +} + +// if return false: portion ends at start of redline, indexes unchanged +// if return true: portion end not known (past end of redline), indexes point to first hint past end of redline +static bool CanSkipOverRedline( + SwTextNode const& rStartNode, sal_Int32 const nStartRedline, + SwRangeRedline const& rRedline, + size_t & rStartIndex, size_t & rEndIndex, + bool const isTheAnswerYes) +{ + size_t nStartIndex(rStartIndex); + size_t nEndIndex(rEndIndex); + SwPosition const*const pRLEnd(rRedline.End()); + if (!pRLEnd->GetNode().IsTextNode() // if fully deleted... + || pRLEnd->GetContentIndex() == pRLEnd->GetNode().GetTextNode()->Len()) + { + // shortcut: nothing follows redline + // current state is end state + return false; + } + std::vector activeCharFmts; + // can't compare the SwFont that's stored somewhere, it doesn't have compare + // operator, so try to recreate the situation with some temp arrays here + SfxPoolItem const* activeCharAttrsStart[RES_CHRATR_END - RES_CHRATR_BEGIN + 1] = { nullptr, }; + if (rStartNode != pRLEnd->GetNode()) + { // nodes' attributes are only needed if there are different nodes + InsertCharAttrs(activeCharAttrsStart, rStartNode.GetSwAttrSet()); + } + if (SwpHints const*const pStartHints = rStartNode.GetpSwpHints()) + { + // check hint ends of hints that start before and end within + sal_Int32 const nRedlineEnd(rStartNode == pRLEnd->GetNode() + ? pRLEnd->GetContentIndex() + : rStartNode.Len()); + for ( ; nEndIndex < pStartHints->Count(); ++nEndIndex) + { + SwTextAttr *const pAttr(pStartHints->GetSortedByEnd(nEndIndex)); + if (!pAttr->End()) + { + continue; + } + if (nRedlineEnd < *pAttr->End()) + { + break; + } + if (nStartRedline <= pAttr->GetStart()) + { + continue; + } + if (pAttr->IsFormatIgnoreEnd()) + { + continue; + } + switch (pAttr->Which()) + { + // if any of these ends inside RL then we need a new portion + case RES_TXTATR_REFMARK: + case RES_TXTATR_TOXMARK: + case RES_TXTATR_META: // actually these 2 aren't allowed to overlap ??? + case RES_TXTATR_METAFIELD: + case RES_TXTATR_INETFMT: + case RES_TXTATR_CJK_RUBY: + case RES_TXTATR_INPUTFIELD: + case RES_TXTATR_CONTENTCONTROL: + { + if (!isTheAnswerYes) return false; // always break + } + break; + // these are guaranteed not to overlap + // and come in order of application + case RES_TXTATR_AUTOFMT: + case RES_TXTATR_CHARFMT: + { + if (pAttr->Which() == RES_TXTATR_CHARFMT) + { + activeCharFmts.push_back(pAttr); + } + // pure formatting hints may end inside the redline & + // start again inside the redline, which must not cause + // a new text portion if they have the same items - so + // store the effective items & compare all at the end + SfxItemSet const& rSet((pAttr->Which() == RES_TXTATR_CHARFMT) + ? static_cast(pAttr->GetCharFormat().GetCharFormat()->GetAttrSet()) + : *pAttr->GetAutoFormat().GetStyleHandle()); + InsertCharAttrs(activeCharAttrsStart, rSet); + } + break; + // SwTextNode::SetAttr puts it into AUTOFMT which is quite + // sensible so it doesn't actually exist as a hint + case RES_TXTATR_UNKNOWN_CONTAINER: + default: assert(false); + } + } + assert(nEndIndex == pStartHints->Count() || + pRLEnd->GetContentIndex() < pStartHints->GetSortedByEnd(nEndIndex)->GetAnyEnd()); + } + + if (rStartNode != pRLEnd->GetNode()) + { + nStartIndex = 0; + nEndIndex = 0; + } + + // treat para properties as text properties + // ... with the FormatToTextAttr we get autofmts that correspond to the *effective* attr set difference + // effective attr set: para props + charfmts + autofmt *in that order* + // ... and the charfmt must be *nominally* the same + + SfxPoolItem const* activeCharAttrsEnd[RES_CHRATR_END - RES_CHRATR_BEGIN + 1] = { nullptr, }; + if (rStartNode != pRLEnd->GetNode()) + { // nodes' attributes are only needed if there are different nodes + InsertCharAttrs(activeCharAttrsEnd, + pRLEnd->GetNode().GetTextNode()->GetSwAttrSet()); + } + + if (SwpHints *const pEndHints = pRLEnd->GetNode().GetTextNode()->GetpSwpHints()) + { + // check hint starts of hints that start within and end after +#ifndef NDEBUG + sal_Int32 const nRedlineStart(rStartNode == pRLEnd->GetNode() + ? nStartRedline + : 0); +#endif + for ( ; nStartIndex < pEndHints->Count(); ++nStartIndex) + { + SwTextAttr *const pAttr(pEndHints->Get(nStartIndex)); + // compare with < here, not <=, to get the effective formatting + // of the 1st char after the redline; should not cause problems + // with consecutive delete redlines because those are handed by + // GetNextRedln() and here we have the last end pos. + if (pRLEnd->GetContentIndex() < pAttr->GetStart()) + { + break; + } + if (!pAttr->End()) + continue; + if (pAttr->IsFormatIgnoreStart()) + { + continue; + } + assert(nRedlineStart <= pAttr->GetStart()); // we wouldn't be here otherwise? + if (*pAttr->End() <= pRLEnd->GetContentIndex()) + { + continue; + } + switch (pAttr->Which()) + { + case RES_TXTATR_REFMARK: + case RES_TXTATR_TOXMARK: + case RES_TXTATR_META: // actually these 2 aren't allowed to overlap ??? + case RES_TXTATR_METAFIELD: + case RES_TXTATR_INETFMT: + case RES_TXTATR_CJK_RUBY: + case RES_TXTATR_INPUTFIELD: + case RES_TXTATR_CONTENTCONTROL: + { + if (!isTheAnswerYes) return false; + } + break; + case RES_TXTATR_AUTOFMT: + case RES_TXTATR_CHARFMT: + { + // char formats must be *nominally* the same + if (pAttr->Which() == RES_TXTATR_CHARFMT) + { + auto iter = std::find_if(activeCharFmts.begin(), activeCharFmts.end(), + [&pAttr](const SwTextAttr* pCharFmt) { return *pCharFmt == *pAttr; }); + if (iter != activeCharFmts.end()) + activeCharFmts.erase(iter); + else if (!isTheAnswerYes) + return false; + } + SfxItemSet const& rSet((pAttr->Which() == RES_TXTATR_CHARFMT) + ? static_cast(pAttr->GetCharFormat().GetCharFormat()->GetAttrSet()) + : *pAttr->GetAutoFormat().GetStyleHandle()); + InsertCharAttrs(activeCharAttrsEnd, rSet); + + } + break; + // SwTextNode::SetAttr puts it into AUTOFMT which is quite + // sensible so it doesn't actually exist as a hint + case RES_TXTATR_UNKNOWN_CONTAINER: + default: assert(false); + } + } + if (rStartNode != pRLEnd->GetNode()) + { + // need to iterate the nEndIndex forward too so the loop in the + // caller can look for the right ends in the next iteration + for (nEndIndex = 0; nEndIndex < pEndHints->Count(); ++nEndIndex) + { + SwTextAttr *const pAttr(pEndHints->GetSortedByEnd(nEndIndex)); + if (!pAttr->End()) + continue; + if (pRLEnd->GetContentIndex() < *pAttr->End()) + { + break; + } + } + } + } + + // if we didn't find a matching start for any end, then it really ends inside + if (!activeCharFmts.empty()) + { + if (!isTheAnswerYes) return false; + } + for (size_t i = 0; i < SAL_N_ELEMENTS(activeCharAttrsStart); ++i) + { + // all of these should be shareable (but we have no SfxItemPool to check it here) + // assert(!activeCharAttrsStart[i] || activeCharAttrsStart[i]->GetItemPool()->Shareable(*activeCharAttrsStart[i])); + if (!SfxPoolItem::areSame(activeCharAttrsStart[i], activeCharAttrsEnd[i])) + { + if (!isTheAnswerYes) return false; + } + } + rStartIndex = nStartIndex; + rEndIndex = nEndIndex; + return true; +} + +static sal_Int32 GetNextAttrImpl(SwTextNode const*const pTextNode, + size_t const nStartIndex, size_t const nEndIndex, + sal_Int32 const nPosition) +{ + // note: this used to be COMPLETE_STRING, but was set to Len() + 1 below, + // which is rather silly, so set it to Len() instead + sal_Int32 nNext = pTextNode->Len(); + if (SwpHints const*const pHints = pTextNode->GetpSwpHints()) + { + // are there attribute starts left? + for (size_t i = nStartIndex; i < pHints->Count(); ++i) + { + SwTextAttr *const pAttr(pHints->Get(i)); + if (!pAttr->IsFormatIgnoreStart()) + { + nNext = pAttr->GetStart(); + break; + } + } + // are there attribute ends left? + for (size_t i = nEndIndex; i < pHints->Count(); ++i) + { + SwTextAttr *const pAttr(pHints->GetSortedByEnd(i)); + if (!pAttr->IsFormatIgnoreEnd()) + { + sal_Int32 const nNextEnd = pAttr->GetAnyEnd(); + nNext = std::min(nNext, nNextEnd); // pick nearest one + break; + } + } + } + // TODO: maybe use hints like FieldHints for this instead of looking at the text... + const sal_Int32 l = std::min(nNext, pTextNode->Len()); + sal_Int32 p = nPosition; + const sal_Unicode* pStr = pTextNode->GetText().getStr(); + while (p < l) + { + sal_Unicode aChar = pStr[p]; + switch (aChar) + { + case CH_TXT_ATR_FORMELEMENT: + case CH_TXT_ATR_FIELDSTART: + case CH_TXT_ATR_FIELDSEP: + case CH_TXT_ATR_FIELDEND: + goto break_; // sigh... + default: + ++p; + } + } +break_: + assert(p <= nNext); + if (p < l) + { + // found a CH_TXT_ATR_FIELD*: if it's same as current position, + // skip behind it so that both before- and after-positions are returned + nNext = (nPosition < p) ? p : p + 1; + } + return nNext; +} + +TextFrameIndex SwAttrIter::GetNextAttr() const +{ + size_t nStartIndex(m_nStartIndex); + size_t nEndIndex(m_nEndIndex); + size_t nPosition(m_nPosition); + SwTextNode const* pTextNode(m_pTextNode); + SwRedlineTable::size_type nActRedline(m_pRedline ? m_pRedline->GetAct() : SwRedlineTable::npos); + + while (true) + { + sal_Int32 nNext = GetNextAttrImpl(pTextNode, nStartIndex, nEndIndex, nPosition); + if( m_pRedline ) + { + std::pair> const redline( + m_pRedline->GetNextRedln(nNext, pTextNode, nActRedline)); + if (redline.second.first) + { + assert(m_pMergedPara); + assert(redline.second.first->End()->GetNodeIndex() <= m_pMergedPara->pLastNode->GetIndex() + || !redline.second.first->End()->GetNode().IsTextNode()); + if (CanSkipOverRedline(*pTextNode, redline.first, *redline.second.first, + nStartIndex, nEndIndex, m_nPosition == redline.first)) + { // if current position is start of the redline, must skip! + nActRedline += redline.second.second; + if (&redline.second.first->End()->GetNode() != pTextNode) + { + pTextNode = redline.second.first->End()->GetNode().GetTextNode(); + nPosition = redline.second.first->End()->GetContentIndex(); + } + else + { + nPosition = redline.second.first->End()->GetContentIndex(); + } + } + else + { + return sw::MapModelToView(*m_pMergedPara, pTextNode, redline.first); + } + } + else + { + return m_pMergedPara + ? sw::MapModelToView(*m_pMergedPara, pTextNode, redline.first) + : TextFrameIndex(redline.first); + } + } + else + { + return TextFrameIndex(nNext); + } + } +} + +namespace { + +class SwMinMaxArgs +{ +public: + VclPtr m_pOut; + SwViewShell const* m_pSh; + sal_uLong& m_rMin; + sal_uLong& m_rAbsMin; + tools::Long m_nRowWidth; + tools::Long m_nWordWidth; + tools::Long m_nWordAdd; + sal_Int32 m_nNoLineBreak; + SwMinMaxArgs(OutputDevice* pOutI, SwViewShell const* pShI, sal_uLong& rMinI, sal_uLong& rAbsI) + : m_pOut(pOutI) + , m_pSh(pShI) + , m_rMin(rMinI) + , m_rAbsMin(rAbsI) + , m_nRowWidth(0) + , m_nWordWidth(0) + , m_nWordAdd(0) + , m_nNoLineBreak(COMPLETE_STRING) + { } + void Minimum( tools::Long nNew ) const { + if (static_cast(m_rMin) < nNew) + m_rMin = nNew; + } + void NewWord() { m_nWordAdd = m_nWordWidth = 0; } +}; + +} + +static bool lcl_MinMaxString( SwMinMaxArgs& rArg, SwFont* pFnt, const OUString &rText, + sal_Int32 nIdx, sal_Int32 nEnd ) +{ + bool bRet = false; + while( nIdx < nEnd ) + { + sal_Int32 nStop = nIdx; + LanguageType eLang = pFnt->GetLanguage(); + assert(g_pBreakIt && g_pBreakIt->GetBreakIter().is()); + + bool bClear = CH_BLANK == rText[ nStop ]; + Boundary aBndry( g_pBreakIt->GetBreakIter()->getWordBoundary( rText, nIdx, + g_pBreakIt->GetLocale( eLang ), + WordType::DICTIONARY_WORD, true ) ); + nStop = aBndry.endPos; + if (nIdx <= aBndry.startPos && nIdx && nIdx - 1 != rArg.m_nNoLineBreak) + rArg.NewWord(); + if( nStop == nIdx ) + ++nStop; + if( nStop > nEnd ) + nStop = nEnd; + + SwDrawTextInfo aDrawInf(rArg.m_pSh, *rArg.m_pOut, rText, nIdx, nStop - nIdx); + tools::Long nCurrentWidth = pFnt->GetTextSize_( aDrawInf ).Width(); + rArg.m_nRowWidth += nCurrentWidth; + if( bClear ) + rArg.NewWord(); + else + { + rArg.m_nWordWidth += nCurrentWidth; + if (static_cast(rArg.m_rAbsMin) < rArg.m_nWordWidth) + rArg.m_rAbsMin = rArg.m_nWordWidth; + rArg.Minimum(rArg.m_nWordWidth + rArg.m_nWordAdd); + bRet = true; + } + nIdx = nStop; + } + return bRet; +} + +bool SwTextNode::IsSymbolAt(const sal_Int32 nBegin) const +{ + SwScriptInfo aScriptInfo; + SwAttrIter aIter( *const_cast(this), aScriptInfo ); + aIter.Seek( TextFrameIndex(nBegin) ); + return aIter.GetFnt()->IsSymbol( getIDocumentLayoutAccess().GetCurrentViewShell() ); +} + +namespace { + +class SwMinMaxNodeArgs +{ +public: + sal_uLong m_nMaxWidth; // sum of all frame widths + tools::Long m_nMinWidth; // biggest frame + tools::Long m_nLeftRest; // space not already covered by frames in the left margin + tools::Long m_nRightRest; // space not already covered by frames in the right margin + tools::Long m_nLeftDiff; // Min/Max-difference of the frame in the left margin + tools::Long m_nRightDiff; // Min/Max-difference of the frame in the right margin + SwNodeOffset m_nIndex; // index of the node + void Minimum( tools::Long nNew ) { + if (nNew > m_nMinWidth) + m_nMinWidth = nNew; + } +}; + +} + +static void lcl_MinMaxNode(SwFrameFormat* pNd, SwMinMaxNodeArgs& rIn) +{ + const SwFormatAnchor& rFormatA = pNd->GetAnchor(); + + if ((RndStdIds::FLY_AT_PARA != rFormatA.GetAnchorId()) && + (RndStdIds::FLY_AT_CHAR != rFormatA.GetAnchorId())) + { + return; + } + + const SwNode *pAnchorNode = rFormatA.GetAnchorNode(); + OSL_ENSURE(pAnchorNode, "Unexpected NULL arguments"); + if (!pAnchorNode || rIn.m_nIndex != pAnchorNode->GetIndex()) + return; + + tools::Long nMin, nMax; + SwHTMLTableLayout *pLayout = nullptr; + const bool bIsDrawFrameFormat = pNd->Which()==RES_DRAWFRMFMT; + if( !bIsDrawFrameFormat ) + { + // Does the frame contain a table at the start or the end? + const SwNodes& rNodes = pNd->GetDoc()->GetNodes(); + const SwFormatContent& rFlyContent = pNd->GetContent(); + SwNodeOffset nStt = rFlyContent.GetContentIdx()->GetIndex(); + SwTableNode* pTableNd = rNodes[nStt+1]->GetTableNode(); + if( !pTableNd ) + { + SwNode *pNd2 = rNodes[nStt]; + pNd2 = rNodes[pNd2->EndOfSectionIndex()-1]; + if( pNd2->IsEndNode() ) + pTableNd = pNd2->StartOfSectionNode()->GetTableNode(); + } + + if( pTableNd ) + pLayout = pTableNd->GetTable().GetHTMLTableLayout(); + } + + const SwFormatHoriOrient& rOrient = pNd->GetHoriOrient(); + sal_Int16 eHoriOri = rOrient.GetHoriOrient(); + + tools::Long nDiff; + if( pLayout ) + { + nMin = pLayout->GetMin(); + nMax = pLayout->GetMax(); + nDiff = nMax - nMin; + } + else + { + if( bIsDrawFrameFormat ) + { + const SdrObject* pSObj = pNd->FindSdrObject(); + if( pSObj ) + nMin = pSObj->GetCurrentBoundRect().GetWidth(); + else + nMin = 0; + + } + else + { + const SwFormatFrameSize &rSz = pNd->GetFrameSize(); + nMin = rSz.GetWidth(); + } + nMax = nMin; + nDiff = 0; + } + + const SvxLRSpaceItem &rLR = pNd->GetLRSpace(); + nMin += rLR.GetLeft(); + nMin += rLR.GetRight(); + nMax += rLR.GetLeft(); + nMax += rLR.GetRight(); + + if( css::text::WrapTextMode_THROUGH == pNd->GetSurround().GetSurround() ) + { + rIn.Minimum( nMin ); + return; + } + + // Frames, which are left- or right-aligned are only party considered + // when calculating the maximum, since the border is already being considered. + // Only if the frame extends into the text body, this part is being added + switch( eHoriOri ) + { + case text::HoriOrientation::RIGHT: + { + if( nDiff ) + { + rIn.m_nRightRest -= rIn.m_nRightDiff; + rIn.m_nRightDiff = nDiff; + } + if( text::RelOrientation::FRAME != rOrient.GetRelationOrient() ) + { + if (rIn.m_nRightRest > 0) + rIn.m_nRightRest = 0; + } + rIn.m_nRightRest -= nMin; + break; + } + case text::HoriOrientation::LEFT: + { + if( nDiff ) + { + rIn.m_nLeftRest -= rIn.m_nLeftDiff; + rIn.m_nLeftDiff = nDiff; + } + if (text::RelOrientation::FRAME != rOrient.GetRelationOrient() && rIn.m_nLeftRest < 0) + rIn.m_nLeftRest = 0; + rIn.m_nLeftRest -= nMin; + break; + } + default: + { + rIn.m_nMaxWidth += nMax; + rIn.Minimum(nMin); + } + } +} + +#define FLYINCNT_MIN_WIDTH 284 + +/** + * Changing this method very likely requires changing of GetScalingOfSelectedText + * This one is called exclusively from import filters, so there is no layout. + */ +void SwTextNode::GetMinMaxSize( SwNodeOffset nIndex, sal_uLong& rMin, sal_uLong &rMax, + sal_uLong& rAbsMin ) const +{ + SwViewShell const * pSh = GetDoc().getIDocumentLayoutAccess().GetCurrentViewShell(); + OutputDevice* pOut = nullptr; + if( pSh ) + pOut = pSh->GetWin()->GetOutDev(); + if( !pOut ) + pOut = Application::GetDefaultDevice(); + + MapMode aOldMap( pOut->GetMapMode() ); + pOut->SetMapMode( MapMode( MapUnit::MapTwip ) ); + + rMin = 0; + rMax = 0; + rAbsMin = 0; + + SvxTextLeftMarginItem const& rTextLeftMargin(GetSwAttrSet().GetTextLeftMargin()); + SvxRightMarginItem const& rRightMargin(GetSwAttrSet().GetRightMargin()); + tools::Long nLROffset = rTextLeftMargin.GetTextLeft() + GetLeftMarginWithNum( true ); + short nFLOffs; + // For enumerations a negative first line indentation is probably filled already + if( !GetFirstLineOfsWithNum( nFLOffs ) || nFLOffs > nLROffset ) + nLROffset = nFLOffs; + + SwMinMaxNodeArgs aNodeArgs; + aNodeArgs.m_nMinWidth = 0; + aNodeArgs.m_nMaxWidth = 0; + aNodeArgs.m_nLeftRest = nLROffset; + aNodeArgs.m_nRightRest = rRightMargin.GetRight(); + aNodeArgs.m_nLeftDiff = 0; + aNodeArgs.m_nRightDiff = 0; + if( nIndex ) + { + sw::SpzFrameFormats* pSpzs = const_cast(GetDoc().GetSpzFrameFormats()); + if(pSpzs) + { + aNodeArgs.m_nIndex = nIndex; + for(auto pFormat: *pSpzs) + lcl_MinMaxNode(pFormat, aNodeArgs); + } + } + if (aNodeArgs.m_nLeftRest < 0) + aNodeArgs.Minimum(nLROffset - aNodeArgs.m_nLeftRest); + aNodeArgs.m_nLeftRest -= aNodeArgs.m_nLeftDiff; + if (aNodeArgs.m_nLeftRest < 0) + aNodeArgs.m_nMaxWidth -= aNodeArgs.m_nLeftRest; + + if (aNodeArgs.m_nRightRest < 0) + aNodeArgs.Minimum(rRightMargin.GetRight() - aNodeArgs.m_nRightRest); + aNodeArgs.m_nRightRest -= aNodeArgs.m_nRightDiff; + if (aNodeArgs.m_nRightRest < 0) + aNodeArgs.m_nMaxWidth -= aNodeArgs.m_nRightRest; + + SwScriptInfo aScriptInfo; + SwAttrIter aIter( *const_cast(this), aScriptInfo ); + TextFrameIndex nIdx(0); + aIter.SeekAndChgAttrIter( nIdx, pOut ); + TextFrameIndex nLen(m_Text.getLength()); + tools::Long nCurrentWidth = 0; + tools::Long nAdd = 0; + SwMinMaxArgs aArg( pOut, pSh, rMin, rAbsMin ); + while( nIdx < nLen ) + { + TextFrameIndex nNextChg = aIter.GetNextAttr(); + TextFrameIndex nStop = aScriptInfo.NextScriptChg( nIdx ); + if( nNextChg > nStop ) + nNextChg = nStop; + SwTextAttr *pHint = nullptr; + sal_Unicode cChar = CH_BLANK; + nStop = nIdx; + while( nStop < nLen && nStop < nNextChg && + CH_TAB != (cChar = m_Text[sal_Int32(nStop)]) && + CH_BREAK != cChar && CHAR_HARDBLANK != cChar && + CHAR_HARDHYPHEN != cChar && CHAR_SOFTHYPHEN != cChar && + CH_TXT_ATR_INPUTFIELDSTART != cChar && + CH_TXT_ATR_INPUTFIELDEND != cChar && + CH_TXT_ATR_FORMELEMENT != cChar && + CH_TXT_ATR_FIELDSTART != cChar && + CH_TXT_ATR_FIELDSEP != cChar && + CH_TXT_ATR_FIELDEND != cChar && + !pHint ) + { + // this looks like some defensive programming to handle dummy char + // with missing hint? but it's rather silly because it may pass the + // dummy char to lcl_MinMaxString in that case... + if( ( CH_TXTATR_BREAKWORD != cChar && CH_TXTATR_INWORD != cChar ) + || ( nullptr == ( pHint = aIter.GetAttr( nStop ) ) ) ) + ++nStop; + } + if (lcl_MinMaxString(aArg, aIter.GetFnt(), m_Text, sal_Int32(nIdx), sal_Int32(nStop))) + { + nAdd = 20; + } + nIdx = nStop; + aIter.SeekAndChgAttrIter( nIdx, pOut ); + switch( cChar ) + { + case CH_BREAK : + { + if (static_cast(rMax) < aArg.m_nRowWidth) + rMax = aArg.m_nRowWidth; + aArg.m_nRowWidth = 0; + aArg.NewWord(); + aIter.SeekAndChgAttrIter( ++nIdx, pOut ); + } + break; + case CH_TAB : + { + aArg.NewWord(); + aIter.SeekAndChgAttrIter( ++nIdx, pOut ); + } + break; + case CHAR_SOFTHYPHEN: + ++nIdx; + break; + case CHAR_HARDBLANK: + case CHAR_HARDHYPHEN: + { + OUString sTmp( cChar ); + SwDrawTextInfo aDrawInf( pSh, + *pOut, sTmp, 0, 1, 0, false ); + nCurrentWidth = aIter.GetFnt()->GetTextSize_( aDrawInf ).Width(); + aArg.m_nWordWidth += nCurrentWidth; + aArg.m_nRowWidth += nCurrentWidth; + if (static_cast(rAbsMin) < aArg.m_nWordWidth) + rAbsMin = aArg.m_nWordWidth; + aArg.Minimum(aArg.m_nWordWidth + aArg.m_nWordAdd); + aArg.m_nNoLineBreak = sal_Int32(nIdx++); + } + break; + case CH_TXTATR_BREAKWORD: + case CH_TXTATR_INWORD: + { + if( !pHint ) + break; + tools::Long nOldWidth = aArg.m_nWordWidth; + tools::Long nOldAdd = aArg.m_nWordAdd; + aArg.NewWord(); + + switch( pHint->Which() ) + { + case RES_TXTATR_FLYCNT : + { + SwFrameFormat *pFrameFormat = pHint->GetFlyCnt().GetFrameFormat(); + const SvxLRSpaceItem &rLR = pFrameFormat->GetLRSpace(); + if( RES_DRAWFRMFMT == pFrameFormat->Which() ) + { + const SdrObject* pSObj = pFrameFormat->FindSdrObject(); + if( pSObj ) + nCurrentWidth = pSObj->GetCurrentBoundRect().GetWidth(); + else + nCurrentWidth = 0; + } + else + { + const SwFormatFrameSize& rTmpSize = pFrameFormat->GetFrameSize(); + if( RES_FLYFRMFMT == pFrameFormat->Which() + && rTmpSize.GetWidthPercent() ) + { + // This is a hack for the following situation: In the paragraph there's a + // text frame with relative size. Then let's take 0.5 cm as minimum width + // and USHRT_MAX as maximum width + // It were cleaner and maybe necessary later on to iterate over the content + // of the text frame and call GetMinMaxSize recursively + nCurrentWidth = FLYINCNT_MIN_WIDTH; // 0.5 cm + rMax = std::max(rMax, sal_uLong(USHRT_MAX)); + } + else + nCurrentWidth = pFrameFormat->GetFrameSize().GetWidth(); + } + nCurrentWidth += rLR.GetLeft(); + nCurrentWidth += rLR.GetRight(); + aArg.m_nWordAdd = nOldWidth + nOldAdd; + aArg.m_nWordWidth = nCurrentWidth; + aArg.m_nRowWidth += nCurrentWidth; + if (static_cast(rAbsMin) < aArg.m_nWordWidth) + rAbsMin = aArg.m_nWordWidth; + aArg.Minimum(aArg.m_nWordWidth + aArg.m_nWordAdd); + break; + } + case RES_TXTATR_FTN : + { + const OUString aText = pHint->GetFootnote().GetNumStr(); + if( lcl_MinMaxString( aArg, aIter.GetFnt(), aText, 0, + aText.getLength() ) ) + nAdd = 20; + break; + } + + case RES_TXTATR_FIELD : + case RES_TXTATR_ANNOTATION : + { + SwField *pField = const_cast(pHint->GetFormatField().GetField()); + const OUString aText = pField->ExpandField(true, nullptr); + if( lcl_MinMaxString( aArg, aIter.GetFnt(), aText, 0, + aText.getLength() ) ) + nAdd = 20; + break; + } + default: + aArg.m_nWordWidth = nOldWidth; + aArg.m_nWordAdd = nOldAdd; + } + aIter.SeekAndChgAttrIter( ++nIdx, pOut ); + } + break; + case CH_TXT_ATR_INPUTFIELDSTART: + case CH_TXT_ATR_INPUTFIELDEND: + case CH_TXT_ATR_FORMELEMENT: + case CH_TXT_ATR_FIELDSTART: + case CH_TXT_ATR_FIELDSEP: + case CH_TXT_ATR_FIELDEND: + { // just skip it and continue with the content... + aIter.SeekAndChgAttrIter( ++nIdx, pOut ); + } + break; + } + } + if (static_cast(rMax) < aArg.m_nRowWidth) + rMax = aArg.m_nRowWidth; + + nLROffset += rRightMargin.GetRight(); + + rAbsMin += nLROffset; + rAbsMin += nAdd; + rMin += nLROffset; + rMin += nAdd; + if (static_cast(rMin) < aNodeArgs.m_nMinWidth) + rMin = aNodeArgs.m_nMinWidth; + if (static_cast(rAbsMin) < aNodeArgs.m_nMinWidth) + rAbsMin = aNodeArgs.m_nMinWidth; + rMax += aNodeArgs.m_nMaxWidth; + rMax += nLROffset; + rMax += nAdd; + if( rMax < rMin ) // e.g. Frames with flow through only contribute to the minimum + rMax = rMin; + pOut->SetMapMode( aOldMap ); +} + +/** + * Calculates the width of the text part specified by nStart and nEnd, + * the height of the line containing nStart is divided by this width, + * indicating the scaling factor, if the text part is rotated. + * Having CH_BREAKs in the text part, this method returns the scaling + * factor for the longest of the text parts separated by the CH_BREAK + * + * Changing this method very likely requires changing of "GetMinMaxSize" + */ +sal_uInt16 SwTextFrame::GetScalingOfSelectedText( + TextFrameIndex nStart, TextFrameIndex nEnd) +{ + assert(GetOffset() <= nStart && (!GetFollow() || nStart < GetFollow()->GetOffset())); + SwViewShell const*const pSh = getRootFrame()->GetCurrShell(); + assert(pSh); + OutputDevice *const pOut = &pSh->GetRefDev(); + assert(pOut); + + MapMode aOldMap( pOut->GetMapMode() ); + pOut->SetMapMode( MapMode( MapUnit::MapTwip ) ); + + if (nStart == nEnd) + { + assert(g_pBreakIt && g_pBreakIt->GetBreakIter().is()); + + SwScriptInfo aScriptInfo; + SwAttrIter aIter(*GetTextNodeFirst(), aScriptInfo, this); + aIter.SeekAndChgAttrIter( nStart, pOut ); + + Boundary aBound = g_pBreakIt->GetBreakIter()->getWordBoundary( + GetText(), sal_Int32(nStart), + g_pBreakIt->GetLocale( aIter.GetFnt()->GetLanguage() ), + WordType::DICTIONARY_WORD, true ); + + if (sal_Int32(nStart) == aBound.startPos) + { + // cursor is at left or right border of word + pOut->SetMapMode( aOldMap ); + return 100; + } + + nStart = TextFrameIndex(aBound.startPos); + nEnd = TextFrameIndex(aBound.endPos); + + if (nStart == nEnd) + { + pOut->SetMapMode( aOldMap ); + return 100; + } + } + + SwScriptInfo aScriptInfo; + SwAttrIter aIter(*GetTextNodeFirst(), aScriptInfo, this); + + // We do not want scaling attributes to be considered during this + // calculation. For this, we push a temporary scaling attribute with + // scaling value 100 and priority flag on top of the scaling stack + SwAttrHandler& rAH = aIter.GetAttrHandler(); + SvxCharScaleWidthItem aItem(100, RES_CHRATR_SCALEW); + SwTextAttrEnd aAttr( aItem, 0, COMPLETE_STRING ); + aAttr.SetPriorityAttr( true ); + rAH.PushAndChg( aAttr, *(aIter.GetFnt()) ); + + TextFrameIndex nIdx = nStart; + + sal_uLong nWidth = 0; + sal_uLong nProWidth = 0; + + while( nIdx < nEnd ) + { + aIter.SeekAndChgAttrIter( nIdx, pOut ); + + // scan for end of portion + TextFrameIndex const nNextChg = std::min(aIter.GetNextAttr(), aScriptInfo.NextScriptChg(nIdx)); + + TextFrameIndex nStop = nIdx; + sal_Unicode cChar = CH_BLANK; + SwTextAttr* pHint = nullptr; + + // stop at special characters in [ nIdx, nNextChg ] + while( nStop < nEnd && nStop < nNextChg ) + { + cChar = GetText()[sal_Int32(nStop)]; + if ( + CH_TAB == cChar || + CH_BREAK == cChar || + CHAR_HARDBLANK == cChar || + CHAR_HARDHYPHEN == cChar || + CHAR_SOFTHYPHEN == cChar || + CH_TXT_ATR_INPUTFIELDSTART == cChar || + CH_TXT_ATR_INPUTFIELDEND == cChar || + CH_TXT_ATR_FORMELEMENT == cChar || + CH_TXT_ATR_FIELDSTART == cChar || + CH_TXT_ATR_FIELDSEP == cChar || + CH_TXT_ATR_FIELDEND == cChar || + ( + (CH_TXTATR_BREAKWORD == cChar || CH_TXTATR_INWORD == cChar) && + (nullptr == (pHint = aIter.GetAttr(nStop))) + ) + ) + { + break; + } + else + ++nStop; + } + + // calculate text widths up to cChar + if ( nStop > nIdx ) + { + SwDrawTextInfo aDrawInf(pSh, *pOut, GetText(), sal_Int32(nIdx), sal_Int32(nStop - nIdx)); + nProWidth += aIter.GetFnt()->GetTextSize_( aDrawInf ).Width(); + } + + nIdx = nStop; + aIter.SeekAndChgAttrIter( nIdx, pOut ); + + if ( cChar == CH_BREAK ) + { + nWidth = std::max( nWidth, nProWidth ); + nProWidth = 0; + nIdx++; + } + else if ( cChar == CH_TAB ) + { + // tab receives width of one space + SwDrawTextInfo aDrawInf(pSh, *pOut, OUStringChar(CH_BLANK), 0, 1); + nProWidth += aIter.GetFnt()->GetTextSize_( aDrawInf ).Width(); + nIdx++; + } + else if ( cChar == CHAR_SOFTHYPHEN ) + ++nIdx; + else if ( cChar == CHAR_HARDBLANK || cChar == CHAR_HARDHYPHEN ) + { + OUString sTmp( cChar ); + SwDrawTextInfo aDrawInf(pSh, *pOut, sTmp, 0, 1); + nProWidth += aIter.GetFnt()->GetTextSize_( aDrawInf ).Width(); + nIdx++; + } + else if ( pHint && ( cChar == CH_TXTATR_BREAKWORD || cChar == CH_TXTATR_INWORD ) ) + { + switch( pHint->Which() ) + { + case RES_TXTATR_FTN : + { + const OUString aText = pHint->GetFootnote().GetNumStr(); + SwDrawTextInfo aDrawInf(pSh, *pOut, aText, 0, aText.getLength()); + + nProWidth += aIter.GetFnt()->GetTextSize_( aDrawInf ).Width(); + break; + } + + case RES_TXTATR_FIELD : + case RES_TXTATR_ANNOTATION : + { + SwField *pField = const_cast(pHint->GetFormatField().GetField()); + OUString const aText = pField->ExpandField(true, getRootFrame()); + SwDrawTextInfo aDrawInf(pSh, *pOut, aText, 0, aText.getLength()); + + nProWidth += aIter.GetFnt()->GetTextSize_( aDrawInf ).Width(); + break; + } + + default: + { + // any suggestions for a default action? + } + } // end of switch + nIdx++; + } + else if (CH_TXT_ATR_INPUTFIELDSTART == cChar || + CH_TXT_ATR_INPUTFIELDEND == cChar || + CH_TXT_ATR_FORMELEMENT == cChar || + CH_TXT_ATR_FIELDSTART == cChar || + CH_TXT_ATR_FIELDSEP == cChar || + CH_TXT_ATR_FIELDEND == cChar) + { // just skip it and continue with the content... + ++nIdx; + } + } // end of while + + nWidth = std::max( nWidth, nProWidth ); + + // search for the line containing nStart + if (HasPara()) + { + SwTextInfo aInf(this); + SwTextIter aLine(this, &aInf); + aLine.CharToLine( nStart ); + pOut->SetMapMode( aOldMap ); + return o3tl::narrowing( nWidth ? + ( ( 100 * aLine.GetCurr()->Height() ) / nWidth ) : 0 ); + } + // no frame or no paragraph, we take the height of the character + // at nStart as line height + + aIter.SeekAndChgAttrIter( nStart, pOut ); + pOut->SetMapMode( aOldMap ); + + SwDrawTextInfo aDrawInf(pSh, *pOut, GetText(), sal_Int32(nStart), 1); + return o3tl::narrowing( nWidth ? ((100 * aIter.GetFnt()->GetTextSize_( aDrawInf ).Height()) / nWidth ) : 0 ); +} + +std::vector SwTextFrame::GetSplitFlyDrawObjs() const +{ + std::vector aObjs; + const SwSortedObjs* pSortedObjs = GetDrawObjs(); + if (!pSortedObjs) + { + return aObjs; + } + + for (const auto& pSortedObj : *pSortedObjs) + { + SwFlyFrame* pFlyFrame = pSortedObj->DynCastFlyFrame(); + if (!pFlyFrame) + { + continue; + } + + if (!pFlyFrame->IsFlySplitAllowed()) + { + continue; + } + + aObjs.push_back(static_cast(pFlyFrame)); + } + + return aObjs; +} + +SwFlyAtContentFrame* SwTextFrame::HasNonLastSplitFlyDrawObj() const +{ + const SwTextFrame* pFollow = GetFollow(); + if (!pFollow) + { + return nullptr; + } + + if (mnOffset != pFollow->GetOffset()) + { + return nullptr; + } + + // At this point we know what we're part of a chain that is an anchor for split fly frames, but + // we're not the last one. See if we have a matching fly. + + // Look up the master of the anchor. + const SwTextFrame* pAnchor = this; + while (pAnchor->IsFollow()) + { + pAnchor = pAnchor->FindMaster(); + } + for (const auto& pFly : pAnchor->GetSplitFlyDrawObjs()) + { + // Nominally all flys are anchored in the master; see if this fly is effectively anchored in + // us. + SwTextFrame* pFlyAnchor = pFly->FindAnchorCharFrame(); + if (pFlyAnchor != this) + { + continue; + } + if (pFly->GetFollow()) + { + return pFly; + } + } + + return nullptr; +} + +bool SwTextFrame::IsEmptyMasterWithSplitFly() const +{ + if (!IsEmptyMaster()) + { + return false; + } + + if (!m_pDrawObjs || m_pDrawObjs->size() != 1) + { + return false; + } + + SwFlyFrame* pFlyFrame = (*m_pDrawObjs)[0]->DynCastFlyFrame(); + if (!pFlyFrame || !pFlyFrame->IsFlySplitAllowed()) + { + return false; + } + + if (mnOffset != GetFollow()->GetOffset()) + { + return false; + } + + return true; +} + +bool SwTextFrame::IsEmptyWithSplitFly() const +{ + if (IsFollow()) + { + return false; + } + + if (GetTextNodeFirst()->GetSwAttrSet().HasItem(RES_PAGEDESC)) + { + return false; + } + + if (getFrameArea().Bottom() <= GetUpper()->getFramePrintArea().Bottom()) + { + return false; + } + + // This is a master that doesn't fit the current parent. + if (!m_pDrawObjs || m_pDrawObjs->size() != 1) + { + return false; + } + + SwFlyFrame* pFlyFrame = (*m_pDrawObjs)[0]->DynCastFlyFrame(); + if (!pFlyFrame || !pFlyFrame->IsFlySplitAllowed()) + { + return false; + } + + // It has a split fly anchored to it. + if (pFlyFrame->GetFrameFormat().GetVertOrient().GetPos() >= 0) + { + return false; + } + + // Negative vertical offset means that visually it already may have a first line. + // Consider that, we may need to split the frame, so the fly frame is on one page and the empty + // paragraph's frame is on a next page. + return true; +} + +SwTwips SwTextNode::GetWidthOfLeadingTabs() const +{ + SwTwips nRet = 0; + + sal_Int32 nIdx = 0; + + while ( nIdx < GetText().getLength() ) + { + const sal_Unicode cCh = GetText()[nIdx]; + if ( cCh!='\t' && cCh!=' ' ) + { + break; + } + ++nIdx; + } + + if ( nIdx > 0 ) + { + SwPosition aPos( *this, nIdx ); + + // Find the non-follow text frame: + SwIterator aIter(*this); + for( SwTextFrame* pFrame = aIter.First(); pFrame; pFrame = aIter.Next() ) + { + // Only consider master frames: + if (!pFrame->IsFollow() && + pFrame->GetTextNodeForFirstText() == this) + { + SwRectFnSet aRectFnSet(pFrame); + SwRect aRect; + pFrame->GetCharRect( aRect, aPos ); + nRet = pFrame->IsRightToLeft() ? + aRectFnSet.GetPrtRight(*pFrame) - aRectFnSet.GetRight(aRect) : + aRectFnSet.GetLeft(aRect) - aRectFnSet.GetPrtLeft(*pFrame); + break; + } + } + } + + return nRet; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/itratr.hxx b/sw/source/core/text/itratr.hxx new file mode 100644 index 0000000000..eb15400cf5 --- /dev/null +++ b/sw/source/core/text/itratr.hxx @@ -0,0 +1,112 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#pragma once + +#include +#include "atrhndl.hxx" +#include + +namespace sw { struct MergedPara; } +class SwTextAttr; +class SwTextNode; +class SwRedlineItr; +class SwViewShell; +class SwTextFrame; + +class SwAttrIter +{ + friend class SwFontSave; +protected: + + SwAttrHandler m_aAttrHandler; + SwViewShell *m_pViewShell; + SwFont* m_pFont; + SwScriptInfo* m_pScriptInfo; + +private: + VclPtr m_pLastOut; + /// count currently open hints, redlines, ext-input + short m_nChgCnt; + std::unique_ptr> m_pRedline; + /// current iteration index in HintStarts + size_t m_nStartIndex; + /// current iteration index in HintEnds + size_t m_nEndIndex; + /// current iteration index in text node + sal_Int32 m_nPosition; + sal_uInt8 m_nPropFont; + o3tl::enumarray m_aFontCacheIds; + o3tl::enumarray m_aFontIdx; + /// input: the current text node + const SwTextNode* m_pTextNode; + sw::MergedPara const* m_pMergedPara; + + void SeekFwd(sal_Int32 nOldPos, sal_Int32 nNewPos); + void SetFnt( SwFont* pNew ) { m_pFont = pNew; } + void InitFontAndAttrHandler( + SwTextNode const& rPropsNode, SwTextNode const& rTextNode, + std::u16string_view aText, bool const* pbVertLayout, + bool const* pbVertLayoutLRBT); + +protected: + void Chg( SwTextAttr const *pHt ); + void Rst( SwTextAttr const *pHt ); + void CtorInitAttrIter(SwTextNode& rTextNode, SwScriptInfo& rScrInf, SwTextFrame const* pFrame = nullptr); + explicit SwAttrIter(SwTextNode const * pTextNode); + +public: + /// All subclasses of this always have a SwTextFrame passed to the + /// constructor, but SwAttrIter itself may be created without a + /// SwTextFrame in certain special cases via this ctor here + SwAttrIter(SwTextNode& rTextNode, SwScriptInfo& rScrInf, SwTextFrame const*const pFrame = nullptr); + + virtual ~SwAttrIter(); + + SwRedlineItr *GetRedln() { return m_pRedline.get(); } + // The parameter returns the position of the next change before or at the + // char position. + TextFrameIndex GetNextAttr() const; + /// Enables the attributes used at char pos nPos in the logical font + bool Seek(TextFrameIndex nPos); + // Creates the font at the specified position via Seek() and checks + // if it's a symbol font. + bool IsSymbol(TextFrameIndex nPos); + + /** Executes ChgPhysFnt if Seek() returns true + * and change font to merge character border with neighbours. + **/ + bool SeekAndChgAttrIter(TextFrameIndex nPos, OutputDevice* pOut); + bool SeekStartAndChgAttrIter( OutputDevice* pOut, const bool bParaFont ); + + // Do we possibly have nasty things like footnotes? + bool MaybeHasHints() const; + + // Returns the attribute for a position + SwTextAttr *GetAttr(TextFrameIndex nPos) const; + + SwFont *GetFnt() { return m_pFont; } + const SwFont *GetFnt() const { return m_pFont; } + + sal_uInt8 GetPropFont() const { return m_nPropFont; } + void SetPropFont( const sal_uInt8 nNew ) { m_nPropFont = nNew; } + + SwAttrHandler& GetAttrHandler() { return m_aAttrHandler; } +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/itrcrsr.cxx b/sw/source/core/text/itrcrsr.cxx new file mode 100644 index 0000000000..a39eb77301 --- /dev/null +++ b/sw/source/core/text/itrcrsr.cxx @@ -0,0 +1,2023 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "itrtxt.hxx" +#include +#include +#include "porfld.hxx" +#include "porfly.hxx" +#include "pordrop.hxx" +#include +#include "pormulti.hxx" +#include +#include + +// Not reentrant !!! +// is set in GetCharRect and is interpreted in UnitUp/Down. +bool SwTextCursor::s_bRightMargin = false; + +// After calculating the position of a character during GetCharRect +// this function allows to find the coordinates of a position (defined +// in pCMS->pSpecialPos) inside a special portion (e.g., a field) +static void lcl_GetCharRectInsideField( SwTextSizeInfo& rInf, SwRect& rOrig, + const SwCursorMoveState& rCMS, + const SwLinePortion& rPor ) +{ + OSL_ENSURE( rCMS.m_pSpecialPos, "Information about special pos missing" ); + + if ( rPor.InFieldGrp() && !static_cast(rPor).GetExp().isEmpty() ) + { + const sal_Int32 nCharOfst = rCMS.m_pSpecialPos->nCharOfst; + sal_Int32 nFieldIdx = 0; + sal_Int32 nFieldLen = 0; + + OUString sString; + const OUString* pString = nullptr; + const SwLinePortion* pPor = &rPor; + do + { + if ( pPor->InFieldGrp() ) + { + sString = static_cast(pPor)->GetExp(); + pString = &sString; + nFieldLen = pString->getLength(); + } + else + { + pString = nullptr; + nFieldLen = 0; + } + + if ( ! pPor->GetNextPortion() || nFieldIdx + nFieldLen > nCharOfst ) + break; + + nFieldIdx = nFieldIdx + nFieldLen; + rOrig.Pos().AdjustX(pPor->Width() ); + pPor = pPor->GetNextPortion(); + + } while ( true ); + + OSL_ENSURE( nCharOfst >= nFieldIdx, "Request of position inside field failed" ); + sal_Int32 nLen = nCharOfst - nFieldIdx + 1; + + if ( pString ) + { + // get script for field portion + rInf.GetFont()->SetActual( SwScriptInfo::WhichFont(0, *pString) ); + + TextFrameIndex const nOldLen = pPor->GetLen(); + const_cast(pPor)->SetLen(TextFrameIndex(nLen - 1)); + const SwTwips nX1 = pPor->GetLen() ? + pPor->GetTextSize( rInf ).Width() : + 0; + + SwTwips nX2 = 0; + if ( rCMS.m_bRealWidth ) + { + const_cast(pPor)->SetLen(TextFrameIndex(nLen)); + nX2 = pPor->GetTextSize( rInf ).Width(); + } + + const_cast(pPor)->SetLen( nOldLen ); + + rOrig.Pos().AdjustX(nX1 ); + rOrig.Width( ( nX2 > nX1 ) ? + ( nX2 - nX1 ) : + 1 ); + } + } + else + { + // special cases: no common fields, e.g., graphic number portion, + // FlyInCntPortions, Notes + rOrig.Width( rCMS.m_bRealWidth && rPor.Width() ? rPor.Width() : 1 ); + } +} + +// #i111284# +namespace { + bool IsLabelAlignmentActive( const SwTextNode& rTextNode ) + { + bool bRet( false ); + + if ( rTextNode.GetNumRule() ) + { + int nListLevel = rTextNode.GetActualListLevel(); + + if (nListLevel < 0) + nListLevel = 0; + + if (nListLevel >= MAXLEVEL) + nListLevel = MAXLEVEL - 1; + + const SwNumFormat& rNumFormat = + rTextNode.GetNumRule()->Get( o3tl::narrowing(nListLevel) ); + if ( rNumFormat.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_ALIGNMENT ) + { + bRet = true; + } + } + + return bRet; + } +} // end of anonymous namespace + +void SwTextMargin::CtorInitTextMargin( SwTextFrame *pNewFrame, SwTextSizeInfo *pNewInf ) +{ + CtorInitTextIter( pNewFrame, pNewInf ); + + m_pInf = pNewInf; + GetInfo().SetFont( GetFnt() ); + const SwTextNode *const pNode = m_pFrame->GetTextNodeForParaProps(); + + SvxFirstLineIndentItem const& rFirstLine(pNode->GetSwAttrSet().GetFirstLineIndent()); + SvxTextLeftMarginItem const& rTextLeftMargin(pNode->GetSwAttrSet().GetTextLeftMargin()); + // #i95907# + // #i111284# + const SwTextNode *pTextNode = m_pFrame->GetTextNodeForParaProps(); + const bool bLabelAlignmentActive = IsLabelAlignmentActive( *pTextNode ); + const bool bListLevelIndentsApplicable = pTextNode->AreListLevelIndentsApplicable() != ::sw::ListLevelIndents::No; + const bool bListLevelIndentsApplicableAndLabelAlignmentActive = bListLevelIndentsApplicable && bLabelAlignmentActive; + + // Carefully adjust the text formatting ranges. + + // This whole area desperately needs some rework. There are + // quite a couple of values that need to be considered: + // 1. paragraph indent + // 2. paragraph first line indent + // 3. numbering indent + // 4. numbering spacing to text + // 5. paragraph border + // Note: These values have already been used during calculation + // of the printing area of the paragraph. + const int nLMWithNum = pNode->GetLeftMarginWithNum( true ); + if ( m_pFrame->IsRightToLeft() ) + { + // this calculation is identical this the calculation for L2R layout - see below + mnLeft = m_pFrame->getFrameArea().Left() + + m_pFrame->getFramePrintArea().Left() + + nLMWithNum - + pNode->GetLeftMarginWithNum() - + // #i95907# + // #i111284# + // rSpace.GetLeft() + rSpace.GetTextLeft(); + (rTextLeftMargin.GetLeft(rFirstLine) - rTextLeftMargin.GetTextLeft()); + } + else + { + // #i95907# + // #i111284# + if ( bListLevelIndentsApplicableAndLabelAlignmentActive || + !pNode->getIDocumentSettingAccess()->get(DocumentSettingId::IGNORE_FIRST_LINE_INDENT_IN_NUMBERING) ) + { + // this calculation is identical this the calculation for R2L layout - see above + mnLeft = m_pFrame->getFrameArea().Left() + + m_pFrame->getFramePrintArea().Left() + + nLMWithNum - + pNode->GetLeftMarginWithNum() - + // #i95907# + // #i111284# + (rTextLeftMargin.GetLeft(rFirstLine) - rTextLeftMargin.GetTextLeft()); + } + else + { + mnLeft = m_pFrame->getFrameArea().Left() + + std::max(tools::Long(rTextLeftMargin.GetTextLeft() + nLMWithNum), + m_pFrame->getFramePrintArea().Left() ); + } + } + + mnRight = m_pFrame->getFrameArea().Left() + m_pFrame->getFramePrintArea().Left() + m_pFrame->getFramePrintArea().Width(); + + if( mnLeft >= mnRight && + // #i53066# Omit adjustment of nLeft for numbered + // paras inside cells inside new documents: + ( pNode->getIDocumentSettingAccess()->get(DocumentSettingId::IGNORE_FIRST_LINE_INDENT_IN_NUMBERING) || + !m_pFrame->IsInTab() || + (bListLevelIndentsApplicable && nLMWithNum == rTextLeftMargin.GetTextLeft()) + || (!bLabelAlignmentActive && nLMWithNum == 0))) + { + mnLeft = m_pFrame->getFramePrintArea().Left() + m_pFrame->getFrameArea().Left(); + if( mnLeft >= mnRight ) // e.g. with large paragraph indentations in slim table columns + mnRight = mnLeft + 1; // einen goennen wir uns immer + } + + if( m_pFrame->IsFollow() && m_pFrame->GetOffset() ) + mnFirst = mnLeft; + else + { + short nFLOfst = 0; + tools::Long nFirstLineOfs = 0; + if( !pNode->GetFirstLineOfsWithNum( nFLOfst ) && + rFirstLine.IsAutoFirst()) + { + nFirstLineOfs = GetFnt()->GetSize( GetFnt()->GetActual() ).Height(); + LanguageType const aLang = m_pFrame->GetLangOfChar( + TextFrameIndex(0), css::i18n::ScriptType::ASIAN); + if (aLang != LANGUAGE_KOREAN && aLang != LANGUAGE_JAPANESE) + nFirstLineOfs<<=1; + + // tdf#129448: Auto first-line indent should not be effected by line space. + // Below is for compatibility with old documents. + if (!pNode->getIDocumentSettingAccess()->get(DocumentSettingId::AUTO_FIRST_LINE_INDENT_DISREGARD_LINE_SPACE)) + { + const SvxLineSpacingItem *pSpace = m_aLineInf.GetLineSpacing(); + if( pSpace ) + { + switch( pSpace->GetLineSpaceRule() ) + { + case SvxLineSpaceRule::Auto: + break; + case SvxLineSpaceRule::Min: + { + if( nFirstLineOfs < pSpace->GetLineHeight() ) + nFirstLineOfs = pSpace->GetLineHeight(); + break; + } + case SvxLineSpaceRule::Fix: + nFirstLineOfs = pSpace->GetLineHeight(); + break; + default: OSL_FAIL( ": unknown LineSpaceRule" ); + } + switch( pSpace->GetInterLineSpaceRule() ) + { + case SvxInterLineSpaceRule::Off: + break; + case SvxInterLineSpaceRule::Prop: + { + tools::Long nTmp = pSpace->GetPropLineSpace(); + // 50% is the minimum, at 0% we switch to + // the default value 100%... + if( nTmp < 50 ) + nTmp = nTmp ? 50 : 100; + + nTmp *= nFirstLineOfs; + nTmp /= 100; + if( !nTmp ) + ++nTmp; + nFirstLineOfs = nTmp; + break; + } + case SvxInterLineSpaceRule::Fix: + { + nFirstLineOfs += pSpace->GetInterLineSpace(); + break; + } + default: OSL_FAIL( ": unknown InterLineSpaceRule" ); + } + } + } + } + else + nFirstLineOfs = nFLOfst; + + // #i95907# + // #i111284# + if ( m_pFrame->IsRightToLeft() || + bListLevelIndentsApplicableAndLabelAlignmentActive || + !pNode->getIDocumentSettingAccess()->get(DocumentSettingId::IGNORE_FIRST_LINE_INDENT_IN_NUMBERING) ) + { + if ( nFirstLineOfs < 0 && m_pFrame->IsInTab() && + mnLeft == m_pFrame->getFramePrintArea().Left() + m_pFrame->getFrameArea().Left() && + !m_pFrame->IsRightToLeft() && + !bListLevelIndentsApplicableAndLabelAlignmentActive ) + { + // tdf#130218 always show hanging indent in narrow table cells + // to avoid hiding the text content of the first line + mnLeft -= nFirstLineOfs; + } + + mnFirst = mnLeft + nFirstLineOfs; + } + else + { + mnFirst = m_pFrame->getFrameArea().Left() + + std::max(rTextLeftMargin.GetTextLeft() + nLMWithNum + nFirstLineOfs, + m_pFrame->getFramePrintArea().Left() ); + } + + // Note: returns a negative + // value for the new list label position and space mode LABEL_ALIGNMENT + // and label alignment CENTER and RIGHT in L2R layout respectively + // label alignment LEFT and CENTER in R2L layout + mnFirst += m_pFrame->GetAdditionalFirstLineOffset(); + + if( mnFirst >= mnRight ) + mnFirst = mnRight - 1; + } + const SvxAdjustItem& rAdjust = m_pFrame->GetTextNodeForParaProps()->GetSwAttrSet().GetAdjust(); + mnAdjust = rAdjust.GetAdjust(); + + // left is left and right is right + if ( m_pFrame->IsRightToLeft() ) + { + if ( SvxAdjust::Left == mnAdjust ) + mnAdjust = SvxAdjust::Right; + else if ( SvxAdjust::Right == mnAdjust ) + mnAdjust = SvxAdjust::Left; + } + + m_bOneBlock = rAdjust.GetOneWord() == SvxAdjust::Block; + m_bLastBlock = rAdjust.GetLastBlock() == SvxAdjust::Block; + m_bLastCenter = rAdjust.GetLastBlock() == SvxAdjust::Center; + + // #i91133# + mnTabLeft = pNode->GetLeftMarginForTabCalculation(); + + DropInit(); +} + +void SwTextMargin::DropInit() +{ + mnDropLeft = mnDropLines = mnDropHeight = mnDropDescent = 0; + const SwParaPortion *pPara = GetInfo().GetParaPortion(); + if( pPara ) + { + const SwDropPortion *pPorDrop = pPara->FindDropPortion(); + if ( pPorDrop ) + { + mnDropLeft = pPorDrop->GetDropLeft(); + mnDropLines = pPorDrop->GetLines(); + mnDropHeight = pPorDrop->GetDropHeight(); + mnDropDescent = pPorDrop->GetDropDescent(); + } + } +} + +// The function is interpreting / observing / evaluating / keeping / respecting the first line indention and the specified width. +SwTwips SwTextMargin::GetLineStart() const +{ + SwTwips nRet = GetLeftMargin(); + if( GetAdjust() != SvxAdjust::Left && + !m_pCurr->GetFirstPortion()->IsMarginPortion() ) + { + // If the first portion is a Margin, then the + // adjustment is expressed by the portions. + if( GetAdjust() == SvxAdjust::Right ) + nRet = Right() - CurrWidth(); + else if( GetAdjust() == SvxAdjust::Center ) + nRet += (GetLineWidth() - CurrWidth()) / 2; + } + return nRet; +} + +void SwTextCursor::CtorInitTextCursor( SwTextFrame *pNewFrame, SwTextSizeInfo *pNewInf ) +{ + CtorInitTextMargin( pNewFrame, pNewInf ); + // 6096: Attention, the iterators are derived! + // GetInfo().SetOut( GetInfo().GetWin() ); +} + +static bool isTrailingDecoration(SwLinePortion* p) +{ + // Optional no-width portion, followed only by no-width portions and/or terminating portions? + for (; p; p = p->GetNextPortion()) + { + if (p->IsMarginPortion() || p->IsBreakPortion()) + return true; + if (p->Width()) + return false; + } + return true; // no more portions +} + +// tdf#120715 tdf#43100: Make width for some HolePortions, so cursor will be able to move into it. +// It should not change the layout, so this should be called after the layout is calculated. +void SwTextCursor::AddExtraBlankWidth() +{ + SwLinePortion* pPos = m_pCurr->GetNextPortion(); + while (pPos) + { + SwLinePortion* pNextPos = pPos->GetNextPortion(); + // Do it only if it is the last portion that able to handle the cursor, + // else the next portion would miscalculate the cursor position + if (pPos->ExtraBlankWidth() && isTrailingDecoration(pNextPos)) + { + pPos->Width(pPos->Width() + pPos->ExtraBlankWidth()); + pPos->ExtraBlankWidth(0); + } + pPos = pNextPos; + } +} + +// 1170: Ancient bug: Shift-End forgets the last character ... +void SwTextCursor::GetEndCharRect(SwRect* pOrig, const TextFrameIndex nOfst, + SwCursorMoveState* pCMS, const tools::Long nMax ) +{ + // 1170: Ambiguity of document positions + s_bRightMargin = true; + CharCursorToLine(nOfst); + + // Somehow twisted: nOfst names the position behind the last + // character of the last line == This is the position in front of the first character + // of the line, in which we are situated: + if( nOfst != GetStart() || !m_pCurr->GetLen() ) + { + // 8810: Master line RightMargin, after that LeftMargin + GetCharRect( pOrig, nOfst, pCMS, nMax ); + s_bRightMargin = nOfst >= GetEnd() && nOfst < TextFrameIndex(GetInfo().GetText().getLength()); + return; + } + + if( !GetPrev() || !GetPrev()->GetLen() || !PrevLine() ) + { + GetCharRect( pOrig, nOfst, pCMS, nMax ); + return; + } + + // If necessary, as catch up, do the adjustment + GetAdjusted(); + + tools::Long nX = 0; + tools::Long nLast = 0; + SwLinePortion *pPor = m_pCurr->GetFirstPortion(); + + SwTwips nTmpHeight, nTmpAscent; + CalcAscentAndHeight( nTmpAscent, nTmpHeight ); + sal_uInt16 nPorHeight = nTmpHeight; + sal_uInt16 nPorAscent = nTmpAscent; + + // Search for the last Text/EndPortion of the line + while( pPor ) + { + nX = nX + pPor->Width(); + if( pPor->InTextGrp() || ( pPor->GetLen() && !pPor->IsFlyPortion() + && !pPor->IsHolePortion() ) || pPor->IsBreakPortion() ) + { + nLast = nX; + nPorHeight = pPor->Height(); + nPorAscent = pPor->GetAscent(); + } + pPor = pPor->GetNextPortion(); + } + + const Size aCharSize( 1, nTmpHeight ); + pOrig->Pos( GetTopLeft() ); + pOrig->SSize( aCharSize ); + pOrig->Pos().AdjustX(nLast ); + const SwTwips nTmpRight = Right() - 1; + if( pOrig->Left() > nTmpRight ) + pOrig->Pos().setX( nTmpRight ); + + if ( pCMS && pCMS->m_bRealHeight ) + { + if ( nTmpAscent > nPorAscent ) + pCMS->m_aRealHeight.setX( nTmpAscent - nPorAscent ); + else + pCMS->m_aRealHeight.setX( 0 ); + OSL_ENSURE( nPorHeight, "GetCharRect: Missing Portion-Height" ); + pCMS->m_aRealHeight.setY( nPorHeight ); + } +} + +// internal function, called by SwTextCursor::GetCharRect() to calculate +// the relative character position in the current line. +// pOrig refers to x and y coordinates, width and height of the cursor +// pCMS is used for restricting the cursor, if there are different font +// heights in one line ( first value = offset to y of pOrig, second +// value = real height of (shortened) cursor +void SwTextCursor::GetCharRect_( SwRect* pOrig, TextFrameIndex const nOfst, + SwCursorMoveState* pCMS ) +{ + const OUString aText = GetInfo().GetText(); + SwTextSizeInfo aInf( GetInfo(), &aText, m_nStart ); + if( GetPropFont() ) + aInf.GetFont()->SetProportion( GetPropFont() ); + SwTwips nTmpAscent, nTmpHeight; // Line height + CalcAscentAndHeight( nTmpAscent, nTmpHeight ); + const Size aCharSize( 1, nTmpHeight ); + const Point aCharPos; + pOrig->Pos( aCharPos ); + pOrig->SSize( aCharSize ); + + // If we are looking for a position inside a field which covers + // more than one line we may not skip any "empty portions" at the + // beginning of a line + const bool bInsideFirstField = pCMS && pCMS->m_pSpecialPos && + ( pCMS->m_pSpecialPos->nLineOfst || + SwSPExtendRange::BEFORE == + pCMS->m_pSpecialPos->nExtendRange ); + + bool bWidth = pCMS && pCMS->m_bRealWidth; + if( !m_pCurr->GetLen() && !m_pCurr->Width() ) + { + if ( pCMS && pCMS->m_bRealHeight ) + { + pCMS->m_aRealHeight.setX( 0 ); + pCMS->m_aRealHeight.setY( nTmpHeight ); + } + } + else + { + SwTwips nPorHeight = nTmpHeight; + SwTwips nPorAscent = nTmpAscent; + SwTwips nX = 0; + SwTwips nTmpFirst = 0; + SwLinePortion *pPor = m_pCurr->GetFirstPortion(); + SwBidiPortion* pLastBidiPor = nullptr; + TextFrameIndex nLastBidiIdx(-1); + SwTwips nLastBidiPorWidth = 0; + std::deque* pKanaComp = m_pCurr->GetpKanaComp(); + sal_uInt16 nSpaceIdx = 0; + size_t nKanaIdx = 0; + tools::Long nSpaceAdd = m_pCurr->IsSpaceAdd() ? m_pCurr->GetLLSpaceAdd( 0 ) : 0; + + bool bNoText = true; + + // First all portions without Len at beginning of line are skipped. + // Exceptions are the mean special portions from WhichFirstPortion: + // Num, ErgoSum, FootnoteNum, FieldRests + // 8477: but also the only Textportion of an empty line with + // Right/Center-Adjustment! So not just pPor->GetExpandPortion() ... + while( pPor && !pPor->GetLen() && ! bInsideFirstField ) + { + nX += pPor->Width(); + if ( pPor->InSpaceGrp() && nSpaceAdd ) + nX += pPor->CalcSpacing( nSpaceAdd, aInf ); + if( bNoText ) + nTmpFirst = nX; + // 8670: EndPortions count once as TextPortions. + // if( pPor->InTextGrp() || pPor->IsBreakPortion() ) + if( pPor->InTextGrp() || pPor->IsBreakPortion() || pPor->InTabGrp() ) + { + bNoText = false; + nTmpFirst = nX; + } + if( pPor->IsMultiPortion() && static_cast(pPor)->HasTabulator() ) + { + if ( m_pCurr->IsSpaceAdd() ) + { + if ( ++nSpaceIdx < m_pCurr->GetLLSpaceAddCount() ) + nSpaceAdd = m_pCurr->GetLLSpaceAdd( nSpaceIdx ); + else + nSpaceAdd = 0; + } + + if( pKanaComp && ( nKanaIdx + 1 ) < pKanaComp->size() ) + ++nKanaIdx; + } + if( pPor->InFixMargGrp() ) + { + if( pPor->IsMarginPortion() ) + bNoText = false; + else + { + // fix margin portion => next SpaceAdd, KanaComp value + if ( m_pCurr->IsSpaceAdd() ) + { + if ( ++nSpaceIdx < m_pCurr->GetLLSpaceAddCount() ) + nSpaceAdd = m_pCurr->GetLLSpaceAdd( nSpaceIdx ); + else + nSpaceAdd = 0; + } + + if( pKanaComp && ( nKanaIdx + 1 ) < pKanaComp->size() ) + ++nKanaIdx; + } + } + pPor = pPor->GetNextPortion(); + } + + if( !pPor ) + { + // There's just Spezialportions. + nX = nTmpFirst; + } + else + { + if( !pPor->IsMarginPortion() && !pPor->IsPostItsPortion() && + (!pPor->InFieldGrp() || pPor->GetAscent() ) ) + { + nPorHeight = pPor->Height(); + nPorAscent = pPor->GetAscent(); + } + while( pPor && !pPor->IsBreakPortion() && ( aInf.GetIdx() < nOfst || + ( bWidth && ( pPor->IsKernPortion() || pPor->IsMultiPortion() ) ) ) ) + { + if( !pPor->IsMarginPortion() && !pPor->IsPostItsPortion() && + (!pPor->InFieldGrp() || pPor->GetAscent() ) ) + { + nPorHeight = pPor->Height(); + nPorAscent = pPor->GetAscent(); + } + + // If we are behind the portion, we add the portion width to + // nX. Special case: nOfst = aInf.GetIdx() + pPor->GetLen(). + // For common portions (including BidiPortions) we want to add + // the portion width to nX. For MultiPortions, nExtra = 0, + // therefore we go to the 'else' branch and start a recursion. + const TextFrameIndex nExtra( (pPor->IsMultiPortion() + && !static_cast(pPor)->IsBidi() + && !bWidth) + ? 0 : 1 ); + if ( aInf.GetIdx() + pPor->GetLen() < nOfst + nExtra ) + { + if ( pPor->InSpaceGrp() && nSpaceAdd ) + nX += pPor->PrtWidth() + + pPor->CalcSpacing( nSpaceAdd, aInf ); + else + { + if( pPor->InFixMargGrp() && ! pPor->IsMarginPortion() ) + { + // update to current SpaceAdd, KanaComp values + if ( m_pCurr->IsSpaceAdd() ) + { + if ( ++nSpaceIdx < m_pCurr->GetLLSpaceAddCount() ) + nSpaceAdd = m_pCurr->GetLLSpaceAdd( nSpaceIdx ); + else + nSpaceAdd = 0; + } + + if ( pKanaComp && + ( nKanaIdx + 1 ) < pKanaComp->size() + ) + ++nKanaIdx; + } + if ( !pPor->IsFlyPortion() || ( pPor->GetNextPortion() && + !pPor->GetNextPortion()->IsMarginPortion() ) ) + nX += pPor->PrtWidth(); + } + if( pPor->IsMultiPortion() ) + { + if ( static_cast(pPor)->HasTabulator() ) + { + if ( m_pCurr->IsSpaceAdd() ) + { + if ( ++nSpaceIdx < m_pCurr->GetLLSpaceAddCount() ) + nSpaceAdd = m_pCurr->GetLLSpaceAdd( nSpaceIdx ); + else + nSpaceAdd = 0; + } + + if( pKanaComp && ( nKanaIdx + 1 ) < pKanaComp->size() ) + ++nKanaIdx; + } + + // if we are right behind a BidiPortion, we have to + // hold a pointer to the BidiPortion in order to + // find the correct cursor position, depending on the + // cursor level + if ( static_cast(pPor)->IsBidi() && + aInf.GetIdx() + pPor->GetLen() == nOfst ) + { + pLastBidiPor = static_cast(pPor); + nLastBidiIdx = aInf.GetIdx(); + nLastBidiPorWidth = pLastBidiPor->Width() + + pLastBidiPor->CalcSpacing( nSpaceAdd, aInf ); + } + } + + aInf.SetIdx( aInf.GetIdx() + pPor->GetLen() ); + pPor = pPor->GetNextPortion(); + } + else + { + if( pPor->IsMultiPortion() ) + { + nTmpAscent = AdjustBaseLine( *m_pCurr, pPor ); + GetInfo().SetMulti( true ); + pOrig->Pos().AdjustY(nTmpAscent - nPorAscent ); + + if( pCMS && pCMS->m_b2Lines ) + { + const bool bRecursion (pCMS->m_p2Lines); + if ( !bRecursion ) + { + pCMS->m_p2Lines.reset(new Sw2LinesPos); + pCMS->m_p2Lines->aLine = SwRect(aCharPos, aCharSize); + } + + if( static_cast(pPor)->HasRotation() ) + { + if( static_cast(pPor)->IsRevers() ) + pCMS->m_p2Lines->nMultiType = MultiPortionType::ROT_270; + else + pCMS->m_p2Lines->nMultiType = MultiPortionType::ROT_90; + } + else if( static_cast(pPor)->IsDouble() ) + pCMS->m_p2Lines->nMultiType = MultiPortionType::TWOLINE; + else if( static_cast(pPor)->IsBidi() ) + pCMS->m_p2Lines->nMultiType = MultiPortionType::BIDI; + else + pCMS->m_p2Lines->nMultiType = MultiPortionType::RUBY; + + SwTwips nTmpWidth = pPor->Width(); + if( nSpaceAdd ) + nTmpWidth += pPor->CalcSpacing(nSpaceAdd, aInf); + + SwRect aRect( Point(aCharPos.X() + nX, pOrig->Top() ), + Size( nTmpWidth, pPor->Height() ) ); + + if ( ! bRecursion ) + pCMS->m_p2Lines->aPortion = aRect; + else + pCMS->m_p2Lines->aPortion2 = aRect; + } + + // In a multi-portion we use GetCharRect()-function + // recursively and must add the x-position + // of the multi-portion. + TextFrameIndex const nOldStart = m_nStart; + SwTwips nOldY = m_nY; + sal_uInt8 nOldProp = GetPropFont(); + m_nStart = aInf.GetIdx(); + SwLineLayout* pOldCurr = m_pCurr; + m_pCurr = &static_cast(pPor)->GetRoot(); + if( static_cast(pPor)->IsDouble() ) + SetPropFont( 50 ); + + SwTextGridItem const*const pGrid( + GetGridItem(GetTextFrame()->FindPageFrame())); + const bool bHasGrid = pGrid && GetInfo().SnapToGrid(); + const sal_uInt16 nRubyHeight = bHasGrid ? + pGrid->GetRubyHeight() : 0; + + if( m_nStart + m_pCurr->GetLen() <= nOfst && GetNext() && + ( ! static_cast(pPor)->IsRuby() || + static_cast(pPor)->OnTop() ) ) + { + sal_uInt16 nOffset; + // in grid mode we may only add the height of the + // ruby line if ruby line is on top + if ( bHasGrid && + static_cast(pPor)->IsRuby() && + static_cast(pPor)->OnTop() ) + nOffset = nRubyHeight; + else + nOffset = GetLineHeight(); + + pOrig->Pos().AdjustY(nOffset ); + Next(); + } + + const bool bSpaceChg = static_cast(pPor)-> + ChgSpaceAdd( m_pCurr, nSpaceAdd ); + Point aOldPos = pOrig->Pos(); + + // Ok, for ruby portions in grid mode we have to + // temporarily set the inner line height to the + // outer line height because that value is needed + // for the adjustment inside the recursion + const sal_uInt16 nOldRubyHeight = m_pCurr->Height(); + const sal_uInt16 nOldRubyRealHeight = m_pCurr->GetRealHeight(); + const bool bChgHeight = + static_cast(pPor)->IsRuby() && bHasGrid; + + if ( bChgHeight ) + { + m_pCurr->Height( pOldCurr->Height() - nRubyHeight ); + m_pCurr->SetRealHeight( pOldCurr->GetRealHeight() - + nRubyHeight ); + } + + SwLayoutModeModifier aLayoutModeModifier( *GetInfo().GetOut() ); + if ( static_cast(pPor)->IsBidi() ) + { + aLayoutModeModifier.Modify( + static_cast(pPor)->GetLevel() % 2 ); + } + + GetCharRect_( pOrig, nOfst, pCMS ); + + if ( bChgHeight ) + { + m_pCurr->Height( nOldRubyHeight ); + m_pCurr->SetRealHeight( nOldRubyRealHeight ); + } + + // if we are still in the first row of + // our 2 line multiportion, we use the FirstMulti flag + // to indicate this + if ( static_cast(pPor)->IsDouble() ) + { + // the recursion may have damaged our font size + SetPropFont( nOldProp ); + GetInfo().GetFont()->SetProportion( 100 ); + + if ( m_pCurr == &static_cast(pPor)->GetRoot() ) + { + GetInfo().SetFirstMulti( true ); + + // we want to treat a double line portion like a + // single line portion, if there is no text in + // the second line + if ( !m_pCurr->GetNext() || + !m_pCurr->GetNext()->GetLen() ) + GetInfo().SetMulti( false ); + } + } + // ruby portions are treated like single line portions + else if( static_cast(pPor)->IsRuby() || + static_cast(pPor)->IsBidi() ) + GetInfo().SetMulti( false ); + + // calculate cursor values + if( static_cast(pPor)->HasRotation() ) + { + GetInfo().SetMulti( false ); + tools::Long nTmp = pOrig->Width(); + pOrig->Width( pOrig->Height() ); + pOrig->Height( nTmp ); + nTmp = pOrig->Left() - aOldPos.X(); + + // if we travel into our rotated portion from + // a line below, we have to take care, that the + // y coord in pOrig is less than line height: + if ( nTmp ) + nTmp--; + + pOrig->Pos().setX( nX + aOldPos.X() ); + if( static_cast(pPor)->IsRevers() ) + pOrig->Pos().setY( aOldPos.Y() + nTmp ); + else + pOrig->Pos().setY( aOldPos.Y() + + pPor->Height() - nTmp - pOrig->Height() ); + if ( pCMS && pCMS->m_bRealHeight ) + { + pCMS->m_aRealHeight.setY( -pCMS->m_aRealHeight.Y() ); + // result for rotated multi portion is not + // correct for reverse (270 degree) portions + if( static_cast(pPor)->IsRevers() ) + { + if ( SvxParaVertAlignItem::Align::Automatic == + GetLineInfo().GetVertAlign() ) + // if vertical alignment is set to auto, + // we switch from base line alignment + // to centered alignment + pCMS->m_aRealHeight.setX( + ( pOrig->Width() + + pCMS->m_aRealHeight.Y() ) / 2 ); + else + pCMS->m_aRealHeight.setX( + pOrig->Width() - + pCMS->m_aRealHeight.X() + + pCMS->m_aRealHeight.Y() ); + } + } + } + else + { + pOrig->Pos().AdjustY(aOldPos.Y() ); + if ( static_cast(pPor)->IsBidi() ) + { + const SwTwips nPorWidth = pPor->Width() + + pPor->CalcSpacing( nSpaceAdd, aInf ); + const SwTwips nInsideOfst = pOrig->Pos().X(); + pOrig->Pos().setX( nX + nPorWidth - + nInsideOfst - pOrig->Width() ); + } + else + pOrig->Pos().AdjustX(nX ); + + if( static_cast(pPor)->HasBrackets() ) + pOrig->Pos().AdjustX( + static_cast(pPor)->PreWidth() ); + } + + if( bSpaceChg ) + SwDoubleLinePortion::ResetSpaceAdd( m_pCurr ); + + m_pCurr = pOldCurr; + m_nStart = nOldStart; + m_nY = nOldY; + m_bPrev = false; + + return; + } + if ( pPor->PrtWidth() ) + { + // tdf#30731: To get the correct nOfst width, we need + // to send the whole portion string to GetTextSize() + // and ask it to return the width of nOfst by calling + // SetMeasureLen(). Cutting the string at nOfst can + // give the wrong width if nOfst is in e.g. the middle + // of a ligature. See SwFntObj::DrawText(). + TextFrameIndex const nOldLen = pPor->GetLen(); + aInf.SetLen( pPor->GetLen() ); + pPor->SetLen( nOfst - aInf.GetIdx() ); + aInf.SetMeasureLen(pPor->GetLen()); + if (aInf.GetLen() < aInf.GetMeasureLen()) + { + pPor->SetLen(aInf.GetMeasureLen()); + aInf.SetLen(pPor->GetLen()); + } + if( nX || !pPor->InNumberGrp() ) + { + SeekAndChg( aInf ); + const bool bOldOnWin = aInf.OnWin(); + aInf.SetOnWin( false ); // no BULLETs! + SwTwips nTmp = nX; + aInf.SetKanaComp( pKanaComp ); + aInf.SetKanaIdx( nKanaIdx ); + nX += pPor->GetTextSize( aInf ).Width(); + aInf.SetOnWin( bOldOnWin ); + if ( pPor->InSpaceGrp() && nSpaceAdd ) + nX += pPor->CalcSpacing( nSpaceAdd, aInf ); + if( bWidth ) + { + pPor->SetLen(pPor->GetLen() + TextFrameIndex(1)); + aInf.SetMeasureLen(pPor->GetLen()); + if (aInf.GetLen() < aInf.GetMeasureLen()) + { + pPor->SetLen(aInf.GetMeasureLen()); + aInf.SetLen(pPor->GetLen()); + } + aInf.SetOnWin( false ); // no BULLETs! + nTmp += pPor->GetTextSize( aInf ).Width(); + aInf.SetOnWin( bOldOnWin ); + if ( pPor->InSpaceGrp() && nSpaceAdd ) + nTmp += pPor->CalcSpacing(nSpaceAdd, aInf); + pOrig->Width( nTmp - nX ); + } + } + pPor->SetLen( nOldLen ); + + // Shift the cursor with the right border width + // Note: nX remains positive because GetTextSize() also include the width of the right border + if( aInf.GetIdx() < nOfst && nOfst < aInf.GetIdx() + pPor->GetLen() ) + { + // Find the current drop portion part and use its right border + if( pPor->IsDropPortion() && static_cast(pPor)->GetLines() > 1 ) + { + SwDropPortion* pDrop = static_cast(pPor); + const SwDropPortionPart* pCurrPart = pDrop->GetPart(); + TextFrameIndex nSumLength(0); + while( pCurrPart && (nSumLength += pCurrPart->GetLen()) < nOfst - aInf.GetIdx() ) + { + pCurrPart = pCurrPart->GetFollow(); + } + if( pCurrPart && nSumLength != nOfst - aInf.GetIdx() && + pCurrPart->GetFont().GetRightBorder() && !pCurrPart->GetJoinBorderWithNext() ) + { + nX -= pCurrPart->GetFont().GetRightBorderSpace(); + } + } + else if( GetInfo().GetFont()->GetRightBorder() && !pPor->GetJoinBorderWithNext()) + { + nX -= GetInfo().GetFont()->GetRightBorderSpace(); + } + } + } + bWidth = false; + break; + } + } + } + + if( pPor ) + { + OSL_ENSURE( !pPor->InNumberGrp() || bInsideFirstField, "Number surprise" ); + bool bEmptyField = false; + if( pPor->InFieldGrp() && pPor->GetLen() ) + { + SwFieldPortion *pTmp = static_cast(pPor); + while( pTmp->HasFollow() && pTmp->GetExp().isEmpty() ) + { + sal_uInt16 nAddX = pTmp->Width(); + SwLinePortion *pNext = pTmp->GetNextPortion(); + while( pNext && !pNext->InFieldGrp() ) + { + OSL_ENSURE( !pNext->GetLen(), "Where's my field follow?" ); + nAddX = nAddX + pNext->Width(); + pNext = pNext->GetNextPortion(); + } + if( !pNext ) + break; + pTmp = static_cast(pNext); + nPorHeight = pTmp->Height(); + nPorAscent = pTmp->GetAscent(); + nX += nAddX; + bEmptyField = true; + } + } + // 8513: Fields in justified text, skipped + while( pPor && !pPor->GetLen() && ! bInsideFirstField && + ( pPor->IsFlyPortion() || pPor->IsKernPortion() || + pPor->IsBlankPortion() || pPor->InTabGrp() || + ( !bEmptyField && pPor->InFieldGrp() ) ) ) + { + if ( pPor->InSpaceGrp() && nSpaceAdd ) + nX += pPor->PrtWidth() + + pPor->CalcSpacing( nSpaceAdd, aInf ); + else + { + if( pPor->InFixMargGrp() && ! pPor->IsMarginPortion() ) + { + if ( m_pCurr->IsSpaceAdd() ) + { + if ( ++nSpaceIdx < m_pCurr->GetLLSpaceAddCount() ) + nSpaceAdd = m_pCurr->GetLLSpaceAdd( nSpaceIdx ); + else + nSpaceAdd = 0; + } + + if( pKanaComp && ( nKanaIdx + 1 ) < pKanaComp->size() ) + ++nKanaIdx; + } + if ( !pPor->IsFlyPortion() || ( pPor->GetNextPortion() && + !pPor->GetNextPortion()->IsMarginPortion() ) ) + nX += pPor->PrtWidth(); + } + if( pPor->IsMultiPortion() && + static_cast(pPor)->HasTabulator() ) + { + if ( m_pCurr->IsSpaceAdd() ) + { + if ( ++nSpaceIdx < m_pCurr->GetLLSpaceAddCount() ) + nSpaceAdd = m_pCurr->GetLLSpaceAdd( nSpaceIdx ); + else + nSpaceAdd = 0; + } + + if( pKanaComp && ( nKanaIdx + 1 ) < pKanaComp->size() ) + ++nKanaIdx; + } + if( !pPor->IsFlyPortion() ) + { + nPorHeight = pPor->Height(); + nPorAscent = pPor->GetAscent(); + } + pPor = pPor->GetNextPortion(); + } + + if( aInf.GetIdx() == nOfst && pPor && pPor->InHyphGrp() && + pPor->GetNextPortion() && pPor->GetNextPortion()->InFixGrp() ) + { + // All special portions have to be skipped + // Taking the German word "zusammen" as example: zu-[FLY]sammen, 'u' == 19, 's' == 20; Right() + // Without the adjustment we end up in front of '-', with the + // adjustment in front of the 's'. + while( pPor && !pPor->GetLen() ) + { + nX += pPor->Width(); + if( !pPor->IsMarginPortion() ) + { + nPorHeight = pPor->Height(); + nPorAscent = pPor->GetAscent(); + } + pPor = pPor->GetNextPortion(); + } + } + if( pPor && pCMS ) + { + if( pCMS->m_bFieldInfo && pPor->InFieldGrp() && pPor->Width() ) + pOrig->Width( pPor->Width() ); + if( pPor->IsDropPortion() ) + { + nPorAscent = static_cast(pPor)->GetDropHeight(); + // The drop height is only calculated, if we have more than + // one line. Otherwise it is 0. + if ( ! nPorAscent) + nPorAscent = pPor->Height(); + nPorHeight = nPorAscent; + pOrig->Height( nPorHeight + + static_cast(pPor)->GetDropDescent() ); + if( nTmpHeight < pOrig->Height() ) + { + nTmpAscent = nPorAscent; + nTmpHeight = sal_uInt16( pOrig->Height() ); + } + } + if( bWidth && pPor->PrtWidth() && pPor->GetLen() && + aInf.GetIdx() == nOfst ) + { + if( !pPor->IsFlyPortion() && pPor->Height() && + pPor->GetAscent() ) + { + nPorHeight = pPor->Height(); + nPorAscent = pPor->GetAscent(); + } + SwTwips nTmp; + if (TextFrameIndex(2) > pPor->GetLen()) + { + nTmp = pPor->Width(); + if ( pPor->InSpaceGrp() && nSpaceAdd ) + nTmp += pPor->CalcSpacing( nSpaceAdd, aInf ); + } + else + { + const bool bOldOnWin = aInf.OnWin(); + TextFrameIndex const nOldLen = pPor->GetLen(); + aInf.SetLen( pPor->GetLen() ); + pPor->SetLen( TextFrameIndex(1) ); + aInf.SetMeasureLen(pPor->GetLen()); + if (aInf.GetLen() < aInf.GetMeasureLen()) + { + pPor->SetLen(aInf.GetMeasureLen()); + aInf.SetLen(pPor->GetLen()); + } + SeekAndChg( aInf ); + aInf.SetOnWin( false ); // no BULLETs! + aInf.SetKanaComp( pKanaComp ); + aInf.SetKanaIdx( nKanaIdx ); + nTmp = pPor->GetTextSize( aInf ).Width(); + aInf.SetOnWin( bOldOnWin ); + if ( pPor->InSpaceGrp() && nSpaceAdd ) + nTmp += pPor->CalcSpacing( nSpaceAdd, aInf ); + pPor->SetLen( nOldLen ); + } + pOrig->Width( nTmp ); + } + + // travel inside field portion? + if ( pCMS->m_pSpecialPos ) + { + // apply attributes to font + Seek( nOfst ); + lcl_GetCharRectInsideField( aInf, *pOrig, *pCMS, *pPor ); + } + } + } + + // special case: We are at the beginning of a BidiPortion or + // directly behind a BidiPortion + if ( pCMS && + ( pLastBidiPor || + ( pPor && + pPor->IsMultiPortion() && + static_cast(pPor)->IsBidi() ) ) ) + { + // we determine if the cursor has to blink before or behind + // the bidi portion + if ( pLastBidiPor ) + { + const sal_uInt8 nPortionLevel = pLastBidiPor->GetLevel(); + + if ( pCMS->m_nCursorBidiLevel >= nPortionLevel ) + { + // we came from inside the bidi portion, we want to blink + // behind the portion + pOrig->Pos().AdjustX( -nLastBidiPorWidth ); + + // Again, there is a special case: logically behind + // the portion can actually mean that the cursor is inside + // the portion. This can happen is the last portion + // inside the bidi portion is a nested bidi portion + SwLineLayout& rLineLayout = + static_cast(pLastBidiPor)->GetRoot(); + + const SwLinePortion *pLast = rLineLayout.FindLastPortion(); + if ( pLast->IsMultiPortion() ) + { + OSL_ENSURE( static_cast(pLast)->IsBidi(), + "Non-BidiPortion inside BidiPortion" ); + TextFrameIndex const nIdx = aInf.GetIdx(); + // correct the index before using CalcSpacing. + aInf.SetIdx(nLastBidiIdx); + pOrig->Pos().AdjustX(pLast->Width() + + pLast->CalcSpacing( nSpaceAdd, aInf ) ); + aInf.SetIdx(nIdx); + } + } + } + else + { + const sal_uInt8 nPortionLevel = static_cast(pPor)->GetLevel(); + + if ( pCMS->m_nCursorBidiLevel >= nPortionLevel ) + { + // we came from inside the bidi portion, we want to blink + // behind the portion + pOrig->Pos().AdjustX(pPor->Width() + + pPor->CalcSpacing( nSpaceAdd, aInf ) ); + } + } + } + + pOrig->Pos().AdjustX(nX ); + + if ( pCMS && pCMS->m_bRealHeight ) + { + nTmpAscent = AdjustBaseLine( *m_pCurr, nullptr, nPorHeight, nPorAscent ); + if ( nTmpAscent > nPorAscent ) + pCMS->m_aRealHeight.setX( nTmpAscent - nPorAscent ); + else + pCMS->m_aRealHeight.setX( 0 ); + OSL_ENSURE( nPorHeight, "GetCharRect: Missing Portion-Height" ); + if ( nTmpHeight > nPorHeight ) + pCMS->m_aRealHeight.setY( nPorHeight ); + else + pCMS->m_aRealHeight.setY( nTmpHeight ); + } + } +} + +void SwTextCursor::GetCharRect( SwRect* pOrig, TextFrameIndex const nOfst, + SwCursorMoveState* pCMS, const tools::Long nMax ) +{ + CharCursorToLine(nOfst); + + // Indicates that a position inside a special portion (field, number portion) + // is requested. + const bool bSpecialPos = pCMS && pCMS->m_pSpecialPos; + TextFrameIndex nFindOfst = nOfst; + + if ( bSpecialPos ) + { + const SwSPExtendRange nExtendRange = pCMS->m_pSpecialPos->nExtendRange; + + OSL_ENSURE( ! pCMS->m_pSpecialPos->nLineOfst || SwSPExtendRange::BEFORE != nExtendRange, + "LineOffset AND Number Portion?" ); + + // portions which are behind the string + if ( SwSPExtendRange::BEHIND == nExtendRange ) + ++nFindOfst; + + // skip lines for fields which cover more than one line + for ( sal_Int32 i = 0; i < pCMS->m_pSpecialPos->nLineOfst; i++ ) + Next(); + } + + // If necessary, as catch up, do the adjustment + GetAdjusted(); + AddExtraBlankWidth(); + + const Point aCharPos( GetTopLeft() ); + + GetCharRect_( pOrig, nFindOfst, pCMS ); + + pOrig->Pos().AdjustX(aCharPos.X() ); + pOrig->Pos().AdjustY(aCharPos.Y() ); + + if( pCMS && pCMS->m_b2Lines && pCMS->m_p2Lines ) + { + pCMS->m_p2Lines->aLine.Pos().AdjustX(aCharPos.X() ); + pCMS->m_p2Lines->aLine.Pos().AdjustY(aCharPos.Y() ); + pCMS->m_p2Lines->aPortion.Pos().AdjustX(aCharPos.X() ); + pCMS->m_p2Lines->aPortion.Pos().AdjustY(aCharPos.Y() ); + } + + if( nMax ) + { + if( pOrig->Top() + pOrig->Height() > nMax ) + { + if( pOrig->Top() > nMax ) + pOrig->Top( nMax ); + pOrig->Height( nMax - pOrig->Top() ); + } + if ( pCMS && pCMS->m_bRealHeight && pCMS->m_aRealHeight.Y() >= 0 ) + { + tools::Long nTmp = pCMS->m_aRealHeight.X() + pOrig->Top(); + if( nTmp >= nMax ) + { + pCMS->m_aRealHeight.setX( nMax - pOrig->Top() ); + pCMS->m_aRealHeight.setY( 0 ); + } + else if( nTmp + pCMS->m_aRealHeight.Y() > nMax ) + pCMS->m_aRealHeight.setY( nMax - nTmp ); + } + } +} + +/** + * Determines if SwTextCursor::GetModelPositionForViewPoint() should consider the next portion when calculating the + * doc model position from a Point. + */ +static bool ConsiderNextPortionForCursorOffset(const SwLinePortion* pPor, SwTwips nWidth30, sal_uInt16 nX) +{ + if (!pPor->GetNextPortion() || pPor->IsBreakPortion()) + { + return false; + } + + // tdf#138592: consider all following zero-width text portions of current text portion, + // like combining characters. + if (nWidth30 == nX && pPor->IsTextPortion() && pPor->GetNextPortion()->IsTextPortion() + && pPor->GetNextPortion()->Width() == 0) + return true; + + // If we're past the target position, stop the iteration in general. + // Exception: don't stop the iteration between as-char fly portions and their comments. + if (nWidth30 >= nX && (!pPor->IsFlyCntPortion() || !pPor->GetNextPortion()->IsPostItsPortion())) + { + // Normally returns false. + + // Another exception: If the cursor is at the very end of the portion, and the next portion is a comment, + // then place the cursor after the zero-width comment. This is primarily to benefit the very end of a line. + return nWidth30 == nX && pPor->GetNextPortion()->IsPostItsPortion(); + } + + return true; +} + +// Return: Offset in String +TextFrameIndex SwTextCursor::GetModelPositionForViewPoint( SwPosition *pPos, const Point &rPoint, + bool bChgNode, SwCursorMoveState* pCMS ) const +{ + // If necessary, as catch up, do the adjustment + GetAdjusted(); + + const OUString &rText = GetInfo().GetText(); + TextFrameIndex nOffset(0); + + // x is the horizontal offset within the line. + SwTwips x = rPoint.X(); + const SwTwips nLeftMargin = GetLineStart(); + SwTwips nRightMargin = GetLineEnd() + + ( GetCurr()->IsHanging() ? GetCurr()->GetHangingMargin() : 0 ); + if( nRightMargin == nLeftMargin ) + nRightMargin += 30; + + const bool bLeftOver = x < nLeftMargin; + if( bLeftOver ) + x = nLeftMargin; + const bool bRightOver = x > nRightMargin; + const bool bRightAllowed = pCMS && ( pCMS->m_eState == CursorMoveState::NONE ); + + // Until here everything in document coordinates. + x -= nLeftMargin; + + SwTwips nX = x; + + // If there are attribute changes in the line, search for the paragraph, + // in which nX is situated. + SwLinePortion *pPor = m_pCurr->GetFirstPortion(); + TextFrameIndex nCurrStart = m_nStart; + bool bLastHyph = false; + + std::deque *pKanaComp = m_pCurr->GetpKanaComp(); + TextFrameIndex const nOldIdx = GetInfo().GetIdx(); + sal_uInt16 nSpaceIdx = 0; + size_t nKanaIdx = 0; + tools::Long nSpaceAdd = m_pCurr->IsSpaceAdd() ? m_pCurr->GetLLSpaceAdd( 0 ) : 0; + short nKanaComp = pKanaComp ? (*pKanaComp)[0] : 0; + + // nWidth is the width of the line, or the width of + // the paragraph with the font change, in which nX is situated. + + SwTwips nWidth = pPor->Width(); + if ( m_pCurr->IsSpaceAdd() || pKanaComp ) + { + if ( pPor->InSpaceGrp() && nSpaceAdd ) + { + const_cast(GetInfo()).SetIdx( nCurrStart ); + nWidth = nWidth + pPor->CalcSpacing( nSpaceAdd, GetInfo() ); + } + if( ( pPor->InFixMargGrp() && ! pPor->IsMarginPortion() ) || + ( pPor->IsMultiPortion() && static_cast(pPor)->HasTabulator() ) + ) + { + if ( m_pCurr->IsSpaceAdd() ) + { + if ( ++nSpaceIdx < m_pCurr->GetLLSpaceAddCount() ) + nSpaceAdd = m_pCurr->GetLLSpaceAdd( nSpaceIdx ); + else + nSpaceAdd = 0; + } + + if( pKanaComp ) + { + if ( nKanaIdx + 1 < pKanaComp->size() ) + nKanaComp = (*pKanaComp)[++nKanaIdx]; + else + nKanaComp = 0; + } + } + } + + SwTwips nWidth30; + if ( pPor->IsPostItsPortion() ) + nWidth30 = 0; + else + nWidth30 = ! nWidth && pPor->GetLen() && pPor->InToxRefOrFieldGrp() ? + 30 : + nWidth; + + while (ConsiderNextPortionForCursorOffset(pPor, nWidth30, nX)) + { + nX = nX - nWidth; + nCurrStart = nCurrStart + pPor->GetLen(); + pPor = pPor->GetNextPortion(); + nWidth = pPor->Width(); + if ( m_pCurr->IsSpaceAdd() || pKanaComp ) + { + if ( pPor->InSpaceGrp() && nSpaceAdd ) + { + const_cast(GetInfo()).SetIdx( nCurrStart ); + nWidth = nWidth + pPor->CalcSpacing( nSpaceAdd, GetInfo() ); + } + + if( ( pPor->InFixMargGrp() && ! pPor->IsMarginPortion() ) || + ( pPor->IsMultiPortion() && static_cast(pPor)->HasTabulator() ) + ) + { + if ( m_pCurr->IsSpaceAdd() ) + { + if ( ++nSpaceIdx < m_pCurr->GetLLSpaceAddCount() ) + nSpaceAdd = m_pCurr->GetLLSpaceAdd( nSpaceIdx ); + else + nSpaceAdd = 0; + } + + if ( pKanaComp ) + { + if( nKanaIdx + 1 < pKanaComp->size() ) + nKanaComp = (*pKanaComp)[++nKanaIdx]; + else + nKanaComp = 0; + } + } + } + + if ( pPor->IsPostItsPortion() ) + nWidth30 = 0; + else + nWidth30 = ! nWidth && pPor->GetLen() && pPor->InToxRefOrFieldGrp() ? + 30 : + nWidth; + if( !pPor->IsFlyPortion() && !pPor->IsMarginPortion() ) + bLastHyph = pPor->InHyphGrp(); + } + + const bool bLastPortion = (nullptr == pPor->GetNextPortion()); + + if( nX==nWidth ) + { + SwLinePortion *pNextPor = pPor->GetNextPortion(); + while( pNextPor && pNextPor->InFieldGrp() && !pNextPor->Width() ) + { + nCurrStart = nCurrStart + pPor->GetLen(); + pPor = pNextPor; + if( !pPor->IsFlyPortion() && !pPor->IsMarginPortion() ) + bLastHyph = pPor->InHyphGrp(); + pNextPor = pPor->GetNextPortion(); + } + } + + const_cast(GetInfo()).SetIdx( nOldIdx ); + + TextFrameIndex nLength = pPor->GetLen(); + + const bool bFieldInfo = pCMS && pCMS->m_bFieldInfo; + + if( bFieldInfo && ( nWidth30 < nX || bRightOver || bLeftOver || + ( pPor->InNumberGrp() && !pPor->IsFootnoteNumPortion() ) || + ( pPor->IsMarginPortion() && nWidth > nX + 30 ) ) ) + pCMS->m_bPosCorr = true; + + // #i27615# + if (pCMS && pCMS->m_bInFrontOfLabel) + { + if (2 * nX >= nWidth || !pPor->InNumberGrp() || pPor->IsFootnoteNumPortion()) + pCMS->m_bInFrontOfLabel = false; + } + + // 7684: We are exactly ended up at their HyphPortion. It is our task to + // provide, that we end up in the String. + // 7993: If length = 0, then we must exit... + if( !nLength ) + { + if( pCMS ) + { + if( pPor->IsFlyPortion() && bFieldInfo ) + pCMS->m_bPosCorr = true; + + if (!bRightOver && nX) + { + if( pPor->IsFootnoteNumPortion()) + pCMS->m_bFootnoteNoInfo = true; + else if (pPor->InNumberGrp() ) // #i23726# + { + pCMS->m_nInNumPortionOffset = nX; + pCMS->m_bInNumPortion = true; + } + } + } + if( !nCurrStart ) + return TextFrameIndex(0); + + // 7849, 7816: pPor->GetHyphPortion is mandatory! + if( ( !bRightAllowed && bLastHyph ) || + ( pPor->IsMarginPortion() && !pPor->GetNextPortion() && + // 46598: Consider the situation: We might end up behind the last character, + // in the last line of a centered paragraph + nCurrStart < TextFrameIndex(rText.getLength()))) + --nCurrStart; + else if( pPor->InFieldGrp() && static_cast(pPor)->IsFollow() + && nWidth > nX ) + { + if( bFieldInfo ) + --nCurrStart; + else + { + sal_uInt16 nHeight = pPor->Height(); + if ( !nHeight || nHeight > nWidth ) + nHeight = nWidth; + if( bChgNode && nWidth - nHeight/2 > nX ) + --nCurrStart; + } + } + if (!pPor->InFieldGrp() || !static_cast(pPor)->IsFollow() + || !pCMS || !pCMS->m_pSpecialPos) + { + return nCurrStart; + } + } + if (TextFrameIndex(1) == nLength || pPor->InFieldGrp()) + { + if ( nWidth ) + { + // no quick return for as-character frames, we want to peek inside + if (!(bChgNode && pPos && pPor->IsFlyCntPortion()) + // if we want to get the position inside the field, we should not return + && (!pCMS || !pCMS->m_pSpecialPos)) + { + if ( pPor->InFieldGrp() || + ( pPor->IsMultiPortion() && + static_cast(pPor)->IsBidi() ) ) + { + sal_uInt16 nHeight = 0; + if( !bFieldInfo ) + { + nHeight = pPor->Height(); + if ( !nHeight || nHeight > nWidth ) + nHeight = nWidth; + } + + if( nWidth - nHeight/2 <= nX && + ( ! pPor->InFieldGrp() || + !static_cast(pPor)->HasFollow() ) ) + { + if (pPor->InFieldGrp()) + { + nCurrStart += static_cast(pPor)->GetFieldLen(); + } + else + { + ++nCurrStart; + } + } + } + else if ( ( !pPor->IsFlyPortion() || ( pPor->GetNextPortion() && + !pPor->GetNextPortion()->IsMarginPortion() && + !pPor->GetNextPortion()->IsHolePortion() ) ) + && ( nWidth/2 < nX ) && + ( !bFieldInfo || + ( pPor->GetNextPortion() && + pPor->GetNextPortion()->IsPostItsPortion() ) ) + && ( bRightAllowed || !bLastHyph )) + ++nCurrStart; + + return nCurrStart; + } + } + else + { + if ( pPor->IsPostItsPortion() || pPor->IsBreakPortion() || + pPor->InToxRefGrp() ) + { + SwPostItsPortion* pPostItsPortion = pPor->IsPostItsPortion() ? dynamic_cast(pPor) : nullptr; + if (pPostItsPortion) + { + if (!pPostItsPortion->IsScript()) // tdf#141079 + { + // Offset would be nCurrStart + nLength below, do the same for post-it portions. + nCurrStart += pPor->GetLen(); + } + } + return nCurrStart; + } + if ( pPor->InFieldGrp() ) + { + if( bRightOver && !static_cast(pPor)->HasFollow() ) + { + nCurrStart += static_cast(pPor)->GetFieldLen(); + } + return nCurrStart; + } + } + } + + // Skip space at the end of the line + if( bLastPortion && (m_pCurr->GetNext() || m_pFrame->GetFollow() ) + && sal_Int32(nLength) != 0 + && rText[sal_Int32(nCurrStart + nLength) - 1] == ' ') + { + --nLength; + } + + if( nWidth > nX || + ( nWidth == nX && pPor->IsMultiPortion() && static_cast(pPor)->IsDouble() ) ) + { + if( pPor->IsMultiPortion() ) + { + // In a multi-portion we use GetModelPositionForViewPoint()-function recursively + SwTwips nTmpY = rPoint.Y() - m_pCurr->GetAscent() + pPor->GetAscent(); + // if we are in the first line of a double line portion, we have + // to add a value to nTmpY for not staying in this line + // we also want to skip the first line, if we are inside ruby + if ( ( static_cast(m_pInf)->IsMulti() && + static_cast(m_pInf)->IsFirstMulti() ) || + ( static_cast(pPor)->IsRuby() && + static_cast(pPor)->OnTop() ) ) + nTmpY += static_cast(pPor)->Height(); + + // Important for cursor traveling in ruby portions: + // We have to set nTmpY to 0 in order to stay in the first row + // if the phonetic line is the second row + if ( static_cast(pPor)->IsRuby() && + ! static_cast(pPor)->OnTop() ) + nTmpY = 0; + + SwTextCursorSave aSave( const_cast(this), static_cast(pPor), + nTmpY, nX, nCurrStart, nSpaceAdd ); + + SwLayoutModeModifier aLayoutModeModifier( *GetInfo().GetOut() ); + if ( static_cast(pPor)->IsBidi() ) + { + const sal_uInt8 nBidiLevel = static_cast(pPor)->GetLevel(); + aLayoutModeModifier.Modify( nBidiLevel % 2 ); + } + + if( static_cast(pPor)->HasRotation() ) + { + nTmpY -= m_nY; + if( !static_cast(pPor)->IsRevers() ) + nTmpY = pPor->Height() - nTmpY; + if( nTmpY < 0 ) + nTmpY = 0; + nX = o3tl::narrowing(nTmpY); + } + + if( static_cast(pPor)->HasBrackets() ) + { + const sal_uInt16 nPreWidth = static_cast(pPor)->PreWidth(); + if ( nX > nPreWidth ) + nX = nX - nPreWidth; + else + nX = 0; + } + + return GetModelPositionForViewPoint( pPos, Point( GetLineStart() + nX, rPoint.Y() ), + bChgNode, pCMS ); + } + if( pPor->InTextGrp() || pPor->IsHolePortion() ) + { + sal_uInt8 nOldProp; + if( GetPropFont() ) + { + const_cast(GetFnt())->SetProportion( GetPropFont() ); + nOldProp = GetFnt()->GetPropr(); + } + else + nOldProp = 0; + { + SwTextSizeInfo aSizeInf( GetInfo(), &rText, nCurrStart ); + const_cast(this)->SeekAndChg( aSizeInf ); + SwTextSlot aDiffText( &aSizeInf, pPor, false, false ); + SwFontSave aSave( aSizeInf, pPor->IsDropPortion() ? + static_cast(pPor)->GetFnt() : nullptr ); + + SwParaPortion* pPara = const_cast(GetInfo().GetParaPortion()); + OSL_ENSURE( pPara, "No paragraph!" ); + + // protect against bugs elsewhere + SAL_WARN_IF( aSizeInf.GetIdx().get() + pPor->GetLen().get() > aSizeInf.GetText().getLength(), "sw", "portion and text are out of sync" ); + TextFrameIndex nSafeLen( std::min(pPor->GetLen().get(), aSizeInf.GetText().getLength() - aSizeInf.GetIdx().get()) ); + + SwDrawTextInfo aDrawInf( aSizeInf.GetVsh(), + *aSizeInf.GetOut(), + &pPara->GetScriptInfo(), + aSizeInf.GetText(), + aSizeInf.GetIdx(), + nSafeLen ); + + // Drop portion works like a multi portion, just its parts are not portions + if( pPor->IsDropPortion() && static_cast(pPor)->GetLines() > 1 ) + { + SwDropPortion* pDrop = static_cast(pPor); + const SwDropPortionPart* pCurrPart = pDrop->GetPart(); + sal_uInt16 nSumWidth = 0; + sal_uInt16 nSumBorderWidth = 0; + // Shift offset with the right and left border of previous parts and left border of actual one + while (pCurrPart && nSumWidth <= nX - sal_Int32(nCurrStart)) + { + nSumWidth += pCurrPart->GetWidth(); + if( pCurrPart->GetFont().GetLeftBorder() && !pCurrPart->GetJoinBorderWithPrev() ) + { + nSumBorderWidth += pCurrPart->GetFont().GetLeftBorderSpace(); + } + if (nSumWidth <= nX - sal_Int32(nCurrStart) && pCurrPart->GetFont().GetRightBorder() && + !pCurrPart->GetJoinBorderWithNext() ) + { + nSumBorderWidth += pCurrPart->GetFont().GetRightBorderSpace(); + } + pCurrPart = pCurrPart->GetFollow(); + } + nX = std::max(static_cast(0), nX - nSumBorderWidth); + } + // Shift the offset with the left border width + else if( GetInfo().GetFont()->GetLeftBorder() && !pPor->GetJoinBorderWithPrev() ) + { + nX = std::max(static_cast(0), nX - GetInfo().GetFont()->GetLeftBorderSpace()); + } + + aDrawInf.SetOffset( nX ); + + if ( nSpaceAdd ) + { + TextFrameIndex nCharCnt(0); + // #i41860# Thai justified alignment needs some + // additional information: + aDrawInf.SetNumberOfBlanks( pPor->InTextGrp() ? + static_cast(pPor)->GetSpaceCnt( aSizeInf, nCharCnt ) : + TextFrameIndex(0) ); + } + + if ( pPor->InFieldGrp() && pCMS && pCMS->m_pSpecialPos ) + aDrawInf.SetLen( TextFrameIndex(COMPLETE_STRING) ); + + aDrawInf.SetSpace( nSpaceAdd ); + aDrawInf.SetFont( aSizeInf.GetFont() ); + aDrawInf.SetFrame( m_pFrame ); + aDrawInf.SetSnapToGrid( aSizeInf.SnapToGrid() ); + aDrawInf.SetPosMatchesBounds( pCMS && pCMS->m_bPosMatchesBounds ); + + if ( SwFontScript::CJK == aSizeInf.GetFont()->GetActual() && + pPara->GetScriptInfo().CountCompChg() && + ! pPor->InFieldGrp() ) + aDrawInf.SetKanaComp( nKanaComp ); + + nLength = aSizeInf.GetFont()->GetModelPositionForViewPoint_( aDrawInf ); + + // get position inside field portion? + if ( pPor->InFieldGrp() && pCMS && pCMS->m_pSpecialPos ) + { + pCMS->m_pSpecialPos->nCharOfst = sal_Int32(nLength); + // follow portions: need to add the length of all previous + // portions for the same field + if (static_cast(pPor)->IsFollow()) + { + int nLines(0); + std::vector portions; + for (SwLineLayout const* pLine = GetInfo().GetParaPortion(); + true; pLine = pLine->GetNext()) + { + for (SwLinePortion const* pLP = pLine; pLP && pLP != pPor; pLP = pLP->GetNextPortion()) + { + if (pLP->InFieldGrp()) + { + SwFieldPortion const* pField(static_cast(pLP)); + if (!pField->IsFollow()) + { + nLines = 0; + portions.clear(); + } + if (pLine == m_pCurr) + { + portions.emplace_back(pField); + } + } + } + if (pLine == m_pCurr) + { + break; + } + ++nLines; + } + for (SwFieldPortion const* pField : portions) + { + pCMS->m_pSpecialPos->nCharOfst += pField->GetExp().getLength(); + } + pCMS->m_pSpecialPos->nLineOfst = nLines; + } + nLength = TextFrameIndex(0); + } + else if (bFieldInfo && nLength == pPor->GetLen() && + (! pPor->GetNextPortion() || + ! pPor->GetNextPortion()->IsPostItsPortion())) + { + --nLength; + } + + // set cursor bidi level + if ( pCMS ) + pCMS->m_nCursorBidiLevel = + aDrawInf.GetCursorBidiLevel(); + } + if( nOldProp ) + const_cast(GetFnt())->SetProportion( nOldProp ); + } + else + { + sw::FlyContentPortion* pFlyPor(nullptr); + if(bChgNode && pPos && (pFlyPor = dynamic_cast(pPor))) + { + // JP 24.11.94: if the Position is not in Fly, then + // we many not return with COMPLETE_STRING as value! + // (BugId: 9692 + Change in feshview) + SwFlyInContentFrame *pTmp = pFlyPor->GetFlyFrame(); + SwFrame* pLower = pTmp->GetLower(); + // Allow non-text-frames to get SwGrfNode for as-char anchored images into pPos + // instead of the closest SwTextNode, to be consistent with at-char behavior. + bool bChgNodeInner = pLower + && (pLower->IsTextFrame() || pLower->IsLayoutFrame() || pLower->IsNoTextFrame()); + Point aTmpPoint( rPoint ); + + if ( m_pFrame->IsRightToLeft() ) + m_pFrame->SwitchLTRtoRTL( aTmpPoint ); + + if ( m_pFrame->IsVertical() ) + m_pFrame->SwitchHorizontalToVertical( aTmpPoint ); + + if( bChgNodeInner && pTmp->getFrameArea().Contains( aTmpPoint ) && + !( pTmp->IsProtected() ) ) + { + pFlyPor->GetFlyCursorOfst(aTmpPoint, *pPos, pCMS); + // After a change of the frame, our font must be still + // available for/in the OutputDevice. + // For comparison: Paint and new SwFlyCntPortion ! + static_cast(m_pInf)->SelectFont(); + + // 6776: The pIter->GetModelPositionForViewPoint is returning here + // from a nesting with COMPLETE_STRING. + return TextFrameIndex(COMPLETE_STRING); + } + } + else + nLength = pPor->GetModelPositionForViewPoint( nX ); + } + } + nOffset = nCurrStart + nLength; + + // 7684: We end up in front of the HyphPortion. We must assure + // that we end up in the string. + // If we are at end of line in front of FlyFrames, we must proceed the same way. + if( nOffset && pPor->GetLen() == nLength && pPor->GetNextPortion() && + !pPor->GetNextPortion()->GetLen() && pPor->GetNextPortion()->InHyphGrp() ) + --nOffset; + + return nOffset; +} + +/** Looks for text portions which are inside the given rectangle + + For a rectangular text selection every text portions which is inside the given + rectangle has to be put into the SwSelectionList as SwPaM + From these SwPaM the SwCursors will be created. + + @param rSelList + The container for the overlapped text portions + + @param rRect + A rectangle in document coordinates, text inside this rectangle has to be + selected. + + @return [ true, false ] + true if any overlapping text portion has been found and put into list + false if no portion overlaps, the list has been unchanged +*/ +bool SwTextFrame::FillSelection( SwSelectionList& rSelList, const SwRect& rRect ) const +{ + bool bRet = false; + // GetPaintArea() instead getFrameArea() for negative indents + SwRect aTmpFrame( GetPaintArea() ); + if( !rRect.Overlaps( aTmpFrame ) ) + return false; + if( rSelList.checkContext( this ) ) + { + SwRect aRect( aTmpFrame ); + aRect.Intersection( rRect ); + SwPosition aPosL( MapViewToModelPos(TextFrameIndex(0)) ); + if( IsEmpty() ) + { + SwPaM *pPam = new SwPaM( aPosL, aPosL ); + rSelList.insertPaM( pPam ); + } + else if( aRect.HasArea() ) + { + SwPosition aOld(aPosL.GetNodes().GetEndOfContent()); + SwPosition aPosR( aPosL ); + Point aPoint; + SwTextInfo aInf( const_cast(this) ); + SwTextIter aLine( const_cast(this), &aInf ); + // We have to care for top-to-bottom layout, where right becomes top etc. + SwRectFnSet aRectFnSet(this); + SwTwips nTop = aRectFnSet.GetTop(aRect); + SwTwips nBottom = aRectFnSet.GetBottom(aRect); + SwTwips nLeft = aRectFnSet.GetLeft(aRect); + SwTwips nRight = aRectFnSet.GetRight(aRect); + SwTwips nY = aLine.Y(); // Top position of the first line + SwTwips nLastY = nY; + while( nY < nTop && aLine.Next() ) // line above rectangle + { + nLastY = nY; + nY = aLine.Y(); + } + bool bLastLine = false; + if( nY < nTop && !aLine.GetNext() ) + { + bLastLine = true; + nY += aLine.GetLineHeight(); + } + do // check the lines for overlapping + { + if( nLastY < nTop ) // if the last line was above rectangle + nLastY = nTop; + if( nY > nBottom ) // if the current line leaves the rectangle + nY = nBottom; + if( nY >= nLastY ) // gotcha: overlapping + { + nLastY += nY; + nLastY /= 2; + if( aRectFnSet.IsVert() ) + { + aPoint.setX( nLastY ); + aPoint.setY( nLeft ); + } + else + { + aPoint.setX( nLeft ); + aPoint.setY( nLastY ); + } + // Looking for the position of the left border of the rectangle + // in this text line + SwCursorMoveState aState( CursorMoveState::UpDown ); + if( GetModelPositionForViewPoint( &aPosL, aPoint, &aState ) ) + { + if( aRectFnSet.IsVert() ) + { + aPoint.setX( nLastY ); + aPoint.setY( nRight ); + } + else + { + aPoint.setX( nRight ); + aPoint.setY( nLastY ); + } + // If we get a right position and if the left position + // is not the same like the left position of the line before + // which could happen e.g. for field portions or fly frames + // a SwPaM will be inserted with these positions + if( GetModelPositionForViewPoint( &aPosR, aPoint, &aState ) && + aOld != aPosL) + { + SwPaM *pPam = new SwPaM( aPosL, aPosR ); + rSelList.insertPaM( pPam ); + aOld = aPosL; + } + } + } + if( aLine.Next() ) + { + nLastY = nY; + nY = aLine.Y(); + } + else if( !bLastLine ) + { + bLastLine = true; + nLastY = nY; + nY += aLine.GetLineHeight(); + } + else + break; + }while( nLastY < nBottom ); + } + } + if( GetDrawObjs() ) + { + const SwSortedObjs &rObjs = *GetDrawObjs(); + for (SwAnchoredObject* pAnchoredObj : rObjs) + { + const SwFlyFrame* pFly = pAnchoredObj->DynCastFlyFrame(); + if( !pFly ) + continue; + if( pFly->IsFlyInContentFrame() && pFly->FillSelection( rSelList, rRect ) ) + bRet = true; + } + } + return bRet; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/itrform2.cxx b/sw/source/core/text/itrform2.cxx new file mode 100644 index 0000000000..c0b4894f8a --- /dev/null +++ b/sw/source/core/text/itrform2.cxx @@ -0,0 +1,3321 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "itrform2.hxx" +#include "porrst.hxx" +#include "portab.hxx" +#include "porfly.hxx" +#include "portox.hxx" +#include "porref.hxx" +#include "porfld.hxx" +#include "porftn.hxx" +#include "porhyph.hxx" +#include "pordrop.hxx" +#include "redlnitr.hxx" +#include +#include +#include +#include +#include +#include "pormulti.hxx" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace ::com::sun::star; + +namespace { + //! Calculates and sets optimal repaint offset for the current line + tools::Long lcl_CalcOptRepaint( SwTextFormatter &rThis, + SwLineLayout const &rCurr, + TextFrameIndex nOldLineEnd, + const std::vector &rFlyStarts ); + //! Determine if we need to build hidden portions + bool lcl_BuildHiddenPortion(const SwTextSizeInfo& rInf, TextFrameIndex &rPos); + + // Check whether the two font has the same border + bool lcl_HasSameBorder(const SwFont& rFirst, const SwFont& rSecond); +} + +static void ClearFly( SwTextFormatInfo &rInf ) +{ + delete rInf.GetFly(); + rInf.SetFly(nullptr); +} + +void SwTextFormatter::CtorInitTextFormatter( SwTextFrame *pNewFrame, SwTextFormatInfo *pNewInf ) +{ + CtorInitTextPainter( pNewFrame, pNewInf ); + m_pInf = pNewInf; + m_pDropFormat = GetInfo().GetDropFormat(); + m_pMulti = nullptr; + + m_bOnceMore = false; + m_bFlyInContentBase = false; + m_bTruncLines = false; + m_nContentEndHyph = 0; + m_nContentMidHyph = 0; + m_nLeftScanIdx = TextFrameIndex(COMPLETE_STRING); + m_nRightScanIdx = TextFrameIndex(0); + m_pByEndIter.reset(); + m_pFirstOfBorderMerge = nullptr; + + if (m_nStart > TextFrameIndex(GetInfo().GetText().getLength())) + { + OSL_ENSURE( false, "+SwTextFormatter::CTOR: bad offset" ); + m_nStart = TextFrameIndex(GetInfo().GetText().getLength()); + } + +} + +SwTextFormatter::~SwTextFormatter() +{ + // Extremely unlikely, but still possible + // e.g.: field splits up, widows start to matter + if( GetInfo().GetRest() ) + { + delete GetInfo().GetRest(); + GetInfo().SetRest(nullptr); + } +} + +void SwTextFormatter::Insert( SwLineLayout *pLay ) +{ + // Insert BEHIND the current element + if ( m_pCurr ) + { + pLay->SetNext( m_pCurr->GetNext() ); + m_pCurr->SetNext( pLay ); + } + else + m_pCurr = pLay; +} + +sal_uInt16 SwTextFormatter::GetFrameRstHeight() const +{ + // We want the rest height relative to the page. + // If we're in a table, then pFrame->GetUpper() is not the page. + + // GetFrameRstHeight() is being called with Footnote. + // Wrong: const SwFrame *pUpper = pFrame->GetUpper(); + const SwFrame *pPage = m_pFrame->FindPageFrame(); + const SwTwips nHeight = pPage->getFrameArea().Top() + + pPage->getFramePrintArea().Top() + + pPage->getFramePrintArea().Height() - Y(); + if( 0 > nHeight ) + return m_pCurr->Height(); + else + return sal_uInt16( nHeight ); +} + +bool SwTextFormatter::ClearIfIsFirstOfBorderMerge(const SwLinePortion* pPortion) +{ + if (pPortion == m_pFirstOfBorderMerge) + { + m_pFirstOfBorderMerge = nullptr; + return true; + } + return false; +} + +SwLinePortion *SwTextFormatter::Underflow( SwTextFormatInfo &rInf ) +{ + // Save values and initialize rInf + SwLinePortion *pUnderflow = rInf.GetUnderflow(); + if( !pUnderflow ) + return nullptr; + + // We format backwards, i.e. attribute changes can happen the next + // line again. + // Can be seen in 8081.sdw, if you enter text in the first line + + TextFrameIndex const nSoftHyphPos = rInf.GetSoftHyphPos(); + TextFrameIndex const nUnderScorePos = rInf.GetUnderScorePos(); + + // Save flys and set to 0, or else segmentation fault + // Not ClearFly(rInf) ! + SwFlyPortion *pFly = rInf.GetFly(); + rInf.SetFly( nullptr ); + + FeedInf( rInf ); + rInf.SetLast( m_pCurr ); + // pUnderflow does not need to be deleted, because it will drown in the following + // Truncate() + rInf.SetUnderflow(nullptr); + rInf.SetSoftHyphPos( nSoftHyphPos ); + rInf.SetUnderScorePos( nUnderScorePos ); + rInf.SetPaintOfst( GetLeftMargin() ); + + // We look for the portion with the under-flow position + SwLinePortion *pPor = m_pCurr->GetFirstPortion(); + if( pPor != pUnderflow ) + { + // pPrev will be the last portion before pUnderflow, + // which still has a real width. + // Exception: SoftHyphPortion must not be forgotten, of course! + // Although they don't have a width. + SwLinePortion *pTmpPrev = pPor; + while( pPor && pPor != pUnderflow ) + { + if( !pPor->IsKernPortion() && + ( pPor->Width() || pPor->IsSoftHyphPortion() ) ) + { + while( pTmpPrev != pPor ) + { + pTmpPrev->Move( rInf ); + rInf.SetLast( pTmpPrev ); + pTmpPrev = pTmpPrev->GetNextPortion(); + OSL_ENSURE( pTmpPrev, "Underflow: losing control!" ); + }; + } + pPor = pPor->GetNextPortion(); + } + pPor = pTmpPrev; + if( pPor && // Skip flys and initials when underflow. + ( pPor->IsFlyPortion() || pPor->IsDropPortion() || + pPor->IsFlyCntPortion() ) ) + { + pPor->Move( rInf ); + rInf.SetLast( pPor ); + rInf.SetStopUnderflow( true ); + pPor = pUnderflow; + } + } + + // What? The under-flow portion is not in the portion chain? + OSL_ENSURE( pPor, "SwTextFormatter::Underflow: overflow but underflow" ); + + // Snapshot + if ( pPor==rInf.GetLast() ) + { + // We end up here, if the portion triggering the under-flow + // spans over the whole line. E.g. if a word spans across + // multiple lines and flows into a fly in the second line. + rInf.SetFly( pFly ); + pPor->Truncate(); + return pPor; // Is that enough? + } + // End the snapshot + + // X + Width == 0 with SoftHyph > Line?! + if( !pPor || !(rInf.X() + pPor->Width()) ) + { + delete pFly; + return nullptr; + } + + // Preparing for Format() + // We need to chip off the chain behind pLast, because we Insert after the Format() + SeekAndChg( rInf ); + + // line width is adjusted, so that pPor does not fit to current + // line anymore + rInf.Width( rInf.X() + (pPor->Width() ? pPor->Width() - 1 : 0) ); + rInf.SetLen( pPor->GetLen() ); + rInf.SetFull( false ); + if( pFly ) + { + // We need to recalculate the FlyPortion due to the following reason: + // If the base line is lowered by a big font in the middle of the line, + // causing overlapping with a fly, the FlyPortion has a wrong size/fixed + // size. + rInf.SetFly( pFly ); + CalcFlyWidth( rInf ); + } + rInf.GetLast()->SetNextPortion(nullptr); + + // The SwLineLayout is an exception to this, which splits at the first + // portion change. + // Here only the other way around: + if( rInf.GetLast() == m_pCurr ) + { + if( pPor->InTextGrp() && !pPor->InExpGrp() ) + { + const PortionType nOldWhich = m_pCurr->GetWhichPor(); + *static_cast(m_pCurr) = *pPor; + m_pCurr->SetNextPortion( pPor->GetNextPortion() ); + m_pCurr->SetWhichPor( nOldWhich ); + pPor->SetNextPortion( nullptr ); + delete pPor; + pPor = m_pCurr; + } + } + + // Make sure that m_pFirstOfBorderMerge does not point to a portion which + // will be deleted by Truncate() below. + SwLinePortion* pNext = pPor->GetNextPortion(); + while (pNext) + { + if (ClearIfIsFirstOfBorderMerge(pNext)) + break; + pNext = pNext->GetNextPortion(); + } + pPor->Truncate(); + SwLinePortion *const pRest( rInf.GetRest() ); + if (pRest && pRest->InFieldGrp() && + static_cast(pRest)->IsNoLength()) + { + // HACK: decrement again, so we pick up the suffix in next line! + m_pByEndIter->PrevAttr(); + } + delete pRest; + rInf.SetRest(nullptr); + return pPor; +} + +void SwTextFormatter::InsertPortion( SwTextFormatInfo &rInf, + SwLinePortion *pPor ) +{ + SwLinePortion *pLast = nullptr; + // The new portion is inserted, but everything's different for + // LineLayout... + if( pPor == m_pCurr ) + { + if ( m_pCurr->GetNextPortion() ) + { + pLast = pPor; + pPor = m_pCurr->GetNextPortion(); + } + + // i#112181 - Prevent footnote anchor being wrapped to next line + // without preceding word + rInf.SetOtherThanFootnoteInside( rInf.IsOtherThanFootnoteInside() || !pPor->IsFootnotePortion() ); + } + else + { + pLast = rInf.GetLast(); + if( pLast->GetNextPortion() ) + { + while( pLast->GetNextPortion() ) + pLast = pLast->GetNextPortion(); + rInf.SetLast( pLast ); + } + pLast->Insert( pPor ); + + rInf.SetOtherThanFootnoteInside( rInf.IsOtherThanFootnoteInside() || !pPor->IsFootnotePortion() ); + + // Adjust maxima + if( m_pCurr->Height() < pPor->Height() ) + m_pCurr->Height( pPor->Height(), pPor->IsTextPortion() ); + if( m_pCurr->GetAscent() < pPor->GetAscent() ) + m_pCurr->SetAscent( pPor->GetAscent() ); + if( m_pCurr->GetHangingBaseline() < pPor->GetHangingBaseline() ) + m_pCurr->SetHangingBaseline( pPor->GetHangingBaseline() ); + + if (GetTextFrame()->GetDoc().getIDocumentSettingAccess().get(DocumentSettingId::MS_WORD_COMP_MIN_LINE_HEIGHT_BY_FLY)) + { + // For DOCX with compat=14 the only shape in line defines height of the line in spite of used font + if (pLast->IsFlyCntPortion() && pPor->IsTextPortion() && pPor->GetLen() == TextFrameIndex(0)) + { + m_pCurr->SetAscent(pLast->GetAscent()); + m_pCurr->Height(pLast->Height()); + } + } + } + + // Sometimes chains are constructed (e.g. by hyphenate) + rInf.SetLast( pPor ); + while( pPor ) + { + if (!pPor->IsDropPortion()) + MergeCharacterBorder(*pPor, pLast, rInf); + + pPor->Move( rInf ); + rInf.SetLast( pPor ); + pLast = pPor; + pPor = pPor->GetNextPortion(); + } +} + +void SwTextFormatter::BuildPortions( SwTextFormatInfo &rInf ) +{ + OSL_ENSURE( rInf.GetText().getLength() < COMPLETE_STRING, + "SwTextFormatter::BuildPortions: bad text length in info" ); + + rInf.ChkNoHyph( CntEndHyph(), CntMidHyph() ); + + // First NewTextPortion() decides whether pCurr ends up in pPor. + // We need to make sure that the font is being set in any case. + // This is done automatically in CalcAscent. + rInf.SetLast( m_pCurr ); + rInf.ForcedLeftMargin( 0 ); + + OSL_ENSURE( m_pCurr->FindLastPortion() == m_pCurr, "pLast supposed to equal pCurr" ); + + if( !m_pCurr->GetAscent() && !m_pCurr->Height() ) + CalcAscent( rInf, m_pCurr ); + + SeekAndChg( rInf ); + + // Width() is shortened in CalcFlyWidth if we have a FlyPortion + OSL_ENSURE( !rInf.X() || m_pMulti, "SwTextFormatter::BuildPortion X=0?" ); + CalcFlyWidth( rInf ); + SwFlyPortion *pFly = rInf.GetFly(); + if( pFly ) + { + if ( 0 < pFly->GetFix() ) + ClearFly( rInf ); + else + rInf.SetFull(true); + } + + ::std::optional oMovedFlyIndex; + if (SwTextFrame const*const pFollow = GetTextFrame()->GetFollow()) + { + // flys are always on master! + if (GetTextFrame()->GetDrawObjs() && pFollow->GetUpper() != GetTextFrame()->GetUpper()) + { + for (SwAnchoredObject const*const pAnchoredObj : *GetTextFrame()->GetDrawObjs()) + { + // tdf#146500 try to stop where a fly is anchored in the follow + // that has recently been moved (presumably by splitting this + // frame); similar to check in SwFlowFrame::MoveBwd() + if (pAnchoredObj->RestartLayoutProcess() + && !pAnchoredObj->IsTmpConsiderWrapInfluence()) + { + SwFormatAnchor const& rAnchor(pAnchoredObj->GetFrameFormat().GetAnchor()); + assert(rAnchor.GetAnchorId() == RndStdIds::FLY_AT_CHAR || rAnchor.GetAnchorId() == RndStdIds::FLY_AT_PARA); + TextFrameIndex const nAnchor(GetTextFrame()->MapModelToViewPos(*rAnchor.GetContentAnchor())); + if (pFollow->GetOffset() <= nAnchor + && (pFollow->GetFollow() == nullptr + || nAnchor < pFollow->GetFollow()->GetOffset())) + { + if (!oMovedFlyIndex || nAnchor < *oMovedFlyIndex) + { + oMovedFlyIndex.emplace(nAnchor); + } + } + } + } + } + } + + SwLinePortion *pPor = NewPortion(rInf, oMovedFlyIndex); + + // Asian grid stuff + SwTextGridItem const*const pGrid(GetGridItem(m_pFrame->FindPageFrame())); + const bool bHasGrid = pGrid && rInf.SnapToGrid() && + GRID_LINES_CHARS == pGrid->GetGridType(); + + + const SwDoc & rDoc = rInf.GetTextFrame()->GetDoc(); + const sal_uInt16 nGridWidth = bHasGrid ? GetGridWidth(*pGrid, rDoc) : 0; + + // used for grid mode only: + // the pointer is stored, because after formatting of non-asian text, + // the width of the kerning portion has to be adjusted + // Inserting a SwKernPortion before a SwTabPortion isn't necessary + // and will break the SwTabPortion. + SwKernPortion* pGridKernPortion = nullptr; + + bool bFull = false; + SwTwips nUnderLineStart = 0; + rInf.Y( Y() ); + + while( pPor && !rInf.IsStop() ) + { + OSL_ENSURE(rInf.GetLen() < TextFrameIndex(COMPLETE_STRING) && + rInf.GetIdx() <= TextFrameIndex(rInf.GetText().getLength()), + "SwTextFormatter::BuildPortions: bad length in info" ); + + // We have to check the script for fields in order to set the + // correct nActual value for the font. + if( pPor->InFieldGrp() ) + static_cast(pPor)->CheckScript( rInf ); + + if( ! bHasGrid && rInf.HasScriptSpace() && + rInf.GetLast() && rInf.GetLast()->InTextGrp() && + rInf.GetLast()->Width() && !rInf.GetLast()->InNumberGrp() ) + { + SwFontScript nNxtActual = rInf.GetFont()->GetActual(); + SwFontScript nLstActual = nNxtActual; + sal_uInt16 nLstHeight = o3tl::narrowing(rInf.GetFont()->GetHeight()); + bool bAllowBehind = false; + const CharClass& rCC = GetAppCharClass(); + + // are there any punctuation characters on both sides + // of the kerning portion? + if ( pPor->InFieldGrp() ) + { + OUString aAltText; + if ( static_cast(pPor)->GetExpText( rInf, aAltText ) && + !aAltText.isEmpty() ) + { + bAllowBehind = rCC.isLetterNumeric( aAltText, 0 ); + + const SwFont* pTmpFnt = static_cast(pPor)->GetFont(); + if ( pTmpFnt ) + nNxtActual = pTmpFnt->GetActual(); + } + } + else + { + const OUString& rText = rInf.GetText(); + sal_Int32 nIdx = sal_Int32(rInf.GetIdx()); + bAllowBehind = nIdx < rText.getLength() && rCC.isLetterNumeric(rText, nIdx); + } + + const SwLinePortion* pLast = rInf.GetLast(); + if ( bAllowBehind && pLast ) + { + bool bAllowBefore = false; + + if ( pLast->InFieldGrp() ) + { + OUString aAltText; + if ( static_cast(pLast)->GetExpText( rInf, aAltText ) && + !aAltText.isEmpty() ) + { + bAllowBefore = rCC.isLetterNumeric( aAltText, aAltText.getLength() - 1 ); + + const SwFont* pTmpFnt = static_cast(pLast)->GetFont(); + if ( pTmpFnt ) + { + nLstActual = pTmpFnt->GetActual(); + nLstHeight = o3tl::narrowing(pTmpFnt->GetHeight()); + } + } + } + else if ( rInf.GetIdx() ) + { + bAllowBefore = rCC.isLetterNumeric(rInf.GetText(), sal_Int32(rInf.GetIdx()) - 1); + // Note: ScriptType returns values in [1,4] + if ( bAllowBefore ) + nLstActual = SwFontScript(m_pScriptInfo->ScriptType(rInf.GetIdx() - TextFrameIndex(1)) - 1); + } + + nLstHeight /= 5; + // does the kerning portion still fit into the line? + if( bAllowBefore && ( nLstActual != nNxtActual ) && + // tdf#89288 we want to insert space between CJK and non-CJK text only. + ( nLstActual == SwFontScript::CJK || nNxtActual == SwFontScript::CJK ) && + nLstHeight && rInf.X() + nLstHeight <= rInf.Width() && + ! pPor->InTabGrp() ) + { + SwKernPortion* pKrn = + new SwKernPortion( *rInf.GetLast(), nLstHeight, + pLast->InFieldGrp() && pPor->InFieldGrp() ); + + // ofz#58550 Direct-leak, pKrn adds itself as the NextPortion + // of rInf.GetLast(), but may use CopyLinePortion to add a copy + // of itself, which will then be left dangling with the following + // SetNextPortion(nullptr) + SwLinePortion *pNext = rInf.GetLast()->GetNextPortion(); + if (pNext != pKrn) + delete pNext; + + rInf.GetLast()->SetNextPortion( nullptr ); + InsertPortion( rInf, pKrn ); + } + } + } + else if ( bHasGrid && ! pGridKernPortion && ! m_pMulti && ! pPor->InTabGrp() ) + { + // insert a grid kerning portion + pGridKernPortion = pPor->IsKernPortion() ? + static_cast(pPor) : + new SwKernPortion( *m_pCurr ); + + // if we have a new GridKernPortion, we initially calculate + // its size so that its ends on the grid + const SwPageFrame* pPageFrame = m_pFrame->FindPageFrame(); + const SwLayoutFrame* pBody = pPageFrame->FindBodyCont(); + SwRectFnSet aRectFnSet(pPageFrame); + + const tools::Long nGridOrigin = pBody ? + aRectFnSet.GetPrtLeft(*pBody) : + aRectFnSet.GetPrtLeft(*pPageFrame); + + SwTwips nStartX = rInf.X() + GetLeftMargin(); + if ( aRectFnSet.IsVert() ) + { + Point aPoint( nStartX, 0 ); + m_pFrame->SwitchHorizontalToVertical( aPoint ); + nStartX = aPoint.Y(); + } + + const SwTwips nOfst = nStartX - nGridOrigin; + if ( nOfst ) + { + const sal_uLong i = ( nOfst > 0 ) ? + ( ( nOfst - 1 ) / nGridWidth + 1 ) : + 0; + const SwTwips nKernWidth = i * nGridWidth - nOfst; + const SwTwips nRestWidth = rInf.Width() - rInf.X(); + + if ( nKernWidth <= nRestWidth ) + pGridKernPortion->Width( nKernWidth ); + } + + if ( pGridKernPortion != pPor ) + InsertPortion( rInf, pGridKernPortion ); + } + + if( pPor->IsDropPortion() ) + MergeCharacterBorder(*static_cast(pPor)); + + // the multi-portion has its own format function + if( pPor->IsMultiPortion() && ( !m_pMulti || m_pMulti->IsBidi() ) ) + bFull = BuildMultiPortion( rInf, *static_cast(pPor) ); + else + bFull = pPor->Format( rInf ); + + if( rInf.IsRuby() && !rInf.GetRest() ) + bFull = true; + + // if we are underlined, we store the beginning of this underlined + // segment for repaint optimization + if ( LINESTYLE_NONE != m_pFont->GetUnderline() && ! nUnderLineStart ) + nUnderLineStart = GetLeftMargin() + rInf.X(); + + if ( pPor->IsFlyPortion() ) + m_pCurr->SetFly( true ); + // some special cases, where we have to take care for the repaint + // offset: + // 1. Underlined portions due to special underline feature + // 2. Right Tab + // 3. BidiPortions + // 4. other Multiportions + // 5. DropCaps + // 6. Grid Mode + else if ( ( ! rInf.GetPaintOfst() || nUnderLineStart < rInf.GetPaintOfst() ) && + // 1. Underlined portions + nUnderLineStart && + // reformat is at end of an underlined portion and next portion + // is not underlined + ( ( rInf.GetReformatStart() == rInf.GetIdx() && + LINESTYLE_NONE == m_pFont->GetUnderline() + ) || + // reformat is inside portion and portion is underlined + ( rInf.GetReformatStart() >= rInf.GetIdx() && + rInf.GetReformatStart() <= rInf.GetIdx() + pPor->GetLen() && + LINESTYLE_NONE != m_pFont->GetUnderline() ) ) ) + rInf.SetPaintOfst( nUnderLineStart ); + else if ( ! rInf.GetPaintOfst() && + // 2. Right Tab + ( ( pPor->InTabGrp() && !pPor->IsTabLeftPortion() ) || + // 3. BidiPortions + ( pPor->IsMultiPortion() && static_cast(pPor)->IsBidi() ) || + // 4. Multi Portion and 5. Drop Caps + ( ( pPor->IsDropPortion() || pPor->IsMultiPortion() ) && + rInf.GetReformatStart() >= rInf.GetIdx() && + rInf.GetReformatStart() <= rInf.GetIdx() + pPor->GetLen() ) + // 6. Grid Mode + || ( bHasGrid && SwFontScript::CJK != m_pFont->GetActual() ) + ) + ) + // we store the beginning of the critical portion as our + // paint offset + rInf.SetPaintOfst( GetLeftMargin() + rInf.X() ); + + // under one of these conditions we are allowed to delete the + // start of the underline portion + if ( IsUnderlineBreak( *pPor, *m_pFont ) ) + nUnderLineStart = 0; + + if( pPor->IsFlyCntPortion() || ( pPor->IsMultiPortion() && + static_cast(pPor)->HasFlyInContent() ) ) + SetFlyInCntBase(); + // bUnderflow needs to be reset or we wrap again at the next softhyphen + if ( !bFull ) + { + rInf.ClrUnderflow(); + if( ! bHasGrid && rInf.HasScriptSpace() && pPor->InTextGrp() && + pPor->GetLen() && !pPor->InFieldGrp() ) + { + // The distance between two different scripts is set + // to 20% of the fontheight. + TextFrameIndex const nTmp = rInf.GetIdx() + pPor->GetLen(); + if (nTmp == m_pScriptInfo->NextScriptChg(nTmp - TextFrameIndex(1)) && + nTmp != TextFrameIndex(rInf.GetText().getLength()) && + (m_pScriptInfo->ScriptType(nTmp - TextFrameIndex(1)) == css::i18n::ScriptType::ASIAN || + m_pScriptInfo->ScriptType(nTmp) == css::i18n::ScriptType::ASIAN) ) + { + const SwTwips nDist = rInf.GetFont()->GetHeight()/5; + + if( nDist ) + { + // we do not want a kerning portion if any end + // would be a punctuation character + const CharClass& rCC = GetAppCharClass(); + if (rCC.isLetterNumeric(rInf.GetText(), sal_Int32(nTmp) - 1) + && rCC.isLetterNumeric(rInf.GetText(), sal_Int32(nTmp))) + { + // does the kerning portion still fit into the line? + if ( rInf.X() + pPor->Width() + nDist <= rInf.Width() ) + new SwKernPortion( *pPor, nDist ); + else + bFull = true; + } + } + } + } + } + + if ( bHasGrid && pPor != pGridKernPortion && ! m_pMulti && ! pPor->InTabGrp() ) + { + TextFrameIndex const nTmp = rInf.GetIdx() + pPor->GetLen(); + const SwTwips nRestWidth = rInf.Width() - rInf.X() - pPor->Width(); + + const SwFontScript nCurrScript = m_pFont->GetActual(); // pScriptInfo->ScriptType( rInf.GetIdx() ); + const SwFontScript nNextScript = + nTmp >= TextFrameIndex(rInf.GetText().getLength()) + ? SwFontScript::CJK + : m_pScriptInfo->WhichFont(nTmp); + + // snap non-asian text to grid if next portion is ASIAN or + // there are no more portions in this line + // be careful when handling an underflow event: the gridkernportion + // could have been deleted + if ( nRestWidth > 0 && SwFontScript::CJK != nCurrScript && + ! rInf.IsUnderflow() && ( bFull || SwFontScript::CJK == nNextScript ) ) + { + OSL_ENSURE( pGridKernPortion, "No GridKernPortion available" ); + + // calculate size + SwLinePortion* pTmpPor = pGridKernPortion->GetNextPortion(); + sal_uInt16 nSumWidth = pPor->Width(); + while ( pTmpPor ) + { + nSumWidth = nSumWidth + pTmpPor->Width(); + pTmpPor = pTmpPor->GetNextPortion(); + } + + const SwTwips i = nSumWidth ? + ( nSumWidth - 1 ) / nGridWidth + 1 : + 0; + const SwTwips nTmpWidth = i * nGridWidth; + const SwTwips nKernWidth = std::min(nTmpWidth - nSumWidth, nRestWidth); + const SwTwips nKernWidth_1 = pGrid->IsSnapToChars() ? + nKernWidth / 2 : 0; + + OSL_ENSURE( nKernWidth <= nRestWidth, + "Not enough space left for adjusting non-asian text in grid mode" ); + if (nKernWidth_1) + { + pGridKernPortion->Width( pGridKernPortion->Width() + nKernWidth_1 ); + rInf.X( rInf.X() + nKernWidth_1 ); + } + + if ( ! bFull && nKernWidth - nKernWidth_1 > 0 ) + new SwKernPortion( *pPor, static_cast(nKernWidth - nKernWidth_1), + false, true ); + + pGridKernPortion = nullptr; + } + else if ( pPor->IsMultiPortion() || pPor->InFixMargGrp() || + pPor->IsFlyCntPortion() || pPor->InNumberGrp() || + pPor->InFieldGrp() || nCurrScript != nNextScript ) + // next portion should snap to grid + pGridKernPortion = nullptr; + } + + rInf.SetFull( bFull ); + + // Restportions from fields with multiple lines don't yet have the right ascent + if ( !pPor->GetLen() && !pPor->IsFlyPortion() + && !pPor->IsGrfNumPortion() && ! pPor->InNumberGrp() + && !pPor->IsMultiPortion() ) + CalcAscent( rInf, pPor ); + + InsertPortion( rInf, pPor ); + if (pPor->IsMultiPortion() && (!m_pMulti || m_pMulti->IsBidi())) + { + (void) rInf.CheckCurrentPosBookmark(); // bookmark was already created inside MultiPortion! + } + pPor = NewPortion(rInf, oMovedFlyIndex); + } + + if( !rInf.IsStop() ) + { + // The last right centered, decimal tab + SwTabPortion *pLastTab = rInf.GetLastTab(); + if( pLastTab ) + pLastTab->FormatEOL( rInf ); + else if( rInf.GetLast() && rInf.LastKernPortion() ) + rInf.GetLast()->FormatEOL( rInf ); + } + if( m_pCurr->GetNextPortion() && m_pCurr->GetNextPortion()->InNumberGrp() + && static_cast(m_pCurr->GetNextPortion())->IsHide() ) + rInf.SetNumDone( false ); + + // Delete fly in any case + ClearFly( rInf ); + + // Reinit the tab overflow flag after the line + rInf.SetTabOverflow( false ); +} + +void SwTextFormatter::CalcAdjustLine( SwLineLayout *pCurrent ) +{ + if( SvxAdjust::Left != GetAdjust() && !m_pMulti) + { + pCurrent->SetFormatAdj(true); + if( IsFlyInCntBase() ) + { + CalcAdjLine( pCurrent ); + // For e.g. centered fly we need to switch the RefPoint + // That's why bAlways = true + UpdatePos( pCurrent, GetTopLeft(), GetStart(), true ); + } + } +} + +void SwTextFormatter::CalcAscent( SwTextFormatInfo &rInf, SwLinePortion *pPor ) +{ + bool bCalc = false; + if ( pPor->InFieldGrp() && static_cast(pPor)->GetFont() ) + { + // Numbering + InterNetFields can keep an own font, then their size is + // independent from hard attribute values + SwFont* pFieldFnt = static_cast(pPor)->m_pFont.get(); + SwFontSave aSave( rInf, pFieldFnt ); + pPor->Height( rInf.GetTextHeight() ); + pPor->SetAscent( rInf.GetAscent() ); + bCalc = true; + } + // i#89179 + // tab portion representing the list tab of a list label gets the + // same height and ascent as the corresponding number portion + else if ( pPor->InTabGrp() && pPor->GetLen() == TextFrameIndex(0) && + rInf.GetLast() && rInf.GetLast()->InNumberGrp() && + static_cast(rInf.GetLast())->HasFont() ) + { + const SwLinePortion* pLast = rInf.GetLast(); + pPor->Height( pLast->Height() ); + pPor->SetAscent( pLast->GetAscent() ); + } + else if (pPor->GetWhichPor() == PortionType::Bookmark + && rInf.GetIdx() == TextFrameIndex(rInf.GetText().getLength())) + { + // bookmark at end of paragraph: *don't* advance iterator, use the + // current font instead; it's possible that there's a font size on the + // paragraph and it's overridden on the last line of the paragraph and + // we don't want to apply it via SwBookmarkPortion and grow the line + // height (example: n758883.docx) + SwLinePortion const*const pLast = rInf.GetLast(); + assert(pLast); + pPor->Height( pLast->Height(), false ); + pPor->SetAscent( pLast->GetAscent() ); + } + else + { + const SwLinePortion *pLast = rInf.GetLast(); + bool bChg = false; + + // In empty lines the attributes are switched on via SeekStart + const bool bFirstPor = rInf.GetLineStart() == rInf.GetIdx(); + if ( pPor->IsQuoVadisPortion() ) + bChg = SeekStartAndChg( rInf, true ); + else + { + if( bFirstPor ) + { + if( !rInf.GetText().isEmpty() ) + { + if ( pPor->GetLen() || !rInf.GetIdx() + || ( m_pCurr != pLast && !pLast->IsFlyPortion() ) + || !m_pCurr->IsRest() ) // instead of !rInf.GetRest() + bChg = SeekAndChg( rInf ); + else + bChg = SeekAndChgBefore( rInf ); + } + else if ( m_pMulti ) + // do not open attributes starting at 0 in empty multi + // portions (rotated numbering followed by a footnote + // can cause trouble, because the footnote attribute + // starts at 0, but if we open it, the attribute handler + // cannot handle it. + bChg = false; + else + bChg = SeekStartAndChg( rInf ); + } + else + bChg = SeekAndChg( rInf ); + } + if( bChg || bFirstPor || !pPor->GetAscent() + || !rInf.GetLast()->InTextGrp() ) + { + pPor->SetHangingBaseline( rInf.GetHangingBaseline() ); + pPor->SetAscent( rInf.GetAscent() ); + pPor->Height( rInf.GetTextHeight() ); + bCalc = true; + } + else + { + pPor->Height( pLast->Height() ); + pPor->SetAscent( pLast->GetAscent() ); + } + } + + if( pPor->InTextGrp() && bCalc ) + { + pPor->SetAscent(pPor->GetAscent() + + rInf.GetFont()->GetTopBorderSpace()); + pPor->Height(pPor->Height() + + rInf.GetFont()->GetTopBorderSpace() + + rInf.GetFont()->GetBottomBorderSpace() ); + } +} + +namespace { + +class SwMetaPortion : public SwTextPortion +{ + Color m_aShadowColor; +public: + SwMetaPortion() { SetWhichPor( PortionType::Meta ); } + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + void SetShadowColor(const Color& rCol ) { m_aShadowColor = rCol; } +}; + +/// A content control portion is a text portion that is inside RES_TXTATR_CONTENTCONTROL. +class SwContentControlPortion : public SwTextPortion +{ + SwTextContentControl* m_pTextContentControl; +public: + SwContentControlPortion(SwTextContentControl* pTextContentControl); + virtual void Paint(const SwTextPaintInfo& rInf) const override; + + /// Emits a PDF form widget for this portion on success, does nothing on failure. + bool DescribePDFControl(const SwTextPaintInfo& rInf) const; +}; +} + +void SwMetaPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + if ( Width() ) + { + rInf.DrawViewOpt( *this, PortionType::Meta, + // custom shading (RDF metadata) + COL_BLACK == m_aShadowColor + ? nullptr + : &m_aShadowColor ); + + SwTextPortion::Paint( rInf ); + } +} + +SwContentControlPortion::SwContentControlPortion(SwTextContentControl* pTextContentControl) + : m_pTextContentControl(pTextContentControl) +{ + SetWhichPor(PortionType::ContentControl); +} + +bool SwContentControlPortion::DescribePDFControl(const SwTextPaintInfo& rInf) const +{ + auto pPDFExtOutDevData = dynamic_cast(rInf.GetOut()->GetExtOutDevData()); + if (!pPDFExtOutDevData) + { + return false; + } + + if (!pPDFExtOutDevData->GetIsExportFormFields()) + { + return false; + } + + if (!m_pTextContentControl) + { + return false; + } + + const SwFormatContentControl& rFormatContentControl = m_pTextContentControl->GetContentControl(); + const std::shared_ptr& pContentControl = rFormatContentControl.GetContentControl(); + if (!pContentControl) + { + return false; + } + + SwTextNode* pTextNode = pContentControl->GetTextNode(); + SwDoc& rDoc = pTextNode->GetDoc(); + if (rDoc.IsInHeaderFooter(*pTextNode)) + { + // Form control in header/footer makes no sense, would allow multiple values for the same + // control. + return false; + } + + // Check if this is the first content control portion of this content control. + sal_Int32 nStart = m_pTextContentControl->GetStart(); + sal_Int32 nEnd = *m_pTextContentControl->GetEnd(); + TextFrameIndex nViewStart = rInf.GetTextFrame()->MapModelToView(pTextNode, nStart); + TextFrameIndex nViewEnd = rInf.GetTextFrame()->MapModelToView(pTextNode, nEnd); + // The content control portion starts 1 char after the starting dummy character. + if (rInf.GetIdx() != nViewStart + TextFrameIndex(1)) + { + // Ignore: don't process and also don't emit plain text fallback. + return true; + } + + const SwPaM aPam(*pTextNode, nEnd, *pTextNode, nStart); + static sal_Unicode const aForbidden[] = { + CH_TXTATR_BREAKWORD, + 0 + }; + const OUString aText = comphelper::string::removeAny(aPam.GetText(), aForbidden); + + std::unique_ptr pDescriptor; + switch (pContentControl->GetType()) + { + case SwContentControlType::RICH_TEXT: + case SwContentControlType::PLAIN_TEXT: + { + pDescriptor = std::make_unique(); + break; + } + case SwContentControlType::CHECKBOX: + { + pDescriptor = std::make_unique(); + auto pCheckBoxWidget = static_cast(pDescriptor.get()); + pCheckBoxWidget->Checked = pContentControl->GetChecked(); + pCheckBoxWidget->OnValue = pContentControl->GetCheckedState(); + pCheckBoxWidget->OffValue = pContentControl->GetUncheckedState(); + break; + } + case SwContentControlType::DROP_DOWN_LIST: + { + pDescriptor = std::make_unique(); + auto pListWidget = static_cast(pDescriptor.get()); + pListWidget->DropDown = true; + sal_Int32 nIndex = 0; + for (const auto& rItem : pContentControl->GetListItems()) + { + pListWidget->Entries.push_back(rItem.m_aDisplayText); + if (rItem.m_aDisplayText == aText) + pListWidget->SelectedEntries.push_back(nIndex); + ++nIndex; + } + break; + } + case SwContentControlType::COMBO_BOX: + { + pDescriptor = std::make_unique(); + auto pComboWidget = static_cast(pDescriptor.get()); + for (const auto& rItem : pContentControl->GetListItems()) + { + pComboWidget->Entries.push_back(rItem.m_aDisplayText); + } + break; + } + case SwContentControlType::DATE: + { + pDescriptor = std::make_unique(); + auto pEditWidget = static_cast(pDescriptor.get()); + pEditWidget->Format = vcl::PDFWriter::Date; + // GetDateFormat() uses a syntax that works with SvNumberFormatter::PutEntry(), PDF's + // AFDate_FormatEx() uses a similar syntax, but uses lowercase characters in case of + // "Y", "M" and "D" at least. + pEditWidget->DateFormat = pContentControl->GetDateFormat().toAsciiLowerCase(); + break; + } + default: + break; + } + + if (!pDescriptor) + { + return false; + } + + const SwFont* pFont = rInf.GetFont(); + if (pFont) + { + pDescriptor->TextFont = pFont->GetActualFont(); + } + + // Description for accessibility purposes. + if (!pContentControl->GetAlias().isEmpty()) + { + pDescriptor->Description = pContentControl->GetAlias(); + } + + // Map the text of the content control to the descriptor's text. + pDescriptor->Text = aText; + + // Calculate the bounding rectangle of this content control, which can be one or more layout + // portions in one or more lines. + SwRect aLocation; + auto pTextFrame = const_cast(rInf.GetTextFrame()); + SwTextSizeInfo aInf(pTextFrame); + SwTextCursor aLine(pTextFrame, &aInf); + SwRect aStartRect, aEndRect; + aLine.GetCharRect(&aStartRect, nViewStart); + aLine.GetCharRect(&aEndRect, nViewEnd); + + // Handling RTL text direction + if(rInf.GetTextFrame()->IsRightToLeft()) + { + rInf.GetTextFrame()->SwitchLTRtoRTL( aStartRect ); + rInf.GetTextFrame()->SwitchLTRtoRTL( aEndRect ); + } + // TODO: handle rInf.GetTextFrame()->IsVertical() + + aLocation = aStartRect; + aLocation.Union(aEndRect); + pDescriptor->Location = aLocation.SVRect(); + + pPDFExtOutDevData->WrapBeginStructureElement(vcl::PDFWriter::Form); + pPDFExtOutDevData->CreateControl(*pDescriptor); + pPDFExtOutDevData->EndStructureElement(); + + return true; +} + +void SwContentControlPortion::Paint(const SwTextPaintInfo& rInf) const +{ + if (Width()) + { + rInf.DrawViewOpt(*this, PortionType::ContentControl); + + if (DescribePDFControl(rInf)) + { + return; + } + + SwTextPortion::Paint(rInf); + } +} + +namespace sw::mark { + OUString ExpandFieldmark(IFieldmark* pBM) + { + if (pBM->GetFieldname() == ODF_FORMCHECKBOX) + { + ::sw::mark::ICheckboxFieldmark const*const pCheckboxFm( + dynamic_cast(pBM)); + assert(pCheckboxFm); + return pCheckboxFm->IsChecked() + ? u"\u2612"_ustr + : u"\u2610"_ustr; + } + assert(pBM->GetFieldname() == ODF_FORMDROPDOWN); + const IFieldmark::parameter_map_t* const pParameters = pBM->GetParameters(); + sal_Int32 nCurrentIdx = 0; + const IFieldmark::parameter_map_t::const_iterator pResult = pParameters->find(ODF_FORMDROPDOWN_RESULT); + if(pResult != pParameters->end()) + pResult->second >>= nCurrentIdx; + + const IFieldmark::parameter_map_t::const_iterator pListEntries = pParameters->find(ODF_FORMDROPDOWN_LISTENTRY); + if (pListEntries != pParameters->end()) + { + uno::Sequence< OUString > vListEntries; + pListEntries->second >>= vListEntries; + if (nCurrentIdx < vListEntries.getLength()) + return vListEntries[nCurrentIdx]; + } + + static constexpr OUStringLiteral vEnSpaces = u"\u2002\u2002\u2002\u2002\u2002"; + return vEnSpaces; + } +} + +SwTextPortion *SwTextFormatter::WhichTextPor( SwTextFormatInfo &rInf ) const +{ + SwTextPortion *pPor = nullptr; + if( GetFnt()->IsTox() ) + { + pPor = new SwToxPortion; + } + else if ( GetFnt()->IsInputField() ) + { + if (rInf.GetOpt().IsFieldName()) + { + OUString aFieldName = SwFieldType::GetTypeStr(SwFieldTypesEnum::Input); + // assume this is only the *first* portion and follows will be created elsewhere => input field must start at Idx + assert(rInf.GetText()[sal_Int32(rInf.GetIdx())] == CH_TXT_ATR_INPUTFIELDSTART); + TextFrameIndex nFieldLen(-1); + for (TextFrameIndex i = rInf.GetIdx() + TextFrameIndex(1); ; ++i) + { + assert(rInf.GetText()[sal_Int32(i)] != CH_TXT_ATR_INPUTFIELDSTART); // can't nest + if (rInf.GetText()[sal_Int32(i)] == CH_TXT_ATR_INPUTFIELDEND) + { + nFieldLen = i + TextFrameIndex(1) - rInf.GetIdx(); + break; + } + } + assert(2 <= sal_Int32(nFieldLen)); + pPor = new SwFieldPortion(aFieldName, nullptr, nFieldLen); + } + else + { + pPor = new SwTextInputFieldPortion(); + } + } + else + { + if( GetFnt()->IsRef() ) + pPor = new SwRefPortion; + else if (GetFnt()->IsMeta()) + { + auto pMetaPor = new SwMetaPortion; + + // set custom LO_EXT_SHADING color, if it exists + SwTextFrame const*const pFrame(rInf.GetTextFrame()); + SwPosition aPosition(pFrame->MapViewToModelPos(rInf.GetIdx())); + SwPaM aPam(aPosition); + uno::Reference const xRet( + SwUnoCursorHelper::GetNestedTextContent( + *aPam.GetPointNode().GetTextNode(), aPosition.GetContentIndex(), false) ); + if (xRet.is()) + { + const SwDoc & rDoc = rInf.GetTextFrame()->GetDoc(); + static uno::Reference< uno::XComponentContext > xContext( + ::comphelper::getProcessComponentContext()); + + static uno::Reference< rdf::XURI > xODF_SHADING( + rdf::URI::createKnown(xContext, rdf::URIs::LO_EXT_SHADING), uno::UNO_SET_THROW); + + uno::Reference xDocumentMetadataAccess( + rDoc.GetDocShell()->GetBaseModel(), uno::UNO_QUERY); + + const css::uno::Reference xSubject(xRet, uno::UNO_QUERY); + const uno::Reference& xRepository = + xDocumentMetadataAccess->getRDFRepository(); + const uno::Reference xEnum( + xRepository->getStatements(xSubject, xODF_SHADING, nullptr), uno::UNO_SET_THROW); + + while (xEnum->hasMoreElements()) + { + rdf::Statement stmt; + if (!(xEnum->nextElement() >>= stmt)) { + throw uno::RuntimeException(); + } + const uno::Reference xObject(stmt.Object, uno::UNO_QUERY); + if (!xObject.is()) continue; + if (xEnum->hasMoreElements()) { + SAL_INFO("sw.uno", "ignoring other odf:shading statements"); + } + Color rColor = Color::STRtoRGB(xObject->getValue()); + pMetaPor->SetShadowColor(rColor); + break; + } + } + pPor = pMetaPor; + } + else if (GetFnt()->IsContentControl()) + { + SwTextFrame const*const pFrame(rInf.GetTextFrame()); + SwPosition aPosition(pFrame->MapViewToModelPos(rInf.GetIdx())); + SwTextNode* pTextNode = aPosition.GetNode().GetTextNode(); + SwTextContentControl* pTextContentControl = nullptr; + if (pTextNode) + { + sal_Int32 nIndex = aPosition.GetContentIndex(); + if (SwTextAttr* pAttr = pTextNode->GetTextAttrAt(nIndex, RES_TXTATR_CONTENTCONTROL, ::sw::GetTextAttrMode::Parent)) + { + pTextContentControl = static_txtattr_cast(pAttr); + } + } + pPor = new SwContentControlPortion(pTextContentControl); + } + else + { + // Only at the End! + // If pCurr does not have a width, it can however already have content. + // E.g. for non-displayable characters + + auto const ch(rInf.GetChar(rInf.GetIdx())); + SwTextFrame const*const pFrame(rInf.GetTextFrame()); + SwPosition aPosition(pFrame->MapViewToModelPos(rInf.GetIdx())); + sw::mark::IFieldmark *pBM = pFrame->GetDoc().getIDocumentMarkAccess()->getInnerFieldmarkFor(aPosition); + if(pBM != nullptr && pBM->GetFieldname( ) == ODF_FORMDATE) + { + if (ch == CH_TXT_ATR_FIELDSTART) + pPor = new SwFieldFormDatePortion(pBM, true); + else if (ch == CH_TXT_ATR_FIELDSEP) + pPor = new SwFieldMarkPortion(); // it's added in DateFieldmark? + else if (ch == CH_TXT_ATR_FIELDEND) + pPor = new SwFieldFormDatePortion(pBM, false); + } + else if (ch == CH_TXT_ATR_FIELDSTART) + pPor = new SwFieldMarkPortion(); + else if (ch == CH_TXT_ATR_FIELDSEP) + pPor = new SwFieldMarkPortion(); + else if (ch == CH_TXT_ATR_FIELDEND) + pPor = new SwFieldMarkPortion(); + else if (ch == CH_TXT_ATR_FORMELEMENT) + { + OSL_ENSURE(pBM != nullptr, "Where is my form field bookmark???"); + if (pBM != nullptr) + { + if (pBM->GetFieldname( ) == ODF_FORMCHECKBOX) + { + pPor = new SwFieldFormCheckboxPortion(); + } + else if (pBM->GetFieldname( ) == ODF_FORMDROPDOWN) + { + pPor = new SwFieldFormDropDownPortion(pBM, sw::mark::ExpandFieldmark(pBM)); + } + /* we need to check for ODF_FORMTEXT for scenario having FormFields inside FORMTEXT. + * Otherwise file will crash on open. + */ + else if (pBM->GetFieldname( ) == ODF_FORMTEXT) + { + pPor = new SwFieldMarkPortion(); + } + } + } + if( !pPor ) + { + if( !rInf.X() && !m_pCurr->GetNextPortion() && !m_pCurr->GetLen() ) + pPor = m_pCurr; + else + pPor = new SwTextPortion; + } + } + } + return pPor; +} + +// We calculate the length, the following portion limits are defined: +// 1) Tabs +// 2) Linebreaks +// 3) CH_TXTATR_BREAKWORD / CH_TXTATR_INWORD +// 4) next attribute change + +SwTextPortion *SwTextFormatter::NewTextPortion( SwTextFormatInfo &rInf ) +{ + // If we're at the line's beginning, we take pCurr + // If pCurr is not derived from SwTextPortion, we need to duplicate + Seek( rInf.GetIdx() ); + SwTextPortion *pPor = WhichTextPor( rInf ); + + // until next attribute change: + const TextFrameIndex nNextAttr = GetNextAttr(); + TextFrameIndex nNextChg = std::min(nNextAttr, TextFrameIndex(rInf.GetText().getLength())); + + // end of script type: + const TextFrameIndex nNextScript = m_pScriptInfo->NextScriptChg(rInf.GetIdx()); + nNextChg = std::min( nNextChg, nNextScript ); + + // end of direction: + const TextFrameIndex nNextDir = m_pScriptInfo->NextDirChg(rInf.GetIdx()); + nNextChg = std::min( nNextChg, nNextDir ); + + // hidden change (potentially via bookmark): + const TextFrameIndex nNextHidden = m_pScriptInfo->NextHiddenChg(rInf.GetIdx()); + nNextChg = std::min( nNextChg, nNextHidden ); + + // bookmarks + const TextFrameIndex nNextBookmark = m_pScriptInfo->NextBookmark(rInf.GetIdx()); + nNextChg = std::min(nNextChg, nNextBookmark); + + // Turbo boost: + // We assume that font characters are not larger than twice + // as wide as height. + // Very crazy: we need to take the ascent into account. + + // Mind the trap! GetSize() contains the wished-for height, the real height + // is only known in CalcAscent! + + // The ratio is even crazier: a blank in Times New Roman has an ascent of + // 182, a height of 200 and a width of 53! + // It follows that a line with a lot of blanks is processed incorrectly. + // Therefore we increase from factor 2 to 8 (due to negative kerning). + + pPor->SetLen(TextFrameIndex(1)); + CalcAscent( rInf, pPor ); + + const SwFont* pTmpFnt = rInf.GetFont(); + sal_Int32 nExpect = std::min( sal_Int32( pTmpFnt->GetHeight() ), + sal_Int32( pPor->GetAscent() ) ) / 8; + if ( !nExpect ) + nExpect = 1; + nExpect = sal_Int32(rInf.GetIdx()) + (rInf.GetLineWidth() / nExpect); + if (TextFrameIndex(nExpect) > rInf.GetIdx() && nNextChg > TextFrameIndex(nExpect)) + nNextChg = TextFrameIndex(std::min(nExpect, rInf.GetText().getLength())); + + // we keep an invariant during method calls: + // there are no portion ending characters like hard spaces + // or tabs in [ nLeftScanIdx, nRightScanIdx ] + if ( m_nLeftScanIdx <= rInf.GetIdx() && rInf.GetIdx() <= m_nRightScanIdx ) + { + if ( nNextChg > m_nRightScanIdx ) + nNextChg = m_nRightScanIdx = + rInf.ScanPortionEnd( m_nRightScanIdx, nNextChg ); + } + else + { + m_nLeftScanIdx = rInf.GetIdx(); + nNextChg = m_nRightScanIdx = + rInf.ScanPortionEnd( rInf.GetIdx(), nNextChg ); + } + + pPor->SetLen( nNextChg - rInf.GetIdx() ); + rInf.SetLen( pPor->GetLen() ); + return pPor; +} + +// first portions have no length +SwLinePortion *SwTextFormatter::WhichFirstPortion(SwTextFormatInfo &rInf) +{ + SwLinePortion *pPor = nullptr; + + if( rInf.GetRest() ) + { + // Tabs and fields + if( '\0' != rInf.GetHookChar() ) + return nullptr; + + pPor = rInf.GetRest(); + if( pPor->IsErgoSumPortion() ) + rInf.SetErgoDone(true); + else + if( pPor->IsFootnoteNumPortion() ) + rInf.SetFootnoteDone(true); + else + if( pPor->InNumberGrp() ) + rInf.SetNumDone(true); + + rInf.SetRest(nullptr); + m_pCurr->SetRest( true ); + return pPor; + } + + // We can stand in the follow, it's crucial that + // pFrame->GetOffset() == 0! + if( rInf.GetIdx() ) + { + // We now too can elongate FootnotePortions and ErgoSumPortions + + // 1. The ErgoSumTexts + if( !rInf.IsErgoDone() ) + { + if( m_pFrame->IsInFootnote() && !m_pFrame->GetIndPrev() ) + pPor = NewErgoSumPortion( rInf ); + rInf.SetErgoDone( true ); + } + + // 2. Arrow portions + if( !pPor && !rInf.IsArrowDone() ) + { + if( m_pFrame->GetOffset() && !m_pFrame->IsFollow() && + rInf.GetIdx() == m_pFrame->GetOffset() ) + pPor = new SwArrowPortion( *m_pCurr ); + rInf.SetArrowDone( true ); + } + + // 3. Kerning portions at beginning of line in grid mode + if ( ! pPor && ! m_pCurr->GetNextPortion() ) + { + SwTextGridItem const*const pGrid( + GetGridItem(GetTextFrame()->FindPageFrame())); + if ( pGrid ) + pPor = new SwKernPortion( *m_pCurr ); + } + + // 4. The line rests (multiline fields) + if( !pPor ) + { + pPor = rInf.GetRest(); + // Only for pPor of course + if( pPor ) + { + m_pCurr->SetRest( true ); + rInf.SetRest(nullptr); + } + } + } + else + { + // 5. The foot note count + if( !rInf.IsFootnoteDone() ) + { + OSL_ENSURE( ( ! rInf.IsMulti() && ! m_pMulti ) || m_pMulti->HasRotation(), + "Rotated number portion trouble" ); + + const bool bFootnoteNum = m_pFrame->IsFootnoteNumFrame(); + rInf.GetParaPortion()->SetFootnoteNum( bFootnoteNum ); + if( bFootnoteNum ) + pPor = NewFootnoteNumPortion( rInf ); + rInf.SetFootnoteDone( true ); + } + + // 6. The ErgoSumTexts of course also exist in the TextMaster, + // it's crucial whether the SwFootnoteFrame is aFollow + if( !rInf.IsErgoDone() && !pPor && ! rInf.IsMulti() ) + { + if( m_pFrame->IsInFootnote() && !m_pFrame->GetIndPrev() ) + pPor = NewErgoSumPortion( rInf ); + rInf.SetErgoDone( true ); + } + + // 7. The numbering + if( !rInf.IsNumDone() && !pPor ) + { + OSL_ENSURE( ( ! rInf.IsMulti() && ! m_pMulti ) || m_pMulti->HasRotation(), + "Rotated number portion trouble" ); + + // If we're in the follow, then of course not + if (GetTextFrame()->GetTextNodeForParaProps()->GetNumRule()) + pPor = NewNumberPortion( rInf ); + rInf.SetNumDone( true ); + } + // 8. The DropCaps + if( !pPor && GetDropFormat() && ! rInf.IsMulti() ) + pPor = NewDropPortion( rInf ); + + // 9. Kerning portions at beginning of line in grid mode + if ( !pPor && !m_pCurr->GetNextPortion() ) + { + SwTextGridItem const*const pGrid( + GetGridItem(GetTextFrame()->FindPageFrame())); + if ( pGrid ) + pPor = new SwKernPortion( *m_pCurr ); + } + } + + // 10. Decimal tab portion at the beginning of each line in table cells + if ( !pPor && !m_pCurr->GetNextPortion() && + GetTextFrame()->IsInTab() && + GetTextFrame()->GetDoc().getIDocumentSettingAccess().get(DocumentSettingId::TAB_COMPAT)) + { + pPor = NewTabPortion( rInf, true ); + } + + // 11. suffix of meta-field + if (!pPor) + { + pPor = TryNewNoLengthPortion(rInf); + } + + // 12. bookmarks + // check this *last* so that BuildMultiPortion() can find it! + if (!pPor && rInf.CheckCurrentPosBookmark()) + { + const auto& bookmark = m_pScriptInfo->GetBookmarks(rInf.GetIdx()); + if (!bookmark.empty()) + { + // only for character width, maybe replaced with ] later + sal_Unicode mark = '['; + + pPor = new SwBookmarkPortion(mark, bookmark); + } + } + + return pPor; +} + +static bool lcl_OldFieldRest( const SwLineLayout* pCurr ) +{ + if( !pCurr->GetNext() ) + return false; + const SwLinePortion *pPor = pCurr->GetNext()->GetNextPortion(); + bool bRet = false; + while( pPor && !bRet ) + { + bRet = (pPor->InFieldGrp() && static_cast(pPor)->IsFollow()) || + (pPor->IsMultiPortion() && static_cast(pPor)->IsFollowField()); + if( !pPor->GetLen() ) + break; + pPor = pPor->GetNextPortion(); + } + return bRet; +} + +/* NewPortion sets rInf.nLen + * A SwTextPortion is limited by a tab, break, txtatr or attr change + * We can have three cases: + * 1) The line is full and the wrap was not emulated + * -> return 0; + * 2) The line is full and a wrap was emulated + * -> Reset width and return new FlyPortion + * 3) We need to construct a new portion + * -> CalcFlyWidth emulates the width and return portion, if needed + */ + +SwLinePortion *SwTextFormatter::NewPortion(SwTextFormatInfo &rInf, + ::std::optional const oMovedFlyIndex) +{ + if (oMovedFlyIndex && *oMovedFlyIndex <= rInf.GetIdx()) + { + SAL_WARN_IF(*oMovedFlyIndex != rInf.GetIdx(), "sw.core", "stopping too late, no portion break at fly anchor?"); + rInf.SetStop(true); + return nullptr; + } + + // Underflow takes precedence + rInf.SetStopUnderflow( false ); + if( rInf.GetUnderflow() ) + { + OSL_ENSURE( rInf.IsFull(), "SwTextFormatter::NewPortion: underflow but not full" ); + return Underflow( rInf ); + } + + // If the line is full, flys and Underflow portions could be waiting ... + if( rInf.IsFull() ) + { + // LineBreaks and Flys (bug05.sdw) + // IsDummy() + if( rInf.IsNewLine() && (!rInf.GetFly() || !m_pCurr->IsDummy()) ) + return nullptr; + + // When the text bumps into the Fly, or when the Fly comes first because + // it juts out over the left edge, GetFly() is returned. + // When IsFull() and no GetFly() is available, naturally zero is returned. + if( rInf.GetFly() ) + { + if( rInf.GetLast()->IsBreakPortion() ) + { + delete rInf.GetFly(); + rInf.SetFly( nullptr ); + } + + return rInf.GetFly(); + } + + // A nasty special case: A frame without wrap overlaps the Footnote area. + // We must declare the Footnote portion as rest of line, so that + // SwTextFrame::Format doesn't abort (the text mass already was formatted). + if( rInf.GetRest() ) + rInf.SetNewLine( true ); + else + { + // When the next line begins with a rest of a field, but now no + // rest remains, the line must definitely be formatted anew! + if( lcl_OldFieldRest( GetCurr() ) ) + rInf.SetNewLine( true ); + else + { + SwLinePortion *pFirst = WhichFirstPortion( rInf ); + if( pFirst ) + { + rInf.SetNewLine( true ); + if( pFirst->InNumberGrp() ) + rInf.SetNumDone( false) ; + delete pFirst; + } + } + } + + return nullptr; + } + + SwLinePortion *pPor = WhichFirstPortion( rInf ); + + // Check for Hidden Portion: + if ( !pPor ) + { + TextFrameIndex nEnd = rInf.GetIdx(); + if ( ::lcl_BuildHiddenPortion( rInf, nEnd ) ) + pPor = new SwHiddenTextPortion( nEnd - rInf.GetIdx() ); + } + + if( !pPor ) + { + if( ( !m_pMulti || m_pMulti->IsBidi() ) && + // i#42734 + // No multi portion if there is a hook character waiting: + ( !rInf.GetRest() || '\0' == rInf.GetHookChar() ) ) + { + // We open a multiportion part, if we enter a multi-line part + // of the paragraph. + TextFrameIndex nEnd = rInf.GetIdx(); + std::optional pCreate = rInf.GetMultiCreator( nEnd, m_pMulti ); + if( pCreate ) + { + SwMultiPortion* pTmp = nullptr; + + if ( SwMultiCreatorId::Bidi == pCreate->nId ) + pTmp = new SwBidiPortion( nEnd, pCreate->nLevel ); + else if ( SwMultiCreatorId::Ruby == pCreate->nId ) + { + pTmp = new SwRubyPortion( *pCreate, *rInf.GetFont(), + GetTextFrame()->GetDoc().getIDocumentSettingAccess(), + nEnd, TextFrameIndex(0), rInf ); + } + else if( SwMultiCreatorId::Rotate == pCreate->nId ) + { + pTmp = new SwRotatedPortion( *pCreate, nEnd, + GetTextFrame()->IsRightToLeft() ); + GetTextFrame()->SetHasRotatedPortions(true); + } + else + pTmp = new SwDoubleLinePortion( *pCreate, nEnd ); + + pCreate.reset(); + CalcFlyWidth( rInf ); + + return pTmp; + } + } + // Tabs and Fields + sal_Unicode cChar = rInf.GetHookChar(); + + if( cChar ) + { + /* We fetch cChar again to be sure that the tab is pending now and + * didn't move to the next line (as happens behind frames). + * However, when a FieldPortion is in the rest, we must naturally fetch + * the cChar from the field content, e.g. DecimalTabs and fields (22615) + */ + if( !rInf.GetRest() || !rInf.GetRest()->InFieldGrp() ) + cChar = rInf.GetChar( rInf.GetIdx() ); + rInf.ClearHookChar(); + } + else + { + if (rInf.GetIdx() >= TextFrameIndex(rInf.GetText().getLength())) + { + rInf.SetFull(true); + CalcFlyWidth( rInf ); + return pPor; + } + cChar = rInf.GetChar( rInf.GetIdx() ); + } + + switch( cChar ) + { + case CH_TAB: + pPor = NewTabPortion( rInf, false ); break; + + case CH_BREAK: + { + SwTextAttr* pHint = GetAttr(rInf.GetIdx()); + pPor = new SwBreakPortion(*rInf.GetLast(), pHint); + break; + } + + case CHAR_SOFTHYPHEN: // soft hyphen + pPor = new SwSoftHyphPortion; break; + + case CHAR_HARDBLANK: // no-break space + // Please check tdf#115067 if you want to edit the char + pPor = new SwBlankPortion( cChar ); break; + + case CHAR_HARDHYPHEN: // non-breaking hyphen + pPor = new SwBlankPortion( '-' ); break; + + case CHAR_ZWSP: // zero width space + case CHAR_WJ : // word joiner + pPor = new SwControlCharPortion( cChar ); break; + + case CH_TXTATR_BREAKWORD: + case CH_TXTATR_INWORD: + if( rInf.HasHint( rInf.GetIdx() ) ) + { + pPor = NewExtraPortion( rInf ); + break; + } + [[fallthrough]]; + default : + { + SwTabPortion* pLastTabPortion = rInf.GetLastTab(); + if ( pLastTabPortion && cChar == rInf.GetTabDecimal() ) + { + // Abandon dec. tab position if line is full + // We have a decimal tab portion in the line and the next character has to be + // aligned at the tab stop position. We store the width from the beginning of + // the tab stop portion up to the portion containing the decimal separator: + if (GetTextFrame()->GetDoc().getIDocumentSettingAccess().get(DocumentSettingId::TAB_COMPAT) /*rInf.GetVsh()->IsTabCompat();*/ && + PortionType::TabDecimal == pLastTabPortion->GetWhichPor() ) + { + OSL_ENSURE( rInf.X() >= pLastTabPortion->GetFix(), "Decimal tab stop position cannot be calculated" ); + const sal_uInt16 nWidthOfPortionsUpToDecimalPosition = o3tl::narrowing(rInf.X() - pLastTabPortion->GetFix() ); + static_cast(pLastTabPortion)->SetWidthOfPortionsUpToDecimalPosition( nWidthOfPortionsUpToDecimalPosition ); + rInf.SetTabDecimal( 0 ); + } + else + rInf.SetFull( rInf.GetLastTab()->Format( rInf ) ); + } + + if( rInf.GetRest() ) + { + if( rInf.IsFull() ) + { + rInf.SetNewLine(true); + return nullptr; + } + pPor = rInf.GetRest(); + rInf.SetRest(nullptr); + } + else + { + if( rInf.IsFull() ) + return nullptr; + pPor = NewTextPortion( rInf ); + } + break; + } + } + + // if a portion is created despite there being a pending RestPortion, + // then it is a field which has been split (e.g. because it contains a Tab) + if( pPor && rInf.GetRest() ) + pPor->SetLen(TextFrameIndex(0)); + + // robust: + if( !pPor || rInf.IsStop() ) + { + delete pPor; + return nullptr; + } + } + + assert(pPor && "can only reach here with pPor existing"); + + // Special portions containing numbers (footnote anchor, footnote number, + // numbering) can be contained in a rotated portion, if the user + // choose a rotated character attribute. + if (!m_pMulti) + { + if ( pPor->IsFootnotePortion() ) + { + const SwTextFootnote* pTextFootnote = static_cast(pPor)->GetTextFootnote(); + + if ( pTextFootnote ) + { + SwFormatFootnote& rFootnote = const_cast(pTextFootnote->GetFootnote()); + const SwDoc *const pDoc = &rInf.GetTextFrame()->GetDoc(); + const SwEndNoteInfo* pInfo; + if( rFootnote.IsEndNote() ) + pInfo = &pDoc->GetEndNoteInfo(); + else + pInfo = &pDoc->GetFootnoteInfo(); + const SwAttrSet& rSet = pInfo->GetAnchorCharFormat(const_cast(*pDoc))->GetAttrSet(); + + Degree10 nDir(0); + if( const SvxCharRotateItem* pItem = rSet.GetItemIfSet( RES_CHRATR_ROTATE ) ) + nDir = pItem->GetValue(); + + if ( nDir ) + { + delete pPor; + pPor = new SwRotatedPortion(rInf.GetIdx() + TextFrameIndex(1), + 900_deg10 == nDir + ? DIR_BOTTOM2TOP + : DIR_TOP2BOTTOM ); + } + } + } + else if ( pPor->InNumberGrp() ) + { + const SwFont* pNumFnt = static_cast(pPor)->GetFont(); + + if ( pNumFnt ) + { + Degree10 nDir = pNumFnt->GetOrientation( rInf.GetTextFrame()->IsVertical() ); + if ( nDir ) + { + delete pPor; + pPor = new SwRotatedPortion(TextFrameIndex(0), 900_deg10 == nDir + ? DIR_BOTTOM2TOP + : DIR_TOP2BOTTOM ); + + rInf.SetNumDone( false ); + rInf.SetFootnoteDone( false ); + } + } + } + } + + // The font is set in output device, + // the ascent and the height will be calculated. + if( !pPor->GetAscent() && !pPor->Height() ) + CalcAscent( rInf, pPor ); + rInf.SetLen( pPor->GetLen() ); + + // In CalcFlyWidth Width() will be shortened if a FlyPortion is present. + CalcFlyWidth( rInf ); + + // One must not forget that pCurr as GetLast() must provide reasonable values: + if( !m_pCurr->Height() ) + { + OSL_ENSURE( m_pCurr->Height(), "SwTextFormatter::NewPortion: limbo dance" ); + m_pCurr->Height( pPor->Height(), false ); + m_pCurr->SetAscent( pPor->GetAscent() ); + } + + OSL_ENSURE(pPor->Height(), "SwTextFormatter::NewPortion: something went wrong"); + if( pPor->IsPostItsPortion() && rInf.X() >= rInf.Width() && rInf.GetFly() ) + { + delete pPor; + pPor = rInf.GetFly(); + } + return pPor; +} + +TextFrameIndex SwTextFormatter::FormatLine(TextFrameIndex const nStartPos) +{ + OSL_ENSURE( ! m_pFrame->IsVertical() || m_pFrame->IsSwapped(), + "SwTextFormatter::FormatLine( nStartPos ) with unswapped frame" ); + + // For the formatting routines, we set pOut to the reference device. + SwHookOut aHook( GetInfo() ); + if (GetInfo().GetLen() < TextFrameIndex(GetInfo().GetText().getLength())) + GetInfo().SetLen(TextFrameIndex(GetInfo().GetText().getLength())); + + bool bBuild = true; + SetFlyInCntBase( false ); + GetInfo().SetLineHeight( 0 ); + GetInfo().SetLineNetHeight( 0 ); + + // Recycling must be suppressed by changed line height and also + // by changed ascent (lowering of baseline). + const SwTwips nOldHeight = m_pCurr->Height(); + const SwTwips nOldAscent = m_pCurr->GetAscent(); + + m_pCurr->SetEndHyph( false ); + m_pCurr->SetMidHyph( false ); + + // fly positioning can make it necessary format a line several times + // for this, we have to keep a copy of our rest portion + SwLinePortion* pField = GetInfo().GetRest(); + std::unique_ptr xSaveField; + + if ( pField && pField->InFieldGrp() && !pField->IsFootnotePortion() ) + xSaveField.reset(new SwFieldPortion( *static_cast(pField) )); + + // for an optimal repaint rectangle, we want to compare fly portions + // before and after the BuildPortions call + const bool bOptimizeRepaint = AllowRepaintOpt(); + TextFrameIndex const nOldLineEnd = nStartPos + m_pCurr->GetLen(); + std::vector flyStarts; + + // these are the conditions for a fly position comparison + if ( bOptimizeRepaint && m_pCurr->IsFly() ) + { + SwLinePortion* pPor = m_pCurr->GetFirstPortion(); + tools::Long nPOfst = 0; + while ( pPor ) + { + if ( pPor->IsFlyPortion() ) + // insert start value of fly portion + flyStarts.push_back( nPOfst ); + + nPOfst += pPor->Width(); + pPor = pPor->GetNextPortion(); + } + } + + // Here soon the underflow check follows. + while( bBuild ) + { + GetInfo().SetFootnoteInside( false ); + GetInfo().SetOtherThanFootnoteInside( false ); + + // These values must not be reset by FormatReset(); + const bool bOldNumDone = GetInfo().IsNumDone(); + const bool bOldFootnoteDone = GetInfo().IsFootnoteDone(); + const bool bOldArrowDone = GetInfo().IsArrowDone(); + const bool bOldErgoDone = GetInfo().IsErgoDone(); + + // besides other things, this sets the repaint offset to 0 + FormatReset( GetInfo() ); + + GetInfo().SetNumDone( bOldNumDone ); + GetInfo().SetFootnoteDone(bOldFootnoteDone); + GetInfo().SetArrowDone( bOldArrowDone ); + GetInfo().SetErgoDone( bOldErgoDone ); + + // build new portions for this line + BuildPortions( GetInfo() ); + + if( GetInfo().IsStop() ) + { + m_pCurr->SetLen(TextFrameIndex(0)); + m_pCurr->Height( GetFrameRstHeight() + 1, false ); + m_pCurr->SetRealHeight( GetFrameRstHeight() + 1 ); + + // Don't oversize the line in case of split flys, so we don't try to move the anchor + // of a precede fly forward, next to its follow. + if (m_pFrame->HasNonLastSplitFlyDrawObj()) + { + m_pCurr->SetRealHeight(GetFrameRstHeight()); + } + + m_pCurr->Width(0); + m_pCurr->Truncate(); + return nStartPos; + } + else if( GetInfo().IsDropInit() ) + { + DropInit(); + GetInfo().SetDropInit( false ); + } + + m_pCurr->CalcLine( *this, GetInfo() ); + CalcRealHeight( GetInfo().IsNewLine() ); + + //i#120864 For Special case that at the first calculation couldn't get + //correct height. And need to recalculate for the right height. + SwLinePortion* pPorTmp = m_pCurr->GetNextPortion(); + if ( IsFlyInCntBase() && (!IsQuick() || (pPorTmp && pPorTmp->IsFlyCntPortion() && !pPorTmp->GetNextPortion() && + m_pCurr->Height() > pPorTmp->Height()))) + { + SwTwips nTmpAscent, nTmpHeight; + CalcAscentAndHeight( nTmpAscent, nTmpHeight ); + AlignFlyInCntBase( Y() + tools::Long( nTmpAscent ) ); + m_pCurr->CalcLine( *this, GetInfo() ); + CalcRealHeight(); + } + + // bBuild decides if another lap of honor is done + if ( m_pCurr->GetRealHeight() <= GetInfo().GetLineHeight() ) + { + m_pCurr->SetRealHeight( GetInfo().GetLineHeight() ); + bBuild = false; + } + else + { + bBuild = ( GetInfo().GetTextFly().IsOn() && ChkFlyUnderflow(GetInfo()) ) + || GetInfo().CheckFootnotePortion(m_pCurr); + if( bBuild ) + { + // fdo44018-2.doc: only restore m_bNumDone if a SwNumberPortion will be truncated + for (SwLinePortion * pPor = m_pCurr->GetNextPortion(); pPor; pPor = pPor->GetNextPortion()) + { + if (pPor->InNumberGrp()) + { + GetInfo().SetNumDone( bOldNumDone ); + break; + } + } + GetInfo().ResetMaxWidthDiff(); + + // delete old rest + if ( GetInfo().GetRest() ) + { + delete GetInfo().GetRest(); + GetInfo().SetRest( nullptr ); + } + + // set original rest portion + if ( xSaveField ) + GetInfo().SetRest( new SwFieldPortion( *xSaveField ) ); + + m_pCurr->SetLen(TextFrameIndex(0)); + m_pCurr->Width(0); + m_pCurr->Truncate(); + } + } + } + + // In case of compat mode, it's possible that a tab portion is wider after + // formatting than before. If this is the case, we also have to make sure + // the SwLineLayout is wider as well. + if (GetInfo().GetTextFrame()->GetDoc().getIDocumentSettingAccess().get(DocumentSettingId::TAB_OVER_MARGIN)) + { + sal_uInt16 nSum = 0; + SwLinePortion* pPor = m_pCurr->GetFirstPortion(); + + while (pPor) + { + nSum += pPor->Width(); + pPor = pPor->GetNextPortion(); + } + + if (nSum > m_pCurr->Width()) + m_pCurr->Width(nSum); + } + + // calculate optimal repaint rectangle + if ( bOptimizeRepaint ) + { + GetInfo().SetPaintOfst( ::lcl_CalcOptRepaint( *this, *m_pCurr, nOldLineEnd, flyStarts ) ); + flyStarts.clear(); + } + else + // Special case: we do not allow an optimization of the repaint + // area, but during formatting the repaint offset is set to indicate + // a maximum value for the offset. This value has to be reset: + GetInfo().SetPaintOfst( 0 ); + + // This corrects the start of the reformat range if something has + // moved to the next line. Otherwise IsFirstReformat in AllowRepaintOpt + // will give us a wrong result if we have to reformat another line + GetInfo().GetParaPortion()->GetReformat().LeftMove( GetInfo().GetIdx() ); + + // delete master copy of rest portion + xSaveField.reset(); + + TextFrameIndex const nNewStart = nStartPos + m_pCurr->GetLen(); + + // adjust text if kana compression is enabled + if ( GetInfo().CompressLine() ) + { + SwTwips nRepaintOfst = CalcKanaAdj( m_pCurr ); + + // adjust repaint offset + if ( nRepaintOfst < GetInfo().GetPaintOfst() ) + GetInfo().SetPaintOfst( nRepaintOfst ); + } + + CalcAdjustLine( m_pCurr ); + + if( nOldHeight != m_pCurr->Height() || nOldAscent != m_pCurr->GetAscent() ) + { + SetFlyInCntBase(); + GetInfo().SetPaintOfst( 0 ); // changed line height => no recycling + // all following line must be painted and when Flys are around, + // also formatted + GetInfo().SetShift( true ); + } + + if ( IsFlyInCntBase() && !IsQuick() ) + UpdatePos( m_pCurr, GetTopLeft(), GetStart() ); + + return nNewStart; +} + +void SwTextFormatter::RecalcRealHeight() +{ + do + { + CalcRealHeight(); + } while (Next()); +} + +void SwTextFormatter::CalcRealHeight( bool bNewLine ) +{ + SwTwips nLineHeight = m_pCurr->Height(); + m_pCurr->SetClipping( false ); + + SwTextGridItem const*const pGrid(GetGridItem(m_pFrame->FindPageFrame())); + if ( pGrid && GetInfo().SnapToGrid() ) + { + const sal_uInt16 nGridWidth = pGrid->GetBaseHeight(); + const sal_uInt16 nRubyHeight = pGrid->GetRubyHeight(); + const bool bRubyTop = ! pGrid->GetRubyTextBelow(); + + nLineHeight = nGridWidth + nRubyHeight; + const sal_uInt16 nAmpRatio = (m_pCurr->Height() + nLineHeight - 1)/nLineHeight; + nLineHeight *= nAmpRatio; + + const sal_uInt16 nAsc = m_pCurr->GetAscent() + + ( bRubyTop ? + ( nLineHeight - m_pCurr->Height() + nRubyHeight ) / 2 : + ( nLineHeight - m_pCurr->Height() - nRubyHeight ) / 2 ); + + m_pCurr->Height( nLineHeight, false ); + m_pCurr->SetAscent( nAsc ); + m_pInf->GetParaPortion()->SetFixLineHeight(); + + // we ignore any line spacing options except from ... + const SvxLineSpacingItem* pSpace = m_aLineInf.GetLineSpacing(); + if ( ! IsParaLine() && pSpace && + SvxInterLineSpaceRule::Prop == pSpace->GetInterLineSpaceRule() ) + { + sal_uLong nTmp = pSpace->GetPropLineSpace(); + + if( nTmp < 100 ) + nTmp = 100; + + nTmp *= nLineHeight; + nLineHeight = nTmp / 100; + } + + m_pCurr->SetRealHeight( nLineHeight ); + return; + } + + // The dummy flag is set on lines that only contain flyportions, these shouldn't + // consider register-true and so on. Unfortunately an empty line can be at + // the end of a paragraph (empty paragraphs or behind a Shift-Return), + // which should consider the register. + if (!m_pCurr->IsDummy() || (!m_pCurr->GetNext() + && GetStart() >= TextFrameIndex(GetTextFrame()->GetText().getLength()) + && !bNewLine)) + { + const SvxLineSpacingItem *pSpace = m_aLineInf.GetLineSpacing(); + if( pSpace ) + { + switch( pSpace->GetLineSpaceRule() ) + { + case SvxLineSpaceRule::Auto: + // shrink first line of paragraph too on spacing < 100% + if (IsParaLine() && + pSpace->GetInterLineSpaceRule() == SvxInterLineSpaceRule::Prop + && GetTextFrame()->GetDoc().getIDocumentSettingAccess().get(DocumentSettingId::PROP_LINE_SPACING_SHRINKS_FIRST_LINE)) + { + tools::Long nTmp = pSpace->GetPropLineSpace(); + // Word will render < 50% too but it's just not readable + if( nTmp < 50 ) + nTmp = nTmp ? 50 : 100; + if (nTmp<100) { // code adapted from fixed line height + nTmp *= nLineHeight; + nTmp /= 100; + if( !nTmp ) + ++nTmp; + nLineHeight = nTmp; + sal_uInt16 nAsc = ( 4 * nLineHeight ) / 5; // 80% +#if 0 + // could do clipping here (like Word does) + // but at 0.5 its unreadable either way... + if( nAsc < pCurr->GetAscent() || + nLineHeight - nAsc < pCurr->Height() - + pCurr->GetAscent() ) + pCurr->SetClipping( true ); +#endif + m_pCurr->SetAscent( nAsc ); + m_pCurr->Height( nLineHeight, false ); + m_pInf->GetParaPortion()->SetFixLineHeight(); + } + } + break; + case SvxLineSpaceRule::Min: + { + if( nLineHeight < pSpace->GetLineHeight() ) + nLineHeight = pSpace->GetLineHeight(); + break; + } + case SvxLineSpaceRule::Fix: + { + nLineHeight = pSpace->GetLineHeight(); + const sal_uInt16 nAsc = ( 4 * nLineHeight ) / 5; // 80% + if( nAsc < m_pCurr->GetAscent() || + nLineHeight - nAsc < m_pCurr->Height() - m_pCurr->GetAscent() ) + m_pCurr->SetClipping( true ); + m_pCurr->Height( nLineHeight, false ); + m_pCurr->SetAscent( nAsc ); + m_pInf->GetParaPortion()->SetFixLineHeight(); + } + break; + default: OSL_FAIL( ": unknown LineSpaceRule" ); + } + // Note: for the _first_ line the line spacing of the previous + // paragraph is applied in SwFlowFrame::CalcUpperSpace() + if( !IsParaLine() ) + switch( pSpace->GetInterLineSpaceRule() ) + { + case SvxInterLineSpaceRule::Off: + break; + case SvxInterLineSpaceRule::Prop: + { + tools::Long nTmp = pSpace->GetPropLineSpace(); + // 50% is the minimum, if 0% we switch to the + // default value 100% ... + if( nTmp < 50 ) + nTmp = nTmp ? 50 : 100; + + // extend line height by (nPropLineSpace - 100) percent of the font height + nTmp -= 100; + nTmp *= m_pCurr->GetTextHeight(); + nTmp /= 100; + nTmp += nLineHeight; + if (nTmp < 1) + nTmp = 1; + nLineHeight = nTmp; + break; + } + case SvxInterLineSpaceRule::Fix: + { + nLineHeight = nLineHeight + pSpace->GetInterLineSpace(); + break; + } + default: OSL_FAIL( ": unknown InterLineSpaceRule" ); + } + } + + if( IsRegisterOn() ) + { + SwTwips nTmpY = Y() + m_pCurr->GetAscent() + nLineHeight - m_pCurr->Height(); + SwRectFnSet aRectFnSet(m_pFrame); + if ( aRectFnSet.IsVert() ) + nTmpY = m_pFrame->SwitchHorizontalToVertical( nTmpY ); + nTmpY = aRectFnSet.YDiff( nTmpY, RegStart() ); + const sal_uInt16 nDiff = sal_uInt16( nTmpY % RegDiff() ); + if( nDiff ) + nLineHeight += RegDiff() - nDiff; + } + } + m_pCurr->SetRealHeight( nLineHeight ); +} + +void SwTextFormatter::FeedInf( SwTextFormatInfo &rInf ) const +{ + // delete Fly in any case! + ClearFly( rInf ); + rInf.Init(); + + rInf.ChkNoHyph( CntEndHyph(), CntMidHyph() ); + rInf.SetRoot( m_pCurr ); + rInf.SetLineStart( m_nStart ); + rInf.SetIdx( m_nStart ); + rInf.Left( Left() ); + rInf.Right( Right() ); + rInf.First( FirstLeft() ); + rInf.LeftMargin(GetLeftMargin()); + + rInf.RealWidth( sal_uInt16(rInf.Right() - GetLeftMargin()) ); + rInf.Width( rInf.RealWidth() ); + if( const_cast(this)->GetRedln() ) + { + const_cast(this)->GetRedln()->Clear( const_cast(this)->GetFnt() ); + const_cast(this)->GetRedln()->Reset(); + } +} + +void SwTextFormatter::FormatReset( SwTextFormatInfo &rInf ) +{ + m_pFirstOfBorderMerge = nullptr; + m_pCurr->Truncate(); + m_pCurr->Init(); + + // delete pSpaceAdd and pKanaComp + m_pCurr->FinishSpaceAdd(); + m_pCurr->FinishKanaComp(); + m_pCurr->ResetFlags(); + FeedInf( rInf ); +} + +bool SwTextFormatter::CalcOnceMore() +{ + if( m_pDropFormat ) + { + const sal_uInt16 nOldDrop = GetDropHeight(); + CalcDropHeight( m_pDropFormat->GetLines() ); + m_bOnceMore = nOldDrop != GetDropHeight(); + } + else + m_bOnceMore = false; + return m_bOnceMore; +} + +SwTwips SwTextFormatter::CalcBottomLine() const +{ + SwTwips nRet = Y() + GetLineHeight(); + SwTwips nMin = GetInfo().GetTextFly().GetMinBottom(); + if( nMin && ++nMin > nRet ) + { + SwTwips nDist = m_pFrame->getFrameArea().Height() - m_pFrame->getFramePrintArea().Height() + - m_pFrame->getFramePrintArea().Top(); + if( nRet + nDist < nMin ) + { + const bool bRepaint = HasTruncLines() && + GetInfo().GetParaPortion()->GetRepaint().Bottom() == nRet-1; + nRet = nMin - nDist; + if( bRepaint ) + { + const_cast(GetInfo().GetParaPortion() + ->GetRepaint()).Bottom( nRet-1 ); + const_cast(GetInfo()).SetPaintOfst( 0 ); + } + } + } + return nRet; +} + +// FME/OD: This routine does a limited text formatting. +SwTwips SwTextFormatter::CalcFitToContent_() +{ + FormatReset( GetInfo() ); + BuildPortions( GetInfo() ); + m_pCurr->CalcLine( *this, GetInfo() ); + return m_pCurr->Width(); +} + +// determines if the calculation of a repaint offset is allowed +// otherwise each line is painted from 0 (this is a copy of the beginning +// of the former SwTextFormatter::Recycle() function +bool SwTextFormatter::AllowRepaintOpt() const +{ + // reformat position in front of current line? Only in this case + // we want to set the repaint offset + bool bOptimizeRepaint = m_nStart < GetInfo().GetReformatStart() && + m_pCurr->GetLen(); + + // a special case is the last line of a block adjusted paragraph: + if ( bOptimizeRepaint ) + { + switch( GetAdjust() ) + { + case SvxAdjust::Block: + { + if( IsLastBlock() || IsLastCenter() ) + bOptimizeRepaint = false; + else + { + // ????: blank in the last master line (blocksat.sdw) + bOptimizeRepaint = nullptr == m_pCurr->GetNext() && !m_pFrame->GetFollow(); + if ( bOptimizeRepaint ) + { + SwLinePortion *pPos = m_pCurr->GetFirstPortion(); + while ( pPos && !pPos->IsFlyPortion() ) + pPos = pPos->GetNextPortion(); + bOptimizeRepaint = !pPos; + } + } + break; + } + case SvxAdjust::Center: + case SvxAdjust::Right: + bOptimizeRepaint = false; + break; + default: ; + } + } + + // Again another special case: invisible SoftHyphs + const TextFrameIndex nReformat = GetInfo().GetReformatStart(); + if (bOptimizeRepaint && TextFrameIndex(COMPLETE_STRING) != nReformat) + { + const sal_Unicode cCh = nReformat >= TextFrameIndex(GetInfo().GetText().getLength()) + ? 0 + : GetInfo().GetText()[ sal_Int32(nReformat) ]; + bOptimizeRepaint = ( CH_TXTATR_BREAKWORD != cCh && CH_TXTATR_INWORD != cCh ) + || ! GetInfo().HasHint( nReformat ); + } + + return bOptimizeRepaint; +} + +void SwTextFormatter::CalcUnclipped( SwTwips& rTop, SwTwips& rBottom ) +{ + OSL_ENSURE( ! m_pFrame->IsVertical() || m_pFrame->IsSwapped(), + "SwTextFormatter::CalcUnclipped with unswapped frame" ); + + SwTwips nFlyAsc, nFlyDesc; + m_pCurr->MaxAscentDescent( rTop, rBottom, nFlyAsc, nFlyDesc ); + rTop = Y() + GetCurr()->GetAscent(); + rBottom = rTop + nFlyDesc; + rTop -= nFlyAsc; +} + +void SwTextFormatter::UpdatePos( SwLineLayout *pCurrent, Point aStart, + TextFrameIndex const nStartIdx, bool bAlways) const +{ + OSL_ENSURE( ! m_pFrame->IsVertical() || m_pFrame->IsSwapped(), + "SwTextFormatter::UpdatePos with unswapped frame" ); + + if( GetInfo().IsTest() ) + return; + SwLinePortion *pFirst = pCurrent->GetFirstPortion(); + SwLinePortion *pPos = pFirst; + SwTextPaintInfo aTmpInf( GetInfo() ); + aTmpInf.SetpSpaceAdd( pCurrent->GetpLLSpaceAdd() ); + aTmpInf.ResetSpaceIdx(); + aTmpInf.SetKanaComp( pCurrent->GetpKanaComp() ); + aTmpInf.ResetKanaIdx(); + + // The frame's size + aTmpInf.SetIdx( nStartIdx ); + aTmpInf.SetPos( aStart ); + + SwTwips nTmpAscent, nTmpDescent, nFlyAsc, nFlyDesc; + pCurrent->MaxAscentDescent( nTmpAscent, nTmpDescent, nFlyAsc, nFlyDesc ); + + const SwTwips nTmpHeight = pCurrent->GetRealHeight(); + SwTwips nAscent = pCurrent->GetAscent() + nTmpHeight - pCurrent->Height(); + AsCharFlags nFlags = AsCharFlags::UlSpace; + if( GetMulti() ) + { + aTmpInf.SetDirection( GetMulti()->GetDirection() ); + if( GetMulti()->HasRotation() ) + { + nFlags |= AsCharFlags::Rotate; + if( GetMulti()->IsRevers() ) + { + nFlags |= AsCharFlags::Reverse; + aTmpInf.X( aTmpInf.X() - nAscent ); + } + else + aTmpInf.X( aTmpInf.X() + nAscent ); + } + else + { + if ( GetMulti()->IsBidi() ) + nFlags |= AsCharFlags::Bidi; + aTmpInf.Y( aTmpInf.Y() + nAscent ); + } + } + else + aTmpInf.Y( aTmpInf.Y() + nAscent ); + + while( pPos ) + { + // We only know one case where changing the position (caused by the + // adjustment) could be relevant for a portion: We need to SetRefPoint + // for FlyCntPortions. + if( ( pPos->IsFlyCntPortion() || pPos->IsGrfNumPortion() ) + && ( bAlways || !IsQuick() ) ) + { + pCurrent->MaxAscentDescent( nTmpAscent, nTmpDescent, nFlyAsc, nFlyDesc, pPos ); + + if( pPos->IsGrfNumPortion() ) + { + if( !nFlyAsc && !nFlyDesc ) + { + nTmpAscent = nAscent; + nFlyAsc = nAscent; + nTmpDescent = nTmpHeight - nAscent; + nFlyDesc = nTmpDescent; + } + static_cast(pPos)->SetBase( nTmpAscent, nTmpDescent, + nFlyAsc, nFlyDesc ); + } + else + { + Point aBase( aTmpInf.GetPos() ); + if ( GetInfo().GetTextFrame()->IsVertical() ) + GetInfo().GetTextFrame()->SwitchHorizontalToVertical( aBase ); + + static_cast(pPos)->SetBase( *aTmpInf.GetTextFrame(), + aBase, nTmpAscent, nTmpDescent, nFlyAsc, + nFlyDesc, nFlags ); + } + } + if( pPos->IsMultiPortion() && static_cast(pPos)->HasFlyInContent() ) + { + OSL_ENSURE( !GetMulti(), "Too much multi" ); + const_cast(this)->m_pMulti = static_cast(pPos); + SwLineLayout *pLay = &GetMulti()->GetRoot(); + Point aSt( aTmpInf.X(), aStart.Y() ); + + if ( GetMulti()->HasBrackets() ) + { + OSL_ENSURE( GetMulti()->IsDouble(), "Brackets only for doubles"); + aSt.AdjustX(static_cast(GetMulti())->PreWidth() ); + } + else if( GetMulti()->HasRotation() ) + { + aSt.AdjustY(pCurrent->GetAscent() - GetMulti()->GetAscent() ); + if( GetMulti()->IsRevers() ) + aSt.AdjustX(GetMulti()->Width() ); + else + aSt.AdjustY(GetMulti()->Height() ); + } + else if ( GetMulti()->IsBidi() ) + // jump to end of the bidi portion + aSt.AdjustX(pLay->Width() ); + + TextFrameIndex nStIdx = aTmpInf.GetIdx(); + do + { + UpdatePos( pLay, aSt, nStIdx, bAlways ); + nStIdx = nStIdx + pLay->GetLen(); + aSt.AdjustY(pLay->Height() ); + pLay = pLay->GetNext(); + } while ( pLay ); + const_cast(this)->m_pMulti = nullptr; + } + pPos->Move( aTmpInf ); + pPos = pPos->GetNextPortion(); + } +} + +void SwTextFormatter::AlignFlyInCntBase( tools::Long nBaseLine ) const +{ + OSL_ENSURE( ! m_pFrame->IsVertical() || m_pFrame->IsSwapped(), + "SwTextFormatter::AlignFlyInCntBase with unswapped frame" ); + + if( GetInfo().IsTest() ) + return; + SwLinePortion *pFirst = m_pCurr->GetFirstPortion(); + SwLinePortion *pPos = pFirst; + AsCharFlags nFlags = AsCharFlags::None; + if( GetMulti() && GetMulti()->HasRotation() ) + { + nFlags |= AsCharFlags::Rotate; + if( GetMulti()->IsRevers() ) + nFlags |= AsCharFlags::Reverse; + } + + SwTwips nTmpAscent, nTmpDescent, nFlyAsc, nFlyDesc; + + while( pPos ) + { + if( pPos->IsFlyCntPortion() || pPos->IsGrfNumPortion() ) + { + m_pCurr->MaxAscentDescent( nTmpAscent, nTmpDescent, nFlyAsc, nFlyDesc, pPos ); + + if( pPos->IsGrfNumPortion() ) + static_cast(pPos)->SetBase( nTmpAscent, nTmpDescent, + nFlyAsc, nFlyDesc ); + else + { + Point aBase; + if ( GetInfo().GetTextFrame()->IsVertical() ) + { + nBaseLine = GetInfo().GetTextFrame()->SwitchHorizontalToVertical( nBaseLine ); + aBase = Point( nBaseLine, static_cast(pPos)->GetRefPoint().Y() ); + } + else + aBase = Point( static_cast(pPos)->GetRefPoint().X(), nBaseLine ); + + static_cast(pPos)->SetBase( *GetInfo().GetTextFrame(), aBase, nTmpAscent, nTmpDescent, + nFlyAsc, nFlyDesc, nFlags ); + } + } + pPos = pPos->GetNextPortion(); + } +} + +bool SwTextFormatter::ChkFlyUnderflow( SwTextFormatInfo &rInf ) const +{ + OSL_ENSURE( rInf.GetTextFly().IsOn(), "SwTextFormatter::ChkFlyUnderflow: why?" ); + if( GetCurr() ) + { + // First we check, whether a fly overlaps with the line. + // = GetLineHeight() + const sal_uInt16 nHeight = GetCurr()->GetRealHeight(); + SwRect aLine( GetLeftMargin(), Y(), rInf.RealWidth(), nHeight ); + + SwRect aLineVert( aLine ); + if ( m_pFrame->IsVertical() ) + m_pFrame->SwitchHorizontalToVertical( aLineVert ); + SwRect aInter( rInf.GetTextFly().GetFrame( aLineVert ) ); + if ( m_pFrame->IsVertical() ) + m_pFrame->SwitchVerticalToHorizontal( aInter ); + + if( !aInter.HasArea() ) + return false; + + // We now check every portion that could have lowered for overlapping + // with the fly. + const SwLinePortion *pPos = GetCurr()->GetFirstPortion(); + aLine.Pos().setY( Y() + GetCurr()->GetRealHeight() - GetCurr()->Height() ); + aLine.Height( GetCurr()->Height() ); + + while( pPos ) + { + aLine.Width( pPos->Width() ); + + aLineVert = aLine; + if ( m_pFrame->IsVertical() ) + m_pFrame->SwitchHorizontalToVertical( aLineVert ); + aInter = rInf.GetTextFly().GetFrame( aLineVert ); + if ( m_pFrame->IsVertical() ) + m_pFrame->SwitchVerticalToHorizontal( aInter ); + + // New flys from below? + if( !pPos->IsFlyPortion() ) + { + if( aInter.Overlaps( aLine ) ) + { + aInter.Intersection_( aLine ); + if( aInter.HasArea() ) + { + // To be evaluated during reformat of this line: + // RealHeight including spacing + rInf.SetLineHeight( nHeight ); + // Height without extra spacing + rInf.SetLineNetHeight( m_pCurr->Height() ); + return true; + } + } + } + else + { + // The fly portion is not intersected by a fly anymore + if ( ! aInter.Overlaps( aLine ) ) + { + rInf.SetLineHeight( nHeight ); + rInf.SetLineNetHeight( m_pCurr->Height() ); + return true; + } + else + { + aInter.Intersection_( aLine ); + + // No area means a fly has become invalid because of + // lowering the line => reformat the line + // we also have to reformat the line, if the fly size + // differs from the intersection interval's size. + if( ! aInter.HasArea() || + static_cast(pPos)->GetFixWidth() != aInter.Width() ) + { + rInf.SetLineHeight( nHeight ); + rInf.SetLineNetHeight( m_pCurr->Height() ); + return true; + } + } + } + + aLine.Left( aLine.Left() + pPos->Width() ); + pPos = pPos->GetNextPortion(); + } + } + return false; +} + +void SwTextFormatter::CalcFlyWidth( SwTextFormatInfo &rInf ) +{ + if( GetMulti() || rInf.GetFly() ) + return; + + SwTextFly& rTextFly = rInf.GetTextFly(); + if( !rTextFly.IsOn() || rInf.IsIgnoreFly() ) + return; + + const SwLinePortion *pLast = rInf.GetLast(); + + tools::Long nAscent; + tools::Long nTop = Y(); + tools::Long nHeight; + + if( rInf.GetLineHeight() ) + { + // Real line height has already been calculated, we only have to + // search for intersections in the lower part of the strip + nAscent = m_pCurr->GetAscent(); + nHeight = rInf.GetLineNetHeight(); + nTop += rInf.GetLineHeight() - nHeight; + } + else + { + // We make a first guess for the lines real height + if ( ! m_pCurr->GetRealHeight() ) + CalcRealHeight(); + + nAscent = pLast->GetAscent(); + nHeight = pLast->Height(); + + if ( m_pCurr->GetRealHeight() > nHeight ) + nTop += m_pCurr->GetRealHeight() - nHeight; + else + // Important for fixed space between lines + nHeight = m_pCurr->GetRealHeight(); + } + + const tools::Long nLeftMar = GetLeftMargin(); + const tools::Long nLeftMin = (rInf.X() || GetDropLeft()) ? nLeftMar : GetLeftMin(); + + SwRect aLine( rInf.X() + nLeftMin, nTop, rInf.RealWidth() - rInf.X() + + nLeftMar - nLeftMin , nHeight ); + + bool bWordFlyWrap = GetTextFrame()->GetDoc().getIDocumentSettingAccess().get(DocumentSettingId::ADD_VERTICAL_FLY_OFFSETS); + // tdf#116486: consider also the upper margin from getFramePrintArea because intersections + // with this additional space should lead to repositioning of paragraphs + // For compatibility we grab a related compat flag: + if (bWordFlyWrap && IsFirstTextLine()) + { + tools::Long nUpper = m_pFrame->getFramePrintArea().Top(); + // Make sure that increase only happens in case the upper spacing comes from the upper + // margin of the current text frame, not because of a lower spacing of the previous text + // frame. + nUpper -= m_pFrame->GetUpperSpaceAmountConsideredForPrevFrameAndPageGrid(); + // Increase the rectangle + if( nUpper > 0 && nTop >= nUpper ) + aLine.SubTop( nUpper ); + } + + if (IsFirstTextLine()) + { + // Check if a compatibility mode requires considering also the lower margin of this text + // frame, intersections with this additional space should lead to shifting the paragraph + // marker down. + SwTwips nLower = m_pFrame->GetLowerMarginForFlyIntersect(); + if (nLower > 0) + { + aLine.AddBottom(nLower); + } + } + + SwRect aLineVert( aLine ); + if ( m_pFrame->IsRightToLeft() ) + m_pFrame->SwitchLTRtoRTL( aLineVert ); + + if ( m_pFrame->IsVertical() ) + m_pFrame->SwitchHorizontalToVertical( aLineVert ); + + // GetFrame(...) determines and returns the intersection rectangle + SwRect aInter( rTextFly.GetFrame( aLineVert ) ); + + if ( m_pFrame->IsRightToLeft() ) + m_pFrame->SwitchRTLtoLTR( aInter ); + + if ( m_pFrame->IsVertical() ) + m_pFrame->SwitchVerticalToHorizontal( aInter ); + + if (!aInter.IsEmpty() && aInter.Bottom() < nTop) + { + // Intersects with the frame area (with upper margin), but not with the print area (without + // upper margin). Don't reserve space for the fly portion in this case, text is allowed to + // flow there. + aInter.Height(0); + } + + if( !aInter.Overlaps( aLine ) ) + return; + + aLine.Left( rInf.X() + nLeftMar ); + bool bForced = false; + bool bSplitFly = false; + for (const auto& pObj : rTextFly.GetAnchoredObjList()) + { + auto pFlyFrame = pObj->DynCastFlyFrame(); + if (!pFlyFrame) + { + continue; + } + + if (!pFlyFrame->IsFlySplitAllowed()) + { + continue; + } + + bSplitFly = true; + break; + } + if( aInter.Left() <= nLeftMin ) + { + SwTwips nFrameLeft = GetTextFrame()->getFrameArea().Left(); + SwTwips nFramePrintAreaLeft = GetTextFrame()->getFramePrintArea().Left(); + if( nFramePrintAreaLeft < 0 ) + nFrameLeft += GetTextFrame()->getFramePrintArea().Left(); + if( aInter.Left() < nFrameLeft ) + { + aInter.Left(nFrameLeft); // both sets left and reduces width + if (bSplitFly && nFramePrintAreaLeft > 0 && nFramePrintAreaLeft < aInter.Width()) + { + // We wrap around a split fly, the fly portion is on the + // left of the paragraph and we have a positive + // paragraph margin. Don't take space twice in this case + // (margin, fly portion), decrease the width of the fly + // portion accordingly. + aInter.Right(aInter.Right() - nFramePrintAreaLeft); + } + } + + tools::Long nAddMar = 0; + if (GetTextFrame()->IsRightToLeft()) + { + nAddMar = GetTextFrame()->getFrameArea().Right() - Right(); + if ( nAddMar < 0 ) + nAddMar = 0; + } + else + nAddMar = nLeftMar - nFrameLeft; + + aInter.Width( aInter.Width() + nAddMar ); + // For a negative first line indent, we set this flag to show + // that the indentation/margin has been moved. + // This needs to be respected by the DefaultTab at the zero position. + if( IsFirstTextLine() && HasNegFirst() ) + bForced = true; + } + aInter.Intersection( aLine ); + if( !aInter.HasArea() ) + return; + + bool bFullLine = aLine.Left() == aInter.Left() && + aLine.Right() == aInter.Right(); + if (!bFullLine && bWordFlyWrap && !GetTextFrame()->IsInTab()) + { + // Word style: if there is minimal space remaining, then handle that similar to a full line + // and put the actual empty paragraph below the fly. + SwTwips nLimit = MINLAY; + if (bSplitFly) + { + // We wrap around a floating table, that has a larger minimal wrap distance. + nLimit = TEXT_MIN_SMALL; + } + + bFullLine = std::abs(aLine.Left() - aInter.Left()) < nLimit + && std::abs(aLine.Right() - aInter.Right()) < nLimit; + } + + // Although no text is left, we need to format another line, + // because also empty lines need to avoid a Fly with no wrapping. + if (bFullLine && rInf.GetIdx() == TextFrameIndex(rInf.GetText().getLength())) + { + rInf.SetNewLine( true ); + // We know that for dummies, it holds ascent == height + m_pCurr->SetDummy(true); + } + + // aInter becomes frame-local + aInter.Pos().AdjustX( -nLeftMar ); + SwFlyPortion *pFly = new SwFlyPortion( aInter ); + if( bForced ) + { + m_pCurr->SetForcedLeftMargin(); + rInf.ForcedLeftMargin( o3tl::narrowing(aInter.Width()) ); + } + + if( bFullLine ) + { + // In order to properly flow around Flys with different + // wrapping attributes, we need to increase by units of line height. + // The last avoiding line should be adjusted in height, so that + // we don't get a frame spacing effect. + // It is important that ascent == height, because the FlyPortion + // values are transferred to pCurr in CalcLine and IsDummy() relies + // on this behaviour. + // To my knowledge we only have two places where DummyLines can be + // created: here and in MakeFlyDummies. + // IsDummy() is evaluated in IsFirstTextLine(), when moving lines + // and in relation with DropCaps. + pFly->Height( aInter.Height() ); + + // nNextTop now contains the margin's bottom edge, which we avoid + // or the next margin's top edge, which we need to respect. + // That means we can comfortably grow up to this value; that's how + // we save a few empty lines. + tools::Long nNextTop = rTextFly.GetNextTop(); + if ( m_pFrame->IsVertical() ) + nNextTop = m_pFrame->SwitchVerticalToHorizontal( nNextTop ); + if( nNextTop > aInter.Bottom() ) + { + SwTwips nH = nNextTop - aInter.Top(); + if( nH < SAL_MAX_UINT16 ) + pFly->Height( nH ); + } + if( nAscent < pFly->Height() ) + pFly->SetAscent( nAscent ); + else + pFly->SetAscent( pFly->Height() ); + } + else + { + if (rInf.GetIdx() == TextFrameIndex(rInf.GetText().getLength())) + { + // Don't use nHeight, or we have a huge descent + pFly->Height( pLast->Height() ); + pFly->SetAscent( pLast->GetAscent() ); + } + else + { + pFly->Height( aInter.Height() ); + if( nAscent < pFly->Height() ) + pFly->SetAscent( nAscent ); + else + pFly->SetAscent( pFly->Height() ); + } + } + + rInf.SetFly( pFly ); + + if( pFly->GetFix() < rInf.Width() ) + rInf.Width( pFly->GetFix() ); + + SwTextGridItem const*const pGrid(GetGridItem(m_pFrame->FindPageFrame())); + if ( !pGrid ) + return; + + const SwPageFrame* pPageFrame = m_pFrame->FindPageFrame(); + const SwLayoutFrame* pBody = pPageFrame->FindBodyCont(); + + SwRectFnSet aRectFnSet(pPageFrame); + + const tools::Long nGridOrigin = pBody ? + aRectFnSet.GetPrtLeft(*pBody) : + aRectFnSet.GetPrtLeft(*pPageFrame); + + const SwDoc & rDoc = rInf.GetTextFrame()->GetDoc(); + const sal_uInt16 nGridWidth = GetGridWidth(*pGrid, rDoc); + + SwTwips nStartX = GetLeftMargin(); + if ( aRectFnSet.IsVert() ) + { + Point aPoint( nStartX, 0 ); + m_pFrame->SwitchHorizontalToVertical( aPoint ); + nStartX = aPoint.Y(); + } + + const SwTwips nOfst = nStartX - nGridOrigin; + const SwTwips nTmpWidth = rInf.Width() + nOfst; + + const SwTwips i = nTmpWidth / nGridWidth + 1; + + const SwTwips nNewWidth = ( i - 1 ) * nGridWidth - nOfst; + if ( nNewWidth > 0 ) + rInf.Width( nNewWidth ); + else + rInf.Width( 0 ); + + +} + +SwFlyCntPortion *SwTextFormatter::NewFlyCntPortion( SwTextFormatInfo &rInf, + SwTextAttr *pHint ) const +{ + const SwFrame *pFrame = m_pFrame; + + SwFlyInContentFrame *pFly; + SwFrameFormat* pFrameFormat = static_cast(pHint)->GetFlyCnt().GetFrameFormat(); + if( RES_FLYFRMFMT == pFrameFormat->Which() ) + { + // set Lock pFrame to avoid m_pCurr getting deleted + TextFrameLockGuard aGuard(m_pFrame); + pFly = static_cast(pHint)->GetFlyFrame(pFrame); + } + else + pFly = nullptr; + // aBase is the document-global position, from which the new extra portion is placed + // aBase.X() = Offset in the line after the current position + // aBase.Y() = LineIter.Y() + Ascent of the current position + + SwTwips nTmpAscent, nTmpDescent, nFlyAsc, nFlyDesc; + // i#11859 - use new method + // to change line spacing behaviour at paragraph - Compatibility to MS Word + //SwLinePortion *pPos = pCurr->GetFirstPortion(); + //lcl_MaxAscDescent( pPos, nTmpAscent, nTmpDescent, nFlyAsc, nFlyDesc ); + m_pCurr->MaxAscentDescent( nTmpAscent, nTmpDescent, nFlyAsc, nFlyDesc ); + + // If the ascent of the frame is larger than the ascent of the current position, + // we use this one when calculating the base, or the frame would be positioned + // too much to the top, sliding down after all causing a repaint in an area + // he actually never was in. + SwTwips nAscent = 0; + + const bool bTextFrameVertical = GetInfo().GetTextFrame()->IsVertical(); + + const bool bUseFlyAscent = pFly && pFly->isFrameAreaPositionValid() && + 0 != ( bTextFrameVertical ? + pFly->GetRefPoint().X() : + pFly->GetRefPoint().Y() ); + + if ( bUseFlyAscent ) + nAscent = std::abs( int( bTextFrameVertical ? + pFly->GetRelPos().X() : + pFly->GetRelPos().Y() ) ); + + // Check if be prefer to use the ascent of the last portion: + if ( IsQuick() || + !bUseFlyAscent || + nAscent < rInf.GetLast()->GetAscent() ) + { + nAscent = rInf.GetLast()->GetAscent(); + } + else if( nAscent > nFlyAsc ) + nFlyAsc = nAscent; + + Point aBase( GetLeftMargin() + rInf.X(), Y() + nAscent ); + AsCharFlags nMode = IsQuick() ? AsCharFlags::Quick : AsCharFlags::None; + if( GetMulti() && GetMulti()->HasRotation() ) + { + nMode |= AsCharFlags::Rotate; + if( GetMulti()->IsRevers() ) + nMode |= AsCharFlags::Reverse; + } + + Point aTmpBase( aBase ); + if ( GetInfo().GetTextFrame()->IsVertical() ) + GetInfo().GetTextFrame()->SwitchHorizontalToVertical( aTmpBase ); + + SwFlyCntPortion* pRet(nullptr); + if( pFly ) + { + pRet = sw::FlyContentPortion::Create(*GetInfo().GetTextFrame(), pFly, aTmpBase, nTmpAscent, nTmpDescent, nFlyAsc, nFlyDesc, nMode); + // We need to make sure that our font is set again in the OutputDevice + // It could be that the FlyInCnt was added anew and GetFlyFrame() would + // in turn cause, that it'd be created anew again. + // This one's frames get formatted right away, which change the font. + rInf.SelectFont(); + if( pRet->GetAscent() > nAscent ) + { + aBase.setY( Y() + pRet->GetAscent() ); + nMode |= AsCharFlags::UlSpace; + if( !rInf.IsTest() ) + { + aTmpBase = aBase; + if ( GetInfo().GetTextFrame()->IsVertical() ) + GetInfo().GetTextFrame()->SwitchHorizontalToVertical( aTmpBase ); + + pRet->SetBase( *rInf.GetTextFrame(), aTmpBase, nTmpAscent, + nTmpDescent, nFlyAsc, nFlyDesc, nMode ); + } + } + } + else + { + pRet = sw::DrawFlyCntPortion::Create(*rInf.GetTextFrame(), *pFrameFormat, aTmpBase, nTmpAscent, nTmpDescent, nFlyAsc, nFlyDesc, nMode); + } + return pRet; +} + +/* Drop portion is a special case, because it has parts which aren't portions + but we have handle them just like portions */ +void SwTextFormatter::MergeCharacterBorder( SwDropPortion const & rPortion ) +{ + if( rPortion.GetLines() <= 1 ) + return; + + SwDropPortionPart* pCurrPart = rPortion.GetPart(); + while( pCurrPart ) + { + if( pCurrPart->GetFollow() && + ::lcl_HasSameBorder(pCurrPart->GetFont(), pCurrPart->GetFollow()->GetFont()) ) + { + pCurrPart->SetJoinBorderWithNext(true); + pCurrPart->GetFollow()->SetJoinBorderWithPrev(true); + } + pCurrPart = pCurrPart->GetFollow(); + } +} + +void SwTextFormatter::MergeCharacterBorder( SwLinePortion& rPortion, SwLinePortion const *pPrev, SwTextFormatInfo& rInf ) +{ + const SwFont aCurFont = *rInf.GetFont(); + if( !aCurFont.HasBorder() ) + return; + + if (pPrev && pPrev->GetJoinBorderWithNext() ) + { + // In some case border merge is called twice to the portion + if( !rPortion.GetJoinBorderWithPrev() ) + { + rPortion.SetJoinBorderWithPrev(true); + if( rPortion.InTextGrp() && rPortion.Width() > aCurFont.GetLeftBorderSpace() ) + rPortion.Width(rPortion.Width() - aCurFont.GetLeftBorderSpace()); + } + } + else + { + rPortion.SetJoinBorderWithPrev(false); + m_pFirstOfBorderMerge = &rPortion; + } + + // Get next portion's font + bool bSeek = false; + if (!rInf.IsFull() && // Not the last portion of the line (in case of line break) + rInf.GetIdx() + rPortion.GetLen() != TextFrameIndex(rInf.GetText().getLength())) // Not the last portion of the paragraph + { + bSeek = Seek(rInf.GetIdx() + rPortion.GetLen()); + } + // Don't join the next portion if SwKernPortion sits between two different boxes. + bool bDisconnect = rPortion.IsKernPortion() && !rPortion.GetJoinBorderWithPrev(); + // If next portion has the same border then merge + if( bSeek && GetFnt()->HasBorder() && ::lcl_HasSameBorder(aCurFont, *GetFnt()) && !bDisconnect ) + { + // In some case border merge is called twice to the portion + if( !rPortion.GetJoinBorderWithNext() ) + { + rPortion.SetJoinBorderWithNext(true); + if( rPortion.InTextGrp() && rPortion.Width() > aCurFont.GetRightBorderSpace() ) + rPortion.Width(rPortion.Width() - aCurFont.GetRightBorderSpace()); + } + } + // If this is the last portion of the merge group then make the real height merge + else + { + rPortion.SetJoinBorderWithNext(false); + if( m_pFirstOfBorderMerge != &rPortion ) + { + // Calculate maximum height and ascent + SwLinePortion* pActPor = m_pFirstOfBorderMerge; + sal_uInt16 nMaxAscent = 0; + sal_uInt16 nMaxHeight = 0; + bool bReachCurrent = false; + while( pActPor ) + { + if( nMaxHeight < pActPor->Height() ) + nMaxHeight = pActPor->Height(); + if( nMaxAscent < pActPor->GetAscent() ) + nMaxAscent = pActPor->GetAscent(); + + pActPor = pActPor->GetNextPortion(); + if( !pActPor && !bReachCurrent ) + { + pActPor = &rPortion; + bReachCurrent = true; + } + } + + // Change all portion's height and ascent + pActPor = m_pFirstOfBorderMerge; + bReachCurrent = false; + while( pActPor ) + { + if( nMaxHeight > pActPor->Height() ) + pActPor->Height(nMaxHeight); + if( nMaxAscent > pActPor->GetAscent() ) + pActPor->SetAscent(nMaxAscent); + + pActPor = pActPor->GetNextPortion(); + if( !pActPor && !bReachCurrent ) + { + pActPor = &rPortion; + bReachCurrent = true; + } + } + m_pFirstOfBorderMerge = nullptr; + } + } + Seek(rInf.GetIdx()); +} + +namespace { + // calculates and sets optimal repaint offset for the current line + tools::Long lcl_CalcOptRepaint( SwTextFormatter &rThis, + SwLineLayout const &rCurr, + TextFrameIndex const nOldLineEnd, + const std::vector &rFlyStarts ) + { + SwTextFormatInfo& txtFormatInfo = rThis.GetInfo(); + if ( txtFormatInfo.GetIdx() < txtFormatInfo.GetReformatStart() ) + // the reformat position is behind our new line, that means + // something of our text has moved to the next line + return 0; + + TextFrameIndex nReformat = std::min(txtFormatInfo.GetReformatStart(), nOldLineEnd); + + // in case we do not have any fly in our line, our repaint position + // is the changed position - 1 + if ( rFlyStarts.empty() && ! rCurr.IsFly() ) + { + // this is the maximum repaint offset determined during formatting + // for example: the beginning of the first right tab stop + // if this value is 0, this means that we do not have an upper + // limit for the repaint offset + const tools::Long nFormatRepaint = txtFormatInfo.GetPaintOfst(); + + if (nReformat < txtFormatInfo.GetLineStart() + TextFrameIndex(3)) + return 0; + + // step back two positions for smoother repaint + nReformat -= TextFrameIndex(2); + + // i#28795, i#34607, i#38388 + // step back more characters, this is required by complex scripts + // e.g., for Khmer (thank you, Javier!) + static const TextFrameIndex nMaxContext(10); + if (nReformat > txtFormatInfo.GetLineStart() + nMaxContext) + nReformat = nReformat - nMaxContext; + else + { + nReformat = txtFormatInfo.GetLineStart(); + //reset the margin flag - prevent loops + SwTextCursor::SetRightMargin(false); + } + + // Weird situation: Our line used to end with a hole portion + // and we delete some characters at the end of our line. We have + // to take care for repainting the blanks which are not anymore + // covered by the hole portion + while ( nReformat > txtFormatInfo.GetLineStart() && + CH_BLANK == txtFormatInfo.GetChar( nReformat ) ) + --nReformat; + + OSL_ENSURE( nReformat < txtFormatInfo.GetIdx(), "Reformat too small for me!" ); + SwRect aRect; + + // Note: GetChareRect is not const. It definitely changes the + // bMulti flag. We have to save and restore the old value. + bool bOldMulti = txtFormatInfo.IsMulti(); + rThis.GetCharRect( &aRect, nReformat ); + txtFormatInfo.SetMulti( bOldMulti ); + + return nFormatRepaint ? std::min( aRect.Left(), nFormatRepaint ) : + aRect.Left(); + } + else + { + // nReformat may be wrong, if something around flys has changed: + // we compare the former and the new fly positions in this line + // if anything has changed, we carefully have to adjust the right + // repaint position + tools::Long nPOfst = 0; + size_t nCnt = 0; + tools::Long nX = 0; + TextFrameIndex nIdx = rThis.GetInfo().GetLineStart(); + SwLinePortion* pPor = rCurr.GetFirstPortion(); + + while ( pPor ) + { + if ( pPor->IsFlyPortion() ) + { + // compare start of fly with former start of fly + if (nCnt < rFlyStarts.size() && + nX == rFlyStarts[ nCnt ] && + nIdx < nReformat + ) + // found fix position, nothing has changed left from nX + nPOfst = nX + pPor->Width(); + else + break; + + nCnt++; + } + nX = nX + pPor->Width(); + nIdx = nIdx + pPor->GetLen(); + pPor = pPor->GetNextPortion(); + } + + return nPOfst + rThis.GetLeftMargin(); + } + } + + // Determine if we need to build hidden portions + bool lcl_BuildHiddenPortion(const SwTextSizeInfo& rInf, TextFrameIndex & rPos) + { + // Only if hidden text should not be shown: + // if ( rInf.GetVsh() && rInf.GetVsh()->GetWin() && rInf.GetOpt().IsShowHiddenChar() ) + const bool bShowInDocView = rInf.GetVsh() && rInf.GetVsh()->GetWin() && rInf.GetOpt().IsShowHiddenChar(); + const bool bShowForPrinting = rInf.GetOpt().IsShowHiddenChar( true ) && rInf.GetOpt().IsPrinting(); + if (bShowInDocView || bShowForPrinting) + return false; + + const SwScriptInfo& rSI = rInf.GetParaPortion()->GetScriptInfo(); + TextFrameIndex nHiddenStart; + TextFrameIndex nHiddenEnd; + rSI.GetBoundsOfHiddenRange( rPos, nHiddenStart, nHiddenEnd ); + if ( nHiddenEnd ) + { + rPos = nHiddenEnd; + return true; + } + + return false; + } + + bool lcl_HasSameBorder(const SwFont& rFirst, const SwFont& rSecond) + { + return + rFirst.GetTopBorder() == rSecond.GetTopBorder() && + rFirst.GetBottomBorder() == rSecond.GetBottomBorder() && + rFirst.GetLeftBorder() == rSecond.GetLeftBorder() && + rFirst.GetRightBorder() == rSecond.GetRightBorder() && + rFirst.GetTopBorderDist() == rSecond.GetTopBorderDist() && + rFirst.GetBottomBorderDist() == rSecond.GetBottomBorderDist() && + rFirst.GetLeftBorderDist() == rSecond.GetLeftBorderDist() && + rFirst.GetRightBorderDist() == rSecond.GetRightBorderDist() && + rFirst.GetOrientation() == rSecond.GetOrientation() && + rFirst.GetShadowColor() == rSecond.GetShadowColor() && + rFirst.GetShadowWidth() == rSecond.GetShadowWidth() && + rFirst.GetShadowLocation() == rSecond.GetShadowLocation(); + } + +} //end unnamed namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/itrform2.hxx b/sw/source/core/text/itrform2.hxx new file mode 100644 index 0000000000..2d71fad34c --- /dev/null +++ b/sw/source/core/text/itrform2.hxx @@ -0,0 +1,245 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#pragma once + +#include "itrpaint.hxx" + +class SwFlyCntPortion; +class SwDropPortion; +class SwFormatDrop; +class SwTextAttr; +class SwNumberPortion; +class SwErgoSumPortion; +class SwExpandPortion; +class SwMultiPortion; +class SwFootnotePortion; + +class SwTextFormatter : public SwTextPainter +{ + const SwFormatDrop *m_pDropFormat; + SwMultiPortion* m_pMulti; // during formatting a multi-portion + sal_uInt8 m_nContentEndHyph; // Counts consecutive hyphens at the line end + sal_uInt8 m_nContentMidHyph; // Counts consecutive hyphens before flies + TextFrameIndex m_nLeftScanIdx; // for increasing performance during + TextFrameIndex m_nRightScanIdx; // scanning for portion ends + bool m_bOnceMore : 1; // Another round? + bool m_bFlyInContentBase : 1; // Base reference that sets a character-bound frame + bool m_bTruncLines : 1; // Flag for extending the repaint rect, if needed + bool m_bUnclipped : 1; // Flag whether repaint is larger than the fixed line height + std::unique_ptr m_pByEndIter; // HACK for TryNewNoLengthPortion + SwLinePortion* m_pFirstOfBorderMerge; // The first text portion of a joined border (during portion building) + + SwLinePortion *NewPortion(SwTextFormatInfo &rInf, ::std::optional); + SwTextPortion *NewTextPortion( SwTextFormatInfo &rInf ); + SwLinePortion *NewExtraPortion( SwTextFormatInfo &rInf ); + SwTabPortion *NewTabPortion( SwTextFormatInfo &rInf, bool bAuto ) const; + SwNumberPortion *NewNumberPortion( SwTextFormatInfo &rInf ) const; + SwDropPortion *NewDropPortion( SwTextFormatInfo &rInf ); + SwNumberPortion *NewFootnoteNumPortion( SwTextFormatInfo const &rInf ) const; + SwErgoSumPortion *NewErgoSumPortion( SwTextFormatInfo const &rInf ) const; + SwExpandPortion *NewFieldPortion( SwTextFormatInfo &rInf, + const SwTextAttr *pHt ) const; + SwFootnotePortion *NewFootnotePortion( SwTextFormatInfo &rInf, SwTextAttr *pHt ); + + /** + Sets a new portion for an object anchored as character + */ + SwFlyCntPortion *NewFlyCntPortion( SwTextFormatInfo &rInf, + SwTextAttr *pHt ) const; + SwLinePortion *WhichFirstPortion( SwTextFormatInfo &rInf ); + SwTextPortion *WhichTextPor( SwTextFormatInfo &rInf ) const; + SwExpandPortion * TryNewNoLengthPortion( SwTextFormatInfo const & rInfo ); + + // The center piece of formatting + void BuildPortions( SwTextFormatInfo &rInf ); + + bool BuildMultiPortion( SwTextFormatInfo &rInf, SwMultiPortion& rMulti ); + + /** + Calculation of the emulated right side. + + Determines the next object, that reaches into the rest of the line and + constructs the appropriate FlyPortion. + SwTextFly::GetFrame(const SwRect&, bool) will be needed for this. + + The right edge can be shortened by flys + */ + void CalcFlyWidth( SwTextFormatInfo &rInf ); + + // Is overloaded by SwTextFormatter because of UpdatePos + void CalcAdjustLine( SwLineLayout *pCurr ); + + // considers line spacing attributes + void CalcRealHeight( bool bNewLine = false ); + + // Transfers the data to rInf + void FeedInf( SwTextFormatInfo &rInf ) const; + + // Treats underflow situations + SwLinePortion *Underflow( SwTextFormatInfo &rInf ); + + // Calculates the ascent and the height from the fontmetric + void CalcAscent( SwTextFormatInfo &rInf, SwLinePortion *pPor ); + + // determines, if an optimized repaint rectangle is allowed + bool AllowRepaintOpt() const; + + // Is called by FormatLine + void FormatReset( SwTextFormatInfo &rInf ); + + /** + The position of the portions changes with the adjustment. + + This method updates the reference point of the anchored as character objects, + for example after adjustment change (right alignment, justified, etc.) + Mainly to correct the X position. + */ + void UpdatePos(SwLineLayout *pCurr, Point aStart, TextFrameIndex nStartIdx, + bool bAlways = false ) const; + + /** + Set all anchored as character objects to the passed BaseLine + (in Y direction). + */ + void AlignFlyInCntBase( tools::Long nBaseLine ) const; + + /** + This is called after the real height of the line has been calculated + Therefore it is possible, that more flys from below intersect with the + line, or that flys from above do not intersect with the line anymore. + We check this and return true, meaning that the line has to be + formatted again. + */ + bool ChkFlyUnderflow( SwTextFormatInfo &rInf ) const; + + // Insert portion + void InsertPortion( SwTextFormatInfo &rInf, SwLinePortion *pPor ); + + // Guess height for the DropPortion + void GuessDropHeight( const sal_uInt16 nLines ); + +public: + // Calculate the height for the DropPortion + void CalcDropHeight( const sal_uInt16 nLines ); + + // Calculates the paragraphs bottom, takes anchored objects within it into + // account which have a wrap setting of "wrap at 1st paragraph" + SwTwips CalcBottomLine() const; + + // Takes character-bound objects into account when calculating the + // repaint rect in lines with fixed line height + void CalcUnclipped( SwTwips& rTop, SwTwips& rBottom ); + + // Amongst others for DropCaps + bool CalcOnceMore(); + + void CtorInitTextFormatter( SwTextFrame *pFrame, SwTextFormatInfo *pInf ); + SwTextFormatter(SwTextFrame *pTextFrame, SwTextFormatInfo *pTextFormatInf) + : SwTextPainter(pTextFrame->GetTextNodeFirst()) + , m_bUnclipped(false) + { + CtorInitTextFormatter( pTextFrame, pTextFormatInf ); + } + virtual ~SwTextFormatter() override; + + TextFrameIndex FormatLine(TextFrameIndex nStart); + + void RecalcRealHeight(); + + // We format a line for interactive hyphenation + bool Hyphenate(SwInterHyphInfoTextFrame & rInf); + + // A special method for QuoVadis texts: + // nErgo is the page number of the ErgoSum Footnote + // At 0 it's still unclear + TextFrameIndex FormatQuoVadis(TextFrameIndex nStart); + + // The emergency break: Cancel formatting, discard line + bool IsStop() const { return GetInfo().IsStop(); } + + // The counterpart: Continue formatting at all costs + bool IsNewLine() const { return GetInfo().IsNewLine(); } + + // FormatQuick(); Refresh formatting information + bool IsQuick() const { return GetInfo().IsQuick(); } + + // Create a SwLineLayout if needed, which avoids Footnote/Fly to oscillate + void MakeDummyLine(); + + // SwTextIter functionality + void Insert( SwLineLayout *pLine ); + + // The remaining height to the page border + sal_uInt16 GetFrameRstHeight() const; + + // How wide would you be without any bounds (Flys etc.)? + SwTwips CalcFitToContent_( ); + + SwLinePortion* MakeRestPortion(const SwLineLayout* pLine, TextFrameIndex nPos); + + const SwFormatDrop *GetDropFormat() const { return m_pDropFormat; } + void ClearDropFormat() { m_pDropFormat = nullptr; } + + SwMultiPortion *GetMulti() const { return m_pMulti; } + + bool IsOnceMore() const { return m_bOnceMore; } + void SetOnceMore( bool bNew ) { m_bOnceMore = bNew; } + + bool HasTruncLines() const { return m_bTruncLines; } + void SetTruncLines( bool bNew ) { m_bTruncLines = bNew; } + + bool IsUnclipped() const { return m_bUnclipped; } + void SetUnclipped( bool bNew ) { m_bUnclipped = bNew; } + + bool IsFlyInCntBase() const { return m_bFlyInContentBase; } + void SetFlyInCntBase( bool bNew = true ) { m_bFlyInContentBase = bNew; } + + SwTextFormatInfo &GetInfo() + { return static_cast(SwTextIter::GetInfo()); } + const SwTextFormatInfo &GetInfo() const + { return static_cast(SwTextIter::GetInfo()); } + + void InitCntHyph() { CntHyphens( m_nContentEndHyph, m_nContentMidHyph ); } + const sal_uInt8 &CntEndHyph() const { return m_nContentEndHyph; } + const sal_uInt8 &CntMidHyph() const { return m_nContentMidHyph; } + sal_uInt8 &CntEndHyph() { return m_nContentEndHyph; } + sal_uInt8 &CntMidHyph() { return m_nContentMidHyph; } + + /** + * Merge border of the drop portion with modifying the font of + * the portions' part. Removing left or right border. + * @param rPortion drop portion for merge + **/ + static void MergeCharacterBorder( SwDropPortion const & rPortion ); + + /** + * Merge border of the line portion with setting the portion's + * m_bJoinBorderWidthNext and m_bJoinBorderWidthPrev members and + * changing the size (width, height and ascent) of the portion + * to get a merged border. + * @param rPortion portion for merge + * @param pPrev portion immediately before rPortion + * @param rInf contain information + **/ + void MergeCharacterBorder( SwLinePortion& rPortion, SwLinePortion const *pPrev, SwTextFormatInfo& rInf ); + + bool ClearIfIsFirstOfBorderMerge(SwLinePortion const *pPortion); +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/itrpaint.cxx b/sw/source/core/text/itrpaint.cxx new file mode 100644 index 0000000000..5b6bb1288d --- /dev/null +++ b/sw/source/core/text/itrpaint.cxx @@ -0,0 +1,807 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include "itrpaint.hxx" +#include +#include +#include "txtpaint.hxx" +#include "porfld.hxx" +#include "portab.hxx" +#include +#include +#include "redlnitr.hxx" +#include "porrst.hxx" +#include "pormulti.hxx" +#include + +// Returns, if we have an underline breaking situation +// Adding some more conditions here means you also have to change them +// in SwTextPainter::CheckSpecialUnderline +bool IsUnderlineBreak( const SwLinePortion& rPor, const SwFont& rFnt ) +{ + return LINESTYLE_NONE == rFnt.GetUnderline() || + rPor.IsFlyPortion() || rPor.IsFlyCntPortion() || + rPor.IsBreakPortion() || rPor.IsMarginPortion() || + rPor.IsHolePortion() || + ( rPor.IsMultiPortion() && ! static_cast(rPor).IsBidi() ) || + rFnt.GetEscapement() < 0 || rFnt.IsWordLineMode() || + SvxCaseMap::SmallCaps == rFnt.GetCaseMap(); +} + +static Color GetUnderColor( const SwFont *pFont ) +{ + return pFont->GetUnderColor() == COL_AUTO ? + pFont->GetColor() : pFont->GetUnderColor(); +} + +void SwTextPainter::CtorInitTextPainter( SwTextFrame *pNewFrame, SwTextPaintInfo *pNewInf ) +{ + CtorInitTextCursor( pNewFrame, pNewInf ); + m_pInf = pNewInf; + SwFont *pMyFnt = GetFnt(); + GetInfo().SetFont( pMyFnt ); + m_bPaintDrop = false; +} + +SwLinePortion *SwTextPainter::CalcPaintOfst(const SwRect &rPaint, bool& rbSkippedNumPortions) +{ + SwLinePortion *pPor = m_pCurr->GetFirstPortion(); + GetInfo().SetPaintOfst( 0 ); + SwTwips nPaintOfst = rPaint.Left(); + + // nPaintOfst was exactly set to the end, therefore <= + // nPaintOfst is document global, therefore add up nLeftMar + // const sal_uInt16 nLeftMar = sal_uInt16(GetLeftMargin()); + // 8310: paint of LineBreaks in empty lines. + if( nPaintOfst && m_pCurr->Width() ) + { + SwLinePortion *pLast = nullptr; + // 7529 and 4757: not <= nPaintOfst + while( pPor && GetInfo().X() + pPor->Width() + (pPor->Height()/2) + < nPaintOfst ) + { + if( pPor->InSpaceGrp() && GetInfo().GetSpaceAdd() ) + { + tools::Long nTmp = GetInfo().X() +pPor->Width() + + pPor->CalcSpacing( GetInfo().GetSpaceAdd(), GetInfo() ); + if( nTmp + (pPor->Height()/2) >= nPaintOfst ) + break; + GetInfo().X( nTmp ); + GetInfo().SetIdx( GetInfo().GetIdx() + pPor->GetLen() ); + } + else + pPor->Move( GetInfo() ); + if (pPor->InNumberGrp() + && !static_cast(pPor)->HasFollow()) + { + rbSkippedNumPortions = true; // all numbering portions were skipped? + } + pLast = pPor; + pPor = pPor->GetNextPortion(); + } + + // 7529: if PostIts return also pLast. + if( pLast && !pLast->Width() && pLast->IsPostItsPortion() ) + { + pPor = pLast; + GetInfo().SetIdx( GetInfo().GetIdx() - pPor->GetLen() ); + } + } + return pPor; +} + +// There are two possibilities to output transparent font: +// 1) DrawRect on the whole line and DrawText afterwards +// (objectively fast, subjectively slow) +// 2) For every portion a DrawRect with subsequent DrawText is done +// (objectively slow, subjectively fast) +// Since the user usually judges subjectively the second method is set as default. +void SwTextPainter::DrawTextLine( const SwRect &rPaint, SwSaveClip &rClip, + const bool bUnderSized, + ::std::optional & roTaggedLabel, + ::std::optional & roTaggedParagraph, + bool const isPDFTaggingEnabled) +{ +#if OSL_DEBUG_LEVEL > 1 +// sal_uInt16 nFntHeight = GetInfo().GetFont()->GetHeight( GetInfo().GetVsh(), GetInfo().GetOut() ); +// sal_uInt16 nFntAscent = GetInfo().GetFont()->GetAscent( GetInfo().GetVsh(), GetInfo().GetOut() ); +#endif + + // maybe catch-up adjustment + GetAdjusted(); + AddExtraBlankWidth(); + GetInfo().SetpSpaceAdd( m_pCurr->GetpLLSpaceAdd() ); + GetInfo().ResetSpaceIdx(); + GetInfo().SetKanaComp( m_pCurr->GetpKanaComp() ); + GetInfo().ResetKanaIdx(); + // The size of the frame + GetInfo().SetIdx( GetStart() ); + GetInfo().SetPos( GetTopLeft() ); + + const bool bDrawInWindow = GetInfo().OnWin(); + + // 6882: blank lines can't be optimized by removing them if Formatting Marks are shown + const bool bEndPor = GetInfo().GetOpt().IsParagraph() && GetInfo().GetText().isEmpty(); + + bool bSkippedNumPortions(false); + SwLinePortion *pPor = bEndPor ? m_pCurr->GetFirstPortion() : CalcPaintOfst(rPaint, bSkippedNumPortions); + + if (bSkippedNumPortions // ugly but hard to check earlier in PaintSwFrame: + && !GetInfo().GetTextFrame()->GetTextNodeForParaProps()->IsOutline()) + { // there is a num portion but it is outside of the frame area and not painted + assert(!roTaggedLabel); + assert(!roTaggedParagraph); + Frame_Info aFrameInfo(*m_pFrame, false); // open LBody + roTaggedParagraph.emplace(nullptr, &aFrameInfo, nullptr, *GetInfo().GetOut()); + } + + SwTaggedPDFHelper::EndCurrentLink(*GetInfo().GetOut()); + + // Optimization! + SwTwips nMaxRight = std::min( rPaint.Right(), Right() ); + const SwTwips nTmpLeft = GetInfo().X(); + //compatibility settings: allow tabstop text to exceed right margin + const auto& iDSA = GetInfo().GetTextFrame()->GetDoc().getIDocumentSettingAccess(); + const bool bTabOverMargin = iDSA.get(DocumentSettingId::TAB_OVER_MARGIN); + const bool bTabOverSpacing = iDSA.get(DocumentSettingId::TAB_OVER_SPACING); + if (bTabOverMargin || bTabOverSpacing) + { + SwLinePortion* pPorIter = pPor; + while( pPorIter ) + { + if( pPorIter->InTabGrp() ) + { + const SwTabPortion* pTabPor = static_cast(pPorIter); + const SwTwips nTabPos = nTmpLeft + pTabPor->GetTabPos(); + if( nMaxRight < nTabPos ) + { + nMaxRight = rPaint.Right(); + break; + } + } + pPorIter = pPorIter->GetNextPortion(); + } + } + if( !bEndPor && nTmpLeft >= nMaxRight ) + return; + + // DropCaps! + // 7538: of course for the printer, too + if( !m_bPaintDrop ) + { + // 8084: Optimization, less painting + // AMA: By 8084 7538 has been revived + // bDrawInWindow removed, so that DropCaps also can be printed + m_bPaintDrop = pPor == m_pCurr->GetFirstPortion() + && GetDropLines() >= GetLineNr(); + } + + SwTwips nTmpHeight, nTmpAscent; + CalcAscentAndHeight( nTmpAscent, nTmpHeight ); + + // bClip decides if there's a need to clip + // The whole thing must be done before retouching + + bool bClip = ( bDrawInWindow || bUnderSized ) && !rClip.IsChg(); + if( bClip && pPor ) + { + // If TopLeft or BottomLeft of the line are outside, the we must clip. + // The check for Right() is done in the output loop ... + + if( GetInfo().GetPos().X() < rPaint.Left() || + GetInfo().GetPos().Y() < rPaint.Top() || + GetInfo().GetPos().Y() + nTmpHeight > rPaint.Top() + rPaint.Height() ) + { + bClip = false; + rClip.ChgClip( rPaint, m_pFrame, m_pCurr->HasUnderscore() ); + } +#if OSL_DEBUG_LEVEL > 1 + static bool bClipAlways = false; + if( bClip && bClipAlways ) + { bClip = false; + rClip.ChgClip( rPaint ); + } +#endif + } + + // Alignment + OutputDevice* pOut = GetInfo().GetOut(); + Point aPnt1( nTmpLeft, GetInfo().GetPos().Y() ); + if ( aPnt1.X() < rPaint.Left() ) + aPnt1.setX( rPaint.Left() ); + if ( aPnt1.Y() < rPaint.Top() ) + aPnt1.setY( rPaint.Top() ); + Point aPnt2( GetInfo().GetPos().X() + nMaxRight - GetInfo().X(), + GetInfo().GetPos().Y() + nTmpHeight ); + if ( aPnt2.X() > rPaint.Right() ) + aPnt2.setX( rPaint.Right() ); + if ( aPnt2.Y() > rPaint.Bottom() ) + aPnt2.setY( rPaint.Bottom() ); + + const SwRect aLineRect( aPnt1, aPnt2 ); + + if( m_pCurr->IsClipping() ) + { + const SwTextFrame& rFrame = *GetInfo().GetTextFrame(); + // tdf#117448 at small fixed line height, enlarge clipping area in table cells + // to show previously clipped text content on the area of paragraph margins + if ( rFrame.IsInTab() ) + rClip.ChgClip( aLineRect, m_pFrame, false, rFrame.GetTopMargin(), rFrame.GetBottomMargin() ); + else + rClip.ChgClip( aLineRect, m_pFrame ); + bClip = false; + } + + if( !pPor && !bEndPor ) + return; + + // Baseline output also if non-TextPortion (compare TabPor with Fill) + // if no special vertical alignment is used, + // we calculate Y value for the whole line + SwTextGridItem const*const pGrid(GetGridItem(GetTextFrame()->FindPageFrame())); + const bool bAdjustBaseLine = + GetLineInfo().HasSpecialAlign( GetTextFrame()->IsVertical() ) || + ( nullptr != pGrid ) || m_pCurr->GetHangingBaseline(); + const SwTwips nLineBaseLine = GetInfo().GetPos().Y() + nTmpAscent; + if ( ! bAdjustBaseLine ) + GetInfo().Y( nLineBaseLine ); + + // 7529: Pre-paint post-its + if( GetInfo().OnWin() && pPor && !pPor->Width() ) + { + SeekAndChg( GetInfo() ); + + if( bAdjustBaseLine ) + { + const SwTwips nOldY = GetInfo().Y(); + + GetInfo().Y( GetInfo().GetPos().Y() + AdjustBaseLine( *m_pCurr, nullptr, + GetInfo().GetFont()->GetHeight( GetInfo().GetVsh(), *pOut ), + GetInfo().GetFont()->GetAscent( GetInfo().GetVsh(), *pOut ) + ) ); + + pPor->PrePaint( GetInfo(), pPor ); + GetInfo().Y( nOldY ); + } + else + pPor->PrePaint( GetInfo(), pPor ); + } + + // 7923: EndPortions output chars, too, that's why we change the font + if( bEndPor ) + SeekStartAndChg( GetInfo() ); + + const bool bRest = m_pCurr->IsRest(); + bool bFirst = true; + + SwArrowPortion *pArrow = nullptr; + // Reference portion for the paragraph end portion + SwLinePortion* pEndTempl = m_pCurr->GetFirstPortion(); + + while( pPor ) + { + bool bSeeked = true; + GetInfo().SetLen( pPor->GetLen() ); + + const SwTwips nOldY = GetInfo().Y(); + + if ( bAdjustBaseLine ) + { + GetInfo().Y( GetInfo().GetPos().Y() + AdjustBaseLine( *m_pCurr, pPor ) ); + + // we store the last portion, because a possible paragraph + // end character has the same font as this portion + // (only in special vertical alignment case, otherwise the first + // portion of the line is used) + if ( pPor->Width() && pPor->InTextGrp() ) + pEndTempl = pPor; + } + + // set redlining for line break symbol + if ( pPor->IsBreakPortion() && GetInfo().GetOpt().IsParagraph() && GetRedln() ) + { + SeekAndChg( GetInfo() ); + if ( m_pCurr->GetRedlineEndType() != RedlineType::None ) + static_cast(*pPor).SetRedline( m_pCurr->GetRedlineEndType() ); + } + + // A special case are GluePortions which output blanks. + + // 6168: Avoid that the rest of a FieldPortion gets the attributes of the + // next portion with SeekAndChgBefore(): + if( bRest && pPor->InFieldGrp() && !pPor->GetLen() ) + SeekAndChgBefore( GetInfo() ); + else if ( pPor->IsQuoVadisPortion() ) + { + // A remark on QuoVadis/ErgoSum: + // We use the Font set for the Paragraph for these portions. + // Thus, we initialize: + TextFrameIndex nOffset = GetInfo().GetIdx(); + SeekStartAndChg( GetInfo(), true ); + if( GetRedln() && m_pCurr->HasRedline() ) + { + std::pair const pos( + GetTextFrame()->MapViewToModel(nOffset)); + GetRedln()->Seek(*m_pFont, pos.first->GetIndex(), pos.second, 0); + } + } + else if( pPor->InTextGrp() || pPor->InFieldGrp() || pPor->InTabGrp() ) + SeekAndChg( GetInfo() ); + else if ( !bFirst && pPor->IsBreakPortion() && GetInfo().GetOpt().IsParagraph() ) + { + // Paragraph symbols should have the same font as the paragraph in front of them, + // except for the case that there's redlining in the paragraph + if( GetRedln() ) + SeekAndChg( GetInfo() ); + else + SeekAndChgBefore( GetInfo() ); + } + else + bSeeked = false; + + // bRest = false; + + // If the end of the portion juts out, it is clipped. + // A safety distance of half the height is added, so that + // TTF-"f" isn't overlapping into the page margin. + if( bClip && + GetInfo().X() + pPor->Width() + ( pPor->Height() / 2 ) > nMaxRight ) + { + bClip = false; + rClip.ChgClip( rPaint, m_pFrame, m_pCurr->HasUnderscore() ); + } + + // Portions, which lay "below" the text like post-its + SwLinePortion *pNext = pPor->GetNextPortion(); + if( GetInfo().OnWin() && pNext && !pNext->Width() ) + { + // Fix 11289: Fields were omitted here because of Last!=Owner during + // loading Brief.sdw. Now the fields are allowed again, + // by bSeeked Last!=Owner is being avoided. + if ( !bSeeked ) + SeekAndChg( GetInfo() ); + pNext->PrePaint( GetInfo(), pPor ); + } + + // We calculate a separate font for underlining. + CheckSpecialUnderline( pPor, bAdjustBaseLine ? nOldY : 0 ); + SwUnderlineFont* pUnderLineFnt = GetInfo().GetUnderFnt(); + if ( pUnderLineFnt ) + { + const Point aTmpPoint( GetInfo().X(), + bAdjustBaseLine ? + pUnderLineFnt->GetPos().Y() : + nLineBaseLine ); + pUnderLineFnt->SetPos( aTmpPoint ); + } + + // in extended input mode we do not want a common underline font. + SwUnderlineFont* pOldUnderLineFnt = nullptr; + if ( GetRedln() && GetRedln()->ExtOn() ) + { + pOldUnderLineFnt = GetInfo().GetUnderFnt(); + GetInfo().SetUnderFnt( nullptr ); + } + + // multiple numbering portions are possible :( + if ((pPor->InNumberGrp() // also footnote label + // weird special case, bullet with soft hyphen + || (pPor->InHyphGrp() && pNext && pNext->InNumberGrp())) + && !GetInfo().GetTextFrame()->GetTextNodeForParaProps()->IsOutline() + && !roTaggedLabel) // note: CalcPaintOfst may skip some portions + { + assert(isPDFTaggingEnabled); + Por_Info aPorInfo(*pPor, *this, 1); // open Lbl + roTaggedLabel.emplace(nullptr, nullptr, &aPorInfo, *pOut); + } + + { + // #i16816# tagged pdf support + Por_Info aPorInfo(*pPor, *this, 0); + SwTaggedPDFHelper aTaggedPDFHelper( nullptr, nullptr, &aPorInfo, *pOut ); + + if( pPor->IsMultiPortion() ) + PaintMultiPortion( rPaint, static_cast(*pPor) ); + else + pPor->Paint( GetInfo() ); + } + + // lazy open LBody and paragraph tag after num portions have been painted to Lbl + if (pPor->InNumberGrp() // also footnote label + // note: numbering portion may be split if it has multiple scripts + && !static_cast(pPor)->HasFollow()) // so wait for the last one + { + if (!GetInfo().GetTextFrame()->GetTextNodeForParaProps()->IsOutline()) + { + assert(roTaggedLabel); + roTaggedLabel.reset(); // close Lbl + assert(!roTaggedParagraph); + Frame_Info aFrameInfo(*m_pFrame, false); // open LBody + roTaggedParagraph.emplace(nullptr, &aFrameInfo, nullptr, *pOut); + } + else + { + assert(!roTaggedLabel); + } + } + + // reset underline font + if ( pOldUnderLineFnt ) + GetInfo().SetUnderFnt( pOldUnderLineFnt ); + + // reset (for special vertical alignment) + GetInfo().Y( nOldY ); + + bFirst &= !pPor->GetLen(); + if( pNext || !pPor->IsMarginPortion() ) + pPor->Move( GetInfo() ); + if( pPor->IsArrowPortion() && GetInfo().OnWin() && !pArrow ) + pArrow = static_cast(pPor); + + pPor = bDrawInWindow || GetInfo().X() <= nMaxRight || + // #i16816# tagged pdf support + ( GetInfo().GetVsh() && + GetInfo().GetVsh()->GetViewOptions()->IsPDFExport() && + pNext && pNext->IsHolePortion() ) ? + pNext : + nullptr; + if (!pPor && isPDFTaggingEnabled && (roTaggedLabel || !roTaggedParagraph)) + { // check if the end of the list label is off-screen + auto FindEndOfNumbering = [&](SwLinePortion const* pP) { + while (pP) + { + if (pP->InNumberGrp() + && !static_cast(pP)->HasFollow()) + { + if (roTaggedLabel) + { + roTaggedLabel.reset(); + } // else, if the numbering isn't visible at all, no Lbl + if (!GetInfo().GetTextFrame()->GetTextNodeForParaProps()->IsOutline()) + { + Frame_Info aFrameInfo(*m_pFrame, false); // open LBody + roTaggedParagraph.emplace(nullptr, &aFrameInfo, nullptr, *GetInfo().GetOut()); + } + return true; + } + pP = pP->GetNextPortion(); + } + return false; + }; + if (!FindEndOfNumbering(pNext)) // check rest of current line + { + // check lines that will be cut off + if (rPaint.Bottom() < Y() + GetLineHeight()) + { + for (SwLineLayout const* pLine = GetNext(); pLine; pLine = pLine->GetNext()) + { + if (FindEndOfNumbering(pLine->GetFirstPortion())) + { + break; + } + } + } + } + } + } + + // delete underline font + delete GetInfo().GetUnderFnt(); + GetInfo().SetUnderFnt( nullptr ); + + // paint remaining stuff + if( bDrawInWindow ) + { + // If special vertical alignment is enabled, GetInfo().Y() is the + // top of the current line. Therefore is has to be adjusted for + // the painting of the remaining stuff. We first store the old value. + const SwTwips nOldY = GetInfo().Y(); + + if( !GetNextLine() && + GetInfo().GetVsh() && !GetInfo().GetVsh()->IsPreview() && + GetInfo().GetOpt().IsParagraph() && !GetTextFrame()->GetFollow() && + GetInfo().GetIdx() >= TextFrameIndex(GetInfo().GetText().getLength())) + { + bool bHasRedlineEnd( GetRedln() && m_pCurr->HasRedlineEnd() ); + RedlineType eRedlineEnd = bHasRedlineEnd ? m_pCurr->GetRedlineEndType() : RedlineType::None; + if( bHasRedlineEnd ) + { + TextFrameIndex nOffset = GetInfo().GetIdx(); + SeekStartAndChg( GetInfo(), true ); + std::pair const pos( + GetTextFrame()->MapViewToModel(nOffset)); + GetRedln()->Seek(*m_pFont, pos.first->GetIndex(), pos.second, 0); + } + const SwTmpEndPortion aEnd( *pEndTempl, + bHasRedlineEnd && eRedlineEnd != RedlineType::Delete ? m_pFont->GetUnderline() : LINESTYLE_NONE, + bHasRedlineEnd && eRedlineEnd == RedlineType::Delete ? m_pFont->GetStrikeout() : STRIKEOUT_NONE, + bHasRedlineEnd ? m_pFont->GetColor() : COL_AUTO ); + GetFnt()->ChgPhysFnt( GetInfo().GetVsh(), *pOut ); + + if ( bAdjustBaseLine ) + GetInfo().Y( GetInfo().GetPos().Y() + + AdjustBaseLine( *m_pCurr, &aEnd ) ); + GetInfo().X( GetInfo().X() + + ( GetCurr()->IsHanging() ? GetCurr()->GetHangingMargin() : 0 ) ); + aEnd.Paint( GetInfo() ); + GetInfo().Y( nOldY ); + } + if( GetInfo().GetVsh() && !GetInfo().GetVsh()->IsPreview() ) + { + const bool bNextUndersized = + ( GetTextFrame()->GetNext() && + 0 == GetTextFrame()->GetNext()->getFramePrintArea().Height() && + GetTextFrame()->GetNext()->IsTextFrame() && + static_cast(GetTextFrame()->GetNext())->IsUndersized() ) ; + + if( bUnderSized || bNextUndersized ) + { + if ( bAdjustBaseLine ) + GetInfo().Y( GetInfo().GetPos().Y() + m_pCurr->GetAscent() ); + + // Left arrow (text overflowing) + if( pArrow ) + GetInfo().DrawRedArrow( *pArrow ); + + // GetInfo().Y() must be current baseline + SwTwips nDiff = GetInfo().Y() + nTmpHeight - nTmpAscent - GetTextFrame()->getFrameArea().Bottom(); + if( ( nDiff > 0 && + (GetEnd() < TextFrameIndex(GetInfo().GetText().getLength()) || + ( nDiff > nTmpHeight/2 && GetPrevLine() ) ) ) || + (nDiff >= 0 && bNextUndersized) ) + + { + // Right arrow (text overflowing) + SwArrowPortion aArrow( GetInfo() ); + GetInfo().DrawRedArrow( aArrow ); + } + + GetInfo().Y( nOldY ); + } + } + } + + if( m_pCurr->IsClipping() ) + rClip.ChgClip( rPaint, m_pFrame ); +} + +void SwTextPainter::CheckSpecialUnderline( const SwLinePortion* pPor, + tools::Long nAdjustBaseLine ) +{ + // Check if common underline should not be continued + if ( IsUnderlineBreak( *pPor, *m_pFont ) ) + { + // delete underline font + delete GetInfo().GetUnderFnt(); + GetInfo().SetUnderFnt( nullptr ); + return; + } + // Reuse calculated underline font as much as possible. + if (GetInfo().GetUnderFnt() && + GetInfo().GetIdx() + pPor->GetLen() <= GetInfo().GetUnderFnt()->GetEnd() + TextFrameIndex(1)) + { + SwFont &rFont = GetInfo().GetUnderFnt()->GetFont(); + const Color aColor = GetUnderColor( GetInfo().GetFont() ); + if ( GetUnderColor( &rFont ) != aColor ) + rFont.SetColor( aColor ); + return; + } + + // If current underline matches the common underline font, we continue + // to use the common underline font. + // Bug 120769:Color of underline display wrongly + if ( GetInfo().GetUnderFnt() && + GetInfo().GetUnderFnt()->GetFont().GetUnderline() == GetFnt()->GetUnderline() && + GetInfo().GetFont() && GetInfo().GetFont()->GetUnderColor() != COL_AUTO ) + return; + //Bug 120769(End) + + OSL_ENSURE( GetFnt() && LINESTYLE_NONE != GetFnt()->GetUnderline(), + "CheckSpecialUnderline without underlined font" ); + MultiSelection aUnderMulti( Range( 0, GetInfo().GetText().getLength() ) ); + const SwFont* pParaFnt = GetAttrHandler().GetFont(); + if( pParaFnt && pParaFnt->GetUnderline() == GetFnt()->GetUnderline() ) + aUnderMulti.SelectAll(); + + if (sw::MergedPara const*const pMerged = GetTextFrame()->GetMergedPara()) + { + // first, add the paragraph properties to MultiSelection - if there are + // Hints too, they will override the positions if they're added later + sal_Int32 nTmp(0); + for (auto const& e : pMerged->extents) + { + if (const SvxUnderlineItem* pItem = e.pNode->GetSwAttrSet().GetItemIfSet( + RES_CHRATR_UNDERLINE)) + { + const bool bUnderSelect(m_pFont->GetUnderline() == + pItem->GetLineStyle()); + aUnderMulti.Select(Range(nTmp, nTmp + e.nEnd - e.nStart - 1), + bUnderSelect); + } + nTmp += e.nEnd - e.nStart; + } + } + + SwTextNode const* pNode(nullptr); + sw::MergedAttrIter iter(*GetTextFrame()); + for (SwTextAttr const* pTextAttr = iter.NextAttr(&pNode); pTextAttr; + pTextAttr = iter.NextAttr(&pNode)) + { + SvxUnderlineItem const*const pItem = + CharFormat::GetItem(*pTextAttr, RES_CHRATR_UNDERLINE); + + if (pItem) + { + TextFrameIndex const nStart( + GetTextFrame()->MapModelToView(pNode, pTextAttr->GetStart())); + TextFrameIndex const nEnd( + GetTextFrame()->MapModelToView(pNode, *pTextAttr->End())); + if (nEnd > nStart) + { + const bool bUnderSelect = m_pFont->GetUnderline() == pItem->GetLineStyle(); + aUnderMulti.Select(Range(sal_Int32(nStart), sal_Int32(nEnd) - 1), + bUnderSelect); + } + } + } + + const TextFrameIndex nIndx = GetInfo().GetIdx(); + TextFrameIndex nUnderEnd(0); + const size_t nCnt = aUnderMulti.GetRangeCount(); + + // find the underline range the current portion is contained in + for( size_t i = 0; i < nCnt; ++i ) + { + const Range& rRange = aUnderMulti.GetRange( i ); + if (nUnderEnd == TextFrameIndex(rRange.Min())) + nUnderEnd = TextFrameIndex(rRange.Max()); + else if (nIndx >= TextFrameIndex(rRange.Min())) + { + nUnderEnd = TextFrameIndex(rRange.Max()); + } + else + break; + } + + if ( GetEnd() && GetEnd() <= nUnderEnd ) + nUnderEnd = GetEnd() - TextFrameIndex(1); + + // calculate the new common underline font + SwFont* pUnderlineFnt = nullptr; + Point aCommonBaseLine; + + // check, if underlining is not isolated + if (nIndx + GetInfo().GetLen() < nUnderEnd + TextFrameIndex(1)) + { + // here starts the algorithm for calculating the underline font + SwScriptInfo& rScriptInfo = GetInfo().GetParaPortion()->GetScriptInfo(); + SwAttrIter aIter(*GetInfo().GetTextFrame()->GetTextNodeFirst(), + rScriptInfo, GetTextFrame()); + + TextFrameIndex nTmpIdx = nIndx; + sal_uLong nSumWidth = 0; + sal_uLong nSumHeight = 0; + sal_uLong nBold = 0; + sal_uInt16 nMaxBaseLineOfst = 0; + int nNumberOfPortions = 0; + + while (nTmpIdx <= nUnderEnd && pPor) + { + if ( pPor->IsFlyPortion() || pPor->IsFlyCntPortion() || + pPor->IsBreakPortion() || pPor->IsMarginPortion() || + pPor->IsHolePortion() || + ( pPor->IsMultiPortion() && ! static_cast(pPor)->IsBidi() ) ) + break; + + aIter.Seek( nTmpIdx ); + if ( aIter.GetFnt()->GetEscapement() < 0 || m_pFont->IsWordLineMode() || + SvxCaseMap::SmallCaps == m_pFont->GetCaseMap() ) + break; + + if ( !aIter.GetFnt()->GetEscapement() ) + { + nSumWidth += pPor->Width(); + const sal_uLong nFontHeight = aIter.GetFnt()->GetHeight(); + + // If we do not have a common baseline we take the baseline + // and the font of the lowest portion. + if ( nAdjustBaseLine ) + { + const sal_uInt16 nTmpBaseLineOfst = AdjustBaseLine( *m_pCurr, pPor ); + if ( nMaxBaseLineOfst < nTmpBaseLineOfst ) + { + nMaxBaseLineOfst = nTmpBaseLineOfst; + nSumHeight = nFontHeight; + } + } + // in horizontal layout we build a weighted sum of the heights + else + nSumHeight += pPor->Width() * nFontHeight; + + if ( WEIGHT_NORMAL != aIter.GetFnt()->GetWeight() ) + nBold += pPor->Width(); + } + + ++nNumberOfPortions; + + nTmpIdx += pPor->GetLen(); + pPor = pPor->GetNextPortion(); + } + + // resulting height + if ( nNumberOfPortions > 1 && nSumWidth ) + { + const sal_uLong nNewFontHeight = nAdjustBaseLine ? + nSumHeight : + nSumHeight / nSumWidth; + + pUnderlineFnt = new SwFont( *GetInfo().GetFont() ); + + // font height + const SwFontScript nActual = pUnderlineFnt->GetActual(); + pUnderlineFnt->SetSize( Size( pUnderlineFnt->GetSize( nActual ).Width(), + nNewFontHeight ), nActual ); + + // font weight + if ( 2 * nBold > nSumWidth ) + pUnderlineFnt->SetWeight( WEIGHT_BOLD, nActual ); + else + pUnderlineFnt->SetWeight( WEIGHT_NORMAL, nActual ); + + // common base line + aCommonBaseLine.setY( nAdjustBaseLine + nMaxBaseLineOfst ); + } + } + + // an escaped redlined portion should also have a special underlining + if( ! pUnderlineFnt && m_pFont->GetEscapement() > 0 && GetRedln() && + GetRedln()->ChkSpecialUnderline() ) + pUnderlineFnt = new SwFont( *m_pFont ); + + delete GetInfo().GetUnderFnt(); + + if ( pUnderlineFnt ) + { + pUnderlineFnt->SetProportion( 100 ); + pUnderlineFnt->SetEscapement( 0 ); + pUnderlineFnt->SetStrikeout( STRIKEOUT_NONE ); + pUnderlineFnt->SetOverline( LINESTYLE_NONE ); + const Color aFillColor( COL_TRANSPARENT ); + pUnderlineFnt->SetFillColor( aFillColor ); + + GetInfo().SetUnderFnt( new SwUnderlineFont( *pUnderlineFnt, nUnderEnd, + aCommonBaseLine ) ); + } + else + // I'm sorry, we do not have a special underlining font for you. + GetInfo().SetUnderFnt( nullptr ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/itrpaint.hxx b/sw/source/core/text/itrpaint.hxx new file mode 100644 index 0000000000..893db371db --- /dev/null +++ b/sw/source/core/text/itrpaint.hxx @@ -0,0 +1,71 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include "itrtxt.hxx" + +#include + +class SwSaveClip; // SwTextPainter +class SwMultiPortion; +class SwTaggedPDFHelper; + +class SwTextPainter : public SwTextCursor +{ + bool m_bPaintDrop; + + SwLinePortion *CalcPaintOfst(const SwRect &rPaint, bool& rbSkippedNumPortions); + void CheckSpecialUnderline( const SwLinePortion* pPor, + tools::Long nAdjustBaseLine = 0 ); +protected: + void CtorInitTextPainter( SwTextFrame *pFrame, SwTextPaintInfo *pInf ); + explicit SwTextPainter(SwTextNode const * pTextNode) + : SwTextCursor(pTextNode) + , m_bPaintDrop(false) + { + } + +public: + SwTextPainter(SwTextFrame *pTextFrame, SwTextPaintInfo *pTextPaintInf) + : SwTextCursor(pTextFrame->GetTextNodeFirst()) + { + CtorInitTextPainter( pTextFrame, pTextPaintInf ); + } + void DrawTextLine( const SwRect &rPaint, SwSaveClip &rClip, + const bool bUnderSz, + ::std::optional & roTaggedLabel, + ::std::optional & roTaggedParagraph, + bool isPDFTaggingEnabled); + void PaintDropPortion(); + // if PaintMultiPortion is called recursively, we have to pass the + // surrounding SwBidiPortion + void PaintMultiPortion( const SwRect &rPaint, SwMultiPortion& rMulti, + const SwMultiPortion* pEnvPor = nullptr ); + void SetPaintDrop( const bool bNew ) { m_bPaintDrop = bNew; } + bool IsPaintDrop() const { return m_bPaintDrop; } + SwTextPaintInfo &GetInfo() + { return static_cast(SwTextIter::GetInfo()); } + const SwTextPaintInfo &GetInfo() const + { return static_cast(SwTextIter::GetInfo()); } +}; + +bool IsUnderlineBreak( const SwLinePortion& rPor, const SwFont& rFnt ); + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/itrtxt.cxx b/sw/source/core/text/itrtxt.cxx new file mode 100644 index 0000000000..1d1eed3e08 --- /dev/null +++ b/sw/source/core/text/itrtxt.cxx @@ -0,0 +1,465 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include +#include +#include +#include + +#include "pormulti.hxx" +#include +#include +#include "porfld.hxx" +#include "porrst.hxx" + +#include "itrtxt.hxx" +#include + +void SwTextIter::CtorInitTextIter( SwTextFrame *pNewFrame, SwTextInfo *pNewInf ) +{ + assert(pNewFrame->GetPara()); + + CtorInitAttrIter( *pNewFrame->GetTextNodeFirst(), pNewFrame->GetPara()->GetScriptInfo(), pNewFrame ); + + SwTextNode const*const pNode = pNewFrame->GetTextNodeForParaProps(); + + m_pFrame = pNewFrame; + m_pInf = pNewInf; + m_aLineInf.CtorInitLineInfo( pNode->GetSwAttrSet(), *pNode ); + m_nFrameStart = m_pFrame->getFrameArea().Pos().Y() + m_pFrame->getFramePrintArea().Pos().Y(); + SwTextIter::Init(); + + // Order is important: only execute FillRegister if GetValue!=0 + m_bRegisterOn = pNode->GetSwAttrSet().GetRegister().GetValue() + && m_pFrame->FillRegister( m_nRegStart, m_nRegDiff ); +} + +void SwTextIter::Init() +{ + m_pCurr = m_pInf->GetParaPortion(); + m_nStart = m_pInf->GetTextStart(); + m_nY = m_nFrameStart; + m_bPrev = true; + m_pPrev = nullptr; + m_nLineNr = 1; +} + +void SwTextIter::CalcAscentAndHeight( SwTwips &rAscent, SwTwips &rHeight ) const +{ + rHeight = GetLineHeight(); + rAscent = m_pCurr->GetAscent() + rHeight - m_pCurr->Height(); +} + +SwLineLayout *SwTextIter::GetPrev_() +{ + m_pPrev = nullptr; + m_bPrev = true; + SwLineLayout *pLay = m_pInf->GetParaPortion(); + if( m_pCurr == pLay ) + return nullptr; + while( pLay->GetNext() != m_pCurr ) + pLay = pLay->GetNext(); + m_pPrev = pLay; + return m_pPrev; +} + +const SwLineLayout *SwTextIter::GetPrev() +{ + if(! m_bPrev) + GetPrev_(); + return m_pPrev; +} + +const SwLineLayout *SwTextIter::Prev() +{ + if( !m_bPrev ) + GetPrev_(); + if( m_pPrev ) + { + m_bPrev = false; + m_pCurr = m_pPrev; + m_nStart = m_nStart - m_pCurr->GetLen(); + m_nY = m_nY - GetLineHeight(); + if( !m_pCurr->IsDummy() && !(--m_nLineNr) ) + ++m_nLineNr; + return m_pCurr; + } + else + return nullptr; +} + +const SwLineLayout *SwTextIter::Next() +{ + if(m_pCurr->GetNext()) + { + m_pPrev = m_pCurr; + m_bPrev = true; + m_nStart = m_nStart + m_pCurr->GetLen(); + m_nY += GetLineHeight(); + if( m_pCurr->GetLen() || ( m_nLineNr>1 && !m_pCurr->IsDummy() ) ) + ++m_nLineNr; + m_pCurr = m_pCurr->GetNext(); + return m_pCurr; + } + else + return nullptr; +} + +const SwLineLayout *SwTextIter::NextLine() +{ + const SwLineLayout *pNext = Next(); + while( pNext && pNext->IsDummy() && pNext->GetNext() ) + { + pNext = Next(); + } + return pNext; +} + +const SwLineLayout *SwTextIter::GetNextLine() const +{ + const SwLineLayout *pNext = m_pCurr->GetNext(); + while( pNext && pNext->IsDummy() && pNext->GetNext() ) + { + pNext = pNext->GetNext(); + } + return pNext; +} + +const SwLineLayout *SwTextIter::GetPrevLine() +{ + const SwLineLayout *pRoot = m_pInf->GetParaPortion(); + if( pRoot == m_pCurr ) + return nullptr; + const SwLineLayout *pLay = pRoot; + + while( pLay->GetNext() != m_pCurr ) + pLay = pLay->GetNext(); + + if( pLay->IsDummy() ) + { + const SwLineLayout *pTmp = pRoot; + pLay = pRoot->IsDummy() ? nullptr : pRoot; + while( pTmp->GetNext() != m_pCurr ) + { + if( !pTmp->IsDummy() ) + pLay = pTmp; + pTmp = pTmp->GetNext(); + } + } + + // If nothing has changed, then there are only dummy's + return pLay; +} + +const SwLineLayout *SwTextIter::PrevLine() +{ + const SwLineLayout *pMyPrev = Prev(); + if( !pMyPrev ) + return nullptr; + + const SwLineLayout *pLast = pMyPrev; + while( pMyPrev && pMyPrev->IsDummy() ) + { + pLast = pMyPrev; + pMyPrev = Prev(); + } + return pMyPrev ? pMyPrev : pLast; +} + +void SwTextIter::Bottom() +{ + while( Next() ) + { + // nothing + } +} + +void SwTextIter::CharToLine(TextFrameIndex const nChar) +{ + while( m_nStart + m_pCurr->GetLen() <= nChar && Next() ) + ; + while( m_nStart > nChar && Prev() ) + ; +} + +// 1170: takes into account ambiguities: +const SwLineLayout *SwTextCursor::CharCursorToLine(TextFrameIndex const nPosition) +{ + CharToLine( nPosition ); + if( nPosition != m_nStart ) + s_bRightMargin = false; + bool bPrevious = s_bRightMargin && m_pCurr->GetLen() && GetPrev() && + GetPrev()->GetLen(); + if (bPrevious && nPosition && CH_BREAK == GetInfo().GetChar(nPosition - TextFrameIndex(1))) + bPrevious = false; + return bPrevious ? PrevLine() : m_pCurr; +} + +SwTwips SwTextCursor::AdjustBaseLine( const SwLineLayout& rLine, + const SwLinePortion* pPor, + SwTwips nPorHeight, SwTwips nPorAscent, + const bool bAutoToCentered ) const +{ + if ( pPor ) + { + nPorHeight = pPor->Height(); + nPorAscent = pPor->GetAscent(); + } + + SwTwips nOfst = rLine.GetRealHeight() - rLine.Height(); + + SwTextGridItem const*const pGrid(GetGridItem(m_pFrame->FindPageFrame())); + + if ( pGrid && GetInfo().SnapToGrid() && pGrid->IsSquaredMode() ) + { + const sal_uInt16 nRubyHeight = pGrid->GetRubyHeight(); + const bool bRubyTop = ! pGrid->GetRubyTextBelow(); + + if ( GetInfo().IsMulti() ) + // we are inside the GetCharRect recursion for multi portions + // we center the portion in its surrounding line + nOfst = ( m_pCurr->Height() - nPorHeight ) / 2 + nPorAscent; + else + { + // We have to take care for ruby portions. + // The ruby portion is NOT centered + nOfst = nOfst + nPorAscent; + + if ( ! pPor || ! pPor->IsMultiPortion() || + ! static_cast(pPor)->IsRuby() ) + { + // Portions which are bigger than on grid distance are + // centered inside the whole line. + + //for text refactor + const sal_uInt16 nLineNet = rLine.Height() - nRubyHeight; + //const sal_uInt16 nLineNet = ( nPorHeight > nGridWidth ) ? + // rLine.Height() - nRubyHeight : + // nGridWidth; + nOfst += ( nLineNet - nPorHeight ) / 2; + if ( bRubyTop ) + nOfst += nRubyHeight; + } + } + } + else + { + switch ( GetLineInfo().GetVertAlign() ) { + case SvxParaVertAlignItem::Align::Top : + nOfst = nOfst + nPorAscent; + break; + case SvxParaVertAlignItem::Align::Center : + OSL_ENSURE( rLine.Height() >= nPorHeight, "Portion height > Line height"); + nOfst += ( rLine.Height() - nPorHeight ) / 2 + nPorAscent; + break; + case SvxParaVertAlignItem::Align::Bottom : + nOfst += rLine.Height() - nPorHeight + nPorAscent; + break; + case SvxParaVertAlignItem::Align::Automatic : + if ( bAutoToCentered || GetInfo().GetTextFrame()->IsVertical() ) + { + // Vertical text has these cases to calculate the baseline: + // - Implicitly TB and RL: the origo is the top right corner, offset is the + // ascent. + // - (Implicitly TB and) LR: the origo is the top left corner, offset is the + // descent. + // - BT and LR: the origo is the bottom left corner, offset is the ascent. + if (GetInfo().GetTextFrame()->IsVertLR() && !GetInfo().GetTextFrame()->IsVertLRBT()) + nOfst += rLine.Height() - ( rLine.Height() - nPorHeight ) / 2 - nPorAscent; + else + { + SwTwips nLineHeight = 0; + bool bHadClearingBreak = false; + if (GetInfo().GetTextFrame()->IsVertical()) + { + // Ignore the height of clearing break portions in the automatic + // alignment case. + const SwLinePortion* pLinePor = rLine.GetFirstPortion(); + while (pLinePor) + { + bool bClearingBreak = false; + if (pLinePor->IsBreakPortion()) + { + auto pBreakPortion = static_cast(pLinePor); + bClearingBreak = pBreakPortion->GetClear() != SwLineBreakClear::NONE; + if (bClearingBreak) + { + bHadClearingBreak = true; + } + } + if (!bClearingBreak && pLinePor->Height() > nLineHeight) + { + nLineHeight = pLinePor->Height(); + } + pLinePor = pLinePor->GetNextPortion(); + } + } + + if (!bHadClearingBreak) + { + nLineHeight = rLine.Height(); + } + + nOfst += ( nLineHeight - nPorHeight ) / 2 + nPorAscent; + } + break; + } + [[fallthrough]]; + case SvxParaVertAlignItem::Align::Baseline : + // base line + if (pPor && pPor->GetHangingBaseline()) + { + nOfst += rLine.GetAscent() // Romn baseline of the line. + - rLine.GetHangingBaseline() // Hanging baseline of the line. + + pPor->GetHangingBaseline(); // Romn baseline of the portion. + } + else + nOfst = nOfst + rLine.GetAscent(); + break; + } + } + + return nOfst; +} + +void SwTextIter::TwipsToLine( const SwTwips y) +{ + while( m_nY + GetLineHeight() <= y && Next() ) + ; + while( m_nY > y && Prev() ) + ; +} + +// Local helper function to check, if pCurr needs a field rest portion: +static bool lcl_NeedsFieldRest( const SwLineLayout* pCurr ) +{ + const SwLinePortion *pPor = pCurr->GetNextPortion(); + bool bRet = false; + while( pPor && !bRet ) + { + bRet = pPor->InFieldGrp() && static_cast(pPor)->HasFollow(); + if( !pPor->GetNextPortion() || !pPor->GetNextPortion()->InFieldGrp() ) + break; + pPor = pPor->GetNextPortion(); + } + return bRet; +} + +void SwTextIter::TruncLines( bool bNoteFollow ) +{ + SwLineLayout *pDel = m_pCurr->GetNext(); + TextFrameIndex const nEnd = m_nStart + m_pCurr->GetLen(); + + if( pDel ) + { + m_pCurr->SetNext( nullptr ); + if (MaybeHasHints() && bNoteFollow) + { + GetInfo().GetParaPortion()->SetFollowField( pDel->IsRest() || + lcl_NeedsFieldRest( m_pCurr ) ); + + // bug 88534: wrong positioning of flys + SwTextFrame* pFollow = GetTextFrame()->GetFollow(); + if ( pFollow && ! pFollow->IsLocked() && + nEnd == pFollow->GetOffset() ) + { + TextFrameIndex nRangeEnd = nEnd; + SwLineLayout* pLine = pDel; + + // determine range to be searched for flys anchored as characters + while ( pLine ) + { + nRangeEnd = nRangeEnd + pLine->GetLen(); + pLine = pLine->GetNext(); + } + + // examine hints in range nEnd - (nEnd + nRangeChar) + SwTextNode const* pNode(nullptr); + sw::MergedAttrIter iter(*GetTextFrame()); + for (SwTextAttr const* pHt = iter.NextAttr(&pNode); pHt; pHt = iter.NextAttr(&pNode)) + { + if( RES_TXTATR_FLYCNT == pHt->Which() ) + { + // check if hint is in our range + TextFrameIndex const nTmpPos( + GetTextFrame()->MapModelToView(pNode, pHt->GetStart())); + if ( nEnd <= nTmpPos && nTmpPos < nRangeEnd ) + pFollow->InvalidateRange_( + SwCharRange( nTmpPos, nTmpPos ) ); + } + } + } + } + delete pDel; + } + if( m_pCurr->IsDummy() && + !m_pCurr->GetLen() && + m_nStart < TextFrameIndex(GetTextFrame()->GetText().getLength())) + { + m_pCurr->SetRealHeight( 1 ); + } + if (MaybeHasHints()) + m_pFrame->RemoveFootnote( nEnd ); +} + +void SwTextIter::CntHyphens( sal_uInt8 &nEndCnt, sal_uInt8 &nMidCnt) const +{ + nEndCnt = 0; + nMidCnt = 0; + if ( m_bPrev && m_pPrev && !m_pPrev->IsEndHyph() && !m_pPrev->IsMidHyph() ) + return; + SwLineLayout *pLay = m_pInf->GetParaPortion(); + if( m_pCurr == pLay ) + return; + while( pLay != m_pCurr ) + { + if ( pLay->IsEndHyph() ) + nEndCnt++; + else + nEndCnt = 0; + if ( pLay->IsMidHyph() ) + nMidCnt++; + else + nMidCnt = 0; + pLay = pLay->GetNext(); + } +} + +// Change current output device to formatting device, this has to be done before +// formatting. +SwHookOut::SwHookOut( SwTextSizeInfo& rInfo ) : + pInf( &rInfo ), + pOut( rInfo.GetOut() ), + bOnWin( rInfo.OnWin() ) +{ + OSL_ENSURE( rInfo.GetRefDev(), "No reference device for text formatting" ); + + // set new values + rInfo.SetOut( rInfo.GetRefDev() ); + rInfo.SetOnWin( false ); +} + +SwHookOut::~SwHookOut() +{ + pInf->SetOut( pOut ); + pInf->SetOnWin( bOnWin ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/itrtxt.hxx b/sw/source/core/text/itrtxt.hxx new file mode 100644 index 0000000000..8db063d616 --- /dev/null +++ b/sw/source/core/text/itrtxt.hxx @@ -0,0 +1,341 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#pragma once + +#include +#include "itratr.hxx" +#include "inftxt.hxx" + +struct SwPosition; +struct SwCursorMoveState; +class SwMarginPortion; +class SwFlyPortion; + +class SwTextIter : public SwAttrIter +{ +protected: + SwLineInfo m_aLineInf; + SwTextFrame *m_pFrame; + SwTextInfo *m_pInf; + SwLineLayout *m_pCurr; + SwLineLayout *m_pPrev; + SwTwips m_nFrameStart; + SwTwips m_nY; + SwTwips m_nRegStart; // The register's start position (Y) + TextFrameIndex m_nStart; // Start in the text string, end = pCurr->GetLen() + sal_uInt16 m_nRegDiff; // Register's line distance + sal_Int32 m_nLineNr; // Line number + bool m_bPrev : 1; + bool m_bRegisterOn : 1; // Keep in register + bool m_bOneBlock : 1; // Justified text: Dispose single words + bool m_bLastBlock : 1; // Justified text: Also the last line + bool m_bLastCenter : 1; // Justified text: Center last line + + SwLineLayout *GetPrev_(); + + // Reset in the first line + void Init(); + void CtorInitTextIter( SwTextFrame *pFrame, SwTextInfo *pInf ); + explicit SwTextIter(SwTextNode const * pTextNode) + : SwAttrIter(pTextNode) + , m_pFrame(nullptr) + , m_pInf(nullptr) + , m_pCurr(nullptr) + , m_pPrev(nullptr) + , m_nFrameStart(0) + , m_nY(0) + , m_nRegStart(0) + , m_nStart(0) + , m_nRegDiff(0) + , m_nLineNr(0) + , m_bPrev(false) + , m_bRegisterOn(false) + , m_bOneBlock(false) + , m_bLastBlock(false) + , m_bLastCenter(false) + { + } +public: + SwTextIter(SwTextFrame *pTextFrame, SwTextInfo *pTextInf) + : SwAttrIter(pTextFrame->GetTextNodeFirst()) + , m_bOneBlock(false) + , m_bLastBlock(false) + , m_bLastCenter(false) + { + CtorInitTextIter(pTextFrame, pTextInf); + } + const SwLineLayout *GetCurr() const { return m_pCurr; } // NEVER 0! + const SwLineLayout *GetNext() const { return m_pCurr->GetNext(); } + const SwLineLayout *GetPrev(); + TextFrameIndex GetLength() const { return m_pCurr->GetLen(); } + sal_Int32 GetLineNr() const { return m_nLineNr; } + TextFrameIndex GetStart() const { return m_nStart; } + TextFrameIndex GetEnd() const { return GetStart() + GetLength(); } + SwTwips Y() const { return m_nY; } + + SwTwips RegStart() const { return m_nRegStart; } + sal_uInt16 RegDiff() const { return m_nRegDiff; } + bool IsRegisterOn() const { return m_bRegisterOn; } + + SwTextInfo &GetInfo() { return *m_pInf; } + const SwTextInfo &GetInfo() const { return *m_pInf; } + + void Top() { Init(); } + void Bottom(); + const SwLineLayout *Next(); + const SwLineLayout *Prev(); + + // Skips the FlyFrames dummy line + const SwLineLayout *NextLine(); + const SwLineLayout *PrevLine(); + const SwLineLayout *GetNextLine() const; + const SwLineLayout *GetPrevLine(); + + void CharToLine(TextFrameIndex); + void TwipsToLine(const SwTwips); + + // Truncates all after pCurr + void TruncLines( bool bNoteFollow = false ); + + SwTwips GetLineHeight() const { return m_pCurr->GetRealHeight(); } + void CalcAscentAndHeight( SwTwips &rAscent, SwTwips &rHeight ) const; + + // Lots of trouble for querying pCurr == pPara + bool IsFirstTextLine() const + { return m_nStart == GetInfo().GetTextStart() && + !( m_pCurr->IsDummy() && GetNextLine() ); } + + // Replacement for the old IsFirstLine() + bool IsParaLine() const + { return m_pCurr == m_pInf->GetParaPortion(); } + + const SwLineInfo &GetLineInfo() const { return m_aLineInf; } + SwTwips GetFirstPos() const { return m_nFrameStart; } + inline bool SeekAndChg( SwTextSizeInfo &rInf ); + inline bool SeekAndChgBefore( SwTextSizeInfo &rInf ); + inline bool SeekStartAndChg( SwTextSizeInfo &rInf, const bool bPara=false ); + + SwTextFrame *GetTextFrame() { return m_pFrame; } + const SwTextFrame *GetTextFrame() const { return m_pFrame; } + + // Counts consecutive hyphens in order to be within the boundary given by MaxHyphens + void CntHyphens( sal_uInt8 &nEndCnt, sal_uInt8 &nMidCnt) const; +}; + +class SwTextMargin : public SwTextIter +{ +private: + SwTwips mnLeft; + SwTwips mnRight; + SwTwips mnFirst; + sal_uInt16 mnDropLeft; + sal_uInt16 mnDropHeight; + sal_uInt16 mnDropDescent; + sal_uInt16 mnDropLines; + SvxAdjust mnAdjust; + // #i91133# + SwTwips mnTabLeft; + +protected: + // For FormatQuoVadis + void Right( const SwTwips nNew ) { mnRight = nNew; } + + void CtorInitTextMargin( SwTextFrame *pFrame, SwTextSizeInfo *pInf ); + explicit SwTextMargin(SwTextNode const * pTextNode) + : SwTextIter(pTextNode) + , mnLeft(0) + , mnRight(0) + , mnFirst(0) + , mnDropLeft(0) + , mnDropHeight(0) + , mnDropDescent(0) + , mnDropLines(0) + , mnAdjust(SvxAdjust::Left) + , mnTabLeft(0) + { + } +public: + SwTextMargin(SwTextFrame *pTextFrame, SwTextSizeInfo *pTextSizeInf) + : SwTextIter(pTextFrame->GetTextNodeFirst()) + { + CtorInitTextMargin( pTextFrame, pTextSizeInf ); + } + inline SwTwips GetLeftMargin() const; + inline SwTwips Left() const; + SwTwips Right() const { return mnRight; } + SwTwips FirstLeft() const { return mnFirst; } + SwTwips CurrWidth() const { return m_pCurr->PrtWidth(); } + SwTwips GetLineStart() const; + SwTwips GetLineEnd() const { return GetLineStart() + CurrWidth(); } + Point GetTopLeft() const { return Point( GetLineStart(), Y() ); } + bool IsOneBlock() const { return m_bOneBlock; } + bool IsLastBlock() const { return m_bLastBlock; } + bool IsLastCenter() const { return m_bLastCenter; } + SvxAdjust GetAdjust() const { return mnAdjust; } + sal_uInt16 GetLineWidth() const + { return sal_uInt16( Right() - GetLeftMargin() + 1 ); } + SwTwips GetLeftMin() const { return std::min(mnFirst, mnLeft); } + bool HasNegFirst() const { return mnFirst < mnLeft; } + + // #i91133# + SwTwips GetTabLeft() const + { + return mnTabLeft; + } + // DropCaps + sal_uInt16 GetDropLines() const { return mnDropLines; } + void SetDropLines( const sal_uInt16 nNew ) { mnDropLines = nNew; } + sal_uInt16 GetDropLeft() const { return mnDropLeft; } + sal_uInt16 GetDropHeight() const { return mnDropHeight; } + void SetDropHeight( const sal_uInt16 nNew ) { mnDropHeight = nNew; } + sal_uInt16 GetDropDescent() const { return mnDropDescent; } + void SetDropDescent( const sal_uInt16 nNew ) { mnDropDescent = nNew; } + void DropInit(); + + // Returns the TextPos for start and end of the current line without whitespace + // Implemented in frminf.cxx + TextFrameIndex GetTextStart() const; + TextFrameIndex GetTextEnd() const; + + SwTextSizeInfo &GetInfo() + { return static_cast(SwTextIter::GetInfo()); } + const SwTextSizeInfo &GetInfo() const + { return static_cast(SwTextIter::GetInfo()); } + +}; + +class SwTextAdjuster : public SwTextMargin +{ + // Adjusts the portion, if we have adjustment and FlyFrames + void CalcFlyAdjust( SwLineLayout *pCurr ); + + // Calls SplitGlues and CalcBlockAdjust + void FormatBlock( ); + + // Creates the glue chain for short lines + SwMarginPortion* CalcRightMargin( SwLineLayout *pCurr, SwTwips nReal = 0 ); + + // Calculate the adjustment (FlyPortions) + SwFlyPortion *CalcFlyPortion( const tools::Long nRealWidth, + const SwRect &rCurrRect ); + +protected: + explicit SwTextAdjuster(SwTextNode const * pTextNode) : SwTextMargin(pTextNode) { } + // Creates the Glues for adjusted paragraphs + void CalcNewBlock( SwLineLayout *pCurr, const SwLinePortion *pStopAt, + SwTwips nReal = 0, bool bSkipKashida = false ); + SwTwips CalcKanaAdj( SwLineLayout *pCurr ); + +public: + // Is overloaded by SwTextFormatter due to UpdatePos + void CalcAdjLine( SwLineLayout *pCurr ); + + // For adjusting afterwards + void GetAdjusted() const + { + if( m_pCurr->IsFormatAdj() ) + const_cast(this)->CalcAdjLine( m_pCurr ); + } + + // Special treatment for DropCaps + void CalcDropAdjust(); + void CalcDropRepaint(); +}; + +class SwTextCursor : public SwTextAdjuster +{ + // A small helper-class to save SwTextCursor member, manipulate them + // and to restore them + friend class SwTextCursorSave; + + // Ambiguities + static bool s_bRightMargin; + void GetCharRect_(SwRect *, TextFrameIndex, SwCursorMoveState *); +protected: + void CtorInitTextCursor( SwTextFrame *pFrame, SwTextSizeInfo *pInf ); + explicit SwTextCursor(SwTextNode const * pTextNode) : SwTextAdjuster(pTextNode) { } + void AddExtraBlankWidth(); +public: + SwTextCursor( SwTextFrame *pTextFrame, SwTextSizeInfo *pTextSizeInf ) + : SwTextAdjuster(pTextFrame->GetTextNodeFirst()) + { + CtorInitTextCursor(pTextFrame, pTextSizeInf); + } + void GetCharRect(SwRect *, TextFrameIndex, SwCursorMoveState* = nullptr, + const tools::Long nMax = 0 ); + void GetEndCharRect(SwRect *, TextFrameIndex, SwCursorMoveState* = nullptr, + const tools::Long nMax = 0 ); + TextFrameIndex GetModelPositionForViewPoint( SwPosition *pPos, const Point &rPoint, + bool bChgNode, SwCursorMoveState* = nullptr ) const; + // Respects ambiguities: For the implementation see below + const SwLineLayout *CharCursorToLine(TextFrameIndex const nPos); + + // calculates baseline for portion rPor + // bAutoToCentered indicates, if AUTOMATIC mode means CENTERED or BASELINE + SwTwips AdjustBaseLine( const SwLineLayout& rLine, const SwLinePortion* pPor, + SwTwips nPorHeight = 0, SwTwips nAscent = 0, + const bool bAutoToCentered = false ) const; + + static void SetRightMargin( const bool bNew ){ s_bRightMargin = bNew; } + static bool IsRightMargin() { return s_bRightMargin; } +}; + +// Change current output device to printer, this has to be done before +// formatting. +class SwHookOut +{ + SwTextSizeInfo* pInf; + VclPtr pOut; + bool bOnWin; +public: + explicit SwHookOut( SwTextSizeInfo& rInfo ); + ~SwHookOut(); +}; + +inline bool SwTextIter::SeekAndChg( SwTextSizeInfo &rInf ) +{ + return SeekAndChgAttrIter( rInf.GetIdx(), rInf.GetOut() ); +} + +inline bool SwTextIter::SeekAndChgBefore( SwTextSizeInfo &rInf ) +{ + if ( rInf.GetIdx() ) + return SeekAndChgAttrIter(rInf.GetIdx() - TextFrameIndex(1), rInf.GetOut()); + else + return SeekAndChgAttrIter( rInf.GetIdx(), rInf.GetOut() ); +} + +inline bool SwTextIter::SeekStartAndChg( SwTextSizeInfo &rInf, const bool bPara ) +{ + return SeekStartAndChgAttrIter( rInf.GetOut(), bPara ); +} + +inline SwTwips SwTextMargin::GetLeftMargin() const +{ + return IsFirstTextLine() ? mnFirst : Left(); +} + +inline SwTwips SwTextMargin::Left() const +{ + return (mnDropLines >= m_nLineNr && 1 != m_nLineNr) ? mnFirst + mnDropLeft : mnLeft; +} + + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/noteurl.cxx b/sw/source/core/text/noteurl.cxx new file mode 100644 index 0000000000..fa91ea252d --- /dev/null +++ b/sw/source/core/text/noteurl.cxx @@ -0,0 +1,25 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include + +// Global variable +SwNoteURL* pNoteURL = nullptr; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/pordrop.hxx b/sw/source/core/text/pordrop.hxx new file mode 100644 index 0000000000..50dd00e566 --- /dev/null +++ b/sw/source/core/text/pordrop.hxx @@ -0,0 +1,107 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#pragma once + +#include "portxt.hxx" +#include + +#include + +class SwFont; + +// DropCap cache, global variable initialized/destroyed in txtinit.cxx +// and used in txtdrop.cxx for initial calculation + +class SwDropCapCache; +extern SwDropCapCache *pDropCapCache; + +// A drop portion can consist of one or more parts in order to allow +// attribute changes inside them. +class SwDropPortionPart +{ + std::unique_ptr m_pFollow; + std::unique_ptr m_pFnt; + TextFrameIndex m_nLen; + sal_uInt16 m_nWidth; + bool m_bJoinBorderWithNext; + bool m_bJoinBorderWithPrev; + +public: + SwDropPortionPart( SwFont& rFont, const TextFrameIndex nL ) + : m_pFnt( &rFont ), m_nLen( nL ), m_nWidth( 0 ), m_bJoinBorderWithNext(false), m_bJoinBorderWithPrev(false) {}; + ~SwDropPortionPart(); + + SwDropPortionPart* GetFollow() const { return m_pFollow.get(); }; + void SetFollow( std::unique_ptr pNew ) { m_pFollow = std::move(pNew); }; + SwFont& GetFont() const { return *m_pFnt; } + TextFrameIndex GetLen() const { return m_nLen; } + sal_uInt16 GetWidth() const { return m_nWidth; } + void SetWidth( sal_uInt16 nNew ) { m_nWidth = nNew; } + + bool GetJoinBorderWithPrev() const { return m_bJoinBorderWithPrev; } + bool GetJoinBorderWithNext() const { return m_bJoinBorderWithNext; } + void SetJoinBorderWithPrev( const bool bJoinPrev ) { m_bJoinBorderWithPrev = bJoinPrev; } + void SetJoinBorderWithNext( const bool bJoinNext ) { m_bJoinBorderWithNext = bJoinNext; } +}; + +/// Text portion for the Format -> Paragraph -> Drop Caps functionality. +class SwDropPortion : public SwTextPortion +{ + friend class SwDropCapCache; + std::unique_ptr m_pPart; // due to script/attribute changes + sal_uInt16 m_nLines; // Line count + sal_uInt16 m_nDropHeight; // Height + sal_uInt16 m_nDropDescent; // Distance to the next line + sal_uInt16 m_nDistance; // Distance to the text + sal_uInt16 m_nFix; // Fixed position + short m_nY; // Y Offset + + bool FormatText( SwTextFormatInfo &rInf ); + void PaintText( const SwTextPaintInfo &rInf ) const; + +public: + SwDropPortion( const sal_uInt16 nLineCnt, + const sal_uInt16 nDropHeight, + const sal_uInt16 nDropDescent, + const sal_uInt16 nDistance ); + virtual ~SwDropPortion() override; + + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + void PaintDrop( const SwTextPaintInfo &rInf ) const; + virtual bool Format( SwTextFormatInfo &rInf ) override; + virtual SwPosSize GetTextSize( const SwTextSizeInfo &rInfo ) const override; + virtual TextFrameIndex GetModelPositionForViewPoint(sal_uInt16 nOfst) const override; + + sal_uInt16 GetLines() const { return m_nLines; } + sal_uInt16 GetDistance() const { return m_nDistance; } + sal_uInt16 GetDropHeight() const { return m_nDropHeight; } + sal_uInt16 GetDropDescent() const { return m_nDropDescent; } + sal_uInt16 GetDropLeft() const { return Width() + m_nFix; } + + SwDropPortionPart* GetPart() const { return m_pPart.get(); } + void SetPart( std::unique_ptr pNew ) { m_pPart = std::move(pNew); } + + void SetY( short nNew ) { m_nY = nNew; } + + SwFont* GetFnt() const { return m_pPart ? &m_pPart->GetFont() : nullptr; } + + static void DeleteDropCapCache(); +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/porexp.cxx b/sw/source/core/text/porexp.cxx new file mode 100644 index 0000000000..0884db6fce --- /dev/null +++ b/sw/source/core/text/porexp.cxx @@ -0,0 +1,317 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include +#include +#include "inftxt.hxx" +#include "porexp.hxx" + +TextFrameIndex SwExpandPortion::GetModelPositionForViewPoint(const sal_uInt16 nOfst) const +{ return SwLinePortion::GetModelPositionForViewPoint( nOfst ); } + +bool SwExpandPortion::GetExpText( const SwTextSizeInfo&, OUString &rText ) const +{ + rText.clear(); + // Do not do: return 0 != rText.Len(); + // Reason being: empty fields replace CH_TXTATR with an empty string + return true; +} + +void SwExpandPortion::HandlePortion( SwPortionHandler& rPH ) const +{ + rPH.Special( GetLen(), OUString(), GetWhichPor() ); +} + +void SwExpandPortion::dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, + TextFrameIndex& nOffset) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwExpandPortion")); + dumpAsXmlAttributes(pWriter, rText, nOffset); + nOffset += GetLen(); + + (void)xmlTextWriterEndElement(pWriter); +} + +SwPosSize SwExpandPortion::GetTextSize( const SwTextSizeInfo &rInf ) const +{ + SwTextSlot aDiffText( &rInf, this, false, false ); + return rInf.GetTextSize(); +} + +bool SwExpandPortion::Format( SwTextFormatInfo &rInf ) +{ + SwTextSlot aDiffText( &rInf, this, true, false ); + TextFrameIndex const nFullLen = rInf.GetLen(); + + // As odd as it may seem: the query for GetLen() must return + // false due to the ExpandPortions _after_ the aDiffText (see SoftHyphs) + // caused by the SetFull ... + if( !nFullLen ) + { + // Do not Init(), because we need height and ascent + Width(0); + return false; + } + return SwTextPortion::Format( rInf ); +} + +void SwExpandPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + rInf.DrawCSDFHighlighting(*this); // here it detects as CS and not DF + + SwTextSlot aDiffText( &rInf, this, true, true ); + const SwFont aOldFont = *rInf.GetFont(); + if( GetJoinBorderWithPrev() ) + const_cast(rInf).GetFont()->SetLeftBorder(nullptr); + if( GetJoinBorderWithNext() ) + const_cast(rInf).GetFont()->SetRightBorder(nullptr); +// rInf.DrawCSDFHighlighting(*this); // here it detects as DF and only the '/' is detected as CS + + rInf.DrawBackBrush( *this ); + rInf.DrawBorder( *this ); + + // Do we have to repaint a post it portion? + if( rInf.OnWin() && mpNextPortion && !mpNextPortion->Width() ) + mpNextPortion->PrePaint( rInf, this ); + + // The contents of field portions is not considered during the + // calculation of the directions. Therefore we let vcl handle + // the calculation by removing the BIDI_STRONG_FLAG temporarily. + SwLayoutModeModifier aLayoutModeModifier( *rInf.GetOut() ); + aLayoutModeModifier.SetAuto(); + + // ST2 + if ( rInf.GetSmartTags() || rInf.GetGrammarCheckList() ) + rInf.DrawMarkedText( *this, rInf.GetLen(), false, + nullptr != rInf.GetSmartTags(), nullptr != rInf.GetGrammarCheckList() ); + else + rInf.DrawText( *this, rInf.GetLen() ); + + if( GetJoinBorderWithPrev() || GetJoinBorderWithNext() ) + *const_cast(rInf).GetFont() = aOldFont; +} + +SwLinePortion *SwBlankPortion::Compress() { return this; } + +/** + * If a Line is full of HardBlanks and overflows, we must not generate + * underflows! + * Causes problems with Fly + */ +sal_uInt16 SwBlankPortion::MayUnderflow( const SwTextFormatInfo &rInf, + TextFrameIndex const nIdx, bool bUnderflow) +{ + if( rInf.StopUnderflow() ) + return 0; + const SwLinePortion *pPos = rInf.GetRoot(); + if( pPos->GetNextPortion() ) + pPos = pPos->GetNextPortion(); + while( pPos && pPos->IsBlankPortion() ) + pPos = pPos->GetNextPortion(); + if( !pPos || !rInf.GetIdx() || ( !pPos->GetLen() && pPos == rInf.GetRoot() ) ) + return 0; // There are just BlankPortions left + + // If a Blank is preceding us, we do not need to trigger underflow + // If a Blank is succeeding us, we do not need to pass on the underflow + if (bUnderflow + && nIdx + TextFrameIndex(1) < TextFrameIndex(rInf.GetText().getLength()) + && CH_BLANK == rInf.GetText()[sal_Int32(nIdx) + 1]) + { + return 0; + } + if( nIdx && !const_cast(rInf).GetFly() ) + { + while( pPos && !pPos->IsFlyPortion() ) + pPos = pPos->GetNextPortion(); + if( !pPos ) + { + // We check to see if there are useful line breaks, blanks or fields etc. left + // In case there still are some, no underflow + // If there are Flys, we still allow the underflow + TextFrameIndex nBlank = nIdx; + while( --nBlank > rInf.GetLineStart() ) + { + const sal_Unicode cCh = rInf.GetChar( nBlank ); + if( CH_BLANK == cCh || + (( CH_TXTATR_BREAKWORD == cCh || CH_TXTATR_INWORD == cCh ) + && rInf.HasHint( nBlank ) ) ) + break; + } + if( nBlank <= rInf.GetLineStart() ) + return 0; + } + } + if (nIdx < TextFrameIndex(2)) + return 1; + sal_Unicode const cCh(rInf.GetChar(nIdx - TextFrameIndex(1))); + if (CH_BLANK == cCh) + return 1; + if( CH_BREAK == cCh ) + return 0; + return 2; +} + +/** + * Format End of Line + */ +void SwBlankPortion::FormatEOL( SwTextFormatInfo &rInf ) +{ + sal_uInt16 nMay = MayUnderflow( rInf, rInf.GetIdx() - mnLineLength, true ); + if( !nMay ) + return; + + if( nMay > 1 ) + { + if( rInf.GetLast() == this ) + rInf.SetLast( FindPrevPortion( rInf.GetRoot() ) ); + rInf.X( rInf.X() - PrtWidth() ); + rInf.SetIdx( rInf.GetIdx() - GetLen() ); + } + Truncate(); + rInf.SetUnderflow( this ); + if( rInf.GetLast()->IsKernPortion() ) + rInf.SetUnderflow( rInf.GetLast() ); +} + +/** + * Pass on the underflows and trigger them ourselves! + */ +bool SwBlankPortion::Format( SwTextFormatInfo &rInf ) +{ + const bool bFull = rInf.IsUnderflow() || SwExpandPortion::Format( rInf ); + if( bFull && MayUnderflow( rInf, rInf.GetIdx(), rInf.IsUnderflow() ) ) + { + Truncate(); + rInf.SetUnderflow( this ); + if( rInf.GetLast()->IsKernPortion() ) + rInf.SetUnderflow( rInf.GetLast() ); + } + return bFull; +} + +void SwBlankPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + // Draw field shade (can be disabled individually) + if (!m_bMulti) // No gray background for multiportion brackets + rInf.DrawViewOpt(*this, PortionType::Blank); + SwExpandPortion::Paint(rInf); + + if (m_cChar == CHAR_HARDBLANK) + { + if (rInf.GetOpt().IsBlank()) + { + // Draw tilde or degree sign + OUString aMarker = (rInf.GetTextFrame()->GetDoc().getIDocumentSettingAccess() + .get(DocumentSettingId::USE_VARIABLE_WIDTH_NBSP) + ? u"~"_ustr + : u"°"_ustr); + + SwPosSize aMarkerSize(rInf.GetTextSize(aMarker)); + Point aPos(rInf.GetPos()); + + std::shared_ptr pPortionRect = std::make_shared(); + rInf.CalcRect(*this, pPortionRect.get()); + aPos.AdjustX((pPortionRect->Width() / 2) - (aMarkerSize.Width() / 2)); + + SwTextPaintInfo aInf(rInf, &aMarker); + aInf.SetPos(aPos); + SwTextPortion aMarkerPor; + aMarkerPor.Width(aMarkerSize.Width()); + aMarkerPor.Height(aMarkerSize.Height()); + aMarkerPor.SetAscent(GetAscent()); + + Color colorBackup = aInf.GetFont()->GetColor(); + aInf.GetFont()->SetColor(NON_PRINTING_CHARACTER_COLOR); + aInf.DrawText(aMarkerPor, TextFrameIndex(aMarker.getLength()), true); + aInf.GetFont()->SetColor(colorBackup); + } + } +} + +bool SwBlankPortion::GetExpText( const SwTextSizeInfo& rInf, OUString &rText ) const +{ + if (m_cChar == CHAR_HARDBLANK + && rInf.GetTextFrame()->GetDoc().getIDocumentSettingAccess().get( + DocumentSettingId::USE_VARIABLE_WIDTH_NBSP)) + rText = OUString(CH_BLANK); + else + rText = OUString(m_cChar); + + return true; +} + +void SwBlankPortion::HandlePortion( SwPortionHandler& rPH ) const +{ + rPH.Special( GetLen(), OUString( m_cChar ), GetWhichPor() ); +} + +void SwBlankPortion::dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, + TextFrameIndex& nOffset) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwBlankPortion")); + dumpAsXmlAttributes(pWriter, rText, nOffset); + nOffset += GetLen(); + + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("char"), + BAD_CAST(OUString(m_cChar).toUtf8().getStr())); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("multi"), + BAD_CAST(OString::boolean(m_bMulti).getStr())); + + (void)xmlTextWriterEndElement(pWriter); +} + +SwPostItsPortion::SwPostItsPortion( bool bScrpt ) + : m_bScript( bScrpt ) +{ + mnLineLength = TextFrameIndex(1); + SetWhichPor( PortionType::PostIts ); +} + +void SwPostItsPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + if( rInf.OnWin() && Width() ) + rInf.DrawPostIts( IsScript() ); +} + +sal_uInt16 SwPostItsPortion::GetViewWidth( const SwTextSizeInfo &rInf ) const +{ + // Unbelievable: PostIts are always visible + return rInf.OnWin() ? SwViewOption::GetPostItsWidth( rInf.GetOut() ) : 0; +} + +bool SwPostItsPortion::Format( SwTextFormatInfo &rInf ) +{ + const bool bRet = SwLinePortion::Format( rInf ); + // PostIts should not have an effect on line height etc. + SetAscent( 1 ); + Height( 1 ); + return bRet; +} + +bool SwPostItsPortion::GetExpText( const SwTextSizeInfo &rInf, OUString &rText ) const +{ + if( rInf.OnWin() && rInf.GetOpt().IsPostIts() ) + rText = " "; + else + rText.clear(); + return true; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/porexp.hxx b/sw/source/core/text/porexp.hxx new file mode 100644 index 0000000000..82de5b1be4 --- /dev/null +++ b/sw/source/core/text/porexp.hxx @@ -0,0 +1,78 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include "portxt.hxx" + +class SwExpandPortion : public SwTextPortion +{ +public: + SwExpandPortion() { SetWhichPor( PortionType::Expand ); } + virtual bool Format( SwTextFormatInfo &rInf ) override; + virtual TextFrameIndex GetModelPositionForViewPoint(sal_uInt16 nOfst) const override; + virtual bool GetExpText( const SwTextSizeInfo &rInf, OUString &rText ) const override; + virtual SwPosSize GetTextSize( const SwTextSizeInfo &rInfo ) const override; + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + + // Accessibility: pass information about this portion to the PortionHandler + virtual void HandlePortion( SwPortionHandler& rPH ) const override; + + void dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, + TextFrameIndex& nOffset) const override; +}; + +/// Non-breaking space or non-breaking hyphen. +class SwBlankPortion : public SwExpandPortion +{ + sal_Unicode m_cChar; + bool m_bMulti; // For multiportion brackets +public: + SwBlankPortion( sal_Unicode cCh, bool bMult = false ) + : m_cChar( cCh ), m_bMulti( bMult ) + { SetLen(TextFrameIndex(1)); SetWhichPor( PortionType::Blank ); } + + virtual SwLinePortion *Compress() override; + virtual bool GetExpText( const SwTextSizeInfo &rInf, OUString &rText ) const override; + virtual void FormatEOL( SwTextFormatInfo &rInf ) override; + virtual bool Format( SwTextFormatInfo &rInf ) override; + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + static sal_uInt16 MayUnderflow(const SwTextFormatInfo &rInf, TextFrameIndex nIdx, + bool bUnderflow ); + + // Accessibility: pass information about this portion to the PortionHandler + virtual void HandlePortion( SwPortionHandler& rPH ) const override; + + void dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, + TextFrameIndex& nOffset) const override; +}; + +class SwPostItsPortion : public SwExpandPortion +{ + bool m_bScript; +public: + explicit SwPostItsPortion( bool bScrpt ); + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + virtual bool Format( SwTextFormatInfo &rInf ) override; + virtual sal_uInt16 GetViewWidth( const SwTextSizeInfo &rInf ) const override; + virtual bool GetExpText( const SwTextSizeInfo &rInf, OUString &rText ) const override; + bool IsScript() const { return m_bScript; } +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/porfld.cxx b/sw/source/core/text/porfld.cxx new file mode 100644 index 0000000000..1a30a4ecd7 --- /dev/null +++ b/sw/source/core/text/porfld.cxx @@ -0,0 +1,1462 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "porlay.hxx" +#include "porfld.hxx" +#include "inftxt.hxx" +#include +#include +#include +#include +#include +#include +#include +#include +#include "porftn.hxx" +#include +#include +#include +#include +#include + +using namespace ::com::sun::star; + +SwLinePortion *SwFieldPortion::Compress() +{ return (GetLen() || !m_aExpand.isEmpty() || SwLinePortion::Compress()) ? this : nullptr; } + +SwFieldPortion *SwFieldPortion::Clone( const OUString &rExpand ) const +{ + std::unique_ptr pNewFnt; + if( m_pFont ) + { + pNewFnt.reset(new SwFont( *m_pFont )); + } + // #i107143# + // pass placeholder property to created instance. + SwFieldPortion* pClone = new SwFieldPortion(rExpand, std::move(pNewFnt)); + pClone->SetNextOffset( m_nNextOffset ); + pClone->m_bNoLength = m_bNoLength; + return pClone; +} + +void SwFieldPortion::TakeNextOffset( const SwFieldPortion* pField ) +{ + OSL_ENSURE( pField, "TakeNextOffset: Missing Source" ); + m_nNextOffset = pField->GetNextOffset(); + m_aExpand = m_aExpand.replaceAt(0, sal_Int32(m_nNextOffset), u""); + m_bFollow = true; +} + +SwFieldPortion::SwFieldPortion(OUString aExpand, std::unique_ptr pFont, TextFrameIndex const nFieldLen) + : m_aExpand(std::move(aExpand)), m_pFont(std::move(pFont)), m_nNextOffset(0) + , m_nNextScriptChg(COMPLETE_STRING), m_nFieldLen(nFieldLen), m_nViewWidth(0) + , m_bFollow( false ), m_bLeft( false), m_bHide( false) + , m_bCenter (false), m_bHasFollow( false ) + , m_bAnimated( false), m_bNoPaint( false) + , m_bReplace(false) + , m_bNoLength( false ) +{ + SetWhichPor( PortionType::Field ); +} + +SwFieldPortion::SwFieldPortion( const SwFieldPortion& rField ) + : SwExpandPortion( rField ) + , m_aExpand( rField.GetExp() ) + , m_nNextOffset( rField.GetNextOffset() ) + , m_nNextScriptChg( rField.m_nNextScriptChg ) + , m_nFieldLen(rField.m_nFieldLen) + , m_nViewWidth( rField.m_nViewWidth ) + , m_bFollow( rField.IsFollow() ) + , m_bLeft( rField.IsLeft() ) + , m_bHide( rField.IsHide() ) + , m_bCenter( rField.IsCenter() ) + , m_bHasFollow( rField.HasFollow() ) + , m_bAnimated ( rField.m_bAnimated ) + , m_bNoPaint( rField.m_bNoPaint) + , m_bReplace( rField.m_bReplace ) + , m_bNoLength( rField.m_bNoLength ) +{ + if ( rField.HasFont() ) + m_pFont.reset( new SwFont( *rField.GetFont() ) ); + + SetWhichPor( PortionType::Field ); +} + +SwFieldPortion::~SwFieldPortion() +{ + m_pFont.reset(); +} + +sal_uInt16 SwFieldPortion::GetViewWidth( const SwTextSizeInfo &rInf ) const +{ + // even though this is const, nViewWidth should be computed at the very end: + SwFieldPortion* pThis = const_cast(this); + if( !Width() && rInf.OnWin() && !rInf.GetOpt().IsPagePreview() && + !rInf.GetOpt().IsReadonly() && rInf.GetOpt().IsFieldShadings() ) + { + if( !m_nViewWidth ) + pThis->m_nViewWidth = rInf.GetTextSize(OUString(' ')).Width(); + } + else + pThis->m_nViewWidth = 0; + return m_nViewWidth; +} + +namespace { + +/** + * Never just use SetLen(0) + */ +class SwFieldSlot +{ + std::shared_ptr m_pOldCachedVclData; + const OUString *pOldText; + OUString aText; + TextFrameIndex nIdx; + TextFrameIndex nLen; + sal_Unicode nOrigHookChar; + SwTextFormatInfo *pInf; + bool bOn; +public: + SwFieldSlot( const SwTextFormatInfo* pNew, const SwFieldPortion *pPor ); + ~SwFieldSlot(); +}; + +} + +SwFieldSlot::SwFieldSlot( const SwTextFormatInfo* pNew, const SwFieldPortion *pPor ) + : pOldText(nullptr) + , nIdx(0) + , nLen(0) + , nOrigHookChar(0) + , pInf(nullptr) +{ + bOn = pPor->GetExpText( *pNew, aText ); + + // The text will be replaced ... + if( !bOn ) + return; + + pInf = const_cast(pNew); + nIdx = pInf->GetIdx(); + nLen = pInf->GetLen(); + pOldText = &(pInf->GetText()); + nOrigHookChar = pInf->GetHookChar(); + m_pOldCachedVclData = pInf->GetCachedVclData(); + pInf->SetLen(TextFrameIndex(aText.getLength())); + pInf->SetCachedVclData(nullptr); + if( pPor->IsFollow() ) + { + pInf->SetFakeLineStart( nIdx > pInf->GetLineStart() ); + pInf->SetIdx(TextFrameIndex(0)); + } + else + { + TextFrameIndex nEnd(pOldText->getLength()); + if (nIdx < nEnd) + { + sal_Int32 const nFieldLen(pPor->GetFieldLen()); + aText = (*pOldText).replaceAt(sal_Int32(nIdx), nFieldLen, aText); + } + else if (nIdx == nEnd) + aText = *pOldText + aText; + else + SAL_WARN("sw.core", "SwFieldSlot bad SwFieldPortion index."); + } + pInf->SetText( aText ); +} + +SwFieldSlot::~SwFieldSlot() +{ + if( bOn ) + { + pInf->SetCachedVclData(m_pOldCachedVclData); + pInf->SetText( *pOldText ); + // ofz#64109 at last for ruby-text when we restore the original text to + // continue laying out the 'body' text of the ruby, then a tab or other + // 'hook char' in the text drawn above it shouldn't affect the 'body' + // While there are other cases, such as tdf#148360, where the tab in an + // inline expanded field, that should affect the body. + if (pInf->IsRuby()) + pInf->SetHookChar(nOrigHookChar); + pInf->SetIdx( nIdx ); + pInf->SetLen( nLen ); + pInf->SetFakeLineStart( false ); + } +} + +void SwFieldPortion::CheckScript( const SwTextSizeInfo &rInf ) +{ + OUString aText; + if (!GetExpText(rInf, aText) || aText.isEmpty()) + return; + + SwFontScript nActual = m_pFont ? m_pFont->GetActual() : rInf.GetFont()->GetActual(); + sal_uInt16 nScript = g_pBreakIt->GetBreakIter()->getScriptType( aText, 0 ); + sal_Int32 nChg = 0; + if( i18n::ScriptType::WEAK == nScript ) + { + nChg = g_pBreakIt->GetBreakIter()->endOfScript(aText,0,nScript); + if (nChg < aText.getLength() && nChg >= 0) + nScript = g_pBreakIt->GetBreakIter()->getScriptType( aText, nChg ); + } + + // nNextScriptChg will be evaluated during SwFieldPortion::Format() + + if (nChg < aText.getLength() && nChg >= 0) + m_nNextScriptChg = TextFrameIndex( + g_pBreakIt->GetBreakIter()->endOfScript(aText, nChg, nScript)); + else + m_nNextScriptChg = TextFrameIndex(aText.getLength()); + + SwFontScript nTmp; + switch ( nScript ) { + case i18n::ScriptType::LATIN : nTmp = SwFontScript::Latin; break; + case i18n::ScriptType::ASIAN : nTmp = SwFontScript::CJK; break; + case i18n::ScriptType::COMPLEX : nTmp = SwFontScript::CTL; break; + default: nTmp = nActual; + } + + // #i16354# Change script type for RTL text to CTL. + const SwScriptInfo& rSI = rInf.GetParaPortion()->GetScriptInfo(); + // #i98418# + const sal_uInt8 nFieldDir = (IsNumberPortion() || IsFootnoteNumPortion()) + ? rSI.GetDefaultDir() + : rSI.DirType(IsFollow() ? rInf.GetIdx() - m_nFieldLen : rInf.GetIdx()); + + { + UErrorCode nError = U_ZERO_ERROR; + UBiDi* pBidi = ubidi_openSized( aText.getLength(), 0, &nError ); + ubidi_setPara( pBidi, reinterpret_cast(aText.getStr()), aText.getLength(), nFieldDir, nullptr, &nError ); + int32_t nEnd; + UBiDiLevel nCurrDir; + ubidi_getLogicalRun( pBidi, 0, &nEnd, &nCurrDir ); + ubidi_close( pBidi ); + const TextFrameIndex nNextDirChg(nEnd); + m_nNextScriptChg = std::min( m_nNextScriptChg, nNextDirChg ); + + // #i89825# change the script type also to CTL + // if there is no strong LTR char in the LTR run (numbers) + if (nCurrDir != UBIDI_RTL && + (UBIDI_LTR != nFieldDir || i18n::ScriptType::COMPLEX == nScript)) + { + nCurrDir = UBIDI_RTL; + for( sal_Int32 nCharIdx = 0; nCharIdx < nEnd; ++nCharIdx ) + { + UCharDirection nCharDir = u_charDirection ( aText[ nCharIdx ]); + if ( nCharDir == U_LEFT_TO_RIGHT || + nCharDir == U_LEFT_TO_RIGHT_EMBEDDING || + nCharDir == U_LEFT_TO_RIGHT_OVERRIDE ) + { + nCurrDir = UBIDI_LTR; + break; + } + } + } + + if (nCurrDir == UBIDI_RTL) + { + nTmp = SwFontScript::CTL; + // If we decided that this range was RTL after all and the + // previous range was complex but clipped to the start of this + // range, then extend it to be complex over the additional RTL range + if (nScript == i18n::ScriptType::COMPLEX) + m_nNextScriptChg = nNextDirChg; + } + } + + // #i98418# + // keep determined script type for footnote portions as preferred script type. + // For footnote portions a font can not be created directly - see footnote + // portion format method. + if ( IsFootnotePortion() ) + { + static_cast(this)->SetPreferredScriptType( nTmp ); + } + else if ( nTmp != nActual ) + { + if( !m_pFont ) + m_pFont.reset( new SwFont( *rInf.GetFont() ) ); + m_pFont->SetActual( nTmp ); + } + +} + +bool SwFieldPortion::Format( SwTextFormatInfo &rInf ) +{ + // Scope wegen aDiffText::DTOR! + bool bFull = false; + bool bEOL = false; + TextFrameIndex const nTextRest = TextFrameIndex(rInf.GetText().getLength()) - rInf.GetIdx(); + { + TextFrameIndex nRest; + SwFieldSlot aDiffText( &rInf, this ); + SwLayoutModeModifier aLayoutModeModifier( *rInf.GetOut() ); + aLayoutModeModifier.SetAuto(); + + // Field portion has to be split in several parts if + // 1. There are script/direction changes inside the field + // 2. There are portion breaks (tab, break) inside the field: + const TextFrameIndex nOldFullLen = rInf.GetLen(); + TextFrameIndex nFullLen = rInf.ScanPortionEnd(rInf.GetIdx(), rInf.GetIdx() + nOldFullLen) - rInf.GetIdx(); + if ( m_nNextScriptChg < nFullLen ) + { + nFullLen = m_nNextScriptChg; + rInf.SetHookChar( 0 ); + } + rInf.SetLen( nFullLen ); + + if (TextFrameIndex(COMPLETE_STRING) != rInf.GetUnderScorePos() && + rInf.GetUnderScorePos() > rInf.GetIdx() ) + rInf.SetUnderScorePos( rInf.GetIdx() ); + + if( m_pFont ) + m_pFont->AllocFontCacheId( rInf.GetVsh(), m_pFont->GetActual() ); + + SwFontSave aSave( rInf, m_pFont.get() ); + + // Length must be 0: the length is set for bFull after format + // and passed along in nRest. Or else the old length would be + // retained and be used for nRest! + SetLen(TextFrameIndex(0)); + TextFrameIndex const nFollow(IsFollow() ? TextFrameIndex(0) : m_nFieldLen); + + // As odd is may seem: the query for GetLen() must return false due + // to the ExpandPortions _after_ aDiffText (see SoftHyphs), caused + // by SetFull. + if( !nFullLen ) + { + // Don't Init(), as we need height and ascent + Width(0); + bFull = rInf.Width() <= rInf.GetPos().X(); + } + else + { + TextFrameIndex const nOldLineStart = rInf.GetLineStart(); + if( IsFollow() ) + rInf.SetLineStart(TextFrameIndex(0)); + rInf.SetNotEOL( nFullLen == nOldFullLen && nTextRest > nFollow ); + + // the height depending on the fields font is set, + // this is required for SwTextGuess::Guess + Height( rInf.GetTextHeight() + rInf.GetFont()->GetTopBorderSpace() + + rInf.GetFont()->GetBottomBorderSpace() ); + // If a kerning portion is inserted after our field portion, + // the ascent and height must be known + SetAscent( rInf.GetAscent() + rInf.GetFont()->GetTopBorderSpace() ); + bFull = SwTextPortion::Format( rInf ); + rInf.SetNotEOL( false ); + rInf.SetLineStart( nOldLineStart ); + } + TextFrameIndex const nTmpLen = GetLen(); + bEOL = !nTmpLen && nFollow && bFull; + nRest = nOldFullLen - nTmpLen; + + // The char is held in the first position + // Unconditionally after format! + SetLen( m_bNoLength ? TextFrameIndex(0) : nFollow ); + + if( nRest ) + { + // aExpand has not yet been shortened; the new Ofst is a + // result of nRest + TextFrameIndex nNextOfst = TextFrameIndex(m_aExpand.getLength()) - nRest; + + if ( IsQuoVadisPortion() ) + nNextOfst = nNextOfst + TextFrameIndex(static_cast(this)->GetContText().getLength()); + + OUString aNew( m_aExpand.copy(sal_Int32(nNextOfst)) ); + m_aExpand = m_aExpand.copy(0, sal_Int32(nNextOfst)); + + // These characters should not be contained in the follow + // field portion. They are handled via the HookChar mechanism. + const sal_Unicode nNew = !aNew.isEmpty() ? aNew[0] : 0; + auto IsHook = [](const sal_Unicode cNew) -> bool + { + switch (cNew) + { + case CH_BREAK: + case CH_TAB: + case CHAR_HARDHYPHEN: // non-breaking hyphen + case CHAR_SOFTHYPHEN: + case CHAR_HARDBLANK: + case CHAR_ZWSP: + case CHAR_WJ: + case CH_TXTATR_BREAKWORD: + case CH_TXTATR_INWORD: + { + return true; + } + default: + return false; + } + }; + if (IsHook(nNew)) + { + if (nNew == CH_BREAK) + { + bFull = true; + } + aNew = aNew.copy(1); + ++nNextOfst; + } + + // Even if there is no more text left for a follow field, + // we have to build a follow field portion (without font), + // otherwise the HookChar mechanism would not work. + SwFieldPortion *pField = Clone( aNew ); + if( !aNew.isEmpty() && !pField->GetFont() ) + { + pField->SetFont( std::make_unique( *rInf.GetFont() ) ); + } + if (IsFollow() || Compress()) + { // empty this will be deleted in SwLineLayout::CalcLine() + // anyway so make sure pField doesn't have a stale flag + pField->SetFollow( true ); + } + if (pField->Compress() && !std::all_of(std::u16string_view(aNew).begin(), + std::u16string_view(aNew).end(), IsHook)) + { // empty pField will be deleted in SwLineLayout::CalcLine() + // anyway so make sure this one doesn't have a stale flag + SetHasFollow( true ); + } + + // For a newly created field, nNextOffset contains the Offset + // of its start of the original string + // If a FollowField is created when formatting, this FollowField's + // Offset is being held in nNextOffset + m_nNextOffset = m_nNextOffset + nNextOfst; + pField->SetNextOffset( m_nNextOffset ); + rInf.SetRest( pField ); + } + } + + if( bEOL && rInf.GetLast() && !rInf.GetUnderflow() ) + rInf.GetLast()->FormatEOL( rInf ); + return bFull; +} + +void SwFieldPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + SwFontSave aSave( rInf, m_pFont.get() ); + +// OSL_ENSURE(GetLen() <= TextFrameIndex(1), "SwFieldPortion::Paint: rest-portion pollution?"); + if (Width() && !m_bContentControl) + { + // A very liberal use of the background + rInf.DrawViewOpt( *this, PortionType::Field ); + SwExpandPortion::Paint( rInf ); + } +} + +bool SwFieldPortion::GetExpText( const SwTextSizeInfo &rInf, OUString &rText ) const +{ + rText = m_aExpand; + if( rText.isEmpty() && rInf.OnWin() && + !rInf.GetOpt().IsPagePreview() && !rInf.GetOpt().IsReadonly() && + rInf.GetOpt().IsFieldShadings() && + !HasFollow() ) + rText = " "; + return true; +} + +void SwFieldPortion::HandlePortion( SwPortionHandler& rPH ) const +{ + rPH.Special( GetLen(), m_aExpand, GetWhichPor() ); +} + +void SwFieldPortion::dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, + TextFrameIndex& nOffset) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwFieldPortion")); + dumpAsXmlAttributes(pWriter, rText, nOffset); + nOffset += GetLen(); + + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("expand"), BAD_CAST(m_aExpand.toUtf8().getStr())); + + if (m_pFont) + { + m_pFont->dumpAsXml(pWriter); + } + + (void)xmlTextWriterEndElement(pWriter); +} + +SwPosSize SwFieldPortion::GetTextSize( const SwTextSizeInfo &rInf ) const +{ + SwFontSave aSave( rInf, m_pFont.get() ); + SwPosSize aSize( SwExpandPortion::GetTextSize( rInf ) ); + return aSize; +} + +SwFieldPortion *SwHiddenPortion::Clone(const OUString &rExpand ) const +{ + std::unique_ptr pNewFnt; + if( m_pFont ) + pNewFnt.reset(new SwFont( *m_pFont )); + return new SwHiddenPortion( rExpand, std::move(pNewFnt) ); +} + +void SwHiddenPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + if( Width() ) + { + SwFontSave aSave( rInf, m_pFont.get() ); + rInf.DrawViewOpt( *this, PortionType::Hidden ); + SwExpandPortion::Paint( rInf ); + } +} + +bool SwHiddenPortion::GetExpText( const SwTextSizeInfo &rInf, OUString &rText ) const +{ + // Do not query for IsHidden()! + return SwFieldPortion::GetExpText( rInf, rText ); +} + +SwNumberPortion::SwNumberPortion( const OUString &rExpand, + std::unique_ptr pFont, + const bool bLft, + const bool bCntr, + const sal_uInt16 nMinDst, + const bool bLabelAlignmentPosAndSpaceModeActive ) + : SwFieldPortion(rExpand, std::move(pFont), TextFrameIndex(0)) + , m_nFixWidth(0) + , m_nMinDist(nMinDst) + , mbLabelAlignmentPosAndSpaceModeActive(bLabelAlignmentPosAndSpaceModeActive) +{ + SetWhichPor( PortionType::Number ); + SetLeft( bLft ); + SetHide( false ); + SetCenter( bCntr ); +} + +TextFrameIndex SwNumberPortion::GetModelPositionForViewPoint(const sal_uInt16) const +{ + return TextFrameIndex(0); +} + +SwFieldPortion *SwNumberPortion::Clone( const OUString &rExpand ) const +{ + std::unique_ptr pNewFnt; + if( m_pFont ) + pNewFnt.reset(new SwFont( *m_pFont )); + + return new SwNumberPortion( rExpand, std::move(pNewFnt), IsLeft(), IsCenter(), + m_nMinDist, mbLabelAlignmentPosAndSpaceModeActive ); +} + +/** + * We can create multiple NumFields + * Tricky, if one enters enough previous-text in the dialog box + * to cause the line to overflow + * We need to keep the Fly's evasion tactics in mind + */ +bool SwNumberPortion::Format( SwTextFormatInfo &rInf ) +{ + SetHide( false ); + const bool bFull = SwFieldPortion::Format( rInf ); + SetLen(TextFrameIndex(0)); + // a numbering portion can be contained in a rotated portion!!! + m_nFixWidth = rInf.IsMulti() ? Height() : Width(); + rInf.SetNumDone( !rInf.GetRest() ); + if( rInf.IsNumDone() ) + { +// SetAscent( rInf.GetAscent() ); + OSL_ENSURE( Height() && mnAscent, "NumberPortions without Height | Ascent" ); + + tools::Long nDiff( 0 ); + + if ( !mbLabelAlignmentPosAndSpaceModeActive ) + { + if (!rInf.GetTextFrame()->GetDoc().getIDocumentSettingAccess().get(DocumentSettingId::IGNORE_FIRST_LINE_INDENT_IN_NUMBERING) && + // #i32902# + !IsFootnoteNumPortion() ) + { + nDiff = rInf.Left() + + rInf.GetTextFrame()->GetTextNodeForParaProps()-> + GetSwAttrSet().GetFirstLineIndent().GetTextFirstLineOffset() + - rInf.First() + + rInf.ForcedLeftMargin(); + } + else + { + nDiff = rInf.Left() - rInf.First() + rInf.ForcedLeftMargin(); + } + } + // The text part of the numbering should always at least + // start at the left margin + if( nDiff < 0 ) + nDiff = 0; + else if ( nDiff > rInf.X() ) + nDiff -= rInf.X(); + else + nDiff = 0; + + if( nDiff < m_nFixWidth + m_nMinDist ) + nDiff = m_nFixWidth + m_nMinDist; + + // Numbering evades the Fly, no nDiff in the second round + // Tricky special case: FlyFrame is in an Area we're just about to + // acquire + // The NumberPortion is marked as hidden + const bool bFly = rInf.GetFly() || + ( rInf.GetLast() && rInf.GetLast()->IsFlyPortion() ); + if( nDiff > rInf.Width() ) + { + nDiff = rInf.Width(); + if ( bFly ) + SetHide( true ); + } + + // A numbering portion can be inside a SwRotatedPortion. Then the + // Height has to be changed + if ( rInf.IsMulti() ) + { + if ( Height() < nDiff ) + Height( nDiff ); + } + else if( Width() < nDiff ) + Width( nDiff ); + } + return bFull; +} + + +/** + * A FormatEOL indicates that the subsequent text did not fit onto + * the line anymore. In order for the Numbering to follow through, + * we hide this NumberPortion + */ +void SwNumberPortion::FormatEOL( SwTextFormatInfo& ) +{ + + // This caused trouble with flys anchored as characters. + // If one of these is numbered but does not fit to the line, + // it calls this function, causing a loop because both the number + // portion and the fly portion go to the next line +// SetHide( true ); +} + + +/** + * A hidden NumberPortion is not displayed, unless there are TextPortions in + * this line or there's just one line at all + */ +void SwNumberPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + if ( IsHide() && rInf.GetParaPortion() && rInf.GetParaPortion()->GetNext() ) + { + SwLinePortion *pTmp = GetNextPortion(); + while ( pTmp && !pTmp->InTextGrp() ) + pTmp = pTmp->GetNextPortion(); + if ( !pTmp ) + return; + } + + // calculate the width of the number portion, including follows + const sal_uInt16 nOldWidth = Width(); + sal_uInt16 nSumWidth = 0; + sal_uInt16 nOffset = 0; + + const SwLinePortion* pTmp = this; + while ( pTmp && pTmp->InNumberGrp() ) + { + nSumWidth = nSumWidth + pTmp->Width(); + if ( static_cast(pTmp)->HasFollow() ) + pTmp = pTmp->GetNextPortion(); + else + { + nOffset = pTmp->Width() - static_cast(pTmp)->m_nFixWidth; + break; + } + } + + // The master portion takes care for painting the background of the + // follow field portions + if ( ! IsFollow() ) + { + SwNumberPortion *pThis = const_cast(this); + pThis->Width( nSumWidth ); + rInf.DrawViewOpt( *this, PortionType::Number ); + pThis->Width( nOldWidth ); + } + + if( m_aExpand.isEmpty() ) + return; + + const SwFont *pTmpFnt = rInf.GetFont(); + bool bPaintSpace = ( LINESTYLE_NONE != pTmpFnt->GetUnderline() || + LINESTYLE_NONE != pTmpFnt->GetOverline() || + STRIKEOUT_NONE != pTmpFnt->GetStrikeout() ) && + !pTmpFnt->IsWordLineMode(); + if( bPaintSpace && m_pFont ) + bPaintSpace = ( LINESTYLE_NONE != m_pFont->GetUnderline() || + LINESTYLE_NONE != m_pFont->GetOverline() || + STRIKEOUT_NONE != m_pFont->GetStrikeout() ) && + !m_pFont->IsWordLineMode(); + + SwFontSave aSave( rInf, m_pFont.get() ); + + if( m_nFixWidth == Width() && ! HasFollow() ) + SwExpandPortion::Paint( rInf ); + else + { + // logical const: reset width + SwNumberPortion *pThis = const_cast(this); + bPaintSpace = bPaintSpace && m_nFixWidth < nOldWidth; + sal_uInt16 nSpaceOffs = m_nFixWidth; + pThis->Width( m_nFixWidth ); + + if( ( IsLeft() && ! rInf.GetTextFrame()->IsRightToLeft() ) || + ( ! IsLeft() && ! IsCenter() && rInf.GetTextFrame()->IsRightToLeft() ) ) + SwExpandPortion::Paint( rInf ); + else + { + SwTextPaintInfo aInf( rInf ); + if( nOffset < m_nMinDist ) + nOffset = 0; + else + { + if( IsCenter() ) + { + /* #110778# a / 2 * 2 == a is not a tautology */ + sal_uInt16 nTmpOffset = nOffset; + nOffset /= 2; + if( nOffset < m_nMinDist ) + nOffset = nTmpOffset - m_nMinDist; + } + else + nOffset = nOffset - m_nMinDist; + } + aInf.X( aInf.X() + nOffset ); + SwExpandPortion::Paint( aInf ); + if( bPaintSpace ) + nSpaceOffs = nSpaceOffs + nOffset; + } + if( bPaintSpace && nOldWidth > nSpaceOffs ) + { + SwTextPaintInfo aInf( rInf ); + aInf.X( aInf.X() + nSpaceOffs ); + + // #i53199# Adjust position of underline: + if ( rInf.GetUnderFnt() ) + { + const Point aNewPos( aInf.GetPos().X(), rInf.GetUnderFnt()->GetPos().Y() ); + rInf.GetUnderFnt()->SetPos( aNewPos ); + } + + pThis->Width( nOldWidth - nSpaceOffs + 12 ); + { + SwTextSlot aDiffText( &aInf, this, true, false, " " ); + aInf.DrawText( *this, aInf.GetLen(), true ); + } + } + pThis->Width( nOldWidth ); + } +} + +SwBulletPortion::SwBulletPortion( const sal_UCS4 cBullet, + std::u16string_view rBulletFollowedBy, + std::unique_ptr pFont, + const bool bLft, + const bool bCntr, + const sal_uInt16 nMinDst, + const bool bLabelAlignmentPosAndSpaceModeActive ) + : SwNumberPortion( OUString(&cBullet, 1) + rBulletFollowedBy, + std::move(pFont), bLft, bCntr, nMinDst, + bLabelAlignmentPosAndSpaceModeActive ) +{ + SetWhichPor( PortionType::Bullet ); +} + +#define GRFNUM_SECURE 10 + +SwGrfNumPortion::SwGrfNumPortion( + const OUString& rGraphicFollowedBy, + const SvxBrushItem* pGrfBrush, OUString const & referer, + const SwFormatVertOrient* pGrfOrient, const Size& rGrfSize, + const bool bLft, const bool bCntr, const sal_uInt16 nMinDst, + const bool bLabelAlignmentPosAndSpaceModeActive ) : + SwNumberPortion( rGraphicFollowedBy, nullptr, bLft, bCntr, nMinDst, + bLabelAlignmentPosAndSpaceModeActive ), + m_pBrush( new SvxBrushItem(RES_BACKGROUND) ), m_nId( 0 ) +{ + SetWhichPor( PortionType::GrfNum ); + SetAnimated( false ); + m_bReplace = false; + if( pGrfBrush ) + { + m_pBrush.reset(pGrfBrush->Clone()); + const Graphic* pGraph = pGrfBrush->GetGraphic(referer); + if( pGraph ) + SetAnimated( pGraph->IsAnimated() ); + else + m_bReplace = true; + } + if( pGrfOrient ) + { + m_nYPos = pGrfOrient->GetPos(); + m_eOrient = pGrfOrient->GetVertOrient(); + } + else + { + m_nYPos = 0; + m_eOrient = text::VertOrientation::TOP; + } + Width( rGrfSize.Width() + 2 * GRFNUM_SECURE ); + m_nFixWidth = Width(); + m_nGrfHeight = rGrfSize.Height() + 2 * GRFNUM_SECURE; + Height( sal_uInt16(m_nGrfHeight) ); + m_bNoPaint = false; +} + +SwGrfNumPortion::~SwGrfNumPortion() +{ + if ( IsAnimated() ) + { + Graphic* pGraph = const_cast(m_pBrush->GetGraphic()); + if (pGraph) + pGraph->StopAnimation( nullptr, m_nId ); + } + m_pBrush.reset(); +} + +void SwGrfNumPortion::StopAnimation( const OutputDevice* pOut ) +{ + if ( IsAnimated() ) + { + Graphic* pGraph = const_cast(m_pBrush->GetGraphic()); + if (pGraph) + pGraph->StopAnimation( pOut, m_nId ); + } +} + +bool SwGrfNumPortion::Format( SwTextFormatInfo &rInf ) +{ + SetHide( false ); +// Width( nFixWidth ); + sal_uInt16 nFollowedByWidth( 0 ); + if ( mbLabelAlignmentPosAndSpaceModeActive ) + { + SwFieldPortion::Format( rInf ); + nFollowedByWidth = Width(); + SetLen(TextFrameIndex(0)); + } + Width( m_nFixWidth + nFollowedByWidth ); + const bool bFull = rInf.Width() < rInf.X() + Width(); + const bool bFly = rInf.GetFly() || + ( rInf.GetLast() && rInf.GetLast()->IsFlyPortion() ); + SetAscent( GetRelPos() > 0 ? GetRelPos() : 0 ); + if( GetAscent() > Height() ) + Height( GetAscent() ); + + if( bFull ) + { + Width( rInf.Width() - rInf.X() ); + if( bFly ) + { + SetLen(TextFrameIndex(0)); + m_bNoPaint = true; + rInf.SetNumDone( false ); + return true; + } + } + rInf.SetNumDone( true ); +// long nDiff = rInf.Left() - rInf.First() + rInf.ForcedLeftMargin(); + tools::Long nDiff = mbLabelAlignmentPosAndSpaceModeActive + ? 0 + : rInf.Left() - rInf.First() + rInf.ForcedLeftMargin(); + // The TextPortion should at least always start on the + // left margin + if( nDiff < 0 ) + nDiff = 0; + else if ( nDiff > rInf.X() ) + nDiff -= rInf.X(); + if( nDiff < m_nFixWidth + m_nMinDist ) + nDiff = m_nFixWidth + m_nMinDist; + + // Numbering evades Fly, no nDiff in the second round + // Tricky special case: FlyFrame is in the Area we were just + // about to get a hold of. + // The NumberPortion is marked as hidden + if( nDiff > rInf.Width() ) + { + nDiff = rInf.Width(); + if( bFly ) + SetHide( true ); + } + + if( Width() < nDiff ) + Width( nDiff ); + return bFull; +} + + +/** + * A hidden NumberPortion is not displayed, unless there are TextPortions in + * this line or there's only one line at all + */ +void SwGrfNumPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + if( m_bNoPaint ) + return; + if ( IsHide() && rInf.GetParaPortion() && rInf.GetParaPortion()->GetNext() ) + { + SwLinePortion *pTmp = GetNextPortion(); + while ( pTmp && !pTmp->InTextGrp() ) + pTmp = pTmp->GetNextPortion(); + if ( !pTmp ) + return; + } + Point aPos( rInf.X() + GRFNUM_SECURE, rInf.Y() - GetRelPos() + GRFNUM_SECURE ); + tools::Long nTmpWidth = std::max( tools::Long(0), static_cast(m_nFixWidth - 2 * GRFNUM_SECURE) ); + Size aSize( nTmpWidth, GetGrfHeight() - 2 * GRFNUM_SECURE ); + + const bool bTmpLeft = mbLabelAlignmentPosAndSpaceModeActive || + ( IsLeft() && ! rInf.GetTextFrame()->IsRightToLeft() ) || + ( ! IsLeft() && ! IsCenter() && rInf.GetTextFrame()->IsRightToLeft() ); + + if( m_nFixWidth < Width() && !bTmpLeft ) + { + sal_uInt16 nOffset = Width() - m_nFixWidth; + if( nOffset < m_nMinDist ) + nOffset = 0; + else + { + if( IsCenter() ) + { + nOffset /= 2; + if( nOffset < m_nMinDist ) + nOffset = Width() - m_nFixWidth - m_nMinDist; + } + else + nOffset = nOffset - m_nMinDist; + } + aPos.AdjustX(nOffset ); + } + + if( m_bReplace ) + { + const tools::Long nTmpH = GetNextPortion() ? GetNextPortion()->GetAscent() : 120; + aSize = Size( nTmpH, nTmpH ); + aPos.setY( rInf.Y() - nTmpH ); + } + SwRect aTmp( aPos, aSize ); + + bool bDraw = true; + + if ( IsAnimated() ) + { + bDraw = !rInf.GetOpt().IsGraphic(); + if( !m_nId ) + { + SetId( reinterpret_cast( rInf.GetTextFrame() ) ); + rInf.GetTextFrame()->SetAnimation(); + } + if( aTmp.Overlaps( rInf.GetPaintRect() ) && !bDraw ) + { + rInf.NoteAnimation(); + const SwViewShell* pViewShell = rInf.GetVsh(); + + // virtual device, not pdf export + if( OUTDEV_VIRDEV == rInf.GetOut()->GetOutDevType() && + pViewShell && pViewShell->GetWin() ) + { + Graphic* pGraph = const_cast(m_pBrush->GetGraphic()); + if (pGraph) + pGraph->StopAnimation(nullptr,m_nId); + rInf.GetTextFrame()->getRootFrame()->GetCurrShell()->InvalidateWindows( aTmp ); + } + + else if ( pViewShell && + !pViewShell->GetAccessibilityOptions()->IsStopAnimatedGraphics() && + !pViewShell->IsPreview() && + // #i9684# Stop animation during printing/pdf export. + pViewShell->GetWin() ) + { + Graphic* pGraph = const_cast(m_pBrush->GetGraphic()); + if (pGraph) + { + const OutputDevice* pOut = rInf.GetOut(); + assert(pOut); + pGraph->StartAnimation( + *const_cast(pOut), aPos, aSize, m_nId); + } + } + + // pdf export, printing, preview, stop animations... + else + bDraw = true; + } + if( bDraw ) + { + + Graphic* pGraph = const_cast(m_pBrush->GetGraphic()); + if (pGraph) + pGraph->StopAnimation( nullptr, m_nId ); + } + } + + SwRect aRepaint( rInf.GetPaintRect() ); + const SwTextFrame& rFrame = *rInf.GetTextFrame(); + if( rFrame.IsVertical() ) + { + rFrame.SwitchHorizontalToVertical( aTmp ); + rFrame.SwitchHorizontalToVertical( aRepaint ); + } + + if( rFrame.IsRightToLeft() ) + { + rFrame.SwitchLTRtoRTL( aTmp ); + rFrame.SwitchLTRtoRTL( aRepaint ); + } + + if( bDraw && aTmp.HasArea() ) + { + const OutputDevice* pOut = rInf.GetOut(); + assert(pOut); + DrawGraphic( m_pBrush.get(), *const_cast(pOut), + aTmp, aRepaint, m_bReplace ? GRFNUM_REPLACE : GRFNUM_YES ); + } +} + +void SwGrfNumPortion::SetBase( tools::Long nLnAscent, tools::Long nLnDescent, + tools::Long nFlyAsc, tools::Long nFlyDesc ) +{ + if ( GetOrient() == text::VertOrientation::NONE ) + return; + + SetRelPos( 0 ); + if ( GetOrient() == text::VertOrientation::CENTER ) + SetRelPos( GetGrfHeight() / 2 ); + else if ( GetOrient() == text::VertOrientation::TOP ) + SetRelPos( GetGrfHeight() - GRFNUM_SECURE ); + else if ( GetOrient() == text::VertOrientation::BOTTOM ) + ; + else if ( GetOrient() == text::VertOrientation::CHAR_CENTER ) + SetRelPos( ( GetGrfHeight() + nLnAscent - nLnDescent ) / 2 ); + else if ( GetOrient() == text::VertOrientation::CHAR_TOP ) + SetRelPos( nLnAscent ); + else if ( GetOrient() == text::VertOrientation::CHAR_BOTTOM ) + SetRelPos( GetGrfHeight() - nLnDescent ); + else + { + if( GetGrfHeight() >= nFlyAsc + nFlyDesc ) + { + // If I'm as large as the line, I do not need to adjust + // at the line; I'll leave the max. ascent unchanged + SetRelPos( nFlyAsc ); + } + else if ( GetOrient() == text::VertOrientation::LINE_CENTER ) + SetRelPos( ( GetGrfHeight() + nFlyAsc - nFlyDesc ) / 2 ); + else if ( GetOrient() == text::VertOrientation::LINE_TOP ) + SetRelPos( nFlyAsc ); + else if ( GetOrient() == text::VertOrientation::LINE_BOTTOM ) + SetRelPos( GetGrfHeight() - nFlyDesc ); + } +} + +void SwTextFrame::StopAnimation( const OutputDevice* pOut ) +{ + OSL_ENSURE( HasAnimation(), "SwTextFrame::StopAnimation: Which Animation?" ); + if( !HasPara() ) + return; + + SwLineLayout *pLine = GetPara(); + while( pLine ) + { + SwLinePortion *pPor = pLine->GetNextPortion(); + while( pPor ) + { + if( pPor->IsGrfNumPortion() ) + static_cast(pPor)->StopAnimation( pOut ); + // The NumberPortion is always at the first char, + // which means we can cancel as soon as we've reached a portion + // with a length > 0 + pPor = pPor->GetLen() ? nullptr : pPor->GetNextPortion(); + } + pLine = pLine->GetLen() ? nullptr : pLine->GetNext(); + } +} + +/** + * Initializes the script array and clears the width array + */ +SwCombinedPortion::SwCombinedPortion( const OUString &rText ) + : SwFieldPortion( rText ) + , m_aWidth{ static_cast(0), + static_cast(0), + static_cast(0) } + , m_nUpPos(0) + , m_nLowPos(0) + , m_nProportion(55) +{ + SetLen(TextFrameIndex(1)); + SetWhichPor( PortionType::Combined ); + if( m_aExpand.getLength() > 6 ) + m_aExpand = m_aExpand.copy( 0, 6 ); + + // Initialization of the scripttype array, + // the arrays of width and position are filled by the format function + assert(g_pBreakIt && g_pBreakIt->GetBreakIter().is()); + + SwFontScript nScr = SW_SCRIPTS; + for( sal_Int32 i = 0; i < rText.getLength(); ++i ) + { + switch ( g_pBreakIt->GetBreakIter()->getScriptType( rText, i ) ) { + case i18n::ScriptType::LATIN : nScr = SwFontScript::Latin; break; + case i18n::ScriptType::ASIAN : nScr = SwFontScript::CJK; break; + case i18n::ScriptType::COMPLEX : nScr = SwFontScript::CTL; break; + } + m_aScrType[i] = nScr; + } +} + +void SwCombinedPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + OSL_ENSURE(GetLen() <= TextFrameIndex(1), "SwFieldPortion::Paint: rest-portion pollution?"); + if( !Width() ) + return; + + rInf.DrawBackBrush( *this ); + rInf.DrawViewOpt( *this, PortionType::Field ); + + // do we have to repaint a post it portion? + if( rInf.OnWin() && mpNextPortion && !mpNextPortion->Width() ) + mpNextPortion->PrePaint( rInf, this ); + + const sal_Int32 nCount = m_aExpand.getLength(); + if( !nCount ) + return; + OSL_ENSURE( nCount < 7, "Too much combined characters" ); + + // the first character of the second row + const sal_Int32 nTop = ( nCount + 1 ) / 2; + + SwFont aTmpFont( *rInf.GetFont() ); + aTmpFont.SetProportion( m_nProportion ); // a smaller font + SwFontSave aFontSave( rInf, &aTmpFont ); + + Point aOldPos = rInf.GetPos(); + Point aOutPos( aOldPos.X(), aOldPos.Y() - m_nUpPos );// Y of the first row + for( sal_Int32 i = 0 ; i < nCount; ++i ) + { + if( i == nTop ) // change the row + aOutPos.setY( aOldPos.Y() + m_nLowPos ); // Y of the second row + aOutPos.setX( aOldPos.X() + m_aPos[i] ); // X position + const SwFontScript nAct = m_aScrType[i]; // script type + aTmpFont.SetActual( nAct ); + + // if there're more than 4 characters to display, we choose fonts + // with 2/3 of the original font width. + if( m_aWidth[ nAct ] ) + { + Size aTmpSz = aTmpFont.GetSize( nAct ); + if( aTmpSz.Width() != m_aWidth[ nAct ] ) + { + aTmpSz.setWidth( m_aWidth[ nAct ] ); + aTmpFont.SetSize( aTmpSz, nAct ); + } + } + const_cast(rInf).SetPos( aOutPos ); + rInf.DrawText(m_aExpand, *this, TextFrameIndex(i), TextFrameIndex(1)); + } + // rInf is const, so we have to take back our manipulations + const_cast(rInf).SetPos( aOldPos ); + +} + +bool SwCombinedPortion::Format( SwTextFormatInfo &rInf ) +{ + const sal_Int32 nCount = m_aExpand.getLength(); + if( !nCount ) + { + Width( 0 ); + return false; + } + + OSL_ENSURE( nCount < 7, "Too much combined characters" ); + + // If there are leading "weak"-scripttyped characters in this portion, + // they get the actual scripttype. + for( sal_Int32 i = 0; i < nCount && SW_SCRIPTS == m_aScrType[i]; ++i ) + m_aScrType[i] = rInf.GetFont()->GetActual(); + if( nCount > 4 ) + { + // more than four? Ok, then we need the 2/3 font width + for( sal_Int32 i = 0; i < m_aExpand.getLength(); ++i ) + { + OSL_ENSURE( m_aScrType[i] < SW_SCRIPTS, "Combined: Script fault" ); + if( !m_aWidth[ m_aScrType[i] ] ) + { + rInf.GetOut()->SetFont( rInf.GetFont()->GetFnt( m_aScrType[i] ) ); + m_aWidth[ m_aScrType[i] ] = + o3tl::narrowing(2 * rInf.GetOut()->GetFontMetric().GetFontSize().Width() / 3); + } + } + } + + const sal_Int32 nTop = ( nCount + 1 ) / 2; // the first character of the second line + SwViewShell *pSh = rInf.GetTextFrame()->getRootFrame()->GetCurrShell(); + SwFont aTmpFont( *rInf.GetFont() ); + SwFontSave aFontSave( rInf, &aTmpFont ); + m_nProportion = 55; + // In nMainAscent/Descent we store the ascent and descent + // of the original surrounding font + sal_uInt16 nMaxDescent, nMaxAscent, nMaxWidth; + sal_uInt16 nMainDescent = rInf.GetFont()->GetHeight( pSh, *rInf.GetOut() ); + const sal_uInt16 nMainAscent = rInf.GetFont()->GetAscent( pSh, *rInf.GetOut() ); + nMainDescent = nMainDescent - nMainAscent; + // we start with a 50% font, but if we notice that the combined portion + // becomes bigger than the surrounding font, we check 45% and maybe 40%. + do + { + m_nProportion -= 5; + aTmpFont.SetProportion( m_nProportion ); + memset( &m_aPos, 0, sizeof(m_aPos) ); + nMaxDescent = 0; + nMaxAscent = 0; + nMaxWidth = 0; + m_nUpPos = m_nLowPos = 0; + + // Now we get the width of all characters. + // The ascent and the width of the first line are stored in the + // ascent member of the portion, the descent in nLowPos. + // The ascent, descent and width of the second line are stored in the + // local nMaxAscent, nMaxDescent and nMaxWidth variables. + for( sal_Int32 i = 0; i < nCount; ++i ) + { + SwFontScript nScrp = m_aScrType[i]; + aTmpFont.SetActual( nScrp ); + if( m_aWidth[ nScrp ] ) + { + Size aFontSize( aTmpFont.GetSize( nScrp ) ); + aFontSize.setWidth( m_aWidth[ nScrp ] ); + aTmpFont.SetSize( aFontSize, nScrp ); + } + + SwDrawTextInfo aDrawInf(pSh, *rInf.GetOut(), m_aExpand, i, 1); + Size aSize = aTmpFont.GetTextSize_( aDrawInf ); + const sal_uInt16 nAsc = aTmpFont.GetAscent( pSh, *rInf.GetOut() ); + m_aPos[ i ] = o3tl::narrowing(aSize.Width()); + if( i == nTop ) // enter the second line + { + m_nLowPos = nMaxDescent; + Height( nMaxDescent + nMaxAscent ); + Width( nMaxWidth ); + SetAscent( nMaxAscent ); + nMaxAscent = 0; + nMaxDescent = 0; + nMaxWidth = 0; + } + nMaxWidth = nMaxWidth + m_aPos[ i ]; + if( nAsc > nMaxAscent ) + nMaxAscent = nAsc; + if( aSize.Height() - nAsc > nMaxDescent ) + nMaxDescent = aSize.Height() - nAsc; + } + // for one or two characters we double the width of the portion + if( nCount < 3 ) + { + nMaxWidth *= 2; + Width( 2*Width() ); + if( nCount < 2 ) + { + Height( nMaxAscent + nMaxDescent ); + m_nLowPos = nMaxDescent; + } + } + Height( Height() + nMaxDescent + nMaxAscent ); + m_nUpPos = nMaxAscent; + SetAscent( Height() - nMaxDescent - m_nLowPos ); + } while( m_nProportion > 40 && ( GetAscent() > nMainAscent || + Height() - GetAscent() > nMainDescent ) ); + // if the combined portion is smaller than the surrounding text, + // the portion grows. This looks better, if there's a character background. + if( GetAscent() < nMainAscent ) + { + Height( Height() + nMainAscent - GetAscent() ); + SetAscent( nMainAscent ); + } + if( Height() < nMainAscent + nMainDescent ) + Height( nMainAscent + nMainDescent ); + + // We calculate the x positions of the characters in both lines... + sal_uInt16 nTopDiff = 0; + sal_uInt16 nBotDiff = 0; + if( nMaxWidth > Width() ) + { + nTopDiff = ( nMaxWidth - Width() ) / 2; + Width( nMaxWidth ); + } + else + nBotDiff = ( Width() - nMaxWidth ) / 2; + switch( nTop) + { + case 3: m_aPos[1] = m_aPos[0] + nTopDiff; + [[fallthrough]]; + case 2: m_aPos[nTop-1] = Width() - m_aPos[nTop-1]; + } + m_aPos[0] = 0; + switch( nCount ) + { + case 5: m_aPos[4] = m_aPos[3] + nBotDiff; + [[fallthrough]]; + case 3: m_aPos[nTop] = nBotDiff; break; + case 6: m_aPos[4] = m_aPos[3] + nBotDiff; + [[fallthrough]]; + case 4: m_aPos[nTop] = 0; + [[fallthrough]]; + case 2: m_aPos[nCount-1] = Width() - m_aPos[nCount-1]; + } + + // Does the combined portion fit the line? + const bool bFull = rInf.Width() < rInf.X() + Width(); + if( bFull ) + { + if( rInf.GetLineStart() == rInf.GetIdx() && (!rInf.GetLast()->InFieldGrp() + || !static_cast(rInf.GetLast())->IsFollow() ) ) + Width( rInf.Width() - rInf.X() ); + else + { + Truncate(); + Width( 0 ); + SetLen(TextFrameIndex(0)); + if( rInf.GetLast() ) + rInf.GetLast()->FormatEOL( rInf ); + } + } + return bFull; +} + +sal_uInt16 SwCombinedPortion::GetViewWidth( const SwTextSizeInfo &rInf ) const +{ + if( !GetLen() ) // for the dummy part at the end of the line, where + return 0; // the combined portion doesn't fit. + return SwFieldPortion::GetViewWidth( rInf ); +} + +SwFieldPortion *SwFieldFormDropDownPortion::Clone(const OUString &rExpand) const +{ + return new SwFieldFormDropDownPortion(m_pFieldMark, rExpand); +} + +void SwFieldFormDropDownPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + SwFieldPortion::Paint( rInf ); + + ::sw::mark::DropDownFieldmark* pDropDownField = dynamic_cast< ::sw::mark::DropDownFieldmark* >(m_pFieldMark); + if(pDropDownField) + { + SwRect aPaintArea; + rInf.CalcRect( *this, &aPaintArea ); + pDropDownField->SetPortionPaintArea(aPaintArea); + } +} + +SwFieldPortion *SwFieldFormDatePortion::Clone(const OUString &/*rExpand*/) const +{ + return new SwFieldFormDatePortion(m_pFieldMark, m_bStart); +} + +void SwFieldFormDatePortion::Paint( const SwTextPaintInfo &rInf ) const +{ + SwFieldPortion::Paint( rInf ); + + ::sw::mark::DateFieldmark* pDateField = dynamic_cast< ::sw::mark::DateFieldmark* >(m_pFieldMark); + if(pDateField) + { + SwRect aPaintArea; + rInf.CalcRect( *this, &aPaintArea ); + if(m_bStart) + pDateField->SetPortionPaintAreaStart(aPaintArea); + else + pDateField->SetPortionPaintAreaEnd(aPaintArea); + } +} + +SwFieldPortion* SwJumpFieldPortion::Clone(const OUString& rExpand) const +{ + auto pRet = new SwJumpFieldPortion(*this); + pRet->m_aExpand = rExpand; + return pRet; +} + +bool SwJumpFieldPortion::DescribePDFControl(const SwTextPaintInfo& rInf) const +{ + auto pPDFExtOutDevData + = dynamic_cast(rInf.GetOut()->GetExtOutDevData()); + if (!pPDFExtOutDevData) + return false; + + if (!pPDFExtOutDevData->GetIsExportFormFields()) + return false; + + if (m_nFormat != SwJumpEditFormat::JE_FMT_TEXT) + return false; + + vcl::PDFWriter::EditWidget aDescriptor; + + aDescriptor.Border = true; + aDescriptor.BorderColor = COL_BLACK; + + SwRect aLocation; + rInf.CalcRect(*this, &aLocation); + aDescriptor.Location = aLocation.SVRect(); + + // Map the text of the field to the descriptor's text. + static sal_Unicode constexpr aForbidden[] = { CH_TXTATR_BREAKWORD, 0 }; + aDescriptor.Text = comphelper::string::removeAny(GetExp(), aForbidden); + + // Description for accessibility purposes. + if (!m_sHelp.isEmpty()) + aDescriptor.Description = m_sHelp; + + pPDFExtOutDevData->WrapBeginStructureElement(vcl::PDFWriter::Form); + pPDFExtOutDevData->CreateControl(aDescriptor); + pPDFExtOutDevData->EndStructureElement(); + + return true; +} + +void SwJumpFieldPortion::Paint(const SwTextPaintInfo& rInf) const +{ + if (Width() && DescribePDFControl(rInf)) + return; + + if (rInf.GetOpt().IsShowPlaceHolderFields()) + SwFieldPortion::Paint(rInf); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/porfld.hxx b/sw/source/core/text/porfld.hxx new file mode 100644 index 0000000000..b923729424 --- /dev/null +++ b/sw/source/core/text/porfld.hxx @@ -0,0 +1,285 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include + +#include + +#include +#include +#include "porexp.hxx" +#include + +class SvxBrushItem; +class SwFormatVertOrient; + +class SwFieldPortion : public SwExpandPortion +{ + friend class SwTextFormatter; +protected: + OUString m_aExpand; // The expanded field + std::unique_ptr m_pFont; // For multi-line fields + TextFrameIndex m_nNextOffset; // Offset of the follow in the original string + TextFrameIndex m_nNextScriptChg; + TextFrameIndex m_nFieldLen; //< Length of field text, 1 for normal fields, any number for input fields + // TODO ^ do we need this as member or is base class len enough? + sal_uInt16 m_nViewWidth; // Screen width for empty fields + bool m_bFollow : 1; // 2nd or later part of a field + bool m_bLeft : 1; // Used by SwNumberPortion + bool m_bHide : 1; // Used by SwNumberPortion + bool m_bCenter : 1; // Used by SwNumberPortion + bool m_bHasFollow : 1; // Continues on the next line + bool m_bAnimated : 1; // Used by SwGrfNumPortion + bool m_bNoPaint : 1; // Used by SwGrfNumPortion + bool m_bReplace : 1; // Used by SwGrfNumPortion + bool m_bNoLength : 1; // HACK for meta suffix (no CH_TXTATR) + bool m_bContentControl = false; + + void SetFont( std::unique_ptr pNew ) { m_pFont = std::move(pNew); } + bool IsNoLength() const { return m_bNoLength; } + void SetNoLength() { m_bNoLength = true; } + +public: + SwFieldPortion( const SwFieldPortion& rField ); + SwFieldPortion(OUString aExpand, std::unique_ptr pFnt = nullptr, TextFrameIndex nLen = TextFrameIndex(1)); + virtual ~SwFieldPortion() override; + + void TakeNextOffset( const SwFieldPortion* pField ); + void CheckScript( const SwTextSizeInfo &rInf ); + bool HasFont() const { return nullptr != m_pFont; } + // #i89179# - made public + const SwFont *GetFont() const { return m_pFont.get(); } + + const OUString& GetExp() const { return m_aExpand; } + virtual bool GetExpText( const SwTextSizeInfo &rInf, OUString &rText ) const override; + virtual bool Format( SwTextFormatInfo &rInf ) override; + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + + // Empty fields are also allowed + virtual SwLinePortion *Compress() override; + + virtual sal_uInt16 GetViewWidth( const SwTextSizeInfo &rInf ) const override; + + bool IsFollow() const { return m_bFollow; } + void SetFollow( bool bNew ) { m_bFollow = bNew; } + + bool IsLeft() const { return m_bLeft; } + void SetLeft( bool bNew ) { m_bLeft = bNew; } + + bool IsHide() const { return m_bHide; } + void SetHide( bool bNew ) { m_bHide = bNew; } + + bool IsCenter() const { return m_bCenter; } + void SetCenter( bool bNew ) { m_bCenter = bNew; } + + bool HasFollow() const { return m_bHasFollow; } + void SetHasFollow( bool bNew ) { m_bHasFollow = bNew; } + + TextFrameIndex GetNextOffset() const { return m_nNextOffset; } + void SetNextOffset(TextFrameIndex nNew) { m_nNextOffset = nNew; } + + TextFrameIndex GetFieldLen() const { return m_nFieldLen; } + + // Field cloner for SplitGlue + virtual SwFieldPortion *Clone( const OUString &rExpand ) const; + + // Extra GetTextSize because of pFnt + virtual SwPosSize GetTextSize( const SwTextSizeInfo &rInfo ) const override; + + // Accessibility: pass information about this portion to the PortionHandler + virtual void HandlePortion( SwPortionHandler& rPH ) const override; + + void SetContentControl(bool bContentControl) { m_bContentControl = bContentControl; } + + void dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, + TextFrameIndex& nOffset) const override; +}; + +/** + * Distinguish only for painting/hide + */ +class SwHiddenPortion : public SwFieldPortion +{ +public: + SwHiddenPortion( const OUString &rExpand, std::unique_ptr pFntL = nullptr ) + : SwFieldPortion( rExpand, std::move(pFntL) ) + { SetLen(TextFrameIndex(1)); SetWhichPor( PortionType::Hidden ); } + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + virtual bool GetExpText( const SwTextSizeInfo &rInf, OUString &rText ) const override; + + // Field cloner for SplitGlue + virtual SwFieldPortion *Clone( const OUString &rExpand ) const override; +}; + +class SwNumberPortion : public SwFieldPortion +{ +protected: + sal_uInt16 m_nFixWidth; // See Glues + sal_uInt16 m_nMinDist; // Minimal distance to the text + bool mbLabelAlignmentPosAndSpaceModeActive; + +public: + SwNumberPortion( const OUString &rExpand, + std::unique_ptr pFnt, + const bool bLeft, + const bool bCenter, + const sal_uInt16 nMinDst, + const bool bLabelAlignmentPosAndSpaceModeActive ); + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + virtual TextFrameIndex GetModelPositionForViewPoint(sal_uInt16 nOfst) const override; + virtual bool Format( SwTextFormatInfo &rInf ) override; + + // Field cloner for SplitGlue + virtual SwFieldPortion *Clone( const OUString &rExpand ) const override; + virtual void FormatEOL( SwTextFormatInfo &rInf ) override; +}; + +class SwBulletPortion : public SwNumberPortion +{ +public: + SwBulletPortion( const sal_UCS4 cCh, + std::u16string_view rBulletFollowedBy, + std::unique_ptr pFnt, + const bool bLeft, + const bool bCenter, + const sal_uInt16 nMinDst, + const bool bLabelAlignmentPosAndSpaceModeActive ); +}; + +class SwGrfNumPortion : public SwNumberPortion +{ + std::unique_ptr m_pBrush; + tools::Long m_nId; // For StopAnimation + SwTwips m_nYPos; // _Always_ contains the current RelPos + SwTwips m_nGrfHeight; + sal_Int16 m_eOrient; +public: + SwGrfNumPortion( const OUString& rGraphicFollowedBy, + const SvxBrushItem* pGrfBrush, + OUString const & referer, + const SwFormatVertOrient* pGrfOrient, + const Size& rGrfSize, + const bool bLeft, + const bool bCenter, + const sal_uInt16 nMinDst, + const bool bLabelAlignmentPosAndSpaceModeActive ); + virtual ~SwGrfNumPortion() override; + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + virtual bool Format( SwTextFormatInfo &rInf ) override; + + void SetBase( tools::Long nLnAscent, tools::Long nLnDescent, + tools::Long nFlyAscent, tools::Long nFlyDescent ); + + void StopAnimation( const OutputDevice* pOut ); + + bool IsAnimated() const { return m_bAnimated; } + void SetAnimated( bool bNew ) { m_bAnimated = bNew; } + void SetRelPos( SwTwips nNew ) { m_nYPos = nNew; } + void SetId( tools::Long nNew ) const + { const_cast(this)->m_nId = nNew; } + SwTwips GetRelPos() const { return m_nYPos; } + SwTwips GetGrfHeight() const { return m_nGrfHeight; } + sal_Int16 GetOrient() const { return m_eOrient; } +}; + +/** + * Used in for asian layout specialities to display up to six characters + * in 2 rows and 2-3 columns. + * E.g.: 
+ *        A..  A..  A.B  A.B   A.B.C   A.B.C
+ *        ...  ..B  .C.  C.D   .D.E.   D.E.F
+ *
+ */ +class SwCombinedPortion : public SwFieldPortion +{ + sal_uInt16 m_aPos[6]; // up to six X positions + o3tl::enumarray m_aWidth; // one width for every scripttype + SwFontScript m_aScrType[6]; // scripttype of every character + sal_uInt16 m_nUpPos; // the Y position of the upper baseline + sal_uInt16 m_nLowPos; // the Y position of the lower baseline + sal_uInt8 m_nProportion; // relative font height +public: + explicit SwCombinedPortion( const OUString &rExpand ); + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + virtual bool Format( SwTextFormatInfo &rInf ) override; + virtual sal_uInt16 GetViewWidth( const SwTextSizeInfo &rInf ) const override; +}; + +namespace sw::mark { class IFieldmark; } + +class SwFieldFormDropDownPortion : public SwFieldPortion +{ +public: + explicit SwFieldFormDropDownPortion(sw::mark::IFieldmark *pFieldMark, const OUString &rExpand) + : SwFieldPortion(rExpand) + , m_pFieldMark(pFieldMark) + { + } + // Field cloner for SplitGlue + virtual SwFieldPortion *Clone( const OUString &rExpand ) const override; + + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + +private: + sw::mark::IFieldmark* m_pFieldMark; +}; + +class SwFieldFormDatePortion : public SwFieldPortion +{ +public: + explicit SwFieldFormDatePortion(sw::mark::IFieldmark *pFieldMark, bool bStart) + : SwFieldPortion("") + , m_pFieldMark(pFieldMark) + , m_bStart(bStart) + { + } + // Field cloner for SplitGlue + virtual SwFieldPortion *Clone( const OUString &rExpand) const override; + + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + +private: + sw::mark::IFieldmark* m_pFieldMark; + bool m_bStart; +}; + +class SwJumpFieldPortion final : public SwFieldPortion +{ +public: + explicit SwJumpFieldPortion(OUString aExpand, OUString aHelp, std::unique_ptr pFont, + sal_uInt32 nFormat) + : SwFieldPortion(std::move(aExpand), std::move(pFont)) + , m_nFormat(nFormat) + , m_sHelp(std::move(aHelp)) + { + } + virtual SwFieldPortion* Clone(const OUString& rExpand) const override; + + virtual void Paint(const SwTextPaintInfo& rInf) const override; + +private: + sal_uInt32 m_nFormat; // SwJumpEditFormat from SwField::GetFormat() + OUString m_sHelp; + + bool DescribePDFControl(const SwTextPaintInfo& rInf) const; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/porfly.cxx b/sw/source/core/text/porfly.cxx new file mode 100644 index 0000000000..14d1bf6eaa --- /dev/null +++ b/sw/source/core/text/porfly.cxx @@ -0,0 +1,423 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include +#include +#include "portab.hxx" +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include "porfly.hxx" +#include "porlay.hxx" +#include "inftxt.hxx" + +#include +#include +#include + +/** + * class SwFlyPortion => we expect a frame-locale SwRect! + */ + +void SwFlyPortion::Paint( const SwTextPaintInfo& ) const +{ +} + +bool SwFlyPortion::Format( SwTextFormatInfo &rInf ) +{ + OSL_ENSURE( GetFix() >= rInf.X(), "SwFlyPortion::Format" ); + + // tabs must be expanded + if( rInf.GetLastTab() ) + rInf.GetLastTab()->FormatEOL( rInf ); + + rInf.GetLast()->FormatEOL( rInf ); + + SetBlankWidth(0); + if (auto blankWidth = rInf.GetLast()->ExtraBlankWidth()) + { + // Swallow previous blank width + SetBlankWidth(blankWidth); + rInf.GetLast()->ExtraBlankWidth(0); + rInf.X(rInf.X() - blankWidth); // Step back + } + + PrtWidth( o3tl::narrowing(GetFix() - rInf.X() + PrtWidth()) ); + if( !Width() ) + { + OSL_ENSURE( Width(), "+SwFlyPortion::Format: a fly is a fly is a fly" ); + Width(1); + } + + // resetting + rInf.SetFly( nullptr ); + rInf.Width( rInf.RealWidth() ); + rInf.GetParaPortion()->SetFly(); + + // trailing blank: + if( rInf.GetIdx() < TextFrameIndex(rInf.GetText().getLength()) + && TextFrameIndex(1) < rInf.GetIdx() + && !rInf.GetRest() + && ' ' == rInf.GetChar( rInf.GetIdx() ) + && ' ' != rInf.GetChar(rInf.GetIdx() - TextFrameIndex(1)) + && ( !rInf.GetLast() || !rInf.GetLast()->IsBreakPortion() ) ) + { + SetBlankWidth(GetBlankWidth() + rInf.GetTextSize(OUString(' ')).Width()); + SetLen(TextFrameIndex(1)); + } + + const sal_uInt16 nNewWidth = o3tl::narrowing(rInf.X() + PrtWidth()); + if( rInf.Width() <= nNewWidth ) + { + Truncate(); + if( nNewWidth > rInf.Width() ) + { + PrtWidth( nNewWidth - rInf.Width() ); + SetFixWidth( PrtWidth() ); + } + return true; + } + return false; +} + +bool SwFlyCntPortion::Format( SwTextFormatInfo &rInf ) +{ + bool bFull = rInf.Width() < rInf.X() + PrtWidth(); + + if( bFull ) + { + // If the line is full, and the character-bound frame is at + // the beginning of a line + // If it is not possible to side step into a Fly + // "Begin of line" criteria ( ! rInf.X() ) has to be extended. + // KerningPortions at beginning of line, e.g., for grid layout + // must be considered. + const SwLinePortion* pLastPor = rInf.GetLast(); + const auto nLeft = ( pLastPor && + ( pLastPor->IsKernPortion() || + pLastPor->IsErgoSumPortion() ) ) ? + pLastPor->Width() : + 0; + + if( nLeft == rInf.X() && ! rInf.GetFly() ) + { + Width( rInf.Width() ); + bFull = false; // so that notes can still be placed in this line + } + else + { + if( !rInf.GetFly() ) + rInf.SetNewLine( true ); + Width(0); + SetAscent(0); + SetLen(TextFrameIndex(0)); + if( rInf.GetLast() ) + rInf.GetLast()->FormatEOL( rInf ); + + return bFull; + } + } + + rInf.GetParaPortion()->SetFly(); + return bFull; +} + +//TODO: improve documentation +/** move character-bound objects inside the given area + * + * This allows moving those objects from Master to Follow, or vice versa. + * + * @param pNew + * @param nStart + * @param nEnd + */ +void SwTextFrame::MoveFlyInCnt(SwTextFrame *pNew, + TextFrameIndex const nStart, TextFrameIndex const nEnd) +{ + SwSortedObjs *pObjs = GetDrawObjs(); + if ( nullptr == pObjs ) + return; + + for ( size_t i = 0; GetDrawObjs() && i < pObjs->size(); ++i ) + { + // Consider changed type of entries + SwAnchoredObject* pAnchoredObj = (*pObjs)[i]; + const SwFormatAnchor& rAnch = pAnchoredObj->GetFrameFormat().GetAnchor(); + if (rAnch.GetAnchorId() == RndStdIds::FLY_AS_CHAR) + { + const SwPosition* pPos = rAnch.GetContentAnchor(); + TextFrameIndex const nIndex(MapModelToViewPos(*pPos)); + if (nStart <= nIndex && nIndex < nEnd) + { + if ( auto pFlyFrame = pAnchoredObj->DynCastFlyFrame() ) + { + RemoveFly( pFlyFrame ); + pNew->AppendFly( pFlyFrame ); + } + else if ( dynamic_cast< const SwAnchoredDrawObject *>( pAnchoredObj ) != nullptr ) + { + RemoveDrawObj( *pAnchoredObj ); + pNew->AppendDrawObj( *pAnchoredObj ); + } + --i; + } + } + } +} + +TextFrameIndex SwTextFrame::CalcFlyPos( SwFrameFormat const * pSearch ) +{ + sw::MergedAttrIter iter(*this); + for (SwTextAttr const* pHt = iter.NextAttr(); pHt; pHt = iter.NextAttr()) + { + if( RES_TXTATR_FLYCNT == pHt->Which() ) + { + SwFrameFormat* pFrameFormat = pHt->GetFlyCnt().GetFrameFormat(); + if( pFrameFormat == pSearch ) + { + return TextFrameIndex(pHt->GetStart()); + } + } + } + OSL_ENSURE(false, "CalcFlyPos: Not Found!"); + return TextFrameIndex(COMPLETE_STRING); +} + +void sw::FlyContentPortion::Paint(const SwTextPaintInfo& rInf) const +{ + // Baseline output + // Re-paint everything at a CompletePaint call + SwRect aRepaintRect(rInf.GetPaintRect()); + + if(rInf.GetTextFrame()->IsRightToLeft()) + rInf.GetTextFrame()->SwitchLTRtoRTL(aRepaintRect); + + if(rInf.GetTextFrame()->IsVertical()) + rInf.GetTextFrame()->SwitchHorizontalToVertical(aRepaintRect); + + if(!((m_pFly->IsCompletePaint() || + m_pFly->getFrameArea().Overlaps(aRepaintRect)) && + SwFlyFrame::IsPaint(m_pFly->GetVirtDrawObj(), m_pFly->getRootFrame()->GetCurrShell()))) + return; + + SwRect aRect(m_pFly->getFrameArea()); + if(!m_pFly->IsCompletePaint()) + aRect.Intersection_(aRepaintRect); + + // GetFlyFrame() may change the layout mode at the output device. + { + SwLayoutModeModifier aLayoutModeModifier(*rInf.GetOut()); + m_pFly->PaintSwFrame(const_cast(*rInf.GetOut()), aRect); + + // track changes: cross out the image, if it is deleted + const SwFrame *pFrame = m_pFly->Lower(); + if ( GetAuthor() != std::string::npos && IsDeleted() && pFrame ) + { + SwRect aPaintRect( pFrame->GetPaintArea() ); + + const AntialiasingFlags nFormerAntialiasing( rInf.GetOut()->GetAntialiasing() ); + const bool bIsAntiAliasing = officecfg::Office::Common::Drawinglayer::AntiAliasing::get(); + if ( bIsAntiAliasing ) + const_cast(*rInf.GetOut()).SetAntialiasing(AntialiasingFlags::Enable); + tools::Long startX = aPaintRect.Left( ), endX = aPaintRect.Right(); + tools::Long startY = aPaintRect.Top( ), endY = aPaintRect.Bottom(); + const_cast(*rInf.GetOut()).SetLineColor( + SwPostItMgr::GetColorAnchor(GetAuthor()) ); + const_cast(*rInf.GetOut()).DrawLine(Point(startX, startY), Point(endX, endY)); + const_cast(*rInf.GetOut()).DrawLine(Point(startX, endY), Point(endX, startY)); + if ( bIsAntiAliasing ) + const_cast(*rInf.GetOut()).SetAntialiasing(nFormerAntialiasing); + } + } + const_cast(rInf).GetRefDev()->SetLayoutMode(rInf.GetOut()->GetLayoutMode()); + + // As the OutputDevice might be anything, the font must be re-selected. + // Being in const method should not be a problem. + const_cast(rInf).SelectFont(); + + assert(rInf.GetVsh()); + SAL_WARN_IF(rInf.GetVsh()->GetOut() != rInf.GetOut(), "sw.core", "SwFlyCntPortion::Paint: Outdev has changed"); + if(rInf.GetVsh()) + const_cast(rInf).SetOut(rInf.GetVsh()->GetOut()); +} + +void sw::DrawFlyCntPortion::Paint(const SwTextPaintInfo&) const +{ + if(!m_pContact->GetAnchorFrame()) + { + // No direct positioning of the drawing object is needed + m_pContact->ConnectToLayout(); + } +} + +/** + * Use the dimensions of pFly->OutRect() + */ +SwFlyCntPortion::SwFlyCntPortion() + : m_bMax(false) + , m_bDeleted(false) + , m_nAuthor(std::string::npos) + , m_eAlign(sw::LineAlign::NONE) +{ + mnLineLength = TextFrameIndex(1); + SetWhichPor(PortionType::FlyCnt); +} + +sw::FlyContentPortion::FlyContentPortion(SwFlyInContentFrame* pFly) + : m_pFly(pFly) +{ + SAL_WARN_IF(!pFly, "sw.core", "SwFlyCntPortion::SwFlyCntPortion: no SwFlyInContentFrame!"); +} + +sw::DrawFlyCntPortion::DrawFlyCntPortion(SwFrameFormat const & rFormat) + : m_pContact(nullptr) +{ + rFormat.CallSwClientNotify(sw::CreatePortionHint(&m_pContact)); + assert(m_pContact); +} + +sw::FlyContentPortion* sw::FlyContentPortion::Create(const SwTextFrame& rFrame, SwFlyInContentFrame* pFly, const Point& rBase, tools::Long nLnAscent, tools::Long nLnDescent, tools::Long nFlyAsc, tools::Long nFlyDesc, AsCharFlags nFlags) +{ + auto pNew(new sw::FlyContentPortion(pFly)); + pNew->SetBase(rFrame, rBase, nLnAscent, nLnDescent, nFlyAsc, nFlyDesc, nFlags | AsCharFlags::UlSpace | AsCharFlags::Init); + return pNew; +} + +sw::DrawFlyCntPortion* sw::DrawFlyCntPortion::Create(const SwTextFrame& rFrame, SwFrameFormat const & rFormat, const Point& rBase, tools::Long nLnAscent, tools::Long nLnDescent, tools::Long nFlyAsc, tools::Long nFlyDesc, AsCharFlags nFlags) +{ + auto pNew(new DrawFlyCntPortion(rFormat)); + pNew->SetBase(rFrame, rBase, nLnAscent, nLnDescent, nFlyAsc, nFlyDesc, nFlags | AsCharFlags::UlSpace | AsCharFlags::Init); + return pNew; +} + +sw::DrawFlyCntPortion::~DrawFlyCntPortion() {}; +sw::FlyContentPortion::~FlyContentPortion() {}; + +SdrObject* sw::FlyContentPortion::GetSdrObj(const SwTextFrame&) +{ + return m_pFly->GetVirtDrawObj(); +} + +SdrObject* sw::DrawFlyCntPortion::GetSdrObj(const SwTextFrame& rFrame) +{ + SdrObject* pSdrObj; + // Determine drawing object ('master' or 'virtual') by frame + pSdrObj = m_pContact->GetDrawObjectByAnchorFrame(rFrame); + if(!pSdrObj) + { + SAL_WARN("sw.core", "SwFlyCntPortion::SetBase(..) - No drawing object found by GetDrawObjectByAnchorFrame( rFrame )>"); + pSdrObj = m_pContact->GetMaster(); + } + + // Call to assure that flag at + // the and at the instance are + // correctly set + if(pSdrObj) + m_pContact->GetAnchoredObj(pSdrObj)->MakeObjPos(); + return pSdrObj; +} + +/** + * After setting the RefPoints, the ascent needs to be recalculated + * because it is dependent on RelPos + * + * @param rBase CAUTION: needs to be an absolute value! + */ +void SwFlyCntPortion::SetBase( const SwTextFrame& rFrame, const Point &rBase, + tools::Long nLnAscent, tools::Long nLnDescent, + tools::Long nFlyAsc, tools::Long nFlyDesc, + AsCharFlags nFlags ) +{ + // Use new class to position object + // Determine drawing object + SdrObject* pSdrObj = GetSdrObj(rFrame); + if (!pSdrObj) + return; + + // position object + objectpositioning::SwAsCharAnchoredObjectPosition aObjPositioning( + *pSdrObj, + rBase, nFlags, + nLnAscent, nLnDescent, nFlyAsc, nFlyDesc ); + + // Scope of local variable + { + SwObjPositioningInProgress aObjPosInProgress( *pSdrObj ); + aObjPositioning.CalcPosition(); + } + + if (auto pFormat = FindFrameFormat(pSdrObj)) + { + if (pFormat->GetOtherTextBoxFormats() + && pFormat->GetAnchor().GetAnchorId() == RndStdIds::FLY_AS_CHAR) + { + // TODO: Improve security with moving this sync call to other place, + // where it works for typing but not during layout calc. + const bool bModified = pFormat->GetDoc()->getIDocumentState().IsEnableSetModified(); + pFormat->GetDoc()->getIDocumentState().SetEnableSetModified(false); + SwTextBoxHelper::synchronizeGroupTextBoxProperty(SwTextBoxHelper::changeAnchor, pFormat, + pFormat->FindRealSdrObject()); + SwTextBoxHelper::synchronizeGroupTextBoxProperty(SwTextBoxHelper::syncTextBoxSize, + pFormat, pFormat->FindRealSdrObject()); + pFormat->GetDoc()->getIDocumentState().SetEnableSetModified(bModified); + } + } + + SetAlign( aObjPositioning.GetLineAlignment() ); + + m_aRef = aObjPositioning.GetAnchorPos(); + if( nFlags & AsCharFlags::Rotate ) + SvXSize( aObjPositioning.GetObjBoundRectInclSpacing().SSize() ); + else + SvLSize( aObjPositioning.GetObjBoundRectInclSpacing().SSize() ); + if( Height() ) + { + // GetRelPosY returns the relative position to baseline (if 0, the + // upper border of the FlyCnt if on the baseline of a line) + SwTwips nRelPos = aObjPositioning.GetRelPosY(); + if ( nRelPos < 0 ) + { + mnAscent = -nRelPos; + if( mnAscent > Height() ) + Height( mnAscent ); + } + else + { + mnAscent = 0; + Height( Height() + o3tl::narrowing(nRelPos) ); + } + } + else + { + Height( 1 ); + mnAscent = 0; + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/porfly.hxx b/sw/source/core/text/porfly.hxx new file mode 100644 index 0000000000..a519c1109c --- /dev/null +++ b/sw/source/core/text/porfly.hxx @@ -0,0 +1,95 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include + +#include "porglue.hxx" +#include + +class SwDrawContact; +class SwTextFrame; +struct SwCursorMoveState; + +class SwFlyPortion : public SwFixPortion +{ + sal_uInt16 m_nBlankWidth; +public: + explicit SwFlyPortion( const SwRect &rFlyRect ) + : SwFixPortion(rFlyRect), m_nBlankWidth( 0 ) { SetWhichPor( PortionType::Fly ); } + sal_uInt16 GetBlankWidth( ) const { return m_nBlankWidth; } + void SetBlankWidth( const sal_uInt16 nNew ) { m_nBlankWidth = nNew; } + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + virtual bool Format( SwTextFormatInfo &rInf ) override; +}; + +/// This portion represents an as-character anchored fly (shape, frame, etc.) +class SwFlyCntPortion : public SwLinePortion +{ + Point m_aRef; // Relatively to this point we calculate the AbsPos + bool m_bMax; // Line adjustment and height == line height + bool m_bDeleted; // Part of tracked deletion: it needs strikethrough + size_t m_nAuthor; // Redline author for color of the strikethrough + sw::LineAlign m_eAlign; + + virtual SdrObject* GetSdrObj(const SwTextFrame&) =0; + +public: + SwFlyCntPortion(); + const Point& GetRefPoint() const { return m_aRef; } + bool IsMax() const { return m_bMax; } + bool IsDeleted() const { return m_bDeleted; } + void SetAuthor(size_t nAuthor) { m_nAuthor = nAuthor; } + size_t GetAuthor() const { return m_nAuthor; } + sw::LineAlign GetAlign() const { return m_eAlign; } + void SetAlign(sw::LineAlign eAlign) { m_eAlign = eAlign; } + void SetMax(bool bMax) { m_bMax = bMax; } + void SetDeleted(bool bDeleted) { m_bDeleted = bDeleted; } + void SetBase(const SwTextFrame& rFrame, const Point& rBase, tools::Long nLnAscent, tools::Long nLnDescent, tools::Long nFlyAscent, tools::Long nFlyDescent, AsCharFlags nFlags); + virtual bool Format(SwTextFormatInfo& rInf) override; +}; + +namespace sw +{ + class FlyContentPortion final : public SwFlyCntPortion + { + SwFlyInContentFrame* m_pFly; + virtual SdrObject* GetSdrObj(const SwTextFrame&) override; + public: + FlyContentPortion(SwFlyInContentFrame* pFly); + static FlyContentPortion* Create(const SwTextFrame& rFrame, SwFlyInContentFrame* pFly, const Point& rBase, tools::Long nAscent, tools::Long nDescent, tools::Long nFlyAsc, tools::Long nFlyDesc, AsCharFlags nFlags); + SwFlyInContentFrame* GetFlyFrame() { return m_pFly; } + void GetFlyCursorOfst(Point& rPoint, SwPosition& rPos, SwCursorMoveState* pCMS) const { m_pFly->GetModelPositionForViewPoint(&rPos, rPoint, pCMS); }; + virtual void Paint(const SwTextPaintInfo& rInf) const override; + virtual ~FlyContentPortion() override; + }; + class DrawFlyCntPortion final : public SwFlyCntPortion + { + SwDrawContact* m_pContact; + virtual SdrObject* GetSdrObj(const SwTextFrame&) override; + public: + DrawFlyCntPortion(SwFrameFormat const & rFormat); + static DrawFlyCntPortion* Create(const SwTextFrame& rFrame, SwFrameFormat const & rFormat, const Point& rBase, tools::Long nAsc, tools::Long nDescent, tools::Long nFlyAsc, tools::Long nFlyDesc, AsCharFlags nFlags); + virtual void Paint(const SwTextPaintInfo& rInf) const override; + virtual ~DrawFlyCntPortion() override; + }; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/porftn.hxx b/sw/source/core/text/porftn.hxx new file mode 100644 index 0000000000..925a04f779 --- /dev/null +++ b/sw/source/core/text/porftn.hxx @@ -0,0 +1,104 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include + +#include + +#include "porfld.hxx" + +class SwTextFootnote; + +class SwFootnotePortion : public SwFieldPortion +{ + SwTextFootnote *m_pFootnote; + sal_uInt16 m_nOrigHeight; + // #i98418# + bool mbPreferredScriptTypeSet; + SwFontScript mnPreferredScriptType; +public: + SwFootnotePortion( const OUString &rExpand, SwTextFootnote *pFootnote, + sal_uInt16 nOrig = USHRT_MAX ); + sal_uInt16& Orig() { return m_nOrigHeight; } + + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + virtual bool GetExpText( const SwTextSizeInfo &rInf, OUString &rText ) const override; + virtual SwPosSize GetTextSize( const SwTextSizeInfo &rInfo ) const override; + virtual bool Format( SwTextFormatInfo &rInf ) override; + + // #i98418# + void SetPreferredScriptType( SwFontScript nPreferredScriptType ); + + const SwTextFootnote* GetTextFootnote() const { return m_pFootnote; }; +}; + +class SwFootnoteNumPortion : public SwNumberPortion +{ +public: + SwFootnoteNumPortion( const OUString &rExpand, std::unique_ptr pFntL ) + : SwNumberPortion( rExpand, std::move(pFntL), true, false, 0, false ) + { SetWhichPor( PortionType::FootnoteNum ); } +}; + +/** + * Used in footnotes if they break across pages, master has this portion at the end. + * + * Created only in case Tools -> Footnotes and Endnotes sets the End of footnote to a non-empty + * value. + */ +class SwQuoVadisPortion : public SwFieldPortion +{ + OUString m_aErgo; +public: + SwQuoVadisPortion( const OUString &rExp, OUString aStr ); + virtual bool Format( SwTextFormatInfo &rInf ) override; + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + virtual bool GetExpText( const SwTextSizeInfo &rInf, OUString &rText ) const override; + + void SetNumber( const OUString& rStr ) { m_aErgo = rStr; } + const OUString& GetQuoText() const { return m_aExpand; } + const OUString &GetContText() const { return m_aErgo; } + + // Field cloner for SplitGlue + virtual SwFieldPortion *Clone( const OUString &rExpand ) const override; + + // Accessibility: pass information about this portion to the PortionHandler + virtual void HandlePortion( SwPortionHandler& rPH ) const override; +}; + +/** + * Used in footnotes if they break across pages, follow starts with this portion. + * + * Created only in case Tools -> Footnotes and Endnotes sets the Start of next page to a non-empty + * value. + */ +class SwErgoSumPortion : public SwFieldPortion +{ +public: + SwErgoSumPortion( const OUString &rExp, std::u16string_view rStr ); + virtual TextFrameIndex GetModelPositionForViewPoint(sal_uInt16 nOfst) const override; + virtual bool Format( SwTextFormatInfo &rInf ) override; + + // Field cloner for SplitGlue + virtual SwFieldPortion *Clone( const OUString &rExpand ) const override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/porglue.cxx b/sw/source/core/text/porglue.cxx new file mode 100644 index 0000000000..5f1fd2a7dc --- /dev/null +++ b/sw/source/core/text/porglue.cxx @@ -0,0 +1,285 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include +#include "porglue.hxx" +#include "inftxt.hxx" +#include "porlay.hxx" +#include "porfly.hxx" +#include + +SwGluePortion::SwGluePortion( const sal_uInt16 nInitFixWidth ) + : m_nFixWidth( nInitFixWidth ) +{ + PrtWidth( m_nFixWidth ); + SetWhichPor( PortionType::Glue ); +} + +TextFrameIndex SwGluePortion::GetModelPositionForViewPoint(const sal_uInt16 nOfst) const +{ + // FIXME why nOfst > GetLen() ? is that supposed to be > Width() ? + if( !GetLen() || nOfst > sal_Int32(GetLen()) || !Width() ) + return SwLinePortion::GetModelPositionForViewPoint( nOfst ); + else + return TextFrameIndex(nOfst / (Width() / sal_Int32(GetLen()))); +} + +SwPosSize SwGluePortion::GetTextSize( const SwTextSizeInfo &rInf ) const +{ + if (TextFrameIndex(1) >= GetLen() || rInf.GetLen() > GetLen() || !Width() || !GetLen()) + return SwPosSize(*this); + else + return SwPosSize((Width() / sal_Int32(GetLen())) * sal_Int32(rInf.GetLen()), Height()); +} + +bool SwGluePortion::GetExpText( const SwTextSizeInfo &rInf, OUString &rText ) const +{ + if( GetLen() && rInf.OnWin() && + rInf.GetOpt().IsBlank() && rInf.IsNoSymbol() ) + { + OUStringBuffer aBuf(GetLen().get()); + comphelper::string::padToLength(aBuf, sal_Int32(GetLen()), CH_BULLET); + rText = aBuf.makeStringAndClear(); + return true; + } + return false; +} + +void SwGluePortion::Paint( const SwTextPaintInfo &rInf ) const +{ + if( !GetLen() ) + return; + + if( rInf.GetFont()->IsPaintBlank() ) + { + const sal_Int32 nCount = GetFixWidth() / sal_Int32(GetLen()); + OUStringBuffer aBuf(nCount); + comphelper::string::padToLength(aBuf, nCount, ' '); + OUString aText(aBuf.makeStringAndClear()); + SwTextPaintInfo aInf( rInf, &aText ); + aInf.DrawText(*this, TextFrameIndex(aText.getLength()), true); + } + + if( !(rInf.OnWin() && rInf.GetOpt().IsBlank() && rInf.IsNoSymbol()) ) + return; + +#if OSL_DEBUG_LEVEL > 0 + const sal_Unicode cChar = rInf.GetChar( rInf.GetIdx() ); + OSL_ENSURE( CH_BLANK == cChar || CH_BULLET == cChar, + "SwGluePortion::Paint: blank expected" ); +#endif + if (TextFrameIndex(1) == GetLen()) + { + OUString aBullet( CH_BULLET ); + SwPosSize aBulletSize( rInf.GetTextSize( aBullet ) ); + Point aPos( rInf.GetPos() ); + aPos.AdjustX((Width()/2) - (aBulletSize.Width()/2) ); + SwTextPaintInfo aInf( rInf, &aBullet ); + aInf.SetPos( aPos ); + SwTextPortion aBulletPor; + aBulletPor.Width( aBulletSize.Width() ); + aBulletPor.Height( aBulletSize.Height() ); + aBulletPor.SetAscent( GetAscent() ); + aInf.DrawText(aBulletPor, TextFrameIndex(aBullet.getLength()), true); + } + else + { + SwTextSlot aSlot( &rInf, this, true, false ); + rInf.DrawText( *this, rInf.GetLen(), true ); + } +} + +void SwGluePortion::MoveGlue( SwGluePortion *pTarget, const tools::Long nPrtGlue ) +{ + auto nPrt = std::min( nPrtGlue, GetPrtGlue() ); + if( 0 < nPrt ) + { + pTarget->AddPrtWidth( nPrt ); //TODO: overflow + SubPrtWidth( nPrt ); //TODO: overflow + } +} + +void SwGluePortion::Join( SwGluePortion *pVictim ) +{ + // The GluePortion is extracted and flushed away ... + AddPrtWidth( pVictim->PrtWidth() ); + SetLen( pVictim->GetLen() + GetLen() ); + if( Height() < pVictim->Height() ) + Height( pVictim->Height() ); + + AdjFixWidth(); + Cut( pVictim ); + delete pVictim; +} + +void SwGluePortion::dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, + TextFrameIndex& nOffset) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwGluePortion")); + dumpAsXmlAttributes(pWriter, rText, nOffset); + nOffset += GetLen(); + + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("fix-width"), BAD_CAST(OString::number(m_nFixWidth).getStr())); + + (void)xmlTextWriterEndElement(pWriter); +} + +/** + * We're expecting a frame-local SwRect! + */ +SwFixPortion::SwFixPortion( const SwRect &rRect ) + :SwGluePortion( sal_uInt16(rRect.Width()) ), m_nFix( sal_uInt16(rRect.Left()) ) +{ + Height( sal_uInt16(rRect.Height()) ); + SetWhichPor( PortionType::Fix ); +} + +SwFixPortion::SwFixPortion() + : SwGluePortion(0), m_nFix(0) +{ + SetWhichPor( PortionType::Fix ); +} + +void SwFixPortion::dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, TextFrameIndex& nOffset) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwFixPortion")); + dumpAsXmlAttributes(pWriter, rText, nOffset); + nOffset += GetLen(); + + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("fix"), + BAD_CAST(OString::number(m_nFix).getStr())); + + (void)xmlTextWriterEndElement(pWriter); +} + +SwMarginPortion::SwMarginPortion() + :SwGluePortion( 0 ) +{ + SetWhichPor( PortionType::Margin ); +} + +/** + * In the outer loop all portions are inspected - the GluePortions + * at the end are processed first. + * The end is shifted forwardly till no more GluePortions remain. + * Always GluePortion-pairs (pLeft and pRight) are treated, where + * textportions between pLeft and pRight are moved at the back of + * pRight if pRight has enough Glue. With every move part of the + * Glue is transferred from pRight to pLeft. + * The next loop starts with the processed pLeft as pRight. + */ +void SwMarginPortion::AdjustRight( const SwLineLayout *pCurr ) +{ + SwGluePortion *pRight = nullptr; + bool bNoMove = nullptr != pCurr->GetpKanaComp(); + while( pRight != this ) + { + + // 1) We search for the left Glue + SwLinePortion *pPos = this; + SwGluePortion *pLeft = nullptr; + while( pPos ) + { + if( pPos->InFixMargGrp() ) + pLeft = static_cast(pPos); + pPos = pPos->GetNextPortion(); + if( pPos == pRight) + pPos = nullptr; + } + + // Two adjoining FlyPortions are merged + if( pRight && pLeft && pLeft->GetNextPortion() == pRight ) + { + pRight->MoveAllGlue( pLeft ); + pRight = nullptr; + } + auto nRightGlue = pRight && 0 < pRight->GetPrtGlue() + ? pRight->GetPrtGlue() : 0; + // 2) balance left and right Glue + // But not for tabs ... + if( pLeft && nRightGlue && !pRight->InTabGrp() ) + { + // pPrev is the portion immediately before pRight + SwLinePortion *pPrev = pRight->FindPrevPortion( pLeft ); + + if ( pRight->IsFlyPortion() && pRight->GetLen() ) + { + SwFlyPortion *pFly = static_cast(pRight); + if ( pFly->GetBlankWidth() < nRightGlue ) + { + // Creating new TextPortion, that takes over the + // Blank previously swallowed by the Fly. + nRightGlue = nRightGlue - pFly->GetBlankWidth(); + pFly->SubPrtWidth( pFly->GetBlankWidth() ); + pFly->SetLen(TextFrameIndex(0)); + SwTextPortion *pNewPor = new SwTextPortion; + pNewPor->SetLen(TextFrameIndex(1)); + pNewPor->Height( pFly->Height() ); + pNewPor->Width( pFly->GetBlankWidth() ); + pFly->Insert( pNewPor ); + } + else + pPrev = pLeft; + } + while( pPrev != pLeft ) + { + if( bNoMove || pPrev->PrtWidth() >= nRightGlue || + pPrev->InHyphGrp() || pPrev->IsKernPortion() ) + { + // The portion before the pRight cannot be moved + // because no Glue is remaining. + // We set the break condition: + pPrev = pLeft; + } + else + { + nRightGlue = nRightGlue - pPrev->PrtWidth(); + // pPrev is moved behind pRight. For this the + // Glue value between pRight and pLeft gets balanced. + pRight->MoveGlue( pLeft, pPrev->PrtWidth() ); + // Now fix the linking of our portions. + SwLinePortion *pPrevPrev = pPrev->FindPrevPortion( pLeft ); + pPrevPrev->SetNextPortion( pRight ); + pPrev->SetNextPortion( pRight->GetNextPortion() ); + pRight->SetNextPortion( pPrev ); + if ( pPrev->GetNextPortion() && pPrev->InTextGrp() + && pPrev->GetNextPortion()->IsHolePortion() ) + { + SwHolePortion *pHolePor = + static_cast(pPrev->GetNextPortion()); + if ( !pHolePor->GetNextPortion() || + !pHolePor->GetNextPortion()->InFixMargGrp() ) + { + pPrev->AddPrtWidth( pHolePor->GetBlankWidth() ); + pPrev->SetLen(pPrev->GetLen() + TextFrameIndex(1)); + pPrev->SetNextPortion( pHolePor->GetNextPortion() ); + delete pHolePor; + } + } + pPrev = pPrevPrev; + } + } + } + // If no left Glue remains, we set the break condition. + pRight = pLeft ? pLeft : this; + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/porglue.hxx b/sw/source/core/text/porglue.hxx new file mode 100644 index 0000000000..aaaeec339f --- /dev/null +++ b/sw/source/core/text/porglue.hxx @@ -0,0 +1,93 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include "porlin.hxx" + +class SwRect; +class SwLineLayout; + +/// A glue portion is either a base class for other portions that want to have a certain width to +/// push text out (e.g. tab portions) or used to align SwQuoVadisPortion instances on the right for +/// footnotes. +class SwGluePortion : public SwLinePortion +{ +private: + sal_uInt16 m_nFixWidth; +public: + explicit SwGluePortion( const sal_uInt16 nInitFixWidth ); + + void Join( SwGluePortion *pVictim ); + + inline tools::Long GetPrtGlue() const; + sal_uInt16 GetFixWidth() const { return m_nFixWidth; } + void SetFixWidth( const sal_uInt16 nNew ) { m_nFixWidth = nNew; } + void MoveGlue( SwGluePortion *pTarget, const tools::Long nPrtGlue ); + inline void MoveAllGlue( SwGluePortion *pTarget ); + inline void MoveHalfGlue( SwGluePortion *pTarget ); + inline void AdjFixWidth(); + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + virtual TextFrameIndex GetModelPositionForViewPoint(sal_uInt16 nOfst) const override; + virtual SwPosSize GetTextSize( const SwTextSizeInfo &rInfo ) const override; + virtual bool GetExpText( const SwTextSizeInfo &rInf, OUString &rText ) const override; + + void dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, TextFrameIndex& nOffset) const override; +}; + +class SwFixPortion : public SwGluePortion +{ + sal_uInt16 m_nFix; // The width offset in the line +public: + explicit SwFixPortion( const SwRect &rFlyRect ); + SwFixPortion(); + void SetFix( const sal_uInt16 nNewFix ) { m_nFix = nNewFix; } + sal_uInt16 GetFix() const { return m_nFix; } + + void dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, TextFrameIndex& nOffset) const override; +}; + +class SwMarginPortion : public SwGluePortion +{ +public: + explicit SwMarginPortion(); + void AdjustRight( const SwLineLayout* pCurr ); +}; + +inline tools::Long SwGluePortion::GetPrtGlue() const +{ return Width() - m_nFixWidth; } + +// The FixWidth MUST NEVER be larger than the accumulated width! +inline void SwGluePortion::AdjFixWidth() +{ + if( m_nFixWidth > PrtWidth() ) + m_nFixWidth = PrtWidth(); +} + +inline void SwGluePortion::MoveAllGlue( SwGluePortion *pTarget ) +{ + MoveGlue( pTarget, GetPrtGlue() ); +} + +inline void SwGluePortion::MoveHalfGlue( SwGluePortion *pTarget ) +{ + MoveGlue( pTarget, GetPrtGlue() / 2 ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/porhyph.hxx b/sw/source/core/text/porhyph.hxx new file mode 100644 index 0000000000..dc3c6651d0 --- /dev/null +++ b/sw/source/core/text/porhyph.hxx @@ -0,0 +1,88 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#pragma once + +#include + +#include + +#include "porexp.hxx" + +class SwHyphPortion : public SwExpandPortion +{ +public: + SwHyphPortion() + { + SetWhichPor( PortionType::Hyphen ); + } + virtual bool GetExpText( const SwTextSizeInfo &rInf, OUString &rText ) const override; + virtual bool Format( SwTextFormatInfo &rInf ) override; + + // Accessibility: pass information about this portion to the PortionHandler + virtual void HandlePortion( SwPortionHandler& rPH ) const override; + + void dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, + TextFrameIndex& nOffset) const override; +}; + +class SwHyphStrPortion : public SwHyphPortion +{ + OUString m_aExpand; +public: + explicit SwHyphStrPortion(std::u16string_view rStr) + : m_aExpand(OUString::Concat(rStr) + "-") + { + SetWhichPor( PortionType::HyphenStr ); + } + + virtual bool GetExpText( const SwTextSizeInfo &rInf, OUString &rText ) const override; + + // Accessibility: pass information about this portion to the PortionHandler + virtual void HandlePortion( SwPortionHandler& rPH ) const override; +}; + +class SwSoftHyphPortion : public SwHyphPortion +{ + bool m_bExpand; + sal_uInt16 m_nViewWidth; + +public: + SwSoftHyphPortion(); + virtual bool GetExpText( const SwTextSizeInfo &rInf, OUString &rText ) const override; + virtual SwLinePortion *Compress() override; + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + virtual bool Format( SwTextFormatInfo &rInf ) override; + virtual void FormatEOL( SwTextFormatInfo &rInf ) override; + void SetExpand( const bool bNew ) { m_bExpand = bNew; } + bool IsExpand() const { return m_bExpand; } + + virtual sal_uInt16 GetViewWidth( const SwTextSizeInfo &rInf ) const override; + + // Accessibility: pass information about this portion to the PortionHandler + virtual void HandlePortion( SwPortionHandler& rPH ) const override; +}; + +class SwSoftHyphStrPortion : public SwHyphStrPortion +{ +public: + explicit SwSoftHyphStrPortion( std::u16string_view rStr ); + virtual void Paint( const SwTextPaintInfo &rInf ) const override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/porlay.cxx b/sw/source/core/text/porlay.cxx new file mode 100644 index 0000000000..cae54845be --- /dev/null +++ b/sw/source/core/text/porlay.cxx @@ -0,0 +1,2996 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include + +#include + +#include "porlay.hxx" +#include "itrform2.hxx" +#include "porglue.hxx" +#include "redlnitr.hxx" +#include "porfly.hxx" +#include "porrst.hxx" +#include "pormulti.hxx" +#include "pordrop.hxx" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +using namespace ::com::sun::star; +using namespace i18n::ScriptType; + +/* + https://www.khtt.net/en/page/1821/the-big-kashida-secret + + the rules of priorities that govern the addition of kashidas in Arabic text + made ... for ... Explorer 5.5 browser. + + The kashida justification is based on a connection priority scheme that + decides where kashidas are put automatically. + + This is how the software decides on kashida-inserting priorities: + 1. First it looks for characters with the highest priority in each word, + which means kashida-extensions will only been used in one position in each + word. Not more. + 2. The kashida will be connected to the character with the highest priority. + 3. If kashida connection opportunities are found with an equal level of + priority in one word, the kashida will be placed towards the end of the + word. + + The priority list of characters and the positioning is as follows: + 1. after a kashida that is manually placed in the text by the user, + 2. after a Seen or Sad (initial and medial form), + 3. before the final form of Taa Marbutah, Haa, Dal, + 4. before the final form of Alef, Tah Lam, Kaf and Gaf, + 5. before the preceding medial Baa of Ra, Ya and Alef Maqsurah, + 6. before the final form of Waw, Ain, Qaf and Fa, + 7. before the final form of other characters that can be connected. +*/ + +#define IS_JOINING_GROUP(c, g) ( u_getIntPropertyValue( (c), UCHAR_JOINING_GROUP ) == U_JG_##g ) +#define isAinChar(c) IS_JOINING_GROUP((c), AIN) +#define isAlefChar(c) IS_JOINING_GROUP((c), ALEF) +#define isDalChar(c) IS_JOINING_GROUP((c), DAL) +#define isFehChar(c) (IS_JOINING_GROUP((c), FEH) || IS_JOINING_GROUP((c), AFRICAN_FEH)) +#define isGafChar(c) IS_JOINING_GROUP((c), GAF) +#define isHehChar(c) IS_JOINING_GROUP((c), HEH) +#define isKafChar(c) IS_JOINING_GROUP((c), KAF) +#define isLamChar(c) IS_JOINING_GROUP((c), LAM) +#define isQafChar(c) (IS_JOINING_GROUP((c), QAF) || IS_JOINING_GROUP((c), AFRICAN_QAF)) +#define isRehChar(c) IS_JOINING_GROUP((c), REH) +#define isTahChar(c) IS_JOINING_GROUP((c), TAH) +#define isTehMarbutaChar(c) IS_JOINING_GROUP((c), TEH_MARBUTA) +#define isWawChar(c) IS_JOINING_GROUP((c), WAW) +#define isSeenOrSadChar(c) (IS_JOINING_GROUP((c), SAD) || IS_JOINING_GROUP((c), SEEN)) + +// Beh and characters that behave like Beh in medial form. +static bool isBehChar(sal_Unicode cCh) +{ + bool bRet = false; + switch (u_getIntPropertyValue(cCh, UCHAR_JOINING_GROUP)) + { + case U_JG_BEH: + case U_JG_NOON: + case U_JG_AFRICAN_NOON: + case U_JG_NYA: + case U_JG_YEH: + case U_JG_FARSI_YEH: + case U_JG_BURUSHASKI_YEH_BARREE: + bRet = true; + break; + default: + bRet = false; + break; + } + + return bRet; +} + +// Yeh and characters that behave like Yeh in final form. +static bool isYehChar(sal_Unicode cCh) +{ + bool bRet = false; + switch (u_getIntPropertyValue(cCh, UCHAR_JOINING_GROUP)) + { + case U_JG_YEH: + case U_JG_FARSI_YEH: + case U_JG_YEH_BARREE: + case U_JG_BURUSHASKI_YEH_BARREE: + case U_JG_YEH_WITH_TAIL: + bRet = true; + break; + default: + bRet = false; + break; + } + + return bRet; +} + +static bool isTransparentChar ( sal_Unicode cCh ) +{ + return u_getIntPropertyValue( cCh, UCHAR_JOINING_TYPE ) == U_JT_TRANSPARENT; +} + +// Checks if cCh + cNectCh builds a ligature (used for Kashidas) +static bool lcl_IsLigature( sal_Unicode cCh, sal_Unicode cNextCh ) +{ + // Lam + Alef + return ( isLamChar ( cCh ) && isAlefChar ( cNextCh )); +} + +// Checks if cCh is connectable to cPrevCh (used for Kashidas) +static bool lcl_ConnectToPrev( sal_Unicode cCh, sal_Unicode cPrevCh ) +{ + const int32_t nJoiningType = u_getIntPropertyValue( cPrevCh, UCHAR_JOINING_TYPE ); + bool bRet = nJoiningType != U_JT_RIGHT_JOINING && nJoiningType != U_JT_NON_JOINING; + + // check for ligatures cPrevChar + cChar + if( bRet ) + bRet = !lcl_IsLigature( cPrevCh, cCh ); + + return bRet; +} + +static bool lcl_HasStrongLTR ( std::u16string_view rText, sal_Int32 nStart, sal_Int32 nEnd ) + { + for( sal_Int32 nCharIdx = nStart; nCharIdx < nEnd; ++nCharIdx ) + { + const UCharDirection nCharDir = u_charDirection ( rText[ nCharIdx ] ); + if ( nCharDir == U_LEFT_TO_RIGHT || + nCharDir == U_LEFT_TO_RIGHT_EMBEDDING || + nCharDir == U_LEFT_TO_RIGHT_OVERRIDE ) + return true; + } + return false; + } + +// This is (meant to be) functionally equivalent to 'delete m_pNext' where +// deleting a SwLineLayout recursively deletes the owned m_pNext SwLineLayout. +// +// Here, instead of using a potentially deep stack, iterate over all the +// SwLineLayouts that would be deleted recursively and delete them linearly +void SwLineLayout::DeleteNext() +{ + if (!m_pNext) + return; + SwLineLayout* pNext = m_pNext; + do + { + SwLineLayout* pLastNext = pNext; + pNext = pNext->GetNext(); + pLastNext->SetNext(nullptr); + delete pLastNext; + } + while (pNext); +} + +void SwLineLayout::Height(const SwTwips nNew, const bool bText) +{ + SwPosSize::Height(nNew); + if (bText) + m_nTextHeight = nNew; +} + +// class SwLineLayout: This is the layout of a single line, which is made +// up of its dimension, the character count and the word spacing in the line. +// Line objects are managed in an own pool, in order to store them continuously +// in memory so that they are paged out together and don't fragment memory. +SwLineLayout::~SwLineLayout() +{ + Truncate(); + DeleteNext(); + m_pLLSpaceAdd.reset(); + m_pKanaComp.reset(); +} + +SwLinePortion *SwLineLayout::Insert( SwLinePortion *pIns ) +{ + // First attribute change: copy mass and length from *pIns into the first + // text portion + if( !mpNextPortion ) + { + if( GetLen() ) + { + mpNextPortion = SwTextPortion::CopyLinePortion(*this); + if( IsBlinking() ) + { + SetBlinking( false ); + } + } + else + { + SetNextPortion( pIns ); + return pIns; + } + } + // Call with scope or we'll end up with recursion! + return mpNextPortion->SwLinePortion::Insert( pIns ); +} + +SwLinePortion *SwLineLayout::Append( SwLinePortion *pIns ) +{ + // First attribute change: copy mass and length from *pIns into the first + // text portion + if( !mpNextPortion ) + mpNextPortion = SwTextPortion::CopyLinePortion(*this); + // Call with scope or we'll end up with recursion! + return mpNextPortion->SwLinePortion::Append( pIns ); +} + +// For special treatment of empty lines + +bool SwLineLayout::Format( SwTextFormatInfo &rInf ) +{ + if( GetLen() ) + return SwTextPortion::Format( rInf ); + + Height( rInf.GetTextHeight() ); + return true; +} + +// We collect all FlyPortions at the beginning of the line and make that a +// MarginPortion. +SwMarginPortion *SwLineLayout::CalcLeftMargin() +{ + SwMarginPortion *pLeft = (GetNextPortion() && GetNextPortion()->IsMarginPortion()) ? + static_cast(GetNextPortion()) : nullptr; + if( !GetNextPortion() ) + SetNextPortion(SwTextPortion::CopyLinePortion(*this)); + if( !pLeft ) + { + pLeft = new SwMarginPortion; + pLeft->SetNextPortion( GetNextPortion() ); + SetNextPortion( pLeft ); + } + else + { + pLeft->Height( 0 ); + pLeft->Width( 0 ); + pLeft->SetLen(TextFrameIndex(0)); + pLeft->SetAscent( 0 ); + pLeft->SetNextPortion( nullptr ); + pLeft->SetFixWidth(0); + } + + SwLinePortion *pPos = pLeft->GetNextPortion(); + while( pPos ) + { + if( pPos->IsFlyPortion() ) + { + // The FlyPortion gets sucked out... + pLeft->Join( static_cast(pPos) ); + pPos = pLeft->GetNextPortion(); + if( GetpKanaComp() && !GetKanaComp().empty() ) + GetKanaComp().pop_front(); + } + else + pPos = nullptr; + } + return pLeft; +} + +void SwLineLayout::InitSpaceAdd() +{ + if ( !m_pLLSpaceAdd ) + CreateSpaceAdd(); + else + SetLLSpaceAdd( 0, 0 ); +} + +void SwLineLayout::CreateSpaceAdd( const tools::Long nInit ) +{ + m_pLLSpaceAdd.reset( new std::vector ); + SetLLSpaceAdd( nInit, 0 ); +} + +// #i3952# Returns true if there are only blanks in [nStt, nEnd[ +// Used to implement IgnoreTabsAndBlanksForLineCalculation compat flag +static bool lcl_HasOnlyBlanks(std::u16string_view rText, TextFrameIndex nStt, TextFrameIndex nEnd) +{ + while ( nStt < nEnd ) + { + switch (rText[sal_Int32(nStt++)]) + { + case 0x0020: // SPACE + case 0x2002: // EN SPACE + case 0x2003: // EM SPACE + case 0x2005: // FOUR-PER-EM SPACE + case 0x3000: // IDEOGRAPHIC SPACE + continue; + default: + return false; + } + } + return true; +} + +// Swapped out from FormatLine() +void SwLineLayout::CalcLine( SwTextFormatter &rLine, SwTextFormatInfo &rInf ) +{ + const sal_uInt16 nLineWidth = rInf.RealWidth(); + + sal_uInt16 nFlyAscent = 0; + sal_uInt16 nFlyHeight = 0; + sal_uInt16 nFlyDescent = 0; + + // If this line has a clearing break, then this is the portion's height. + sal_uInt16 nBreakHeight = 0; + + bool bOnlyPostIts = true; + SetHanging( false ); + + bool bTmpDummy = !GetLen(); + SwFlyCntPortion* pFlyCnt = nullptr; + if( bTmpDummy ) + { + nFlyAscent = 0; + nFlyHeight = 0; + nFlyDescent = 0; + } + + // #i3952# + const bool bIgnoreBlanksAndTabsForLineHeightCalculation = + rInf.GetTextFrame()->GetDoc().getIDocumentSettingAccess().get( + DocumentSettingId::IGNORE_TABS_AND_BLANKS_FOR_LINE_CALCULATION); + + bool bHasBlankPortion = false; + bool bHasOnlyBlankPortions = true; + bool bHasFlyPortion = false; + + if( mpNextPortion ) + { + SetContent( false ); + if( mpNextPortion->IsBreakPortion() ) + { + SetLen( mpNextPortion->GetLen() ); + if( GetLen() ) + bTmpDummy = false; + } + else + { + const SwTwips nLineHeight = Height(); + Init( GetNextPortion() ); + SwLinePortion *pPos = mpNextPortion; + SwLinePortion *pLast = this; + sal_uInt16 nMaxDescent = 0; + + // A group is a segment in the portion chain of pCurr or a fixed + // portion spanning to the end or the next fixed portion + while( pPos ) + { + SAL_WARN_IF( PortionType::NONE == pPos->GetWhichPor(), + "sw.core", "SwLineLayout::CalcLine: don't use SwLinePortions !" ); + + // Null portions are eliminated. They can form if two FlyFrames + // overlap. + // coverity[deref_arg] - "Cut" means next "GetNextPortion" returns a different Portion + if( !pPos->Compress() ) + { + // Only take over Height and Ascent if the rest of the line + // is empty. + if( !pPos->GetNextPortion() ) + { + if( !Height() ) + Height( pPos->Height(), false ); + if( !GetAscent() ) + SetAscent( pPos->GetAscent() ); + } + SwLinePortion* pPortion = pLast->Cut( pPos ); + rLine.ClearIfIsFirstOfBorderMerge(pPortion); + delete pPortion; + pPos = pLast->GetNextPortion(); + continue; + } + + TextFrameIndex const nPorSttIdx = rInf.GetLineStart() + mnLineLength; + mnLineLength += pPos->GetLen(); + AddPrtWidth( pPos->Width() ); + + // #i3952# + if (bIgnoreBlanksAndTabsForLineHeightCalculation && !rInf.GetLineStart()) + { + if ( pPos->InTabGrp() || pPos->IsHolePortion() || + ( pPos->IsTextPortion() && + lcl_HasOnlyBlanks( rInf.GetText(), nPorSttIdx, nPorSttIdx + pPos->GetLen() ) ) ) + { + pLast = pPos; + pPos = pPos->GetNextPortion(); + bHasBlankPortion = true; + continue; + } + } + + // Ignore drop portion height + // tdf#130804 ... and bookmark portions + if ((pPos->IsDropPortion() && static_cast(pPos)->GetLines() > 1) + || pPos->GetWhichPor() == PortionType::Bookmark) + { + pLast = pPos; + pPos = pPos->GetNextPortion(); + continue; + } + + bHasOnlyBlankPortions = false; + + // We had an attribute change: Sum up/build maxima of length and mass + + SwTwips nPosHeight = pPos->Height(); + SwTwips nPosAscent = pPos->GetAscent(); + + SAL_WARN_IF( nPosHeight < nPosAscent, + "sw.core", "SwLineLayout::CalcLine: bad ascent or height" ); + + if( pPos->IsHangingPortion() ) + { + SetHanging(true); + rInf.GetParaPortion()->SetMargin(); + } + else if( !bHasFlyPortion && ( pPos->IsFlyCntPortion() || pPos->IsFlyPortion() ) ) + bHasFlyPortion = true; + + // A line break portion only influences the height of the line in case it's the only + // portion in the line, except when it's a clearing break. + bool bClearingBreak = false; + if (pPos->IsBreakPortion()) + { + auto pBreakPortion = static_cast(pPos); + bClearingBreak = pBreakPortion->GetClear() != SwLineBreakClear::NONE; + nBreakHeight = nPosHeight; + } + if (!(pPos->IsBreakPortion() && !bClearingBreak) || !Height()) + { + if (!pPos->IsPostItsPortion()) bOnlyPostIts = false; + + if( bTmpDummy && !mnLineLength ) + { + if( pPos->IsFlyPortion() ) + { + if( nFlyHeight < nPosHeight ) + nFlyHeight = nPosHeight; + if( nFlyAscent < nPosAscent ) + nFlyAscent = nPosAscent; + if( nFlyDescent < nPosHeight - nPosAscent ) + nFlyDescent = nPosHeight - nPosAscent; + } + else + { + if( pPos->InNumberGrp() ) + { + sal_uInt16 nTmp = rInf.GetFont()->GetAscent( + rInf.GetVsh(), *rInf.GetOut() ); + if( nTmp > nPosAscent ) + { + nPosHeight += nTmp - nPosAscent; + nPosAscent = nTmp; + } + nTmp = rInf.GetFont()->GetHeight( rInf.GetVsh(), + *rInf.GetOut() ); + if( nTmp > nPosHeight ) + nPosHeight = nTmp; + } + Height( nPosHeight, false ); + mnAscent = nPosAscent; + nMaxDescent = nPosHeight - nPosAscent; + } + } + else if( !pPos->IsFlyPortion() ) + { + if( Height() < nPosHeight ) + { + // Height is set to 0 when Init() is called. + if (bIgnoreBlanksAndTabsForLineHeightCalculation && pPos->IsFlyCntPortion()) + // Compat flag set: take the line height, if it's larger. + Height(std::max(nPosHeight, nLineHeight), false); + else + // Just care about the portion height. + Height(nPosHeight, pPos->IsTextPortion()); + } + SwFlyCntPortion* pAsFly(nullptr); + if(pPos->IsFlyCntPortion()) + pAsFly = static_cast(pPos); + if( pAsFly || ( pPos->IsMultiPortion() + && static_cast(pPos)->HasFlyInContent() ) ) + rLine.SetFlyInCntBase(); + if(pAsFly && pAsFly->GetAlign() != sw::LineAlign::NONE) + { + pAsFly->SetMax(false); + if( !pFlyCnt || pPos->Height() > pFlyCnt->Height() ) + pFlyCnt = pAsFly; + } + else + { + if( mnAscent < nPosAscent ) + mnAscent = nPosAscent; + if( nMaxDescent < nPosHeight - nPosAscent ) + nMaxDescent = nPosHeight - nPosAscent; + } + } + } + else if( pPos->GetLen() ) + bTmpDummy = false; + + if( !HasContent() && !pPos->InNumberGrp() ) + { + if ( pPos->InExpGrp() ) + { + OUString aText; + if( pPos->GetExpText( rInf, aText ) && !aText.isEmpty() ) + SetContent(true); + } + else if( ( pPos->InTextGrp() || pPos->IsMultiPortion() ) && + pPos->GetLen() ) + SetContent(true); + } + + bTmpDummy &= !HasContent() && ( !pPos->Width() || pPos->IsFlyPortion() ); + + pLast = pPos; + pPos = pPos->GetNextPortion(); + } + + if( pFlyCnt ) + { + if( pFlyCnt->Height() == Height() ) + { + pFlyCnt->SetMax( true ); + if( Height() > nMaxDescent + mnAscent ) + { + if( sw::LineAlign::BOTTOM == pFlyCnt->GetAlign() ) + mnAscent = Height() - nMaxDescent; + else if( sw::LineAlign::CENTER == pFlyCnt->GetAlign() ) + mnAscent = ( Height() + mnAscent - nMaxDescent ) / 2; + } + pFlyCnt->SetAscent( mnAscent ); + } + } + + if( bTmpDummy && nFlyHeight ) + { + mnAscent = nFlyAscent; + if( nFlyDescent > nFlyHeight - nFlyAscent ) + Height( nFlyHeight + nFlyDescent, false ); + else + { + if (nBreakHeight > nFlyHeight) + { + // The line has no content, but it has a clearing break: then the line + // height is not only the intersection of the fly and line's rectangle, but + // also includes the clearing break's height. + Height(nBreakHeight, false); + } + else + { + Height(nFlyHeight, false); + } + } + } + else if( nMaxDescent > Height() - mnAscent ) + Height( nMaxDescent + mnAscent, false ); + + if( bOnlyPostIts && !( bHasBlankPortion && bHasOnlyBlankPortions ) ) + { + Height( rInf.GetFont()->GetHeight( rInf.GetVsh(), *rInf.GetOut() ) ); + mnAscent = rInf.GetFont()->GetAscent( rInf.GetVsh(), *rInf.GetOut() ); + } + } + } + else + { + SetContent( !bTmpDummy ); + + // #i3952# + if ( bIgnoreBlanksAndTabsForLineHeightCalculation && + lcl_HasOnlyBlanks( rInf.GetText(), rInf.GetLineStart(), rInf.GetLineStart() + GetLen() ) ) + { + bHasBlankPortion = true; + } + } + + // #i3952# Whitespace does not increase line height + if ( bHasBlankPortion && bHasOnlyBlankPortions ) + { + sal_uInt16 nTmpAscent = GetAscent(); + sal_uInt16 nTmpHeight = Height(); + rLine.GetAttrHandler().GetDefaultAscentAndHeight( rInf.GetVsh(), *rInf.GetOut(), nTmpAscent, nTmpHeight ); + + short nEscapement = rLine.GetAttrHandler().GetFont()->GetEscapement(); + if (GetAscent() && Height() && !nTmpAscent && !nTmpHeight + && (nEscapement == DFLT_ESC_AUTO_SUPER || nEscapement == DFLT_ESC_AUTO_SUB)) + { + // We already had a calculated ascent + height, it would be cleared, automatic + // sub/superscript is set and we have no content. In this case it makes no sense to + // clear the old, correct ascent/height. + nTmpAscent = GetAscent(); + nTmpHeight = Height(); + } + + if (nTmpAscent < GetAscent() || GetAscent() <= 0) + SetAscent(nTmpAscent); + if (nTmpHeight < Height() || Height() <= 0) + Height(nTmpHeight, false); + } + + // Robust: + if( nLineWidth < Width() ) + Width( nLineWidth ); + SAL_WARN_IF( nLineWidth < Width(), "sw.core", "SwLineLayout::CalcLine: line is bursting" ); + SetDummy( bTmpDummy ); + std::pair const start( + rInf.GetTextFrame()->MapViewToModel(rLine.GetStart())); + std::pair const end( + rInf.GetTextFrame()->MapViewToModel(rLine.GetEnd())); + bool bHasRedline = rLine.GetRedln(); + if( bHasRedline ) + { + OUString sRedlineText; + bool bHasRedlineEnd; + enum RedlineType eRedlineEnd; + bHasRedline = rLine.GetRedln()->CheckLine(start.first->GetIndex(), start.second, + end.first->GetIndex(), end.second, sRedlineText, bHasRedlineEnd, eRedlineEnd); + if( bHasRedline ) + { + SetRedlineText( sRedlineText ); + if( bHasRedlineEnd ) + SetRedlineEnd( bHasRedlineEnd ); + if( eRedlineEnd != RedlineType::None ) + SetRedlineEndType( eRedlineEnd ); + } + } + SetRedline( bHasRedline ); + + // redlining: set crossing out for deleted anchored objects + if ( !bHasFlyPortion ) + return; + + SwLinePortion *pPos = mpNextPortion; + TextFrameIndex nLineLength; + while ( pPos ) + { + TextFrameIndex const nPorSttIdx = rInf.GetLineStart() + nLineLength; + nLineLength += pPos->GetLen(); + // anchored as characters + if( pPos->IsFlyCntPortion() ) + { + bool bDeleted = false; + size_t nAuthor = std::string::npos; + if ( bHasRedline ) + { + OUString sRedlineText; + bool bHasRedlineEnd; + enum RedlineType eRedlineEnd; + std::pair const flyStart( + rInf.GetTextFrame()->MapViewToModel(nPorSttIdx)); + bool bHasFlyRedline = rLine.GetRedln()->CheckLine(flyStart.first->GetIndex(), + flyStart.second, flyStart.first->GetIndex(), flyStart.second, sRedlineText, + bHasRedlineEnd, eRedlineEnd, /*pAuthorAtPos=*/&nAuthor); + bDeleted = bHasFlyRedline && eRedlineEnd == RedlineType::Delete; + } + static_cast(pPos)->SetDeleted(bDeleted); + static_cast(pPos)->SetAuthor(nAuthor); + } + // anchored to characters + else if ( pPos->IsFlyPortion() ) + { + const IDocumentRedlineAccess& rIDRA = + rInf.GetTextFrame()->GetDoc().getIDocumentRedlineAccess(); + SwSortedObjs *pObjs = rInf.GetTextFrame()->GetDrawObjs(); + if ( pObjs && IDocumentRedlineAccess::IsShowChanges( rIDRA.GetRedlineFlags() ) ) + { + for ( size_t i = 0; rInf.GetTextFrame()->GetDrawObjs() && i < pObjs->size(); ++i ) + { + SwAnchoredObject* pAnchoredObj = (*rInf.GetTextFrame()->GetDrawObjs())[i]; + if ( auto pFly = pAnchoredObj->DynCastFlyFrame() ) + { + bool bDeleted = false; + size_t nAuthor = std::string::npos; + const SwFormatAnchor& rAnchor = pAnchoredObj->GetFrameFormat().GetAnchor(); + if ( rAnchor.GetAnchorId() == RndStdIds::FLY_AT_CHAR ) + { + SwPosition aAnchor = *rAnchor.GetContentAnchor(); + SwRedlineTable::size_type n = 0; + const SwRangeRedline* pFnd = + rIDRA.GetRedlineTable().FindAtPosition( aAnchor, n ); + if ( pFnd && RedlineType::Delete == pFnd->GetType() ) + { + bDeleted = true; + nAuthor = pFnd->GetAuthor(); + } + } + pFly->SetDeleted(bDeleted); + pFly->SetAuthor(nAuthor); + } + } + } + } + pPos = pPos->GetNextPortion(); + } +} + +// #i47162# - add optional parameter <_bNoFlyCntPorAndLinePor> +// to control, if the fly content portions and line portion are considered. +void SwLineLayout::MaxAscentDescent( SwTwips& _orAscent, + SwTwips& _orDescent, + SwTwips& _orObjAscent, + SwTwips& _orObjDescent, + const SwLinePortion* _pDontConsiderPortion, + const bool _bNoFlyCntPorAndLinePor ) const +{ + _orAscent = 0; + _orDescent = 0; + _orObjAscent = 0; + _orObjDescent = 0; + + const SwLinePortion* pTmpPortion = this; + if ( !pTmpPortion->GetLen() && pTmpPortion->GetNextPortion() ) + { + pTmpPortion = pTmpPortion->GetNextPortion(); + } + + while ( pTmpPortion ) + { + if ( !pTmpPortion->IsBreakPortion() && !pTmpPortion->IsFlyPortion() && + // tdf#130804 ignore bookmark portions + pTmpPortion->GetWhichPor() != PortionType::Bookmark && + ( !_bNoFlyCntPorAndLinePor || + ( !pTmpPortion->IsFlyCntPortion() && + !(pTmpPortion == this && pTmpPortion->GetNextPortion() ) ) ) ) + { + SwTwips nPortionAsc = pTmpPortion->GetAscent(); + SwTwips nPortionDesc = pTmpPortion->Height() - nPortionAsc; + + const bool bFlyCmp = pTmpPortion->IsFlyCntPortion() ? + static_cast(pTmpPortion)->IsMax() : + ( pTmpPortion != _pDontConsiderPortion ); + + if ( bFlyCmp ) + { + _orObjAscent = std::max( _orObjAscent, nPortionAsc ); + _orObjDescent = std::max( _orObjDescent, nPortionDesc ); + } + + if ( !pTmpPortion->IsFlyCntPortion() && !pTmpPortion->IsGrfNumPortion() ) + { + _orAscent = std::max( _orAscent, nPortionAsc ); + _orDescent = std::max( _orDescent, nPortionDesc ); + } + } + pTmpPortion = pTmpPortion->GetNextPortion(); + } +} + +void SwLineLayout::dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, + TextFrameIndex& nOffset) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwLineLayout")); + dumpAsXmlAttributes(pWriter, rText, nOffset); + nOffset += GetLen(); + + (void)xmlTextWriterEndElement(pWriter); +} + +void SwLineLayout::ResetFlags() +{ + m_bFormatAdj = m_bDummy = m_bEndHyph = m_bMidHyph = m_bFly + = m_bRest = m_bBlinking = m_bClipping = m_bContent = m_bRedline + = m_bRedlineEnd = m_bForcedLeftMargin = m_bHanging = false; + m_eRedlineEnd = RedlineType::None; +} + +SwLineLayout::SwLineLayout() + : m_pNext( nullptr ), + m_nRealHeight( 0 ), + m_nTextHeight( 0 ), + m_bUnderscore( false ) +{ + ResetFlags(); + SetWhichPor( PortionType::Lay ); +} + +SwLinePortion *SwLineLayout::GetFirstPortion() const +{ + const SwLinePortion *pRet = mpNextPortion ? mpNextPortion : this; + return const_cast(pRet); +} + +SwCharRange &SwCharRange::operator+=(const SwCharRange &rRange) +{ + if (TextFrameIndex(0) != rRange.m_nLen) + { + if (TextFrameIndex(0) == m_nLen) { + m_nStart = rRange.m_nStart; + m_nLen = rRange.m_nLen ; + } + else { + if(rRange.m_nStart + rRange.m_nLen > m_nStart + m_nLen) { + m_nLen = rRange.m_nStart + rRange.m_nLen - m_nStart; + } + if(rRange.m_nStart < m_nStart) { + m_nLen += m_nStart - rRange.m_nStart; + m_nStart = rRange.m_nStart; + } + } + } + return *this; +} + +SwScriptInfo::SwScriptInfo() + : m_nInvalidityPos(0) + , m_nDefaultDir(0) +{ +}; + +SwScriptInfo::~SwScriptInfo() +{ +} + +// Converts i18n Script Type (LATIN, ASIAN, COMPLEX, WEAK) to +// Sw Script Types (SwFontScript::Latin, SwFontScript::CJK, SwFontScript::CTL), used to identify the font +static SwFontScript lcl_ScriptToFont(sal_uInt16 const nScript) +{ + switch ( nScript ) { + case i18n::ScriptType::LATIN : return SwFontScript::Latin; + case i18n::ScriptType::ASIAN : return SwFontScript::CJK; + case i18n::ScriptType::COMPLEX : return SwFontScript::CTL; + } + + OSL_FAIL( "Somebody tells lies about the script type!" ); + return SwFontScript::Latin; +} + +SwFontScript SwScriptInfo::WhichFont(TextFrameIndex const nIdx) const +{ + const sal_uInt16 nScript(ScriptType(nIdx)); + return lcl_ScriptToFont(nScript); +} + +SwFontScript SwScriptInfo::WhichFont(sal_Int32 nIdx, OUString const& rText) +{ + const sal_uInt16 nScript(g_pBreakIt->GetRealScriptOfText(rText, nIdx)); + return lcl_ScriptToFont(nScript); +} + +static Color getBookmarkColor(const SwTextNode& rNode, const sw::mark::IBookmark* pBookmark) +{ + // search custom color in metadata, otherwise use COL_TRANSPARENT; + Color c = COL_TRANSPARENT; + + try + { + SwDoc& rDoc = const_cast(rNode.GetDoc()); + const rtl::Reference< SwXBookmark > xRef = SwXBookmark::CreateXBookmark(rDoc, + const_cast(static_cast(pBookmark))); + const css::uno::Reference xSubject(xRef); + uno::Reference xModel = rDoc.GetDocShell()->GetBaseModel(); + + static uno::Reference< uno::XComponentContext > xContext( + ::comphelper::getProcessComponentContext()); + + static uno::Reference< rdf::XURI > xODF_SHADING( + rdf::URI::createKnown(xContext, rdf::URIs::LO_EXT_SHADING), uno::UNO_SET_THROW); + + uno::Reference xDocumentMetadataAccess( + rDoc.GetDocShell()->GetBaseModel(), uno::UNO_QUERY); + const uno::Reference& xRepository = + xDocumentMetadataAccess->getRDFRepository(); + const uno::Reference xEnum( + xRepository->getStatements(xSubject, xODF_SHADING, nullptr), uno::UNO_SET_THROW); + + rdf::Statement stmt; + if ( xEnum->hasMoreElements() && (xEnum->nextElement() >>= stmt) ) + { + const uno::Reference xObject(stmt.Object, uno::UNO_QUERY); + if ( xObject.is() ) + c = Color::STRtoRGB(xObject->getValue()); + } + } + catch (const lang::IllegalArgumentException&) + { + } + + return c; +} + +static void InitBookmarks( + std::optional::const_iterator> oPrevIter, + std::vector::const_iterator iter, + std::vector::const_iterator const end, + TextFrameIndex nOffset, + std::vector> & rBookmarks, + std::vector> & o_rBookmarks) +{ + SwTextNode const*const pNode(iter->pNode); + for (auto const& it : rBookmarks) + { + assert(iter->pNode == pNode || pNode->GetIndex() < iter->pNode->GetIndex()); + assert(!oPrevIter || (*oPrevIter)->pNode->GetIndex() <= pNode->GetIndex()); + + // search for custom bookmark boundary mark color + Color c = getBookmarkColor(*pNode, it.first); + + switch (it.second) + { + case SwScriptInfo::MarkKind::Start: + { + // SwUndoSaveContent::DelContentIndex() is rather messy but + // apparently bookmarks "on the edge" are deleted if + // * point: equals start-of-selection (not end-of-selection) + // * expanded: one position equals edge of selection + // and other does not (is inside) + // interesting case: if end[/start] of the mark is on the + // start of first[/end of last] extent, and the other one + // is outside this merged paragraph, is it deleted or not? + // assume "no" because the line break it contains isn't deleted. + SwPosition const& rStart(it.first->GetMarkStart()); + SwPosition const& rEnd(it.first->GetMarkEnd()); + assert(&rStart.GetNode() == pNode); + while (iter != end) + { + if (&rStart.GetNode() != iter->pNode // iter moved to next node + || rStart.GetContentIndex() < iter->nStart) + { + if (rEnd.GetNodeIndex() < iter->pNode->GetIndex() + || (&rEnd.GetNode() == iter->pNode && rEnd.GetContentIndex() <= iter->nStart)) + { + break; // deleted - skip it + } + else + { + o_rBookmarks.emplace_back(nOffset, it.second, c, it.first->GetName()); + break; + } + } + else if (rStart.GetContentIndex() <= iter->nEnd) + { + auto const iterNext(iter + 1); + if (rStart.GetContentIndex() == iter->nEnd + && (iterNext == end + ? &rEnd.GetNode() == iter->pNode + : (rEnd.GetNodeIndex() < iterNext->pNode->GetIndex() + || (&rEnd.GetNode() == iterNext->pNode && rEnd.GetContentIndex() < iterNext->nStart)))) + { + break; // deleted - skip it + } + else + { + o_rBookmarks.emplace_back( + nOffset + TextFrameIndex(rStart.GetContentIndex() - iter->nStart), + it.second, c, it.first->GetName()); + break; + } + } + else + { + nOffset += TextFrameIndex(iter->nEnd - iter->nStart); + oPrevIter = iter; + ++iter; // bookmarks are sorted... + } + } + if (iter == end) + { + if (pNode->GetIndex() < rEnd.GetNodeIndex()) // pNode is last node of merged + { + break; // deleted - skip it + } + else + { + o_rBookmarks.emplace_back(nOffset, it.second, c, it.first->GetName()); + } + } + break; + } + case SwScriptInfo::MarkKind::End: + { + SwPosition const& rEnd(it.first->GetMarkEnd()); + assert(&rEnd.GetNode() == pNode); + while (true) + { + if (iter == end + || &rEnd.GetNode() != iter->pNode // iter moved to next node + || rEnd.GetContentIndex() <= iter->nStart) + { + SwPosition const& rStart(it.first->GetMarkStart()); + // oPrevIter may point to pNode or a preceding node + if (oPrevIter + ? ((*oPrevIter)->pNode->GetIndex() < rStart.GetNodeIndex() + || ((*oPrevIter)->pNode == &rStart.GetNode() + && ((iter != end && &rEnd.GetNode() == iter->pNode && rEnd.GetContentIndex() == iter->nStart) + ? (*oPrevIter)->nEnd < rStart.GetContentIndex() + : (*oPrevIter)->nEnd <= rStart.GetContentIndex()))) + : rStart.GetNode() == rEnd.GetNode()) + { + break; // deleted - skip it + } + else + { + o_rBookmarks.emplace_back(nOffset, it.second, c, it.first->GetName()); + break; + } + } + else if (rEnd.GetContentIndex() <= iter->nEnd) + { + o_rBookmarks.emplace_back( + nOffset + TextFrameIndex(rEnd.GetContentIndex() - iter->nStart), + it.second, c, it.first->GetName()); + break; + } + else + { + nOffset += TextFrameIndex(iter->nEnd - iter->nStart); + oPrevIter = iter; + ++iter; + } + } + break; + } + case SwScriptInfo::MarkKind::Point: + { + SwPosition const& rPos(it.first->GetMarkPos()); + assert(&rPos.GetNode() == pNode); + while (iter != end) + { + if (&rPos.GetNode() != iter->pNode // iter moved to next node + || rPos.GetContentIndex() < iter->nStart) + { + break; // deleted - skip it + } + else if (rPos.GetContentIndex() <= iter->nEnd) + { + if (rPos.GetContentIndex() == iter->nEnd + && rPos.GetContentIndex() != iter->pNode->Len()) + { + break; // deleted - skip it + } + else + { + o_rBookmarks.emplace_back( + nOffset + TextFrameIndex(rPos.GetContentIndex() - iter->nStart), + it.second, c, it.first->GetName()); + } + break; + } + else + { + nOffset += TextFrameIndex(iter->nEnd - iter->nStart); + oPrevIter = iter; + ++iter; + } + } + break; + } + } + if (iter == end) + { + break; // remaining marks are hidden + } + } +} + +// searches for script changes in rText and stores them +void SwScriptInfo::InitScriptInfo(const SwTextNode& rNode, + sw::MergedPara const*const pMerged) +{ + InitScriptInfo( rNode, pMerged, m_nDefaultDir == UBIDI_RTL ); +} + +void SwScriptInfo::InitScriptInfo(const SwTextNode& rNode, + sw::MergedPara const*const pMerged, bool bRTL) +{ + assert(g_pBreakIt && g_pBreakIt->GetBreakIter().is()); + + const OUString& rText(pMerged ? pMerged->mergedText : rNode.GetText()); + + // HIDDEN TEXT INFORMATION + + m_Bookmarks.clear(); + m_HiddenChg.clear(); + if (pMerged) + { + SwTextNode const* pNode(nullptr); + TextFrameIndex nOffset(0); + std::optional::const_iterator> oPrevIter; + for (auto iter = pMerged->extents.begin(); iter != pMerged->extents.end(); + oPrevIter = iter) + { + if (iter->pNode == pNode) + { + nOffset += TextFrameIndex(iter->nEnd - iter->nStart); + ++iter; + continue; // skip extents at end of previous node + } + pNode = iter->pNode; + Range aRange( 0, pNode->Len() > 0 ? pNode->Len() - 1 : 0 ); + MultiSelection aHiddenMulti( aRange ); + std::vector> bookmarks; + CalcHiddenRanges(*pNode, aHiddenMulti, &bookmarks); + + InitBookmarks(oPrevIter, iter, pMerged->extents.end(), nOffset, bookmarks, m_Bookmarks); + + for (sal_Int32 i = 0; i < aHiddenMulti.GetRangeCount(); ++i) + { + const Range& rRange = aHiddenMulti.GetRange( i ); + const sal_Int32 nStart = rRange.Min(); + const sal_Int32 nEnd = rRange.Max() + 1; + bool isStartHandled(false); + ::std::optional oExtend; + + if (nEnd <= iter->nStart) + { // entirely in gap, skip this hidden range + continue; + } + + do + { + if (!isStartHandled && nStart <= iter->nEnd) + { + isStartHandled = true; + if (nStart <= iter->nStart && !m_HiddenChg.empty() + && m_HiddenChg.back() == nOffset) + { + // previous one went until end of extent, extend it + oExtend.emplace(::std::min(iter->nEnd, nEnd) - ::std::max(iter->nStart, nStart)); + } + else + { + m_HiddenChg.push_back(nOffset + TextFrameIndex(::std::max(nStart - iter->nStart, sal_Int32(0)))); + } + } + else if (oExtend) + { + *oExtend += ::std::min(iter->nEnd, nEnd) - iter->nStart; + } + if (nEnd <= iter->nEnd) + { + if (oExtend) + { + m_HiddenChg.back() += TextFrameIndex(*oExtend); + } + else + { + m_HiddenChg.push_back(nOffset + TextFrameIndex(::std::max(nEnd - iter->nStart, sal_Int32(0)))); + } + break; // iterate to next hidden range + } + nOffset += TextFrameIndex(iter->nEnd - iter->nStart); + ++iter; + } + while (iter != pMerged->extents.end() && iter->pNode == pNode); + if (iter == pMerged->extents.end() || iter->pNode != pNode) + { + if (isStartHandled) + { // dangling end + if (oExtend) + { + m_HiddenChg.back() += TextFrameIndex(*oExtend); + } + else + { + m_HiddenChg.push_back(nOffset); + } + } // else: beyond last extent in node, ignore + break; // skip hidden ranges beyond last extent in node + } + } + } + } + else + { + Range aRange( 0, !rText.isEmpty() ? rText.getLength() - 1 : 0 ); + MultiSelection aHiddenMulti( aRange ); + std::vector> bookmarks; + CalcHiddenRanges(rNode, aHiddenMulti, &bookmarks); + + for (auto const& it : bookmarks) + { + // don't show __RefHeading__ bookmarks, which are hidden in Navigator, too + // (They are inserted automatically e.g. with the ToC at the beginning of + // the headings) + if (it.first->GetName().startsWith( + IDocumentMarkAccess::GetCrossRefHeadingBookmarkNamePrefix())) + { + continue; + } + + // search for custom bookmark boundary mark color + Color c = getBookmarkColor(rNode, it.first); + + switch (it.second) + { + case MarkKind::Start: + m_Bookmarks.emplace_back(TextFrameIndex(it.first->GetMarkStart().GetContentIndex()), it.second, c, it.first->GetName()); + break; + case MarkKind::End: + m_Bookmarks.emplace_back(TextFrameIndex(it.first->GetMarkEnd().GetContentIndex()), it.second, c, it.first->GetName()); + break; + case MarkKind::Point: + m_Bookmarks.emplace_back(TextFrameIndex(it.first->GetMarkPos().GetContentIndex()), it.second, c, it.first->GetName()); + break; + } + } + + m_HiddenChg.reserve( aHiddenMulti.GetRangeCount() * 2 ); + for (sal_Int32 i = 0; i < aHiddenMulti.GetRangeCount(); ++i) + { + const Range& rRange = aHiddenMulti.GetRange( i ); + const sal_Int32 nStart = rRange.Min(); + const sal_Int32 nEnd = rRange.Max() + (rText.isEmpty() ? 0 : 1); + + m_HiddenChg.push_back( TextFrameIndex(nStart) ); + m_HiddenChg.push_back( TextFrameIndex(nEnd) ); + } + } + + // SCRIPT AND SCRIPT RELATED INFORMATION + + TextFrameIndex nChg = m_nInvalidityPos; + + // COMPLETE_STRING means the data structure is up to date + m_nInvalidityPos = TextFrameIndex(COMPLETE_STRING); + + // this is the default direction + m_nDefaultDir = static_cast(bRTL ? UBIDI_RTL : UBIDI_LTR); + + // counter for script info arrays + size_t nCnt = 0; + // counter for compression information arrays + size_t nCntComp = 0; + // counter for kashida array + size_t nCntKash = 0; + + sal_Int16 nScript = i18n::ScriptType::LATIN; + + // compression type + const CharCompressType aCompEnum = rNode.getIDocumentSettingAccess()->getCharacterCompressionType(); + + auto const& rParaItems((pMerged ? *pMerged->pParaPropsNode : rNode).GetSwAttrSet()); + // justification type + const bool bAdjustBlock = SvxAdjust::Block == rParaItems.GetAdjust().GetAdjust(); + + // FIND INVALID RANGES IN SCRIPT INFO ARRAYS: + + if( nChg ) + { + // if change position = 0 we do not use any data from the arrays + // because by deleting all characters of the first group at the beginning + // of a paragraph nScript is set to a wrong value + SAL_WARN_IF( !CountScriptChg(), "sw.core", "Where're my changes of script?" ); + while( nCnt < CountScriptChg() ) + { + if ( nChg > GetScriptChg( nCnt ) ) + nCnt++; + else + { + nScript = GetScriptType( nCnt ); + break; + } + } + if( CharCompressType::NONE != aCompEnum ) + { + while( nCntComp < CountCompChg() ) + { + if ( nChg <= GetCompStart( nCntComp ) ) + break; + nCntComp++; + } + } + if ( bAdjustBlock ) + { + while( nCntKash < CountKashida() ) + { + if ( nChg <= GetKashida( nCntKash ) ) + break; + nCntKash++; + } + } + } + + // ADJUST nChg VALUE: + + // by stepping back one position we know that we are inside a group + // declared as an nScript group + if ( nChg ) + --nChg; + + const TextFrameIndex nGrpStart = nCnt ? GetScriptChg(nCnt - 1) : TextFrameIndex(0); + + // we go back in our group until we reach the first character of + // type nScript + while ( nChg > nGrpStart && + nScript != g_pBreakIt->GetBreakIter()->getScriptType(rText, sal_Int32(nChg))) + --nChg; + + // If we are at the start of a group, we do not trust nScript, + // we better get nScript from the breakiterator: + if ( nChg == nGrpStart ) + nScript = static_cast(g_pBreakIt->GetBreakIter()->getScriptType(rText, sal_Int32(nChg))); + + // INVALID DATA FROM THE SCRIPT INFO ARRAYS HAS TO BE DELETED: + + // remove invalid entries from script information arrays + m_ScriptChanges.erase(m_ScriptChanges.begin() + nCnt, m_ScriptChanges.end()); + + // get the start of the last compression group + TextFrameIndex nLastCompression = nChg; + if( nCntComp ) + { + --nCntComp; + nLastCompression = GetCompStart( nCntComp ); + if( nChg >= nLastCompression + GetCompLen( nCntComp ) ) + { + nLastCompression = nChg; + ++nCntComp; + } + } + + // remove invalid entries from compression information arrays + m_CompressionChanges.erase(m_CompressionChanges.begin() + nCntComp, + m_CompressionChanges.end()); + + // get the start of the last kashida group + TextFrameIndex nLastKashida = nChg; + if( nCntKash && i18n::ScriptType::COMPLEX == nScript ) + { + --nCntKash; + nLastKashida = GetKashida( nCntKash ); + } + + // remove invalid entries from kashida array + m_Kashida.erase(m_Kashida.begin() + nCntKash, m_Kashida.end()); + + // TAKE CARE OF WEAK CHARACTERS: WE MUST FIND AN APPROPRIATE + // SCRIPT FOR WEAK CHARACTERS AT THE BEGINNING OF A PARAGRAPH + + if (WEAK == g_pBreakIt->GetBreakIter()->getScriptType(rText, sal_Int32(nChg))) + { + // If the beginning of the current group is weak, this means that + // all of the characters in this group are weak. We have to assign + // the scripts to these characters depending on the fonts which are + // set for these characters to display them. + TextFrameIndex nEnd( + g_pBreakIt->GetBreakIter()->endOfScript(rText, sal_Int32(nChg), WEAK)); + + if (nEnd > TextFrameIndex(rText.getLength()) || nEnd < TextFrameIndex(0)) + nEnd = TextFrameIndex(rText.getLength()); + + nScript = SvtLanguageOptions::GetI18NScriptTypeOfLanguage( GetAppLanguage() ); + + SAL_WARN_IF( i18n::ScriptType::LATIN != nScript && + i18n::ScriptType::ASIAN != nScript && + i18n::ScriptType::COMPLEX != nScript, "sw.core", "Wrong default language" ); + + nChg = nEnd; + + // Get next script type or set to weak in order to exit + sal_uInt8 nNextScript = (nEnd < TextFrameIndex(rText.getLength())) + ? static_cast(g_pBreakIt->GetBreakIter()->getScriptType(rText, sal_Int32(nEnd))) + : sal_uInt8(WEAK); + + if ( nScript != nNextScript ) + { + m_ScriptChanges.emplace_back(nEnd, nScript); + nCnt++; + nScript = nNextScript; + } + } + + // UPDATE THE SCRIPT INFO ARRAYS: + + while (nChg < TextFrameIndex(rText.getLength()) + || (m_ScriptChanges.empty() && rText.isEmpty())) + { + SAL_WARN_IF( i18n::ScriptType::WEAK == nScript, + "sw.core", "Inserting WEAK into SwScriptInfo structure" ); + + TextFrameIndex nSearchStt = nChg; + nChg = TextFrameIndex(g_pBreakIt->GetBreakIter()->endOfScript( + rText, sal_Int32(nSearchStt), nScript)); + + if (nChg > TextFrameIndex(rText.getLength()) || nChg < TextFrameIndex(0)) + nChg = TextFrameIndex(rText.getLength()); + + // special case for dotted circle since it can be used with complex + // before a mark, so we want it associated with the mark's script + // tdf#112594: another special case for NNBSP followed by a Mongolian + // character, since NNBSP has special uses in Mongolian (tdf#112594) + auto nPos = sal_Int32(nChg); + auto nPrevPos = nPos; + auto nPrevChar = rText.iterateCodePoints(&nPrevPos, -1); + if (nChg < TextFrameIndex(rText.getLength()) && nChg > TextFrameIndex(0) && + i18n::ScriptType::WEAK == g_pBreakIt->GetBreakIter()->getScriptType(rText, nPrevPos)) + { + auto nChar = rText.iterateCodePoints(&nPos, 0); + auto nType = unicode::getUnicodeType(nChar); + if (nType == css::i18n::UnicodeType::NON_SPACING_MARK || + nType == css::i18n::UnicodeType::ENCLOSING_MARK || + nType == css::i18n::UnicodeType::COMBINING_SPACING_MARK || + (nPrevChar == CHAR_NNBSP && + u_getIntPropertyValue(nChar, UCHAR_SCRIPT) == USCRIPT_MONGOLIAN)) + { + nPos = nPrevPos; + } + } + m_ScriptChanges.emplace_back(TextFrameIndex(nPos), nScript); + ++nCnt; + + // if current script is asian, we search for compressible characters + // in this range + if ( CharCompressType::NONE != aCompEnum && + i18n::ScriptType::ASIAN == nScript ) + { + CompType ePrevState = NONE; + CompType eState = NONE; + TextFrameIndex nPrevChg = nLastCompression; + + while ( nLastCompression < nChg ) + { + sal_Unicode cChar = rText[ sal_Int32(nLastCompression) ]; + + // examine current character + switch ( cChar ) + { + // Left punctuation found + case 0x3008: case 0x300A: case 0x300C: case 0x300E: + case 0x3010: case 0x3014: case 0x3016: case 0x3018: + case 0x301A: case 0x301D: + case 0xFF08: case 0xFF3B: case 0xFF5B: + eState = SPECIAL_LEFT; + break; + // Right punctuation found + case 0x3009: case 0x300B: + case 0x300D: case 0x300F: case 0x3011: case 0x3015: + case 0x3017: case 0x3019: case 0x301B: case 0x301E: + case 0x301F: + case 0xFF09: case 0xFF3D: case 0xFF5D: + eState = SPECIAL_RIGHT; + break; + case 0x3001: case 0x3002: // Fullstop or comma + case 0xFF0C: case 0xFF0E: case 0xFF1A: case 0xFF1B: + eState = SPECIAL_MIDDLE ; + break; + default: + eState = ( 0x3040 <= cChar && 0x3100 > cChar ) ? KANA : NONE; + } + + // insert range of compressible characters + if( ePrevState != eState ) + { + if ( ePrevState != NONE ) + { + // insert start and type + if ( CharCompressType::PunctuationAndKana == aCompEnum || + ePrevState != KANA ) + { + m_CompressionChanges.emplace_back(nPrevChg, + nLastCompression - nPrevChg, ePrevState); + } + } + + ePrevState = eState; + nPrevChg = nLastCompression; + } + + nLastCompression++; + } + + // we still have to examine last entry + if ( ePrevState != NONE ) + { + // insert start and type + if ( CharCompressType::PunctuationAndKana == aCompEnum || + ePrevState != KANA ) + { + m_CompressionChanges.emplace_back(nPrevChg, + nLastCompression - nPrevChg, ePrevState); + } + } + } + + // we search for connecting opportunities (kashida) + else if ( bAdjustBlock && i18n::ScriptType::COMPLEX == nScript ) + { + // sw_redlinehide: this is the only place that uses SwScanner with + // frame text, so we convert to sal_Int32 here + std::function const pGetLangOfCharM( + [&pMerged](sal_Int32 const nBegin, sal_uInt16 const script, bool const bNoChar) + { + std::pair const pos( + sw::MapViewToModel(*pMerged, TextFrameIndex(nBegin))); + return pos.first->GetLang(pos.second, bNoChar ? 0 : 1, script); + }); + std::function const pGetLangOfChar1( + [&rNode](sal_Int32 const nBegin, sal_uInt16 const script, bool const bNoChar) + { return rNode.GetLang(nBegin, bNoChar ? 0 : 1, script); }); + auto pGetLangOfChar(pMerged ? pGetLangOfCharM : pGetLangOfChar1); + SwScanner aScanner( std::move(pGetLangOfChar), rText, nullptr, ModelToViewHelper(), + i18n::WordType::DICTIONARY_WORD, + sal_Int32(nLastKashida), sal_Int32(nChg)); + + // the search has to be performed on a per word base + while ( aScanner.NextWord() ) + { + const OUString& rWord = aScanner.GetWord(); + + sal_Int32 nIdx = 0, nPrevIdx = 0; + sal_Int32 nKashidaPos = -1; + sal_Unicode cCh, cPrevCh = 0; + + int nPriorityLevel = 7; // 0..6 = level found + // 7 not found + + sal_Int32 nWordLen = rWord.getLength(); + + // ignore trailing vowel chars + while( nWordLen && isTransparentChar( rWord[ nWordLen - 1 ] )) + --nWordLen; + + while (nIdx < nWordLen) + { + cCh = rWord[ nIdx ]; + + // 1. Priority: + // after user inserted kashida + if ( 0x640 == cCh ) + { + nKashidaPos = aScanner.GetBegin() + nIdx; + nPriorityLevel = 0; + } + + // 2. Priority: + // after a Seen or Sad + if (nPriorityLevel >= 1 && nIdx < nWordLen - 1) + { + if( isSeenOrSadChar( cCh ) + && (rWord[ nIdx+1 ] != 0x200C) ) // #i98410#: prevent ZWNJ expansion + { + nKashidaPos = aScanner.GetBegin() + nIdx; + nPriorityLevel = 1; + } + } + + // 3. Priority: + // before final form of Teh Marbuta, Heh, Dal + if ( nPriorityLevel >= 2 && nIdx > 0 ) + { + if ( isTehMarbutaChar ( cCh ) || // Teh Marbuta (right joining) + isDalChar ( cCh ) || // Dal (right joining) final form may appear in the middle of word + ( isHehChar ( cCh ) && nIdx == nWordLen - 1)) // Heh (dual joining) only at end of word + { + + SAL_WARN_IF( 0 == cPrevCh, "sw.core", "No previous character" ); + // check if character is connectable to previous character, + if ( lcl_ConnectToPrev( cCh, cPrevCh ) ) + { + nKashidaPos = aScanner.GetBegin() + nPrevIdx; + nPriorityLevel = 2; + } + } + } + + // 4. Priority: + // before final form of Alef, Tah, Lam, Kaf or Gaf + if ( nPriorityLevel >= 3 && nIdx > 0 ) + { + if ( isAlefChar ( cCh ) || // Alef (right joining) final form may appear in the middle of word + (( isLamChar ( cCh ) || // Lam, + isTahChar ( cCh ) || // Tah, + isKafChar ( cCh ) || // Kaf (all dual joining) + isGafChar ( cCh ) ) + && nIdx == nWordLen - 1)) // only at end of word + { + SAL_WARN_IF( 0 == cPrevCh, "sw.core", "No previous character" ); + // check if character is connectable to previous character, + if ( lcl_ConnectToPrev( cCh, cPrevCh ) ) + { + nKashidaPos = aScanner.GetBegin() + nPrevIdx; + nPriorityLevel = 3; + } + } + } + + // 5. Priority: + // before medial Beh-like + if ( nPriorityLevel >= 4 && nIdx > 0 && nIdx < nWordLen - 1 ) + { + if ( isBehChar ( cCh ) ) + { + // check if next character is Reh or Yeh-like + sal_Unicode cNextCh = rWord[ nIdx + 1 ]; + if ( isRehChar ( cNextCh ) || isYehChar ( cNextCh )) + { + SAL_WARN_IF( 0 == cPrevCh, "sw.core", "No previous character" ); + // check if character is connectable to previous character, + if ( lcl_ConnectToPrev( cCh, cPrevCh ) ) + { + nKashidaPos = aScanner.GetBegin() + nPrevIdx; + nPriorityLevel = 4; + } + } + } + } + + // 6. Priority: + // before the final form of Waw, Ain, Qaf and Feh + if ( nPriorityLevel >= 5 && nIdx > 0 ) + { + if ( isWawChar ( cCh ) || // Wav (right joining) + // final form may appear in the middle of word + (( isAinChar ( cCh ) || // Ain (dual joining) + isQafChar ( cCh ) || // Qaf (dual joining) + isFehChar ( cCh ) ) // Feh (dual joining) + && nIdx == nWordLen - 1)) // only at end of word + { + SAL_WARN_IF( 0 == cPrevCh, "sw.core", "No previous character" ); + // check if character is connectable to previous character, + if ( lcl_ConnectToPrev( cCh, cPrevCh ) ) + { + nKashidaPos = aScanner.GetBegin() + nPrevIdx; + nPriorityLevel = 5; + } + } + } + + // other connecting possibilities + if ( nPriorityLevel >= 6 && nIdx > 0 ) + { + // Reh, Zain + if ( isRehChar ( cCh ) ) + { + SAL_WARN_IF( 0 == cPrevCh, "sw.core", "No previous character" ); + // check if character is connectable to previous character, + if ( lcl_ConnectToPrev( cCh, cPrevCh ) ) + { + nKashidaPos = aScanner.GetBegin() + nPrevIdx; + nPriorityLevel = 6; + } + } + } + + // Do not consider vowel marks when checking if a character + // can be connected to previous character. + if ( !isTransparentChar ( cCh) ) + { + cPrevCh = cCh; + nPrevIdx = nIdx; + } + + ++nIdx; + } // end of current word + + if ( -1 != nKashidaPos ) + { + m_Kashida.insert(m_Kashida.begin() + nCntKash, TextFrameIndex(nKashidaPos)); + nCntKash++; + } + } // end of kashida search + } + + if (nChg < TextFrameIndex(rText.getLength())) + nScript = static_cast(g_pBreakIt->GetBreakIter()->getScriptType(rText, sal_Int32(nChg))); + + nLastCompression = nChg; + nLastKashida = nChg; + } + +#if OSL_DEBUG_LEVEL > 0 + // check kashida data + TextFrameIndex nTmpKashidaPos(-1); + bool bWrongKash = false; + for (size_t i = 0; i < m_Kashida.size(); ++i) + { + TextFrameIndex nCurrKashidaPos = GetKashida( i ); + if ( nCurrKashidaPos <= nTmpKashidaPos ) + { + bWrongKash = true; + break; + } + nTmpKashidaPos = nCurrKashidaPos; + } + SAL_WARN_IF( bWrongKash, "sw.core", "Kashida array contains wrong data" ); +#endif + + // remove invalid entries from direction information arrays + m_DirectionChanges.clear(); + + // Perform Unicode Bidi Algorithm for text direction information + { + UpdateBidiInfo( rText ); + + // #i16354# Change script type for RTL text to CTL: + // 1. All text in RTL runs will use the CTL font + // #i89825# change the script type also to CTL (hennerdrewes) + // 2. Text in embedded LTR runs that does not have any strong LTR characters (numbers!) + for (size_t nDirIdx = 0; nDirIdx < m_DirectionChanges.size(); ++nDirIdx) + { + const sal_uInt8 nCurrDirType = GetDirType( nDirIdx ); + // nStart is start of RTL run: + const TextFrameIndex nStart = nDirIdx > 0 ? GetDirChg(nDirIdx - 1) : TextFrameIndex(0); + // nEnd is end of RTL run: + const TextFrameIndex nEnd = GetDirChg( nDirIdx ); + + if ( nCurrDirType % 2 == UBIDI_RTL || // text in RTL run + (nCurrDirType > UBIDI_LTR && // non-strong text in embedded LTR run + !lcl_HasStrongLTR(rText, sal_Int32(nStart), sal_Int32(nEnd)))) + { + // nScriptIdx points into the ScriptArrays: + size_t nScriptIdx = 0; + + // Skip entries in ScriptArray which are not inside the RTL run: + // Make nScriptIdx become the index of the script group with + // 1. nStartPosOfGroup <= nStart and + // 2. nEndPosOfGroup > nStart + while ( GetScriptChg( nScriptIdx ) <= nStart ) + ++nScriptIdx; + + const TextFrameIndex nStartPosOfGroup = nScriptIdx + ? GetScriptChg(nScriptIdx - 1) + : TextFrameIndex(0); + const sal_uInt8 nScriptTypeOfGroup = GetScriptType( nScriptIdx ); + + SAL_WARN_IF( nStartPosOfGroup > nStart || GetScriptChg( nScriptIdx ) <= nStart, + "sw.core", "Script override with CTL font trouble" ); + + // Check if we have to insert a new script change at + // position nStart. If nStartPosOfGroup < nStart, + // we have to insert a new script change: + if (nStart > TextFrameIndex(0) && nStartPosOfGroup < nStart) + { + m_ScriptChanges.insert(m_ScriptChanges.begin() + nScriptIdx, + ScriptChangeInfo(nStart, nScriptTypeOfGroup) ); + ++nScriptIdx; + } + + // Remove entries in ScriptArray which end inside the RTL run: + while (nScriptIdx < m_ScriptChanges.size() + && GetScriptChg(nScriptIdx) <= nEnd) + { + m_ScriptChanges.erase(m_ScriptChanges.begin() + nScriptIdx); + } + + // Insert a new entry in ScriptArray for the end of the RTL run: + m_ScriptChanges.insert(m_ScriptChanges.begin() + nScriptIdx, + ScriptChangeInfo(nEnd, i18n::ScriptType::COMPLEX) ); + +#if OSL_DEBUG_LEVEL > 1 + // Check that ScriptChangeInfos are in increasing order of + // position and that we don't have "empty" changes. + sal_uInt8 nLastTyp = i18n::ScriptType::WEAK; + TextFrameIndex nLastPos = TextFrameIndex(0); + for (const auto& rScriptChange : m_ScriptChanges) + { + SAL_WARN_IF( nLastTyp == rScriptChange.type || + nLastPos >= rScriptChange.position, + "sw.core", "Heavy InitScriptType() confusion" ); + nLastPos = rScriptChange.position; + nLastTyp = rScriptChange.type; + } +#endif + } + } + } +} + +void SwScriptInfo::UpdateBidiInfo( const OUString& rText ) +{ + // remove invalid entries from direction information arrays + m_DirectionChanges.clear(); + + // Bidi functions from icu 2.0 + + UErrorCode nError = U_ZERO_ERROR; + UBiDi* pBidi = ubidi_openSized( rText.getLength(), 0, &nError ); + nError = U_ZERO_ERROR; + + ubidi_setPara( pBidi, reinterpret_cast(rText.getStr()), rText.getLength(), + m_nDefaultDir, nullptr, &nError ); + nError = U_ZERO_ERROR; + int nCount = ubidi_countRuns( pBidi, &nError ); + int32_t nStart = 0; + int32_t nEnd; + UBiDiLevel nCurrDir; + for ( int nIdx = 0; nIdx < nCount; ++nIdx ) + { + ubidi_getLogicalRun( pBidi, nStart, &nEnd, &nCurrDir ); + m_DirectionChanges.emplace_back(TextFrameIndex(nEnd), nCurrDir); + nStart = nEnd; + } + + ubidi_close( pBidi ); +} + +// returns the position of the next character which belongs to another script +// than the character of the actual (input) position. +// If there's no script change until the end of the paragraph, it will return +// COMPLETE_STRING. +// Scripts are Asian (Chinese, Japanese, Korean), +// Latin ( English etc.) +// and Complex ( Hebrew, Arabian ) +TextFrameIndex SwScriptInfo::NextScriptChg(const TextFrameIndex nPos) const +{ + const size_t nEnd = CountScriptChg(); + for( size_t nX = 0; nX < nEnd; ++nX ) + { + if( nPos < GetScriptChg( nX ) ) + return GetScriptChg( nX ); + } + + return TextFrameIndex(COMPLETE_STRING); +} + +// returns the script of the character at the input position +sal_Int16 SwScriptInfo::ScriptType(const TextFrameIndex nPos) const +{ + const size_t nEnd = CountScriptChg(); + for( size_t nX = 0; nX < nEnd; ++nX ) + { + if( nPos < GetScriptChg( nX ) ) + return GetScriptType( nX ); + } + + // the default is the application language script + return SvtLanguageOptions::GetI18NScriptTypeOfLanguage( GetAppLanguage() ); +} + +TextFrameIndex SwScriptInfo::NextDirChg(const TextFrameIndex nPos, + const sal_uInt8* pLevel ) const +{ + const sal_uInt8 nCurrDir = pLevel ? *pLevel : 62; + const size_t nEnd = CountDirChg(); + for( size_t nX = 0; nX < nEnd; ++nX ) + { + if( nPos < GetDirChg( nX ) && + ( nX + 1 == nEnd || GetDirType( nX + 1 ) <= nCurrDir ) ) + return GetDirChg( nX ); + } + + return TextFrameIndex(COMPLETE_STRING); +} + +sal_uInt8 SwScriptInfo::DirType(const TextFrameIndex nPos) const +{ + const size_t nEnd = CountDirChg(); + for( size_t nX = 0; nX < nEnd; ++nX ) + { + if( nPos < GetDirChg( nX ) ) + return GetDirType( nX ); + } + + return 0; +} + +TextFrameIndex SwScriptInfo::NextHiddenChg(TextFrameIndex const nPos) const +{ + for (auto const& it : m_HiddenChg) + { + if (nPos < it) + { + return it; + } + } + return TextFrameIndex(COMPLETE_STRING); +} + +TextFrameIndex SwScriptInfo::NextBookmark(TextFrameIndex const nPos) const +{ + for (auto const& it : m_Bookmarks) + { + if (nPos < std::get<0>(it)) + { + return std::get<0>(it); + } + } + return TextFrameIndex(COMPLETE_STRING); +} + +std::vector> + SwScriptInfo::GetBookmarks(TextFrameIndex const nPos) +{ + std::vector> aColors; + for (auto const& it : m_Bookmarks) + { + if (nPos == std::get<0>(it)) + { + const OUString& sName = std::get<3>(it); + // filter hidden bookmarks imported from OOXML + // TODO import them as hidden bookmarks + if ( !( sName.startsWith("_Toc") || sName.startsWith("_Ref") ) ) + aColors.push_back(std::tuple(std::get<1>(it), std::get<2>(it), std::get<3>(it))); + } + else if (nPos < std::get<0>(it)) + { + break; + } + } + + // sort bookmark boundary marks at the same position + // mark order: ] | [ + // color order: [c1 [c2 [c3 ... c3] c2] c1] + sort(aColors.begin(), aColors.end(), + [](std::tuple const a, std::tuple const b) { + return (MarkKind::End == std::get<0>(a) && MarkKind::End != std::get<0>(b)) || + (MarkKind::Point == std::get<0>(a) && MarkKind::Start == std::get<0>(b)) || + // if both are end or start, order by color + (MarkKind::End == std::get<0>(a) && MarkKind::End == std::get<0>(b) && std::get<1>(a) < std::get<1>(b)) || + (MarkKind::Start == std::get<0>(a) && MarkKind::Start == std::get<0>(b) && std::get<1>(b) < std::get<1>(a));}); + + return aColors; +} + +// Takes a string and replaced the hidden ranges with cChar. +sal_Int32 SwScriptInfo::MaskHiddenRanges( const SwTextNode& rNode, OUStringBuffer & rText, + const sal_Int32 nStt, const sal_Int32 nEnd, + const sal_Unicode cChar ) +{ + assert(rNode.GetText().getLength() == rText.getLength()); + + std::vector aList; + sal_Int32 nHiddenStart; + sal_Int32 nHiddenEnd; + sal_Int32 nNumOfHiddenChars = 0; + GetBoundsOfHiddenRange( rNode, 0, nHiddenStart, nHiddenEnd, &aList ); + auto rFirst( aList.crbegin() ); + auto rLast( aList.crend() ); + while ( rFirst != rLast ) + { + nHiddenEnd = *(rFirst++); + nHiddenStart = *(rFirst++); + + if ( nHiddenEnd < nStt || nHiddenStart > nEnd ) + continue; + + while ( nHiddenStart < nHiddenEnd && nHiddenStart < nEnd ) + { + if (nHiddenStart >= nStt) + { + rText[nHiddenStart] = cChar; + ++nNumOfHiddenChars; + } + ++nHiddenStart; + } + } + + return nNumOfHiddenChars; +} + +// Takes a SwTextNode and deletes the hidden ranges from the node. +void SwScriptInfo::DeleteHiddenRanges( SwTextNode& rNode ) +{ + std::vector aList; + sal_Int32 nHiddenStart; + sal_Int32 nHiddenEnd; + GetBoundsOfHiddenRange( rNode, 0, nHiddenStart, nHiddenEnd, &aList ); + auto rFirst( aList.crbegin() ); + auto rLast( aList.crend() ); + while ( rFirst != rLast ) + { + nHiddenEnd = *(rFirst++); + nHiddenStart = *(rFirst++); + + SwPaM aPam( rNode, nHiddenStart, rNode, nHiddenEnd ); + rNode.getIDocumentContentOperations().DeleteRange( aPam ); + } +} + +bool SwScriptInfo::GetBoundsOfHiddenRange( const SwTextNode& rNode, sal_Int32 nPos, + sal_Int32& rnStartPos, sal_Int32& rnEndPos, + std::vector* pList ) +{ + rnStartPos = COMPLETE_STRING; + rnEndPos = 0; + + bool bNewContainsHiddenChars = false; + + // Optimization: First examine the flags at the text node: + + if ( !rNode.IsCalcHiddenCharFlags() ) + { + bool bWholePara = rNode.HasHiddenCharAttribute( true ); + bool bContainsHiddenChars = rNode.HasHiddenCharAttribute( false ); + if ( !bContainsHiddenChars ) + return false; + + if ( bWholePara ) + { + if ( pList ) + { + pList->push_back( 0 ); + pList->push_back(rNode.GetText().getLength()); + } + + rnStartPos = 0; + rnEndPos = rNode.GetText().getLength(); + return true; + } + } + + // sw_redlinehide: this won't work if it's merged +#if 0 + const SwScriptInfo* pSI = SwScriptInfo::GetScriptInfo( rNode ); + if ( pSI ) + { + + // Check first, if we have a valid SwScriptInfo object for this text node: + + bNewContainsHiddenChars = pSI->GetBoundsOfHiddenRange( nPos, rnStartPos, rnEndPos, pList ); + const bool bNewHiddenCharsHidePara = + rnStartPos == 0 && rnEndPos >= rNode.GetText().getLength(); + rNode.SetHiddenCharAttribute( bNewHiddenCharsHidePara, bNewContainsHiddenChars ); + } + else +#endif + { + + // No valid SwScriptInfo Object, we have to do it the hard way: + + Range aRange(0, (!rNode.GetText().isEmpty()) + ? rNode.GetText().getLength() - 1 + : 0); + MultiSelection aHiddenMulti( aRange ); + SwScriptInfo::CalcHiddenRanges(rNode, aHiddenMulti, nullptr); + for( sal_Int32 i = 0; i < aHiddenMulti.GetRangeCount(); ++i ) + { + const Range& rRange = aHiddenMulti.GetRange( i ); + const sal_Int32 nHiddenStart = rRange.Min(); + const sal_Int32 nHiddenEnd = rRange.Max() + 1; + + if ( nHiddenStart > nPos ) + break; + if (nPos < nHiddenEnd) + { + rnStartPos = nHiddenStart; + rnEndPos = std::min(nHiddenEnd, + rNode.GetText().getLength()); + break; + } + } + + if ( pList ) + { + for( sal_Int32 i = 0; i < aHiddenMulti.GetRangeCount(); ++i ) + { + const Range& rRange = aHiddenMulti.GetRange( i ); + pList->push_back( rRange.Min() ); + pList->push_back( rRange.Max() + 1 ); + } + } + + bNewContainsHiddenChars = aHiddenMulti.GetRangeCount() > 0; + } + + return bNewContainsHiddenChars; +} + +bool SwScriptInfo::GetBoundsOfHiddenRange(TextFrameIndex nPos, + TextFrameIndex & rnStartPos, TextFrameIndex & rnEndPos) const +{ + rnStartPos = TextFrameIndex(COMPLETE_STRING); + rnEndPos = TextFrameIndex(0); + + const size_t nEnd = CountHiddenChg(); + for( size_t nX = 0; nX < nEnd; ++nX ) + { + const TextFrameIndex nHiddenStart = GetHiddenChg( nX++ ); + const TextFrameIndex nHiddenEnd = GetHiddenChg( nX ); + + if ( nHiddenStart > nPos ) + break; + if (nPos < nHiddenEnd) + { + rnStartPos = nHiddenStart; + rnEndPos = nHiddenEnd; + break; + } + } + + return CountHiddenChg() > 0; +} + +bool SwScriptInfo::IsInHiddenRange( const SwTextNode& rNode, sal_Int32 nPos ) +{ + sal_Int32 nStartPos; + sal_Int32 nEndPos; + SwScriptInfo::GetBoundsOfHiddenRange( rNode, nPos, nStartPos, nEndPos ); + return nStartPos != COMPLETE_STRING; +} + +#ifdef DBG_UTIL +// returns the type of the compressed character +SwScriptInfo::CompType SwScriptInfo::DbgCompType(const TextFrameIndex nPos) const +{ + const size_t nEnd = CountCompChg(); + for( size_t nX = 0; nX < nEnd; ++nX ) + { + const TextFrameIndex nChg = GetCompStart(nX); + + if ( nPos < nChg ) + return NONE; + + if( nPos < nChg + GetCompLen( nX ) ) + return GetCompType( nX ); + } + return NONE; +} +#endif + +// returns, if there are compressible kanas or specials +// between nStart and nEnd +size_t SwScriptInfo::HasKana(TextFrameIndex const nStart, TextFrameIndex const nLen) const +{ + const size_t nCnt = CountCompChg(); + TextFrameIndex nEnd = nStart + nLen; + + for( size_t nX = 0; nX < nCnt; ++nX ) + { + TextFrameIndex nKanaStart = GetCompStart(nX); + TextFrameIndex nKanaEnd = nKanaStart + GetCompLen(nX); + + if ( nKanaStart >= nEnd ) + return SAL_MAX_SIZE; + + if ( nStart < nKanaEnd ) + return nX; + } + + return SAL_MAX_SIZE; +} + +tools::Long SwScriptInfo::Compress(KernArray& rKernArray, TextFrameIndex nIdx, TextFrameIndex nLen, + const sal_uInt16 nCompress, const sal_uInt16 nFontHeight, + bool bCenter, + Point* pPoint ) const +{ + SAL_WARN_IF( !nCompress, "sw.core", "Compression without compression?!" ); + SAL_WARN_IF( !nLen, "sw.core", "Compression without text?!" ); + const size_t nCompCount = CountCompChg(); + + // In asian typography, there are full width and half width characters. + // Full width punctuation characters can be compressed by 50% + // to determine this, we compare the font width with 75% of its height + const tools::Long nMinWidth = ( 3 * nFontHeight ) / 4; + + size_t nCompIdx = HasKana( nIdx, nLen ); + + if ( SAL_MAX_SIZE == nCompIdx ) + return 0; + + TextFrameIndex nChg = GetCompStart( nCompIdx ); + TextFrameIndex nCompLen = GetCompLen( nCompIdx ); + sal_Int32 nI = 0; + nLen += nIdx; + + if( nChg > nIdx ) + { + nI = sal_Int32(nChg - nIdx); + nIdx = nChg; + } + else if( nIdx < nChg + nCompLen ) + nCompLen -= nIdx - nChg; + + if( nIdx > nLen || nCompIdx >= nCompCount ) + return 0; + + tools::Long nSub = 0; + tools::Long nLast = nI ? rKernArray[ nI - 1 ] : 0; + do + { + const CompType nType = GetCompType( nCompIdx ); +#ifdef DBG_UTIL + SAL_WARN_IF( nType != DbgCompType( nIdx ), "sw.core", "Gimme the right type!" ); +#endif + nCompLen += nIdx; + if( nCompLen > nLen ) + nCompLen = nLen; + + // are we allowed to compress the character? + if ( rKernArray[ nI ] - nLast < nMinWidth ) + { + nIdx++; nI++; + } + else + { + while( nIdx < nCompLen ) + { + SAL_WARN_IF( SwScriptInfo::NONE == nType, "sw.core", "None compression?!" ); + + // nLast is width of current character + nLast -= rKernArray[ nI ]; + + nLast *= nCompress; + tools::Long nMove = 0; + if( SwScriptInfo::KANA != nType ) + { + nLast /= 24000; + if( pPoint && SwScriptInfo::SPECIAL_LEFT == nType ) + { + if( nI ) + nMove = nLast; + else + { + pPoint->AdjustX(nLast ); + nLast = 0; + } + } + else if( bCenter && SwScriptInfo::SPECIAL_MIDDLE == nType ) + nMove = nLast / 2; + } + else + nLast /= 100000; + nSub -= nLast; + nLast = rKernArray[ nI ]; + if( nI && nMove ) + rKernArray.adjust(nI - 1, nMove); + rKernArray.adjust(nI, -nSub); + ++nI; + ++nIdx; + } + } + + if( nIdx >= nLen ) + break; + + TextFrameIndex nTmpChg = nLen; + if( ++nCompIdx < nCompCount ) + { + nTmpChg = GetCompStart( nCompIdx ); + if( nTmpChg > nLen ) + nTmpChg = nLen; + nCompLen = GetCompLen( nCompIdx ); + } + + while( nIdx < nTmpChg ) + { + nLast = rKernArray[ nI ]; + rKernArray.adjust(nI, -nSub); + ++nI; + ++nIdx; + } + } while( nIdx < nLen ); + return nSub; +} + +// Note on calling KashidaJustify(): +// Kashida positions may be marked as invalid. Therefore KashidaJustify may return the clean +// total number of kashida positions, or the number of kashida positions after some positions +// have been dropped, depending on the state of the m_KashidaInvalid set. + +sal_Int32 SwScriptInfo::KashidaJustify( KernArray* pKernArray, + sal_Bool* pKashidaArray, + TextFrameIndex const nStt, + TextFrameIndex const nLen, + tools::Long nSpaceAdd ) const +{ + SAL_WARN_IF( !nLen, "sw.core", "Kashida justification without text?!" ); + + if( !IsKashidaLine(nStt)) + return -1; + + // evaluate kashida information in collected in SwScriptInfo + + size_t nCntKash = 0; + while( nCntKash < CountKashida() ) + { + if ( nStt <= GetKashida( nCntKash ) ) + break; + ++nCntKash; + } + + const TextFrameIndex nEnd = nStt + nLen; + + size_t nCntKashEnd = nCntKash; + while ( nCntKashEnd < CountKashida() ) + { + if ( nEnd <= GetKashida( nCntKashEnd ) ) + break; + ++nCntKashEnd; + } + + size_t nActualKashCount = nCntKashEnd - nCntKash; + for (size_t i = nCntKash; i < nCntKashEnd; ++i) + { + if ( nActualKashCount && !IsKashidaValid ( i ) ) + --nActualKashCount; + } + + if ( !pKernArray ) + return nActualKashCount; + + // do nothing if there is no more kashida + if ( nCntKash < CountKashida() ) + { + // skip any invalid kashidas + while (nCntKash < nCntKashEnd && !IsKashidaValid(nCntKash)) + ++nCntKash; + + TextFrameIndex nIdx = nCntKash < nCntKashEnd && IsKashidaValid(nCntKash) + ? GetKashida(nCntKash) + : nEnd; + tools::Long nKashAdd = nSpaceAdd; + + while ( nIdx < nEnd ) + { + TextFrameIndex nArrayPos = nIdx - nStt; + + // mark Kashida insertion positions, code in VCL will use this + // array to know where to insert Kashida. + if (pKashidaArray) + pKashidaArray[sal_Int32(nArrayPos)] = true; + + // next kashida position + ++nCntKash; + while (nCntKash < nCntKashEnd && !IsKashidaValid(nCntKash)) + ++nCntKash; + + nIdx = nCntKash < nCntKashEnd && IsKashidaValid(nCntKash) ? GetKashida(nCntKash) : nEnd; + if ( nIdx > nEnd ) + nIdx = nEnd; + + const TextFrameIndex nArrayEnd = nIdx - nStt; + + while ( nArrayPos < nArrayEnd ) + { + pKernArray->adjust(sal_Int32(nArrayPos), nKashAdd); + ++nArrayPos; + } + nKashAdd += nSpaceAdd; + } + } + + return 0; +} + +// Checks if the current text is 'Arabic' text. Note that only the first +// character has to be checked because a ctl portion only contains one +// script, see NewTextPortion +bool SwScriptInfo::IsArabicText(const OUString& rText, + TextFrameIndex const nStt, TextFrameIndex const nLen) +{ + using namespace ::com::sun::star::i18n; + static const ScriptTypeList typeList[] = { + { UnicodeScript_kArabic, UnicodeScript_kArabic, sal_Int16(UnicodeScript_kArabic) }, // 11, + { UnicodeScript_kScriptCount, UnicodeScript_kScriptCount, sal_Int16(UnicodeScript_kScriptCount) } // 88 + }; + + // go forward if current position does not hold a regular character: + const CharClass& rCC = GetAppCharClass(); + sal_Int32 nIdx = sal_Int32(nStt); + const sal_Int32 nEnd = sal_Int32(nStt + nLen); + while ( nIdx < nEnd && !rCC.isLetterNumeric( rText, nIdx ) ) + { + ++nIdx; + } + + if( nIdx == nEnd ) + { + // no regular character found in this portion. Go backward: + --nIdx; + while ( nIdx >= 0 && !rCC.isLetterNumeric( rText, nIdx ) ) + { + --nIdx; + } + } + + if( nIdx >= 0 ) + { + const sal_Unicode cCh = rText[nIdx]; + const sal_Int16 type = unicode::getUnicodeScriptType( cCh, typeList, sal_Int16(UnicodeScript_kScriptCount) ); + return type == sal_Int16(UnicodeScript_kArabic); + } + return false; +} + +bool SwScriptInfo::IsKashidaValid(size_t const nKashPos) const +{ + return m_KashidaInvalid.find(nKashPos) == m_KashidaInvalid.end(); +} + +void SwScriptInfo::ClearKashidaInvalid(size_t const nKashPos) +{ + m_KashidaInvalid.erase(nKashPos); +} + +// bMark == true: +// marks the first valid kashida in the given text range as invalid +// bMark == false: +// clears all kashida invalid flags in the given text range +bool SwScriptInfo::MarkOrClearKashidaInvalid( + TextFrameIndex const nStt, TextFrameIndex const nLen, + bool bMark, sal_Int32 nMarkCount) +{ + size_t nCntKash = 0; + while( nCntKash < CountKashida() ) + { + if ( nStt <= GetKashida( nCntKash ) ) + break; + nCntKash++; + } + + const TextFrameIndex nEnd = nStt + nLen; + + while ( nCntKash < CountKashida() ) + { + if ( nEnd <= GetKashida( nCntKash ) ) + break; + if(bMark) + { + if ( MarkKashidaInvalid ( nCntKash ) ) + { + --nMarkCount; + if (!nMarkCount) + return true; + } + } + else + { + ClearKashidaInvalid ( nCntKash ); + } + nCntKash++; + } + return false; +} + +bool SwScriptInfo::MarkKashidaInvalid(size_t const nKashPos) +{ + return m_KashidaInvalid.insert(nKashPos).second; +} + +// retrieve the kashida positions in the given text range +void SwScriptInfo::GetKashidaPositions( + TextFrameIndex const nStt, TextFrameIndex const nLen, + std::vector& rKashidaPosition) +{ + size_t nCntKash = 0; + while( nCntKash < CountKashida() ) + { + if ( nStt <= GetKashida( nCntKash ) ) + break; + nCntKash++; + } + + const TextFrameIndex nEnd = nStt + nLen; + + size_t nCntKashEnd = nCntKash; + while ( nCntKashEnd < CountKashida() ) + { + if ( nEnd <= GetKashida( nCntKashEnd ) ) + break; + rKashidaPosition.push_back(GetKashida(nCntKashEnd)); + nCntKashEnd++; + } +} + +void SwScriptInfo::SetNoKashidaLine(TextFrameIndex const nStt, TextFrameIndex const nLen) +{ + m_NoKashidaLine.push_back( nStt ); + m_NoKashidaLineEnd.push_back( nStt + nLen ); +} + +// determines if the line uses kashida justification +bool SwScriptInfo::IsKashidaLine(TextFrameIndex const nCharIdx) const +{ + for (size_t i = 0; i < m_NoKashidaLine.size(); ++i) + { + if (nCharIdx >= m_NoKashidaLine[i] && nCharIdx < m_NoKashidaLineEnd[i]) + return false; + } + return true; +} + +void SwScriptInfo::ClearNoKashidaLine(TextFrameIndex const nStt, TextFrameIndex const nLen) +{ + size_t i = 0; + while (i < m_NoKashidaLine.size()) + { + if (nStt + nLen >= m_NoKashidaLine[i] && nStt < m_NoKashidaLineEnd[i]) + { + m_NoKashidaLine.erase(m_NoKashidaLine.begin() + i); + m_NoKashidaLineEnd.erase(m_NoKashidaLineEnd.begin() + i); + } + else + ++i; + } +} + +// mark the given character indices as invalid kashida positions +void SwScriptInfo::MarkKashidasInvalid(sal_Int32 const nCnt, + const TextFrameIndex* pKashidaPositions) +{ + SAL_WARN_IF( !pKashidaPositions || nCnt == 0, "sw.core", "Where are kashidas?" ); + + size_t nCntKash = 0; + sal_Int32 nKashidaPosIdx = 0; + + while (nCntKash < CountKashida() && nKashidaPosIdx < nCnt) + { + if ( pKashidaPositions [nKashidaPosIdx] > GetKashida( nCntKash ) ) + { + ++nCntKash; + continue; + } + + if ( pKashidaPositions [nKashidaPosIdx] != GetKashida( nCntKash ) || !IsKashidaValid ( nCntKash ) ) + return; // something is wrong + + MarkKashidaInvalid ( nCntKash ); + nKashidaPosIdx++; + } +} + +TextFrameIndex SwScriptInfo::ThaiJustify( std::u16string_view aText, KernArray* pKernArray, + TextFrameIndex const nStt, + TextFrameIndex const nLen, + TextFrameIndex nNumberOfBlanks, + tools::Long nSpaceAdd ) +{ + SAL_WARN_IF( nStt + nLen > TextFrameIndex(aText.size()), "sw.core", "String in ThaiJustify too small" ); + + SwTwips nNumOfTwipsToDistribute = nSpaceAdd * sal_Int32(nNumberOfBlanks) / + SPACING_PRECISION_FACTOR; + + tools::Long nSpaceSum = 0; + TextFrameIndex nCnt(0); + + for (sal_Int32 nI = 0; nI < sal_Int32(nLen); ++nI) + { + const sal_Unicode cCh = aText[sal_Int32(nStt) + nI]; + + // check if character is not above or below base + if ( ( 0xE34 > cCh || cCh > 0xE3A ) && + ( 0xE47 > cCh || cCh > 0xE4E ) && cCh != 0xE31 ) + { + if (nNumberOfBlanks > TextFrameIndex(0)) + { + nSpaceAdd = nNumOfTwipsToDistribute / sal_Int32(nNumberOfBlanks); + --nNumberOfBlanks; + nNumOfTwipsToDistribute -= nSpaceAdd; + } + nSpaceSum += nSpaceAdd; + ++nCnt; + } + + if (pKernArray) + pKernArray->adjust(nI, nSpaceSum); + } + + return nCnt; +} + +SwScriptInfo* SwScriptInfo::GetScriptInfo( const SwTextNode& rTNd, + SwTextFrame const**const o_ppFrame, + bool const bAllowInvalid) +{ + SwIterator aIter(rTNd); + SwScriptInfo* pScriptInfo = nullptr; + + for( SwTextFrame* pLast = aIter.First(); pLast; pLast = aIter.Next() ) + { + pScriptInfo = const_cast(pLast->GetScriptInfo()); + if ( pScriptInfo ) + { + if (bAllowInvalid || + TextFrameIndex(COMPLETE_STRING) == pScriptInfo->GetInvalidityA()) + { + if (o_ppFrame) + { + *o_ppFrame = pLast; + } + break; + } + pScriptInfo = nullptr; + } + } + + return pScriptInfo; +} + +SwParaPortion::SwParaPortion() +{ + FormatReset(); + m_bFlys = m_bFootnoteNum = m_bMargin = false; + SetWhichPor( PortionType::Para ); +} + +SwParaPortion::~SwParaPortion() +{ +} + +TextFrameIndex SwParaPortion::GetParLen() const +{ + TextFrameIndex nLen(0); + const SwLineLayout *pLay = this; + while( pLay ) + { + nLen += pLay->GetLen(); + pLay = pLay->GetNext(); + } + return nLen; +} + +bool SwParaPortion::HasNumberingPortion(FootnoteOrNot const eFootnote) const +{ + SwLinePortion const* pPortion(nullptr); + // the first line may contain only fly portion... + for (SwLineLayout const* pLine = this; pLine && !pPortion; pLine = pLine->GetNext()) + { + pPortion = pLine->GetFirstPortion(); + while (pPortion && (pPortion->InGlueGrp() || pPortion->IsKernPortion() || pPortion->IsFlyPortion())) + { // skip margins and fly spacers - numbering should be first then + pPortion = pPortion->GetNextPortion(); + } + } + if (pPortion && pPortion->InHyphGrp()) + { // weird special case, bullet with soft hyphen + pPortion = pPortion->GetNextPortion(); + } + return pPortion && pPortion->InNumberGrp() + && (eFootnote == SwParaPortion::FootnoteToo || !pPortion->IsFootnoteNumPortion()); +} + +bool SwParaPortion::HasContentPortions() const +{ + SwLinePortion const* pPortion(nullptr); + for (SwLineLayout const* pLine = this; pLine && !pPortion; pLine = pLine->GetNext()) + { + pPortion = pLine->GetFirstPortion(); + while (pPortion && (pPortion->InGlueGrp() || pPortion->IsKernPortion() || pPortion->IsFlyPortion())) + { // skip margins and fly spacers + pPortion = pPortion->GetNextPortion(); + } + } + return pPortion != nullptr; +} + +const SwDropPortion *SwParaPortion::FindDropPortion() const +{ + const SwLineLayout *pLay = this; + while( pLay && pLay->IsDummy() ) + pLay = pLay->GetNext(); + while( pLay ) + { + const SwLinePortion *pPos = pLay->GetNextPortion(); + while ( pPos && !pPos->GetLen() ) + pPos = pPos->GetNextPortion(); + if( pPos && pPos->IsDropPortion() ) + return static_cast(pPos); + pLay = pLay->GetLen() ? nullptr : pLay->GetNext(); + } + return nullptr; +} + +void SwParaPortion::dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, + TextFrameIndex& nOffset) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwParaPortion")); + dumpAsXmlAttributes(pWriter, rText, nOffset); + nOffset += GetLen(); + + (void)xmlTextWriterEndElement(pWriter); +} + +void SwLineLayout::Init( SwLinePortion* pNextPortion ) +{ + Height( 0, false ); + Width( 0 ); + SetLen(TextFrameIndex(0)); + SetAscent( 0 ); + SetRealHeight( 0 ); + SetNextPortion( pNextPortion ); +} + +// looks for hanging punctuation portions in the paragraph +// and return the maximum right offset of them. +// If no such portion is found, the Margin/Hanging-flags will be updated. +SwTwips SwLineLayout::GetHangingMargin_() const +{ + SwLinePortion* pPor = GetNextPortion(); + bool bFound = false; + SwTwips nDiff = 0; + while( pPor) + { + if( pPor->IsHangingPortion() ) + { + nDiff = static_cast(pPor)->GetInnerWidth() - pPor->Width(); + if( nDiff ) + bFound = true; + } + // the last post its portion + else if ( pPor->IsPostItsPortion() && ! pPor->GetNextPortion() ) + nDiff = mnAscent; + + pPor = pPor->GetNextPortion(); + } + if( !bFound ) // update the hanging-flag + const_cast(this)->SetHanging( false ); + return nDiff; +} + +SwTwips SwTextFrame::HangingMargin() const +{ + SAL_WARN_IF( !HasPara(), "sw.core", "Don't call me without a paraportion" ); + if( !GetPara()->IsMargin() ) + return 0; + const SwLineLayout* pLine = GetPara(); + SwTwips nRet = 0; + do + { + SwTwips nDiff = pLine->GetHangingMargin(); + if( nDiff > nRet ) + nRet = nDiff; + pLine = pLine->GetNext(); + } while ( pLine ); + if( !nRet ) // update the margin-flag + const_cast(GetPara())->SetMargin( false ); + return nRet; +} + +SwTwips SwTextFrame::GetLowerMarginForFlyIntersect() const +{ + const IDocumentSettingAccess& rIDSA = GetDoc().getIDocumentSettingAccess(); + if (!rIDSA.get(DocumentSettingId::TAB_OVER_MARGIN)) + { + // Word >= 2013 style or Writer style: lower margin is ignored when determining the text + // frame height. + return 0; + } + + const SwAttrSet* pAttrSet = GetTextNodeForParaProps()->GetpSwAttrSet(); + if (!pAttrSet) + { + return 0; + } + + // If it has multiple lines, then probably it already has the needed fly portion. + // Limit this to empty paragraphs for now. + if ((GetPara() && GetPara()->GetNext()) || !GetText().isEmpty()) + { + return 0; + } + + return pAttrSet->GetULSpace().GetLower(); +} + +void SwScriptInfo::selectHiddenTextProperty(const SwTextNode& rNode, + MultiSelection & rHiddenMulti, + std::vector> *const pBookmarks) +{ + assert((rNode.GetText().isEmpty() && rHiddenMulti.GetTotalRange().Len() == 1) + || (rNode.GetText().getLength() == rHiddenMulti.GetTotalRange().Len())); + + const SvxCharHiddenItem* pItem = rNode.GetSwAttrSet().GetItemIfSet( RES_CHRATR_HIDDEN ); + if( pItem && pItem->GetValue() ) + { + rHiddenMulti.SelectAll(); + } + + const SwpHints* pHints = rNode.GetpSwpHints(); + + if( pHints ) + { + for( size_t nTmp = 0; nTmp < pHints->Count(); ++nTmp ) + { + const SwTextAttr* pTextAttr = pHints->Get( nTmp ); + const SvxCharHiddenItem* pHiddenItem = CharFormat::GetItem( *pTextAttr, RES_CHRATR_HIDDEN ); + if( pHiddenItem ) + { + const sal_Int32 nSt = pTextAttr->GetStart(); + const sal_Int32 nEnd = *pTextAttr->End(); + if( nEnd > nSt ) + { + Range aTmp( nSt, nEnd - 1 ); + rHiddenMulti.Select( aTmp, pHiddenItem->GetValue() ); + } + } + } + } + + for (const SwContentIndex* pIndex = rNode.GetFirstIndex(); pIndex; pIndex = pIndex->GetNext()) + { + const sw::mark::IMark* pMark = pIndex->GetMark(); + const sw::mark::IBookmark* pBookmark = dynamic_cast(pMark); + if (pBookmarks && pBookmark) + { + if (!pBookmark->IsExpanded()) + { + pBookmarks->emplace_back(pBookmark, MarkKind::Point); + } + else if (pIndex == &pBookmark->GetMarkStart().nContent) + { + pBookmarks->emplace_back(pBookmark, MarkKind::Start); + } + else + { + assert(pIndex == &pBookmark->GetMarkEnd().nContent); + pBookmarks->emplace_back(pBookmark, MarkKind::End); + } + } + + // condition is evaluated in DocumentFieldsManager::UpdateExpFields() + if (pBookmark && pBookmark->IsHidden()) + { + // intersect bookmark range with textnode range and add the intersection to rHiddenMulti + + const sal_Int32 nSt = pBookmark->GetMarkStart().GetContentIndex(); + const sal_Int32 nEnd = pBookmark->GetMarkEnd().GetContentIndex(); + + if( nEnd > nSt ) + { + Range aTmp( nSt, nEnd - 1 ); + rHiddenMulti.Select(aTmp, true); + } + } + } +} + +void SwScriptInfo::selectRedLineDeleted(const SwTextNode& rNode, MultiSelection &rHiddenMulti, bool bSelect) +{ + assert((rNode.GetText().isEmpty() && rHiddenMulti.GetTotalRange().Len() == 1) + || (rNode.GetText().getLength() == rHiddenMulti.GetTotalRange().Len())); + + const IDocumentRedlineAccess& rIDRA = rNode.getIDocumentRedlineAccess(); + if ( !IDocumentRedlineAccess::IsShowChanges( rIDRA.GetRedlineFlags() ) ) + return; + + SwRedlineTable::size_type nAct = rIDRA.GetRedlinePos( rNode, RedlineType::Any ); + + for ( ; nAct < rIDRA.GetRedlineTable().size(); nAct++ ) + { + const SwRangeRedline* pRed = rIDRA.GetRedlineTable()[ nAct ]; + + if (pRed->Start()->GetNode() > rNode) + break; + + if (pRed->GetType() != RedlineType::Delete) + continue; + + sal_Int32 nRedlStart; + sal_Int32 nRedlnEnd; + pRed->CalcStartEnd( rNode.GetIndex(), nRedlStart, nRedlnEnd ); + //clip it if the redline extends past the end of the nodes text + nRedlnEnd = std::min(nRedlnEnd, rNode.GetText().getLength()); + if ( nRedlnEnd > nRedlStart ) + { + Range aTmp( nRedlStart, nRedlnEnd - 1 ); + rHiddenMulti.Select( aTmp, bSelect ); + } + } +} + +// Returns a MultiSection indicating the hidden ranges. +void SwScriptInfo::CalcHiddenRanges( const SwTextNode& rNode, + MultiSelection & rHiddenMulti, + std::vector> *const pBookmarks) +{ + selectHiddenTextProperty(rNode, rHiddenMulti, pBookmarks); + + // If there are any hidden ranges in the current text node, we have + // to unhide the redlining ranges: + selectRedLineDeleted(rNode, rHiddenMulti, false); + + // We calculated a lot of stuff. Finally we can update the flags at the text node. + + const bool bNewContainsHiddenChars = rHiddenMulti.GetRangeCount() > 0; + bool bNewHiddenCharsHidePara = false; + if ( bNewContainsHiddenChars ) + { + const Range& rRange = rHiddenMulti.GetRange( 0 ); + const sal_Int32 nHiddenStart = rRange.Min(); + const sal_Int32 nHiddenEnd = rRange.Max() + 1; + bNewHiddenCharsHidePara = + (nHiddenStart == 0 && nHiddenEnd >= rNode.GetText().getLength()); + } + rNode.SetHiddenCharAttribute( bNewHiddenCharsHidePara, bNewContainsHiddenChars ); +} + +TextFrameIndex SwScriptInfo::CountCJKCharacters(const OUString &rText, + TextFrameIndex nPos, TextFrameIndex const nEnd, LanguageType aLang) +{ + TextFrameIndex nCount(0); + if (nEnd > nPos) + { + sal_Int32 nDone = 0; + const lang::Locale &rLocale = g_pBreakIt->GetLocale( aLang ); + while ( nPos < nEnd ) + { + nPos = TextFrameIndex(g_pBreakIt->GetBreakIter()->nextCharacters( + rText, sal_Int32(nPos), + rLocale, + i18n::CharacterIteratorMode::SKIPCELL, 1, nDone)); + nCount++; + } + } + else + nCount = nEnd - nPos ; + + return nCount; +} + +void SwScriptInfo::CJKJustify( const OUString& rText, KernArray& rKernArray, + TextFrameIndex const nStt, + TextFrameIndex const nLen, LanguageType aLang, + tools::Long nSpaceAdd, bool bIsSpaceStop ) +{ + assert( sal_Int32(nStt) >= 0 ); + if (sal_Int32(nLen) <= 0) + return; + + tools::Long nSpaceSum = 0; + const lang::Locale &rLocale = g_pBreakIt->GetLocale( aLang ); + sal_Int32 nDone = 0; + sal_Int32 nNext(nStt); + for ( sal_Int32 nI = 0; nI < sal_Int32(nLen); ++nI ) + { + if (nI + sal_Int32(nStt) == nNext) + { + nNext = g_pBreakIt->GetBreakIter()->nextCharacters( rText, nNext, + rLocale, + i18n::CharacterIteratorMode::SKIPCELL, 1, nDone ); + if (nNext < sal_Int32(nStt + nLen) || !bIsSpaceStop) + nSpaceSum += nSpaceAdd; + } + rKernArray.adjust(nI, nSpaceSum); + } +} +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/porlay.hxx b/sw/source/core/text/porlay.hxx new file mode 100644 index 0000000000..3b07b70161 --- /dev/null +++ b/sw/source/core/text/porlay.hxx @@ -0,0 +1,352 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#pragma once + +#include + +#include +#include +#include "portxt.hxx" +#include + +#include +#include + +class SwMarginPortion; +class SwDropPortion; +class SwTextFormatter; + +class SwCharRange +{ +private: + TextFrameIndex m_nStart; + TextFrameIndex m_nLen; + +public: + SwCharRange(TextFrameIndex const nInitStart = TextFrameIndex(0), + TextFrameIndex const nInitLen = TextFrameIndex(0)) + : m_nStart( nInitStart ), m_nLen(nInitLen) {} + TextFrameIndex & Start() { return m_nStart; } + TextFrameIndex const& Start() const { return m_nStart; } + void LeftMove(TextFrameIndex const nNew) + { if ( nNew < m_nStart ) { m_nLen += m_nStart-nNew; m_nStart = nNew; } } + TextFrameIndex & Len() { return m_nLen; } + TextFrameIndex const& Len() const { return m_nLen; } + bool operator<(const SwCharRange &rRange) const + { return m_nStart < rRange.m_nStart; } + bool operator>(const SwCharRange &rRange) const + { return m_nStart + m_nLen > rRange.m_nStart + rRange.m_nLen; } + bool operator!=(const SwCharRange &rRange) const + { return *this < rRange || *this > rRange; } + SwCharRange &operator+=(const SwCharRange &rRange); +}; + +// SwRepaint is a document-global SwRect +// nOfst states from where in the first line should be painted +// nRightOfst gives the right margin +class SwRepaint : public SwRect +{ + SwTwips m_nOffset; + SwTwips m_nRightOffset; +public: + SwRepaint() : SwRect(), m_nOffset( 0 ), m_nRightOffset( 0 ) {} + + SwTwips GetOffset() const { return m_nOffset; } + void SetOffset( const SwTwips nNew ) { m_nOffset = nNew; } + SwTwips GetRightOfst() const { return m_nRightOffset; } + void SetRightOfst( const SwTwips nNew ) { m_nRightOffset = nNew; } +}; + +/// Collection of SwLinePortion instances, representing one line of text. +/// Typically owned by an SwParaPortion. +class SW_DLLPUBLIC SwLineLayout : public SwTextPortion +{ +private: + SwLineLayout *m_pNext; // The next Line + std::unique_ptr> m_pLLSpaceAdd; // Used for justified alignment + std::unique_ptr> m_pKanaComp; // Used for Kana compression + SwTwips m_nRealHeight; // The height resulting from line spacing and register + SwTwips m_nTextHeight; // The max height of all non-FlyCnt portions in this Line + bool m_bFormatAdj : 1; + bool m_bDummy : 1; + bool m_bEndHyph : 1; + bool m_bMidHyph : 1; + bool m_bFly : 1; + bool m_bRest : 1; + bool m_bBlinking : 1; + bool m_bClipping : 1; // Clipping needed for exact line height + bool m_bContent : 1; // Text for line numbering + bool m_bRedline : 1; // The Redlining + bool m_bRedlineEnd: 1; // Redlining for paragraph mark: tracked change at the end + bool m_bForcedLeftMargin : 1; // Left adjustment moved by the Fly + bool m_bHanging : 1; // Contains a hanging portion in the margin + bool m_bUnderscore : 1; + + enum RedlineType m_eRedlineEnd; // redline type of pilcrow and line break symbols + + OUString m_sRedlineText; // shortened text of (first) tracked deletion shown in margin + + SwTwips GetHangingMargin_() const; + + void DeleteNext(); +public: + // From SwPosSize + using SwPosSize::Height; + virtual void Height(const SwTwips nNew, const bool bText = true) override; + + // From SwLinePortion + virtual SwLinePortion *Insert( SwLinePortion *pPortion ) override; + virtual SwLinePortion *Append( SwLinePortion *pPortion ) override; + SwLinePortion *GetFirstPortion() const; + + // Flags + void ResetFlags(); + void SetFormatAdj( const bool bNew ) { m_bFormatAdj = bNew; } + bool IsFormatAdj() const { return m_bFormatAdj; } + void SetEndHyph( const bool bNew ) { m_bEndHyph = bNew; } + bool IsEndHyph() const { return m_bEndHyph; } + void SetMidHyph( const bool bNew ) { m_bMidHyph = bNew; } + bool IsMidHyph() const { return m_bMidHyph; } + void SetFly( const bool bNew ) { m_bFly = bNew; } + bool IsFly() const { return m_bFly; } + void SetRest( const bool bNew ) { m_bRest = bNew; } + bool IsRest() const { return m_bRest; } + void SetBlinking( const bool bNew ) { m_bBlinking = bNew; } + bool IsBlinking() const { return m_bBlinking; } + void SetContent( const bool bNew ) { m_bContent = bNew; } + bool HasContent() const { return m_bContent; } + void SetRedline( const bool bNew ) { m_bRedline = bNew; } + bool HasRedline() const { return m_bRedline; } + void SetRedlineEnd( const bool bNew ) { m_bRedlineEnd = bNew; } + bool HasRedlineEnd() const { return m_bRedlineEnd; } + void SetRedlineEndType( const enum RedlineType eNew ) { m_eRedlineEnd = eNew; } + RedlineType GetRedlineEndType() const { return m_eRedlineEnd; } + void SetRedlineText ( const OUString& sText ) { m_sRedlineText = sText; } + const OUString* GetRedlineText() const { return &m_sRedlineText; } + void SetForcedLeftMargin() { m_bForcedLeftMargin = true; } + bool HasForcedLeftMargin() const { return m_bForcedLeftMargin; } + void SetHanging( const bool bNew ) { m_bHanging = bNew; } + bool IsHanging() const { return m_bHanging; } + void SetUnderscore( const bool bNew ) { m_bUnderscore = bNew; } + bool HasUnderscore() const { return m_bUnderscore; } + + // Respecting empty dummy lines + void SetDummy( const bool bNew ) { m_bDummy = bNew; } + bool IsDummy() const { return m_bDummy; } + + void SetClipping( const bool bNew ) { m_bClipping = bNew; } + bool IsClipping() const { return m_bClipping; } + + SwLineLayout(); + virtual ~SwLineLayout() override; + + SwLineLayout *GetNext() { return m_pNext; } + const SwLineLayout *GetNext() const { return m_pNext; } + void SetNext( SwLineLayout *pNew ) { m_pNext = pNew; } + + void Init( SwLinePortion *pNextPortion = nullptr); + + // Collects the data for the line + void CalcLine( SwTextFormatter &rLine, SwTextFormatInfo &rInf ); + + void SetRealHeight( SwTwips nNew ) { m_nRealHeight = nNew; } + SwTwips GetRealHeight() const { return m_nRealHeight; } + + SwTwips GetTextHeight() const { return m_nTextHeight; } + + // Creates the glue chain for short lines + SwMarginPortion *CalcLeftMargin(); + + SwTwips GetHangingMargin() const + { return GetHangingMargin_(); } + + // For special treatment for empty lines + virtual bool Format( SwTextFormatInfo &rInf ) override; + + // Stuff for justified alignment + bool IsSpaceAdd() const { return m_pLLSpaceAdd != nullptr; } + void InitSpaceAdd(); // Creates pLLSpaceAdd if necessary + void CreateSpaceAdd( const tools::Long nInit = 0 ); + void FinishSpaceAdd() { m_pLLSpaceAdd.reset(); } + sal_uInt16 GetLLSpaceAddCount() const { return sal::static_int_cast< sal_uInt16 >(m_pLLSpaceAdd->size()); } + void SetLLSpaceAdd( tools::Long nNew, sal_uInt16 nIdx ) + { + if ( nIdx == GetLLSpaceAddCount() ) + m_pLLSpaceAdd->push_back( nNew ); + else + (*m_pLLSpaceAdd)[ nIdx ] = nNew; + } + tools::Long GetLLSpaceAdd( sal_uInt16 nIdx ) { return (*m_pLLSpaceAdd)[ nIdx ]; } + void RemoveFirstLLSpaceAdd() { m_pLLSpaceAdd->erase( m_pLLSpaceAdd->begin() ); } + std::vector* GetpLLSpaceAdd() const { return m_pLLSpaceAdd.get(); } + + // Stuff for Kana compression + void SetKanaComp( std::unique_ptr> pNew ){ m_pKanaComp = std::move(pNew); } + void FinishKanaComp() { m_pKanaComp.reset(); } + std::deque* GetpKanaComp() const { return m_pKanaComp.get(); } + std::deque& GetKanaComp() { return *m_pKanaComp; } + + /** determine ascent and descent for positioning of as-character anchored + object + + OD 07.01.2004 #i11859# - previously local method + Method calculates maximum ascents and descents of the line layout. + One value considering as-character anchored objects, one without these + objects. + Portions for other anchored objects aren't considered. + OD 2005-05-20 #i47162# - add optional parameter <_bNoFlyCntPorAndLinePor> + to control, if the fly content portions and line portion are considered. + + @param _orAscent + output parameter - maximum ascent without as-character anchored objects + + @param _orDescent + output parameter - maximum descent without as-character anchored objects + + @param _orObjAscent + output parameter - maximum ascent with as-character anchored objects + + @param _orObjDescent + output parameter - maximum descent with as-character anchored objects + + @param _pDontConsiderPortion + input parameter - portion, which isn't considered for calculating + <_orObjAscent> and <_orObjDescent>, if it isn't a portion for a + as-character anchored object or it isn't as high as the line. + + @param _bNoFlyCntPorAndLinePor + optional input parameter - boolean, indicating that fly content portions + and the line portion are considered or not. + */ + void MaxAscentDescent( SwTwips& _orAscent, + SwTwips& _orDescent, + SwTwips& _orObjAscent, + SwTwips& _orObjDescent, + const SwLinePortion* _pDontConsiderPortion = nullptr, + const bool _bNoFlyCntPorAndLinePor = false ) const; + + void dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, + TextFrameIndex& nOffset) const override; +}; + +/// Collection of SwLineLayout instances, represents the paragraph text in Writer layout. +/// Typically owned by an SwTextFrame. +class SwParaPortion : public SwLineLayout +{ + // Area that needs repainting + SwRepaint m_aRepaint; + // Area that needs reformatting + SwCharRange m_aReformat; + SwScriptInfo m_aScriptInfo; + + // Fraction aZoom; + tools::Long m_nDelta; + + // If a SwTextFrame is locked, no changes occur to the formatting data (under + // pLine) (compare with Orphans) + bool m_bFlys : 1; // Overlapping Flys? + bool m_bPrep : 1; // PREP_* + bool m_bPrepWidows : 1; // PrepareHint::Widows + bool m_bPrepAdjust : 1; // PrepareHint::AdjustSizeWithoutFormatting + bool m_bPrepMustFit : 1; // PrepareHint::MustFit + bool m_bFollowField : 1; // We have a bit of field left for the Follow + + bool m_bFixLineHeight : 1; // Fixed line height + bool m_bFootnoteNum : 1; // is the frame that may contain a footnotenumberportion + bool m_bMargin : 1; // contains a hanging punctuation in the margin + +public: + SwParaPortion(); + virtual ~SwParaPortion() override; + + // Resets all formatting information (except for bFlys) + inline void FormatReset(); + + // Resets the Flags + inline void ResetPreps(); + + // Get/Set methods + SwRepaint& GetRepaint() { return m_aRepaint; } + const SwRepaint& GetRepaint() const { return m_aRepaint; } + SwCharRange& GetReformat() { return m_aReformat; } + const SwCharRange& GetReformat() const { return m_aReformat; } + void SetDelta(tools::Long nDelta) { m_nDelta = nDelta; } + tools::Long GetDelta() const { return m_nDelta; } + SwScriptInfo& GetScriptInfo() { return m_aScriptInfo; } + const SwScriptInfo& GetScriptInfo() const { return m_aScriptInfo; } + + // For SwTextFrame::Format: returns the paragraph's current length + TextFrameIndex GetParLen() const; + + // For Prepare() + bool UpdateQuoVadis( std::u16string_view rQuo ); + + // Flags + void SetFly() { m_bFlys = true; } + bool HasFly() const { return m_bFlys; } + + // Preps + void SetPrep() { m_bPrep = true; } + bool IsPrep() const { return m_bPrep; } + void SetPrepWidows() { m_bPrepWidows = true; } + bool IsPrepWidows() const { return m_bPrepWidows; } + void SetPrepMustFit( const bool bNew ) { m_bPrepMustFit = bNew; } + bool IsPrepMustFit() const { return m_bPrepMustFit; } + void SetPrepAdjust() { m_bPrepAdjust = true; } + bool IsPrepAdjust() const { return m_bPrepAdjust; } + void SetFollowField( const bool bNew ) { m_bFollowField = bNew; } + bool IsFollowField() const { return m_bFollowField; } + void SetFixLineHeight() { m_bFixLineHeight = true; } + bool IsFixLineHeight() const { return m_bFixLineHeight; } + + void SetFootnoteNum( const bool bNew ) { m_bFootnoteNum = bNew; } + bool IsFootnoteNum() const { return m_bFootnoteNum; } + void SetMargin( const bool bNew = true ) { m_bMargin = bNew; } + bool IsMargin() const { return m_bMargin; } + enum FootnoteOrNot { OnlyNumbering, FootnoteToo }; + bool HasNumberingPortion(FootnoteOrNot) const; + bool HasContentPortions() const; + + // Set nErgo in the QuoVadisPortion + void SetErgoSumNum( const OUString &rErgo ); + + const SwDropPortion *FindDropPortion() const; + + void dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, + TextFrameIndex& nOffset) const override; +}; + +inline void SwParaPortion::ResetPreps() +{ + m_bPrep = m_bPrepWidows = m_bPrepAdjust = m_bPrepMustFit = false; +} + +inline void SwParaPortion::FormatReset() +{ + m_nDelta = 0; + m_aReformat = SwCharRange(TextFrameIndex(0), TextFrameIndex(COMPLETE_STRING)); + // bFlys needs to be retained in SwTextFrame::Format_() so that empty + // paragraphs that needed to avoid Frames with no flow, reformat + // when the Frame disappears from the Area + // bFlys = false; + ResetPreps(); + m_bFollowField = m_bFixLineHeight = m_bMargin = false; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/porlin.cxx b/sw/source/core/text/porlin.cxx new file mode 100644 index 0000000000..a420d64301 --- /dev/null +++ b/sw/source/core/text/porlin.cxx @@ -0,0 +1,358 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include + +#include "porlin.hxx" +#include "portxt.hxx" +#include "inftxt.hxx" +#include "pormulti.hxx" +#if OSL_DEBUG_LEVEL > 0 + +static bool ChkChain( SwLinePortion *pStart ) +{ + SwLinePortion *pPor = pStart->GetNextPortion(); + sal_uInt16 nCount = 0; + while( pPor ) + { + ++nCount; + OSL_ENSURE( nCount < 200 && pPor != pStart, + "ChkChain(): lost in chains" ); + if( nCount >= 200 || pPor == pStart ) + { + // the lifesaver + pPor = pStart->GetNextPortion(); + pStart->SetNextPortion(nullptr); + pPor->Truncate(); + pStart->SetNextPortion( pPor ); + return false; + } + pPor = pPor->GetNextPortion(); + } + return true; +} +#endif + +SwLinePortion::~SwLinePortion() +{ +} + +SwLinePortion *SwLinePortion::Compress() +{ + return GetLen() || Width() ? this : nullptr; +} + +sal_uInt16 SwLinePortion::GetViewWidth( const SwTextSizeInfo & ) const +{ + return 0; +} + +SwLinePortion::SwLinePortion( ) : + mpNextPortion( nullptr ), + mnLineLength( 0 ), + mnAscent( 0 ), + mnHangingBaseline( 0 ), + mnWhichPor( PortionType::NONE ), + m_bJoinBorderWithPrev(false), + m_bJoinBorderWithNext(false) +{ +} + +void SwLinePortion::PrePaint( const SwTextPaintInfo& rInf, + const SwLinePortion* pLast ) const +{ + OSL_ENSURE( rInf.OnWin(), "SwLinePortion::PrePaint: don't prepaint on a printer"); + OSL_ENSURE( !Width(), "SwLinePortion::PrePaint: For Width()==0 only!"); + + const sal_uInt16 nViewWidth = GetViewWidth( rInf ); + + if( ! nViewWidth ) + return; + + const sal_uInt16 nHalfView = nViewWidth / 2; + sal_uInt16 nLastWidth = pLast->Width() + pLast->ExtraBlankWidth(); + + if ( pLast->InSpaceGrp() && rInf.GetSpaceAdd(/*bShrink=*/true) ) + nLastWidth += pLast->CalcSpacing( rInf.GetSpaceAdd(/*bShrink=*/true), rInf ); + + sal_uInt16 nPos; + SwTextPaintInfo aInf( rInf ); + + const bool bBidiPor = rInf.GetTextFrame()->IsRightToLeft() != + bool( vcl::text::ComplexTextLayoutFlags::BiDiRtl & rInf.GetOut()->GetLayoutMode() ); + + Degree10 nDir = bBidiPor ? + 1800_deg10 : + rInf.GetFont()->GetOrientation( rInf.GetTextFrame()->IsVertical() ); + + // pLast == this *only* for the 1st portion in the line so nLastWidth is 0; + // allow this too, will paint outside the frame but might look better... + if (nLastWidth > nHalfView || pLast == this) + { + switch (nDir.get()) + { + case 0: + nPos = sal_uInt16( rInf.X() ); + nPos += nLastWidth - nHalfView; + aInf.X( nPos ); + break; + case 900: + nPos = sal_uInt16( rInf.Y() ); + nPos -= nLastWidth - nHalfView; + aInf.Y( nPos ); + break; + case 1800: + nPos = sal_uInt16( rInf.X() ); + nPos -= nLastWidth - nHalfView; + aInf.X( nPos ); + break; + case 2700: + nPos = sal_uInt16( rInf.Y() ); + nPos += nLastWidth - nHalfView; + aInf.Y( nPos ); + break; + } + } + + SwLinePortion *pThis = const_cast(this); + pThis->Width( nViewWidth ); + Paint( aInf ); + pThis->Width(0); +} + +void SwLinePortion::CalcTextSize( const SwTextSizeInfo &rInf ) +{ + if( GetLen() == rInf.GetLen() ) + *static_cast(this) = GetTextSize( rInf ); + else + { + SwTextSizeInfo aInf( rInf ); + aInf.SetLen( GetLen() ); + *static_cast(this) = GetTextSize( aInf ); + } +} + +// all following portions will be deleted +void SwLinePortion::Truncate_() +{ + SwLinePortion *pPos = mpNextPortion; + do + { + OSL_ENSURE( pPos != this, "SwLinePortion::Truncate: loop" ); + SwLinePortion *pLast = pPos; + pPos = pPos->GetNextPortion(); + pLast->SetNextPortion( nullptr ); + delete pLast; + + } while( pPos ); + + mpNextPortion = nullptr; +} + +// It always will be inserted after us. +SwLinePortion *SwLinePortion::Insert( SwLinePortion *pIns ) +{ + pIns->FindLastPortion()->SetNextPortion( mpNextPortion ); + SetNextPortion( pIns ); +#if OSL_DEBUG_LEVEL > 0 + ChkChain( this ); +#endif + return pIns; +} + +SwLinePortion *SwLinePortion::FindLastPortion() +{ + SwLinePortion *pPos = this; + // Find the end and link pLinPortion to the last one... + while( pPos->GetNextPortion() ) + { + pPos = pPos->GetNextPortion(); + } + return pPos; +} + +SwLinePortion *SwLinePortion::Append( SwLinePortion *pIns ) +{ + SwLinePortion *pPos = FindLastPortion(); + pPos->SetNextPortion( pIns ); + pIns->SetNextPortion( nullptr ); +#if OSL_DEBUG_LEVEL > 0 + ChkChain( this ); +#endif + return pIns; +} + +SwLinePortion *SwLinePortion::Cut( SwLinePortion *pVictim ) +{ + SwLinePortion *pPrev = pVictim->FindPrevPortion( this ); + OSL_ENSURE( pPrev, "SwLinePortion::Cut(): can't cut" ); + // note: if pVictim is a follow then clearing pPrev's m_bHasFollow here is + // tricky because it could be that the HookChar inserted a tab portion + // between 2 field portions + pPrev->SetNextPortion( pVictim->GetNextPortion() ); + pVictim->SetNextPortion(nullptr); + return pVictim; +} + +SwLinePortion *SwLinePortion::FindPrevPortion( const SwLinePortion *pRoot ) +{ + OSL_ENSURE( pRoot != this, "SwLinePortion::FindPrevPortion(): invalid root" ); + SwLinePortion *pPos = const_cast(pRoot); + while( pPos->GetNextPortion() && pPos->GetNextPortion() != this ) + { + pPos = pPos->GetNextPortion(); + } + OSL_ENSURE( pPos->GetNextPortion(), + "SwLinePortion::FindPrevPortion: blowing in the wind"); + return pPos; +} + +TextFrameIndex SwLinePortion::GetModelPositionForViewPoint(const sal_uInt16 nOfst) const +{ + if( nOfst > ( PrtWidth() / 2 ) ) + return GetLen(); + else + return TextFrameIndex(0); +} + +SwPosSize SwLinePortion::GetTextSize( const SwTextSizeInfo & ) const +{ + OSL_ENSURE( false, "SwLinePortion::GetTextSize: don't ask me about sizes, " + "I'm only a stupid SwLinePortion" ); + return SwPosSize(); +} + +bool SwLinePortion::Format( SwTextFormatInfo &rInf ) +{ + if( rInf.X() > rInf.Width() ) + { + Truncate(); + rInf.SetUnderflow( this ); + return true; + } + + const SwLinePortion *pLast = rInf.GetLast(); + Height( pLast->Height() ); + SetAscent( pLast->GetAscent() ); + const sal_uInt16 nNewWidth = o3tl::narrowing(rInf.X() + PrtWidth()); + // Only portions with true width can return true + // Notes for example never set bFull==true + if( rInf.Width() <= nNewWidth && PrtWidth() && ! IsKernPortion() ) + { + Truncate(); + if( nNewWidth > rInf.Width() ) + PrtWidth( nNewWidth - rInf.Width() ); + rInf.GetLast()->FormatEOL( rInf ); + return true; + } + return false; +} + +// Format end of line + +void SwLinePortion::FormatEOL( SwTextFormatInfo & ) +{ } + +void SwLinePortion::Move(SwTextPaintInfo & rInf) const +{ + bool bB2T = rInf.GetDirection() == DIR_BOTTOM2TOP; + const bool bFrameDir = rInf.GetTextFrame()->IsRightToLeft(); + bool bCounterDir = ( ! bFrameDir && DIR_RIGHT2LEFT == rInf.GetDirection() ) || + ( bFrameDir && DIR_LEFT2RIGHT == rInf.GetDirection() ); + + SwTwips nTmp = PrtWidth() + ExtraBlankWidth(); + if ( InSpaceGrp() && rInf.GetSpaceAdd(/*bShrink=*/true) ) + { + nTmp += CalcSpacing( rInf.GetSpaceAdd(/*bShrink=*/true), rInf ); + if( rInf.IsRotated() ) + rInf.Y( rInf.Y() + ( bB2T ? -nTmp : nTmp ) ); + else if ( bCounterDir ) + rInf.X( rInf.X() - nTmp ); + else + rInf.X( rInf.X() + nTmp ); + } + else + { + if( InFixMargGrp() && !IsMarginPortion() ) + { + rInf.IncSpaceIdx(); + rInf.IncKanaIdx(); + } + if( rInf.IsRotated() ) + rInf.Y(rInf.Y() + (bB2T ? -nTmp : nTmp)); + else if ( bCounterDir ) + rInf.X(rInf.X() - nTmp); + else + rInf.X(rInf.X() + nTmp); + } + if (IsMultiPortion() && static_cast(this)->HasTabulator()) + rInf.IncSpaceIdx(); + + rInf.SetIdx( rInf.GetIdx() + GetLen() ); +} + +SwTwips SwLinePortion::CalcSpacing( tools::Long , const SwTextSizeInfo & ) const +{ + return 0; +} + +bool SwLinePortion::GetExpText( const SwTextSizeInfo &, OUString & ) const +{ + return false; +} + +void SwLinePortion::HandlePortion( SwPortionHandler& rPH ) const +{ + rPH.Special( GetLen(), OUString(), GetWhichPor() ); +} + +void SwLinePortion::dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, TextFrameIndex& nOffset) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwLinePortion")); + dumpAsXmlAttributes(pWriter, rText, nOffset); + nOffset += GetLen(); + + (void)xmlTextWriterEndElement(pWriter); +} + +void SwLinePortion::dumpAsXmlAttributes(xmlTextWriterPtr pWriter, std::u16string_view rText, TextFrameIndex nOffset) const +{ + (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("symbol"), BAD_CAST(typeid(*this).name())); + (void)xmlTextWriterWriteAttribute( + pWriter, BAD_CAST("width"), + BAD_CAST(OString::number(Width()).getStr())); + (void)xmlTextWriterWriteAttribute( + pWriter, BAD_CAST("height"), + BAD_CAST(OString::number(Height()).getStr())); + (void)xmlTextWriterWriteAttribute( + pWriter, BAD_CAST("length"), + BAD_CAST(OString::number(static_cast(mnLineLength)).getStr())); + (void)xmlTextWriterWriteAttribute( + pWriter, BAD_CAST("type"), + BAD_CAST(sw::PortionTypeToString(GetWhichPor()))); + OUString aText( rText.substr(sal_Int32(nOffset), sal_Int32(GetLen())) ); + for (int i = 0; i < 32; ++i) + aText = aText.replace(i, '*'); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("portion"), + BAD_CAST(aText.toUtf8().getStr())); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/porlin.hxx b/sw/source/core/text/porlin.hxx new file mode 100644 index 0000000000..50ee3ed159 --- /dev/null +++ b/sw/source/core/text/porlin.hxx @@ -0,0 +1,220 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#pragma once + +#include + +#include "possiz.hxx" +#include +#include +#include + +class SwTextSizeInfo; +class SwTextPaintInfo; +class SwTextFormatInfo; +class SwPortionHandler; + +/// Portion groups +/// @see enum PortionType in txttypes.hxx +#define PORGRP_TXT 0x8000 +#define PORGRP_EXP 0x4000 +#define PORGRP_FLD 0x2000 +#define PORGRP_HYPH 0x1000 +#define PORGRP_NUMBER 0x0800 +#define PORGRP_GLUE 0x0400 +#define PORGRP_FIX 0x0200 +#define PORGRP_TAB 0x0100 +// Small special groups +#define PORGRP_FIXMARG 0x0040 +//#define PORGRP_? 0x0020 +#define PORGRP_TABNOTLFT 0x0010 +#define PORGRP_TOXREF 0x0008 + +/// Base class for anything that can be part of a line in the Writer layout. +/// Typically owned by SwLineLayout. +class SAL_DLLPUBLIC_RTTI SwLinePortion: public SwPosSize +{ +protected: + // Here we have areas with different attributes + SwLinePortion *mpNextPortion; + // Count of chars and spaces on the line + TextFrameIndex mnLineLength; + SwTwips mnAscent; // Maximum ascender + SwTwips mnHangingBaseline; + + SwLinePortion(); +private: + PortionType mnWhichPor; // Who's who? + bool m_bJoinBorderWithPrev; + bool m_bJoinBorderWithNext; + SwTwips m_nExtraBlankWidth = 0; // width of spaces after the break + + void Truncate_(); + +public: + explicit inline SwLinePortion(const SwLinePortion &rPortion); + virtual ~SwLinePortion(); + + // Access methods + SwLinePortion *GetNextPortion() const { return mpNextPortion; } + inline SwLinePortion &operator=(const SwLinePortion &rPortion); + TextFrameIndex GetLen() const { return mnLineLength; } + void SetLen(TextFrameIndex const nLen) { mnLineLength = nLen; } + void SetNextPortion( SwLinePortion *pNew ){ mpNextPortion = pNew; } + SwTwips &GetAscent() { return mnAscent; } + SwTwips GetAscent() const { return mnAscent; } + void SetAscent( const SwTwips nNewAsc ) { mnAscent = nNewAsc; } + void PrtWidth( SwTwips nNewWidth ) { Width( nNewWidth ); } + SwTwips PrtWidth() const { return Width(); } + void AddPrtWidth( const SwTwips nNew ) { Width( Width() + nNew ); } + void SubPrtWidth( const SwTwips nNew ) { Width( Width() - nNew ); } + SwTwips ExtraBlankWidth() const { return m_nExtraBlankWidth; } + void ExtraBlankWidth(const SwTwips nNew) { m_nExtraBlankWidth = nNew; } + SwTwips GetHangingBaseline() const { return mnHangingBaseline; } + void SetHangingBaseline( const SwTwips nNewBaseline ) { mnHangingBaseline = nNewBaseline; } + + // Insert methods + virtual SwLinePortion *Insert( SwLinePortion *pPortion ); + virtual SwLinePortion *Append( SwLinePortion *pPortion ); + SwLinePortion *Cut( SwLinePortion *pVictim ); + inline void Truncate(); + + // Returns 0, if there's no payload + virtual SwLinePortion *Compress(); + + void SetWhichPor( const PortionType nNew ) { mnWhichPor = nNew; } + PortionType GetWhichPor( ) const { return mnWhichPor; } + +// Group queries + bool InTextGrp() const { return (sal_uInt16(mnWhichPor) & PORGRP_TXT) != 0; } + bool InGlueGrp() const { return (sal_uInt16(mnWhichPor) & PORGRP_GLUE) != 0; } + bool InTabGrp() const { return (sal_uInt16(mnWhichPor) & PORGRP_TAB) != 0; } + bool InHyphGrp() const { return (sal_uInt16(mnWhichPor) & PORGRP_HYPH) != 0; } + bool InNumberGrp() const { return (sal_uInt16(mnWhichPor) & PORGRP_NUMBER) != 0; } + bool InFixGrp() const { return (sal_uInt16(mnWhichPor) & PORGRP_FIX) != 0; } + bool InFieldGrp() const { return (sal_uInt16(mnWhichPor) & PORGRP_FLD) != 0; } + bool InToxRefGrp() const { return (sal_uInt16(mnWhichPor) & PORGRP_TOXREF) != 0; } + bool InToxRefOrFieldGrp() const { return (sal_uInt16(mnWhichPor) & ( PORGRP_FLD | PORGRP_TOXREF )) != 0; } + bool InExpGrp() const { return (sal_uInt16(mnWhichPor) & PORGRP_EXP) != 0; } + bool InFixMargGrp() const { return (sal_uInt16(mnWhichPor) & PORGRP_FIXMARG) != 0; } + bool InSpaceGrp() const { return InTextGrp() || IsMultiPortion(); } +// Individual queries + bool IsGrfNumPortion() const { return mnWhichPor == PortionType::GrfNum; } + bool IsFlyCntPortion() const { return mnWhichPor == PortionType::FlyCnt; } + bool IsBlankPortion() const { return mnWhichPor == PortionType::Blank; } + bool IsBreakPortion() const { return mnWhichPor == PortionType::Break; } + bool IsErgoSumPortion() const { return mnWhichPor == PortionType::ErgoSum; } + bool IsQuoVadisPortion() const { return mnWhichPor == PortionType::QuoVadis; } + bool IsTabLeftPortion() const { return mnWhichPor == PortionType::TabLeft; } + bool IsTabRightPortion() const { return mnWhichPor == PortionType::TabRight; } + bool IsTabCenterPortion() const { return mnWhichPor == PortionType::TabCenter; } + bool IsTabDecimalPortion() const { return mnWhichPor == PortionType::TabDecimal; } + bool IsFootnoteNumPortion() const { return mnWhichPor == PortionType::FootnoteNum; } + bool IsFootnotePortion() const { return mnWhichPor == PortionType::Footnote; } + bool IsDropPortion() const { return mnWhichPor == PortionType::Drop; } + bool IsLayPortion() const { return mnWhichPor == PortionType::Lay; } + bool IsParaPortion() const { return mnWhichPor == PortionType::Para; } + bool IsMarginPortion() const { return mnWhichPor == PortionType::Margin; } + bool IsFlyPortion() const { return mnWhichPor == PortionType::Fly; } + bool IsHolePortion() const { return mnWhichPor == PortionType::Hole; } + bool IsSoftHyphPortion() const { return mnWhichPor == PortionType::SoftHyphen; } + bool IsPostItsPortion() const { return mnWhichPor == PortionType::PostIts; } + bool IsCombinedPortion() const { return mnWhichPor == PortionType::Combined; } + bool IsTextPortion() const { return mnWhichPor == PortionType::Text; } + bool IsHangingPortion() const { return mnWhichPor == PortionType::Hanging; } + bool IsKernPortion() const { return mnWhichPor == PortionType::Kern; } + bool IsArrowPortion() const { return mnWhichPor == PortionType::Arrow; } + bool IsMultiPortion() const { return mnWhichPor == PortionType::Multi; } + bool IsNumberPortion() const { return mnWhichPor == PortionType::Number; } // #i23726# + bool IsControlCharPortion() const { return mnWhichPor == PortionType::ControlChar || mnWhichPor == PortionType::Bookmark; } + + // Positioning + SwLinePortion *FindPrevPortion( const SwLinePortion *pRoot ); + SwLinePortion *FindLastPortion(); + + /// the parameter is actually SwTwips apparently? + virtual TextFrameIndex GetModelPositionForViewPoint(sal_uInt16 nOfst) const; + virtual SwPosSize GetTextSize( const SwTextSizeInfo &rInfo ) const; + void CalcTextSize( const SwTextSizeInfo &rInfo ); + + // Output + virtual void Paint( const SwTextPaintInfo &rInf ) const = 0; + void PrePaint( const SwTextPaintInfo &rInf, const SwLinePortion *pLast ) const; + + virtual bool Format( SwTextFormatInfo &rInf ); + // Is called for the line's last portion + virtual void FormatEOL( SwTextFormatInfo &rInf ); + void Move(SwTextPaintInfo & rInf) const; + + // For SwTextSlot + virtual bool GetExpText( const SwTextSizeInfo &rInf, OUString &rText ) const; + + // For SwFieldPortion, SwSoftHyphPortion + virtual sal_uInt16 GetViewWidth( const SwTextSizeInfo &rInf ) const; + + // for text- and multi-portions + virtual SwTwips CalcSpacing( tools::Long nSpaceAdd, const SwTextSizeInfo &rInf ) const; + + // Accessibility: pass information about this portion to the PortionHandler + virtual void HandlePortion( SwPortionHandler& rPH ) const; + + bool GetJoinBorderWithPrev() const { return m_bJoinBorderWithPrev; } + bool GetJoinBorderWithNext() const { return m_bJoinBorderWithNext; } + void SetJoinBorderWithPrev( const bool bJoinPrev ) { m_bJoinBorderWithPrev = bJoinPrev; } + void SetJoinBorderWithNext( const bool bJoinNext ) { m_bJoinBorderWithNext = bJoinNext; } + + virtual void dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, + TextFrameIndex& rOffset) const; + void dumpAsXmlAttributes(xmlTextWriterPtr writer, std::u16string_view rText, + TextFrameIndex nOffset) const; +}; + +inline SwLinePortion &SwLinePortion::operator=(const SwLinePortion &rPortion) +{ + *static_cast(this) = rPortion; + mnLineLength = rPortion.mnLineLength; + mnAscent = rPortion.mnAscent; + mnHangingBaseline = rPortion.mnHangingBaseline; + mnWhichPor = rPortion.mnWhichPor; + m_bJoinBorderWithPrev = rPortion.m_bJoinBorderWithPrev; + m_bJoinBorderWithNext = rPortion.m_bJoinBorderWithNext; + m_nExtraBlankWidth = rPortion.m_nExtraBlankWidth; + return *this; +} + +inline SwLinePortion::SwLinePortion(const SwLinePortion &rPortion) : + SwPosSize( rPortion ), + mpNextPortion( nullptr ), + mnLineLength( rPortion.mnLineLength ), + mnAscent( rPortion.mnAscent ), + mnHangingBaseline( rPortion.mnHangingBaseline ), + mnWhichPor( rPortion.mnWhichPor ), + m_bJoinBorderWithPrev( rPortion.m_bJoinBorderWithPrev ), + m_bJoinBorderWithNext( rPortion.m_bJoinBorderWithNext ), + m_nExtraBlankWidth(rPortion.m_nExtraBlankWidth) +{ +} + +inline void SwLinePortion::Truncate() +{ + if ( mpNextPortion ) + Truncate_(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/pormulti.cxx b/sw/source/core/text/pormulti.cxx new file mode 100644 index 0000000000..7771ab9b5e --- /dev/null +++ b/sw/source/core/text/pormulti.cxx @@ -0,0 +1,2635 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "pormulti.hxx" +#include "inftxt.hxx" +#include "itrpaint.hxx" +#include +#include "itrform2.hxx" +#include "porfld.hxx" +#include "porglue.hxx" +#include "porrst.hxx" +#include +#include +#include +#include +#include +#include + +using namespace ::com::sun::star; + +// A SwMultiPortion is not a simple portion, +// it's a container, which contains almost a SwLineLayoutPortion. +// This SwLineLayout could be followed by other textportions via pPortion +// and by another SwLineLayout via pNext to realize a doubleline portion. +SwMultiPortion::~SwMultiPortion() +{ +} + +void SwMultiPortion::Paint( const SwTextPaintInfo & ) const +{ + OSL_FAIL( "Don't try SwMultiPortion::Paint, try SwTextPainter::PaintMultiPortion" ); +} + +// Summarize the internal lines to calculate the (external) size. +// The internal line has to calculate first. +void SwMultiPortion::CalcSize( SwTextFormatter& rLine, SwTextFormatInfo &rInf ) +{ + Width( 0 ); + Height( 0 ); + SetAscent( 0 ); + SetFlyInContent( false ); + SwLineLayout *pLay = &GetRoot(); + do + { + pLay->CalcLine( rLine, rInf ); + if( rLine.IsFlyInCntBase() ) + SetFlyInContent( true ); + if( IsRuby() && ( OnTop() == ( pLay == &GetRoot() ) ) ) + { + // An empty phonetic line don't need an ascent or a height. + if( !pLay->Width() ) + { + pLay->SetAscent( 0 ); + pLay->Height( 0 ); + } + if( OnTop() ) + SetAscent( GetAscent() + pLay->Height() ); + } + else + SetAscent( GetAscent() + pLay->GetAscent() ); + + // Increase the line height, except for ruby text on the right. + if ( !IsRuby() || !OnRight() || pLay == &GetRoot() ) + Height( Height() + pLay->Height() ); + else + { + // We already added the width after building the portion, + // so no need to add it twice. + break; + } + + if( Width() < pLay->Width() ) + Width( pLay->Width() ); + pLay = pLay->GetNext(); + } while ( pLay ); + if( !HasBrackets() ) + return; + + sal_uInt16 nTmp = static_cast(this)->GetBrackets()->nHeight; + if( nTmp > Height() ) + { + const sal_uInt16 nAdd = ( nTmp - Height() ) / 2; + GetRoot().SetAscent( GetRoot().GetAscent() + nAdd ); + GetRoot().Height( GetRoot().Height() + nAdd ); + Height( nTmp ); + } + nTmp = static_cast(this)->GetBrackets()->nAscent; + if( nTmp > GetAscent() ) + SetAscent( nTmp ); +} + +SwTwips SwMultiPortion::CalcSpacing( tools::Long , const SwTextSizeInfo & ) const +{ + return 0; +} + +bool SwMultiPortion::ChgSpaceAdd( SwLineLayout*, tools::Long ) const +{ + return false; +} + +void SwMultiPortion::HandlePortion( SwPortionHandler& rPH ) const +{ + rPH.Text( GetLen(), GetWhichPor() ); +} + +void SwMultiPortion::dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, + TextFrameIndex& nOffset) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwMultiPortion")); + dumpAsXmlAttributes(pWriter, rText, nOffset); + // Intentionally not incrementing nOffset here, one of the child portions will do that. + + const SwLineLayout* pLine = &GetRoot(); + while (pLine) + { + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwLineLayout")); + pLine->dumpAsXmlAttributes(pWriter, rText, nOffset); + const SwLinePortion* pPor = pLine->GetFirstPortion(); + while (pPor) + { + pPor->dumpAsXml(pWriter, rText, nOffset); + pPor = pPor->GetNextPortion(); + } + (void)xmlTextWriterEndElement(pWriter); + pLine = pLine->GetNext(); + } + + (void)xmlTextWriterEndElement(pWriter); +} + +// sets the tabulator-flag, if there's any tabulator-portion inside. +void SwMultiPortion::ActualizeTabulator() +{ + SwLinePortion* pPor = GetRoot().GetFirstPortion(); + // First line + for( m_bTab1 = m_bTab2 = false; pPor; pPor = pPor->GetNextPortion() ) + if( pPor->InTabGrp() ) + SetTab1( true ); + if( GetRoot().GetNext() ) + { + // Second line + pPor = GetRoot().GetNext()->GetFirstPortion(); + do + { + if( pPor->InTabGrp() ) + SetTab2( true ); + pPor = pPor->GetNextPortion(); + } while ( pPor ); + } +} + +SwRotatedPortion::SwRotatedPortion( const SwMultiCreator& rCreate, + TextFrameIndex const nEnd, bool bRTL ) + : SwMultiPortion( nEnd ) +{ + const SvxCharRotateItem* pRot = static_cast(rCreate.pItem); + if( !pRot ) + { + const SwTextAttr& rAttr = *rCreate.pAttr; + const SfxPoolItem *const pItem = + CharFormat::GetItem(rAttr, RES_CHRATR_ROTATE); + if ( pItem ) + { + pRot = static_cast(pItem); + } + } + if( pRot ) + { + sal_uInt8 nDir; + if ( bRTL ) + nDir = pRot->IsBottomToTop() ? 3 : 1; + else + nDir = pRot->IsBottomToTop() ? 1 : 3; + + SetDirection( nDir ); + } +} + +SwBidiPortion::SwBidiPortion(TextFrameIndex const nEnd, sal_uInt8 nLv) + : SwMultiPortion( nEnd ), m_nLevel( nLv ) +{ + SetBidi(); + + if ( m_nLevel % 2 ) + SetDirection( DIR_RIGHT2LEFT ); + else + SetDirection( DIR_LEFT2RIGHT ); +} + +SwTwips SwBidiPortion::CalcSpacing( tools::Long nSpaceAdd, const SwTextSizeInfo& rInf ) const +{ + return HasTabulator() ? 0 : sal_Int32(GetSpaceCnt(rInf)) * nSpaceAdd / SPACING_PRECISION_FACTOR; +} + +bool SwBidiPortion::ChgSpaceAdd( SwLineLayout* pCurr, tools::Long nSpaceAdd ) const +{ + if( !HasTabulator() && nSpaceAdd > 0 && !pCurr->IsSpaceAdd() ) + { + pCurr->CreateSpaceAdd(); + pCurr->SetLLSpaceAdd( nSpaceAdd, 0 ); + return true; + } + + return false; +} + +TextFrameIndex SwBidiPortion::GetSpaceCnt(const SwTextSizeInfo &rInf) const +{ + // Calculate number of blanks for justified alignment + TextFrameIndex nTmpStart = rInf.GetIdx(); + TextFrameIndex nNull(0); + TextFrameIndex nBlanks(0); + + for (SwLinePortion* pPor = GetRoot().GetFirstPortion(); pPor; pPor = pPor->GetNextPortion()) + { + if( pPor->InTextGrp() ) + nBlanks = nBlanks + static_cast(pPor)->GetSpaceCnt( rInf, nNull ); + else if ( pPor->IsMultiPortion() && + static_cast(pPor)->IsBidi() ) + nBlanks = nBlanks + static_cast(pPor)->GetSpaceCnt( rInf ); + + const_cast(rInf).SetIdx( rInf.GetIdx() + pPor->GetLen() ); + } + const_cast(rInf).SetIdx( nTmpStart ); + return nBlanks; +} + +// This constructor is for the continuation of a doubleline portion +// in the next line. +// It takes the same brackets and if the original has no content except +// brackets, these will be deleted. +SwDoubleLinePortion::SwDoubleLinePortion( + SwDoubleLinePortion& rDouble, TextFrameIndex const nEnd) + : SwMultiPortion(nEnd) + , m_nLineDiff(0) + , m_nBlank1(0) + , m_nBlank2(0) +{ + SetDirection( rDouble.GetDirection() ); + SetDouble(); + if( rDouble.GetBrackets() ) + { + SetBrackets( rDouble ); + // An empty multiportion needs no brackets. + // Notice: GetLen() might be zero, if the multiportion contains + // the second part of a field and the width might be zero, if + // it contains a note only. In this cases the brackets are okay. + // But if the length and the width are both zero, the portion + // is really empty. + if( rDouble.Width() == rDouble.BracketWidth() ) + rDouble.ClearBrackets(); + } +} + +// This constructor uses the textattribute to get the right brackets. +// The textattribute could be a 2-line-attribute or a character- or +// internet style, which contains the 2-line-attribute. +SwDoubleLinePortion::SwDoubleLinePortion( + const SwMultiCreator& rCreate, TextFrameIndex const nEnd) + : SwMultiPortion(nEnd) + , m_pBracket(new SwBracket) + , m_nLineDiff(0) + , m_nBlank1(0) + , m_nBlank2(0) +{ + m_pBracket->nAscent = 0; + m_pBracket->nHeight = 0; + m_pBracket->nPreWidth = 0; + m_pBracket->nPostWidth = 0; + + SetDouble(); + const SvxTwoLinesItem* pTwo = static_cast(rCreate.pItem); + if( pTwo ) + m_pBracket->nStart = TextFrameIndex(0); + else + { + const SwTextAttr& rAttr = *rCreate.pAttr; + m_pBracket->nStart = rCreate.nStartOfAttr; + + const SfxPoolItem * const pItem = + CharFormat::GetItem( rAttr, RES_CHRATR_TWO_LINES ); + if ( pItem ) + { + pTwo = static_cast(pItem); + } + } + if( pTwo ) + { + m_pBracket->cPre = pTwo->GetStartBracket(); + m_pBracket->cPost = pTwo->GetEndBracket(); + } + else + { + m_pBracket->cPre = 0; + m_pBracket->cPost = 0; + } + SwFontScript nTmp = SW_SCRIPTS; + if( m_pBracket->cPre > 255 ) + { + OUString aText(m_pBracket->cPre); + nTmp = SwScriptInfo::WhichFont(0, aText); + } + m_pBracket->nPreScript = nTmp; + nTmp = SW_SCRIPTS; + if( m_pBracket->cPost > 255 ) + { + OUString aText(m_pBracket->cPost); + nTmp = SwScriptInfo::WhichFont(0, aText); + } + m_pBracket->nPostScript = nTmp; + + if( !m_pBracket->cPre && !m_pBracket->cPost ) + { + m_pBracket.reset(); + } + + // double line portions have the same direction as the frame directions + if ( rCreate.nLevel % 2 ) + SetDirection( DIR_RIGHT2LEFT ); + else + SetDirection( DIR_LEFT2RIGHT ); +} + +// paints the wished bracket, +// if the multiportion has surrounding brackets. +// The X-position of the SwTextPaintInfo will be modified: +// the open bracket sets position behind itself, +// the close bracket in front of itself. +void SwDoubleLinePortion::PaintBracket( SwTextPaintInfo &rInf, + tools::Long nSpaceAdd, + bool bOpen ) const +{ + sal_Unicode cCh = bOpen ? m_pBracket->cPre : m_pBracket->cPost; + if( !cCh ) + return; + const sal_uInt16 nChWidth = bOpen ? PreWidth() : PostWidth(); + if( !nChWidth ) + return; + if( !bOpen ) + rInf.X( rInf.X() + Width() - PostWidth() + + ( nSpaceAdd > 0 ? CalcSpacing( nSpaceAdd, rInf ) : 0 ) ); + + SwBlankPortion aBlank( cCh, true ); + aBlank.SetAscent( m_pBracket->nAscent ); + aBlank.Width( nChWidth ); + aBlank.Height( m_pBracket->nHeight ); + { + SwFont aTmpFnt( *rInf.GetFont() ); + SwFontScript nAct = bOpen ? m_pBracket->nPreScript : m_pBracket->nPostScript; + if( SW_SCRIPTS > nAct ) + aTmpFnt.SetActual( nAct ); + aTmpFnt.SetProportion( 100 ); + SwFontSave aSave( rInf, &aTmpFnt ); + aBlank.Paint( rInf ); + } + if( bOpen ) + rInf.X( rInf.X() + PreWidth() ); +} + +// creates the bracket-structure +// and fills it, if not both characters are 0x00. +void SwDoubleLinePortion::SetBrackets( const SwDoubleLinePortion& rDouble ) +{ + if( rDouble.m_pBracket ) + { + m_pBracket.reset( new SwBracket ); + m_pBracket->cPre = rDouble.m_pBracket->cPre; + m_pBracket->cPost = rDouble.m_pBracket->cPost; + m_pBracket->nPreScript = rDouble.m_pBracket->nPreScript; + m_pBracket->nPostScript = rDouble.m_pBracket->nPostScript; + m_pBracket->nStart = rDouble.m_pBracket->nStart; + } +} + +// calculates the size of the brackets => pBracket, +// reduces the nMaxWidth-parameter ( minus bracket-width ) +// and moves the rInf-x-position behind the opening bracket. +void SwDoubleLinePortion::FormatBrackets( SwTextFormatInfo &rInf, SwTwips& nMaxWidth ) +{ + nMaxWidth -= rInf.X(); + SwFont aTmpFnt( *rInf.GetFont() ); + aTmpFnt.SetProportion( 100 ); + m_pBracket->nAscent = 0; + m_pBracket->nHeight = 0; + if( m_pBracket->cPre ) + { + OUString aStr( m_pBracket->cPre ); + SwFontScript nActualScr = aTmpFnt.GetActual(); + if( SW_SCRIPTS > m_pBracket->nPreScript ) + aTmpFnt.SetActual( m_pBracket->nPreScript ); + SwFontSave aSave( rInf, &aTmpFnt ); + SwPosSize aSize = rInf.GetTextSize( aStr ); + m_pBracket->nAscent = rInf.GetAscent(); + m_pBracket->nHeight = aSize.Height(); + aTmpFnt.SetActual( nActualScr ); + if( nMaxWidth > aSize.Width() ) + { + m_pBracket->nPreWidth = aSize.Width(); + nMaxWidth -= aSize.Width(); + rInf.X( rInf.X() + aSize.Width() ); + } + else + { + m_pBracket->nPreWidth = 0; + nMaxWidth = 0; + } + } + else + m_pBracket->nPreWidth = 0; + if( m_pBracket->cPost ) + { + OUString aStr( m_pBracket->cPost ); + if( SW_SCRIPTS > m_pBracket->nPostScript ) + aTmpFnt.SetActual( m_pBracket->nPostScript ); + SwFontSave aSave( rInf, &aTmpFnt ); + SwPosSize aSize = rInf.GetTextSize( aStr ); + const sal_uInt16 nTmpAsc = rInf.GetAscent(); + if( nTmpAsc > m_pBracket->nAscent ) + { + m_pBracket->nHeight += nTmpAsc - m_pBracket->nAscent; + m_pBracket->nAscent = nTmpAsc; + } + if( aSize.Height() > m_pBracket->nHeight ) + m_pBracket->nHeight = aSize.Height(); + if( nMaxWidth > aSize.Width() ) + { + m_pBracket->nPostWidth = aSize.Width(); + nMaxWidth -= aSize.Width(); + } + else + { + m_pBracket->nPostWidth = 0; + nMaxWidth = 0; + } + } + else + m_pBracket->nPostWidth = 0; + nMaxWidth += rInf.X(); +} + +// calculates the number of blanks in each line and +// the difference of the width of the two lines. +// These results are used from the text adjustment. +void SwDoubleLinePortion::CalcBlanks( SwTextFormatInfo &rInf ) +{ + SwLinePortion* pPor = GetRoot().GetFirstPortion(); + TextFrameIndex nNull(0); + TextFrameIndex nStart = rInf.GetIdx(); + SetTab1( false ); + SetTab2( false ); + for (m_nBlank1 = TextFrameIndex(0); pPor; pPor = pPor->GetNextPortion()) + { + if( pPor->InTextGrp() ) + m_nBlank1 = m_nBlank1 + static_cast(pPor)->GetSpaceCnt( rInf, nNull ); + rInf.SetIdx( rInf.GetIdx() + pPor->GetLen() ); + if( pPor->InTabGrp() ) + SetTab1( true ); + } + m_nLineDiff = GetRoot().Width(); + if( GetRoot().GetNext() ) + { + pPor = GetRoot().GetNext()->GetFirstPortion(); + m_nLineDiff -= GetRoot().GetNext()->Width(); + } + for (m_nBlank2 = TextFrameIndex(0); pPor; pPor = pPor->GetNextPortion()) + { + if( pPor->InTextGrp() ) + m_nBlank2 = m_nBlank2 + static_cast(pPor)->GetSpaceCnt( rInf, nNull ); + rInf.SetIdx( rInf.GetIdx() + pPor->GetLen() ); + if( pPor->InTabGrp() ) + SetTab2( true ); + } + rInf.SetIdx( nStart ); +} + +SwTwips SwDoubleLinePortion::CalcSpacing( tools::Long nSpaceAdd, const SwTextSizeInfo & ) const +{ + return HasTabulator() ? 0 : sal_Int32(GetSpaceCnt()) * nSpaceAdd / SPACING_PRECISION_FACTOR; +} + +// Merges the spaces for text adjustment from the inner and outer part. +// Inside the doubleline portion the wider line has no spaceadd-array, the +// smaller line has such an array to reach width of the wider line. +// If the surrounding line has text adjustment and the doubleline portion +// contains no tabulator, it is necessary to create/manipulate the inner +// space arrays. +bool SwDoubleLinePortion::ChgSpaceAdd( SwLineLayout* pCurr, + tools::Long nSpaceAdd ) const +{ + bool bRet = false; + if( !HasTabulator() && nSpaceAdd > 0 ) + { + if( !pCurr->IsSpaceAdd() ) + { + // The wider line gets the spaceadd from the surrounding line direct + pCurr->CreateSpaceAdd(); + pCurr->SetLLSpaceAdd( nSpaceAdd, 0 ); + bRet = true; + } + else + { + sal_Int32 const nMyBlank = sal_Int32(GetSmallerSpaceCnt()); + sal_Int32 const nOther = sal_Int32(GetSpaceCnt()); + SwTwips nMultiSpace = pCurr->GetLLSpaceAdd( 0 ) * nMyBlank + nOther * nSpaceAdd; + + if( nMyBlank ) + nMultiSpace /= sal_Int32(nMyBlank); + +// pCurr->SetLLSpaceAdd( nMultiSpace, 0 ); + // #i65711# SetLLSpaceAdd replaces the first value, + // instead we want to insert a new first value: + std::vector* pVec = pCurr->GetpLLSpaceAdd(); + pVec->insert( pVec->begin(), nMultiSpace ); + bRet = true; + } + } + return bRet; +} +// cancels the manipulation from SwDoubleLinePortion::ChangeSpaceAdd(..) +void SwDoubleLinePortion::ResetSpaceAdd( SwLineLayout* pCurr ) +{ + pCurr->RemoveFirstLLSpaceAdd(); + if( !pCurr->GetLLSpaceAddCount() ) + pCurr->FinishSpaceAdd(); +} + +SwDoubleLinePortion::~SwDoubleLinePortion() +{ +} + +// constructs a ruby portion, i.e. an additional text is displayed +// beside the main text, e.g. phonetic characters. +SwRubyPortion::SwRubyPortion(const SwRubyPortion& rRuby, TextFrameIndex const nEnd) + : SwMultiPortion( nEnd ) + , m_nRubyOffset( rRuby.GetRubyOffset() ) + , m_nAdjustment( rRuby.GetAdjustment() ) +{ + SetDirection( rRuby.GetDirection() ); + SetRubyPosition( rRuby.GetRubyPosition() ); + SetRuby(); +} + +// constructs a ruby portion, i.e. an additional text is displayed +// beside the main text, e.g. phonetic characters. +SwRubyPortion::SwRubyPortion( const SwMultiCreator& rCreate, const SwFont& rFnt, + const IDocumentSettingAccess& rIDocumentSettingAccess, + TextFrameIndex const nEnd, TextFrameIndex const nOffs, + const SwTextSizeInfo &rInf ) + : SwMultiPortion( nEnd ) +{ + SetRuby(); + OSL_ENSURE( SwMultiCreatorId::Ruby == rCreate.nId, "Ruby expected" ); + OSL_ENSURE( RES_TXTATR_CJK_RUBY == rCreate.pAttr->Which(), "Wrong attribute" ); + const SwFormatRuby& rRuby = rCreate.pAttr->GetRuby(); + m_nAdjustment = rRuby.GetAdjustment(); + m_nRubyOffset = nOffs; + + const SwTextFrame *pFrame = rInf.GetTextFrame(); + RubyPosition ePos = static_cast( rRuby.GetPosition() ); + + // RIGHT is designed for horizontal writing mode only. + if ( ePos == RubyPosition::RIGHT && pFrame->IsVertical() ) + ePos = RubyPosition::ABOVE; + + // In grid mode we force the ruby text to the upper or lower line + if ( rInf.SnapToGrid() ) + { + SwTextGridItem const*const pGrid( GetGridItem(pFrame->FindPageFrame()) ); + if ( pGrid ) + ePos = pGrid->GetRubyTextBelow() ? RubyPosition::BELOW : RubyPosition::ABOVE; + } + + SetRubyPosition( ePos ); + + const SwCharFormat *const pFormat = + static_txtattr_cast(rCreate.pAttr)->GetCharFormat(); + std::unique_ptr pRubyFont; + if( pFormat ) + { + const SwAttrSet& rSet = pFormat->GetAttrSet(); + pRubyFont.reset(new SwFont( rFnt )); + pRubyFont->SetDiffFnt( &rSet, &rIDocumentSettingAccess ); + + // we do not allow a vertical font for the ruby text + pRubyFont->SetVertical( rFnt.GetOrientation() , OnRight() ); + } + + OUString aStr = rRuby.GetText().copy( sal_Int32(nOffs) ); + SwFieldPortion *pField = new SwFieldPortion( aStr, std::move(pRubyFont) ); + pField->SetNextOffset( nOffs ); + pField->SetFollow( true ); + + if( OnTop() ) + GetRoot().SetNextPortion( pField ); + else + { + GetRoot().SetNext( new SwLineLayout() ); + GetRoot().GetNext()->SetNextPortion( pField ); + } + + // ruby portions have the same direction as the frame directions + if ( rCreate.nLevel % 2 ) + { + // switch right and left ruby adjustment in rtl environment + if ( css::text::RubyAdjust_LEFT == m_nAdjustment ) + m_nAdjustment = css::text::RubyAdjust_RIGHT; + else if ( css::text::RubyAdjust_RIGHT == m_nAdjustment ) + m_nAdjustment = css::text::RubyAdjust_LEFT; + + SetDirection( DIR_RIGHT2LEFT ); + } + else + SetDirection( DIR_LEFT2RIGHT ); +} + +// In ruby portion there are different alignments for +// the ruby text and the main text. +// Left, right, centered and two possibilities of block adjustment +// The block adjustment is realized by spacing between the characters, +// either with a half space or no space in front of the first letter and +// a half space at the end of the last letter. +// Notice: the smaller line will be manipulated, normally it's the ruby line, +// but it could be the main text, too. +// If there is a tabulator in smaller line, no adjustment is possible. +void SwRubyPortion::Adjust_( SwTextFormatInfo &rInf ) +{ + SwTwips nLineDiff = GetRoot().Width() - GetRoot().GetNext()->Width(); + TextFrameIndex const nOldIdx = rInf.GetIdx(); + if( !nLineDiff ) + return; + SwLineLayout *pCurr; + if( nLineDiff < 0 ) + { // The first line has to be adjusted. + if( GetTab1() ) + return; + pCurr = &GetRoot(); + nLineDiff = -nLineDiff; + } + else + { // The second line has to be adjusted. + if( GetTab2() ) + return; + pCurr = GetRoot().GetNext(); + rInf.SetIdx( nOldIdx + GetRoot().GetLen() ); + } + sal_uInt16 nLeft = 0; // the space in front of the first letter + sal_uInt16 nRight = 0; // the space at the end of the last letter + TextFrameIndex nSub(0); + switch ( m_nAdjustment ) + { + case css::text::RubyAdjust_CENTER: nRight = o3tl::narrowing(nLineDiff / 2); + [[fallthrough]]; + case css::text::RubyAdjust_RIGHT: nLeft = o3tl::narrowing(nLineDiff - nRight); break; + case css::text::RubyAdjust_BLOCK: nSub = TextFrameIndex(1); + [[fallthrough]]; + case css::text::RubyAdjust_INDENT_BLOCK: + { + TextFrameIndex nCharCnt(0); + SwLinePortion *pPor; + for( pPor = pCurr->GetFirstPortion(); pPor; pPor = pPor->GetNextPortion() ) + { + if( pPor->InTextGrp() ) + static_cast(pPor)->GetSpaceCnt( rInf, nCharCnt ); + rInf.SetIdx( rInf.GetIdx() + pPor->GetLen() ); + } + if( nCharCnt > nSub ) + { + SwTwips nCalc = nLineDiff / sal_Int32(nCharCnt - nSub); + short nTmp; + if( nCalc < SHRT_MAX ) + nTmp = -short(nCalc); + else + nTmp = SHRT_MIN; + + pCurr->CreateSpaceAdd( SPACING_PRECISION_FACTOR * nTmp ); + nLineDiff -= nCalc * (sal_Int32(nCharCnt) - 1); + } + if( nLineDiff > 1 ) + { + nRight = o3tl::narrowing(nLineDiff / 2); + nLeft = o3tl::narrowing(nLineDiff - nRight); + } + break; + } + default: OSL_FAIL( "New ruby adjustment" ); + } + if( nLeft || nRight ) + { + if( !pCurr->GetNextPortion() ) + pCurr->SetNextPortion(SwTextPortion::CopyLinePortion(*pCurr)); + if( nLeft ) + { + SwMarginPortion *pMarg = new SwMarginPortion; + pMarg->AddPrtWidth( nLeft ); + pMarg->SetNextPortion( pCurr->GetNextPortion() ); + pCurr->SetNextPortion( pMarg ); + } + if( nRight ) + { + SwMarginPortion *pMarg = new SwMarginPortion; + pMarg->AddPrtWidth( nRight ); + pCurr->FindLastPortion()->Append( pMarg ); + } + } + + pCurr->Width( Width() ); + rInf.SetIdx( nOldIdx ); +} + +// has to change the nRubyOffset, if there's a fieldportion +// in the phonetic line. +// The nRubyOffset is the position in the rubystring, where the +// next SwRubyPortion has start the displaying of the phonetics. +void SwRubyPortion::CalcRubyOffset() +{ + const SwLineLayout *pCurr = &GetRoot(); + if( !OnTop() ) + { + pCurr = pCurr->GetNext(); + if( !pCurr ) + return; + } + const SwLinePortion *pPor = pCurr->GetFirstPortion(); + const SwFieldPortion *pField = nullptr; + while( pPor ) + { + if( pPor->InFieldGrp() ) + pField = static_cast(pPor); + pPor = pPor->GetNextPortion(); + } + if( pField ) + { + if( pField->HasFollow() ) + m_nRubyOffset = pField->GetNextOffset(); + else + m_nRubyOffset = TextFrameIndex(COMPLETE_STRING); + } +} + +// A little helper function for GetMultiCreator(..) +// It extracts the 2-line-format from a 2-line-attribute or a character style. +// The rValue is set to true, if the 2-line-attribute's value is set and +// no 2-line-format reference is passed. If there is a 2-line-format reference, +// then the rValue is set only, if the 2-line-attribute's value is set _and_ +// the 2-line-formats has the same brackets. +static bool lcl_Check2Lines(const SfxPoolItem *const pItem, + const SvxTwoLinesItem* &rpRef, bool &rValue) +{ + if( pItem ) + { + rValue = static_cast(pItem)->GetValue(); + if( !rpRef ) + rpRef = static_cast(pItem); + else if( static_cast(pItem)->GetEndBracket() != + rpRef->GetEndBracket() || + static_cast(pItem)->GetStartBracket() != + rpRef->GetStartBracket() ) + rValue = false; + return true; + } + return false; +} + +static bool lcl_Has2Lines(const SwTextAttr& rAttr, + const SvxTwoLinesItem* &rpRef, bool &rValue) +{ + const SfxPoolItem* pItem = CharFormat::GetItem(rAttr, RES_CHRATR_TWO_LINES); + return lcl_Check2Lines(pItem, rpRef, rValue); +} + +// is a little help function for GetMultiCreator(..) +// It extracts the charrotation from a charrotate-attribute or a character style. +// The rValue is set to true, if the charrotate-attribute's value is set and +// no charrotate-format reference is passed. +// If there is a charrotate-format reference, then the rValue is set only, +// if the charrotate-attribute's value is set _and_ identical +// to the charrotate-format's value. +static bool lcl_CheckRotation(const SfxPoolItem *const pItem, + const SvxCharRotateItem* &rpRef, bool &rValue) +{ + if ( pItem ) + { + rValue = static_cast(pItem)->GetValue() != 0_deg10; + if( !rpRef ) + rpRef = static_cast(pItem); + else if( static_cast(pItem)->GetValue() != + rpRef->GetValue() ) + rValue = false; + return true; + } + + return false; +} + +static bool lcl_HasRotation(const SwTextAttr& rAttr, + const SvxCharRotateItem* &rpRef, bool &rValue) +{ + const SfxPoolItem* pItem = CharFormat::GetItem( rAttr, RES_CHRATR_ROTATE ); + return lcl_CheckRotation(pItem, rpRef, rValue); +} + +namespace sw { + namespace { + + // need to use a very special attribute iterator here that returns + // both the hints and the nodes, so that GetMultiCreator() can handle + // items in the nodes' set properly + class MergedAttrIterMulti + : public MergedAttrIterBase + { + private: + bool m_First = true; + public: + MergedAttrIterMulti(SwTextFrame const& rFrame) : MergedAttrIterBase(rFrame) {} + SwTextAttr const* NextAttr(SwTextNode const*& rpNode); + // can't have operator= because m_pMerged/m_pNode const + void Assign(MergedAttrIterMulti const& rOther) + { + assert(m_pMerged == rOther.m_pMerged); + assert(m_pNode == rOther.m_pNode); + m_CurrentExtent = rOther.m_CurrentExtent; + m_CurrentHint = rOther.m_CurrentHint; + m_First = rOther.m_First; + } + }; + + } + + SwTextAttr const* MergedAttrIterMulti::NextAttr(SwTextNode const*& rpNode) + { + if (m_First) + { + m_First = false; + rpNode = m_pMerged + ? !m_pMerged->extents.empty() + ? m_pMerged->extents[0].pNode + : m_pMerged->pFirstNode + : m_pNode; + return nullptr; + } + if (m_pMerged) + { + const auto nExtentsSize = m_pMerged->extents.size(); + while (m_CurrentExtent < nExtentsSize) + { + sw::Extent const& rExtent(m_pMerged->extents[m_CurrentExtent]); + if (SwpHints const*const pHints = rExtent.pNode->GetpSwpHints()) + { + auto nHintsCount = pHints->Count(); + while (m_CurrentHint < nHintsCount) + { + SwTextAttr const*const pHint(pHints->Get(m_CurrentHint)); + if (rExtent.nEnd < pHint->GetStart()) + { + break; + } + ++m_CurrentHint; + if (rExtent.nStart <= pHint->GetStart()) + { + rpNode = rExtent.pNode; + return pHint; + } + } + } + ++m_CurrentExtent; + if (m_CurrentExtent < nExtentsSize && + rExtent.pNode != m_pMerged->extents[m_CurrentExtent].pNode) + { + m_CurrentHint = 0; // reset + rpNode = m_pMerged->extents[m_CurrentExtent].pNode; + return nullptr; + } + } + return nullptr; + } + else + { + SwpHints const*const pHints(m_pNode->GetpSwpHints()); + if (pHints) + { + if (m_CurrentHint < pHints->Count()) + { + SwTextAttr const*const pHint(pHints->Get(m_CurrentHint)); + ++m_CurrentHint; + rpNode = m_pNode; + return pHint; + } + } + return nullptr; + } + } +} + +// If we (e.g. the position rPos) are inside a two-line-attribute or +// a ruby-attribute, the attribute will be returned in a SwMultiCreator-struct, +// otherwise the function returns zero. +// The rPos parameter is set to the end of the multiportion, +// normally this is the end of the attribute, +// but sometimes it is the start of another attribute, which finished or +// interrupts the first attribute. +// E.g. a ruby portion interrupts a 2-line-attribute, a 2-line-attribute +// with different brackets interrupts another 2-line-attribute. +std::optional SwTextSizeInfo::GetMultiCreator(TextFrameIndex &rPos, + SwMultiPortion const * pMulti ) const +{ + SwScriptInfo& rSI = const_cast(GetParaPortion())->GetScriptInfo(); + + // get the last embedding level + sal_uInt8 nCurrLevel; + if ( pMulti ) + { + OSL_ENSURE( pMulti->IsBidi(), "Nested MultiPortion is not BidiPortion" ); + // level associated with bidi-portion; + nCurrLevel = static_cast(pMulti)->GetLevel(); + } + else + // no nested bidi portion required + nCurrLevel = GetTextFrame()->IsRightToLeft() ? 1 : 0; + + // check if there is a field at rPos: + sal_uInt8 nNextLevel = nCurrLevel; + bool bFieldBidi = false; + + if (rPos < TextFrameIndex(GetText().getLength()) && CH_TXTATR_BREAKWORD == GetChar(rPos)) + { + bFieldBidi = true; + } + else + nNextLevel = rSI.DirType( rPos ); + + if (TextFrameIndex(GetText().getLength()) != rPos && nNextLevel > nCurrLevel) + { + rPos = bFieldBidi ? rPos + TextFrameIndex(1) : rSI.NextDirChg(rPos, &nCurrLevel); + if (TextFrameIndex(COMPLETE_STRING) == rPos) + return {}; + SwMultiCreator aRet; + aRet.pItem = nullptr; + aRet.pAttr = nullptr; + aRet.nStartOfAttr = TextFrameIndex(-1); + aRet.nId = SwMultiCreatorId::Bidi; + aRet.nLevel = nCurrLevel + 1; + return aRet; + } + + // a bidi portion can only contain other bidi portions + if ( pMulti ) + return {}; + + // need the node that contains input rPos + std::pair startPos(m_pFrame->MapViewToModel(rPos)); + const SvxCharRotateItem* pActiveRotateItem(nullptr); + const SvxCharRotateItem* pNodeRotateItem(nullptr); + const SvxTwoLinesItem* pActiveTwoLinesItem(nullptr); + const SvxTwoLinesItem* pNodeTwoLinesItem(nullptr); + SwTextAttr const* pActiveTwoLinesHint(nullptr); + SwTextAttr const* pActiveRotateHint(nullptr); + const SwTextAttr *pRuby = nullptr; + sw::MergedAttrIterMulti iterAtStartOfNode(*m_pFrame); + bool bTwo = false; + bool bRot = false; + + for (sw::MergedAttrIterMulti iter = *m_pFrame; ; ) + { + SwTextNode const* pNode(nullptr); + SwTextAttr const*const pAttr = iter.NextAttr(pNode); + if (!pNode) + { + break; + } + if (pAttr) + { + assert(pNode->GetIndex() <= startPos.first->GetIndex()); // should break earlier + if (startPos.first->GetIndex() <= pNode->GetIndex()) + { + if (startPos.first->GetIndex() != pNode->GetIndex() + || startPos.second < pAttr->GetStart()) + { + break; + } + if (startPos.second < pAttr->GetAnyEnd()) + { + // sw_redlinehide: ruby *always* splits + if (RES_TXTATR_CJK_RUBY == pAttr->Which()) + pRuby = pAttr; + else + { + const SvxCharRotateItem* pRoTmp = nullptr; + if (lcl_HasRotation( *pAttr, pRoTmp, bRot )) + { + pActiveRotateHint = bRot ? pAttr : nullptr; + pActiveRotateItem = pRoTmp; + } + const SvxTwoLinesItem* p2Tmp = nullptr; + if (lcl_Has2Lines( *pAttr, p2Tmp, bTwo )) + { + pActiveTwoLinesHint = bTwo ? pAttr : nullptr; + pActiveTwoLinesItem = p2Tmp; + } + } + } + } + } + else if (pNode) // !pAttr && pNode means the node changed + { + if (startPos.first->GetIndex() < pNode->GetIndex()) + { + break; // only one node initially + } + if (startPos.first->GetIndex() == pNode->GetIndex()) + { + iterAtStartOfNode.Assign(iter); + if (SfxItemState::SET == pNode->GetSwAttrSet().GetItemState( + RES_CHRATR_ROTATE, true, &pNodeRotateItem) && + pNodeRotateItem->GetValue()) + { + pActiveRotateItem = pNodeRotateItem; + } + else + { + pNodeRotateItem = nullptr; + } + if (SfxItemState::SET == startPos.first->GetSwAttrSet().GetItemState( + RES_CHRATR_TWO_LINES, true, &pNodeTwoLinesItem) && + pNodeTwoLinesItem->GetValue()) + { + pActiveTwoLinesItem = pNodeTwoLinesItem; + } + else + { + pNodeTwoLinesItem = nullptr; + } + } + } + } + if (!pRuby && !pActiveTwoLinesItem && !pActiveRotateItem) + return {}; + + if( pRuby ) + { // The winner is ... a ruby attribute and so + // the end of the multiportion is the end of the ruby attribute. + rPos = m_pFrame->MapModelToView(startPos.first, *pRuby->End()); + SwMultiCreator aRet; + aRet.pItem = nullptr; + aRet.pAttr = pRuby; + aRet.nStartOfAttr = m_pFrame->MapModelToView(startPos.first, aRet.pAttr->GetStart()); + aRet.nId = SwMultiCreatorId::Ruby; + aRet.nLevel = GetTextFrame()->IsRightToLeft() ? 1 : 0; + return aRet; + } + if (pActiveTwoLinesHint || + (pNodeTwoLinesItem && SfxPoolItem::areSame(pNodeTwoLinesItem, pActiveTwoLinesItem) && + rPos < TextFrameIndex(GetText().getLength()))) + { // The winner is a 2-line-attribute, + // the end of the multiportion depends on the following attributes... + SwMultiCreator aRet; + + // We note the endpositions of the 2-line attributes in aEnd as stack + std::deque aEnd; + + // The bOn flag signs the state of the last 2-line attribute in the + // aEnd-stack, it is compatible with the winner-attribute or + // it interrupts the other attribute. + bool bOn = true; + + if (pActiveTwoLinesHint) + { + aRet.pItem = nullptr; + aRet.pAttr = pActiveTwoLinesHint; + aRet.nStartOfAttr = m_pFrame->MapModelToView(startPos.first, aRet.pAttr->GetStart()); + if (pNodeTwoLinesItem) + { + aEnd.push_front(m_pFrame->MapModelToView(startPos.first, startPos.first->Len())); + bOn = pNodeTwoLinesItem->GetEndBracket() == + pActiveTwoLinesItem->GetEndBracket() && + pNodeTwoLinesItem->GetStartBracket() == + pActiveTwoLinesItem->GetStartBracket(); + } + else + { + aEnd.push_front(m_pFrame->MapModelToView(startPos.first, *aRet.pAttr->End())); + } + } + else + { + aRet.pItem = pNodeTwoLinesItem; + aRet.pAttr = nullptr; + aRet.nStartOfAttr = TextFrameIndex(-1); + aEnd.push_front(m_pFrame->MapModelToView(startPos.first, startPos.first->Len())); + } + aRet.nId = SwMultiCreatorId::Double; + aRet.nLevel = GetTextFrame()->IsRightToLeft() ? 1 : 0; + + // pActiveTwoLinesHint is the last 2-line-attribute, which contains + // the actual position. + + // At this moment we know that at position rPos the "winner"-attribute + // causes a 2-line-portion. The end of the attribute is the end of the + // portion, if there's no interrupting attribute. + // There are two kinds of interrupters: + // - ruby attributes stops the 2-line-attribute, the end of the + // multiline is the start of the ruby attribute + // - 2-line-attributes with value "Off" or with different brackets, + // these attributes may interrupt the winner, but they could be + // neutralized by another 2-line-attribute starting at the same + // position with the same brackets as the winner-attribute. + + // In the following loop rPos is the critical position and it will be + // evaluated, if at rPos starts an interrupting or a maintaining + // continuity attribute. + + // iterAtStartOfNode is positioned to the first hint of the node + // (if any); the node item itself has already been handled above + for (sw::MergedAttrIterMulti iter = iterAtStartOfNode; ; ) + { + SwTextNode const* pNode(nullptr); + SwTextAttr const*const pTmp = iter.NextAttr(pNode); + if (!pNode) + { + break; + } + assert(startPos.first->GetIndex() <= pNode->GetIndex()); + TextFrameIndex nTmpStart; + TextFrameIndex nTmpEnd; + if (pTmp) + { + nTmpEnd = m_pFrame->MapModelToView(pNode, pTmp->GetAnyEnd()); + if (nTmpEnd <= rPos) + continue; + nTmpStart = m_pFrame->MapModelToView(pNode, pTmp->GetStart()); + } + else + { + pNodeTwoLinesItem = pNode->GetSwAttrSet().GetItemIfSet( + RES_CHRATR_TWO_LINES); + nTmpStart = m_pFrame->MapModelToView(pNode, 0); + nTmpEnd = m_pFrame->MapModelToView(pNode, pNode->Len()); + assert(rPos <= nTmpEnd); // next node must not have smaller index + } + + if (rPos < nTmpStart) + { + // If bOn is false and the next attribute starts later than rPos + // the winner attribute is interrupted at rPos. + // If the start of the next attribute is behind the end of + // the last attribute on the aEnd-stack, this is the endposition + // on the stack is the end of the 2-line portion. + if (!bOn || aEnd.back() < nTmpStart) + break; + // At this moment, bOn is true and the next attribute starts + // behind rPos, so we could move rPos to the next startpoint + rPos = nTmpStart; + // We clean up the aEnd-stack, endpositions equal to rPos are + // superfluous. + while( !aEnd.empty() && aEnd.back() <= rPos ) + { + bOn = !bOn; + aEnd.pop_back(); + } + // If the endstack is empty, we simulate an attribute with + // state true and endposition rPos + if( aEnd.empty() ) + { + aEnd.push_front( rPos ); + bOn = true; + } + } + // A ruby attribute stops the 2-line immediately + if (pTmp && RES_TXTATR_CJK_RUBY == pTmp->Which()) + return aRet; + if (pTmp ? lcl_Has2Lines(*pTmp, pActiveTwoLinesItem, bTwo) + : lcl_Check2Lines(pNodeTwoLinesItem, pActiveTwoLinesItem, bTwo)) + { // We have an interesting attribute... + if( bTwo == bOn ) + { // .. with the same state, so the last attribute could + // be continued. + if (aEnd.back() < nTmpEnd) + aEnd.back() = nTmpEnd; + } + else + { // .. with a different state. + bOn = bTwo; + // If this is smaller than the last on the stack, we put + // it on the stack. If it has the same endposition, the last + // could be removed. + if (nTmpEnd < aEnd.back()) + aEnd.push_back( nTmpEnd ); + else if( aEnd.size() > 1 ) + aEnd.pop_back(); + else + aEnd.back() = nTmpEnd; + } + } + } + if( bOn && !aEnd.empty() ) + rPos = aEnd.back(); + return aRet; + } + if (pActiveRotateHint || + (pNodeRotateItem && SfxPoolItem::areSame(pNodeRotateItem, pActiveRotateItem) && + rPos < TextFrameIndex(GetText().getLength()))) + { // The winner is a rotate-attribute, + // the end of the multiportion depends on the following attributes... + SwMultiCreator aRet; + aRet.nId = SwMultiCreatorId::Rotate; + + // We note the endpositions of the 2-line attributes in aEnd as stack + std::deque aEnd; + + // The bOn flag signs the state of the last 2-line attribute in the + // aEnd-stack, which could interrupts the winning rotation attribute. + bool bOn = pNodeTwoLinesItem != nullptr; + aEnd.push_front(TextFrameIndex(GetText().getLength())); + + // first, search for the start position of the next TWOLINE portion + // because the ROTATE portion must end there at the latest + TextFrameIndex n2Start = rPos; + for (sw::MergedAttrIterMulti iter = iterAtStartOfNode; ; ) + { + SwTextNode const* pNode(nullptr); + SwTextAttr const*const pTmp = iter.NextAttr(pNode); + if (!pNode) + { + break; + } + assert(startPos.first->GetIndex() <= pNode->GetIndex()); + TextFrameIndex nTmpStart; + TextFrameIndex nTmpEnd; + if (pTmp) + { + nTmpEnd = m_pFrame->MapModelToView(pNode, pTmp->GetAnyEnd()); + if (nTmpEnd <= n2Start) + continue; + nTmpStart = m_pFrame->MapModelToView(pNode, pTmp->GetStart()); + } + else + { + pNodeTwoLinesItem = pNode->GetSwAttrSet().GetItemIfSet( + RES_CHRATR_TWO_LINES); + nTmpStart = m_pFrame->MapModelToView(pNode, 0); + nTmpEnd = m_pFrame->MapModelToView(pNode, pNode->Len()); + assert(n2Start <= nTmpEnd); // next node must not have smaller index + } + + if (n2Start < nTmpStart) + { + if (bOn || aEnd.back() < nTmpStart) + break; + n2Start = nTmpStart; + while( !aEnd.empty() && aEnd.back() <= n2Start ) + { + bOn = !bOn; + aEnd.pop_back(); + } + if( aEnd.empty() ) + { + aEnd.push_front( n2Start ); + bOn = false; + } + } + // A ruby attribute stops immediately + if (pTmp && RES_TXTATR_CJK_RUBY == pTmp->Which()) + { + bOn = true; + break; + } + const SvxTwoLinesItem* p2Lines = nullptr; + if (pTmp ? lcl_Has2Lines(*pTmp, p2Lines, bTwo) + : lcl_Check2Lines(pNodeTwoLinesItem, p2Lines, bTwo)) + { + if( bTwo == bOn ) + { + if (aEnd.back() < nTmpEnd) + aEnd.back() = nTmpEnd; + } + else + { + bOn = bTwo; + if (nTmpEnd < aEnd.back()) + aEnd.push_back( nTmpEnd ); + else if( aEnd.size() > 1 ) + aEnd.pop_back(); + else + aEnd.back() = nTmpEnd; + } + } + } + if( !bOn && !aEnd.empty() ) + n2Start = aEnd.back(); + + aEnd.clear(); + + // now, search for the end of the ROTATE portion, similar to above + bOn = true; + if (pActiveRotateHint) + { + aRet.pItem = nullptr; + aRet.pAttr = pActiveRotateHint; + aRet.nStartOfAttr = m_pFrame->MapModelToView(startPos.first, aRet.pAttr->GetStart()); + if (pNodeRotateItem) + { + aEnd.push_front(m_pFrame->MapModelToView(startPos.first, startPos.first->Len())); + bOn = pNodeRotateItem->GetValue() == + pActiveRotateItem->GetValue(); + } + else + { + aEnd.push_front(m_pFrame->MapModelToView(startPos.first, *aRet.pAttr->End())); + } + } + else + { + aRet.pItem = pNodeRotateItem; + aRet.pAttr = nullptr; + aRet.nStartOfAttr = TextFrameIndex(-1); + aEnd.push_front(m_pFrame->MapModelToView(startPos.first, startPos.first->Len())); + } + for (sw::MergedAttrIterMulti iter = iterAtStartOfNode; ; ) + { + SwTextNode const* pNode(nullptr); + SwTextAttr const*const pTmp = iter.NextAttr(pNode); + if (!pNode) + { + break; + } + assert(startPos.first->GetIndex() <= pNode->GetIndex()); + TextFrameIndex nTmpStart; + TextFrameIndex nTmpEnd; + if (pTmp) + { + nTmpEnd = m_pFrame->MapModelToView(pNode, pTmp->GetAnyEnd()); + if (nTmpEnd <= rPos) + continue; + nTmpStart = m_pFrame->MapModelToView(pNode, pTmp->GetStart()); + } + else + { + pNodeRotateItem = pNode->GetSwAttrSet().GetItemIfSet( + RES_CHRATR_ROTATE); + nTmpStart = m_pFrame->MapModelToView(pNode, 0); + nTmpEnd = m_pFrame->MapModelToView(pNode, pNode->Len()); + assert(rPos <= nTmpEnd); // next node must not have smaller index + } + + if (rPos < nTmpStart) + { + if (!bOn || aEnd.back() < nTmpStart) + break; + rPos = nTmpStart; + while( !aEnd.empty() && aEnd.back() <= rPos ) + { + bOn = !bOn; + aEnd.pop_back(); + } + if( aEnd.empty() ) + { + aEnd.push_front( rPos ); + bOn = true; + } + } + if (pTmp && RES_TXTATR_CJK_RUBY == pTmp->Which()) + { + bOn = false; + break; + } + // TODO why does this use bTwo, not bRot ??? + if (pTmp ? lcl_HasRotation(*pTmp, pActiveRotateItem, bTwo) + : lcl_CheckRotation(pNodeRotateItem, pActiveRotateItem, bTwo)) + { + if( bTwo == bOn ) + { + if (aEnd.back() < nTmpEnd) + aEnd.back() = nTmpEnd; + } + else + { + bOn = bTwo; + if (nTmpEnd < aEnd.back()) + aEnd.push_back( nTmpEnd ); + else if( aEnd.size() > 1 ) + aEnd.pop_back(); + else + aEnd.back() = nTmpEnd; + } + } + } + if( bOn && !aEnd.empty() ) + rPos = aEnd.back(); + if( rPos > n2Start ) + rPos = n2Start; + return aRet; + } + return {}; +} + +namespace { + +// A little helper class to manage the spaceadd-arrays of the text adjustment +// during a PaintMultiPortion. +// The constructor prepares the array for the first line of multiportion, +// the SecondLine-function restores the values for the first line and prepares +// the second line. +// The destructor restores the values of the last manipulation. +class SwSpaceManipulator +{ + SwTextPaintInfo& m_rInfo; + SwMultiPortion& m_rMulti; + std::vector* m_pOldSpaceAdd; + sal_uInt16 m_nOldSpaceIndex; + tools::Long m_nSpaceAdd; + bool m_bSpaceChg; + sal_uInt8 m_nOldDir; + +public: + SwSpaceManipulator( SwTextPaintInfo& rInf, SwMultiPortion& rMult ); + ~SwSpaceManipulator(); + void SecondLine(); + tools::Long GetSpaceAdd() const { return m_nSpaceAdd; } +}; + +} + +SwSpaceManipulator::SwSpaceManipulator(SwTextPaintInfo& rInf, SwMultiPortion& rMult) + : m_rInfo(rInf) + , m_rMulti(rMult) + , m_nSpaceAdd(0) +{ + m_pOldSpaceAdd = m_rInfo.GetpSpaceAdd(); + m_nOldSpaceIndex = m_rInfo.GetSpaceIdx(); + m_nOldDir = m_rInfo.GetDirection(); + m_rInfo.SetDirection(m_rMulti.GetDirection()); + m_bSpaceChg = false; + + if (m_rMulti.IsDouble()) + { + m_nSpaceAdd = (m_pOldSpaceAdd && !m_rMulti.HasTabulator()) ? m_rInfo.GetSpaceAdd() : 0; + if (m_rMulti.GetRoot().IsSpaceAdd()) + { + m_rInfo.SetpSpaceAdd(m_rMulti.GetRoot().GetpLLSpaceAdd()); + m_rInfo.ResetSpaceIdx(); + m_bSpaceChg = m_rMulti.ChgSpaceAdd(&m_rMulti.GetRoot(), m_nSpaceAdd); + } + else if (m_rMulti.HasTabulator()) + m_rInfo.SetpSpaceAdd(nullptr); + } + else if (!m_rMulti.IsBidi()) + { + m_rInfo.SetpSpaceAdd(m_rMulti.GetRoot().GetpLLSpaceAdd()); + m_rInfo.ResetSpaceIdx(); + } +} + +void SwSpaceManipulator::SecondLine() +{ + if (m_bSpaceChg) + { + m_rInfo.RemoveFirstSpaceAdd(); + m_bSpaceChg = false; + } + SwLineLayout* pLay = m_rMulti.GetRoot().GetNext(); + if( pLay->IsSpaceAdd() ) + { + m_rInfo.SetpSpaceAdd(pLay->GetpLLSpaceAdd()); + m_rInfo.ResetSpaceIdx(); + m_bSpaceChg = m_rMulti.ChgSpaceAdd(pLay, m_nSpaceAdd); + } + else + { + m_rInfo.SetpSpaceAdd((!m_rMulti.IsDouble() || m_rMulti.HasTabulator()) ? nullptr + : m_pOldSpaceAdd); + m_rInfo.SetSpaceIdx(m_nOldSpaceIndex); + } +} + +SwSpaceManipulator::~SwSpaceManipulator() +{ + if (m_bSpaceChg) + { + m_rInfo.RemoveFirstSpaceAdd(); + m_bSpaceChg = false; + } + m_rInfo.SetpSpaceAdd(m_pOldSpaceAdd); + m_rInfo.SetSpaceIdx(m_nOldSpaceIndex); + m_rInfo.SetDirection(m_nOldDir); +} + +// Manages the paint for a SwMultiPortion. +// External, for the calling function, it seems to be a normal Paint-function, +// internal it is like a SwTextFrame::PaintSwFrame with multiple DrawTextLines +void SwTextPainter::PaintMultiPortion( const SwRect &rPaint, + SwMultiPortion& rMulti, const SwMultiPortion* pEnvPor ) +{ + SwTextGridItem const*const pGrid(GetGridItem(m_pFrame->FindPageFrame())); + const bool bHasGrid = pGrid && GetInfo().SnapToGrid(); + sal_uInt16 nRubyHeight = 0; + bool bRubyTop = true; + + if ( bHasGrid && pGrid->IsSquaredMode() ) + { + nRubyHeight = pGrid->GetRubyHeight(); + bRubyTop = ! pGrid->GetRubyTextBelow(); + } + + // do not allow grid mode for first line in ruby portion + const bool bRubyInGrid = bHasGrid && rMulti.IsRuby(); + + const sal_uInt16 nOldHeight = rMulti.Height(); + const bool bOldGridModeAllowed = GetInfo().SnapToGrid(); + + if ( bRubyInGrid ) + { + GetInfo().SetSnapToGrid( ! bRubyTop ); + if (pGrid->IsSquaredMode()) + rMulti.Height( m_pCurr->Height() ); + } + + SwLayoutModeModifier aLayoutModeModifier( *GetInfo().GetOut() ); + bool bEnvDir = false; + bool bThisDir = false; + bool bFrameDir = false; + if ( rMulti.IsBidi() ) + { + // these values are needed for the calculation of the x coordinate + // and the layout mode + OSL_ENSURE( ! pEnvPor || pEnvPor->IsBidi(), + "Oh no, I expected a BidiPortion" ); + bFrameDir = GetInfo().GetTextFrame()->IsRightToLeft(); + bEnvDir = pEnvPor ? ((static_cast(pEnvPor)->GetLevel() % 2) != 0) : bFrameDir; + bThisDir = (static_cast(rMulti).GetLevel() % 2) != 0; + } + +#if OSL_DEBUG_LEVEL > 1 + // only paint first level bidi portions + if( rMulti.Width() > 1 && ! pEnvPor ) + GetInfo().DrawViewOpt( rMulti, PortionType::Field ); +#endif + + if ( bRubyInGrid && pGrid->IsSquaredMode() ) + rMulti.Height( nOldHeight ); + + // do we have to repaint a post it portion? + if( GetInfo().OnWin() && rMulti.GetNextPortion() && + ! rMulti.GetNextPortion()->Width() ) + rMulti.GetNextPortion()->PrePaint( GetInfo(), &rMulti ); + + // old values must be saved and restored at the end + TextFrameIndex const nOldLen = GetInfo().GetLen(); + const SwTwips nOldX = GetInfo().X(); + const SwTwips nOldY = GetInfo().Y(); + TextFrameIndex const nOldIdx = GetInfo().GetIdx(); + + SwSpaceManipulator aManip( GetInfo(), rMulti ); + + std::optional oFontSave; + std::unique_ptr pTmpFnt; + + if( rMulti.IsDouble() ) + { + pTmpFnt.reset(new SwFont( *GetInfo().GetFont() )); + if( rMulti.IsDouble() ) + { + SetPropFont( 50 ); + pTmpFnt->SetProportion( GetPropFont() ); + } + oFontSave.emplace( GetInfo(), pTmpFnt.get(), this ); + } + else + { + pTmpFnt = nullptr; + } + + if( rMulti.HasBrackets() ) + { + // WP is mandatory + Por_Info const por(rMulti, *this, 1); + SwTaggedPDFHelper const tag(nullptr, nullptr, &por, *GetInfo().GetOut()); + + TextFrameIndex const nTmpOldIdx = GetInfo().GetIdx(); + GetInfo().SetIdx(static_cast(rMulti).GetBrackets()->nStart); + SeekAndChg( GetInfo() ); + static_cast(rMulti).PaintBracket( GetInfo(), 0, true ); + GetInfo().SetIdx( nTmpOldIdx ); + } + + const SwTwips nTmpX = GetInfo().X(); + + SwLineLayout* pLay = &rMulti.GetRoot();// the first line of the multiportion + SwLinePortion* pPor = pLay->GetFirstPortion();//first portion of these line + SwTwips nOfst = 0; + + // GetInfo().Y() is the baseline from the surrounding line. We must switch + // this temporary to the baseline of the inner lines of the multiportion. + if( rMulti.HasRotation() ) + { + if( rMulti.IsRevers() ) + { + GetInfo().Y( nOldY - rMulti.GetAscent() ); + nOfst = nTmpX + rMulti.Width(); + } + else + { + GetInfo().Y( nOldY - rMulti.GetAscent() + rMulti.Height() ); + nOfst = nTmpX; + } + } + else if ( rMulti.IsBidi() ) + { + // does the current bidi portion has the same direction + // as its environment? + if ( bEnvDir != bThisDir ) + { + // different directions, we have to adjust the x coordinate + SwTwips nMultiWidth = rMulti.Width() + + rMulti.CalcSpacing( GetInfo().GetSpaceAdd(), GetInfo() ); + + if ( bFrameDir == bThisDir ) + GetInfo().X( GetInfo().X() - nMultiWidth ); + else + GetInfo().X( GetInfo().X() + nMultiWidth ); + } + + nOfst = nOldY - rMulti.GetAscent(); + + // set layout mode + aLayoutModeModifier.Modify( bThisDir ); + } + else + nOfst = nOldY - rMulti.GetAscent(); + + bool bRest = pLay->IsRest(); + bool bFirst = true; + + OSL_ENSURE( nullptr == GetInfo().GetUnderFnt() || rMulti.IsBidi(), + " Only BiDi portions are allowed to use the common underlining font" ); + + ::std::optional oTag; + if (rMulti.IsDouble()) + { + Por_Info const por(rMulti, *this, 2); + oTag.emplace(nullptr, nullptr, &por, *GetInfo().GetOut()); + } + else if (rMulti.IsRuby()) + { + Por_Info const por(rMulti, *this, bRubyTop ? 1 : 2); + oTag.emplace(nullptr, nullptr, &por, *GetInfo().GetOut()); + GetInfo().SetRuby( rMulti.OnTop() ); + } + + do + { + if ( bHasGrid && pGrid->IsSquaredMode() ) + { + if( rMulti.HasRotation() ) + { + const sal_uInt16 nAdjustment = ( pLay->Height() - pPor->Height() ) / 2 + + pPor->GetAscent(); + if( rMulti.IsRevers() ) + GetInfo().X( nOfst - nAdjustment ); + else + GetInfo().X( nOfst + nAdjustment ); + } + else + { + // special treatment for ruby portions in grid mode + SwTwips nAdjustment = 0; + if ( rMulti.IsRuby() ) + { + if ( bRubyTop != ( pLay == &rMulti.GetRoot() ) ) + // adjust base text + nAdjustment = ( m_pCurr->Height() - nRubyHeight - pPor->Height() ) / 2; + else if ( bRubyTop ) + // adjust upper ruby text + nAdjustment = nRubyHeight - pPor->Height(); + // else adjust lower ruby text + } + + GetInfo().Y( nOfst + nAdjustment + pPor->GetAscent() ); + } + } + else if( rMulti.HasRotation() ) + { + if( rMulti.IsRevers() ) + GetInfo().X( nOfst - AdjustBaseLine( *pLay, pPor, 0, 0, true ) ); + else + GetInfo().X( nOfst + AdjustBaseLine( *pLay, pPor ) ); + } + else if ( rMulti.IsRuby() && rMulti.OnRight() && GetInfo().IsRuby() ) + { + SwTwips nLineDiff = std::max(( rMulti.GetRoot().Height() - pPor->Width() ) / 2, static_cast(0) ); + GetInfo().Y( nOfst + nLineDiff ); + // Draw the ruby text on top of the preserved space. + GetInfo().X( GetInfo().X() - pPor->Height() ); + } + else + GetInfo().Y( nOfst + AdjustBaseLine( *pLay, pPor ) ); + + bool bSeeked = true; + GetInfo().SetLen( pPor->GetLen() ); + + if( bRest && pPor->InFieldGrp() && !pPor->GetLen() ) + { + if( static_cast(pPor)->HasFont() ) + bSeeked = false; + else + SeekAndChgBefore( GetInfo() ); + } + else if( pPor->InTextGrp() || pPor->InFieldGrp() || pPor->InTabGrp() ) + SeekAndChg( GetInfo() ); + else if ( !bFirst && pPor->IsBreakPortion() && GetInfo().GetOpt().IsParagraph() ) + { + if( GetRedln() ) + SeekAndChg( GetInfo() ); + else + SeekAndChgBefore( GetInfo() ); + } + else + bSeeked = false; + + SwLinePortion *pNext = pPor->GetNextPortion(); + if(GetInfo().OnWin() && pNext && !pNext->Width() ) + { + if ( !bSeeked ) + SeekAndChg( GetInfo() ); + pNext->PrePaint( GetInfo(), pPor ); + } + + CheckSpecialUnderline( pPor ); + SwUnderlineFont* pUnderLineFnt = GetInfo().GetUnderFnt(); + if ( pUnderLineFnt ) + { + if ( rMulti.IsDouble() ) + pUnderLineFnt->GetFont().SetProportion( 50 ); + pUnderLineFnt->SetPos( GetInfo().GetPos() ); + } + + if ( rMulti.IsBidi() ) + { + // we do not allow any rotation inside a bidi portion + SwFont* pTmpFont = GetInfo().GetFont(); + pTmpFont->SetVertical( 0_deg10, GetInfo().GetTextFrame()->IsVertical() ); + } + + if( pPor->IsMultiPortion() && static_cast(pPor)->IsBidi() ) + { + // but we do allow nested bidi portions + OSL_ENSURE( rMulti.IsBidi(), "Only nesting of bidi portions is allowed" ); + PaintMultiPortion( rPaint, static_cast(*pPor), &rMulti ); + } + else + { + Por_Info const por(*pPor, *this, 0); + SwTaggedPDFHelper const tag(nullptr, nullptr, &por, *GetInfo().GetOut()); + + pPor->Paint( GetInfo() ); + } + + bFirst &= !pPor->GetLen(); + if( pNext || !pPor->IsMarginPortion() ) + pPor->Move( GetInfo() ); + + pPor = pNext; + + // If there's no portion left, we go to the next line + if( !pPor && pLay->GetNext() ) + { + pLay = pLay->GetNext(); + pPor = pLay->GetFirstPortion(); + bRest = pLay->IsRest(); + aManip.SecondLine(); + + // delete underline font + delete GetInfo().GetUnderFnt(); + GetInfo().SetUnderFnt( nullptr ); + + if( rMulti.HasRotation() ) + { + if( rMulti.IsRevers() ) + { + nOfst += pLay->Height(); + GetInfo().Y( nOldY - rMulti.GetAscent() ); + } + else + { + nOfst -= pLay->Height(); + GetInfo().Y( nOldY - rMulti.GetAscent() + rMulti.Height() ); + } + } + else if ( bHasGrid && rMulti.IsRuby() ) + { + GetInfo().SetSnapToGrid( bRubyTop ); + GetInfo().X( nTmpX ); + if (pGrid->IsSquaredMode() ) + { + if ( bRubyTop ) + nOfst += nRubyHeight; + else + nOfst += m_pCurr->Height() - nRubyHeight; + } + else + { + nOfst += rMulti.GetRoot().Height(); + } + } + else if ( rMulti.IsRuby() && rMulti.OnRight() ) + { + GetInfo().SetDirection( DIR_TOP2BOTTOM ); + GetInfo().SetRuby( true ); + } else + { + GetInfo().X( nTmpX ); + // We switch to the baseline of the next inner line + nOfst += rMulti.GetRoot().Height(); + } + if (rMulti.IsRuby()) + { + oTag.reset(); + Por_Info const por(rMulti, *this, bRubyTop ? 2 : 1); + oTag.emplace(nullptr, nullptr, &por, *GetInfo().GetOut()); + } + } + } while( pPor ); + + if (rMulti.IsDouble()) + { + oTag.reset(); + } + + if ( bRubyInGrid ) + GetInfo().SetSnapToGrid( bOldGridModeAllowed ); + + // delete underline font + if ( ! rMulti.IsBidi() ) + { + delete GetInfo().GetUnderFnt(); + GetInfo().SetUnderFnt( nullptr ); + } + + GetInfo().SetIdx( nOldIdx ); + GetInfo().Y( nOldY ); + + if( rMulti.HasBrackets() ) + { + // WP is mandatory + Por_Info const por(rMulti, *this, 1); + SwTaggedPDFHelper const tag(nullptr, nullptr, &por, *GetInfo().GetOut()); + + TextFrameIndex const nTmpOldIdx = GetInfo().GetIdx(); + GetInfo().SetIdx(static_cast(rMulti).GetBrackets()->nStart); + SeekAndChg( GetInfo() ); + GetInfo().X( nOldX ); + static_cast(rMulti).PaintBracket( GetInfo(), + aManip.GetSpaceAdd(), false ); + GetInfo().SetIdx( nTmpOldIdx ); + } + // Restore the saved values + GetInfo().X( nOldX ); + GetInfo().SetLen( nOldLen ); + oFontSave.reset(); + pTmpFnt.reset(); + SetPropFont( 0 ); +} + +static bool lcl_ExtractFieldFollow( SwLineLayout* pLine, SwLinePortion* &rpField ) +{ + SwLinePortion* pLast = pLine; + rpField = pLine->GetNextPortion(); + while( rpField && !rpField->InFieldGrp() ) + { + pLast = rpField; + rpField = rpField->GetNextPortion(); + } + bool bRet = rpField != nullptr; + if( bRet ) + { + if( static_cast(rpField)->IsFollow() ) + { + rpField->Truncate(); + pLast->SetNextPortion( nullptr ); + } + else + rpField = nullptr; + } + pLine->Truncate(); + return bRet; +} + +// If a multi portion completely has to go to the +// next line, this function is called to truncate +// the rest of the remaining multi portion +static void lcl_TruncateMultiPortion( SwMultiPortion& rMulti, SwTextFormatInfo& rInf, + TextFrameIndex const nStartIdx) +{ + rMulti.GetRoot().Truncate(); + rMulti.GetRoot().SetLen(TextFrameIndex(0)); + rMulti.GetRoot().Width(0); +// rMulti.CalcSize( *this, aInf ); + if ( rMulti.GetRoot().GetNext() ) + { + rMulti.GetRoot().GetNext()->Truncate(); + rMulti.GetRoot().GetNext()->SetLen(TextFrameIndex(0)); + rMulti.GetRoot().GetNext()->Width( 0 ); + } + rMulti.Width( 0 ); + rMulti.SetLen(TextFrameIndex(0)); + rInf.SetIdx( nStartIdx ); +} + +// Manages the formatting of a SwMultiPortion. External, for the calling +// function, it seems to be a normal Format-function, internal it is like a +// SwTextFrame::Format_ with multiple BuildPortions +bool SwTextFormatter::BuildMultiPortion( SwTextFormatInfo &rInf, + SwMultiPortion& rMulti ) +{ + SwTwips nMaxWidth = rInf.Width(); + SwTwips nOldX = 0; + + if( rMulti.HasBrackets() ) + { + TextFrameIndex const nOldIdx = rInf.GetIdx(); + rInf.SetIdx( static_cast(rMulti).GetBrackets()->nStart ); + SeekAndChg( rInf ); + nOldX = GetInfo().X(); + static_cast(rMulti).FormatBrackets( rInf, nMaxWidth ); + rInf.SetIdx( nOldIdx ); + } + + SeekAndChg( rInf ); + std::optional oFontSave; + std::unique_ptr xTmpFont; + if( rMulti.IsDouble() ) + { + xTmpFont.reset(new SwFont( *rInf.GetFont() )); + if( rMulti.IsDouble() ) + { + SetPropFont( 50 ); + xTmpFont->SetProportion( GetPropFont() ); + } + oFontSave.emplace(rInf, xTmpFont.get(), this); + } + + SwLayoutModeModifier aLayoutModeModifier( *GetInfo().GetOut() ); + if ( rMulti.IsBidi() ) + { + // set layout mode + aLayoutModeModifier.Modify( ! rInf.GetTextFrame()->IsRightToLeft() ); + } + + SwTwips nTmpX = 0; + + if( rMulti.HasRotation() ) + { + // For nMaxWidth we take the height of the body frame. + // #i25067#: If the current frame is inside a table, we restrict + // nMaxWidth to the current frame height, unless the frame size + // attribute is set to variable size: + + // We set nTmpX (which is used for portion calculating) to the + // current Y value + const SwPageFrame* pPage = m_pFrame->FindPageFrame(); + OSL_ENSURE( pPage, "No page in frame!"); + const SwLayoutFrame* pUpperFrame = pPage; + + if ( m_pFrame->IsInTab() ) + { + pUpperFrame = m_pFrame->GetUpper(); + while ( pUpperFrame && !pUpperFrame->IsCellFrame() ) + pUpperFrame = pUpperFrame->GetUpper(); + assert(pUpperFrame); //pFrame is in table but does not have an upper cell frame + if (!pUpperFrame) + return false; + const SwTableLine* pLine = static_cast(pUpperFrame->GetUpper())->GetTabLine(); + const SwFormatFrameSize& rFrameFormatSize = pLine->GetFrameFormat()->GetFrameSize(); + if ( SwFrameSize::Variable == rFrameFormatSize.GetHeightSizeType() ) + pUpperFrame = pPage; + } + if ( pUpperFrame == pPage && !m_pFrame->IsInFootnote() ) + pUpperFrame = pPage->FindBodyCont(); + + nMaxWidth = pUpperFrame ? + ( rInf.GetTextFrame()->IsVertical() ? + pUpperFrame->getFramePrintArea().Width() : + pUpperFrame->getFramePrintArea().Height() ) : + USHRT_MAX; + } + else + nTmpX = rInf.X(); + + SwMultiPortion* pOldMulti = m_pMulti; + + m_pMulti = &rMulti; + SwLineLayout *pOldCurr = m_pCurr; + TextFrameIndex const nOldStart = GetStart(); + SwTwips nMinWidth = nTmpX + 1; + SwTwips nActWidth = nMaxWidth; + const TextFrameIndex nStartIdx = rInf.GetIdx(); + TextFrameIndex nMultiLen = rMulti.GetLen(); + + SwLinePortion *pFirstRest; + SwLinePortion *pSecondRest; + if( rMulti.IsFormatted() ) + { + if( !lcl_ExtractFieldFollow( &rMulti.GetRoot(), pFirstRest ) + && rMulti.IsDouble() && rMulti.GetRoot().GetNext() ) + lcl_ExtractFieldFollow( rMulti.GetRoot().GetNext(), pFirstRest ); + if( !rMulti.IsDouble() && rMulti.GetRoot().GetNext() ) + lcl_ExtractFieldFollow( rMulti.GetRoot().GetNext(), pSecondRest ); + else + pSecondRest = nullptr; + } + else + { + pFirstRest = rMulti.GetRoot().GetNextPortion(); + pSecondRest = rMulti.GetRoot().GetNext() ? + rMulti.GetRoot().GetNext()->GetNextPortion() : nullptr; + if( pFirstRest ) + rMulti.GetRoot().SetNextPortion( nullptr ); + if( pSecondRest ) + rMulti.GetRoot().GetNext()->SetNextPortion( nullptr ); + rMulti.SetFormatted(); + nMultiLen = nMultiLen - rInf.GetIdx(); + } + + // save some values + const OUString* pOldText = &(rInf.GetText()); + const SwTwips nOldPaintOfst = rInf.GetPaintOfst(); + std::shared_ptr const pOldCachedVclData(rInf.GetCachedVclData()); + rInf.SetCachedVclData(nullptr); + + OUString const aMultiStr( rInf.GetText().copy(0, sal_Int32(nMultiLen + rInf.GetIdx())) ); + rInf.SetText( aMultiStr ); + SwTextFormatInfo aInf( rInf, rMulti.GetRoot(), nActWidth ); + // Do we allow break cuts? The FirstMulti-Flag is evaluated during + // line break determination. + bool bFirstMulti = rInf.GetIdx() != rInf.GetLineStart(); + + SwLinePortion *pNextFirst = nullptr; + SwLinePortion *pNextSecond = nullptr; + bool bRet = false; + + SwTextGridItem const*const pGrid(GetGridItem(m_pFrame->FindPageFrame())); + const bool bHasGrid = pGrid && GRID_LINES_CHARS == pGrid->GetGridType(); + + bool bRubyTop = false; + + if ( bHasGrid ) + bRubyTop = ! pGrid->GetRubyTextBelow(); + + do + { + m_pCurr = &rMulti.GetRoot(); + m_nStart = nStartIdx; + bRet = false; + FormatReset( aInf ); + aInf.X( nTmpX ); + aInf.Width( sal_uInt16(nActWidth) ); + aInf.RealWidth( sal_uInt16(nActWidth) ); + aInf.SetFirstMulti( bFirstMulti ); + aInf.SetNumDone( rInf.IsNumDone() ); + aInf.SetFootnoteDone( rInf.IsFootnoteDone() ); + + // if there's a bookmark at the start of the MultiPortion, it will be + // painted with the rotation etc. of the MultiPortion; move it *inside* + // so it gets positioned correctly; currently there's no other portion + // inserted between the end of WhichFirstPortion() and + // BuildMultiPortion() + if (rInf.GetLast()->GetWhichPor() == PortionType::Bookmark) + { + auto const pBookmark(static_cast(rInf.GetLast())); + auto *const pPrevious = pBookmark->FindPrevPortion(rInf.GetRoot()); + assert(!pPrevious || pPrevious->GetNextPortion() == pBookmark); + if (pPrevious) + { + pPrevious->SetNextPortion(nullptr); + } + rInf.SetLast(pPrevious); + assert(m_pCurr->GetNextPortion() == nullptr); + m_pCurr->SetNextPortion(pBookmark); + } + + if( pFirstRest ) + { + OSL_ENSURE( pFirstRest->InFieldGrp(), "BuildMulti: Fieldrest expected"); + SwFieldPortion *pField = + static_cast(pFirstRest)->Clone( + static_cast(pFirstRest)->GetExp() ); + pField->SetFollow( true ); + aInf.SetRest( pField ); + } + aInf.SetRuby( rMulti.IsRuby() && rMulti.OnTop() ); + + // in grid mode we temporarily have to disable the grid for the ruby line + const bool bOldGridModeAllowed = GetInfo().SnapToGrid(); + if ( bHasGrid && aInf.IsRuby() && bRubyTop ) + aInf.SetSnapToGrid( false ); + + // If there's no more rubytext, then buildportion is forbidden + if( pFirstRest || !aInf.IsRuby() ) + BuildPortions( aInf ); + + aInf.SetSnapToGrid( bOldGridModeAllowed ); + + rMulti.CalcSize( *this, aInf ); + m_pCurr->SetRealHeight( m_pCurr->Height() ); + + if( rMulti.IsBidi() ) + { + pNextFirst = aInf.GetRest(); + break; + } + + if( rMulti.HasRotation() && !rMulti.IsDouble() ) + break; + // second line has to be formatted + else if( m_pCurr->GetLen()GetLen(); + delete m_pCurr->GetNext(); + m_pCurr->SetNext( new SwLineLayout() ); + m_pCurr = m_pCurr->GetNext(); + m_nStart = aInf.GetIdx(); + aInf.X( nTmpX ); + SwTextFormatInfo aTmp( aInf, *m_pCurr, nActWidth ); + if( rMulti.IsRuby() ) + { + aTmp.SetRuby( !rMulti.OnTop() ); + pNextFirst = aInf.GetRest(); + if( pSecondRest ) + { + OSL_ENSURE( pSecondRest->InFieldGrp(), "Fieldrest expected"); + SwFieldPortion *pField = static_cast(pSecondRest)->Clone( + static_cast(pSecondRest)->GetExp() ); + pField->SetFollow( true ); + aTmp.SetRest( pField ); + } + if( !rMulti.OnTop() && nFirstLen < nMultiLen ) + bRet = true; + } + else + aTmp.SetRest( aInf.GetRest() ); + aInf.SetRest( nullptr ); + + // in grid mode we temporarily have to disable the grid for the ruby line + if ( bHasGrid && aTmp.IsRuby() && ! bRubyTop ) + aTmp.SetSnapToGrid( false ); + + BuildPortions( aTmp ); + + const SwLinePortion *pRightPortion = rMulti.OnRight() ? + rMulti.GetRoot().GetNext()->GetNextPortion() : nullptr; + if (pRightPortion) + { + // The ruby text on the right is vertical. + // The width and the height are swapped. + SwTwips nHeight = pRightPortion->Height(); + // Keep room for the ruby text. + rMulti.GetRoot().FindLastPortion()->AddPrtWidth( nHeight ); + } + + aTmp.SetSnapToGrid( bOldGridModeAllowed ); + + rMulti.CalcSize( *this, aInf ); + rMulti.GetRoot().SetRealHeight( rMulti.GetRoot().Height() ); + m_pCurr->SetRealHeight( m_pCurr->Height() ); + if( rMulti.IsRuby() ) + { + pNextSecond = aTmp.GetRest(); + if( pNextFirst ) + bRet = true; + } + else + pNextFirst = aTmp.GetRest(); + if( ( !aTmp.IsRuby() && nFirstLen + m_pCurr->GetLen() < nMultiLen ) + || aTmp.GetRest() ) + // our guess for width of multiportion was too small, + // text did not fit into multiportion + bRet = true; + } + if( rMulti.IsRuby() ) + break; + if( bRet ) + { + // our guess for multiportion width was too small, + // we set min to act + nMinWidth = nActWidth; + nActWidth = ( 3 * nMaxWidth + nMinWidth + 3 ) / 4; + if ( nActWidth == nMaxWidth && rInf.GetLineStart() == rInf.GetIdx() ) + // we have too less space, we must allow break cuts + // ( the first multi flag is considered during TextPortion::Format_() ) + bFirstMulti = false; + if( nActWidth <= nMinWidth ) + break; + } + else + { + // For Solaris, this optimization can causes trouble: + // Setting this to the portion width ( = rMulti.Width() ) + // can make GetTextBreak inside SwTextGuess::Guess return too small + // values. Therefore we add some extra twips. + if( nActWidth > nTmpX + rMulti.Width() + 6 ) + nActWidth = nTmpX + rMulti.Width() + 6; + nMaxWidth = nActWidth; + nActWidth = ( 3 * nMaxWidth + nMinWidth + 3 ) / 4; + if( nActWidth >= nMaxWidth ) + break; + // we do not allow break cuts during formatting + bFirstMulti = true; + } + delete pNextFirst; + pNextFirst = nullptr; + } while ( true ); + + m_pMulti = pOldMulti; + + m_pCurr = pOldCurr; + m_nStart = nOldStart; + SetPropFont( 0 ); + + rMulti.SetLen( rMulti.GetRoot().GetLen() + ( rMulti.GetRoot().GetNext() ? + rMulti.GetRoot().GetNext()->GetLen() : TextFrameIndex(0) ) ); + + if( rMulti.IsDouble() ) + { + static_cast(rMulti).CalcBlanks( rInf ); + if( static_cast(rMulti).GetLineDiff() ) + { + SwLineLayout* pLine = &rMulti.GetRoot(); + if( static_cast(rMulti).GetLineDiff() > 0 ) + { + rInf.SetIdx( nStartIdx + pLine->GetLen() ); + pLine = pLine->GetNext(); + } + if( pLine ) + { + GetInfo().SetMulti( true ); + + // If the fourth element bSkipKashida of function CalcNewBlock is true, multiportion will be showed in justification. + // Kashida (Persian) is a type of justification used in some cursive scripts, particularly Arabic. + // In contrast to white-space justification, which increases the length of a line of text by expanding spaces between words or individual letters, + // kashida justification is accomplished by elongating characters at certain chosen points. + // Kashida justification can be combined with white-space justification to various extents. + // The default value of bSkipKashida (the 4th parameter passed to 'CalcNewBlock') is false. + // Only when Adjust is SvxAdjust::Block ( alignment is justify ), multiportion will be showed in justification in new code. + CalcNewBlock( pLine, nullptr, rMulti.Width(), GetAdjust() != SvxAdjust::Block ); + + GetInfo().SetMulti( false ); + } + rInf.SetIdx( nStartIdx ); + } + if( static_cast(rMulti).GetBrackets() ) + { + rMulti.Width( rMulti.Width() + + static_cast(rMulti).BracketWidth() ); + GetInfo().X( nOldX ); + } + } + else + { + rMulti.ActualizeTabulator(); + if( rMulti.IsRuby() ) + { + static_cast(rMulti).Adjust( rInf ); + static_cast(rMulti).CalcRubyOffset(); + } + } + if( rMulti.HasRotation() ) + { + SwTwips nH = rMulti.Width(); + SwTwips nAsc = rMulti.GetAscent() + ( nH - rMulti.Height() )/2; + if( nAsc > nH ) + nAsc = nH; + else if( nAsc < 0 ) + nAsc = 0; + rMulti.Width( rMulti.Height() ); + rMulti.Height( sal_uInt16(nH) ); + rMulti.SetAscent( sal_uInt16(nAsc) ); + bRet = ( rInf.GetPos().X() + rMulti.Width() > rInf.Width() ) && + nStartIdx != rInf.GetLineStart(); + } + else if ( rMulti.IsBidi() ) + { + bRet = rMulti.GetLen() < nMultiLen || pNextFirst; + } + + // line break has to be performed! + if( bRet ) + { + OSL_ENSURE( !pNextFirst || pNextFirst->InFieldGrp(), + "BuildMultiPortion: Surprising restportion, field expected" ); + SwMultiPortion *pTmp; + if( rMulti.IsDouble() ) + pTmp = new SwDoubleLinePortion( static_cast(rMulti), + nMultiLen + rInf.GetIdx() ); + else if( rMulti.IsRuby() ) + { + OSL_ENSURE( !pNextSecond || pNextSecond->InFieldGrp(), + "BuildMultiPortion: Surprising restportion, field expected" ); + + if ( rInf.GetIdx() == rInf.GetLineStart() ) + { + // the ruby portion has to be split in two portions + pTmp = new SwRubyPortion( static_cast(rMulti), + nMultiLen + rInf.GetIdx() ); + + if( pNextSecond ) + { + pTmp->GetRoot().SetNext( new SwLineLayout() ); + pTmp->GetRoot().GetNext()->SetNextPortion( pNextSecond ); + } + pTmp->SetFollowField(); + } + else + { + // we try to keep our ruby portion together + lcl_TruncateMultiPortion( rMulti, rInf, nStartIdx ); + pTmp = nullptr; + // A follow field portion may still be waiting. If nobody wants + // it, we delete it. + delete pNextSecond; + } + } + else if( rMulti.HasRotation() ) + { + // we try to keep our rotated portion together + lcl_TruncateMultiPortion( rMulti, rInf, nStartIdx ); + pTmp = new SwRotatedPortion( nMultiLen + rInf.GetIdx(), + rMulti.GetDirection() ); + } + // during a recursion of BuildMultiPortions we may not build + // a new SwBidiPortion, this would cause a memory leak + else if( rMulti.IsBidi() && ! m_pMulti ) + { + if ( ! rMulti.GetLen() ) + lcl_TruncateMultiPortion( rMulti, rInf, nStartIdx ); + + // If there is a HolePortion at the end of the bidi portion, + // it has to be moved behind the bidi portion. Otherwise + // the visual cursor travelling gets into trouble. + SwLineLayout& aRoot = rMulti.GetRoot(); + SwLinePortion* pPor = aRoot.GetFirstPortion(); + while ( pPor ) + { + if ( pPor->GetNextPortion() && pPor->GetNextPortion()->IsHolePortion() ) + { + SwLinePortion* pHolePor = pPor->GetNextPortion(); + pPor->SetNextPortion( nullptr ); + aRoot.SetLen( aRoot.GetLen() - pHolePor->GetLen() ); + rMulti.SetLen( rMulti.GetLen() - pHolePor->GetLen() ); + rMulti.SetNextPortion( pHolePor ); + break; + } + pPor = pPor->GetNextPortion(); + } + + pTmp = new SwBidiPortion( nMultiLen + rInf.GetIdx(), + static_cast(rMulti).GetLevel() ); + } + else + pTmp = nullptr; + + if ( ! rMulti.GetLen() && rInf.GetLast() ) + { + SeekAndChgBefore( rInf ); + rInf.GetLast()->FormatEOL( rInf ); + } + + if( pNextFirst && pTmp ) + { + pTmp->SetFollowField(); + pTmp->GetRoot().SetNextPortion( pNextFirst ); + } + else + // A follow field portion is still waiting. If nobody wants it, + // we delete it. + delete pNextFirst; + + rInf.SetRest( pTmp ); + } + + rInf.SetCachedVclData(pOldCachedVclData); + rInf.SetText( *pOldText ); + rInf.SetPaintOfst( nOldPaintOfst ); + rInf.SetStop( aInf.IsStop() ); + rInf.SetNumDone( true ); + rInf.SetFootnoteDone( true ); + SeekAndChg( rInf ); + delete pFirstRest; + delete pSecondRest; + oFontSave.reset(); + return bRet; +} + +static bool IsIncompleteRuby(const SwMultiPortion& rHelpMulti) +{ + return rHelpMulti.IsRuby() && static_cast(rHelpMulti).GetRubyOffset() < TextFrameIndex(COMPLETE_STRING); +} + +// When a fieldportion at the end of line breaks and needs a following +// fieldportion in the next line, then the "restportion" of the formatinfo +// has to be set. Normally this happens during the formatting of the first +// part of the fieldportion. +// But sometimes the formatting starts at the line with the following part, +// especially when the following part is on the next page. +// In this case the MakeRestPortion-function has to create the following part. +// The first parameter is the line that contains possibly a first part +// of a field. When the function finds such field part, it creates the right +// restportion. This may be a multiportion, e.g. if the field is surrounded by +// a doubleline- or ruby-portion. +// The second parameter is the start index of the line. +SwLinePortion* SwTextFormatter::MakeRestPortion( const SwLineLayout* pLine, + TextFrameIndex nPosition) +{ + if( !nPosition ) + return nullptr; + TextFrameIndex nMultiPos = nPosition - pLine->GetLen(); + const SwMultiPortion *pTmpMulti = nullptr; + const SwMultiPortion *pHelpMulti = nullptr; + const SwLinePortion* pPor = pLine->GetFirstPortion(); + SwFieldPortion *pField = nullptr; + while( pPor ) + { + if( pPor->GetLen() && !pHelpMulti ) + { + nMultiPos = nMultiPos + pPor->GetLen(); + pTmpMulti = nullptr; + } + if( pPor->InFieldGrp() ) + { + if( !pHelpMulti ) + pTmpMulti = nullptr; + pField = const_cast(static_cast(pPor)); + } + else if( pPor->IsMultiPortion() ) + { + OSL_ENSURE( !pHelpMulti || pHelpMulti->IsBidi(), + "Nested multiportions are forbidden." ); + + pField = nullptr; + pTmpMulti = static_cast(pPor); + } + pPor = pPor->GetNextPortion(); + // If the last portion is a multi-portion, we enter it + // and look for a field portion inside. + // If we are already in a multiportion, we could change to the + // next line + if( !pPor && pTmpMulti ) + { + if( pHelpMulti ) + { // We're already inside the multiportion, let's take the second + // line, if we are in a double line portion + if( !pHelpMulti->IsRuby() ) + pPor = pHelpMulti->GetRoot().GetNext(); + pTmpMulti = nullptr; + } + else + { // Now we enter a multiportion, in a ruby portion we take the + // main line, not the phonetic line, in a doublelineportion we + // starts with the first line. + pHelpMulti = pTmpMulti; + nMultiPos = nMultiPos - pHelpMulti->GetLen(); + if( pHelpMulti->IsRuby() && pHelpMulti->OnTop() ) + pPor = pHelpMulti->GetRoot().GetNext(); + else + pPor = pHelpMulti->GetRoot().GetFirstPortion(); + } + } + } + if( pField && !pField->HasFollow() ) + pField = nullptr; + + SwLinePortion *pRest = nullptr; + if( pField ) + { + const SwTextAttr *pHint = GetAttr(nPosition - TextFrameIndex(1)); + if ( pHint + && ( pHint->Which() == RES_TXTATR_FIELD + || pHint->Which() == RES_TXTATR_ANNOTATION ) ) + { + pRest = NewFieldPortion( GetInfo(), pHint ); + if( pRest->InFieldGrp() ) + static_cast(pRest)->TakeNextOffset( pField ); + else + { + delete pRest; + pRest = nullptr; + } + } + } + if( !pHelpMulti ) + return pRest; + + nPosition = nMultiPos + pHelpMulti->GetLen(); + std::optional pCreate = GetInfo().GetMultiCreator( nMultiPos, nullptr ); + + if ( !pCreate ) + { + OSL_ENSURE( !pHelpMulti->GetLen(), "Multiportion without attribute?" ); + if ( nMultiPos ) + --nMultiPos; + pCreate = GetInfo().GetMultiCreator( --nMultiPos, nullptr ); + } + + if (!pCreate) + return pRest; + + if( pRest || nMultiPos > nPosition || IsIncompleteRuby(*pHelpMulti)) + { + SwMultiPortion* pTmp; + if( pHelpMulti->IsDouble() ) + pTmp = new SwDoubleLinePortion( *pCreate, nMultiPos ); + else if( pHelpMulti->IsBidi() ) + pTmp = new SwBidiPortion( nMultiPos, pCreate->nLevel ); + else if (IsIncompleteRuby(*pHelpMulti) && pCreate->pAttr) + { + TextFrameIndex nRubyOffset = static_cast(pHelpMulti)->GetRubyOffset(); + pTmp = new SwRubyPortion( *pCreate, *GetInfo().GetFont(), + m_pFrame->GetDoc().getIDocumentSettingAccess(), + nMultiPos, nRubyOffset, + GetInfo() ); + } + else if( pHelpMulti->HasRotation() ) + pTmp = new SwRotatedPortion( nMultiPos, pHelpMulti->GetDirection() ); + else + { + return pRest; + } + pCreate.reset(); + pTmp->SetFollowField(); + if( pRest ) + { + SwLineLayout *pLay = &pTmp->GetRoot(); + if( pTmp->IsRuby() && pTmp->OnTop() ) + { + pLay->SetNext( new SwLineLayout() ); + pLay = pLay->GetNext(); + } + pLay->SetNextPortion( pRest ); + } + return pTmp; + } + return pRest; +} + +// SwTextCursorSave notes the start and current line of a SwTextCursor, +// sets them to the values for GetModelPositionForViewPoint inside a multiportion +// and restores them in the destructor. +SwTextCursorSave::SwTextCursorSave( SwTextCursor* pCursor, + SwMultiPortion* pMulti, + SwTwips nY, + SwTwips& nX, + TextFrameIndex const nCurrStart, + tools::Long nSpaceAdd ) + : pTextCursor(pCursor), + pCurr(pCursor->m_pCurr), + nStart(pCursor->m_nStart) +{ + pCursor->m_nStart = nCurrStart; + pCursor->m_pCurr = &pMulti->GetRoot(); + while( pCursor->Y() + pCursor->GetLineHeight() < nY && + pCursor->Next() ) + ; // nothing + nWidth = pCursor->m_pCurr->Width(); + nOldProp = pCursor->GetPropFont(); + + if ( pMulti->IsDouble() || pMulti->IsBidi() ) + { + bSpaceChg = pMulti->ChgSpaceAdd( pCursor->m_pCurr, nSpaceAdd ); + + TextFrameIndex nSpaceCnt; + if ( pMulti->IsDouble() ) + { + pCursor->SetPropFont( 50 ); + nSpaceCnt = static_cast(pMulti)->GetSpaceCnt(); + } + else + { + TextFrameIndex const nOldIdx = pCursor->GetInfo().GetIdx(); + pCursor->GetInfo().SetIdx ( nCurrStart ); + nSpaceCnt = static_cast(pMulti)->GetSpaceCnt(pCursor->GetInfo()); + pCursor->GetInfo().SetIdx ( nOldIdx ); + } + + if( nSpaceAdd > 0 && !pMulti->HasTabulator() ) + pCursor->m_pCurr->Width( o3tl::narrowing(nWidth + nSpaceAdd * sal_Int32(nSpaceCnt) / SPACING_PRECISION_FACTOR) ); + + // For a BidiPortion we have to calculate the offset from the + // end of the portion + if ( nX && pMulti->IsBidi() ) + nX = pCursor->m_pCurr->Width() - nX; + } + else + bSpaceChg = false; +} + +SwTextCursorSave::~SwTextCursorSave() +{ + if( bSpaceChg ) + SwDoubleLinePortion::ResetSpaceAdd( pTextCursor->m_pCurr ); + pTextCursor->m_pCurr->Width( nWidth ); + pTextCursor->m_pCurr = pCurr; + pTextCursor->m_nStart = nStart; + pTextCursor->SetPropFont( nOldProp ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/pormulti.hxx b/sw/source/core/text/pormulti.hxx new file mode 100644 index 0000000000..e5a3da2b32 --- /dev/null +++ b/sw/source/core/text/pormulti.hxx @@ -0,0 +1,256 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#pragma once + +#include +#include "porlay.hxx" +#include + +class IDocumentSettingAccess; +class SwTextFormatInfo; +class SwTextCursor; +class SwTextPaintInfo; +class SwTextAttr; +class SfxPoolItem; +class SwFont; + +// SwMultiCreator is a small structure to create a multiportion. +// It contains the kind of multiportion and a textattribute +// or a poolitem. +// The GetMultiCreator-function fills this structure and +// the Ctor of the SwMultiPortion uses it. +enum class SwMultiCreatorId +{ + Double, Ruby, Rotate, Bidi +}; + +enum class RubyPosition : sal_uInt16 +{ + ABOVE = 0, + BELOW = 1, + RIGHT = 2 +}; + +struct SwMultiCreator +{ + TextFrameIndex nStartOfAttr; + const SwTextAttr* pAttr; + const SfxPoolItem* pItem; + SwMultiCreatorId nId; + sal_uInt8 nLevel; +}; + +// A two-line-portion (SwMultiPortion) could have surrounding brackets, +// in this case the structure SwBracket will be used. +struct SwBracket +{ + TextFrameIndex nStart; // Start of text attribute determines the font + sal_uInt16 nAscent; // Ascent of the brackets + sal_uInt16 nHeight; // Height of them + sal_uInt16 nPreWidth; // Width of the opening bracket + sal_uInt16 nPostWidth; // Width of the closing bracket + sal_Unicode cPre; // Initial character, e.g. '(' + sal_Unicode cPost; // Final character, e.g. ')' + SwFontScript nPreScript; // Script of the initial character + SwFontScript nPostScript; // Script of the final character +}; + +// The SwMultiPortion is line portion inside a line portion, +// it's a group of portions, +// e.g. a double line portion in a line +// or phonetics (ruby) +// or combined characters +// or a rotated portion. +class SAL_DLLPUBLIC_RTTI SwMultiPortion : public SwLinePortion +{ + SwLineLayout m_aRoot; // One or more lines + bool m_bTab1 :1; // First line tabulator + bool m_bTab2 :1; // Second line includes tabulator + bool m_bDouble :1; // Double line + bool m_bRuby :1; // Phonetics + bool m_bBidi :1; + bool m_bFormatted :1; // Already formatted + bool m_bFollowField :1; // Field follow inside + bool m_bFlyInContent:1; // Fly as character inside + RubyPosition m_eRubyPosition; // Phonetic position + sal_uInt8 m_nDirection:2; // Direction (0/90/180/270 degrees) +protected: + explicit SwMultiPortion(TextFrameIndex const nEnd) + : m_bTab1(false) + , m_bTab2(false) + , m_bDouble(false) + , m_bRuby(false) + , m_bBidi(false) + , m_bFormatted(false) + , m_bFollowField(false) + , m_bFlyInContent(false) + , m_eRubyPosition( RubyPosition::ABOVE ) + , m_nDirection(0) + { + SetWhichPor(PortionType::Multi); + SetLen(nEnd); + } + void SetDouble() { m_bDouble = true; } + void SetRuby() { m_bRuby = true; } + void SetBidi() { m_bBidi = true; } + void SetRubyPosition( RubyPosition eNew ) { m_eRubyPosition = eNew; } + void SetTab1( bool bNew ) { m_bTab1 = bNew; } + void SetTab2( bool bNew ) { m_bTab2 = bNew; } + void SetDirection( sal_uInt8 nNew ) { m_nDirection = nNew; } + bool GetTab1() const { return m_bTab1; } + bool GetTab2() const { return m_bTab2; } +public: + virtual ~SwMultiPortion() override; + const SwLineLayout& GetRoot() const { return m_aRoot; } + SwLineLayout& GetRoot() { return m_aRoot; } + + bool HasTabulator() const { return m_bTab1 || m_bTab2; } + bool IsFormatted() const { return m_bFormatted; } + void SetFormatted() { m_bFormatted = true; } + bool IsFollowField() const { return m_bFollowField; } + void SetFollowField() { m_bFollowField = true; } + bool HasFlyInContent() const { return m_bFlyInContent; } + void SetFlyInContent( bool bNew ) { m_bFlyInContent = bNew; } + bool IsDouble() const { return m_bDouble; } + bool IsRuby() const { return m_bRuby; } + bool IsBidi() const { return m_bBidi; } + bool OnTop() const { return m_eRubyPosition == RubyPosition::ABOVE; } + bool OnRight() const { return m_eRubyPosition == RubyPosition::RIGHT; } + RubyPosition GetRubyPosition() const { return m_eRubyPosition; } + void ActualizeTabulator(); + + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + virtual SwTwips CalcSpacing( tools::Long nSpaceAdd, const SwTextSizeInfo &rInf ) const override; + virtual bool ChgSpaceAdd( SwLineLayout* pCurr, tools::Long nSpaceAdd ) const; + + // Summarize the internal lines to calculate the (external) size + void CalcSize( SwTextFormatter& rLine, SwTextFormatInfo &rInf ); + + inline bool HasBrackets() const; + bool HasRotation() const { return 0 != (1 & m_nDirection); } + bool IsRevers() const { return 0 != (2 & m_nDirection); } + sal_uInt8 GetDirection() const { return m_nDirection; } + + // Accessibility: pass information about this portion to the PortionHandler + virtual void HandlePortion( SwPortionHandler& rPH ) const override; + + void dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, + TextFrameIndex& nOffset) const override; +}; + +class SwDoubleLinePortion : public SwMultiPortion +{ + std::unique_ptr m_pBracket; // Surrounding brackets + SwTwips m_nLineDiff; // Difference of the width of the both lines + TextFrameIndex m_nBlank1; ///< Number of blanks in the first line + TextFrameIndex m_nBlank2; ///< Number of blanks in the second line +public: + SwDoubleLinePortion(SwDoubleLinePortion& rDouble, TextFrameIndex nEnd); + SwDoubleLinePortion(const SwMultiCreator& rCreate, TextFrameIndex nEnd); + virtual ~SwDoubleLinePortion() override; + + SwBracket* GetBrackets() const { return m_pBracket.get(); } + void SetBrackets( const SwDoubleLinePortion& rDouble ); + void PaintBracket( SwTextPaintInfo& rInf, tools::Long nSpaceAdd, bool bOpen ) const; + void FormatBrackets( SwTextFormatInfo &rInf, SwTwips& nMaxWidth ); + sal_uInt16 PreWidth() const { return m_pBracket->nPreWidth; }; + sal_uInt16 PostWidth() const { return m_pBracket->nPostWidth; } + void ClearBrackets() + { m_pBracket->nPreWidth = m_pBracket->nPostWidth=0; Width( 0 ); } + sal_uInt16 BracketWidth(){ return PreWidth() + PostWidth(); } + + void CalcBlanks( SwTextFormatInfo &rInf ); + static void ResetSpaceAdd( SwLineLayout* pCurr ); + SwTwips GetLineDiff() const { return m_nLineDiff; } + TextFrameIndex GetSpaceCnt() const + { return ( m_nLineDiff < 0 ) ? m_nBlank2 : m_nBlank1; } + TextFrameIndex GetSmallerSpaceCnt() const + { return ( m_nLineDiff < 0 ) ? m_nBlank1 : m_nBlank2; } + + virtual SwTwips CalcSpacing( tools::Long nSpaceAdd, const SwTextSizeInfo &rInf ) const override; + virtual bool ChgSpaceAdd( SwLineLayout* pCurr, tools::Long nSpaceAdd ) const override; +}; + +class SwRubyPortion : public SwMultiPortion +{ + TextFrameIndex m_nRubyOffset; + css::text::RubyAdjust m_nAdjustment; + void Adjust_( SwTextFormatInfo &rInf); +public: + SwRubyPortion(const SwRubyPortion& rRuby, TextFrameIndex nEnd); + + SwRubyPortion( const SwMultiCreator& rCreate, const SwFont& rFnt, + const IDocumentSettingAccess& rIDocumentSettingAccess, + TextFrameIndex nEnd, TextFrameIndex nOffs, + const SwTextSizeInfo &rInf ); + + void CalcRubyOffset(); + void Adjust( SwTextFormatInfo &rInf ) + { if(m_nAdjustment != css::text::RubyAdjust_LEFT && GetRoot().GetNext()) Adjust_(rInf); } + css::text::RubyAdjust GetAdjustment() const { return m_nAdjustment; } + TextFrameIndex GetRubyOffset() const { return m_nRubyOffset; } +}; + +class SwRotatedPortion : public SwMultiPortion +{ +public: + SwRotatedPortion(TextFrameIndex const nEnd, sal_uInt8 nDir) + : SwMultiPortion( nEnd ) { SetDirection( nDir ); } + SwRotatedPortion( const SwMultiCreator& rCreate, TextFrameIndex nEnd, + bool bRTL ); +}; + +class SwBidiPortion : public SwMultiPortion +{ + sal_uInt8 m_nLevel; + +public: + SwBidiPortion(TextFrameIndex nEnd, sal_uInt8 nLv); + + sal_uInt8 GetLevel() const { return m_nLevel; } + // Get number of blanks for justified alignment + TextFrameIndex GetSpaceCnt(const SwTextSizeInfo &rInf) const; + // Calculates extra spacing based on number of blanks + virtual SwTwips CalcSpacing( tools::Long nSpaceAdd, const SwTextSizeInfo &rInf ) const override; + // Manipulate the spacing array at pCurr + virtual bool ChgSpaceAdd( SwLineLayout* pCurr, tools::Long nSpaceAdd ) const override; +}; + +// For cursor travelling in multiportions + +class SwTextCursorSave +{ + SwTextCursor* pTextCursor; + SwLineLayout* pCurr; + TextFrameIndex nStart; + sal_uInt16 nWidth; + sal_uInt8 nOldProp; + bool bSpaceChg; +public: + SwTextCursorSave( SwTextCursor* pTextCursor, SwMultiPortion* pMulti, + SwTwips nY, SwTwips& nX, TextFrameIndex nCurrStart, tools::Long nSpaceAdd); + ~SwTextCursorSave(); +}; + +inline bool SwMultiPortion::HasBrackets() const +{ + return IsDouble() && nullptr != static_cast(this)->GetBrackets(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/porref.cxx b/sw/source/core/text/porref.cxx new file mode 100644 index 0000000000..a64f2df1fe --- /dev/null +++ b/sw/source/core/text/porref.cxx @@ -0,0 +1,75 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include + +#include "porref.hxx" +#include "inftxt.hxx" + +void SwRefPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + if( Width() ) + { + rInf.DrawViewOpt( *this, PortionType::Ref ); + SwTextPortion::Paint( rInf ); + } +} + +SwLinePortion *SwIsoRefPortion::Compress() { return this; } + +SwIsoRefPortion::SwIsoRefPortion() : m_nViewWidth(0) +{ + SetLen(TextFrameIndex(1)); + SetWhichPor( PortionType::IsoRef ); +} + +sal_uInt16 SwIsoRefPortion::GetViewWidth( const SwTextSizeInfo &rInf ) const +{ + // Although we are const, nViewWidth should be calculated in the last + // moment possible + SwIsoRefPortion* pThis = const_cast(this); + if( !Width() && rInf.OnWin() && rInf.GetOpt().IsFieldShadings() && + !rInf.GetOpt().IsReadonly() && !rInf.GetOpt().IsPagePreview() ) + { + if( !m_nViewWidth ) + pThis->m_nViewWidth = rInf.GetTextSize(OUString(' ')).Width(); + } + else + pThis->m_nViewWidth = 0; + return m_nViewWidth; +} + +bool SwIsoRefPortion::Format( SwTextFormatInfo &rInf ) +{ + return SwLinePortion::Format( rInf ); +} + +void SwIsoRefPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + if( Width() ) + rInf.DrawViewOpt( *this, PortionType::Ref ); +} + +void SwIsoRefPortion::HandlePortion( SwPortionHandler& rPH ) const +{ + rPH.Special( GetLen(), OUString(), GetWhichPor() ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/porref.hxx b/sw/source/core/text/porref.hxx new file mode 100644 index 0000000000..d128030803 --- /dev/null +++ b/sw/source/core/text/porref.hxx @@ -0,0 +1,45 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#pragma once + +#include "portxt.hxx" + +class SwRefPortion : public SwTextPortion +{ +public: + SwRefPortion() { SetWhichPor(PortionType::Ref); } + virtual void Paint(const SwTextPaintInfo& rInf) const override; +}; + +class SwIsoRefPortion : public SwRefPortion +{ + sal_uInt16 m_nViewWidth; + +public: + SwIsoRefPortion(); + virtual bool Format(SwTextFormatInfo& rInf) override; + virtual void Paint(const SwTextPaintInfo& rInf) const override; + virtual SwLinePortion* Compress() override; + virtual sal_uInt16 GetViewWidth(const SwTextSizeInfo& rInf) const override; + + // Accessibility: pass information about this portion to the PortionHandler + virtual void HandlePortion(SwPortionHandler& rPH) const override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/porrst.cxx b/sw/source/core/text/porrst.cxx new file mode 100644 index 0000000000..029adca753 --- /dev/null +++ b/sw/source/core/text/porrst.cxx @@ -0,0 +1,949 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include "porrst.hxx" +#include "inftxt.hxx" +#include "txtpaint.hxx" +#include +#include +#include +#include +#include "redlnitr.hxx" +#include "atrhndl.hxx" +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include + +SwTmpEndPortion::SwTmpEndPortion( const SwLinePortion &rPortion, + const FontLineStyle eUL, + const FontStrikeout eStrkout, + const Color& rCol ) : + m_eUnderline( eUL ), m_eStrikeout( eStrkout ), m_aColor( rCol ) +{ + Height( rPortion.Height() ); + SetAscent( rPortion.GetAscent() ); + SetWhichPor( PortionType::TempEnd ); +} + +void SwTmpEndPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + if (!(rInf.OnWin() && rInf.GetOpt().IsParagraph())) + return; + + const SwFont* pOldFnt = rInf.GetFont(); + + SwFont aFont(*pOldFnt); + + // Paint strikeout/underline based on redline color and settings + // (with an extra pilcrow in the background, because there is + // no SetStrikeoutColor(), also SetUnderColor() doesn't work()). + if ( m_eUnderline != LINESTYLE_NONE || m_eStrikeout != STRIKEOUT_NONE ) + { + aFont.SetColor( m_aColor ); + aFont.SetUnderline( m_eUnderline ); + aFont.SetStrikeout( m_eStrikeout ); + + const_cast(rInf).SetFont(&aFont); + + // draw the pilcrow with strikeout/underline in redline color + rInf.DrawText(CH_PAR, *this); + + } + + aFont.SetColor( NON_PRINTING_CHARACTER_COLOR ); + aFont.SetStrikeout( STRIKEOUT_NONE ); + aFont.SetUnderline( LINESTYLE_NONE ); + const_cast(rInf).SetFont(&aFont); + + // draw the pilcrow + rInf.DrawText(CH_PAR, *this); + + const_cast(rInf).SetFont(const_cast(pOldFnt)); +} + +SwBreakPortion::SwBreakPortion( const SwLinePortion &rPortion, const SwTextAttr* pAttr ) + : SwLinePortion( rPortion ) +{ + mnLineLength = TextFrameIndex(1); + m_eRedline = RedlineType::None; + SetWhichPor( PortionType::Break ); + + m_eClear = SwLineBreakClear::NONE; + if (pAttr && pAttr->Which() == RES_TXTATR_LINEBREAK) + { + m_eClear = pAttr->GetLineBreak().GetValue(); + } + m_nTextHeight = 0; +} + +TextFrameIndex SwBreakPortion::GetModelPositionForViewPoint(const sal_uInt16) const +{ + return TextFrameIndex(0); +} + +sal_uInt16 SwBreakPortion::GetViewWidth( const SwTextSizeInfo & ) const +{ return 0; } + +SwLinePortion *SwBreakPortion::Compress() +{ return (GetNextPortion() && GetNextPortion()->InTextGrp() ? nullptr : this); } + +void SwBreakPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + if( !(rInf.OnWin() && rInf.GetOpt().IsLineBreak()) ) + return; + + // Reduce height to text height for the duration of the print, so the vertical height will look + // correct for the line break character, even for clearing breaks. + SwTwips nHeight = Height(); + SwTwips nVertPosOffset = (nHeight - m_nTextHeight) / 2; + auto pPortion = const_cast(this); + pPortion->Height(m_nTextHeight, false); + if (rInf.GetTextFrame()->IsVertical()) + { + // Compensate for the offset done in SwTextCursor::AdjustBaseLine() for the vertical case. + const_cast(rInf).Y(rInf.Y() + nVertPosOffset); + } + comphelper::ScopeGuard g( + [pPortion, nHeight, &rInf, nVertPosOffset] + { + if (rInf.GetTextFrame()->IsVertical()) + { + const_cast(rInf).Y(rInf.Y() - nVertPosOffset); + } + pPortion->Height(nHeight, false); + }); + + rInf.DrawLineBreak( *this ); + + // paint redlining + if (m_eRedline == RedlineType::None) + return; + + sal_Int16 nNoBreakWidth = rInf.GetTextSize(S_NOBREAK_FOR_REDLINE).Width(); + if ( nNoBreakWidth > 0 ) + { + // approximate portion size with multiple no-break spaces + // and draw these spaces (at least a single one) by DrawText + // painting the requested redline underline/strikeout + sal_Int16 nSpaces = (LINE_BREAK_WIDTH + nNoBreakWidth/2) / nNoBreakWidth; + OUStringBuffer aBuf(S_NOBREAK_FOR_REDLINE); + for (sal_Int16 i = 1; i < nSpaces; ++i) + aBuf.append(S_NOBREAK_FOR_REDLINE); + + const SwFont* pOldFnt = rInf.GetFont(); + + SwFont aFont(*pOldFnt); + + if (m_eRedline == RedlineType::Delete) + aFont.SetUnderline( LINESTYLE_NONE ); + else + aFont.SetStrikeout( STRIKEOUT_NONE ); + + const_cast(rInf).SetFont(&aFont); + + rInf.DrawText(aBuf.makeStringAndClear(), *this); + + const_cast(rInf).SetFont(const_cast(pOldFnt)); + } +} + +bool SwBreakPortion::Format( SwTextFormatInfo &rInf ) +{ + const SwLinePortion *pRoot = rInf.GetRoot(); + Width( 0 ); + Height( pRoot->Height() ); + m_nTextHeight = Height(); + + // See if this is a clearing break. If so, calculate how much we need to "jump down" so the next + // line can again use the full text width. + SwLineBreakClear eClear = m_eClear; + if (rInf.GetTextFrame()->IsRightToLeft() && eClear != SwLineBreakClear::ALL) + { + // RTL ignores left/right breaks. + eClear = SwLineBreakClear::NONE; + } + if (eClear != SwLineBreakClear::NONE) + { + SwTextFly& rTextFly = rInf.GetTextFly(); + if (rTextFly.IsOn()) + { + SwTwips nHeight = rTextFly.GetMaxBottom(*this, rInf) - rInf.Y(); + if (nHeight > Height()) + { + Height(nHeight, /*bText=*/false); + } + } + } + + SetAscent( pRoot->GetAscent() ); + if (rInf.GetIdx() + TextFrameIndex(1) == TextFrameIndex(rInf.GetText().getLength())) + rInf.SetNewLine( true ); + return true; +} + +void SwBreakPortion::HandlePortion( SwPortionHandler& rPH ) const +{ + rPH.Text( GetLen(), GetWhichPor() ); +} + +void SwBreakPortion::dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, TextFrameIndex& + nOffset) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwBreakPortion")); + dumpAsXmlAttributes(pWriter, rText, nOffset); + nOffset += GetLen(); + + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("text-height"), + BAD_CAST(OString::number(m_nTextHeight).getStr())); + + (void)xmlTextWriterEndElement(pWriter); +} + +SwLineBreakClear SwBreakPortion::GetClear() const { return m_eClear; } + +SwKernPortion::SwKernPortion( SwLinePortion &rPortion, short nKrn, + bool bBG, bool bGK ) : + m_nKern( nKrn ), m_bBackground( bBG ), m_bGridKern( bGK ) +{ + Height( rPortion.Height() ); + SetAscent( rPortion.GetAscent() ); + mnLineLength = TextFrameIndex(0); + SetWhichPor( PortionType::Kern ); + if( m_nKern > 0 ) + Width( m_nKern ); + rPortion.Insert( this ); +} + +SwKernPortion::SwKernPortion( const SwLinePortion& rPortion ) : + m_nKern( 0 ), m_bBackground( false ), m_bGridKern( true ) +{ + Height( rPortion.Height() ); + SetAscent( rPortion.GetAscent() ); + + mnLineLength = TextFrameIndex(0); + SetWhichPor( PortionType::Kern ); +} + +void SwKernPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + if( !Width() ) + return; + + // bBackground is set for Kerning Portions between two fields + if ( m_bBackground ) + rInf.DrawViewOpt( *this, PortionType::Field ); + + rInf.DrawBackBrush( *this ); + if (GetJoinBorderWithNext() ||GetJoinBorderWithPrev()) + rInf.DrawBorder( *this ); + + // do we have to repaint a post it portion? + if( rInf.OnWin() && mpNextPortion && !mpNextPortion->Width() ) + mpNextPortion->PrePaint( rInf, this ); + + if( rInf.GetFont()->IsPaintBlank() ) + { + SwRect aClipRect; + rInf.CalcRect( *this, &aClipRect ); + SwSaveClip aClip( const_cast(rInf.GetOut()) ); + aClip.ChgClip( aClipRect ); + rInf.DrawText(" ", *this, TextFrameIndex(0), TextFrameIndex(2), true ); + } +} + +void SwKernPortion::FormatEOL( SwTextFormatInfo &rInf ) +{ + if ( m_bGridKern ) + return; + + if( rInf.GetLast() == this ) + rInf.SetLast( FindPrevPortion( rInf.GetRoot() ) ); + if( m_nKern < 0 ) + Width( -m_nKern ); + else + Width( 0 ); + rInf.GetLast()->FormatEOL( rInf ); +} + +SwArrowPortion::SwArrowPortion( const SwLinePortion &rPortion ) : + m_bLeft( true ) +{ + Height( rPortion.Height() ); + SetAscent( rPortion.GetAscent() ); + mnLineLength = TextFrameIndex(0); + SetWhichPor( PortionType::Arrow ); +} + +SwArrowPortion::SwArrowPortion( const SwTextPaintInfo &rInf ) + : m_bLeft( false ) +{ + Height( o3tl::narrowing(rInf.GetTextFrame()->getFramePrintArea().Height()) ); + m_aPos.setX( rInf.GetTextFrame()->getFrameArea().Left() + + rInf.GetTextFrame()->getFramePrintArea().Right() ); + m_aPos.setY( rInf.GetTextFrame()->getFrameArea().Top() + + rInf.GetTextFrame()->getFramePrintArea().Bottom() ); + SetWhichPor( PortionType::Arrow ); +} + +void SwArrowPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + const_cast(this)->m_aPos = rInf.GetPos(); +} + +SwLinePortion *SwArrowPortion::Compress() { return this; } + +SwTwips SwTextFrame::EmptyHeight() const +{ + if (IsCollapse()) { + SwViewShell *pSh = getRootFrame()->GetCurrShell(); + if ( auto pCrSh = dynamic_cast( pSh ) ) { + // this is called during formatting so avoid recursive layout + SwContentFrame const*const pCurrFrame = pCrSh->GetCurrFrame(false); + if (pCurrFrame==static_cast(this)) { + // do nothing + } else { + return 1; + } + } else { + return 1; + } + } + OSL_ENSURE( ! IsVertical() || ! IsSwapped(),"SwTextFrame::EmptyHeight with swapped frame" ); + + std::unique_ptr pFnt; + const SwTextNode& rTextNode = *GetTextNodeForParaProps(); + const IDocumentSettingAccess* pIDSA = rTextNode.getIDocumentSettingAccess(); + SwViewShell *pSh = getRootFrame()->GetCurrShell(); + if ( rTextNode.HasSwAttrSet() ) + { + const SwAttrSet *pAttrSet = &( rTextNode.GetSwAttrSet() ); + pFnt.reset(new SwFont( pAttrSet, pIDSA )); + } + else + { + SwFontAccess aFontAccess( &rTextNode.GetAnyFormatColl(), pSh); + pFnt.reset(new SwFont( aFontAccess.Get()->GetFont() )); + pFnt->CheckFontCacheId( pSh, pFnt->GetActual() ); + } + + if ( IsVertical() ) + pFnt->SetVertical( 2700_deg10 ); + + OutputDevice* pOut = pSh ? pSh->GetOut() : nullptr; + if ( !pOut || !pSh->GetViewOptions()->getBrowseMode() || + pSh->GetViewOptions()->IsPrtFormat() ) + { + pOut = rTextNode.getIDocumentDeviceAccess().getReferenceDevice(true); + } + + const IDocumentRedlineAccess& rIDRA = rTextNode.getIDocumentRedlineAccess(); + if (IDocumentRedlineAccess::IsShowChanges(rIDRA.GetRedlineFlags()) + && !getRootFrame()->IsHideRedlines()) + { + const SwRedlineTable::size_type nRedlPos = rIDRA.GetRedlinePos( rTextNode, RedlineType::Any ); + if( SwRedlineTable::npos != nRedlPos ) + { + SwAttrHandler aAttrHandler; + aAttrHandler.Init(rTextNode.GetSwAttrSet(), + *rTextNode.getIDocumentSettingAccess()); + SwRedlineItr aRedln( rTextNode, *pFnt, aAttrHandler, + nRedlPos, SwRedlineItr::Mode::Show); + } + } + + SwTwips nRet; + if( !pOut ) + nRet = IsVertical() ? + getFramePrintArea().SSize().Width() + 1 : + getFramePrintArea().SSize().Height() + 1; + else + { + pFnt->SetFntChg( true ); + pFnt->ChgPhysFnt( pSh, *pOut ); + nRet = pFnt->GetHeight( pSh, *pOut ); + } + return nRet; +} + +bool SwTextFrame::FormatEmpty() +{ + OSL_ENSURE( ! IsVertical() || ! IsSwapped(),"SwTextFrame::FormatEmpty with swapped frame" ); + + bool bCollapse = EmptyHeight( ) == 1 && IsCollapse( ); + + // sw_redlinehide: just disable FormatEmpty optimisation for now + // Split fly frames: non-last parts of the anchor want this optimization to clear the old + // content. + SwFlyAtContentFrame* pNonLastSplitFlyDrawObj = HasNonLastSplitFlyDrawObj(); + bool bHasNonLastSplitFlyDrawObj = pNonLastSplitFlyDrawObj != nullptr; + + if (pNonLastSplitFlyDrawObj && pNonLastSplitFlyDrawObj->IsWrapOnAllPages()) + { + // Split fly: the anchor is non-empty on all pages in the "wrap on all pages" case. + bHasNonLastSplitFlyDrawObj = false; + } + + if ((HasFollow() && !bHasNonLastSplitFlyDrawObj) || GetMergedPara() || (GetTextNodeFirst()->GetpSwpHints() && !bHasNonLastSplitFlyDrawObj) || + nullptr != GetTextNodeForParaProps()->GetNumRule() || + GetTextNodeFirst()->HasHiddenCharAttribute(true) || + IsInFootnote() || ( HasPara() && GetPara()->IsPrepMustFit() ) ) + return false; + const SwAttrSet& aSet = GetTextNodeForParaProps()->GetSwAttrSet(); + const SvxAdjust nAdjust = aSet.GetAdjust().GetAdjust(); + if( !bCollapse && ( ( ( ! IsRightToLeft() && ( SvxAdjust::Left != nAdjust ) ) || + ( IsRightToLeft() && ( SvxAdjust::Right != nAdjust ) ) ) || + aSet.GetRegister().GetValue() ) ) + return false; + const SvxLineSpacingItem &rSpacing = aSet.GetLineSpacing(); + if( !bCollapse && ( SvxLineSpaceRule::Min == rSpacing.GetLineSpaceRule() || + SvxLineSpaceRule::Fix == rSpacing.GetLineSpaceRule() || + aSet.GetFirstLineIndent().IsAutoFirst())) + { + return false; + } + + SwTextFly aTextFly( this ); + SwRect aRect; + bool bFirstFlyCheck = 0 != getFramePrintArea().Height(); + if ( !bCollapse && bFirstFlyCheck && + aTextFly.IsOn() && aTextFly.IsAnyObj( aRect ) && !bHasNonLastSplitFlyDrawObj ) + return false; + + if (IsEmptyWithSplitFly()) + { + // We don't want this optimization in case the paragraph is not really empty, because it has + // a fly frame and it also needs space for the empty paragraph in a next line. + return false; + } + + // only need to check one node because of early return on GetMerged() + for (SwContentIndex const* pIndex = GetTextNodeFirst()->GetFirstIndex(); + pIndex; pIndex = pIndex->GetNext()) + { + sw::mark::IMark const*const pMark = pIndex->GetMark(); + if (dynamic_cast(pMark) != nullptr) + { // need bookmark portions! + return false; + } + } + + SwTwips nHeight = EmptyHeight(); + + if (aSet.GetParaGrid().GetValue() && + IsInDocBody() ) + { + SwTextGridItem const*const pGrid(GetGridItem(FindPageFrame())); + if ( pGrid ) + nHeight = pGrid->GetBaseHeight() + pGrid->GetRubyHeight(); + } + + SwRectFnSet aRectFnSet(this); + SwTwips nChg = nHeight - aRectFnSet.GetHeight(getFramePrintArea()); + const SwBodyFrame* pBody = FindBodyFrame(); + if (pNonLastSplitFlyDrawObj && pBody) + { + // See if we need to increase the text frame height due to split flys. This is necessary for + // anchors of inner floating tables, where moving to a next page moves indirectly, so we + // want a correct text frame height. + SwTwips nFrameBottom = aRectFnSet.GetBottom(getFrameArea()) + nChg; + SwTwips nFlyBottom = aRectFnSet.GetBottom(pNonLastSplitFlyDrawObj->getFrameArea()); + SwTwips nBodyBottom = aRectFnSet.GetBottom(pBody->getFrameArea()); + if (nFlyBottom > nBodyBottom) + { + // This is the legacy case where flys may overlap with footer frames. + nFlyBottom = nBodyBottom; + } + if (pNonLastSplitFlyDrawObj->isFrameAreaPositionValid() && nFlyBottom > nFrameBottom) + { + nChg += (nFlyBottom - nFrameBottom); + } + } + + if( !nChg ) + SetUndersized( false ); + AdjustFrame( nChg ); + + if (GetHasRotatedPortions()) + { + ClearPara(); + SetHasRotatedPortions(false); + } + + RemoveFromCache(); + if( !IsEmpty() ) + { + SetEmpty( true ); + SetCompletePaint(); + } + if( !bCollapse && !bFirstFlyCheck && + aTextFly.IsOn() && aTextFly.IsAnyObj( aRect ) ) + return false; + + // #i35635# - call method + // to assure that objects anchored at the empty paragraph are + // correctly visible resp. invisible. + HideAndShowObjects(); + return true; +} + +bool SwTextFrame::FillRegister( SwTwips& rRegStart, sal_uInt16& rRegDiff ) +{ + const SwFrame *pFrame = this; + rRegDiff = 0; + while( !( ( SwFrameType::Body | SwFrameType::Fly ) + & pFrame->GetType() ) && pFrame->GetUpper() ) + pFrame = pFrame->GetUpper(); + if( ( SwFrameType::Body| SwFrameType::Fly ) & pFrame->GetType() ) + { + SwRectFnSet aRectFnSet(pFrame); + rRegStart = aRectFnSet.GetPrtTop(*pFrame); + pFrame = pFrame->FindPageFrame(); + if( pFrame->IsPageFrame() ) + { + SwPageDesc* pDesc = const_cast(static_cast(pFrame))->FindPageDesc(); + if( pDesc ) + { + rRegDiff = pDesc->GetRegHeight(); + if( !rRegDiff ) + { + const SwTextFormatColl *pFormat = pDesc->GetRegisterFormatColl(); + if( pFormat ) + { + const SvxLineSpacingItem &rSpace = pFormat->GetLineSpacing(); + if( SvxLineSpaceRule::Fix == rSpace.GetLineSpaceRule() ) + { + rRegDiff = rSpace.GetLineHeight(); + pDesc->SetRegHeight( rRegDiff ); + pDesc->SetRegAscent( ( 4 * rRegDiff ) / 5 ); + } + else + { + SwViewShell *pSh = getRootFrame()->GetCurrShell(); + SwFontAccess aFontAccess( pFormat, pSh ); + SwFont aFnt( aFontAccess.Get()->GetFont() ); + + OutputDevice *pOut = nullptr; + if( !pSh || !pSh->GetViewOptions()->getBrowseMode() || + pSh->GetViewOptions()->IsPrtFormat() ) + pOut = GetDoc().getIDocumentDeviceAccess().getReferenceDevice( true ); + + if( pSh && !pOut ) + pOut = pSh->GetWin()->GetOutDev(); + + if( !pOut ) + pOut = Application::GetDefaultDevice(); + + MapMode aOldMap( pOut->GetMapMode() ); + pOut->SetMapMode( MapMode( MapUnit::MapTwip ) ); + + aFnt.ChgFnt( pSh, *pOut ); + rRegDiff = aFnt.GetHeight( pSh, *pOut ); + sal_uInt16 nNetHeight = rRegDiff; + + switch( rSpace.GetLineSpaceRule() ) + { + case SvxLineSpaceRule::Auto: + break; + case SvxLineSpaceRule::Min: + { + if( rRegDiff < rSpace.GetLineHeight() ) + rRegDiff = rSpace.GetLineHeight(); + break; + } + default: + OSL_FAIL( ": unknown LineSpaceRule" ); + } + switch( rSpace.GetInterLineSpaceRule() ) + { + case SvxInterLineSpaceRule::Off: + break; + case SvxInterLineSpaceRule::Prop: + { + tools::Long nTmp = rSpace.GetPropLineSpace(); + if( nTmp < 50 ) + nTmp = nTmp ? 50 : 100; + nTmp *= rRegDiff; + nTmp /= 100; + if( !nTmp ) + ++nTmp; + rRegDiff = o3tl::narrowing(nTmp); + nNetHeight = rRegDiff; + break; + } + case SvxInterLineSpaceRule::Fix: + { + rRegDiff = rRegDiff + rSpace.GetInterLineSpace(); + nNetHeight = rRegDiff; + break; + } + default: OSL_FAIL( ": unknown InterLineSpaceRule" ); + } + pDesc->SetRegHeight( rRegDiff ); + pDesc->SetRegAscent( rRegDiff - nNetHeight + + aFnt.GetAscent( pSh, *pOut ) ); + pOut->SetMapMode( aOldMap ); + } + } + } + const tools::Long nTmpDiff = pDesc->GetRegAscent() - rRegDiff; + if ( aRectFnSet.IsVert() ) + rRegStart -= nTmpDiff; + else + rRegStart += nTmpDiff; + } + } + } + return ( 0 != rRegDiff ); +} + +void SwHiddenTextPortion::Paint( const SwTextPaintInfo & rInf) const +{ +#ifdef DBG_UTIL + OutputDevice* pOut = const_cast(rInf.GetOut()); + Color aCol( rInf.GetOpt().GetFieldShadingsColor() ); + Color aOldColor( pOut->GetFillColor() ); + pOut->SetFillColor( aCol ); + Point aPos( rInf.GetPos() ); + aPos.AdjustY( -150 ); + aPos.AdjustX( -25 ); + SwRect aRect( aPos, Size( 100, 200 ) ); + pOut->DrawRect( aRect.SVRect() ); + pOut->SetFillColor( aOldColor ); +#else + (void)rInf; +#endif +} + +bool SwHiddenTextPortion::Format( SwTextFormatInfo &rInf ) +{ + Width( 0 ); + rInf.GetTextFrame()->HideFootnotes( rInf.GetIdx(), rInf.GetIdx() + GetLen() ); + + return false; +}; + +bool SwControlCharPortion::DoPaint(SwTextPaintInfo const& rTextPaintInfo, + OUString & rOutString, SwFont & rTmpFont, int &) const +{ + if (mcChar == CHAR_WJ || !rTextPaintInfo.GetOpt().IsFieldShadings()) + { + return false; + } + + switch (mcChar) + { + case CHAR_ZWSP: + rOutString = "/"; break; +// case CHAR_LRM : +// rText = sal_Unicode(0x2514); break; +// case CHAR_RLM : +// rText = sal_Unicode(0x2518); break; + default: + assert(false); + break; + } + + rTmpFont.SetEscapement( CHAR_ZWSP == mcChar ? DFLT_ESC_AUTO_SUB : -25 ); + const sal_uInt16 nProp = 40; + rTmpFont.SetProportion( nProp ); // a smaller font + + return true; +} + +bool SwBookmarkPortion::DoPaint(SwTextPaintInfo const& rTextPaintInfo, + OUString & rOutString, SwFont & rFont, int & rDeltaY) const +{ + // custom color is visible without field shading, too + if (!rTextPaintInfo.GetOpt().IsShowBookmarks()) + { + return false; + } + + rOutString = OUStringChar(mcChar); + + // init font: we want OpenSymbol to ensure it doesn't look too crazy; + // thin and a bit higher than the surrounding text + auto const nOrigAscent(rFont.GetAscent(rTextPaintInfo.GetVsh(), *rTextPaintInfo.GetOut())); + rFont.SetName("OpenSymbol", rFont.GetActual()); + Size aSize(rFont.GetSize(rFont.GetActual())); + // use also the external leading (line gap) of the portion, but don't use + // 100% of it because i can't figure out how to baseline align that + assert(aSize.Height() != 0); + auto const nFactor = aSize.Height() > 0 ? (Height() * 95) / aSize.Height() : Height(); + rFont.SetProportion(nFactor); + rFont.SetWeight(WEIGHT_THIN, rFont.GetActual()); + rFont.SetColor(rTextPaintInfo.GetOpt().GetFieldShadingsColor()); + // reset these to default... + rFont.SetAlign(ALIGN_BASELINE); + rFont.SetUnderline(LINESTYLE_NONE); + rFont.SetOverline(LINESTYLE_NONE); + rFont.SetStrikeout(STRIKEOUT_NONE); + rFont.SetOutline(false); + rFont.SetShadow(false); + rFont.SetTransparent(false); + rFont.SetEmphasisMark(FontEmphasisMark::NONE); + rFont.SetEscapement(0); + rFont.SetPitch(PITCH_DONTKNOW, rFont.GetActual()); + rFont.SetRelief(FontRelief::NONE); + + // adjust Y position to account for different baselines of the fonts + auto const nOSAscent(rFont.GetAscent(rTextPaintInfo.GetVsh(), *rTextPaintInfo.GetOut())); + rDeltaY = nOSAscent - nOrigAscent; + + return true; +} + +void SwControlCharPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + if ( !Width() ) // is only set during prepaint mode + return; + + rInf.DrawViewOpt(*this, GetWhichPor()); + + int deltaY(0); + SwFont aTmpFont( *rInf.GetFont() ); + OUString aOutString; + + if (!(rInf.OnWin() + && !rInf.GetOpt().IsPagePreview() + && !rInf.GetOpt().IsReadonly() + && DoPaint(rInf, aOutString, aTmpFont, deltaY))) + return; + + SwFontSave aFontSave( rInf, &aTmpFont ); + + if ( !mnHalfCharWidth ) + mnHalfCharWidth = rInf.GetTextSize( aOutString ).Width() / 2; + + Point aOldPos = rInf.GetPos(); + Point aNewPos( aOldPos ); + auto const deltaX((Width() / 2) - mnHalfCharWidth); + switch (rInf.GetFont()->GetOrientation(rInf.GetTextFrame()->IsVertical()).get()) + { + case 0: + aNewPos.AdjustX(deltaX); + aNewPos.AdjustY(deltaY); + break; + case 900: + aNewPos.AdjustY(-deltaX); + aNewPos.AdjustX(deltaY); + break; + case 2700: + aNewPos.AdjustY(deltaX); + aNewPos.AdjustX(-deltaY); + break; + default: + assert(false); + break; + } + const_cast< SwTextPaintInfo& >( rInf ).SetPos( aNewPos ); + + rInf.DrawText( aOutString, *this ); + + const_cast< SwTextPaintInfo& >( rInf ).SetPos( aOldPos ); +} + +void SwBookmarkPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + if ( !Width() ) // is only set during prepaint mode + return; + + rInf.DrawViewOpt(*this, GetWhichPor()); + + int deltaY(0); + SwFont aTmpFont( *rInf.GetFont() ); + OUString aOutString; + + if (!(rInf.OnWin() + && !rInf.GetOpt().IsPagePreview() + && !rInf.GetOpt().IsReadonly() + && DoPaint(rInf, aOutString, aTmpFont, deltaY))) + return; + + SwFontSave aFontSave( rInf, &aTmpFont ); + + if ( !mnHalfCharWidth ) + mnHalfCharWidth = rInf.GetTextSize( aOutString ).Width() / 2; + + Point aOldPos = rInf.GetPos(); + Point aNewPos( aOldPos ); + auto const deltaX((Width() / 2) - mnHalfCharWidth); + switch (rInf.GetFont()->GetOrientation(rInf.GetTextFrame()->IsVertical()).get()) + { + case 0: + aNewPos.AdjustX(deltaX); + aNewPos.AdjustY(deltaY); + break; + case 900: + aNewPos.AdjustY(-deltaX); + aNewPos.AdjustX(deltaY); + break; + case 2700: + aNewPos.AdjustY(deltaX); + aNewPos.AdjustX(-deltaY); + break; + default: + assert(false); + break; + } + + // draw end marks before the character position + if ( m_nStart == 0 || m_nEnd == 0 ) + { + // single type boundary marks are there outside of the bookmark text + // some |text| here + // [[ ]] + if (m_nStart > 1) + aNewPos.AdjustX(static_cast(mnHalfCharWidth) * -2 * (m_oColors.size() - 1)); + } + else if ( m_nStart != 0 && m_nEnd != 0 ) + // both end and start boundary marks: adjust them around the bookmark position + // |te|xt| + // ]] [[ + aNewPos.AdjustX(static_cast(mnHalfCharWidth) * -(2 * m_nEnd - 1 + m_nPoint) ); + + const_cast< SwTextPaintInfo& >( rInf ).SetPos( aNewPos ); + + for ( const auto& it : m_oColors ) + { + // set bold for custom colored bookmark symbol + // and draw multiple symbols showing all custom colors + aTmpFont.SetWeight( COL_TRANSPARENT == std::get<1>(it) ? WEIGHT_THIN : WEIGHT_BOLD, aTmpFont.GetActual() ); + aTmpFont.SetColor( COL_TRANSPARENT == std::get<1>(it) ? rInf.GetOpt().GetFieldShadingsColor() : std::get<1>(it) ); + aOutString = OUString(std::get<0>(it) == SwScriptInfo::MarkKind::Start ? '[' : ']'); + + // MarkKind::Point: drawn I-beam (e.g. U+2336) as overlapping ][ + if ( std::get<0>(it) == SwScriptInfo::MarkKind::Point ) + { + aNewPos.AdjustX(-mnHalfCharWidth * 5/16); + const_cast< SwTextPaintInfo& >( rInf ).SetPos( aNewPos ); + rInf.DrawText( aOutString, *this ); + + // when the overlapping vertical lines are 50 pixel width on the screen, + // this distance (half width * 5/8) still results precise overlapping + aNewPos.AdjustX(mnHalfCharWidth * 5/8); + const_cast< SwTextPaintInfo& >( rInf ).SetPos( aNewPos ); + aOutString = OUString('['); + } + rInf.DrawText( aOutString, *this ); + // place the next symbol after the previous one + // TODO: fix orientation and start/end + aNewPos.AdjustX(mnHalfCharWidth * 2); + const_cast< SwTextPaintInfo& >( rInf ).SetPos( aNewPos ); + } + + const_cast< SwTextPaintInfo& >( rInf ).SetPos( aOldPos ); +} + +void SwBookmarkPortion::HandlePortion( SwPortionHandler& rPH ) const +{ + OUStringBuffer aStr; + for ( const auto& it : m_oColors ) + { + aStr.append("#" + std::get<2>(it) + " " + SwResId(STR_BOOKMARK_DEF_NAME)); + switch (std::get<0>(it)) + { + case SwScriptInfo::MarkKind::Point: + break; + case SwScriptInfo::MarkKind::Start: + aStr.append(" " + SwResId(STR_CAPTION_BEGINNING)); + break; + case SwScriptInfo::MarkKind::End: + aStr.append(" " + SwResId(STR_CAPTION_END)); + break; + } + } + + rPH.Special( GetLen(), aStr.makeStringAndClear(), GetWhichPor() ); +} + +void SwBookmarkPortion::dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, TextFrameIndex& nOffset) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwBookmarkPortion")); + dumpAsXmlAttributes(pWriter, rText, nOffset); + nOffset += GetLen(); + + if (!m_oColors.empty()) + { + OUStringBuffer aStr; + for (const auto& rColor : m_oColors) + { + aStr.append("#" + std::get<2>(rColor) + " " + SwResId(STR_BOOKMARK_DEF_NAME)); + switch (std::get<0>(rColor)) + { + case SwScriptInfo::MarkKind::Point: + break; + case SwScriptInfo::MarkKind::Start: + aStr.append(" " + SwResId(STR_CAPTION_BEGINNING)); + break; + case SwScriptInfo::MarkKind::End: + aStr.append(" " + SwResId(STR_CAPTION_END)); + break; + } + } + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("colors"), + BAD_CAST(aStr.makeStringAndClear().toUtf8().getStr())); + } + + (void)xmlTextWriterEndElement(pWriter); +} + +bool SwControlCharPortion::Format( SwTextFormatInfo &rInf ) +{ + const SwLinePortion* pRoot = rInf.GetRoot(); + Width( 0 ); + Height( pRoot->Height() ); + SetAscent( pRoot->GetAscent() ); + + return false; +} + +sal_uInt16 SwControlCharPortion::GetViewWidth( const SwTextSizeInfo& rInf ) const +{ + if( !mnViewWidth ) + mnViewWidth = rInf.GetTextSize(OUString(' ')).Width(); + + return mnViewWidth; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/porrst.hxx b/sw/source/core/text/porrst.hxx new file mode 100644 index 0000000000..c5e57c688a --- /dev/null +++ b/sw/source/core/text/porrst.hxx @@ -0,0 +1,222 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#pragma once + +#include + +#include +#include +#include +#include +#include + +#include "porlin.hxx" +#include "portxt.hxx" +#include "possiz.hxx" + +class SwPortionHandler; +class SwTextPaintInfo; +class SwTextSizeInfo; +class SwFont; + +#define LINE_BREAK_WIDTH 150 +#define SPECIAL_FONT_HEIGHT 200 + +class SwTextFormatInfo; + +class SwTmpEndPortion : public SwLinePortion +{ + const FontLineStyle m_eUnderline; + const FontStrikeout m_eStrikeout; + Color m_aColor; + +public: + explicit SwTmpEndPortion( const SwLinePortion &rPortion, + const FontLineStyle eUnderline, + const FontStrikeout eStrikeout, + const Color& rColor ); + virtual void Paint( const SwTextPaintInfo &rInf ) const override; +}; + +enum class SwLineBreakClear; + +class SwBreakPortion : public SwLinePortion +{ + RedlineType m_eRedline; + + /// Tracks the type of the breaking clear from SwTextLineBreak, if there is one. + SwLineBreakClear m_eClear; + + /// Height of the line-break character itself, without spacing added for clearing. + SwTwips m_nTextHeight; + +public: + explicit SwBreakPortion(const SwLinePortion& rPortion, const SwTextAttr* pAttr); + // Returns 0 if we have no usable data + virtual SwLinePortion *Compress() override; + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + virtual bool Format( SwTextFormatInfo &rInf ) override; + virtual sal_uInt16 GetViewWidth( const SwTextSizeInfo &rInf ) const override; + virtual TextFrameIndex GetModelPositionForViewPoint(sal_uInt16 nOfst) const override; + + // Accessibility: pass information about this portion to the PortionHandler + virtual void HandlePortion( SwPortionHandler& rPH ) const override; + + void dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, + TextFrameIndex& nOffset) const override; + + static constexpr OUString S_NOBREAK_FOR_REDLINE = u"\u00A0"_ustr; + void SetRedline( const RedlineType eRedline ) { m_eRedline = eRedline; } + + SwLineBreakClear GetClear() const; +}; + +class SwKernPortion : public SwLinePortion +{ + short m_nKern; + bool m_bBackground; + bool m_bGridKern; + +public: + + // This constructor automatically appends the portion to rPortion + // bBG indicates, that the background of the kerning portion has to + // be painted, e.g., if the portion if positioned between to fields. + // bGridKern indicates, that the kerning portion is used to provide + // additional space in grid mode. + SwKernPortion( SwLinePortion &rPortion, short nKrn, + bool bBG = false, bool bGridKern = false ); + + // This constructor only sets the height and ascent to the values + // of rPortion. It is only used for kerning portions for grid mode + explicit SwKernPortion( const SwLinePortion &rPortion ); + + virtual void FormatEOL( SwTextFormatInfo &rInf ) override; + virtual void Paint( const SwTextPaintInfo &rInf ) const override; +}; + +/// Indicator that the content does not fit into a fixed height frame (red triangle on the UI). +class SwArrowPortion : public SwLinePortion +{ + Point m_aPos; + bool m_bLeft; +public: + explicit SwArrowPortion( const SwLinePortion &rPortion ); + explicit SwArrowPortion( const SwTextPaintInfo &rInf ); + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + virtual SwLinePortion *Compress() override; + bool IsLeft() const { return m_bLeft; } + const Point& GetPos() const { return m_aPos; } +}; + +// The characters which are forbidden at the start of a line like the dot and +// other punctuation marks are allowed to display in the margin of the page +// by a user option. +// The SwHangingPortion is the corresponding textportion to do that. +class SwHangingPortion : public SwTextPortion +{ + sal_uInt16 m_nInnerWidth; +public: + explicit SwHangingPortion( SwPosSize aSize ) : m_nInnerWidth( aSize.Width() ) + { + SetWhichPor( PortionType::Hanging ); + SetLen(TextFrameIndex(1)); + Height( aSize.Height() ); + } + + sal_uInt16 GetInnerWidth() const { return m_nInnerWidth; } +}; + +// Used to hide text +class SwHiddenTextPortion : public SwLinePortion +{ +public: + explicit SwHiddenTextPortion(TextFrameIndex const nLen) + { + SetWhichPor( PortionType::HiddenText ); SetLen( nLen ); + } + + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + virtual bool Format( SwTextFormatInfo &rInf ) override; +}; + +class SwControlCharPortion : public SwLinePortion +{ + +private: + mutable sal_uInt16 mnViewWidth; // used to cache a calculated value +protected: + mutable sal_uInt16 mnHalfCharWidth; // used to cache a calculated value + sal_Unicode mcChar; + +public: + + explicit SwControlCharPortion( sal_Unicode cChar ) + : mnViewWidth( 0 ), mnHalfCharWidth( 0 ), mcChar( cChar ) + { + SetWhichPor( PortionType::ControlChar ); SetLen( TextFrameIndex(1) ); + } + + virtual bool DoPaint(SwTextPaintInfo const& rInf, + OUString & rOutString, SwFont & rTmpFont, int & rDeltaY) const; + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + virtual bool Format( SwTextFormatInfo &rInf ) override; + virtual sal_uInt16 GetViewWidth( const SwTextSizeInfo& rInf ) const override; +}; + +/// for showing bookmark starts and ends; note that in contrast to +/// SwControlCharPortion these do not have a character in the text. +class SwBookmarkPortion : public SwControlCharPortion +{ + // custom colors defined by metadata + std::vector> m_oColors; + // number of MarkKind marks + sal_Int16 m_nStart, m_nEnd, m_nPoint; + bool m_bHasCustomColor; + +public: + explicit SwBookmarkPortion(sal_Unicode const cChar, std::vector>rColors) + : SwControlCharPortion(cChar), m_oColors(rColors), m_nStart(0), m_nEnd(0), m_nPoint(0), m_bHasCustomColor(false) + { + SetWhichPor(PortionType::Bookmark); + SetLen(TextFrameIndex(0)); + for (const auto& it : m_oColors) + { + if (std::get<0>(it) == SwScriptInfo::MarkKind::Start) + m_nStart++; + else if (std::get<0>(it) == SwScriptInfo::MarkKind::End) + m_nEnd++; + else + m_nPoint++; + + if (!m_bHasCustomColor && COL_TRANSPARENT != std::get<1>(it)) + m_bHasCustomColor = true; + } + } + + virtual bool DoPaint(SwTextPaintInfo const& rInf, + OUString & rOutString, SwFont & rTmpFont, int & rDeltaY) const override; + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + virtual SwLinePortion * Compress() override { return this; } + virtual void HandlePortion(SwPortionHandler& rPH) const override; + void dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, + TextFrameIndex& rOffset) const override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/portab.hxx b/sw/source/core/text/portab.hxx new file mode 100644 index 0000000000..9ffe7be506 --- /dev/null +++ b/sw/source/core/text/portab.hxx @@ -0,0 +1,111 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#pragma once + +#include "porglue.hxx" + +class SwTabPortion : public SwFixPortion +{ + const sal_uInt16 m_nTabPos; + const sal_Unicode m_cFill; + const bool m_bAutoTabStop; + + // Format() branches either into PreFormat() or PostFormat() + bool PreFormat( SwTextFormatInfo &rInf ); +public: + SwTabPortion( const sal_uInt16 nTabPos, const sal_Unicode cFill, const bool bAutoTab = true ); + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + virtual bool Format( SwTextFormatInfo &rInf ) override; + virtual void FormatEOL( SwTextFormatInfo &rInf ) override; + bool PostFormat( SwTextFormatInfo &rInf ); + bool IsFilled() const { return 0 != m_cFill; } + sal_uInt16 GetTabPos() const { return m_nTabPos; } + + // Accessibility: pass information about this portion to the PortionHandler + virtual void HandlePortion( SwPortionHandler& rPH ) const override; +}; + +class SwTabLeftPortion : public SwTabPortion +{ +public: + SwTabLeftPortion( const sal_uInt16 nTabPosVal, const sal_Unicode cFillChar, bool bAutoTab ) + : SwTabPortion( nTabPosVal, cFillChar, bAutoTab ) + { SetWhichPor( PortionType::TabLeft ); } +}; + +class SwTabRightPortion : public SwTabPortion +{ +public: + SwTabRightPortion( const sal_uInt16 nTabPosVal, const sal_Unicode cFillChar ) + : SwTabPortion( nTabPosVal, cFillChar ) + { SetWhichPor( PortionType::TabRight ); } +}; + +class SwTabCenterPortion : public SwTabPortion +{ +public: + SwTabCenterPortion( const sal_uInt16 nTabPosVal, const sal_Unicode cFillChar ) + : SwTabPortion( nTabPosVal, cFillChar ) + { SetWhichPor( PortionType::TabCenter ); } +}; + +class SwTabDecimalPortion : public SwTabPortion +{ + const sal_Unicode mcTab; + + /* + * During text formatting, we already store the width of the portions + * following the tab stop up to the decimal position. This value is + * evaluated during pLastTab->FormatEOL. FME 2006-01-06 #127428#. + */ + sal_uInt16 mnWidthOfPortionsUpTpDecimalPosition; + +public: + SwTabDecimalPortion( const sal_uInt16 nTabPosVal, const sal_Unicode cTab, + const sal_Unicode cFillChar ) + : SwTabPortion( nTabPosVal, cFillChar ), + mcTab(cTab), + mnWidthOfPortionsUpTpDecimalPosition( USHRT_MAX ) + { SetWhichPor( PortionType::TabDecimal ); } + + sal_Unicode GetTabDecimal() const { return mcTab; } + + void SetWidthOfPortionsUpToDecimalPosition( sal_uInt16 nNew ) + { + mnWidthOfPortionsUpTpDecimalPosition = nNew; + } + sal_uInt16 GetWidthOfPortionsUpToDecimalPosition() const + { + return mnWidthOfPortionsUpTpDecimalPosition; + } +}; + +class SwAutoTabDecimalPortion : public SwTabDecimalPortion +{ +public: + SwAutoTabDecimalPortion( const sal_uInt16 nTabPosVal, const sal_Unicode cTab, + const sal_Unicode cFillChar ) + : SwTabDecimalPortion( nTabPosVal, cTab, cFillChar ) + { + SetLen(TextFrameIndex(0)); + } + virtual void Paint( const SwTextPaintInfo &rInf ) const override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/portox.cxx b/sw/source/core/text/portox.cxx new file mode 100644 index 0000000000..bd72e83b04 --- /dev/null +++ b/sw/source/core/text/portox.cxx @@ -0,0 +1,77 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include + +#include "portox.hxx" +#include "inftxt.hxx" + +void SwToxPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + if( Width() ) + { + rInf.DrawViewOpt( *this, PortionType::Tox ); + SwTextPortion::Paint( rInf ); + } +} + +SwLinePortion *SwIsoToxPortion::Compress() { return this; } + +SwIsoToxPortion::SwIsoToxPortion() : m_nViewWidth(0) +{ + SetLen(TextFrameIndex(1)); + SetWhichPor( PortionType::IsoTox ); +} + +sal_uInt16 SwIsoToxPortion::GetViewWidth( const SwTextSizeInfo &rInf ) const +{ + // Although we are const, nViewWidth should be calculated in the last + // moment possible + SwIsoToxPortion* pThis = const_cast(this); + // nViewWidth need to be calculated + if( !Width() && rInf.OnWin() && + !rInf.GetOpt().IsPagePreview() && + !rInf.GetOpt().IsReadonly() && rInf.GetOpt().IsFieldShadings() ) + { + if( !m_nViewWidth ) + pThis->m_nViewWidth = rInf.GetTextSize(OUString(' ')).Width(); + } + else + pThis->m_nViewWidth = 0; + return m_nViewWidth; +} + +bool SwIsoToxPortion::Format( SwTextFormatInfo &rInf ) +{ + return SwLinePortion::Format( rInf ); +} + +void SwIsoToxPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + if( Width() ) + rInf.DrawViewOpt( *this, PortionType::Tox ); +} + +void SwIsoToxPortion::HandlePortion( SwPortionHandler& rPH ) const +{ + rPH.Special( GetLen(), OUString(), GetWhichPor() ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/portox.hxx b/sw/source/core/text/portox.hxx new file mode 100644 index 0000000000..07d7c44fb2 --- /dev/null +++ b/sw/source/core/text/portox.hxx @@ -0,0 +1,46 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include "portxt.hxx" + +class SwToxPortion : public SwTextPortion +{ +public: + SwToxPortion() { SetWhichPor(PortionType::Tox); } + virtual void Paint(const SwTextPaintInfo& rInf) const override; +}; + +class SwIsoToxPortion : public SwToxPortion +{ + sal_uInt16 m_nViewWidth; + +public: + SwIsoToxPortion(); + virtual bool Format(SwTextFormatInfo& rInf) override; + virtual void Paint(const SwTextPaintInfo& rInf) const override; + virtual SwLinePortion* Compress() override; + virtual sal_uInt16 GetViewWidth(const SwTextSizeInfo& rInf) const override; + + // Accessibility: pass information about this portion to the PortionHandler + virtual void HandlePortion(SwPortionHandler& rPH) const override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/portxt.cxx b/sw/source/core/text/portxt.cxx new file mode 100644 index 0000000000..85691ef21e --- /dev/null +++ b/sw/source/core/text/portxt.cxx @@ -0,0 +1,925 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include +#include +#include +#include +#include +#include +#include "porlay.hxx" +#include "inftxt.hxx" +#include "guess.hxx" +#include "porfld.hxx" +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +using namespace ::sw::mark; +using namespace ::com::sun::star; +using namespace ::com::sun::star::i18n::ScriptType; + +// Returns for how many characters an extra space has to be added +// (for justified alignment). +static TextFrameIndex lcl_AddSpace(const SwTextSizeInfo &rInf, + const OUString* pStr, const SwLinePortion& rPor) +{ + TextFrameIndex nPos, nEnd; + const SwScriptInfo* pSI = nullptr; + + if ( pStr ) + { + // passing a string means we are inside a field + nPos = TextFrameIndex(0); + nEnd = TextFrameIndex(pStr->getLength()); + } + else + { + nPos = rInf.GetIdx(); + nEnd = rInf.GetIdx() + rPor.GetLen(); + pStr = &rInf.GetText(); + pSI = &const_cast(rInf.GetParaPortion())->GetScriptInfo(); + } + + TextFrameIndex nCnt(0); + sal_uInt8 nScript = 0; + + // If portion consists of Asian characters and language is not + // Korean, we add extra space to each character. + // first we get the script type + if ( pSI ) + nScript = pSI->ScriptType( nPos ); + else + nScript = static_cast( + g_pBreakIt->GetBreakIter()->getScriptType(*pStr, sal_Int32(nPos))); + + // Note: rInf.GetIdx() can differ from nPos, + // e.g., when rPor is a field portion. nPos refers to the string passed + // to the function, rInf.GetIdx() refers to the original string. + + // We try to find out which justification mode is required. This is done by + // evaluating the script type and the language attribute set for this portion + + // Asian Justification: Each character get some extra space + if ( nEnd > nPos && ASIAN == nScript ) + { + LanguageType aLang = + rInf.GetTextFrame()->GetLangOfChar(rInf.GetIdx(), nScript); + + if (!MsLangId::isKorean(aLang)) + { + const SwLinePortion* pPor = rPor.GetNextPortion(); + if ( pPor && ( pPor->IsKernPortion() || + pPor->IsControlCharPortion() || + pPor->IsPostItsPortion() ) ) + pPor = pPor->GetNextPortion(); + + nCnt += SwScriptInfo::CountCJKCharacters( *pStr, nPos, nEnd, aLang ); + + if ( !pPor || pPor->IsHolePortion() || pPor->InFixMargGrp() || + pPor->IsBreakPortion() ) + --nCnt; + + return nCnt; + } + } + + // Kashida Justification: Insert Kashidas + if ( nEnd > nPos && pSI && COMPLEX == nScript ) + { + if ( SwScriptInfo::IsArabicText( *pStr, nPos, nEnd - nPos ) && pSI->CountKashida() ) + { + const sal_Int32 nKashRes = pSI->KashidaJustify(nullptr, nullptr, nPos, nEnd - nPos); + // i60591: need to check result of KashidaJustify + // determine if kashida justification is applicable + if (nKashRes != -1) + return TextFrameIndex(nKashRes); + } + } + + // Thai Justification: Each character cell gets some extra space + if ( nEnd > nPos && COMPLEX == nScript ) + { + LanguageType aLang = + rInf.GetTextFrame()->GetLangOfChar(rInf.GetIdx(), nScript); + + if ( LANGUAGE_THAI == aLang ) + { + nCnt = SwScriptInfo::ThaiJustify(*pStr, nullptr, nPos, nEnd - nPos); + + const SwLinePortion* pPor = rPor.GetNextPortion(); + if ( pPor && ( pPor->IsKernPortion() || + pPor->IsControlCharPortion() || + pPor->IsPostItsPortion() ) ) + pPor = pPor->GetNextPortion(); + + if ( nCnt && ( ! pPor || pPor->IsHolePortion() || pPor->InFixMargGrp() ) ) + --nCnt; + + return nCnt; + } + } + + // Here starts the good old "Look for blanks and add space to them" part. + // Note: We do not want to add space to an isolated latin blank in front + // of some complex characters in RTL environment + const bool bDoNotAddSpace = + LATIN == nScript && (nEnd == nPos + TextFrameIndex(1)) && pSI && + ( i18n::ScriptType::COMPLEX == + pSI->ScriptType(nPos + TextFrameIndex(1))) && + rInf.GetTextFrame() && rInf.GetTextFrame()->IsRightToLeft(); + + if ( bDoNotAddSpace ) + return nCnt; + + TextFrameIndex nTextEnd = std::min(nEnd, TextFrameIndex(pStr->getLength())); + for ( ; nPos < nTextEnd; ++nPos ) + { + if (CH_BLANK == (*pStr)[ sal_Int32(nPos) ]) + ++nCnt; + } + + // We still have to examine the next character: + // If the next character is ASIAN and not KOREAN we have + // to add an extra space + // nPos refers to the original string, even if a field string has + // been passed to this function + nPos = rInf.GetIdx() + rPor.GetLen(); + if (nPos < TextFrameIndex(rInf.GetText().getLength())) + { + sal_uInt8 nNextScript = 0; + const SwLinePortion* pPor = rPor.GetNextPortion(); + if ( pPor && pPor->IsKernPortion() ) + pPor = pPor->GetNextPortion(); + + if (!pPor || pPor->InFixMargGrp()) + return nCnt; + + // next character is inside a field? + if ( CH_TXTATR_BREAKWORD == rInf.GetChar( nPos ) && pPor->InExpGrp() ) + { + bool bOldOnWin = rInf.OnWin(); + const_cast(rInf).SetOnWin( false ); + + OUString aStr; + pPor->GetExpText( rInf, aStr ); + const_cast(rInf).SetOnWin( bOldOnWin ); + + nNextScript = static_cast(g_pBreakIt->GetBreakIter()->getScriptType( aStr, 0 )); + } + else + nNextScript = static_cast( + g_pBreakIt->GetBreakIter()->getScriptType(rInf.GetText(), sal_Int32(nPos))); + + if( ASIAN == nNextScript ) + { + LanguageType aLang = + rInf.GetTextFrame()->GetLangOfChar(nPos, nNextScript); + + if (!MsLangId::isKorean(aLang)) + ++nCnt; + } + } + + return nCnt; +} + +SwTextPortion * SwTextPortion::CopyLinePortion(const SwLinePortion &rPortion) +{ + SwTextPortion *const pNew(new SwTextPortion); + static_cast(*pNew) = rPortion; + pNew->SetWhichPor( PortionType::Text ); // overwrite that! + return pNew; +} + +void SwTextPortion::BreakCut( SwTextFormatInfo &rInf, const SwTextGuess &rGuess ) +{ + // The word/char is larger than the line + // Special case 1: The word is larger than the line + // We truncate ... + const sal_uInt16 nLineWidth = o3tl::narrowing(rInf.Width() - rInf.X()); + TextFrameIndex nLen = rGuess.CutPos() - rInf.GetIdx(); + if (nLen > TextFrameIndex(0)) + { + // special case: guess does not always provide the correct + // width, only in common cases. + if ( !rGuess.BreakWidth() ) + { + rInf.SetLen( nLen ); + SetLen( nLen ); + CalcTextSize( rInf ); + + // changing these values requires also changing them in + // guess.cxx + sal_uInt16 nItalic = 0; + if( ITALIC_NONE != rInf.GetFont()->GetItalic() && !rInf.NotEOL() ) + { + nItalic = Height() / 12; + } + Width( Width() + nItalic ); + } + else + { + Width( rGuess.BreakWidth() ); + SetLen( nLen ); + } + } + // special case: first character does not fit to line + else if ( rGuess.CutPos() == rInf.GetLineStart() ) + { + SetLen( TextFrameIndex(1) ); + Width( nLineWidth ); + } + else + { + SetLen( TextFrameIndex(0) ); + Width( 0 ); + } +} + +void SwTextPortion::BreakUnderflow( SwTextFormatInfo &rInf ) +{ + Truncate(); + Height( 0 ); + Width( 0 ); + SetLen( TextFrameIndex(0) ); + SetAscent( 0 ); + rInf.SetUnderflow( this ); +} + +static bool lcl_HasContent( const SwFieldPortion& rField, SwTextFormatInfo const &rInf ) +{ + OUString aText; + return rField.GetExpText( rInf, aText ) && !aText.isEmpty(); +} + +bool SwTextPortion::Format_( SwTextFormatInfo &rInf ) +{ + // 5744: If only the hyphen does not fit anymore, we still need to wrap + // the word, or else return true! + if( rInf.IsUnderflow() && rInf.GetSoftHyphPos() ) + { + // soft hyphen portion has triggered an underflow event because + // of an alternative spelling position + bool bFull = false; + const bool bHyph = rInf.ChgHyph( true ); + if( rInf.IsHyphenate() ) + { + SwTextGuess aGuess; + // check for alternative spelling left from the soft hyphen + // this should usually be true but + aGuess.AlternativeSpelling(rInf, rInf.GetSoftHyphPos() - TextFrameIndex(1)); + bFull = CreateHyphen( rInf, aGuess ); + OSL_ENSURE( bFull, "Problem with hyphenation!!!" ); + } + rInf.ChgHyph( bHyph ); + rInf.SetSoftHyphPos( TextFrameIndex(0) ); + return bFull; + } + + SwTextGuess aGuess; + bool bFull = !aGuess.Guess( *this, rInf, Height() ); + + // tdf#158776 for the last full text portion, call Guess() again to allow more text in the + // adjusted line by shrinking spaces using the know space count from the first Guess() call + const SvxAdjust& rAdjust = rInf.GetTextFrame()->GetTextNodeForParaProps()->GetSwAttrSet().GetAdjust().GetAdjust(); + if ( bFull && rAdjust == SvxAdjust::Block && + aGuess.BreakPos() != TextFrameIndex(COMPLETE_STRING) && + rInf.GetTextFrame()->GetDoc().getIDocumentSettingAccess().get( + DocumentSettingId::JUSTIFY_LINES_WITH_SHRINKING) && + // tdf#158436 avoid shrinking at underflow, e.g. no-break space after a + // very short word resulted endless loop + !rInf.IsUnderflow() ) + { + sal_Int32 nSpacesInLine(0); + for (sal_Int32 i = sal_Int32(rInf.GetLineStart()); i < sal_Int32(aGuess.BreakPos()); ++i) + { + sal_Unicode cChar = rInf.GetText()[i]; + if ( cChar == CH_BLANK ) + ++nSpacesInLine; + } + + // call with an extra space: shrinking can result a new word in the line + // and a new space before that, which is also a shrank space + // (except if the line was already broken at a soft hyphen, i.e. inside a word) + if ( aGuess.BreakPos() < TextFrameIndex(rInf.GetText().getLength()) && + rInf.GetText()[sal_Int32(aGuess.BreakPos())] != CHAR_SOFTHYPHEN ) + { + ++nSpacesInLine; + } + + bFull = !aGuess.Guess( *this, rInf, Height(), nSpacesInLine ); + } + + // these are the possible cases: + // A Portion fits to current line + // B Portion does not fit to current line but a possible line break + // within the portion has been found by the break iterator, 2 subcases + // B1 break is hyphen + // B2 break is word end + // C Portion does not fit to current line and no possible line break + // has been found by break iterator, 2 subcases: + // C1 break iterator found a possible line break in portion before us + // ==> this break is used (underflow) + // C2 break iterator does not found a possible line break at all: + // ==> line break + + // case A: line not yet full + if ( !bFull ) + { + Width( aGuess.BreakWidth() ); + ExtraBlankWidth(aGuess.ExtraBlankWidth()); + // Caution! + if( !InExpGrp() || InFieldGrp() ) + SetLen( rInf.GetLen() ); + + short nKern = rInf.GetFont()->CheckKerning(); + if( nKern > 0 && rInf.Width() < rInf.X() + Width() + nKern ) + { + nKern = static_cast(rInf.Width() - rInf.X() - Width() - 1); + if( nKern < 0 ) + nKern = 0; + } + if( nKern ) + new SwKernPortion( *this, nKern ); + } + // special case: hanging portion + else if( aGuess.GetHangingPortion() ) + { + Width( aGuess.BreakWidth() ); + SetLen( aGuess.BreakPos() - rInf.GetIdx() ); + aGuess.GetHangingPortion()->SetAscent( GetAscent() ); + Insert( aGuess.ReleaseHangingPortion() ); + } + // breakPos >= index + else if (aGuess.BreakPos() >= rInf.GetIdx() && aGuess.BreakPos() != TextFrameIndex(COMPLETE_STRING)) + { + // case B1 + if( aGuess.HyphWord().is() && aGuess.BreakPos() > rInf.GetLineStart() + && ( aGuess.BreakPos() > rInf.GetIdx() || + ( rInf.GetLast() && ! rInf.GetLast()->IsFlyPortion() ) ) ) + { + CreateHyphen( rInf, aGuess ); + if ( rInf.GetFly() ) + rInf.GetRoot()->SetMidHyph( true ); + else + rInf.GetRoot()->SetEndHyph( true ); + } + // case C1 + // - Footnote portions with fake line start (i.e., not at beginning of line) + // should keep together with the text portion. (Note: no keep together + // with only footnote portions. + // - TabPortions not at beginning of line should keep together with the + // text portion, if they are not followed by a blank + // (work around different definition of tab stop character - breaking or + // non breaking character - in compatibility mode) + else if ( ( IsFootnotePortion() && rInf.IsFakeLineStart() && + + rInf.IsOtherThanFootnoteInside() ) || + ( rInf.GetLast() && + rInf.GetTextFrame()->GetDoc().getIDocumentSettingAccess().get(DocumentSettingId::TAB_COMPAT) && + rInf.GetLast()->InTabGrp() && + rInf.GetLineStart() + rInf.GetLast()->GetLen() < rInf.GetIdx() && + aGuess.BreakPos() == rInf.GetIdx() && + CH_BLANK != rInf.GetChar( rInf.GetIdx() ) && + CH_FULL_BLANK != rInf.GetChar( rInf.GetIdx() ) && + CH_SIX_PER_EM != rInf.GetChar( rInf.GetIdx() ) ) ) + BreakUnderflow( rInf ); + // case B2 + else if( rInf.GetIdx() > rInf.GetLineStart() || + aGuess.BreakPos() > rInf.GetIdx() || + // this is weird: during formatting the follow of a field + // the values rInf.GetIdx and rInf.GetLineStart are replaced + // IsFakeLineStart indicates GetIdx > GetLineStart + rInf.IsFakeLineStart() || + rInf.GetFly() || + rInf.IsFirstMulti() || + ( rInf.GetLast() && + ( rInf.GetLast()->IsFlyPortion() || + ( rInf.GetLast()->InFieldGrp() && + ! rInf.GetLast()->InNumberGrp() && + ! rInf.GetLast()->IsErgoSumPortion() && + lcl_HasContent(*static_cast(rInf.GetLast()),rInf ) ) ) ) ) + { + Width( aGuess.BreakWidth() ); + + SetLen( aGuess.BreakPos() - rInf.GetIdx() ); + + OSL_ENSURE( aGuess.BreakStart() >= aGuess.FieldDiff(), + "Trouble with expanded field portions during line break" ); + TextFrameIndex const nRealStart = aGuess.BreakStart() - aGuess.FieldDiff(); + if( aGuess.BreakPos() < nRealStart && !InExpGrp() ) + { + SwHolePortion *pNew = new SwHolePortion( *this ); + pNew->SetLen( nRealStart - aGuess.BreakPos() ); + pNew->Width(0); + pNew->ExtraBlankWidth( aGuess.ExtraBlankWidth() ); + Insert( pNew ); + + // UAX #14 Unicode Line Breaking Algorithm Non-tailorable Line breaking rule LB6: + // https://www.unicode.org/reports/tr14/#LB6 Do not break before hard line breaks + if (auto ch = rInf.GetChar(aGuess.BreakStart()); !ch || ch == CH_BREAK) + bFull = false; // Keep following SwBreakPortion / para break in the same line + } + } + else // case C2, last exit + BreakCut( rInf, aGuess ); + } + // breakPos < index or no breakpos at all + else + { + bool bFirstPor = rInf.GetLineStart() == rInf.GetIdx(); + if (aGuess.BreakPos() != TextFrameIndex(COMPLETE_STRING) && + aGuess.BreakPos() != rInf.GetLineStart() && + ( !bFirstPor || rInf.GetFly() || rInf.GetLast()->IsFlyPortion() || + rInf.IsFirstMulti() ) && + ( !rInf.GetLast()->IsBlankPortion() || + SwBlankPortion::MayUnderflow(rInf, rInf.GetIdx() - TextFrameIndex(1), true))) + { // case C1 (former BreakUnderflow()) + BreakUnderflow( rInf ); + } + else + // case C2, last exit + BreakCut(rInf, aGuess); + } + + return bFull; +} + +bool SwTextPortion::Format( SwTextFormatInfo &rInf ) +{ + // GetLineWidth() takes care of DocumentSettingId::TAB_OVER_MARGIN. + if( rInf.GetLineWidth() < 0 || (!GetLen() && !InExpGrp()) ) + { + Height( 0 ); + Width( 0 ); + SetLen( TextFrameIndex(0) ); + SetAscent( 0 ); + SetNextPortion( nullptr ); // ???? + return true; + } + + OSL_ENSURE( rInf.RealWidth() || (rInf.X() == rInf.Width()), + "SwTextPortion::Format: missing real width" ); + OSL_ENSURE( Height(), "SwTextPortion::Format: missing height" ); + + return Format_( rInf ); +} + +// Format end of line +// 5083: We can have awkward cases e.g.: +// "from {Santa}" +// Santa wraps, "from " turns into "from" and " " in a justified +// paragraph, in which the glue gets expanded instead of merged +// with the MarginPortion. + +// rInf.nIdx points to the next word, nIdx-1 is the portion's last char +void SwTextPortion::FormatEOL( SwTextFormatInfo &rInf ) +{ + if( ( GetNextPortion() && + ( !GetNextPortion()->IsKernPortion() || GetNextPortion()->GetNextPortion() ) ) || + !GetLen() || + rInf.GetIdx() >= TextFrameIndex(rInf.GetText().getLength()) || + TextFrameIndex(1) >= rInf.GetIdx() || + ' ' != rInf.GetChar(rInf.GetIdx() - TextFrameIndex(1)) || + rInf.GetLast()->IsHolePortion() ) + return; + + // calculate number of blanks + TextFrameIndex nX(rInf.GetIdx() - TextFrameIndex(1)); + TextFrameIndex nHoleLen(1); + while( nX && nHoleLen < GetLen() && CH_BLANK == rInf.GetChar( --nX ) ) + nHoleLen++; + + // First set ourselves and the insert, because there could be + // a SwLineLayout + sal_uInt16 nBlankSize; + if( nHoleLen == GetLen() ) + nBlankSize = Width(); + else + nBlankSize = sal_Int32(nHoleLen) * rInf.GetTextSize(OUString(' ')).Width(); + Width( Width() - nBlankSize ); + rInf.X( rInf.X() - nBlankSize ); + SetLen( GetLen() - nHoleLen ); + SwLinePortion *pHole = new SwHolePortion( *this ); + static_cast( pHole )->SetBlankWidth( nBlankSize ); + static_cast( pHole )->SetLen( nHoleLen ); + Insert( pHole ); + +} + +TextFrameIndex SwTextPortion::GetModelPositionForViewPoint(const sal_uInt16 nOfst) const +{ + OSL_ENSURE( false, "SwTextPortion::GetModelPositionForViewPoint: don't use this method!" ); + return SwLinePortion::GetModelPositionForViewPoint( nOfst ); +} + +// The GetTextSize() assumes that the own length is correct +SwPosSize SwTextPortion::GetTextSize( const SwTextSizeInfo &rInf ) const +{ + SwPosSize aSize = rInf.GetTextSize(); + if( !GetJoinBorderWithPrev() ) + aSize.Width(aSize.Width() + rInf.GetFont()->GetLeftBorderSpace() ); + if( !GetJoinBorderWithNext() ) + aSize.Width(aSize.Width() + rInf.GetFont()->GetRightBorderSpace() ); + + aSize.Height(aSize.Height() + + rInf.GetFont()->GetTopBorderSpace() + + rInf.GetFont()->GetBottomBorderSpace() ); + + return aSize; +} + +void SwTextPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + if (rInf.OnWin() && TextFrameIndex(1) == rInf.GetLen() + && CH_TXT_ATR_FIELDEND == rInf.GetText()[sal_Int32(rInf.GetIdx())]) + { + assert(false); // this is some debugging only code + rInf.DrawBackBrush( *this ); + const OUString aText(CH_TXT_ATR_SUBST_FIELDEND); + rInf.DrawText(aText, *this, TextFrameIndex(0), TextFrameIndex(aText.getLength())); + } + else if (rInf.OnWin() && TextFrameIndex(1) == rInf.GetLen() + && CH_TXT_ATR_FIELDSTART == rInf.GetText()[sal_Int32(rInf.GetIdx())]) + { + assert(false); // this is some debugging only code + rInf.DrawBackBrush( *this ); + const OUString aText(CH_TXT_ATR_SUBST_FIELDSTART); + rInf.DrawText(aText, *this, TextFrameIndex(0), TextFrameIndex(aText.getLength())); + } + else if( GetLen() ) + { + rInf.DrawBackBrush( *this ); + rInf.DrawBorder( *this ); + + rInf.DrawCSDFHighlighting(*this); + + // do we have to repaint a post it portion? + if( rInf.OnWin() && mpNextPortion && !mpNextPortion->Width() ) + mpNextPortion->PrePaint( rInf, this ); + + auto const* pWrongList = rInf.GetpWrongList(); + auto const* pGrammarCheckList = rInf.GetGrammarCheckList(); + auto const* pSmarttags = rInf.GetSmartTags(); + + const bool bWrong = nullptr != pWrongList; + const bool bGrammarCheck = nullptr != pGrammarCheckList; + const bool bSmartTags = nullptr != pSmarttags; + + if ( bWrong || bSmartTags || bGrammarCheck ) + rInf.DrawMarkedText( *this, rInf.GetLen(), bWrong, bSmartTags, bGrammarCheck ); + else + rInf.DrawText( *this, rInf.GetLen() ); + } +} + +bool SwTextPortion::GetExpText( const SwTextSizeInfo &, OUString & ) const +{ + return false; +} + +// Responsible for the justified paragraph. They calculate the blank +// count and the resulting added space. +TextFrameIndex SwTextPortion::GetSpaceCnt(const SwTextSizeInfo &rInf, + TextFrameIndex& rCharCnt) const +{ + TextFrameIndex nCnt(0); + TextFrameIndex nPos(0); + + if ( rInf.SnapToGrid() ) + { + SwTextGridItem const*const pGrid(GetGridItem(rInf.GetTextFrame()->FindPageFrame())); + if (pGrid && GRID_LINES_CHARS == pGrid->GetGridType() && pGrid->IsSnapToChars()) + return TextFrameIndex(0); + } + + if ( InExpGrp() || PortionType::InputField == GetWhichPor() ) + { + if (OUString ExpOut; + (!IsBlankPortion() + || (GetExpText(rInf, ExpOut) && OUStringChar(CH_BLANK) == ExpOut)) + && !InNumberGrp() && !IsCombinedPortion()) + { + // OnWin() likes to return a blank instead of an empty string from + // time to time. We cannot use that here at all, however. + bool bOldOnWin = rInf.OnWin(); + const_cast(rInf).SetOnWin( false ); + + OUString aStr; + GetExpText( rInf, aStr ); + const_cast(rInf).SetOnWin( bOldOnWin ); + + nCnt = nCnt + lcl_AddSpace( rInf, &aStr, *this ); + nPos = TextFrameIndex(aStr.getLength()); + } + } + else if( !IsDropPortion() ) + { + nCnt = nCnt + lcl_AddSpace( rInf, nullptr, *this ); + nPos = GetLen(); + } + rCharCnt = rCharCnt + nPos; + return nCnt; +} + +SwTwips SwTextPortion::CalcSpacing( tools::Long nSpaceAdd, const SwTextSizeInfo &rInf ) const +{ + TextFrameIndex nCnt(0); + + if ( rInf.SnapToGrid() ) + { + SwTextGridItem const*const pGrid(GetGridItem(rInf.GetTextFrame()->FindPageFrame())); + if (pGrid && GRID_LINES_CHARS == pGrid->GetGridType() && pGrid->IsSnapToChars()) + return 0; + } + + if ( InExpGrp() || PortionType::InputField == GetWhichPor() ) + { + if (OUString ExpOut; + (!IsBlankPortion() + || (GetExpText(rInf, ExpOut) && OUStringChar(CH_BLANK) == ExpOut)) + && !InNumberGrp() && !IsCombinedPortion()) + { + // OnWin() likes to return a blank instead of an empty string from + // time to time. We cannot use that here at all, however. + bool bOldOnWin = rInf.OnWin(); + const_cast(rInf).SetOnWin( false ); + + OUString aStr; + GetExpText( rInf, aStr ); + const_cast(rInf).SetOnWin( bOldOnWin ); + if( nSpaceAdd > 0 ) + nCnt = nCnt + lcl_AddSpace( rInf, &aStr, *this ); + else + { + nSpaceAdd = -nSpaceAdd; + nCnt = TextFrameIndex(aStr.getLength()); + } + } + } + else if( !IsDropPortion() ) + { + if( nSpaceAdd > 0 ) + nCnt = nCnt + lcl_AddSpace( rInf, nullptr, *this ); + else + { + nSpaceAdd = -nSpaceAdd; + nCnt = GetLen(); + SwLinePortion* pPor = GetNextPortion(); + + // we do not want an extra space in front of margin portions + if ( nCnt ) + { + while ( pPor && !pPor->Width() && ! pPor->IsHolePortion() ) + pPor = pPor->GetNextPortion(); + + if ( !pPor || pPor->InFixMargGrp() || pPor->IsHolePortion() ) + --nCnt; + } + } + } + + return sal_Int32(nCnt) * (nSpaceAdd > LONG_MAX/2 ? LONG_MAX/2 - nSpaceAdd : nSpaceAdd) + / SPACING_PRECISION_FACTOR; +} + +void SwTextPortion::HandlePortion( SwPortionHandler& rPH ) const +{ + rPH.Text( GetLen(), GetWhichPor() ); +} + +SwTextInputFieldPortion::SwTextInputFieldPortion() +{ + SetWhichPor( PortionType::InputField ); +} + +bool SwTextInputFieldPortion::Format(SwTextFormatInfo &rTextFormatInfo) +{ + return SwTextPortion::Format(rTextFormatInfo); +} + +void SwTextInputFieldPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + if ( Width() ) + { + rInf.DrawViewOpt( *this, PortionType::InputField ); + SwTextSlot aPaintText( &rInf, this, true, true, OUString() ); + SwTextPortion::Paint( rInf ); + } + else + { + // highlight empty input field, elsewhere they are completely invisible for the user + SwRect aIntersect; + rInf.CalcRect(*this, &aIntersect); + const sal_uInt16 aAreaWidth = rInf.GetTextSize(OUString(' ')).Width(); + aIntersect.Left(aIntersect.Left() - aAreaWidth/2); + aIntersect.Width(aAreaWidth); + + if (aIntersect.HasArea() + && rInf.OnWin() + && rInf.GetOpt().IsFieldShadings() + && !rInf.GetOpt().IsPagePreview()) + { + OutputDevice* pOut = const_cast(rInf.GetOut()); + pOut->Push(vcl::PushFlags::LINECOLOR | vcl::PushFlags::FILLCOLOR); + pOut->SetFillColor(rInf.GetOpt().GetFieldShadingsColor()); + pOut->SetLineColor(); + pOut->DrawRect(aIntersect.SVRect()); + pOut->Pop(); + } + } +} + +bool SwTextInputFieldPortion::GetExpText( const SwTextSizeInfo &rInf, OUString &rText ) const +{ + sal_Int32 nIdx(rInf.GetIdx()); + sal_Int32 nLen(GetLen()); + if ( rInf.GetChar( rInf.GetIdx() ) == CH_TXT_ATR_INPUTFIELDSTART ) + { + ++nIdx; + --nLen; + } + if (rInf.GetChar(rInf.GetIdx() + GetLen() - TextFrameIndex(1)) == CH_TXT_ATR_INPUTFIELDEND) + { + --nLen; + } + rText = rInf.GetText().copy( nIdx, std::min( nLen, rInf.GetText().getLength() - nIdx ) ); + + return true; +} + +SwPosSize SwTextInputFieldPortion::GetTextSize( const SwTextSizeInfo &rInf ) const +{ + SwTextSlot aFormatText( &rInf, this, true, false ); + if (rInf.GetLen() == TextFrameIndex(0)) + { + return SwPosSize( 0, 0 ); + } + + return rInf.GetTextSize(); +} + +SwHolePortion::SwHolePortion( const SwTextPortion &rPor ) + : m_nBlankWidth( 0 ) +{ + SetLen( TextFrameIndex(1) ); + Height( rPor.Height() ); + Width(0); + SetAscent( rPor.GetAscent() ); + SetWhichPor( PortionType::Hole ); +} + +SwLinePortion *SwHolePortion::Compress() { return this; } + +// The GetTextSize() assumes that the own length is correct +SwPosSize SwHolePortion::GetTextSize(const SwTextSizeInfo& rInf) const +{ + SwPosSize aSize = rInf.GetTextSize(); + if (!GetJoinBorderWithPrev()) + aSize.Width(aSize.Width() + rInf.GetFont()->GetLeftBorderSpace()); + if (!GetJoinBorderWithNext()) + aSize.Width(aSize.Width() + rInf.GetFont()->GetRightBorderSpace()); + + aSize.Height(aSize.Height() + + rInf.GetFont()->GetTopBorderSpace() + + rInf.GetFont()->GetBottomBorderSpace()); + + return aSize; +} + +void SwHolePortion::Paint( const SwTextPaintInfo &rInf ) const +{ + if( !rInf.GetOut() ) + return; + + bool bPDFExport = rInf.GetVsh()->GetViewOptions()->IsPDFExport(); + + // #i16816# export stuff only needed for tagged pdf support + if (bPDFExport && !SwTaggedPDFHelper::IsExportTaggedPDF( *rInf.GetOut()) ) + return; + + // #i68503# the hole must have no decoration for a consistent visual appearance + const SwFont* pOrigFont = rInf.GetFont(); + std::unique_ptr pHoleFont; + std::optional oFontSave; + if( pOrigFont->GetUnderline() != LINESTYLE_NONE + || pOrigFont->GetOverline() != LINESTYLE_NONE + || pOrigFont->GetStrikeout() != STRIKEOUT_NONE ) + { + pHoleFont.reset(new SwFont( *pOrigFont )); + pHoleFont->SetUnderline( LINESTYLE_NONE ); + pHoleFont->SetOverline( LINESTYLE_NONE ); + pHoleFont->SetStrikeout( STRIKEOUT_NONE ); + oFontSave.emplace( rInf, pHoleFont.get() ); + } + + if (bPDFExport) + { + rInf.DrawText(" ", *this, TextFrameIndex(0), TextFrameIndex(1)); + } + else + { + // tdf#43244: Paint spaces even at end of line, + // but only if this paint is not called for pdf export, to keep that pdf export intact + rInf.DrawText(*this, rInf.GetLen()); + } + + oFontSave.reset(); + pHoleFont.reset(); +} + +bool SwHolePortion::Format( SwTextFormatInfo &rInf ) +{ + return rInf.IsFull() || rInf.X() >= rInf.Width(); +} + +void SwHolePortion::HandlePortion( SwPortionHandler& rPH ) const +{ + rPH.Text( GetLen(), GetWhichPor() ); +} + +void SwHolePortion::dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, TextFrameIndex& nOffset) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwHolePortion")); + dumpAsXmlAttributes(pWriter, rText, nOffset); + nOffset += GetLen(); + + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("blank-width"), + BAD_CAST(OString::number(m_nBlankWidth).getStr())); + + (void)xmlTextWriterEndElement(pWriter); +} + +void SwFieldMarkPortion::Paint( const SwTextPaintInfo & /*rInf*/) const +{ + // These shouldn't be painted! + //SwTextPortion::Paint(rInf); +} + +bool SwFieldMarkPortion::Format( SwTextFormatInfo & ) +{ + Width(0); + return false; +} + +void SwFieldFormCheckboxPortion::Paint( const SwTextPaintInfo& rInf ) const +{ + SwPosition const aPosition(rInf.GetTextFrame()->MapViewToModelPos(rInf.GetIdx())); + + IFieldmark const*const pBM = rInf.GetTextFrame()->GetDoc().getIDocumentMarkAccess()->getFieldmarkAt(aPosition); + + OSL_ENSURE(pBM && pBM->GetFieldname( ) == ODF_FORMCHECKBOX, + "Where is my form field bookmark???"); + + if (pBM && pBM->GetFieldname( ) == ODF_FORMCHECKBOX) + { + const ICheckboxFieldmark* pCheckboxFm = dynamic_cast(pBM); + bool bChecked = pCheckboxFm && pCheckboxFm->IsChecked(); + rInf.DrawCheckBox(*this, bChecked); + } +} + +bool SwFieldFormCheckboxPortion::Format( SwTextFormatInfo & rInf ) +{ + SwPosition const aPosition(rInf.GetTextFrame()->MapViewToModelPos(rInf.GetIdx())); + IFieldmark const*const pBM = rInf.GetTextFrame()->GetDoc().getIDocumentMarkAccess()->getFieldmarkAt(aPosition); + OSL_ENSURE(pBM && pBM->GetFieldname( ) == ODF_FORMCHECKBOX, "Where is my form field bookmark???"); + if (pBM && pBM->GetFieldname( ) == ODF_FORMCHECKBOX) + { + // the width of the checkbox portion is the same as its height since it's a square + // and that size depends on the font size. + // See: + // http://document-foundation-mail-archive.969070.n3.nabble.com/Wrong-copy-paste-in-SwFieldFormCheckboxPortion-Format-td4269112.html + Width( rInf.GetTextHeight( ) ); + Height( rInf.GetTextHeight( ) ); + SetAscent( rInf.GetAscent( ) ); + } + return false; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/portxt.hxx b/sw/source/core/text/portxt.hxx new file mode 100644 index 0000000000..c826395272 --- /dev/null +++ b/sw/source/core/text/portxt.hxx @@ -0,0 +1,104 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#pragma once + +#include "porlin.hxx" + +class SwTextGuess; + +/// This portion represents a part of the paragraph string. +class SwTextPortion : public SwLinePortion +{ + void BreakCut( SwTextFormatInfo &rInf, const SwTextGuess &rGuess ); + void BreakUnderflow( SwTextFormatInfo &rInf ); + bool Format_( SwTextFormatInfo &rInf ); + +public: + SwTextPortion(){ SetWhichPor( PortionType::Text ); } + static SwTextPortion * CopyLinePortion(const SwLinePortion &rPortion); + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + virtual bool Format( SwTextFormatInfo &rInf ) override; + virtual void FormatEOL( SwTextFormatInfo &rInf ) override; + virtual TextFrameIndex GetModelPositionForViewPoint(sal_uInt16 nOfst) const override; + virtual SwPosSize GetTextSize( const SwTextSizeInfo &rInfo ) const override; + virtual bool GetExpText( const SwTextSizeInfo &rInf, OUString &rText ) const override; + virtual SwTwips CalcSpacing( tools::Long nSpaceAdd, const SwTextSizeInfo &rInf ) const override; + + // Counts the spaces for justified paragraph + TextFrameIndex GetSpaceCnt(const SwTextSizeInfo &rInf, TextFrameIndex& rCnt) const; + + bool CreateHyphen( SwTextFormatInfo &rInf, SwTextGuess const &rGuess ); + + // Accessibility: pass information about this portion to the PortionHandler + virtual void HandlePortion( SwPortionHandler& rPH ) const override; +}; + +class SwTextInputFieldPortion : public SwTextPortion +{ +public: + SwTextInputFieldPortion(); + + virtual bool Format( SwTextFormatInfo &rInf ) override; + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + virtual bool GetExpText( const SwTextSizeInfo &rInf, OUString &rText ) const override; + virtual SwPosSize GetTextSize( const SwTextSizeInfo &rInfo ) const override; +}; + +class SwHolePortion : public SwLinePortion +{ + sal_uInt16 m_nBlankWidth; +public: + explicit SwHolePortion( const SwTextPortion &rPor ); + sal_uInt16 GetBlankWidth( ) const { return m_nBlankWidth; } + void SetBlankWidth( const sal_uInt16 nNew ) { m_nBlankWidth = nNew; } + virtual SwLinePortion *Compress() override; + virtual bool Format( SwTextFormatInfo &rInf ) override; + virtual SwPosSize GetTextSize(const SwTextSizeInfo& rInfo) const override; + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + + // Accessibility: pass information about this portion to the PortionHandler + virtual void HandlePortion( SwPortionHandler& rPH ) const override; + + void dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, + TextFrameIndex& nOffset) const override; +}; + +class SwFieldMarkPortion : public SwTextPortion +{ + public: + SwFieldMarkPortion() : SwTextPortion() + { + SetWhichPor(PortionType::FieldMark); + } + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + virtual bool Format( SwTextFormatInfo &rInf ) override; +}; + +class SwFieldFormCheckboxPortion : public SwTextPortion +{ +public: + SwFieldFormCheckboxPortion() : SwTextPortion() + { + SetWhichPor(PortionType::FieldFormCheckbox); + } + virtual void Paint( const SwTextPaintInfo &rInf ) const override; + virtual bool Format( SwTextFormatInfo &rInf ) override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/possiz.hxx b/sw/source/core/text/possiz.hxx new file mode 100644 index 0000000000..f66bd1988c --- /dev/null +++ b/sw/source/core/text/possiz.hxx @@ -0,0 +1,72 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#pragma once + +#include +#include + +// Compared to the SV sizes SwPosSize is always positive +class SwPosSize +{ + SwTwips m_nWidth; + SwTwips m_nHeight; +public: + SwPosSize( const SwTwips nW = 0, const SwTwips nH = 0 ) + : m_nWidth(nW) + , m_nHeight(nH) + { + } + explicit SwPosSize( const Size &rSize ) + : m_nWidth(SwTwips(rSize.Width())) + , m_nHeight(SwTwips(rSize.Height())) + { + } +#if defined(__COVERITY__) + virtual ~SwPosSize() COVERITY_NOEXCEPT_FALSE {} +#else + virtual ~SwPosSize() {} +#endif + SwPosSize(SwPosSize const &) = default; + SwPosSize(SwPosSize &&) = default; + SwPosSize & operator =(SwPosSize const &) = default; + SwPosSize & operator =(SwPosSize &&) = default; + SwTwips Height() const { return m_nHeight; } + virtual void Height(const SwTwips nNew, const bool = true) { m_nHeight = nNew; } + SwTwips Width() const { return m_nWidth; } + void Width( const SwTwips nNew ) { m_nWidth = nNew; } + Size SvLSize() const { return Size( m_nWidth, m_nHeight ); } + void SvLSize( const Size &rSize ) + { + m_nWidth = SwTwips(rSize.Width()); + m_nHeight = SwTwips(rSize.Height()); + } + void SvXSize( const Size &rSize ) + { + m_nHeight = SwTwips(rSize.Width()); + m_nWidth = SwTwips(rSize.Height()); + } + SwPosSize& operator=( const Size &rSize ) + { + m_nWidth = SwTwips(rSize.Width()); + m_nHeight = SwTwips(rSize.Height()); + return *this; + } +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/redlnitr.cxx b/sw/source/core/text/redlnitr.cxx new file mode 100644 index 0000000000..0e89b7f75a --- /dev/null +++ b/sw/source/core/text/redlnitr.cxx @@ -0,0 +1,1201 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "itratr.hxx" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "redlnitr.hxx" +#include +#include +#include +#include +#include +#include +#include + +using namespace ::com::sun::star; + +namespace { + +class HideIterator +{ +private: + IDocumentRedlineAccess const& m_rIDRA; + IDocumentMarkAccess const& m_rIDMA; + bool const m_isHideRedlines; + sw::FieldmarkMode const m_eFieldmarkMode; + bool const m_isHideParagraphBreaks; + SwPosition const m_Start; + /// next redline + SwRedlineTable::size_type m_RedlineIndex; + /// next fieldmark + std::pair> m_Fieldmark; + std::optional m_oNextFieldmarkHide; + /// previous paragraph break - because m_pStartPos/EndPos are non-owning + std::optional> m_oParagraphBreak; + /// current start/end pair + SwPosition const* m_pStartPos; + SwPosition const* m_pEndPos; + +public: + SwPosition const* GetStartPos() const { return m_pStartPos; } + SwPosition const* GetEndPos() const { return m_pEndPos; } + + HideIterator(SwTextNode & rTextNode, + bool const isHideRedlines, sw::FieldmarkMode const eMode, + sw::ParagraphBreakMode const ePBMode) + : m_rIDRA(rTextNode.getIDocumentRedlineAccess()) + , m_rIDMA(*rTextNode.getIDocumentMarkAccess()) + , m_isHideRedlines(isHideRedlines) + , m_eFieldmarkMode(eMode) + , m_isHideParagraphBreaks(ePBMode == sw::ParagraphBreakMode::Hidden) + , m_Start(rTextNode, 0) + , m_RedlineIndex(isHideRedlines ? m_rIDRA.GetRedlinePos(rTextNode, RedlineType::Any) : SwRedlineTable::npos) + , m_pStartPos(nullptr) + , m_pEndPos(&m_Start) + { + } + + // delete redlines and fieldmarks can't overlap, due to sw::CalcBreaks() + // and no combining of adjacent redlines + // -> dummy chars are delete-redlined *iff* entire fieldmark is + // Note: caller is responsible for checking for immediately adjacent hides + bool Next() + { + SwPosition const* pNextRedlineHide(nullptr); + assert(m_pEndPos); + if (m_isHideRedlines) + { + // position on current or next redline + for (; m_RedlineIndex < m_rIDRA.GetRedlineTable().size(); ++m_RedlineIndex) + { + SwRangeRedline const*const pRed = m_rIDRA.GetRedlineTable()[m_RedlineIndex]; + + if (m_pEndPos->GetNodeIndex() < pRed->Start()->GetNodeIndex()) + break; + + if (pRed->GetType() != RedlineType::Delete) + continue; + + auto [pStart, pEnd] = pRed->StartEnd(); // SwPosition* + if (*pStart == *pEnd) + { // only allowed while moving (either way?) +// assert(IDocumentRedlineAccess::IsHideChanges(rIDRA.GetRedlineFlags())); + continue; + } + if (pStart->GetNode().IsTableNode()) + { + assert(pEnd->GetNode() == m_Start.GetNode() && pEnd->GetContentIndex() == 0); + continue; // known pathology, ignore it + } + if (*m_pEndPos <= *pStart) + { + pNextRedlineHide = pStart; + break; // the next one + } + } + } + + // position on current or next fieldmark + m_oNextFieldmarkHide.reset(); + if (m_eFieldmarkMode != sw::FieldmarkMode::ShowBoth) + { + sal_Unicode const magic(m_eFieldmarkMode == sw::FieldmarkMode::ShowResult + ? CH_TXT_ATR_FIELDSTART + : CH_TXT_ATR_FIELDSEP); + SwTextNode* pTextNode = m_pEndPos->GetNode().GetTextNode(); + sal_Int32 const nPos = pTextNode ? pTextNode->GetText().indexOf( + magic, m_pEndPos->GetContentIndex()) : -1; + if (nPos != -1) + { + m_oNextFieldmarkHide.emplace(*pTextNode, nPos); + sw::mark::IFieldmark const*const pFieldmark( + m_eFieldmarkMode == sw::FieldmarkMode::ShowResult + ? m_rIDMA.getFieldmarkAt(*m_oNextFieldmarkHide) + : m_rIDMA.getInnerFieldmarkFor(*m_oNextFieldmarkHide)); + assert(pFieldmark); + m_Fieldmark.first = pFieldmark; + // for cursor travelling, there should be 2 visible chars; + // whichever char is hidden, the cursor travelling needs to + // be adapted in any case to skip in some situation or other; + // always hide the CH_TXT_ATR_FIELDSEP for now + if (m_eFieldmarkMode == sw::FieldmarkMode::ShowResult) + { + m_Fieldmark.second.emplace( + sw::mark::FindFieldSep(*m_Fieldmark.first)); + m_Fieldmark.second->AdjustContent(+1); + m_oNextFieldmarkHide->AdjustContent(+1); // skip start + } + else + { + m_Fieldmark.second.emplace(pFieldmark->GetMarkEnd()); + m_Fieldmark.second->AdjustContent(-1); + } + } + } + + // == can happen only if redline starts inside field command, and in + // that case redline will end before field separator + assert(!pNextRedlineHide || !m_oNextFieldmarkHide + || *pNextRedlineHide != *m_oNextFieldmarkHide + || *m_rIDRA.GetRedlineTable()[m_RedlineIndex]->End() < *m_Fieldmark.second); + if (pNextRedlineHide + && (!m_oNextFieldmarkHide || *pNextRedlineHide < *m_oNextFieldmarkHide)) + { + SwRangeRedline const*const pRed(m_rIDRA.GetRedlineTable()[m_RedlineIndex]); + m_pStartPos = pRed->Start(); + m_pEndPos = pRed->End(); + ++m_RedlineIndex; + return true; + } + else if (m_oNextFieldmarkHide) + { + assert(!pNextRedlineHide || *m_oNextFieldmarkHide <= *pNextRedlineHide); + m_pStartPos = &*m_oNextFieldmarkHide; + m_pEndPos = &*m_Fieldmark.second; + return true; + } + else + { + assert(!pNextRedlineHide && !m_oNextFieldmarkHide); + auto const hasHiddenItem = [](auto const& rNode) { + auto const& rpSet(rNode.GetAttr(RES_PARATR_LIST_AUTOFMT).GetStyleHandle()); + return rpSet ? rpSet->Get(RES_CHRATR_HIDDEN).GetValue() : false; + }; + auto const hasBreakBefore = [](SwTextNode const& rNode) { + if (rNode.GetAttr(RES_PAGEDESC).GetPageDesc()) + { + return true; + } + switch (rNode.GetAttr(RES_BREAK).GetBreak()) + { + case SvxBreak::ColumnBefore: + case SvxBreak::ColumnBoth: + case SvxBreak::PageBefore: + case SvxBreak::PageBoth: + return true; + default: + break; + } + return false; + }; + auto const hasBreakAfter = [](SwTextNode const& rNode) { + switch (rNode.GetAttr(RES_BREAK).GetBreak()) + { + case SvxBreak::ColumnAfter: + case SvxBreak::ColumnBoth: + case SvxBreak::PageAfter: + case SvxBreak::PageBoth: + return true; + default: + break; + } + return false; + }; + if (m_isHideParagraphBreaks + && m_pEndPos->GetNode().IsTextNode() // ooo27109-1.sxw + // only merge if next node is also text node + && m_pEndPos->GetNodes()[m_pEndPos->GetNodeIndex()+1]->IsTextNode() + && hasHiddenItem(*m_pEndPos->GetNode().GetTextNode()) + // no merge if there's a page break on any node + && !hasBreakBefore(*m_pEndPos->GetNodes()[m_pEndPos->GetNodeIndex()+1]->GetTextNode()) + // first node, see SwTextFrame::GetBreak() + && !hasBreakAfter(*m_Start.GetNode().GetTextNode())) + { + m_oParagraphBreak.emplace( + SwPosition(*m_pEndPos->GetNode().GetTextNode(), m_pEndPos->GetNode().GetTextNode()->Len()), + SwPosition(*m_pEndPos->GetNodes()[m_pEndPos->GetNodeIndex()+1]->GetTextNode(), 0)); + m_pStartPos = &m_oParagraphBreak->first; + m_pEndPos = &m_oParagraphBreak->second; + return true; + } + else // nothing + { + m_pStartPos = nullptr; + m_pEndPos = nullptr; + return false; + } + } + } +}; + +} + +namespace sw { + +std::unique_ptr +CheckParaRedlineMerge(SwTextFrame & rFrame, SwTextNode & rTextNode, + FrameMode const eMode) +{ + if (!rFrame.getRootFrame()->HasMergedParas()) + { + return nullptr; + } + bool bHaveRedlines(false); + std::vector nodes{ &rTextNode }; + std::vector tables; + std::vector sections; + std::vector extents; + OUStringBuffer mergedText; + SwTextNode * pParaPropsNode(nullptr); + SwTextNode * pNode(&rTextNode); + sal_Int32 nLastEnd(0); + for (auto iter = HideIterator(rTextNode, + rFrame.getRootFrame()->IsHideRedlines(), + rFrame.getRootFrame()->GetFieldmarkMode(), + rFrame.getRootFrame()->GetParagraphBreakMode()); + iter.Next(); ) + { + SwPosition const*const pStart(iter.GetStartPos()); + SwPosition const*const pEnd(iter.GetEndPos()); + bHaveRedlines = true; + assert(pNode != &rTextNode || &pStart->GetNode() == &rTextNode); // detect calls with wrong start node + if (pStart->GetContentIndex() != nLastEnd) // not 0 so we eliminate adjacent deletes + { + extents.emplace_back(pNode, nLastEnd, pStart->GetContentIndex()); + mergedText.append(pNode->GetText().subView(nLastEnd, pStart->GetContentIndex() - nLastEnd)); + } + if (&pEnd->GetNode() != pNode) + { + if (pNode == &rTextNode) + { + pNode->SetRedlineMergeFlag(SwNode::Merge::First); + } // else: was already set before + int nLevel(0); + for (SwNodeOffset j = pNode->GetIndex() + 1; j < pEnd->GetNodeIndex(); ++j) + { + SwNode *const pTmp(pNode->GetNodes()[j]); + if (nLevel == 0) + { + if (pTmp->IsTextNode()) + { + nodes.push_back(pTmp->GetTextNode()); + } + else if (pTmp->IsTableNode()) + { + tables.push_back(pTmp->GetTableNode()); + } + else if (pTmp->IsSectionNode()) + { + sections.push_back(pTmp->GetSectionNode()); + } + } + if (pTmp->IsStartNode()) + { + ++nLevel; + } + else if (pTmp->IsEndNode()) + { + --nLevel; + } + pTmp->SetRedlineMergeFlag(SwNode::Merge::Hidden); + } + // note: in DelLastPara() case, the end node is not actually merged + // and is likely a SwTableNode! + if (!pEnd->GetNode().IsTextNode()) + { + assert(pEnd->GetNode() != pStart->GetNode()); + // must set pNode too because it will mark the last node + pNode = nodes.back(); + assert(pNode == pNode->GetNodes()[pEnd->GetNodeIndex() - 1]); + if (pNode != &rTextNode) + { // something might depend on last merged one being NonFirst? + pNode->SetRedlineMergeFlag(SwNode::Merge::NonFirst); + } + nLastEnd = pNode->Len(); + } + else + { + pNode = pEnd->GetNode().GetTextNode(); + nodes.push_back(pNode); + pNode->SetRedlineMergeFlag(SwNode::Merge::NonFirst); + nLastEnd = pEnd->GetContentIndex(); + } + } + else + { + nLastEnd = pEnd->GetContentIndex(); + } + } + if (pNode == &rTextNode) + { + if (rTextNode.GetRedlineMergeFlag() != SwNode::Merge::None) + { + rTextNode.SetRedlineMergeFlag(SwNode::Merge::None); + } + } + // Reset flag of the following text node since we know it's not merged; + // also any table/sections in between. + // * the following SwTextNode is in same nodes section as pNode (nLevel=0) + // * the start nodes that don't have a SwTextNode before them + // on their level, and their corresponding end nodes + // * the first SwTextNode inside each start node of the previous point + // Other (non-first) SwTextNodes in nested sections shouldn't be reset! + int nLevel(0); + for (SwNodeOffset j = pNode->GetIndex() + 1; j < pNode->GetNodes().Count(); ++j) + { + SwNode *const pTmp(pNode->GetNodes()[j]); + if (!pTmp->IsCreateFrameWhenHidingRedlines()) + { // clear stale flag caused by editing with redlines shown + pTmp->SetRedlineMergeFlag(SwNode::Merge::None); + } + if (pTmp->IsStartNode()) + { + ++nLevel; + } + else if (pTmp->IsEndNode()) + { + if (nLevel == 0) + { + break; // there is no following text node; avoid leaving section + } + --nLevel; + } + else if (pTmp->IsTextNode()) + { + if (nLevel == 0) + { + break; // done + } + else + { // skip everything other than 1st text node in section! + j = pTmp->EndOfSectionIndex() - 1; // will be incremented again + } + } + } + if (!bHaveRedlines) + { + if (rTextNode.IsInList() && !rTextNode.GetNum(rFrame.getRootFrame())) + { + rTextNode.AddToListRLHidden(); // try to add it... + } + return nullptr; + } + if (nLastEnd != pNode->Len()) + { + extents.emplace_back(pNode, nLastEnd, pNode->Len()); + mergedText.append(pNode->GetText().subView(nLastEnd, pNode->Len() - nLastEnd)); + } + if (extents.empty()) // there was no text anywhere + { + assert(mergedText.isEmpty()); + pParaPropsNode = pNode; // if every node is empty, the last one wins + } + else + { + assert(!mergedText.isEmpty()); + pParaPropsNode = extents.begin()->pNode; // para props from first node that isn't empty + } +// pParaPropsNode = &rTextNode; // well, actually... + // keep lists up to date with visible nodes + if (pParaPropsNode->IsInList() && !pParaPropsNode->GetNum(rFrame.getRootFrame())) + { + pParaPropsNode->AddToListRLHidden(); // try to add it... + } + for (auto const pTextNode : nodes) + { + if (pTextNode != pParaPropsNode) + { + pTextNode->RemoveFromListRLHidden(); + } + } + if (eMode == FrameMode::Existing) + { + // remove existing footnote frames for first node; + // for non-first nodes with own frames, DelFrames will remove all + // (could possibly call lcl_ChangeFootnoteRef, not sure if worth it) + // note: must be done *before* changing listeners! + // for non-first nodes that are already merged with this frame, + // need to remove here too, otherwise footnotes can be removed only + // by lucky accident, e.g. TruncLines(). + auto itExtent(extents.begin()); + for (auto const pTextNode : nodes) + { + sal_Int32 nLast(0); + std::vector> hidden; + for ( ; itExtent != extents.end(); ++itExtent) + { + if (itExtent->pNode != pTextNode) + { + break; + } + if (itExtent->nStart != 0) + { + assert(itExtent->nStart != nLast); + hidden.emplace_back(nLast, itExtent->nStart); + } + nLast = itExtent->nEnd; + } + if (nLast != pTextNode->Len()) + { + hidden.emplace_back(nLast, pTextNode->Len()); + } + sw::RemoveFootnotesForNode(*rFrame.getRootFrame(), *pTextNode, &hidden); + } + // unfortunately DelFrames() must be done before StartListening too, + // otherwise footnotes cannot be deleted by SwTextFootnote::DelFrames! + auto const end(--nodes.rend()); + for (auto iter = nodes.rbegin(); iter != end; ++iter) + { + (**iter).DelFrames(rFrame.getRootFrame()); + } + // also delete tables & sections here; not necessary, but convenient + for (auto const pTableNode : tables) + { + pTableNode->DelFrames(rFrame.getRootFrame()); + } + for (auto const pSectionNode : sections) + { + pSectionNode->GetSection().GetFormat()->DelFrames(/*rFrame.getRootFrame()*/); + } + } + auto pRet(std::make_unique(rFrame, std::move(extents), + mergedText.makeStringAndClear(), pParaPropsNode, &rTextNode, + nodes.back())); + for (SwTextNode * pTmp : nodes) + { + pRet->listener.StartListening(pTmp); + } + rFrame.EndListeningAll(); + return pRet; +} + +} // namespace sw + +void SwAttrIter::InitFontAndAttrHandler( + SwTextNode const& rPropsNode, + SwTextNode const& rTextNode, + std::u16string_view aText, + bool const*const pbVertLayout, + bool const*const pbVertLayoutLRBT) +{ + // Build a font matching the default paragraph style: + SwFontAccess aFontAccess( &rPropsNode.GetAnyFormatColl(), m_pViewShell ); + // It is possible that Init is called more than once, e.g., in a + // SwTextFrame::FormatOnceMore situation or (since sw_redlinehide) + // from SwAttrIter::Seek(); in the latter case SwTextSizeInfo::m_pFnt + // is an alias of m_pFont so it must not be deleted! + if (m_pFont) + { + *m_pFont = aFontAccess.Get()->GetFont(); + } + else + { + m_pFont = new SwFont( aFontAccess.Get()->GetFont() ); + } + + // set font to vertical if frame layout is vertical + // if it's a re-init, the vert flag never changes + bool bVertLayoutLRBT = false; + if (pbVertLayoutLRBT) + bVertLayoutLRBT = *pbVertLayoutLRBT; + if (pbVertLayout ? *pbVertLayout : m_aAttrHandler.IsVertLayout()) + { + m_pFont->SetVertical(m_pFont->GetOrientation(), true, bVertLayoutLRBT); + } + + // Initialize the default attribute of the attribute handler + // based on the attribute array cached together with the font. + // If any further attributes for the paragraph are given in pAttrSet + // consider them during construction of the default array, and apply + // them to the font + m_aAttrHandler.Init(aFontAccess.Get()->GetDefault(), rTextNode.GetpSwAttrSet(), + *rTextNode.getIDocumentSettingAccess(), m_pViewShell, *m_pFont, + pbVertLayout ? *pbVertLayout : m_aAttrHandler.IsVertLayout(), + bVertLayoutLRBT ); + + m_aFontCacheIds[SwFontScript::Latin] = m_aFontCacheIds[SwFontScript::CJK] = m_aFontCacheIds[SwFontScript::CTL] = nullptr; + + assert(g_pBreakIt && g_pBreakIt->GetBreakIter().is()); + + m_pFont->SetActual( m_pScriptInfo->WhichFont(TextFrameIndex(0)) ); + + TextFrameIndex nChg(0); + size_t nCnt = 0; + + do + { + if ( nCnt >= m_pScriptInfo->CountScriptChg() ) + break; + nChg = m_pScriptInfo->GetScriptChg( nCnt ); + SwFontScript nTmp = SW_SCRIPTS; + switch ( m_pScriptInfo->GetScriptType( nCnt++ ) ) { + case i18n::ScriptType::ASIAN : + if( !m_aFontCacheIds[SwFontScript::CJK] ) nTmp = SwFontScript::CJK; + break; + case i18n::ScriptType::COMPLEX : + if( !m_aFontCacheIds[SwFontScript::CTL] ) nTmp = SwFontScript::CTL; + break; + default: + if( !m_aFontCacheIds[SwFontScript::Latin ] ) nTmp = SwFontScript::Latin; + } + if( nTmp < SW_SCRIPTS ) + { + m_pFont->CheckFontCacheId( m_pViewShell, nTmp ); + m_pFont->GetFontCacheId( m_aFontCacheIds[ nTmp ], m_aFontIdx[ nTmp ], nTmp ); + } + } + while (nChg < TextFrameIndex(aText.size())); +} + +void SwAttrIter::CtorInitAttrIter(SwTextNode & rTextNode, + SwScriptInfo & rScriptInfo, SwTextFrame const*const pFrame) +{ + // during HTML-Import it can happen, that no layout exists + SwRootFrame* pRootFrame = rTextNode.getIDocumentLayoutAccess().GetCurrentLayout(); + m_pViewShell = pRootFrame ? pRootFrame->GetCurrShell() : nullptr; + + m_pScriptInfo = &rScriptInfo; + + // set font to vertical if frame layout is vertical + bool bVertLayout = false; + bool bVertLayoutLRBT = false; + bool bRTL = false; + if ( pFrame ) + { + if ( pFrame->IsVertical() ) + { + bVertLayout = true; + } + if (pFrame->IsVertLRBT()) + { + bVertLayoutLRBT = true; + } + bRTL = pFrame->IsRightToLeft(); + m_pMergedPara = pFrame->GetMergedPara(); + } + + // determine script changes if not already done for current paragraph + assert(m_pScriptInfo); + if (m_pScriptInfo->GetInvalidityA() != TextFrameIndex(COMPLETE_STRING)) + m_pScriptInfo->InitScriptInfo(rTextNode, m_pMergedPara, bRTL); + + InitFontAndAttrHandler( + m_pMergedPara ? *m_pMergedPara->pParaPropsNode : rTextNode, + rTextNode, + m_pMergedPara ? m_pMergedPara->mergedText : rTextNode.GetText(), + & bVertLayout, + & bVertLayoutLRBT); + + m_nStartIndex = m_nEndIndex = m_nPosition = m_nChgCnt = 0; + m_nPropFont = 0; + SwDoc& rDoc = rTextNode.GetDoc(); + const IDocumentRedlineAccess& rIDRA = rTextNode.getIDocumentRedlineAccess(); + + // sw_redlinehide: this is a Ring - pExtInp is the first PaM that's inside + // the node. It's not clear whether there can be more than 1 PaM in the + // Ring, and this code doesn't handle that case; neither did the old code. + const SwExtTextInput* pExtInp = rDoc.GetExtTextInput( rTextNode ); + if (!pExtInp && m_pMergedPara) + { + SwTextNode const* pNode(&rTextNode); + for (auto const& rExtent : m_pMergedPara->extents) + { + if (rExtent.pNode != pNode) + { + pNode = rExtent.pNode; + pExtInp = rDoc.GetExtTextInput(*pNode); + if (pExtInp) + break; + } + } + } + const bool bShow = IDocumentRedlineAccess::IsShowChanges(rIDRA.GetRedlineFlags()) + && pRootFrame && !pRootFrame->IsHideRedlines(); + if (!(pExtInp || m_pMergedPara || bShow)) + return; + + SwRedlineTable::size_type nRedlPos = rIDRA.GetRedlinePos( rTextNode, RedlineType::Any ); + if (SwRedlineTable::npos == nRedlPos && m_pMergedPara) + { + SwTextNode const* pNode(&rTextNode); + for (auto const& rExtent : m_pMergedPara->extents) + { // note: have to search because extents based only on Delete + if (rExtent.pNode != pNode) + { + pNode = rExtent.pNode; + nRedlPos = rIDRA.GetRedlinePos(*pNode, RedlineType::Any); + if (SwRedlineTable::npos != nRedlPos) + break; + } + } + // TODO this is true initially but after delete ops it may be false... need to delete m_pMerged somewhere? + // assert(SwRedlineTable::npos != nRedlPos); + // false now with fieldmarks + assert(!pRootFrame + || pRootFrame->GetFieldmarkMode() != sw::FieldmarkMode::ShowBoth + || SwRedlineTable::npos != nRedlPos || m_pMergedPara->extents.size() <= 1); + } + if (!(pExtInp || m_pMergedPara || SwRedlineTable::npos != nRedlPos)) + return; + + const std::vector *pArr = nullptr; + if( pExtInp ) + { + pArr = &pExtInp->GetAttrs(); + Seek( TextFrameIndex(0) ); + } + + m_pRedline.reset(new SwRedlineItr( rTextNode, *m_pFont, m_aAttrHandler, nRedlPos, + (pRootFrame && pRootFrame->IsHideRedlines()) + ? SwRedlineItr::Mode::Hide + : bShow + ? SwRedlineItr::Mode::Show + : SwRedlineItr::Mode::Ignore, + pArr, pExtInp ? pExtInp->Start() : nullptr)); + + if( m_pRedline->IsOn() ) + ++m_nChgCnt; +} + +// The Redline-Iterator +// The following information/states exist in RedlineIterator: +// +// m_nFirst is the first index of RedlineTable, which overlaps with the paragraph. +// +// m_nAct is the currently active (if m_bOn is set) or the next possible index. +// m_nStart and m_nEnd give you the borders of the object within the paragraph. +// +// If m_bOn is set, the font has been manipulated according to it. +// +// If m_nAct is set to SwRedlineTable::npos (via Reset()), then currently no +// Redline is active, m_nStart and m_nEnd are invalid. +SwRedlineItr::SwRedlineItr( const SwTextNode& rTextNd, SwFont& rFnt, + SwAttrHandler& rAH, sal_Int32 nRed, + Mode const mode, + const std::vector *pArr, + SwPosition const*const pExtInputStart) + : m_rDoc( rTextNd.GetDoc() ) + , m_rAttrHandler( rAH ) + , m_nNdIdx( rTextNd.GetIndex() ) + , m_nFirst( nRed ) + , m_nAct( SwRedlineTable::npos ) + , m_nStart( COMPLETE_STRING ) + , m_nEnd( COMPLETE_STRING ) + , m_bOn( false ) + , m_eMode( mode ) +{ + if( pArr ) + { + assert(pExtInputStart); + m_pExt.reset( new SwExtend(*pArr, pExtInputStart->GetNodeIndex(), + pExtInputStart->GetContentIndex()) ); + } + else + m_pExt = nullptr; + assert(m_pExt || m_eMode != Mode::Ignore); // only create if necessary + Seek(rFnt, m_nNdIdx, 0, COMPLETE_STRING); +} + +SwRedlineItr::~SwRedlineItr() COVERITY_NOEXCEPT_FALSE +{ + Clear( nullptr ); + m_pExt.reset(); +} + +// The return value of SwRedlineItr::Seek tells you if the current font +// has been manipulated by leaving (-1) or accessing (+1) of a section +short SwRedlineItr::Seek(SwFont& rFnt, + SwNodeOffset const nNode, sal_Int32 const nNew, sal_Int32 const nOld) +{ + short nRet = 0; + if( ExtOn() ) + return 0; // Abbreviation: if we're within an ExtendTextInputs + // there can't be other changes of attributes (not even by redlining) + if (m_eMode == Mode::Show) + { + if (m_bOn) + { + if (nNew >= m_nEnd) + { + --nRet; + Clear_( &rFnt ); // We go behind the current section + ++m_nAct; // and check the next one + } + else if (nNew < m_nStart) + { + --nRet; + Clear_( &rFnt ); // We go in front of the current section + if (m_nAct > m_nFirst) + m_nAct = m_nFirst; // the test has to run from the beginning + else + return nRet + EnterExtend(rFnt, nNode, nNew); // There's none prior to us + } + else + return nRet + EnterExtend(rFnt, nNode, nNew); // We stayed in the same section + } + if (SwRedlineTable::npos == m_nAct || nOld > nNew) + m_nAct = m_nFirst; + + m_nStart = COMPLETE_STRING; + m_nEnd = COMPLETE_STRING; + const SwRedlineTable& rTable = m_rDoc.getIDocumentRedlineAccess().GetRedlineTable(); + + for ( ; m_nAct < rTable.size() ; ++m_nAct) + { + rTable[ m_nAct ]->CalcStartEnd(nNode, m_nStart, m_nEnd); + + if (nNew < m_nEnd) + { + if (nNew >= m_nStart) // only possible candidate + { + m_bOn = true; + const SwRangeRedline *pRed = rTable[ m_nAct ]; + + if (m_pSet) + m_pSet->ClearItem(); + else + { + SwAttrPool& rPool = + const_cast(m_rDoc).GetAttrPool(); + m_pSet = std::make_unique>(rPool); + } + + if( 1 < pRed->GetStackCount() ) + FillHints( pRed->GetAuthor( 1 ), pRed->GetType( 1 ) ); + FillHints( pRed->GetAuthor(), pRed->GetType() ); + + SfxWhichIter aIter( *m_pSet ); + + // moved text: dark green with double underline or strikethrough + if ( pRed->IsMoved() ) + { + m_pSet->Put(SvxColorItem( COL_GREEN, RES_CHRATR_COLOR )); + if (SfxItemState::SET == m_pSet->GetItemState(RES_CHRATR_CROSSEDOUT, true)) + m_pSet->Put(SvxCrossedOutItem( STRIKEOUT_DOUBLE, RES_CHRATR_CROSSEDOUT )); + else + m_pSet->Put(SvxUnderlineItem( LINESTYLE_DOUBLE, RES_CHRATR_UNDERLINE )); + } + + sal_uInt16 nWhich = aIter.FirstWhich(); + while( nWhich ) + { + const SfxPoolItem* pItem; + if( ( nWhich < RES_CHRATR_END ) && + ( SfxItemState::SET == aIter.GetItemState( true, &pItem ) ) ) + { + SwTextAttr* pAttr = MakeRedlineTextAttr( + const_cast(m_rDoc), + *const_cast(pItem) ); + pAttr->SetPriorityAttr( true ); + m_Hints.push_back(pAttr); + m_rAttrHandler.PushAndChg( *pAttr, rFnt ); + } + nWhich = aIter.NextWhich(); + } + + ++nRet; + } + break; + } + m_nStart = COMPLETE_STRING; + m_nEnd = COMPLETE_STRING; + } + } + else if (m_eMode == Mode::Hide) + { // ... just iterate to update m_nAct for GetNextRedln(); + // there is no need to care about formatting in this mode + if (m_nAct == SwRedlineTable::npos || nOld == COMPLETE_STRING) + { // reset, or move backward + m_nAct = m_nFirst; + } + for ( ; m_nAct < m_rDoc.getIDocumentRedlineAccess().GetRedlineTable().size(); ++m_nAct) + { // only Start matters in this mode + // Seeks until it finds a RL that starts at or behind the seek pos. + // - then update m_nStart/m_nEnd to the intersection of it with the + // current node (if any). + // The only way to skip to a different node is if there is a Delete + // RL, so if there is no intersection we'll never skip again. + // Note: here, assume that delete can't nest inside delete! + SwRangeRedline const*const pRedline( + m_rDoc.getIDocumentRedlineAccess().GetRedlineTable()[m_nAct]); + SwPosition const*const pStart(pRedline->Start()); + if (pRedline->GetType() == RedlineType::Delete + && (nNode < pStart->GetNodeIndex() + || (nNode == pStart->GetNodeIndex() + && nNew <= pStart->GetContentIndex()))) + { + pRedline->CalcStartEnd(nNode, m_nStart, m_nEnd); + break; + } + m_nStart = COMPLETE_STRING; + m_nEnd = COMPLETE_STRING; + } + } + return nRet + EnterExtend(rFnt, nNode, nNew); +} + +void SwRedlineItr::FillHints( std::size_t nAuthor, RedlineType eType ) +{ + switch ( eType ) + { + case RedlineType::Insert: + SW_MOD()->GetInsertAuthorAttr(nAuthor, *m_pSet); + break; + case RedlineType::Delete: + SW_MOD()->GetDeletedAuthorAttr(nAuthor, *m_pSet); + break; + case RedlineType::Format: + case RedlineType::FmtColl: + SW_MOD()->GetFormatAuthorAttr(nAuthor, *m_pSet); + break; + default: + break; + } +} + +void SwRedlineItr::ChangeTextAttr( SwFont* pFnt, SwTextAttr const &rHt, bool bChg ) +{ + OSL_ENSURE( IsOn(), "SwRedlineItr::ChangeTextAttr: Off?" ); + + if (m_eMode != Mode::Show && !m_pExt) + return; + + if( bChg ) + { + if (m_pExt && m_pExt->IsOn()) + m_rAttrHandler.PushAndChg( rHt, *m_pExt->GetFont() ); + else + m_rAttrHandler.PushAndChg( rHt, *pFnt ); + } + else + { + OSL_ENSURE( ! m_pExt || ! m_pExt->IsOn(), "Pop of attribute during opened extension" ); + m_rAttrHandler.PopAndChg( rHt, *pFnt ); + } +} + +void SwRedlineItr::Clear_( SwFont* pFnt ) +{ + OSL_ENSURE( m_bOn, "SwRedlineItr::Clear: Off?" ); + m_bOn = false; + for (auto const& hint : m_Hints) + { + if( pFnt ) + m_rAttrHandler.PopAndChg( *hint, *pFnt ); + else + m_rAttrHandler.Pop( *hint ); + SwTextAttr::Destroy(hint, const_cast(m_rDoc).GetAttrPool() ); + } + m_Hints.clear(); +} + +/// Ignore mode: does nothing. +/// Show mode: returns end of redline if currently in one, or start of next +/// Hide mode: returns start of next redline in current node, plus (if it's a +/// Delete) its end position and number of consecutive RLs +std::pair> +SwRedlineItr::GetNextRedln(sal_Int32 nNext, SwTextNode const*const pNode, + SwRedlineTable::size_type & rAct) +{ + sal_Int32 nStart(m_nStart); + sal_Int32 nEnd(m_nEnd); + nNext = NextExtend(pNode->GetIndex(), nNext); + if (m_eMode == Mode::Ignore || SwRedlineTable::npos == m_nFirst) + return std::make_pair(nNext, std::make_pair(nullptr, 0)); + if (SwRedlineTable::npos == rAct) + { + rAct = m_nFirst; + } + if (rAct != m_nAct) + { + while (rAct < m_rDoc.getIDocumentRedlineAccess().GetRedlineTable().size()) + { + SwRangeRedline const*const pRedline( + m_rDoc.getIDocumentRedlineAccess().GetRedlineTable()[rAct]); + pRedline->CalcStartEnd(pNode->GetIndex(), nStart, nEnd); + if (m_eMode != Mode::Hide + || pRedline->GetType() == RedlineType::Delete) + { + break; + } + ++rAct; // Hide mode: search a Delete RL + } + } + if (rAct == m_rDoc.getIDocumentRedlineAccess().GetRedlineTable().size()) + { + return std::make_pair(nNext, std::make_pair(nullptr, 0)); // no Delete here + } + if (m_bOn || (m_eMode == Mode::Show && nStart == 0)) + { // in Ignore mode, the end of redlines isn't relevant, except as returned in the second in the pair! + if (nEnd < nNext) + nNext = nEnd; + } + else if (nStart <= nNext) + { + if (m_eMode == Mode::Show) + { + nNext = nStart; + } + else + { + assert(m_eMode == Mode::Hide); + SwRangeRedline const* pRedline( + m_rDoc.getIDocumentRedlineAccess().GetRedlineTable()[rAct]); + assert(pRedline->GetType() == RedlineType::Delete); //? + if (pRedline->GetType() == RedlineType::Delete) + { + nNext = nStart; + size_t nSkipped(1); // (consecutive) candidates to be skipped + while (rAct + nSkipped < + m_rDoc.getIDocumentRedlineAccess().GetRedlineTable().size()) + { + SwRangeRedline const*const pNext = + m_rDoc.getIDocumentRedlineAccess().GetRedlineTable()[rAct + nSkipped]; + if (*pRedline->End() < *pNext->Start()) + { + break; // done for now + } + else if (*pNext->Start() == *pRedline->End() && + pNext->GetType() == RedlineType::Delete) + { + // consecutive delete - continue + pRedline = pNext; + } + ++nSkipped; + } + return std::make_pair(nNext, std::make_pair(pRedline, nSkipped)); + } + } + } + return std::make_pair(nNext, std::make_pair(nullptr, 0)); +} + +bool SwRedlineItr::ChkSpecialUnderline_() const +{ + // If the underlining or the escapement is caused by redlining, + // we always apply the SpecialUnderlining, i.e. the underlining + // below the base line + for (SwTextAttr* pHint : m_Hints) + { + const sal_uInt16 nWhich = pHint->Which(); + if( RES_CHRATR_UNDERLINE == nWhich || + RES_CHRATR_ESCAPEMENT == nWhich ) + return true; + } + return false; +} + +bool SwRedlineItr::CheckLine( + SwNodeOffset const nStartNode, sal_Int32 const nChkStart, + SwNodeOffset const nEndNode, sal_Int32 nChkEnd, OUString& rRedlineText, + bool& bRedlineEnd, RedlineType& eRedlineEnd, size_t* pAuthorAtPos) +{ + // note: previously this would return true in the (!m_bShow && m_pExt) + // case, but surely that was a bug? + if (m_nFirst == SwRedlineTable::npos || m_eMode != Mode::Show) + return false; + if( nChkEnd == nChkStart && pAuthorAtPos == nullptr ) // empty lines look one char further + ++nChkEnd; + sal_Int32 nOldStart = m_nStart; + sal_Int32 nOldEnd = m_nEnd; + SwRedlineTable::size_type const nOldAct = m_nAct; + bool bRet = bRedlineEnd = false; + eRedlineEnd = RedlineType::None; + + SwPosition const start(*m_rDoc.GetNodes()[nStartNode]->GetContentNode(), nChkStart); + SwPosition const end(*m_rDoc.GetNodes()[nEndNode]->GetContentNode(), nChkEnd); + SwRangeRedline const* pPrevRedline = nullptr; + bool isBreak(false); + for (m_nAct = m_nFirst; m_nAct < m_rDoc.getIDocumentRedlineAccess().GetRedlineTable().size(); ++m_nAct) + { + SwRangeRedline const*const pRedline( + m_rDoc.getIDocumentRedlineAccess().GetRedlineTable()[ m_nAct ] ); + // collect text of the hidden redlines at the end of the line + bool isExtendText(false); + switch (ComparePosition(*pRedline->Start(), *pRedline->End(), start, end)) + { + case SwComparePosition::Behind: + isBreak = true; + break; + case SwComparePosition::OverlapBehind: + case SwComparePosition::CollideStart: + case SwComparePosition::Outside: + case SwComparePosition::Equal: + // store redlining at line end (for line break formatting) + eRedlineEnd = pRedline->GetType(); + bRedlineEnd = true; + isBreak = true; + if (pAuthorAtPos) + *pAuthorAtPos = pRedline->GetAuthor(); + [[fallthrough]]; + case SwComparePosition::OverlapBefore: + case SwComparePosition::CollideEnd: + case SwComparePosition::Inside: + { + bRet = true; + // start to collect text of invisible redlines for ChangesInMargin layout + if (rRedlineText.isEmpty() && !pRedline->IsVisible()) + { + rRedlineText = const_cast(pRedline)->GetDescr(/*bSimplified=*/true); + pPrevRedline = pRedline; + isExtendText = true; + } + // join the text of the next invisible redlines in the same position + // i.e. characters deleted by pressing backspace or delete + else if (pPrevRedline && !pRedline->IsVisible() && + *pRedline->Start() == *pPrevRedline->Start() && *pRedline->End() == *pPrevRedline->End() ) + { + OUString sExtendText(const_cast(pRedline)->GetDescr(/*bSimplified=*/true)); + if (!sExtendText.isEmpty()) + { + if (rRedlineText.getLength() < 12) + { + // TODO: remove extra space from GetDescr(true), + // but show deletion of paragraph or line break + rRedlineText = rRedlineText + + const_cast(pRedline)->GetDescr(/*bSimplified=*/true).subView(1); + } + else + rRedlineText = OUString::Concat(rRedlineText.subView(0, rRedlineText.getLength() - 3)) + "..."; + } + isExtendText = true; + } + break; + } + case SwComparePosition::Before: + break; // -Werror=switch + } + if (isBreak && !isExtendText) + { + break; + } + } + + m_nStart = nOldStart; + m_nEnd = nOldEnd; + m_nAct = nOldAct; + return bRet; +} + +void SwExtend::ActualizeFont( SwFont &rFnt, ExtTextInputAttr nAttr ) +{ + if ( nAttr & ExtTextInputAttr::Underline ) + rFnt.SetUnderline( LINESTYLE_SINGLE ); + else if ( nAttr & ExtTextInputAttr::DoubleUnderline ) + rFnt.SetUnderline( LINESTYLE_DOUBLE ); + else if ( nAttr & ExtTextInputAttr::BoldUnderline ) + rFnt.SetUnderline( LINESTYLE_BOLD ); + else if ( nAttr & ExtTextInputAttr::DottedUnderline ) + rFnt.SetUnderline( LINESTYLE_DOTTED ); + else if ( nAttr & ExtTextInputAttr::DashDotUnderline ) + rFnt.SetUnderline( LINESTYLE_DOTTED ); + + if ( nAttr & ExtTextInputAttr::RedText ) + rFnt.SetColor( COL_RED ); + + if ( nAttr & ExtTextInputAttr::Highlight ) + { + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + rFnt.SetColor( rStyleSettings.GetHighlightTextColor() ); + rFnt.SetBackColor( rStyleSettings.GetHighlightColor() ); + } + if ( nAttr & ExtTextInputAttr::GrayWaveline ) + rFnt.SetGreyWave( true ); +} + +short SwExtend::Enter(SwFont& rFnt, SwNodeOffset const nNode, sal_Int32 const nNew) +{ + OSL_ENSURE( !m_pFont, "SwExtend: Enter with Font" ); + if (nNode != m_nNode) + return 0; + OSL_ENSURE( !Inside(), "SwExtend: Enter without Leave" ); + m_nPos = nNew; + if( Inside() ) + { + m_pFont.reset( new SwFont(rFnt) ); + ActualizeFont( rFnt, m_rArr[m_nPos - m_nStart] ); + return 1; + } + return 0; +} + +bool SwExtend::Leave_(SwFont& rFnt, SwNodeOffset const nNode, sal_Int32 const nNew) +{ + OSL_ENSURE(nNode == m_nNode && Inside(), "SwExtend: Leave without Enter"); + if (nNode != m_nNode) + return true; + const ExtTextInputAttr nOldAttr = m_rArr[m_nPos - m_nStart]; + m_nPos = nNew; + if( Inside() ) + { // We stayed within the ExtendText-section + const ExtTextInputAttr nAttr = m_rArr[m_nPos - m_nStart]; + if( nOldAttr != nAttr ) // Is there an (inner) change of attributes? + { + rFnt = *m_pFont; + ActualizeFont( rFnt, nAttr ); + } + } + else + { + rFnt = *m_pFont; + m_pFont.reset(); + return true; + } + return false; +} + +sal_Int32 SwExtend::Next(SwNodeOffset const nNode, sal_Int32 nNext) +{ + if (nNode != m_nNode) + return nNext; + if (m_nPos < m_nStart) + { + if (nNext > m_nStart) + nNext = m_nStart; + } + else if (m_nPos < m_nEnd) + { + sal_Int32 nIdx = m_nPos - m_nStart; + const ExtTextInputAttr nAttr = m_rArr[ nIdx ]; + while (o3tl::make_unsigned(++nIdx) < m_rArr.size() && nAttr == m_rArr[nIdx]) + ; //nothing + nIdx = nIdx + m_nStart; + if( nNext > nIdx ) + nNext = nIdx; + } + return nNext; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/redlnitr.hxx b/sw/source/core/text/redlnitr.hxx new file mode 100644 index 0000000000..5c30131264 --- /dev/null +++ b/sw/source/core/text/redlnitr.hxx @@ -0,0 +1,135 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include +#include + +#include + +#include +#include +#include +#include + +class SwTextNode; +class SwDoc; +class SfxItemSet; +class SwAttrHandler; + +class SwExtend +{ + std::unique_ptr m_pFont; + const std::vector &m_rArr; + /// position of start of SwExtTextInput + SwNodeOffset const m_nNode; + sal_Int32 const m_nStart; + /// current position (inside) + sal_Int32 m_nPos; + /// position of end of SwExtTextInput (in same node as start) + sal_Int32 const m_nEnd; + bool Leave_(SwFont& rFnt, SwNodeOffset nNode, sal_Int32 nNew); + bool Inside() const { return (m_nPos >= m_nStart && m_nPos < m_nEnd); } + static void ActualizeFont( SwFont &rFnt, ExtTextInputAttr nAttr ); +public: + SwExtend(const std::vector &rArr, + SwNodeOffset const nNode, sal_Int32 const nStart) + : m_rArr(rArr) + , m_nNode(nNode) + , m_nStart(nStart) + , m_nPos(COMPLETE_STRING) + , m_nEnd(m_nStart + rArr.size()) + {} + bool IsOn() const { return m_pFont != nullptr; } + void Reset() { m_pFont.reset(); m_nPos = COMPLETE_STRING; } + bool Leave(SwFont& rFnt, SwNodeOffset const nNode, sal_Int32 const nNew) + { return m_pFont && Leave_(rFnt, nNode, nNew); } + short Enter(SwFont& rFnt, SwNodeOffset nNode, sal_Int32 nNew); + sal_Int32 Next(SwNodeOffset nNode, sal_Int32 nNext); + SwFont* GetFont() { return m_pFont.get(); } + void UpdateFont(SwFont &rFont) { ActualizeFont(rFont, m_rArr[m_nPos - m_nStart]); } +}; + +class SwRedlineItr +{ + std::deque m_Hints; + const SwDoc& m_rDoc; + SwAttrHandler& m_rAttrHandler; + std::unique_ptr m_pSet; + std::unique_ptr m_pExt; + // note: this isn't actually used in the merged-para (Hide) case + SwNodeOffset const m_nNdIdx; + SwRedlineTable::size_type const m_nFirst; + SwRedlineTable::size_type m_nAct; + sal_Int32 m_nStart; + sal_Int32 m_nEnd; + bool m_bOn; +public: + enum class Mode { Show, Ignore, Hide }; +private: + Mode const m_eMode; + + void Clear_( SwFont* pFnt ); + bool ChkSpecialUnderline_() const; + void FillHints( std::size_t nAuthor, RedlineType eType ); + short EnterExtend(SwFont& rFnt, SwNodeOffset const nNode, sal_Int32 const nNew) + { + if (m_pExt) return m_pExt->Enter(rFnt, nNode, nNew); + return 0; + } + sal_Int32 NextExtend(SwNodeOffset const nNode, sal_Int32 const nNext) { + if (m_pExt) return m_pExt->Next(nNode, nNext); + return nNext; + } +public: + SwRedlineItr( const SwTextNode& rTextNd, SwFont& rFnt, SwAttrHandler& rAH, + sal_Int32 nRedlPos, Mode mode, + const std::vector *pArr = nullptr, + SwPosition const* pExtInputStart = nullptr); + ~SwRedlineItr() COVERITY_NOEXCEPT_FALSE; + SwRedlineTable::size_type GetAct() const { return m_nAct; } + bool IsOn() const { return m_bOn || (m_pExt && m_pExt->IsOn()); } + void Clear( SwFont* pFnt ) { if (m_bOn) Clear_( pFnt ); } + void ChangeTextAttr( SwFont* pFnt, SwTextAttr const &rHt, bool bChg ); + short Seek(SwFont& rFnt, SwNodeOffset nNode, sal_Int32 nNew, sal_Int32 nOld); + void Reset() { + if (m_nAct != m_nFirst) m_nAct = SwRedlineTable::npos; + if (m_pExt) m_pExt->Reset(); + } + std::pair> GetNextRedln( + sal_Int32 nNext, SwTextNode const* pNode, SwRedlineTable::size_type & rAct); + bool ChkSpecialUnderline() const + { return IsOn() && ChkSpecialUnderline_(); } + bool CheckLine(SwNodeOffset nStartNode, sal_Int32 nChkStart, SwNodeOffset nEndNode, + sal_Int32 nChkEnd, OUString& rRedlineText, bool& bRedlineEnd, + RedlineType& eRedlineEnd, size_t* pAuthorAtPos = nullptr); + bool LeaveExtend(SwFont& rFnt, SwNodeOffset const nNode, sal_Int32 const nNew) + { return m_pExt->Leave(rFnt, nNode, nNew); } + bool ExtOn() { + if (m_pExt) return m_pExt->IsOn(); + return false; + } + void UpdateExtFont( SwFont &rFnt ) { + OSL_ENSURE( ExtOn(), "UpdateExtFont without ExtOn" ); + m_pExt->UpdateFont( rFnt ); + } +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/txtcache.cxx b/sw/source/core/text/txtcache.cxx new file mode 100644 index 0000000000..188fa7bec6 --- /dev/null +++ b/sw/source/core/text/txtcache.cxx @@ -0,0 +1,193 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include "txtcache.hxx" +#include +#include "porlay.hxx" + +#include +#include +#include + +SwTextLine::SwTextLine( SwTextFrame const *pFrame, std::unique_ptr pNew ) : + SwCacheObj( static_cast(pFrame) ), + m_pLine( std::move(pNew) ) +{ +} + +SwTextLine::~SwTextLine() +{ +} + +void SwTextLine::UpdateCachePos() +{ + // note: SwTextFrame lives longer than its SwTextLine, see ~SwTextFrame + assert(m_pOwner); + const_cast(static_cast(m_pOwner))->SetCacheIdx(GetCachePos()); +} + +SwCacheObj *SwTextLineAccess::NewObj() +{ + return new SwTextLine( static_cast(m_pOwner) ); +} + +SwParaPortion *SwTextLineAccess::GetPara() +{ + SwTextLine *pRet; + if ( m_pObj ) + pRet = static_cast(m_pObj); + else + { + pRet = static_cast(Get(false)); + const_cast(static_cast(m_pOwner))->SetCacheIdx( pRet->GetCachePos() ); + } + if ( !pRet->GetPara() ) + pRet->SetPara( new SwParaPortion, true/*bDelete*/ ); + return pRet->GetPara(); +} + +SwTextLineAccess::SwTextLineAccess( const SwTextFrame *pOwn ) : + SwCacheAccess( *SwTextFrame::GetTextCache(), pOwn, pOwn->GetCacheIdx() ) +{ +} + +bool SwTextLineAccess::IsAvailable() const +{ + return m_pObj && static_cast(m_pObj)->GetPara(); +} + +bool SwTextFrame::HasPara_() const +{ + SwTextLine *pTextLine = static_cast(SwTextFrame::GetTextCache()-> + Get( this, GetCacheIdx(), false )); + if ( pTextLine ) + { + if ( pTextLine->GetPara() ) + return true; + } + else + const_cast(this)->mnCacheIndex = USHRT_MAX; + + return false; +} + +SwParaPortion *SwTextFrame::GetPara() +{ + if ( GetCacheIdx() != USHRT_MAX ) + { + SwTextLine *pLine = static_cast(SwTextFrame::GetTextCache()-> + Get( this, GetCacheIdx(), false )); + if ( pLine ) + return pLine->GetPara(); + else + mnCacheIndex = USHRT_MAX; + } + return nullptr; +} + +void SwTextFrame::ClearPara() +{ + OSL_ENSURE( !IsLocked(), "+SwTextFrame::ClearPara: this is locked." ); + if ( !IsLocked() && GetCacheIdx() != USHRT_MAX ) + { + SwTextLine *pTextLine = static_cast(SwTextFrame::GetTextCache()-> + Get( this, GetCacheIdx(), false )); + if ( pTextLine ) + { + pTextLine->SetPara( nullptr, true/*bDelete*/ ); + } + else + mnCacheIndex = USHRT_MAX; + } +} + +void SwTextFrame::RemoveFromCache() +{ + if (GetCacheIdx() != USHRT_MAX) + { + s_pTextCache->Delete(this, GetCacheIdx()); + SetCacheIdx(USHRT_MAX); + } +} + +void SwTextFrame::SetPara( SwParaPortion *pNew, bool bDelete ) +{ + if ( GetCacheIdx() != USHRT_MAX ) + { + // Only change the information, the CacheObj stays there + SwTextLine *pTextLine = static_cast(SwTextFrame::GetTextCache()-> + Get( this, GetCacheIdx(), false )); + if ( pTextLine ) + { + pTextLine->SetPara( pNew, bDelete ); + } + else + { + OSL_ENSURE( !pNew, "+SetPara: Losing SwParaPortion" ); + mnCacheIndex = USHRT_MAX; + } + } + else if ( pNew ) + { // Insert a new one + SwTextLine *pTextLine = new SwTextLine( this, std::unique_ptr(pNew) ); + if (SwTextFrame::GetTextCache()->Insert(pTextLine, false)) + mnCacheIndex = pTextLine->GetCachePos(); + else + { + OSL_FAIL( "+SetPara: InsertCache failed." ); + } + } +} + +/** Prevent the SwParaPortions of the *visible* paragraphs from being deleted; + they would just be recreated on the next paint. + + Heuristic: 100 per view are visible + + If the cache is too small, enlarge it to ensure there are sufficient free + entries for the layout so it doesn't have to throw away a node's + SwParaPortion when it starts formatting the next node. +*/ +SwSaveSetLRUOfst::SwSaveSetLRUOfst() +{ + sal_uInt16 nVisibleShells(0); + for (auto pView = SfxViewShell::GetFirst(true, checkSfxViewShell); + pView != nullptr; + pView = SfxViewShell::GetNext(*pView, true, checkSfxViewShell)) + { + // Apparently we are not interested here what document pView is for, but only in the + // total number of shells in the process? + ++nVisibleShells; + } + + sal_uInt16 const nPreserved(100 * nVisibleShells); + SwCache & rCache(*SwTextFrame::GetTextCache()); + if (rCache.GetCurMax() < nPreserved + 250) + { + rCache.IncreaseMax(nPreserved + 250 - rCache.GetCurMax()); + } + rCache.SetLRUOfst(nPreserved); +} + +SwSaveSetLRUOfst::~SwSaveSetLRUOfst() +{ + SwTextFrame::GetTextCache()->ResetLRUOfst(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/txtcache.hxx b/sw/source/core/text/txtcache.hxx new file mode 100644 index 0000000000..ee18f14c3b --- /dev/null +++ b/sw/source/core/text/txtcache.hxx @@ -0,0 +1,65 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include +#include "porlay.hxx" +#include + +class SwTextFrame; + +class SwTextLine : public SwCacheObj +{ + std::unique_ptr m_pLine; + + virtual void UpdateCachePos() override; + +public: + SwTextLine(SwTextFrame const* pFrame, std::unique_ptr pNew = nullptr); + virtual ~SwTextLine() override; + + SwParaPortion* GetPara() { return m_pLine.get(); } + const SwParaPortion* GetPara() const { return m_pLine.get(); } + + void SetPara(SwParaPortion* pNew, bool bDelete) + { + if (!bDelete) + { + // coverity[leaked_storage] - intentional, ownership transferred + (void)m_pLine.release(); + } + m_pLine.reset(pNew); + } +}; + +class SwTextLineAccess : public SwCacheAccess +{ +protected: + virtual SwCacheObj* NewObj() override; + +public: + explicit SwTextLineAccess(const SwTextFrame* pOwner); + + SwParaPortion* GetPara(); + + bool IsAvailable() const; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/txtdrop.cxx b/sw/source/core/text/txtdrop.cxx new file mode 100644 index 0000000000..afbe3b1470 --- /dev/null +++ b/sw/source/core/text/txtdrop.cxx @@ -0,0 +1,1093 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include +#include +#include +#include +#include +#include +#include "pordrop.hxx" +#include "itrform2.hxx" +#include "txtpaint.hxx" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace ::com::sun::star::i18n; +using namespace ::com::sun::star; + +/** + * Calculates if a drop caps portion intersects with a fly + * The width and height of the drop caps portion are passed as arguments, + * the position is calculated from the values in rInf + */ +static bool lcl_IsDropFlyInter( const SwTextFormatInfo &rInf, + sal_uInt16 nWidth, sal_uInt16 nHeight ) +{ + const SwTextFly& rTextFly = rInf.GetTextFly(); + if( rTextFly.IsOn() ) + { + SwRect aRect( rInf.GetTextFrame()->getFrameArea().Pos(), Size( nWidth, nHeight) ); + aRect.Pos() += rInf.GetTextFrame()->getFramePrintArea().Pos(); + aRect.Pos().AdjustX(rInf.X() ); + aRect.Pos().setY( rInf.Y() ); + aRect = rTextFly.GetFrame( aRect ); + return aRect.HasArea(); + } + + return false; +} + +namespace { + +class SwDropSave +{ + SwTextPaintInfo* pInf; + sal_Int32 nIdx; + sal_Int32 nLen; + tools::Long nX; + tools::Long nY; + +public: + explicit SwDropSave( const SwTextPaintInfo &rInf ); + ~SwDropSave(); +}; + +} + +SwDropSave::SwDropSave( const SwTextPaintInfo &rInf ) : + pInf( const_cast(&rInf) ), nIdx( rInf.GetIdx() ), + nLen( rInf.GetLen() ), nX( rInf.X() ), nY( rInf.Y() ) +{ +} + +SwDropSave::~SwDropSave() +{ + pInf->SetIdx(TextFrameIndex(nIdx)); + pInf->SetLen(TextFrameIndex(nLen)); + pInf->X( nX ); + pInf->Y( nY ); +} + +/// SwDropPortionPart DTor +SwDropPortionPart::~SwDropPortionPart() +{ + m_pFollow.reset(); + m_pFnt.reset(); +} + +/// SwDropPortion CTor, DTor +SwDropPortion::SwDropPortion( const sal_uInt16 nLineCnt, + const sal_uInt16 nDrpHeight, + const sal_uInt16 nDrpDescent, + const sal_uInt16 nDist ) + : m_nLines( nLineCnt ), + m_nDropHeight(nDrpHeight), + m_nDropDescent(nDrpDescent), + m_nDistance(nDist), + m_nFix(0), + m_nY(0) +{ + SetWhichPor( PortionType::Drop ); +} + +SwDropPortion::~SwDropPortion() +{ + m_pPart.reset(); +} + +/// nWishLen = 0 indicates that we want a whole word +sal_Int32 SwTextNode::GetDropLen( sal_Int32 nWishLen ) const +{ + sal_Int32 nEnd = GetText().getLength(); + if( nWishLen && nWishLen < nEnd ) + nEnd = nWishLen; + + if (! nWishLen) + { + // find first word + const SwAttrSet& rAttrSet = GetSwAttrSet(); + const sal_uInt16 nTextScript = g_pBreakIt->GetRealScriptOfText( GetText(), 0 ); + + LanguageType eLanguage; + + switch ( nTextScript ) + { + case i18n::ScriptType::ASIAN : + eLanguage = rAttrSet.GetCJKLanguage().GetLanguage(); + break; + case i18n::ScriptType::COMPLEX : + eLanguage = rAttrSet.GetCTLLanguage().GetLanguage(); + break; + default : + eLanguage = rAttrSet.GetLanguage().GetLanguage(); + break; + } + + Boundary aBound = + g_pBreakIt->GetBreakIter()->getWordBoundary( GetText(), 0, + g_pBreakIt->GetLocale( eLanguage ), WordType::DICTIONARY_WORD, true ); + + nEnd = aBound.endPos; + } + + sal_Int32 i = 0; + for( ; i < nEnd; ++i ) + { + sal_Unicode const cChar = GetText()[i]; + if( CH_TAB == cChar || CH_BREAK == cChar || + (( CH_TXTATR_BREAKWORD == cChar || CH_TXTATR_INWORD == cChar ) + && GetTextAttrForCharAt(i)) ) + break; + } + return i; +} + +/// nWishLen = 0 indicates that we want a whole word +TextFrameIndex SwTextFrame::GetDropLen(TextFrameIndex const nWishLen) const +{ + TextFrameIndex nEnd(GetText().getLength()); + if (nWishLen && nWishLen < nEnd) + nEnd = nWishLen; + + if (! nWishLen) + { + // find first word + const SwAttrSet& rAttrSet = GetTextNodeForParaProps()->GetSwAttrSet(); + const sal_uInt16 nTextScript = g_pBreakIt->GetRealScriptOfText(GetText(), 0); + + LanguageType eLanguage; + + switch ( nTextScript ) + { + case i18n::ScriptType::ASIAN : + eLanguage = rAttrSet.GetCJKLanguage().GetLanguage(); + break; + case i18n::ScriptType::COMPLEX : + eLanguage = rAttrSet.GetCTLLanguage().GetLanguage(); + break; + default : + eLanguage = rAttrSet.GetLanguage().GetLanguage(); + break; + } + + Boundary aBound = g_pBreakIt->GetBreakIter()->getWordBoundary( + GetText(), 0, g_pBreakIt->GetLocale(eLanguage), + WordType::DICTIONARY_WORD, true ); + + nEnd = TextFrameIndex(aBound.endPos); + } + + TextFrameIndex i(0); + for ( ; i < nEnd; ++i) + { + sal_Unicode const cChar = GetText()[sal_Int32(i)]; + if (CH_TAB == cChar || CH_BREAK == cChar || + CH_TXTATR_BREAKWORD == cChar || CH_TXTATR_INWORD == cChar) + { +#ifndef NDEBUG + if (CH_TXTATR_BREAKWORD == cChar || CH_TXTATR_INWORD == cChar) + { + std::pair const pos(MapViewToModel(i)); + assert(pos.first->GetTextAttrForCharAt(pos.second) != nullptr); + } +#endif + break; + } + } + return i; +} + +/** + * If a dropcap is found the return value is true otherwise false. The + * drop cap sizes passed back by reference are font height, drop height + * and drop descent. + */ +bool SwTextNode::GetDropSize(int& rFontHeight, int& rDropHeight, int& rDropDescent) const +{ + rFontHeight = 0; + rDropHeight = 0; + rDropDescent =0; + + const SwAttrSet& rSet = GetSwAttrSet(); + const SwFormatDrop& rDrop = rSet.GetDrop(); + + // Return (0,0) if there is no drop cap at this paragraph + if( 1 >= rDrop.GetLines() || + ( !rDrop.GetChars() && !rDrop.GetWholeWord() ) ) + { + return false; + } + + // get text frame + SwIterator aIter(*this); + for( SwTextFrame* pLastFrame = aIter.First(); pLastFrame; pLastFrame = aIter.Next() ) + { + // Only (master-) text frames can have a drop cap. + if (!pLastFrame->IsFollow() && + pLastFrame->GetTextNodeForFirstText() == this) + { + + if( !pLastFrame->HasPara() ) + pLastFrame->GetFormatted(); + + if ( !pLastFrame->IsEmpty() ) + { + const SwParaPortion* pPara = pLastFrame->GetPara(); + OSL_ENSURE( pPara, "GetDropSize could not find the ParaPortion, I'll guess the drop cap size" ); + + if ( pPara ) + { + const SwLinePortion* pFirstPor = pPara->GetFirstPortion(); + if (pFirstPor && pFirstPor->IsDropPortion()) + { + const SwDropPortion* pDrop = static_cast(pFirstPor); + rDropHeight = pDrop->GetDropHeight(); + rDropDescent = pDrop->GetDropDescent(); + if (const SwFont *pFont = pDrop->GetFnt()) + rFontHeight = pFont->GetSize(pFont->GetActual()).Height(); + else + { + const SvxFontHeightItem& rItem = rSet.Get(RES_CHRATR_FONTSIZE); + rFontHeight = rItem.GetHeight(); + } + } + } + } + break; + } + } + + if (rFontHeight==0 && rDropHeight==0 && rDropDescent==0) + { + const sal_uInt16 nLines = rDrop.GetLines(); + + const SvxFontHeightItem& rItem = rSet.Get( RES_CHRATR_FONTSIZE ); + rFontHeight = rItem.GetHeight(); + rDropHeight = nLines * rFontHeight; + rDropDescent = rFontHeight / 5; + return false; + } + + return true; +} + +/// Manipulate the width, otherwise the chars are being stretched +void SwDropPortion::PaintText( const SwTextPaintInfo &rInf ) const +{ + OSL_ENSURE( m_nDropHeight && m_pPart && m_nLines != 1, "Drop Portion painted twice" ); + + const SwDropPortionPart* pCurrPart = GetPart(); + const TextFrameIndex nOldLen = GetLen(); + const sal_uInt16 nOldWidth = Width(); + const sal_uInt16 nOldAscent = GetAscent(); + + const SwTwips nBasePosY = rInf.Y(); + const_cast(rInf).Y( nBasePosY + m_nY ); + const_cast(this)->SetAscent( nOldAscent + m_nY ); + SwDropSave aSave( rInf ); + // for text inside drop portions we let vcl handle the text directions + SwLayoutModeModifier aLayoutModeModifier( *rInf.GetOut() ); + aLayoutModeModifier.SetAuto(); + + while ( pCurrPart ) + { + const_cast(this)->SetLen( pCurrPart->GetLen() ); + const_cast(this)->Width( pCurrPart->GetWidth() ); + const_cast(rInf).SetLen( pCurrPart->GetLen() ); + SwFontSave aFontSave( rInf, &pCurrPart->GetFont() ); + const_cast(this)->SetJoinBorderWithNext(pCurrPart->GetJoinBorderWithNext()); + const_cast(this)->SetJoinBorderWithPrev(pCurrPart->GetJoinBorderWithPrev()); + + if ( rInf.OnWin() && + !rInf.GetOpt().IsPagePreview() && !rInf.GetOpt().IsReadonly() && rInf.GetOpt().IsFieldShadings() && + (!pCurrPart->GetFont().GetBackColor() || *pCurrPart->GetFont().GetBackColor() == COL_TRANSPARENT) ) + { + rInf.DrawBackground( *this ); + } + + SwTextPortion::Paint( rInf ); + + const_cast(rInf).SetIdx( rInf.GetIdx() + pCurrPart->GetLen() ); + const_cast(rInf).X( rInf.X() + pCurrPart->GetWidth() ); + pCurrPart = pCurrPart->GetFollow(); + } + + const_cast(rInf).Y( nBasePosY ); + const_cast(this)->Width( nOldWidth ); + const_cast(this)->SetLen( nOldLen ); + const_cast(this)->SetAscent( nOldAscent ); + const_cast(this)->SetJoinBorderWithNext(false); + const_cast(this)->SetJoinBorderWithPrev(false); +} + +void SwDropPortion::PaintDrop( const SwTextPaintInfo &rInf ) const +{ + // normal output is being done during the normal painting + if( ! m_nDropHeight || ! m_pPart || m_nLines == 1 ) + return; + + // set the lying values + const sal_uInt16 nOldHeight = Height(); + const sal_uInt16 nOldWidth = Width(); + const sal_uInt16 nOldAscent = GetAscent(); + const SwTwips nOldPosY = rInf.Y(); + const SwTwips nOldPosX = rInf.X(); + const SwParaPortion *pPara = rInf.GetParaPortion(); + const Point aOutPos( nOldPosX, nOldPosY - pPara->GetAscent() + - pPara->GetRealHeight() + pPara->Height() ); + // make good for retouching + + // Set baseline + const_cast(rInf).Y( aOutPos.Y() + m_nDropHeight ); + + // for background + const_cast(this)->Height( m_nDropHeight + m_nDropDescent ); + const_cast(this)->SetAscent( m_nDropHeight ); + + // Always adapt Clipregion to us, never set it off using the existing ClipRect + // as that could be set for the line + SwRect aClipRect; + if ( rInf.OnWin() ) + { + aClipRect = SwRect( aOutPos, SvLSize() ); + aClipRect.Intersection( rInf.GetPaintRect() ); + } + SwSaveClip aClip( const_cast(rInf.GetOut()) ); + aClip.ChgClip( aClipRect, rInf.GetTextFrame() ); + + // Just do, what we always do ... + PaintText( rInf ); + + // save old values + const_cast(this)->Height( nOldHeight ); + const_cast(this)->Width( nOldWidth ); + const_cast(this)->SetAscent( nOldAscent ); + const_cast(rInf).Y( nOldPosY ); +} + +void SwDropPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + // normal output is being done here + if( !(! m_nDropHeight || ! m_pPart || 1 == m_nLines) ) + return; + + if ( rInf.OnWin() && + !rInf.GetOpt().IsPagePreview() && !rInf.GetOpt().IsReadonly() && rInf.GetOpt().IsFieldShadings() ) + rInf.DrawBackground( *this ); + + // make sure that font is not rotated + std::unique_ptr pTmpFont; + if ( rInf.GetFont()->GetOrientation( rInf.GetTextFrame()->IsVertical() ) ) + { + pTmpFont.reset(new SwFont( *rInf.GetFont() )); + pTmpFont->SetVertical( 0_deg10, rInf.GetTextFrame()->IsVertical() ); + } + + SwFontSave aFontSave( rInf, pTmpFont.get() ); + // for text inside drop portions we let vcl handle the text directions + SwLayoutModeModifier aLayoutModeModifier( *rInf.GetOut() ); + aLayoutModeModifier.SetAuto(); + + SwTextPortion::Paint( rInf ); +} + +bool SwDropPortion::FormatText( SwTextFormatInfo &rInf ) +{ + const TextFrameIndex nOldLen = GetLen(); + const TextFrameIndex nOldInfLen = rInf.GetLen(); + if (!SwTextPortion::Format( rInf )) + return false; + + // looks like shit, but what can we do? + rInf.SetUnderflow( nullptr ); + Truncate(); + SetLen( nOldLen ); + rInf.SetLen( nOldInfLen ); + + return true; +} + +SwPosSize SwDropPortion::GetTextSize( const SwTextSizeInfo &rInf ) const +{ + sal_uInt16 nMyX = 0; + TextFrameIndex nIdx(0); + + const SwDropPortionPart* pCurrPart = GetPart(); + + // skip parts + while ( pCurrPart && nIdx + pCurrPart->GetLen() < rInf.GetLen() ) + { + nMyX = nMyX + pCurrPart->GetWidth(); + nIdx = nIdx + pCurrPart->GetLen(); + pCurrPart = pCurrPart->GetFollow(); + } + + TextFrameIndex const nOldIdx = rInf.GetIdx(); + TextFrameIndex const nOldLen = rInf.GetLen(); + + const_cast(rInf).SetIdx( nIdx ); + const_cast(rInf).SetLen( rInf.GetLen() - nIdx ); + + if( pCurrPart ) + { + const_cast(this)->SetJoinBorderWithNext(pCurrPart->GetJoinBorderWithNext()); + const_cast(this)->SetJoinBorderWithPrev(pCurrPart->GetJoinBorderWithPrev()); + } + + // robust + SwFontSave aFontSave( rInf, pCurrPart ? &pCurrPart->GetFont() : nullptr ); + SwPosSize aPosSize( SwTextPortion::GetTextSize( rInf ) ); + aPosSize.Width( aPosSize.Width() + nMyX ); + + const_cast(rInf).SetIdx( nOldIdx ); + const_cast(rInf).SetLen( nOldLen ); + if( pCurrPart ) + { + const_cast(this)->SetJoinBorderWithNext(false); + const_cast(this)->SetJoinBorderWithPrev(false); + } + + return aPosSize; +} + +TextFrameIndex SwDropPortion::GetModelPositionForViewPoint(const sal_uInt16) const +{ + return TextFrameIndex(0); +} + +void SwTextFormatter::CalcDropHeight( const sal_uInt16 nLines ) +{ + const SwLinePortion *const pOldCurr = GetCurr(); + sal_uInt16 nDropHght = 0; + SwTwips nAscent = 0; + SwTwips nHeight = 0; + sal_uInt16 nDropLns = 0; + const bool bRegisterOld = IsRegisterOn(); + m_bRegisterOn = false; + + Top(); + + while( GetCurr()->IsDummy() ) + { + if ( !Next() ) + break; + } + + // If we have only one line we return 0 + if( GetNext() || GetDropLines() == 1 ) + { + for( ; nDropLns < nLines; nDropLns++ ) + { + if ( GetCurr()->IsDummy() ) + break; + else + { + CalcAscentAndHeight( nAscent, nHeight ); + nDropHght = nDropHght + nHeight; + m_bRegisterOn = bRegisterOld; + } + if ( !Next() ) + { + nDropLns++; + break; + } + } + + // We hit the line ascent when reaching the last line! + nDropHght = nDropHght - nHeight; + nDropHght = nDropHght + nAscent; + Top(); + } + m_bRegisterOn = bRegisterOld; + SetDropDescent( nHeight - nAscent ); + SetDropHeight( nDropHght ); + SetDropLines( nDropLns ); + // Find old position! + while( pOldCurr != GetCurr() ) + { + if( !Next() ) + { + OSL_ENSURE( false, "SwTextFormatter::_CalcDropHeight: left Toulouse" ); + break; + } + } +} + +/** + * We assume that the font height doesn't change and that at first there + * are at least as many lines, as the DropCap-setting claims + */ +void SwTextFormatter::GuessDropHeight( const sal_uInt16 nLines ) +{ + OSL_ENSURE( nLines, "GuessDropHeight: Give me more Lines!" ); + SwTwips nAscent = 0; + SwTwips nHeight = 0; + SetDropLines( nLines ); + if ( GetDropLines() > 1 ) + { + CalcRealHeight(); + CalcAscentAndHeight( nAscent, nHeight ); + } + SetDropDescent( nHeight - nAscent ); + SetDropHeight( nHeight * nLines - GetDropDescent() ); +} + +SwDropPortion *SwTextFormatter::NewDropPortion( SwTextFormatInfo &rInf ) +{ + if( !m_pDropFormat ) + return nullptr; + + TextFrameIndex nPorLen(m_pDropFormat->GetWholeWord() ? 0 : m_pDropFormat->GetChars()); + nPorLen = m_pFrame->GetDropLen( nPorLen ); + if( !nPorLen ) + { + ClearDropFormat(); + return nullptr; + } + + SwDropPortion *pDropPor = nullptr; + + // first or second round? + if ( !( GetDropHeight() || IsOnceMore() ) ) + { + if ( GetNext() ) + CalcDropHeight( m_pDropFormat->GetLines() ); + else + GuessDropHeight( m_pDropFormat->GetLines() ); + } + + // the DropPortion + if( GetDropHeight() ) + pDropPor = new SwDropPortion( GetDropLines(), GetDropHeight(), + GetDropDescent(), m_pDropFormat->GetDistance() ); + else + pDropPor = new SwDropPortion( 0,0,0,m_pDropFormat->GetDistance() ); + + pDropPor->SetLen( nPorLen ); + + // If it was not possible to create a proper drop cap portion + // due to avoiding endless loops. We return a drop cap portion + // with an empty SwDropCapPart. For these portions the current + // font is used. + if ( GetDropLines() < 2 ) + { + SetPaintDrop( true ); + return pDropPor; + } + + // build DropPortionParts: + OSL_ENSURE( ! rInf.GetIdx(), "Drop Portion not at 0 position!" ); + TextFrameIndex nNextChg(0); + const SwCharFormat* pFormat = m_pDropFormat->GetCharFormat(); + SwDropPortionPart* pCurrPart = nullptr; + + while ( nNextChg < nPorLen ) + { + // check for attribute changes and if the portion has to split: + Seek( nNextChg ); + + // the font is deleted in the destructor of the drop portion part + SwFont* pTmpFnt = new SwFont( *rInf.GetFont() ); + if ( pFormat ) + { + const SwAttrSet& rSet = pFormat->GetAttrSet(); + pTmpFnt->SetDiffFnt(&rSet, &m_pFrame->GetDoc().getIDocumentSettingAccess()); + } + + // we do not allow a vertical font for the drop portion + pTmpFnt->SetVertical( 0_deg10, rInf.GetTextFrame()->IsVertical() ); + + // find next attribute change / script change + const TextFrameIndex nTmpIdx = nNextChg; + TextFrameIndex nNextAttr = GetNextAttr(); + nNextChg = m_pScriptInfo->NextScriptChg( nTmpIdx ); + if( nNextChg > nNextAttr ) + nNextChg = nNextAttr; + if ( nNextChg > nPorLen ) + nNextChg = nPorLen; + + std::unique_ptr pPart( + new SwDropPortionPart( *pTmpFnt, nNextChg - nTmpIdx ) ); + auto pPartTemp = pPart.get(); + + if ( ! pCurrPart ) + pDropPor->SetPart( std::move(pPart) ); + else + pCurrPart->SetFollow( std::move(pPart) ); + + pCurrPart = pPartTemp; + } + + SetPaintDrop( true ); + return pDropPor; +} + +void SwTextPainter::PaintDropPortion() +{ + const SwDropPortion *pDrop = GetInfo().GetParaPortion()->FindDropPortion(); + OSL_ENSURE( pDrop, "DrapCop-Portion not available." ); + if( !pDrop ) + return; + + const SwTwips nOldY = GetInfo().Y(); + + Top(); + + GetInfo().SetpSpaceAdd( m_pCurr->GetpLLSpaceAdd() ); + GetInfo().ResetSpaceIdx(); + GetInfo().SetKanaComp( m_pCurr->GetpKanaComp() ); + GetInfo().ResetKanaIdx(); + + // 8047: Drops and Dummies + while( !m_pCurr->GetLen() && Next() ) + ; + + // MarginPortion and Adjustment! + const SwLinePortion *pPor = m_pCurr->GetFirstPortion(); + tools::Long nX = 0; + while( pPor && !pPor->IsDropPortion() ) + { + nX = nX + pPor->Width(); + pPor = pPor->GetNextPortion(); + } + Point aLineOrigin( GetTopLeft() ); + + aLineOrigin.AdjustX(nX ); + SwTwips nTmpAscent, nTmpHeight; + CalcAscentAndHeight( nTmpAscent, nTmpHeight ); + aLineOrigin.AdjustY(nTmpAscent ); + GetInfo().SetIdx( GetStart() ); + GetInfo().SetPos( aLineOrigin ); + GetInfo().SetLen( pDrop->GetLen() ); + + pDrop->PaintDrop( GetInfo() ); + + GetInfo().Y( nOldY ); +} + +// Since the calculation of the font size is expensive, this is being +// channeled through a DropCapCache +#define DROP_CACHE_SIZE 10 + +class SwDropCapCache +{ + const void* m_aFontCacheId[ DROP_CACHE_SIZE ] = {}; + OUString m_aText[ DROP_CACHE_SIZE ]; + sal_uInt16 m_aFactor[ DROP_CACHE_SIZE ]; + sal_uInt16 m_aWishedHeight[ DROP_CACHE_SIZE ] = {}; + short m_aDescent[ DROP_CACHE_SIZE ]; + sal_uInt16 m_nIndex = 0; +public: + SwDropCapCache() = default; + void CalcFontSize( SwDropPortion* pDrop, SwTextFormatInfo &rInf ); +}; + +void SwDropPortion::DeleteDropCapCache() +{ + delete pDropCapCache; +} + +void SwDropCapCache::CalcFontSize( SwDropPortion* pDrop, SwTextFormatInfo &rInf ) +{ + const void* nFntCacheId = nullptr; + sal_uInt16 nTmpIdx = 0; + + OSL_ENSURE( pDrop->GetPart(),"DropPortion without part during font calculation"); + + SwDropPortionPart* pCurrPart = pDrop->GetPart(); + const bool bUseCache = ! pCurrPart->GetFollow() && !pCurrPart->GetFont().HasBorder(); + TextFrameIndex nIdx = rInf.GetIdx(); + OUString aStr(rInf.GetText().copy(sal_Int32(nIdx), sal_Int32(pCurrPart->GetLen()))); + + tools::Long nDescent = 0; + tools::Long nFactor = -1; + + if ( bUseCache ) + { + SwFont& rFnt = pCurrPart->GetFont(); + rFnt.CheckFontCacheId( rInf.GetVsh(), rFnt.GetActual() ); + rFnt.GetFontCacheId( nFntCacheId, nTmpIdx, rFnt.GetActual() ); + + nTmpIdx = 0; + + while( nTmpIdx < DROP_CACHE_SIZE && + ( m_aText[ nTmpIdx ] != aStr || m_aFontCacheId[ nTmpIdx ] != nFntCacheId || + m_aWishedHeight[ nTmpIdx ] != pDrop->GetDropHeight() ) ) + ++nTmpIdx; + } + + // we have to calculate a new font scaling factor if + // 1. we did not find a scaling factor in the cache or + // 2. we are not allowed to use the cache because the drop portion + // consists of more than one part + if( nTmpIdx >= DROP_CACHE_SIZE || ! bUseCache ) + { + ++m_nIndex; + m_nIndex %= DROP_CACHE_SIZE; + nTmpIdx = m_nIndex; + + tools::Long nWishedHeight = pDrop->GetDropHeight(); + tools::Long nAscent = 0; + + // find out biggest font size for initial scaling factor + tools::Long nMaxFontHeight = 1; + while ( pCurrPart ) + { + const SwFont& rFnt = pCurrPart->GetFont(); + const tools::Long nCurrHeight = rFnt.GetHeight( rFnt.GetActual() ); + if ( nCurrHeight > nMaxFontHeight ) + nMaxFontHeight = nCurrHeight; + + pCurrPart = pCurrPart->GetFollow(); + } + + nFactor = ( 1000 * nWishedHeight ) / nMaxFontHeight; + + if ( bUseCache ) + { + // save keys for cache + m_aFontCacheId[ nTmpIdx ] = nFntCacheId; + m_aText[ nTmpIdx ] = aStr; + m_aWishedHeight[ nTmpIdx ] = sal_uInt16(nWishedHeight); + // save initial scaling factor + m_aFactor[ nTmpIdx ] = o3tl::narrowing(nFactor); + } + + bool bGrow = (pDrop->GetLen() != TextFrameIndex(0)); + + // for growing control + tools::Long nMax = USHRT_MAX; + tools::Long nMin = 0; +#if OSL_DEBUG_LEVEL > 1 + tools::Long nGrow = 0; +#endif + + bool bWinUsed = false; + vcl::Font aOldFnt; + MapMode aOldMap( MapUnit::MapTwip ); + OutputDevice* pOut = rInf.GetOut(); + OutputDevice* pWin; + if( rInf.GetVsh() && rInf.GetVsh()->GetWin() ) + pWin = rInf.GetVsh()->GetWin()->GetOutDev(); + else + pWin = Application::GetDefaultDevice(); + + // adjust punctuation? + bool bKeepBaseline = rInf.GetTextFrame()->GetDoc().getIDocumentSettingAccess() + .get(DocumentSettingId::DROP_CAP_PUNCTUATION) && + !rInf.GetDropFormat()->GetWholeWord(); // && rInf.GetDropFormat()->GetChars() == 1; + + while( bGrow ) + { + // reset pCurrPart to first part + pCurrPart = pDrop->GetPart(); + bool bFirstGlyphRect = true; + tools::Rectangle aCommonRect, aRect; + + while ( pCurrPart ) + { + // current font + SwFont& rFnt = pCurrPart->GetFont(); + + // Get height including proportion + const tools::Long nCurrHeight = rFnt.GetHeight( rFnt.GetActual() ); + + // Get without proportion + const sal_uInt8 nOldProp = rFnt.GetPropr(); + rFnt.SetProportion( 100 ); + Size aOldSize( 0, rFnt.GetHeight( rFnt.GetActual() ) ); + + Size aNewSize( 0, ( nFactor * nCurrHeight ) / 1000 ); + rFnt.SetSize( aNewSize, rFnt.GetActual() ); + rFnt.ChgPhysFnt( rInf.GetVsh(), *pOut ); + + nAscent = rFnt.GetAscent( rInf.GetVsh(), *pOut ); + + // we get the rectangle that covers all chars + bool bHaveGlyphRect = pOut->GetTextBoundRect( aRect, rInf.GetText(), 0, + sal_Int32(nIdx), sal_Int32(pCurrPart->GetLen())) + && ! aRect.IsEmpty(); + + if ( ! bHaveGlyphRect ) + { + // getting glyph boundaries failed for some reason, + // we take the window for calculating sizes + if ( pWin ) + { + if ( ! bWinUsed ) + { + bWinUsed = true; + aOldMap = pWin->GetMapMode( ); + pWin->SetMapMode( MapMode( MapUnit::MapTwip ) ); + aOldFnt = pWin->GetFont(); + } + pWin->SetFont( rFnt.GetActualFont() ); + + bHaveGlyphRect = pWin->GetTextBoundRect( aRect, rInf.GetText(), 0, + sal_Int32(nIdx), sal_Int32(pCurrPart->GetLen())) + && ! aRect.IsEmpty(); + } + if (!bHaveGlyphRect) + { + // We do not have a window or our window could not + // give us glyph boundaries. + aRect = tools::Rectangle( Point( 0, 0 ), Size( 0, nAscent ) ); + } + } + + // extend rectangle to the baseline to avoid of giant dashes, + // quotation marks, bullet, asterisks etc. + if ( bKeepBaseline && aRect.Top() < 0 ) + { + aRect.SetBottom(0); + aRect.SetTop(aRect.Top() - nAscent/60); + } + + // Now we (hopefully) have a bounding rectangle for the + // glyphs of the current portion and the ascent of the current + // font + + // reset font size and proportion + rFnt.SetSize( aOldSize, rFnt.GetActual() ); + rFnt.SetProportion( nOldProp ); + + // Modify the bounding rectangle with the borders + // Robust: If the padding is so big as drop cap letter has no enough space than + // remove all padding. + if( rFnt.GetTopBorderSpace() + rFnt.GetBottomBorderSpace() >= nWishedHeight ) + { + rFnt.SetTopBorderDist(0); + rFnt.SetBottomBorderDist(0); + rFnt.SetRightBorderDist(0); + rFnt.SetLeftBorderDist(0); + } + + if( rFnt.GetTopBorder() ) + { + aRect.setHeight(aRect.GetHeight() + rFnt.GetTopBorderSpace()); + aRect.SetPosY(aRect.Top() - rFnt.GetTopBorderSpace()); + } + + if( rFnt.GetBottomBorder() ) + { + aRect.setHeight(aRect.GetHeight() + rFnt.GetBottomBorderSpace()); + } + + if ( bFirstGlyphRect ) + { + aCommonRect = aRect; + bFirstGlyphRect = false; + } + else + aCommonRect.Union( aRect ); + + nIdx = nIdx + pCurrPart->GetLen(); + pCurrPart = pCurrPart->GetFollow(); + } + + // now we have a union ( aCommonRect ) of all glyphs with + // respect to a common baseline : 0 + + // get descent and ascent from union + if ( rInf.GetTextFrame()->IsVertical() ) + { + nDescent = aCommonRect.Left(); + nAscent = aCommonRect.Right(); + + if ( nDescent < 0 ) + nDescent = -nDescent; + } + else + { + nDescent = aCommonRect.Bottom(); + nAscent = aCommonRect.Top(); + } + if ( nAscent < 0 ) + nAscent = -nAscent; + + const tools::Long nHght = nAscent + nDescent; + if ( nHght ) + { + if ( nHght > nWishedHeight ) + nMax = nFactor; + else + { + if ( bUseCache ) + m_aFactor[ nTmpIdx ] = o3tl::narrowing(nFactor); + nMin = nFactor; + } + + nFactor = ( nFactor * nWishedHeight ) / nHght; + bGrow = ( nFactor > nMin ) && ( nFactor < nMax ); +#if OSL_DEBUG_LEVEL > 1 + if ( bGrow ) + nGrow++; +#endif + nIdx = rInf.GetIdx(); + } + else + bGrow = false; + } + + if ( bWinUsed ) + { + // reset window if it has been used + pWin->SetMapMode( aOldMap ); + pWin->SetFont( aOldFnt ); + } + + if ( bUseCache ) + m_aDescent[ nTmpIdx ] = -short( nDescent ); + } + + pCurrPart = pDrop->GetPart(); + + // did made any new calculations or did we use the cache? + if ( -1 == nFactor ) + { + nFactor = m_aFactor[ nTmpIdx ]; + nDescent = m_aDescent[ nTmpIdx ]; + } + else + nDescent = -nDescent; + + while ( pCurrPart ) + { + // scale current font + SwFont& rFnt = pCurrPart->GetFont(); + Size aNewSize( 0, ( nFactor * rFnt.GetHeight( rFnt.GetActual() ) ) / 1000 ); + + const sal_uInt8 nOldProp = rFnt.GetPropr(); + rFnt.SetProportion( 100 ); + rFnt.SetSize( aNewSize, rFnt.GetActual() ); + rFnt.SetProportion( nOldProp ); + + pCurrPart = pCurrPart->GetFollow(); + } + pDrop->SetY( static_cast(nDescent) ); +} + +bool SwDropPortion::Format( SwTextFormatInfo &rInf ) +{ + bool bFull = false; + m_nFix = o3tl::narrowing(rInf.X()); + + SwLayoutModeModifier aLayoutModeModifier( *rInf.GetOut() ); + aLayoutModeModifier.SetAuto(); + + if( m_nDropHeight && m_pPart && m_nLines!=1 ) + { + if( !pDropCapCache ) + pDropCapCache = new SwDropCapCache; + + // adjust font sizes to fit into the rectangle + pDropCapCache->CalcFontSize( this, rInf ); + + const tools::Long nOldX = rInf.X(); + { + SwDropSave aSave( rInf ); + SwDropPortionPart* pCurrPart = m_pPart.get(); + + while ( pCurrPart ) + { + rInf.SetLen( pCurrPart->GetLen() ); + SwFont& rFnt = pCurrPart->GetFont(); + { + SwFontSave aFontSave( rInf, &rFnt ); + SetJoinBorderWithNext(pCurrPart->GetJoinBorderWithNext()); + SetJoinBorderWithPrev(pCurrPart->GetJoinBorderWithPrev()); + bFull = FormatText( rInf ); + + if ( bFull ) + break; + } + + const SwTwips nTmpWidth = + ( InSpaceGrp() && rInf.GetSpaceAdd() ) ? + Width() + CalcSpacing( rInf.GetSpaceAdd(), rInf ) : + Width(); + + // set values + pCurrPart->SetWidth( o3tl::narrowing(nTmpWidth) ); + + // Move + rInf.SetIdx( rInf.GetIdx() + pCurrPart->GetLen() ); + rInf.X( rInf.X() + nTmpWidth ); + pCurrPart = pCurrPart->GetFollow(); + } + SetJoinBorderWithNext(false); + SetJoinBorderWithPrev(false); + Width( o3tl::narrowing(rInf.X() - nOldX) ); + } + + // reset my length + SetLen( rInf.GetLen() ); + + // Quit when Flys are overlapping + if( ! bFull ) + bFull = lcl_IsDropFlyInter( rInf, Width(), m_nDropHeight ); + + if( bFull ) + { + // FormatText could have caused nHeight to be 0 + if ( !Height() ) + Height( rInf.GetTextHeight() ); + + // And now for another round + m_nDropHeight = m_nLines = 0; + m_pPart.reset(); + + // Meanwhile use normal formatting + bFull = SwTextPortion::Format( rInf ); + } + else + rInf.SetDropInit( true ); + + Height( rInf.GetTextHeight() ); + SetAscent( rInf.GetAscent() ); + } + else + bFull = SwTextPortion::Format( rInf ); + + if( bFull ) + m_nDistance = 0; + else + { + const sal_uInt16 nWant = Width() + GetDistance(); + const sal_uInt16 nRest = o3tl::narrowing(rInf.Width() - rInf.X()); + if( ( nWant > nRest ) || + lcl_IsDropFlyInter( rInf, Width() + GetDistance(), m_nDropHeight ) ) + m_nDistance = 0; + + Width( Width() + m_nDistance ); + } + return bFull; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/txtfld.cxx b/sw/source/core/text/txtfld.cxx new file mode 100644 index 0000000000..84f32e3097 --- /dev/null +++ b/sw/source/core/text/txtfld.cxx @@ -0,0 +1,715 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "porfld.hxx" +#include "porftn.hxx" +#include "porref.hxx" +#include "portox.hxx" +#include "porfly.hxx" +#include "itrform2.hxx" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static bool lcl_IsInBody( SwFrame const *pFrame ) +{ + if ( pFrame->IsInDocBody() ) + return true; + + while (const SwFlyFrame* pFly = pFrame->FindFlyFrame()) + pFrame = pFly->GetAnchorFrame(); + return pFrame->IsInDocBody(); +} + +static OUString ExpandField(const SwField& rField, const SwTextFormatter& rFormatter, + const SwTextFormatInfo& rInf) +{ + if (rInf.GetOpt().IsFieldName()) + return rField.GetFieldName(); + + const SwViewShell* pSh = rInf.GetVsh(); + const SwDoc* pDoc(pSh ? pSh->GetDoc() : nullptr); + const bool bInClipboard(!pDoc || pDoc->IsClipBoard()); + return rField.ExpandField(bInClipboard, rFormatter.GetTextFrame()->getRootFrame()); +} + +SwExpandPortion *SwTextFormatter::NewFieldPortion( SwTextFormatInfo &rInf, + const SwTextAttr *pHint ) const +{ + SwField *pField = const_cast(pHint->GetFormatField().GetField()); + const bool bName = rInf.GetOpt().IsFieldName(); + + // set language + const_cast(this)->SeekAndChg( rInf ); + if (pField->GetLanguage() != GetFnt()->GetLanguage()) + pField->SetLanguage( GetFnt()->GetLanguage() ); + + SwViewShell *pSh = rInf.GetVsh(); + + switch (pField->GetTyp()->Which()) + { + case SwFieldIds::Script: + case SwFieldIds::Postit: + return new SwPostItsPortion(SwFieldIds::Script == pField->GetTyp()->Which()); + case SwFieldIds::CombinedChars: + if (!bName) + return new SwCombinedPortion(ExpandField(*pField, *this, rInf)); + break; + case SwFieldIds::HiddenText: + return new SwHiddenPortion(ExpandField(*pField, *this, rInf)); + case SwFieldIds::Chapter: + if (!bName && pSh && !pSh->Imp()->IsUpdateExpFields()) + { + static_cast(pField)->ChangeExpansion( + *m_pFrame, &static_txtattr_cast(pHint)->GetTextNode()); + } + break; + case SwFieldIds::DocStat: + if (!bName && pSh && !pSh->Imp()->IsUpdateExpFields()) + { + static_cast(pField)->ChangeExpansion(m_pFrame); + } + break; + case SwFieldIds::PageNumber: + if (!bName && pSh && pSh->GetLayout() && !pSh->Imp()->IsUpdateExpFields()) + { + auto pPageNr = static_cast(pField->GetTyp()); + + const SwRootFrame* pTmpRootFrame = pSh->GetLayout(); + const bool bVirt = pTmpRootFrame->IsVirtPageNum(); + + sal_uInt16 nVirtNum = m_pFrame->GetVirtPageNum(); + sal_uInt16 nNumPages = pTmpRootFrame->GetPageNum(); + SvxNumType nNumFormat = SvxNumType(-1); + if (SVX_NUM_PAGEDESC == pField->GetFormat()) + nNumFormat + = m_pFrame->FindPageFrame()->GetPageDesc()->GetNumType().GetNumberingType(); + static_cast(pField)->ChangeExpansion(nVirtNum, nNumPages); + pPageNr->ChangeExpansion(pSh->GetDoc(), bVirt, + nNumFormat != SvxNumType(-1) ? &nNumFormat : nullptr); + } + break; + case SwFieldIds::GetExp: + if (!bName && pSh && !pSh->Imp()->IsUpdateExpFields()) + { + auto pExpField = static_cast(pField); + if (!::lcl_IsInBody(m_pFrame)) + { + pExpField->ChgBodyTextFlag(false); + pExpField->ChangeExpansion(*m_pFrame, + *static_txtattr_cast(pHint)); + } + else if (!pExpField->IsInBodyText()) + { + // Was something else previously, thus: expand first, then convert it! + pExpField->ChangeExpansion(*m_pFrame, + *static_txtattr_cast(pHint)); + pExpField->ChgBodyTextFlag(true); + } + } + break; + case SwFieldIds::Database: + if (!bName) + { + static_cast(pField)->ChgBodyTextFlag(::lcl_IsInBody(m_pFrame)); + } + break; + case SwFieldIds::RefPageGet: + if (!bName && pSh && !pSh->Imp()->IsUpdateExpFields()) + { + static_cast(pField)->ChangeExpansion( + *m_pFrame, static_txtattr_cast(pHint)); + } + break; + case SwFieldIds::JumpEdit: + { + std::unique_ptr pFont; + if (!bName) + { + pFont = std::make_unique(*m_pFont); + pFont->SetDiffFnt( + &static_cast(pField)->GetCharFormat()->GetAttrSet(), + &m_pFrame->GetDoc().getIDocumentSettingAccess()); + } + return new SwJumpFieldPortion(ExpandField(*pField, *this, rInf), pField->GetPar2(), + std::move(pFont), pField->GetFormat()); + } + case SwFieldIds::GetRef: + if (!bName) + { + auto pGetRef = static_cast(pField); + if (pGetRef->GetSubType() == REF_STYLE) + pGetRef->UpdateField(static_txtattr_cast(pHint), m_pFrame); + } + break; + default: + break; + } + return new SwFieldPortion(ExpandField(*pField, *this, rInf)); +} + +static SwFieldPortion * lcl_NewMetaPortion(SwTextAttr & rHint, const bool bPrefix) +{ + ::sw::Meta *const pMeta( + static_cast(rHint.GetAttr()).GetMeta() ); + OUString fix; + ::sw::MetaField *const pField( dynamic_cast< ::sw::MetaField * >(pMeta) ); + OSL_ENSURE(pField, "lcl_NewMetaPortion: no meta field?"); + if (pField) + { + OUString color; + pField->GetPrefixAndSuffix(bPrefix ? &fix : nullptr, bPrefix ? nullptr : &fix, &color); + } + return new SwFieldPortion( fix ); +} + +/** + * Try to create a new portion with zero length, for an end of a hint + * (where there is no CH_TXTATR). Because there may be multiple hint ends at a + * given index, m_pByEndIter is used to keep track of the already created + * portions. But the portions created here may actually be deleted again, + * due to Underflow. In that case, m_pByEndIter must be decremented, + * so the portion will be created again on the next line. + */ +SwExpandPortion * SwTextFormatter::TryNewNoLengthPortion(SwTextFormatInfo const & rInfo) +{ + const TextFrameIndex nIdx(rInfo.GetIdx()); + + // sw_redlinehide: because there is a dummy character at the start of these + // hints, it's impossible to have ends of hints from different nodes at the + // same view position, so it's sufficient to check the hints of the current + // node. However, m_pByEndIter exists for the whole text frame, so + // it's necessary to iterate all hints for that purpose... + if (!m_pByEndIter) + { + m_pByEndIter.reset(new sw::MergedAttrIterByEnd(*rInfo.GetTextFrame())); + } + SwTextNode const* pNode(nullptr); + for (SwTextAttr const* pHint = m_pByEndIter->NextAttr(pNode); pHint; + pHint = m_pByEndIter->NextAttr(pNode)) + { + SwTextAttr & rHint(const_cast(*pHint)); + TextFrameIndex const nEnd( + rInfo.GetTextFrame()->MapModelToView(pNode, rHint.GetAnyEnd())); + if (nEnd > nIdx) + { + m_pByEndIter->PrevAttr(); + break; + } + if (nEnd == nIdx) + { + if (RES_TXTATR_METAFIELD == rHint.Which()) + { + SwFieldPortion *const pPortion( + lcl_NewMetaPortion(rHint, false)); + pPortion->SetNoLength(); // no CH_TXTATR at hint end! + return pPortion; + } + } + } + return nullptr; +} + +SwLinePortion *SwTextFormatter::NewExtraPortion( SwTextFormatInfo &rInf ) +{ + SwTextAttr *pHint = GetAttr( rInf.GetIdx() ); + SwLinePortion *pRet = nullptr; + if( !pHint ) + { + pRet = new SwTextPortion; + pRet->SetLen(TextFrameIndex(1)); + rInf.SetLen(TextFrameIndex(1)); + return pRet; + } + + switch( pHint->Which() ) + { + case RES_TXTATR_FLYCNT : + { + pRet = NewFlyCntPortion( rInf, pHint ); + break; + } + case RES_TXTATR_FTN : + { + pRet = NewFootnotePortion( rInf, pHint ); + break; + } + case RES_TXTATR_FIELD : + case RES_TXTATR_ANNOTATION : + { + pRet = NewFieldPortion( rInf, pHint ); + break; + } + case RES_TXTATR_REFMARK : + { + pRet = new SwIsoRefPortion; + break; + } + case RES_TXTATR_TOXMARK : + { + pRet = new SwIsoToxPortion; + break; + } + case RES_TXTATR_METAFIELD: + { + pRet = lcl_NewMetaPortion( *pHint, true ); + break; + } + default: ; + } + if( !pRet ) + { + auto pFieldPortion = new SwFieldPortion( "" ); + if (pHint->Which() == RES_TXTATR_CONTENTCONTROL) + { + pFieldPortion->SetContentControl(true); + } + pRet = pFieldPortion; + rInf.SetLen(TextFrameIndex(1)); + } + return pRet; +} + +/** + * OOXML spec says that w:rPr inside w:pPr specifies formatting for the paragraph mark symbol (i.e. the control + * character than can be configured to be shown). However, in practice MSO also uses it as direct formatting + * for numbering in that paragraph. I don't know if the problem is in the spec or in MSWord. + */ +static void checkApplyParagraphMarkFormatToNumbering(SwFont* pNumFnt, SwTextFormatInfo& rInf, + const IDocumentSettingAccess* pIDSA, + const SwAttrSet* pFormat) +{ + if( !pIDSA->get(DocumentSettingId::APPLY_PARAGRAPH_MARK_FORMAT_TO_NUMBERING )) + return; + + SwFormatAutoFormat const& rListAutoFormat(rInf.GetTextFrame()->GetTextNodeForParaProps()->GetAttr(RES_PARATR_LIST_AUTOFMT)); + std::shared_ptr pSet(rListAutoFormat.GetStyleHandle()); + + // Check each item and in case it should be ignored, then clear it. + if (!pSet) + return; + + std::unique_ptr const pCleanedSet = pSet->Clone(); + + if (pCleanedSet->HasItem(RES_TXTATR_CHARFMT)) + { + // Insert attributes of referenced char format into current set + const SwFormatCharFormat& rCharFormat = pCleanedSet->Get(RES_TXTATR_CHARFMT); + const SwAttrSet& rStyleAttrs = static_cast(rCharFormat.GetRegisteredIn())->GetAttrSet(); + SfxWhichIter aIter(rStyleAttrs); + sal_uInt16 nWhich = aIter.FirstWhich(); + while (nWhich) + { + if (!SwTextNode::IsIgnoredCharFormatForNumbering(nWhich, /*bIsCharStyle=*/true) + && !pCleanedSet->HasItem(nWhich) + && !(pFormat && pFormat->HasItem(nWhich)) + && rStyleAttrs.GetItemState(nWhich) > SfxItemState::DEFAULT) + { + // Copy from parent sets only allowed items which will not overwrite + // values explicitly defined in current set (pCleanedSet) or in pFormat + if (const SfxPoolItem* pItem = rStyleAttrs.GetItem(nWhich, true)) + pCleanedSet->Put(*pItem); + } + nWhich = aIter.NextWhich(); + } + + // It is not required here anymore, all referenced items are inserted + pCleanedSet->ClearItem(RES_TXTATR_CHARFMT); + }; + + SfxItemIter aIter(*pSet); + const SfxPoolItem* pItem = aIter.GetCurItem(); + while (pItem) + { + if (SwTextNode::IsIgnoredCharFormatForNumbering(pItem->Which())) + pCleanedSet->ClearItem(pItem->Which()); + else if (pFormat && pFormat->HasItem(pItem->Which())) + pCleanedSet->ClearItem(pItem->Which()); + else if (pItem->Which() == RES_CHRATR_BACKGROUND) + { + bool bShadingWasImported = false; + // If Shading was imported, it should not be converted to a Highlight, + // but remain as Shading which is ignored for numbering. + if (pCleanedSet->HasItem(RES_CHRATR_GRABBAG)) + { + SfxGrabBagItem aGrabBag = pCleanedSet->Get(RES_CHRATR_GRABBAG, /*bSrchInParent=*/false); + std::map& rMap = aGrabBag.GetGrabBag(); + auto aIterator = rMap.find("CharShadingMarker"); + if (aIterator != rMap.end()) + aIterator->second >>= bShadingWasImported; + } + + // If used, BACKGROUND is converted to HIGHLIGHT. So also ignore if a highlight already exists. + if (bShadingWasImported + || pCleanedSet->HasItem(RES_CHRATR_HIGHLIGHT) + || (pFormat && pFormat->HasItem(RES_CHRATR_HIGHLIGHT))) + { + pCleanedSet->ClearItem(pItem->Which()); + } + } + pItem = aIter.NextItem(); + }; + + // SetDiffFnt resets the background color (why?), so capture it and re-apply if it had a value, + // because an existing value should override anything inherited from the paragraph marker. + const std::optional oFontBackColor = pNumFnt->GetBackColor(); + // The same is true for the highlight color. + const Color aHighlight = pNumFnt->GetHighlightColor(); + + pNumFnt->SetDiffFnt(pCleanedSet.get(), pIDSA); + + if (oFontBackColor) + pNumFnt->SetBackColor(oFontBackColor); + if (aHighlight != COL_TRANSPARENT) + pNumFnt->SetHighlightColor(aHighlight); +} + +static const SwRangeRedline* lcl_GetRedlineAtNodeInsertionOrDeletion( const SwTextNode& rTextNode, + bool& bIsMoved ) +{ + const SwDoc& rDoc = rTextNode.GetDoc(); + SwRedlineTable::size_type nRedlPos = rDoc.getIDocumentRedlineAccess().GetRedlinePos( rTextNode, RedlineType::Any ); + + if( SwRedlineTable::npos != nRedlPos ) + { + const SwNodeOffset nNdIdx = rTextNode.GetIndex(); + const SwRedlineTable& rTable = rDoc.getIDocumentRedlineAccess().GetRedlineTable(); + for( ; nRedlPos < rTable.size() ; ++nRedlPos ) + { + const SwRangeRedline* pTmp = rTable[ nRedlPos ]; + SwNodeOffset nStart = pTmp->GetPoint()->GetNodeIndex(), + nEnd = pTmp->GetMark()->GetNodeIndex(); + if( nStart > nEnd ) + std::swap(nStart, nEnd); + if( RedlineType::Delete == pTmp->GetType() || + RedlineType::Insert == pTmp->GetType() ) + { + if( nStart <= nNdIdx && nEnd > nNdIdx ) + { + bIsMoved = pTmp->IsMoved(); + return pTmp; + } + } + if( nStart > nNdIdx ) + break; + } + } + return nullptr; +} + +static bool lcl_setRedlineAttr( SwTextFormatInfo &rInf, const SwTextNode& rTextNode, const std::unique_ptr& pNumFnt ) +{ + if ( rInf.GetVsh()->GetLayout()->IsHideRedlines() ) + return false; + + bool bIsMoved; + const SwRangeRedline* pRedlineNum = lcl_GetRedlineAtNodeInsertionOrDeletion( rTextNode, bIsMoved ); + if (!pRedlineNum) + return false; + + // moved text: dark green with double underline or strikethrough + if ( bIsMoved ) + { + pNumFnt->SetColor(COL_GREEN); + if ( RedlineType::Delete == pRedlineNum->GetType() ) + pNumFnt->SetStrikeout(STRIKEOUT_DOUBLE); + else + pNumFnt->SetUnderline(LINESTYLE_DOUBLE); + return true; + } + + SwAttrPool& rPool = rInf.GetVsh()->GetDoc()->GetAttrPool(); + SfxItemSetFixed aSet(rPool); + + std::size_t aAuthor = (1 < pRedlineNum->GetStackCount()) + ? pRedlineNum->GetAuthor( 1 ) + : pRedlineNum->GetAuthor(); + + if ( RedlineType::Delete == pRedlineNum->GetType() ) + SW_MOD()->GetDeletedAuthorAttr(aAuthor, aSet); + else + SW_MOD()->GetInsertAuthorAttr(aAuthor, aSet); + + if (const SvxColorItem* pItem = aSet.GetItemIfSet(RES_CHRATR_COLOR)) + pNumFnt->SetColor(pItem->GetValue()); + if (const SvxUnderlineItem* pItem = aSet.GetItemIfSet(RES_CHRATR_UNDERLINE)) + pNumFnt->SetUnderline(pItem->GetLineStyle()); + if (const SvxCrossedOutItem* pItem = aSet.GetItemIfSet(RES_CHRATR_CROSSEDOUT)) + pNumFnt->SetStrikeout( pItem->GetStrikeout() ); + + return true; +} + +SwNumberPortion *SwTextFormatter::NewNumberPortion( SwTextFormatInfo &rInf ) const +{ + if( rInf.IsNumDone() || rInf.GetTextStart() != m_nStart + || rInf.GetTextStart() != rInf.GetIdx() ) + return nullptr; + + SwNumberPortion *pRet = nullptr; + // sw_redlinehide: at this point it's certain that pTextNd is the node with + // the numbering of the frame; only the actual number-vector (GetNumString) + // depends on the hide-mode in the layout so other calls don't need to care + const SwTextNode *const pTextNd = GetTextFrame()->GetTextNodeForParaProps(); + const SwNumRule* pNumRule = pTextNd->GetNumRule(); + + // Has a "valid" number? + // sw_redlinehide: check that pParaPropsNode is the correct one + assert(pTextNd->IsNumbered(m_pFrame->getRootFrame()) == pTextNd->IsNumbered(nullptr)); + if (pTextNd->IsNumbered(m_pFrame->getRootFrame()) && pTextNd->IsCountedInList()) + { + int nLevel = pTextNd->GetActualListLevel(); + + if (nLevel < 0) + nLevel = 0; + + if (nLevel >= MAXLEVEL) + nLevel = MAXLEVEL - 1; + + const SwNumFormat &rNumFormat = pNumRule->Get( nLevel ); + const bool bLeft = SvxAdjust::Left == rNumFormat.GetNumAdjust(); + const bool bCenter = SvxAdjust::Center == rNumFormat.GetNumAdjust(); + const bool bLabelAlignmentPosAndSpaceModeActive( + rNumFormat.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_ALIGNMENT ); + const sal_uInt16 nMinDist = bLabelAlignmentPosAndSpaceModeActive + ? 0 : rNumFormat.GetCharTextDistance(); + + if( SVX_NUM_BITMAP == rNumFormat.GetNumberingType() ) + { + OUString referer; + if (auto const sh1 = rInf.GetVsh()) { + if (auto const doc = sh1->GetDoc()) { + auto const sh2 = doc->GetPersist(); + if (sh2 != nullptr && sh2->HasName()) { + referer = sh2->GetMedium()->GetName(); + } + } + } + pRet = new SwGrfNumPortion( pTextNd->GetLabelFollowedBy(), + rNumFormat.GetBrush(), referer, + rNumFormat.GetGraphicOrientation(), + rNumFormat.GetGraphicSize(), + bLeft, bCenter, nMinDist, + bLabelAlignmentPosAndSpaceModeActive ); + tools::Long nTmpA = rInf.GetLast()->GetAscent(); + tools::Long nTmpD = rInf.GetLast()->Height() - nTmpA; + if( !rInf.IsTest() ) + static_cast(pRet)->SetBase( nTmpA, nTmpD, nTmpA, nTmpD ); + } + else + { + // The SwFont is created dynamically and passed in the ctor, + // as the CharFormat only returns an SV-Font. + // In the dtor of SwNumberPortion, the SwFont is deleted. + const SwAttrSet* pFormat = rNumFormat.GetCharFormat() ? + &rNumFormat.GetCharFormat()->GetAttrSet() : + nullptr; + const IDocumentSettingAccess* pIDSA = pTextNd->getIDocumentSettingAccess(); + + if( SVX_NUM_CHAR_SPECIAL == rNumFormat.GetNumberingType() ) + { + const std::optional pFormatFnt = rNumFormat.GetBulletFont(); + + // Build a new bullet font basing on the current paragraph font: + std::unique_ptr pNumFnt(new SwFont( &rInf.GetCharAttr(), pIDSA )); + + // #i53199# + if ( !pIDSA->get(DocumentSettingId::DO_NOT_RESET_PARA_ATTRS_FOR_NUM_FONT) ) + { + // i18463: + // Underline style of paragraph font should not be considered + // Overline style of paragraph font should not be considered + // Weight style of paragraph font should not be considered + // Posture style of paragraph font should not be considered + pNumFnt->SetUnderline( LINESTYLE_NONE ); + pNumFnt->SetOverline( LINESTYLE_NONE ); + pNumFnt->SetItalic( ITALIC_NONE, SwFontScript::Latin ); + pNumFnt->SetItalic( ITALIC_NONE, SwFontScript::CJK ); + pNumFnt->SetItalic( ITALIC_NONE, SwFontScript::CTL ); + pNumFnt->SetWeight( WEIGHT_NORMAL, SwFontScript::Latin ); + pNumFnt->SetWeight( WEIGHT_NORMAL, SwFontScript::CJK ); + pNumFnt->SetWeight( WEIGHT_NORMAL, SwFontScript::CTL ); + } + + // Apply the explicit attributes from the character style + // associated with the numbering to the new bullet font. + if( pFormat ) + pNumFnt->SetDiffFnt( pFormat, pIDSA ); + + checkApplyParagraphMarkFormatToNumbering(pNumFnt.get(), rInf, pIDSA, pFormat); + + if ( pFormatFnt ) + { + const SwFontScript nAct = pNumFnt->GetActual(); + pNumFnt->SetFamily( pFormatFnt->GetFamilyType(), nAct ); + pNumFnt->SetName( pFormatFnt->GetFamilyName(), nAct ); + pNumFnt->SetStyleName( pFormatFnt->GetStyleName(), nAct ); + pNumFnt->SetCharSet( pFormatFnt->GetCharSet(), nAct ); + pNumFnt->SetPitch( pFormatFnt->GetPitch(), nAct ); + } + + // we do not allow a vertical font + pNumFnt->SetVertical( pNumFnt->GetOrientation(), + m_pFrame->IsVertical() ); + + lcl_setRedlineAttr( rInf, *pTextNd, pNumFnt ); + + // --> OD 2008-01-23 #newlistelevelattrs# + if (rNumFormat.GetBulletChar()) + { + pRet = new SwBulletPortion(rNumFormat.GetBulletChar(), + pTextNd->GetLabelFollowedBy(), + std::move(pNumFnt), + bLeft, bCenter, nMinDist, + bLabelAlignmentPosAndSpaceModeActive); + } + } + else + { + // Show Changes mode shows the actual numbering (SwListRedlineType::HIDDEN) and + // the original one (SwListRedlineType::ORIGTEXT) instead of the fake numbering + // (SwListRedlineType::SHOW, which counts removed and inserted numbered paragraphs + // in a single list) + bool bHasHiddenNum = false; + OUString aText( pTextNd->GetNumString(true, MAXLEVEL, m_pFrame->getRootFrame(), SwListRedlineType::HIDDEN) ); + const SwDoc& rDoc = pTextNd->GetDoc(); + const SwRedlineTable& rTable = rDoc.getIDocumentRedlineAccess().GetRedlineTable(); + if ( rTable.size() && !rInf.GetVsh()->GetLayout()->IsHideRedlines() ) + { + OUString aHiddenText( pTextNd->GetNumString(true, MAXLEVEL, m_pFrame->getRootFrame(), SwListRedlineType::ORIGTEXT) ); + + if ( !aText.isEmpty() || !aHiddenText.isEmpty() ) + { + bool bDisplayChangedParagraphNumbering = officecfg::Office::Writer::Comparison::DisplayChangedParagraphNumbering::get(); + if (bDisplayChangedParagraphNumbering && aText != aHiddenText && !aHiddenText.isEmpty()) + { + bHasHiddenNum = true; + // show also original number after the actual one enclosed in [ and ], + // and replace tabulator with space to avoid messy indentation + // resulted by the longer numbering, e.g. "1.[2.]" instead of "1.". + aText = aText + "[" + aHiddenText + "]" + + pTextNd->GetLabelFollowedBy().replaceAll("\t", " "); + } + else if (!aText.isEmpty()) + aText += pTextNd->GetLabelFollowedBy(); + } + } + else if (pTextNd->getIDocumentSettingAccess()->get(DocumentSettingId::NO_NUMBERING_SHOW_FOLLOWBY) + || !aText.isEmpty()) + aText += pTextNd->GetLabelFollowedBy(); + + // Not just an optimization ... + // A number portion without text will be assigned a width of 0. + // The succeeding text portion will flow into the BreakCut in the BreakLine, + // although we have rInf.GetLast()->GetFlyPortion()! + if( !aText.isEmpty() ) + { + + // Build a new numbering font basing on the current paragraph font: + std::unique_ptr pNumFnt(new SwFont( &rInf.GetCharAttr(), pIDSA )); + + const SwTextNode& rTextNode = *rInf.GetTextFrame()->GetTextNodeForParaProps(); + if (const SwpHints* pHints = rTextNode.GetpSwpHints()) + { + // Also look for an empty character hint that sits at the paragraph end: + for (size_t i = 0; i < pHints->Count(); ++i) + { + const SwTextAttr* pHint = pHints->GetSortedByEnd(i); + if (pHint->Which() == RES_TXTATR_AUTOFMT && pHint->GetEnd() + && pHint->GetStart() == *pHint->GetEnd() + && pHint->GetStart() == rTextNode.GetText().getLength()) + { + std::shared_ptr pSet + = pHint->GetAutoFormat().GetStyleHandle(); + if (pSet) + { + pNumFnt->SetDiffFnt(pSet.get(), pIDSA); + break; + } + } + } + } + + // #i53199# + if ( !pIDSA->get(DocumentSettingId::DO_NOT_RESET_PARA_ATTRS_FOR_NUM_FONT) ) + { + // i18463: + // Underline style of paragraph font should not be considered + pNumFnt->SetUnderline( LINESTYLE_NONE ); + // Overline style of paragraph font should not be considered + pNumFnt->SetOverline( LINESTYLE_NONE ); + } + + // Apply the explicit attributes from the character style + // associated with the numbering to the new bullet font. + if( pFormat ) + pNumFnt->SetDiffFnt( pFormat, pIDSA ); + + checkApplyParagraphMarkFormatToNumbering(pNumFnt.get(), rInf, pIDSA, pFormat); + + if ( !lcl_setRedlineAttr( rInf, *pTextNd, pNumFnt ) && bHasHiddenNum ) + pNumFnt->SetColor(NON_PRINTING_CHARACTER_COLOR); + + // we do not allow a vertical font + pNumFnt->SetVertical( pNumFnt->GetOrientation(), m_pFrame->IsVertical() ); + + pRet = new SwNumberPortion( aText, std::move(pNumFnt), + bLeft, bCenter, nMinDist, + bLabelAlignmentPosAndSpaceModeActive ); + } + } + } + } + return pRet; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/txtfly.cxx b/sw/source/core/text/txtfly.cxx new file mode 100644 index 0000000000..ff5566f537 --- /dev/null +++ b/sw/source/core/text/txtfly.cxx @@ -0,0 +1,1493 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "inftxt.hxx" +#include "porrst.hxx" +#include "txtpaint.hxx" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef DBG_UTIL +#include +#include +#endif + +using namespace ::com::sun::star; + +namespace +{ + // #i68520# + struct AnchoredObjOrder + { + bool mbR2L; + SwRectFn mfnRect; + + AnchoredObjOrder( const bool bR2L, + SwRectFn fnRect ) + : mbR2L( bR2L ), + mfnRect( fnRect ) + {} + + bool operator()( const SwAnchoredObject* pListedAnchoredObj, + const SwAnchoredObject* pNewAnchoredObj ) + { + const SwRect& aBoundRectOfListedObj( pListedAnchoredObj->GetObjRectWithSpaces() ); + const SwRect& aBoundRectOfNewObj( pNewAnchoredObj->GetObjRectWithSpaces() ); + if ( ( mbR2L && + ( (aBoundRectOfListedObj.*mfnRect->fnGetRight)() == + (aBoundRectOfNewObj.*mfnRect->fnGetRight)() ) ) || + ( !mbR2L && + ( (aBoundRectOfListedObj.*mfnRect->fnGetLeft)() == + (aBoundRectOfNewObj.*mfnRect->fnGetLeft)() ) ) ) + { + SwTwips nTopDiff = + (*mfnRect->fnYDiff)( (aBoundRectOfNewObj.*mfnRect->fnGetTop)(), + (aBoundRectOfListedObj.*mfnRect->fnGetTop)() ); + if ( nTopDiff == 0 && + ( ( mbR2L && + ( (aBoundRectOfNewObj.*mfnRect->fnGetLeft)() > + (aBoundRectOfListedObj.*mfnRect->fnGetLeft)() ) ) || + ( !mbR2L && + ( (aBoundRectOfNewObj.*mfnRect->fnGetRight)() < + (aBoundRectOfListedObj.*mfnRect->fnGetRight)() ) ) ) ) + { + return true; + } + else if ( nTopDiff > 0 ) + { + return true; + } + } + else if ( ( mbR2L && + ( (aBoundRectOfListedObj.*mfnRect->fnGetRight)() > + (aBoundRectOfNewObj.*mfnRect->fnGetRight)() ) ) || + ( !mbR2L && + ( (aBoundRectOfListedObj.*mfnRect->fnGetLeft)() < + (aBoundRectOfNewObj.*mfnRect->fnGetLeft)() ) ) ) + { + return true; + } + + return false; + } + }; +} + +SwContourCache::SwContourCache() : + mnPointCount( 0 ) +{ +} + +SwContourCache::~SwContourCache() +{ +} + +void SwContourCache::ClrObject( sal_uInt16 nPos ) +{ + mnPointCount -= mvItems[ nPos ].mxTextRanger->GetPointCount(); + mvItems.erase(mvItems.begin() + nPos); +} + +void ClrContourCache( const SdrObject *pObj ) +{ + if( pContourCache && pObj ) + for( sal_uInt16 i = 0; i < pContourCache->GetCount(); ++i ) + if( pObj == pContourCache->GetObject( i ) ) + { + pContourCache->ClrObject( i ); + break; + } +} + +void ClrContourCache() +{ + if( pContourCache ) + { + pContourCache->mvItems.clear(); + pContourCache->mnPointCount = 0; + } +} + +// #i68520# +SwRect SwContourCache::CalcBoundRect( const SwAnchoredObject* pAnchoredObj, + const SwRect &rLine, + const SwTextFrame* pFrame, + const tools::Long nXPos, + const bool bRight ) +{ + SwRect aRet; + const SwFrameFormat* pFormat = &(pAnchoredObj->GetFrameFormat()); + bool bHandleContour(pFormat->GetSurround().IsContour()); + + if(!bHandleContour) + { + // RotateFlyFrame3: Object has no set contour, but for rotated + // FlyFrames we can create a 'default' contour to make text + // flow around the free, non-covered + const SwFlyFreeFrame* pSwFlyFreeFrame(dynamic_cast< const SwFlyFreeFrame* >(pAnchoredObj)); + + if(nullptr != pSwFlyFreeFrame && pSwFlyFreeFrame->supportsAutoContour()) + { + bHandleContour = true; + } + } + + if( bHandleContour && + ( pAnchoredObj->DynCastFlyFrame() == nullptr || + ( static_cast(pAnchoredObj)->Lower() && + static_cast(pAnchoredObj)->Lower()->IsNoTextFrame() ) ) ) + { + aRet = pAnchoredObj->GetObjRectWithSpaces(); + if( aRet.Overlaps( rLine ) ) + { + if( !pContourCache ) + pContourCache = new SwContourCache; + + aRet = pContourCache->ContourRect( + pFormat, pAnchoredObj->GetDrawObj(), pFrame, rLine, nXPos, bRight ); + } + else + aRet.Width( 0 ); + } + else + { + aRet = pAnchoredObj->GetObjRectWithSpaces(); + } + + return aRet; +} + +SwRect SwContourCache::ContourRect( const SwFormat* pFormat, + const SdrObject* pObj, const SwTextFrame* pFrame, const SwRect &rLine, + const tools::Long nXPos, const bool bRight ) +{ + SwRect aRet; + sal_uInt16 nPos = 0; // Search in the Cache + while( nPos < GetCount() && pObj != mvItems[ nPos ].mpSdrObj ) + ++nPos; + if( GetCount() == nPos ) // Not found + { + if( GetCount() == POLY_CNT ) + { + mnPointCount -= mvItems.back().mxTextRanger->GetPointCount(); + mvItems.pop_back(); + } + ::basegfx::B2DPolyPolygon aPolyPolygon; + std::optional<::basegfx::B2DPolyPolygon> pPolyPolygon; + + if ( auto pVirtFlyDrawObj = dynamic_cast< const SwVirtFlyDrawObj *>( pObj ) ) + { + // GetContour() causes the graphic to be loaded, which may cause + // the graphic to change its size, call ClrObject() + tools::PolyPolygon aPoly; + if( !pVirtFlyDrawObj->GetFlyFrame()->GetContour( aPoly ) ) + aPoly = tools::PolyPolygon( pVirtFlyDrawObj-> + GetFlyFrame()->getFrameArea().SVRect() ); + aPolyPolygon.clear(); + aPolyPolygon.append(aPoly.getB2DPolyPolygon()); + } + else + { + if( DynCastE3dObject( pObj ) == nullptr ) + { + aPolyPolygon = pObj->TakeXorPoly(); + } + + pPolyPolygon = pObj->TakeContour(); + } + const SvxLRSpaceItem &rLRSpace = pFormat->GetLRSpace(); + const SvxULSpaceItem &rULSpace = pFormat->GetULSpace(); + CacheItem item { + pObj, // due to #37347 the Object must be entered only after GetContour() + std::make_unique( aPolyPolygon, pPolyPolygon ? &*pPolyPolygon : nullptr, 20, + o3tl::narrowing(rLRSpace.GetLeft()), o3tl::narrowing(rLRSpace.GetRight()), + pFormat->GetSurround().IsOutside(), false, pFrame->IsVertical() ) + }; + mvItems.insert(mvItems.begin(), std::move(item)); + mvItems[0].mxTextRanger->SetUpper( rULSpace.GetUpper() ); + mvItems[0].mxTextRanger->SetLower( rULSpace.GetLower() ); + + pPolyPolygon.reset(); + + mnPointCount += mvItems[0].mxTextRanger->GetPointCount(); + while( mnPointCount > POLY_MAX && mvItems.size() > POLY_MIN ) + { + mnPointCount -= mvItems.back().mxTextRanger->GetPointCount(); + mvItems.pop_back(); + } + } + else if( nPos ) + { + CacheItem item = std::move(mvItems[nPos]); + mvItems.erase(mvItems.begin() + nPos); + mvItems.insert(mvItems.begin(), std::move(item)); + } + SwRectFnSet aRectFnSet(pFrame); + tools::Long nTmpTop = aRectFnSet.GetTop(rLine); + // fnGetBottom is top + height + tools::Long nTmpBottom = aRectFnSet.GetBottom(rLine); + + Range aRange( std::min( nTmpTop, nTmpBottom ), std::max( nTmpTop, nTmpBottom ) ); + + std::deque* pTmp = mvItems[0].mxTextRanger->GetTextRanges( aRange ); + + const size_t nCount = pTmp->size(); + if( 0 != nCount ) + { + size_t nIdx = 0; + while( nIdx < nCount && (*pTmp)[ nIdx ] < nXPos ) + ++nIdx; + bool bOdd = nIdx % 2; + bool bSet = true; + if( bOdd ) + --nIdx; // within interval + else if( ! bRight && ( nIdx >= nCount || (*pTmp)[ nIdx ] != nXPos ) ) + { + if( nIdx ) + nIdx -= 2; // an interval to the left + else + bSet = false; // before the first interval + } + + if( bSet && nIdx < nCount ) + { + aRectFnSet.SetTopAndHeight( aRet, aRectFnSet.GetTop(rLine), + aRectFnSet.GetHeight(rLine) ); + aRectFnSet.SetLeft( aRet, (*pTmp)[ nIdx ] ); + aRectFnSet.SetRight( aRet, (*pTmp)[ nIdx + 1 ] + 1 ); + } + } + return aRet; +} + +SwTextFly::SwTextFly() + : m_pPage(nullptr) + , mpCurrAnchoredObj(nullptr) + , m_pCurrFrame(nullptr) + , m_pMaster(nullptr) + , m_nMinBottom(0) + , m_nNextTop(0) + , m_nCurrFrameNodeIndex(0) + , m_bOn(false) + , m_bTopRule(false) + , mbIgnoreCurrentFrame(false) + , mbIgnoreContour(false) + , mbIgnoreObjsInHeaderFooter(false) + +{ +} + +SwTextFly::SwTextFly( const SwTextFrame *pFrame ) +{ + CtorInitTextFly( pFrame ); +} + +SwTextFly::SwTextFly( const SwTextFly& rTextFly ) +{ + m_pPage = rTextFly.m_pPage; + mpCurrAnchoredObj = rTextFly.mpCurrAnchoredObj; + m_pCurrFrame = rTextFly.m_pCurrFrame; + m_pMaster = rTextFly.m_pMaster; + if( rTextFly.mpAnchoredObjList ) + { + mpAnchoredObjList.reset( new SwAnchoredObjList( *(rTextFly.mpAnchoredObjList) ) ); + } + + m_bOn = rTextFly.m_bOn; + m_bTopRule = rTextFly.m_bTopRule; + m_nMinBottom = rTextFly.m_nMinBottom; + m_nNextTop = rTextFly.m_nNextTop; + m_nCurrFrameNodeIndex = rTextFly.m_nCurrFrameNodeIndex; + mbIgnoreCurrentFrame = rTextFly.mbIgnoreCurrentFrame; + mbIgnoreContour = rTextFly.mbIgnoreContour; + mbIgnoreObjsInHeaderFooter = rTextFly.mbIgnoreObjsInHeaderFooter; +} + +SwTextFly::~SwTextFly() +{ +} + +void SwTextFly::CtorInitTextFly( const SwTextFrame *pFrame ) +{ + mbIgnoreCurrentFrame = false; + mbIgnoreContour = false; + mbIgnoreObjsInHeaderFooter = false; + m_pPage = pFrame->FindPageFrame(); + const SwFlyFrame* pTmp = pFrame->FindFlyFrame(); + // #i68520# + mpCurrAnchoredObj = pTmp; + m_pCurrFrame = pFrame; + m_pMaster = m_pCurrFrame->IsFollow() ? nullptr : m_pCurrFrame; + // If we're not overlapped by a frame or if a FlyCollection does not exist + // at all, we switch off forever. + // It could be, however, that a line is added while formatting, that + // extends into a frame. + // That's why we do not optimize for: bOn = pSortedFlys && IsAnyFrame(); + m_bOn = m_pPage->GetSortedObjs() != nullptr; + m_bTopRule = true; + m_nMinBottom = 0; + m_nNextTop = 0; + m_nCurrFrameNodeIndex = NODE_OFFSET_MAX; +} + +SwRect SwTextFly::GetFrame_( const SwRect &rRect ) const +{ + SwRect aRet; + if( ForEach( rRect, &aRet, true ) ) + { + SwRectFnSet aRectFnSet(m_pCurrFrame); + aRectFnSet.SetTop( aRet, aRectFnSet.GetTop(rRect) ); + + // Do not always adapt the bottom + const SwTwips nRetBottom = aRectFnSet.GetBottom(aRet); + const SwTwips nRectBottom = aRectFnSet.GetBottom(rRect); + if ( aRectFnSet.YDiff( nRetBottom, nRectBottom ) > 0 || + aRectFnSet.GetHeight(aRet) < 0 ) + aRectFnSet.SetBottom( aRet, nRectBottom ); + } + return aRet; +} + +bool SwTextFly::IsAnyFrame() const +{ + SwSwapIfSwapped swap(const_cast(m_pCurrFrame)); + + OSL_ENSURE( m_bOn, "IsAnyFrame: Why?" ); + SwRect aRect(m_pCurrFrame->getFrameArea().Pos() + m_pCurrFrame->getFramePrintArea().Pos(), + m_pCurrFrame->getFramePrintArea().SSize()); + + return ForEach( aRect, nullptr, false ); +} + +bool SwTextFly::IsAnyObj( const SwRect &rRect ) const +{ + OSL_ENSURE( m_bOn, "SwTextFly::IsAnyObj: Who's knocking?" ); + + SwRect aRect( rRect ); + if ( aRect.IsEmpty() ) + { + aRect = SwRect(m_pCurrFrame->getFrameArea().Pos() + m_pCurrFrame->getFramePrintArea().Pos(), + m_pCurrFrame->getFramePrintArea().SSize()); + + SwTwips nLower = m_pCurrFrame->GetLowerMarginForFlyIntersect(); + if (nLower > 0) + { + aRect.AddBottom(nLower); + } + } + + const SwSortedObjs *pSorted = m_pPage->GetSortedObjs(); + if( pSorted ) // bOn actually makes sure that we have objects on the side, + // but who knows who deleted something in the meantime? + { + for ( size_t i = 0; i < pSorted->size(); ++i ) + { + const SwAnchoredObject* pObj = (*pSorted)[i]; + + const SwRect aBound( pObj->GetObjRectWithSpaces() ); + + // Optimization + if( pObj->GetObjRect().Left() > aRect.Right() ) + continue; + + // #i68520# + if( mpCurrAnchoredObj != pObj && aBound.Overlaps( aRect ) ) + return true; + } + } + return false; +} + +const SwTextFrame* SwTextFly::GetMaster_() +{ + m_pMaster = m_pCurrFrame; + while (m_pMaster && m_pMaster->IsFollow()) + m_pMaster = m_pMaster->FindMaster(); + return m_pMaster; +} + +void SwTextFly::DrawTextOpaque( SwDrawTextInfo &rInf ) +{ + SwSaveClip aClipSave( rInf.GetpOut() ); + SwRect aRect( rInf.GetPos(), rInf.GetSize() ); + if( rInf.GetSpace() ) + { + TextFrameIndex const nTmpLen = TextFrameIndex(COMPLETE_STRING) == rInf.GetLen() + ? TextFrameIndex(rInf.GetText().getLength()) + : rInf.GetLen(); + if( rInf.GetSpace() > 0 ) + { + sal_Int32 nSpaceCnt = 0; + const TextFrameIndex nEndPos = rInf.GetIdx() + nTmpLen; + for (TextFrameIndex nPos = rInf.GetIdx(); nPos < nEndPos; ++nPos) + { + if (CH_BLANK == rInf.GetText()[sal_Int32(nPos)]) + ++nSpaceCnt; + } + if( nSpaceCnt ) + aRect.Width( aRect.Width() + nSpaceCnt * rInf.GetSpace() ); + } + else + aRect.Width( aRect.Width() - sal_Int32(nTmpLen) * rInf.GetSpace() ); + } + + if( aClipSave.IsOn() && rInf.GetOut().IsClipRegion() ) + { + SwRect aClipRect( rInf.GetOut().GetClipRegion().GetBoundRect() ); + aRect.Intersection( aClipRect ); + } + + SwRegionRects aRegion( aRect ); + + bool bOpaque = false; + // #i68520# + const sal_uInt32 nCurrOrd = mpCurrAnchoredObj + ? mpCurrAnchoredObj->GetDrawObj()->GetOrdNum() + : SAL_MAX_UINT32; + OSL_ENSURE( !m_bTopRule, "DrawTextOpaque: Wrong TopRule" ); + + // #i68520# + const SwAnchoredObjList::size_type nCount( m_bOn ? GetAnchoredObjList().size() : 0 ); + if (nCount > 0) + { + const SdrLayerID nHellId = m_pPage->getRootFrame()->GetCurrShell()->getIDocumentDrawModelAccess().GetHellId(); + for( SwAnchoredObjList::size_type i = 0; i < nCount; ++i ) + { + // #i68520# + const SwAnchoredObject* pTmpAnchoredObj = (*mpAnchoredObjList)[i]; + const SwFlyFrame* pFly = pTmpAnchoredObj->DynCastFlyFrame(); + if( pFly && mpCurrAnchoredObj != pTmpAnchoredObj ) + { + // #i68520# + if( aRegion.GetOrigin().Overlaps( pFly->getFrameArea() ) ) + { + const SwFrameFormat *pFormat = pFly->GetFormat(); + const SwFormatSurround &rSur = pFormat->GetSurround(); + const SwFormatAnchor& rAnchor = pFormat->GetAnchor(); + // Only the ones who are opaque and more to the top + if( ! pFly->IsBackgroundTransparent() && + css::text::WrapTextMode_THROUGH == rSur.GetSurround() && + ( !rSur.IsAnchorOnly() || + // #i68520# + GetMaster() == pFly->GetAnchorFrame() || + ((RndStdIds::FLY_AT_PARA != rAnchor.GetAnchorId()) && + (RndStdIds::FLY_AT_CHAR != rAnchor.GetAnchorId()) + ) + ) && + // #i68520# + pTmpAnchoredObj->GetDrawObj()->GetLayer() != nHellId && + nCurrOrd < pTmpAnchoredObj->GetDrawObj()->GetOrdNum() + ) + { + // Except for the content is transparent + const SwNoTextFrame *pNoText = + pFly->Lower() && pFly->Lower()->IsNoTextFrame() + ? static_cast(pFly->Lower()) + : nullptr; + if ( !pNoText || + (!pNoText->IsTransparent() && !rSur.IsContour()) ) + { + bOpaque = true; + aRegion -= pFly->getFrameArea(); + } + } + } + } + } + } + + Point aPos( rInf.GetPos().X(), rInf.GetPos().Y() + rInf.GetAscent() ); + const Point aOldPos(rInf.GetPos()); + rInf.SetPos( aPos ); + + if( !bOpaque ) + { + if( rInf.GetKern() ) + rInf.GetFont()->DrawStretchText_( rInf ); + else + rInf.GetFont()->DrawText_( rInf ); + rInf.SetPos(aOldPos); + return; + } + else if( !aRegion.empty() ) + { + // What a huge effort ... + SwSaveClip aClipVout( rInf.GetpOut() ); + for( size_t i = 0; i < aRegion.size(); ++i ) + { + SwRect &rRect = aRegion[i]; + if( rRect != aRegion.GetOrigin() ) + aClipVout.ChgClip( rRect ); + if( rInf.GetKern() ) + rInf.GetFont()->DrawStretchText_( rInf ); + else + rInf.GetFont()->DrawText_( rInf ); + } + } + rInf.SetPos(aOldPos); +} + +void SwTextFly::DrawFlyRect( OutputDevice* pOut, const SwRect &rRect ) +{ + SwRegionRects aRegion( rRect ); + OSL_ENSURE( !m_bTopRule, "DrawFlyRect: Wrong TopRule" ); + // #i68520# + const SwAnchoredObjList::size_type nCount( m_bOn ? GetAnchoredObjList().size() : 0 ); + if (nCount > 0) + { + const SdrLayerID nHellId = m_pPage->getRootFrame()->GetCurrShell()->getIDocumentDrawModelAccess().GetHellId(); + for( SwAnchoredObjList::size_type i = 0; i < nCount; ++i ) + { + // #i68520# + const SwAnchoredObject* pAnchoredObjTmp = (*mpAnchoredObjList)[i]; + if (mpCurrAnchoredObj == pAnchoredObjTmp) + continue; + + // #i68520# + const SwFlyFrame* pFly = pAnchoredObjTmp->DynCastFlyFrame(); + if (pFly) + { + // #i68520# + const SwFormatSurround& rSur = pAnchoredObjTmp->GetFrameFormat().GetSurround(); + + // OD 24.01.2003 #106593# - correct clipping of fly frame area. + // Consider that fly frame background/shadow can be transparent + // and fly frame area + // #i47804# - consider transparent graphics + // and OLE objects. + bool bClipFlyArea = + ( ( css::text::WrapTextMode_THROUGH == rSur.GetSurround() ) + // #i68520# + ? (pAnchoredObjTmp->GetDrawObj()->GetLayer() != nHellId) + : !rSur.IsContour() ) && + !pFly->IsBackgroundTransparent() && + ( !pFly->Lower() || + !pFly->Lower()->IsNoTextFrame() || + !static_cast(pFly->Lower())->IsTransparent() ); + if ( bClipFlyArea ) + { + // #i68520# + SwRect aFly( pAnchoredObjTmp->GetObjRect() ); + // OD 24.01.2003 #106593# + ::SwAlignRect( aFly, m_pPage->getRootFrame()->GetCurrShell(), pOut ); + if( !aFly.IsEmpty() ) + aRegion -= aFly; + } + } + } + } + + for( size_t i = 0; i < aRegion.size(); ++i ) + { + pOut->DrawRect( aRegion[i].SVRect() ); + } +} + +/** + * #i26945# - change first parameter + * Now it's the instance of the floating screen object + */ +bool SwTextFly::GetTop( const SwAnchoredObject* _pAnchoredObj, + const bool bInFootnote, + const bool bInFooterOrHeader ) +{ + // #i68520# + // is set, if is inside a fly frame + if( _pAnchoredObj != mpCurrAnchoredObj ) + { + // #i26945# + const SdrObject* pNew = _pAnchoredObj->GetDrawObj(); + // #102344# Ignore connectors which have one or more connections + if (const SdrEdgeObj* pEdgeObj = dynamic_cast(pNew)) + { + if (pEdgeObj->GetConnectedNode(true) || pEdgeObj->GetConnectedNode(false)) + { + return false; + } + } + + if( ( bInFootnote || bInFooterOrHeader ) && m_bTopRule ) + { + // #i26945# + const SwFrameFormat& rFrameFormat = _pAnchoredObj->GetFrameFormat(); + const SwFormatAnchor& rNewA = rFrameFormat.GetAnchor(); + if (RndStdIds::FLY_AT_PAGE == rNewA.GetAnchorId()) + { + if ( bInFootnote ) + return false; + + if ( bInFooterOrHeader ) + { + const SwFormatVertOrient& aVert( rFrameFormat.GetVertOrient() ); + bool bVertPrt = aVert.GetRelationOrient() == text::RelOrientation::PRINT_AREA || + aVert.GetRelationOrient() == text::RelOrientation::PAGE_PRINT_AREA; + if( bVertPrt ) + return false; + } + } + } + + // #i68520# + // bEvade: consider pNew, if we are not inside a fly + // consider pNew, if pNew is lower of + bool bEvade = !mpCurrAnchoredObj || + Is_Lower_Of( mpCurrAnchoredObj->DynCastFlyFrame(), pNew); + + auto pFly = _pAnchoredObj->DynCastFlyFrame(); + if (pFly && pFly->IsFlySplitAllowed()) + { + // Check if _pAnchoredObj is a split fly inside an other split fly. Always collect such + // flys, otherwise the inner anchor text will overlap with the inner fly. + SwFrame* pFlyAnchor = const_cast(_pAnchoredObj) + ->GetAnchorFrameContainingAnchPos(); + if (pFlyAnchor && pFlyAnchor->IsInFly()) + { + auto pOuterFly = pFlyAnchor->FindFlyFrame(); + if (pOuterFly && pOuterFly->IsFlySplitAllowed()) + { + return true; + } + } + } + + if ( !bEvade ) + { + // We are currently inside a fly frame and pNew is not + // inside this fly frame. We can do some more checks if + // we have to consider pNew. + + // If bTopRule is not set, we ignore the frame types. + // We directly check the z-order + if ( !m_bTopRule ) + bEvade = true; + else + { + // Within chained Flys we only avoid Lower + // #i68520# + const SwFormatChain &rChain = mpCurrAnchoredObj->GetFrameFormat().GetChain(); + if ( !rChain.GetPrev() && !rChain.GetNext() ) + { + // #i26945# + const SwFormatAnchor& rNewA = _pAnchoredObj->GetFrameFormat().GetAnchor(); + // #i68520# + const SwFormatAnchor& rCurrA = mpCurrAnchoredObj->GetFrameFormat().GetAnchor(); + + // If is anchored as character, its content + // does not wrap around pNew + if (RndStdIds::FLY_AS_CHAR == rCurrA.GetAnchorId()) + return false; + + // If pNew is anchored to page and does not wrap around pNew + // If both pNew and are anchored to page, we can do + // some more checks + if (RndStdIds::FLY_AT_PAGE == rNewA.GetAnchorId()) + { + if (RndStdIds::FLY_AT_PAGE == rCurrA.GetAnchorId()) + { + bEvade = true; + } + else + return false; + } + else if (RndStdIds::FLY_AT_PAGE == rCurrA.GetAnchorId()) + return false; // Page anchored ones only avoid page anchored ones + else if (RndStdIds::FLY_AT_FLY == rNewA.GetAnchorId()) + bEvade = true; // Non-page anchored ones avoid frame anchored ones + else if( RndStdIds::FLY_AT_FLY == rCurrA.GetAnchorId() ) + return false; // Frame anchored ones do not avoid paragraph anchored ones + // #i57062# + // In order to avoid loop situation, it's decided to adjust + // the wrapping behaviour of content of at-paragraph/at-character + // anchored objects to one in the page header/footer and + // the document body --> content of at-paragraph/at-character + // anchored objects doesn't wrap around each other. + else + return false; + } + } + + // But: we never avoid a subordinate one and additionally we only avoid when overlapping. + // #i68520# + bEvade &= ( mpCurrAnchoredObj->GetDrawObj()->GetOrdNum() < pNew->GetOrdNum() ); + if( bEvade ) + { + // #i68520# + const SwRect& aTmp( _pAnchoredObj->GetObjRectWithSpaces() ); + if ( !aTmp.Overlaps( mpCurrAnchoredObj->GetObjRectWithSpaces() ) ) + bEvade = false; + } + } + + if ( bEvade ) + { + // #i26945# + const SwFormatAnchor& rNewA = _pAnchoredObj->GetFrameFormat().GetAnchor(); + OSL_ENSURE( RndStdIds::FLY_AS_CHAR != rNewA.GetAnchorId(), + "Don't call GetTop with a FlyInContentFrame" ); + if (RndStdIds::FLY_AT_PAGE == rNewA.GetAnchorId()) + return true; // We always avoid page anchored ones + + // If Flys anchored at paragraph are caught in a FlyCnt, then + // their influence ends at the borders of the FlyCnt! + // If we are currently formatting the text of the FlyCnt, then + // it has to get out of the way of the Frame anchored at paragraph! + // m_pCurrFrame is the anchor of pNew? + // #i26945# + const SwFrame* pTmp = _pAnchoredObj->GetAnchorFrame(); + if (pTmp == m_pCurrFrame) + return true; + if( pTmp->IsTextFrame() && ( pTmp->IsInFly() || pTmp->IsInFootnote() ) ) + { + // #i26945# + Point aPos = _pAnchoredObj->GetObjRect().Pos(); + pTmp = GetVirtualUpper( pTmp, aPos ); + } + // #i26945# + // If is a text frame inside a table, take the upper + // of the anchor frame, which contains the anchor position. + else if ( pTmp->IsTextFrame() && pTmp->IsInTab() ) + { + pTmp = const_cast(_pAnchoredObj) + ->GetAnchorFrameContainingAnchPos()->GetUpper(); + } + // #i28701# - consider all objects in same context, + // if wrapping style is considered on object positioning. + // Thus, text will wrap around negative positioned objects. + // #i3317# - remove condition on checking, + // if wrappings style is considered on object positioning. + // Thus, text is wrapping around negative positioned objects. + // #i35640# - no consideration of negative + // positioned objects, if wrapping style isn't considered on + // object position and former text wrapping is applied. + // This condition is typically for documents imported from the + // OpenOffice.org file format. + const IDocumentSettingAccess* pIDSA = &m_pCurrFrame->GetDoc().getIDocumentSettingAccess(); + if ( ( pIDSA->get(DocumentSettingId::CONSIDER_WRAP_ON_OBJECT_POSITION) || + !pIDSA->get(DocumentSettingId::USE_FORMER_TEXT_WRAPPING) ) && + ::FindContext( pTmp, SwFrameType::None ) == ::FindContext(m_pCurrFrame, SwFrameType::None)) + { + return true; + } + + const SwFrame* pHeader = nullptr; + if (m_pCurrFrame->GetNext() != pTmp && + (IsFrameInSameContext( pTmp, m_pCurrFrame ) || + // #i13832#, #i24135# wrap around objects in page header + ( !pIDSA->get(DocumentSettingId::USE_FORMER_TEXT_WRAPPING) && + nullptr != ( pHeader = pTmp->FindFooterOrHeader() ) && + m_pCurrFrame->IsInDocBody()))) + { + if( pHeader || RndStdIds::FLY_AT_FLY == rNewA.GetAnchorId() ) + return true; + + // Compare indices: + // The Index of the other is retrieved from the anchor attr. + SwNodeOffset nTmpIndex = rNewA.GetAnchorNode()->GetIndex(); + // Now check whether the current paragraph is before the anchor + // of the displaced object in the text, then we don't have to + // get out of its way. + // If possible determine Index via SwFormatAnchor because + // otherwise it's quite expensive. + if (NODE_OFFSET_MAX == m_nCurrFrameNodeIndex) + m_nCurrFrameNodeIndex = m_pCurrFrame->GetTextNodeFirst()->GetIndex(); + + if (FrameContainsNode(*m_pCurrFrame, nTmpIndex) || nTmpIndex < m_nCurrFrameNodeIndex) + return true; + } + } + } + return false; +} + +SwRect SwTextFly::GetFrameArea() const +{ + // i#28701 - consider complete frame area for new text wrapping + SwRect aRect; + if (m_pCurrFrame->GetDoc().getIDocumentSettingAccess().get(DocumentSettingId::USE_FORMER_TEXT_WRAPPING)) + { + aRect = m_pCurrFrame->getFramePrintArea(); + aRect += m_pCurrFrame->getFrameArea().Pos(); + } + else + { + aRect = m_pCurrFrame->getFrameArea(); + } + return aRect; +} + +// #i68520# +SwAnchoredObjList& SwTextFly::InitAnchoredObjList() +{ + OSL_ENSURE( m_pCurrFrame, "InitFlyList: No Frame, no FlyList" ); + // #i68520# + OSL_ENSURE( !mpAnchoredObjList, "InitFlyList: FlyList already initialized" ); + + SwSwapIfSwapped swap(const_cast(m_pCurrFrame)); + + const SwSortedObjs *pSorted = m_pPage->GetSortedObjs(); + const size_t nCount = pSorted ? pSorted->size() : 0; + // --> #108724# Page header/footer content doesn't have to wrap around + // floating screen objects + // which was added simply to be compatible with MS Office. + // MSO still allows text to wrap around in-table-flies in headers/footers/footnotes + const bool bFooterHeader = nullptr != m_pCurrFrame->FindFooterOrHeader(); + const IDocumentSettingAccess* pIDSA = &m_pCurrFrame->GetDoc().getIDocumentSettingAccess(); + // #i40155# - check, if frame is marked not to wrap + const bool bAllowCompatWrap = m_pCurrFrame->IsInTab() && (bFooterHeader || m_pCurrFrame->IsInFootnote()); + const bool bWrapAllowed = ( pIDSA->get(DocumentSettingId::USE_FORMER_TEXT_WRAPPING) || + bAllowCompatWrap || + (!m_pCurrFrame->IsInFootnote() && !bFooterHeader)); + + m_bOn = false; + + // #i68520# + mpAnchoredObjList.reset(new SwAnchoredObjList); + + if( nCount && bWrapAllowed ) + { + SwRect const aRect(GetFrameArea()); + // Make ourselves a little smaller than we are, + // so that 1-Twip-overlappings are ignored (#49532) + SwRectFnSet aRectFnSet(m_pCurrFrame); + const tools::Long nRight = aRectFnSet.GetRight(aRect) - 1; + const tools::Long nLeft = aRectFnSet.GetLeft(aRect) + 1; + const bool bR2L = m_pCurrFrame->IsRightToLeft(); + + const IDocumentDrawModelAccess& rIDDMA = m_pCurrFrame->GetDoc().getIDocumentDrawModelAccess(); + + for( size_t i = 0; i < nCount; ++i ) + { + // #i68520# + // do not consider hidden objects + // check, if object has to be considered for text wrap + // #118809# - If requested, do not consider + // objects in page header|footer for text frames not in page + // header|footer. This is requested for the calculation of + // the base offset for objects + // #i20505# Do not consider oversized objects + SwAnchoredObject* pAnchoredObj = (*pSorted)[ i ]; + assert(pAnchoredObj); + if ( !pAnchoredObj || + !rIDDMA.IsVisibleLayerId( pAnchoredObj->GetDrawObj()->GetLayer() ) || + !pAnchoredObj->ConsiderForTextWrap() || + ( mbIgnoreObjsInHeaderFooter && !bFooterHeader && + pAnchoredObj->GetAnchorFrame()->FindFooterOrHeader() ) || + ( bAllowCompatWrap && !pAnchoredObj->GetFrameFormat().GetFollowTextFlow().GetValue() ) + ) + { + continue; + } + + const SwRect aBound( pAnchoredObj->GetObjRectWithSpaces() ); + if ( nRight < aRectFnSet.GetLeft(aBound) || + aRectFnSet.YDiff( aRectFnSet.GetTop(aRect), + aRectFnSet.GetBottom(aBound) ) > 0 || + nLeft > aRectFnSet.GetRight(aBound) || + aRectFnSet.GetHeight(aBound) > + 2 * aRectFnSet.GetHeight(m_pPage->getFrameArea()) ) + { + continue; + } + + // #i26945# - pass to method + // instead of only the instance of the + // anchored object + if (GetTop(pAnchoredObj, m_pCurrFrame->IsInFootnote(), bFooterHeader)) + { + // OD 11.03.2003 #107862# - adjust insert position: + // overlapping objects should be sorted from left to right and + // inside left to right sorting from top to bottom. + // If objects on the same position are found, they are sorted + // on its width. + // #i68520# + { + SwAnchoredObjList::iterator aInsPosIter = + std::lower_bound( mpAnchoredObjList->begin(), + mpAnchoredObjList->end(), + pAnchoredObj, + AnchoredObjOrder( bR2L, aRectFnSet.FnRect() ) ); + + mpAnchoredObjList->insert( aInsPosIter, pAnchoredObj ); + } + + const SwFormatSurround &rFlyFormat = pAnchoredObj->GetFrameFormat().GetSurround(); + // #i68520# + if ( rFlyFormat.IsAnchorOnly() && + pAnchoredObj->GetAnchorFrame() == GetMaster() ) + { + const SwFormatVertOrient &rTmpFormat = + pAnchoredObj->GetFrameFormat().GetVertOrient(); + if( text::VertOrientation::BOTTOM != rTmpFormat.GetVertOrient() ) + m_nMinBottom = ( aRectFnSet.IsVert() && m_nMinBottom ) ? + std::min( m_nMinBottom, aBound.Left() ) : + std::max( m_nMinBottom, aRectFnSet.GetBottom(aBound) ); + } + + m_bOn = true; + } + } + if( m_nMinBottom ) + { + SwTwips nMax = aRectFnSet.GetPrtBottom(*m_pCurrFrame->GetUpper()); + if( aRectFnSet.YDiff( m_nMinBottom, nMax ) > 0 ) + m_nMinBottom = nMax; + } + } + + // #i68520# + return *mpAnchoredObjList; +} + +SwTwips SwTextFly::CalcMinBottom() const +{ + SwTwips nRet = 0; + const SwContentFrame *pLclMaster = GetMaster(); + OSL_ENSURE(pLclMaster, "SwTextFly without master"); + const SwSortedObjs *pDrawObj = pLclMaster ? pLclMaster->GetDrawObjs() : nullptr; + const size_t nCount = pDrawObj ? pDrawObj->size() : 0; + if( nCount ) + { + SwTwips nEndOfFrame = m_pCurrFrame->getFrameArea().Bottom(); + for( size_t i = 0; i < nCount; ++i ) + { + SwAnchoredObject* pAnchoredObj = (*pDrawObj)[ i ]; + const SwFormatSurround &rFlyFormat = pAnchoredObj->GetFrameFormat().GetSurround(); + if( rFlyFormat.IsAnchorOnly() ) + { + const SwFormatVertOrient &rTmpFormat = + pAnchoredObj->GetFrameFormat().GetVertOrient(); + if( text::VertOrientation::BOTTOM != rTmpFormat.GetVertOrient() ) + { + const SwRect& aBound( pAnchoredObj->GetObjRectWithSpaces() ); + if( aBound.Top() < nEndOfFrame ) + nRet = std::max( nRet, SwTwips(aBound.Bottom()) ); + } + } + } + SwTwips nMax = m_pCurrFrame->GetUpper()->getFrameArea().Top() + + m_pCurrFrame->GetUpper()->getFramePrintArea().Bottom(); + if( nRet > nMax ) + nRet = nMax; + } + return nRet; +} + +SwTwips SwTextFly::GetMaxBottom(const SwBreakPortion& rPortion, const SwTextFormatInfo& rInfo) const +{ + // Note that m_pCurrFrame is already swapped at this stage, so it's correct to bypass + // SwRectFnSet here. + SwTwips nRet = 0; + size_t nCount(m_bOn ? GetAnchoredObjList().size() : 0); + + // Get the horizontal position of the break portion in absolute twips. The frame area is in + // absolute twips, the frame's print area is relative to the frame area. Finally the portion's + // position is relative to the frame's print area. + SwTwips nX = rInfo.X(); + nX += m_pCurrFrame->getFrameArea().Left(); + nX += m_pCurrFrame->getFramePrintArea().Left(); + + for (size_t i = 0; i < nCount; ++i) + { + const SwAnchoredObject* pAnchoredObj = (*mpAnchoredObjList)[i]; + + if (pAnchoredObj->GetAnchorFrame()->FindFooterOrHeader()) + { + // Anchored in the header or footer, ignore it for clearing break purposes. + continue; + } + + SwRect aRect(pAnchoredObj->GetObjRectWithSpaces()); + + if (m_pCurrFrame->IsVertical()) + { + m_pCurrFrame->SwitchVerticalToHorizontal(aRect); + } + + if (rPortion.GetClear() == SwLineBreakClear::LEFT) + { + if (nX < aRect.Left()) + { + // Want to jump down to the first line that's unblocked on the left. This object is + // on the right of the break, ignore it. + continue; + } + } + if (rPortion.GetClear() == SwLineBreakClear::RIGHT) + { + if (nX > aRect.Right()) + { + // Want to jump down to the first line that's unblocked on the right. This object is + // on the left of the break, ignore it. + continue; + } + } + SwTwips nBottom = aRect.Top() + aRect.Height(); + if (nBottom > nRet) + { + nRet = nBottom; + } + } + return nRet; +} + +bool SwTextFly::ForEach( const SwRect &rRect, SwRect* pRect, bool bAvoid ) const +{ + SwSwapIfSwapped swap(const_cast(m_pCurrFrame)); + + // Optimization + SwRectFnSet aRectFnSet(m_pCurrFrame); + + // tdf#127235 stop if the area is larger than the page + if( aRectFnSet.GetHeight(m_pPage->getFrameArea()) < aRectFnSet.GetHeight(rRect)) + { + // get the doc model description + const SwPageDesc* pPageDesc = m_pPage->GetPageDesc(); + + // if there is no next page style or it is the same as the current + // => stop trying to place the frame (it would end in an infinite loop) + if( pPageDesc && + ( !pPageDesc->GetFollow() || pPageDesc->GetFollow() == pPageDesc) ) + { + return false; + } + } + + bool bRet = false; + // #i68520# + const SwAnchoredObjList::size_type nCount( m_bOn ? GetAnchoredObjList().size() : 0 ); + if (nCount > 0) + { + for( SwAnchoredObjList::size_type i = 0; i < nCount; ++i ) + { + // #i68520# + const SwAnchoredObject* pAnchoredObj = (*mpAnchoredObjList)[i]; + + SwRect aRect( pAnchoredObj->GetObjRectWithSpaces() ); + + if( aRectFnSet.GetLeft(aRect) > aRectFnSet.GetRight(rRect) ) + break; + + // #i68520# + if ( mpCurrAnchoredObj != pAnchoredObj && aRect.Overlaps( rRect ) ) + { + // #i68520# + const SwFormat* pFormat( &(pAnchoredObj->GetFrameFormat()) ); + const SwFormatSurround &rSur = pFormat->GetSurround(); + if( bAvoid ) + { + // If the text flows below, it has no influence on + // formatting. In LineIter::DrawText() it is "just" + // necessary to cleverly set the ClippingRegions + const SwFormatAnchor& rAnchor = pFormat->GetAnchor(); + if( ( css::text::WrapTextMode_THROUGH == rSur.GetSurround() && + ( !rSur.IsAnchorOnly() || + // #i68520# + GetMaster() == pAnchoredObj->GetAnchorFrame() || + ((RndStdIds::FLY_AT_PARA != rAnchor.GetAnchorId()) && + (RndStdIds::FLY_AT_CHAR != rAnchor.GetAnchorId())) ) ) + || aRect.Top() == FAR_AWAY ) + continue; + } + + // #i58642# + // Compare instead of with the + // anchor frame of the anchored object, because a follow frame + // has to ignore the anchored objects of its master frame. + // Note: Anchored objects are always registered at the master + // frame, exception are as-character anchored objects, + // but these aren't handled here. + // #i68520# + if ( mbIgnoreCurrentFrame && + GetMaster() == pAnchoredObj->GetAnchorFrame() ) + continue; + + if( pRect ) + { + // #i68520# + SwRect aFly = AnchoredObjToRect( pAnchoredObj, rRect ); + if( aFly.IsEmpty() || !aFly.Overlaps( rRect ) ) + continue; + if( !bRet || ( + (!m_pCurrFrame->IsRightToLeft() && + ( aRectFnSet.GetLeft(aFly) < + aRectFnSet.GetLeft(*pRect) ) ) || + (m_pCurrFrame->IsRightToLeft() && + ( aRectFnSet.GetRight(aFly) > + aRectFnSet.GetRight(*pRect) ) ) ) ) + *pRect = aFly; + if( rSur.IsContour() ) + { + bRet = true; + continue; + } + } + bRet = true; + break; + } + } + } + + return bRet; +} + +// #i68520# +SwAnchoredObjList::size_type SwTextFly::GetPos( const SwAnchoredObject* pAnchoredObj ) const +{ + SwAnchoredObjList::size_type nCount = GetAnchoredObjList().size(); + SwAnchoredObjList::size_type nRet = 0; + while ( nRet < nCount && pAnchoredObj != (*mpAnchoredObjList)[ nRet ] ) + ++nRet; + return nRet; +} + +// #i68520# +void SwTextFly::CalcRightMargin( SwRect &rFly, + SwAnchoredObjList::size_type nFlyPos, + const SwRect &rLine ) const +{ + // Usually the right margin is the right margin of the Printarea + OSL_ENSURE( !m_pCurrFrame->IsVertical() || !m_pCurrFrame->IsSwapped(), + "SwTextFly::CalcRightMargin with swapped frame" ); + SwRectFnSet aRectFnSet(m_pCurrFrame); + // #118796# - correct determination of right of printing area + SwTwips nRight = aRectFnSet.GetPrtRight(*m_pCurrFrame); + SwTwips nFlyRight = aRectFnSet.GetRight(rFly); + SwRect aLine( rLine ); + aRectFnSet.SetRight( aLine, nRight ); + aRectFnSet.SetLeft( aLine, aRectFnSet.GetLeft(rFly) ); + + // It is possible that there is another object that is _above_ us + // and protrudes into the same line. + // Flys with run-through are invisible for those below, i.e., they + // are ignored for computing the margins of other Flys. + // 3301: pNext->getFrameArea().Overlaps( rLine ) is necessary + // #i68520# + css::text::WrapTextMode eSurroundForTextWrap; + + bool bStop = false; + // #i68520# + SwAnchoredObjList::size_type nPos = 0; + + // #i68520# + while( nPos < mpAnchoredObjList->size() && !bStop ) + { + if( nPos == nFlyPos ) + { + ++nPos; + continue; + } + // #i68520# + const SwAnchoredObject* pNext = (*mpAnchoredObjList)[ nPos++ ]; + if ( pNext == mpCurrAnchoredObj ) + continue; + eSurroundForTextWrap = GetSurroundForTextWrap( pNext ); + if( css::text::WrapTextMode_THROUGH == eSurroundForTextWrap ) + continue; + + const SwRect aTmp( SwContourCache::CalcBoundRect + ( pNext, aLine, m_pCurrFrame, nFlyRight, true ) ); + SwTwips nTmpRight = aRectFnSet.GetRight(aTmp); + + // optimization: + // Record in nNextTop at which Y-position frame related changes are + // likely. This is so that, despite only looking at frames in the + // current line height, for frames without wrap the line height is + // incremented so that with a single line the lower border of the frame + // (or possibly the upper border of another frame) is reached. + // Especially in HTML documents there are often (dummy) paragraphs in + // 2 pt font, and they used to only evade big frames after huge numbers + // of empty lines. + const tools::Long nTmpTop = aRectFnSet.GetTop(aTmp); + if( aRectFnSet.YDiff( nTmpTop, aRectFnSet.GetTop(aLine) ) > 0 ) + { + if( aRectFnSet.YDiff( m_nNextTop, nTmpTop ) > 0 ) + SetNextTop( nTmpTop ); // upper border of next frame + } + else if (!aRectFnSet.GetWidth(aTmp)) // typical for Objects with contour wrap + { // For Objects with contour wrap that start before the current + // line, and end below it, but do not actually overlap it, the + // optimization has to be disabled, because the circumstances + // can change in the next line. + if( ! aRectFnSet.GetHeight(aTmp) || + aRectFnSet.YDiff( aRectFnSet.GetBottom(aTmp), + aRectFnSet.GetTop(aLine) ) > 0 ) + SetNextTop( 0 ); + } + if( aTmp.Overlaps( aLine ) && nTmpRight > nFlyRight ) + { + nFlyRight = nTmpRight; + if( css::text::WrapTextMode_RIGHT == eSurroundForTextWrap || + css::text::WrapTextMode_PARALLEL == eSurroundForTextWrap ) + { + // overrule the FlyFrame + if( nRight > nFlyRight ) + nRight = nFlyRight; + bStop = true; + } + } + } + aRectFnSet.SetRight( rFly, nRight ); +} + +// #i68520# +void SwTextFly::CalcLeftMargin( SwRect &rFly, + SwAnchoredObjList::size_type nFlyPos, + const SwRect &rLine ) const +{ + OSL_ENSURE( !m_pCurrFrame->IsVertical() || !m_pCurrFrame->IsSwapped(), + "SwTextFly::CalcLeftMargin with swapped frame" ); + SwRectFnSet aRectFnSet(m_pCurrFrame); + // #118796# - correct determination of left of printing area + SwTwips nLeft = aRectFnSet.GetPrtLeft(*m_pCurrFrame); + const SwTwips nFlyLeft = aRectFnSet.GetLeft(rFly); + + if( nLeft > nFlyLeft ) + nLeft = rFly.Left(); + + SwRect aLine( rLine ); + aRectFnSet.SetLeft( aLine, nLeft ); + + // It is possible that there is another object that is _above_ us + // and protrudes into the same line. + // Flys with run-through are invisible for those below, i.e., they + // are ignored for computing the margins of other Flys. + // 3301: pNext->getFrameArea().Overlaps( rLine ) is necessary + + // #i68520# + SwAnchoredObjList::size_type nMyPos = nFlyPos; + while( ++nFlyPos < mpAnchoredObjList->size() ) + { + // #i68520# + const SwAnchoredObject* pNext = (*mpAnchoredObjList)[ nFlyPos ]; + const SwRect& aTmp( pNext->GetObjRectWithSpaces() ); + if( aRectFnSet.GetLeft(aTmp) >= nFlyLeft ) + break; + } + + while( nFlyPos ) + { + if( --nFlyPos == nMyPos ) + continue; + // #i68520# + const SwAnchoredObject* pNext = (*mpAnchoredObjList)[ nFlyPos ]; + if( pNext == mpCurrAnchoredObj ) + continue; + css::text::WrapTextMode eSurroundForTextWrap = GetSurroundForTextWrap( pNext ); + if( css::text::WrapTextMode_THROUGH == eSurroundForTextWrap ) + continue; + + const SwRect aTmp( SwContourCache::CalcBoundRect + (pNext, aLine, m_pCurrFrame, nFlyLeft, false) ); + + if( aRectFnSet.GetLeft(aTmp) < nFlyLeft && aTmp.Overlaps( aLine ) ) + { + // #118796# - no '+1', because <..fnGetRight> + // returns the correct value. + SwTwips nTmpRight = aRectFnSet.GetRight(aTmp); + if ( nLeft <= nTmpRight ) + nLeft = nTmpRight; + + break; + } + } + aRectFnSet.SetLeft( rFly, nLeft ); +} + +// #i68520# +SwRect SwTextFly::AnchoredObjToRect( const SwAnchoredObject* pAnchoredObj, + const SwRect &rLine ) const +{ + SwRectFnSet aRectFnSet(m_pCurrFrame); + + const tools::Long nXPos = m_pCurrFrame->IsRightToLeft() ? + rLine.Right() : + aRectFnSet.GetLeft(rLine); + + SwRect aFly = mbIgnoreContour ? + pAnchoredObj->GetObjRectWithSpaces() : + SwContourCache::CalcBoundRect(pAnchoredObj, rLine, m_pCurrFrame, + nXPos, !m_pCurrFrame->IsRightToLeft()); + + if( !aFly.Width() ) + return aFly; + + // so the line may grow up to the lower edge of the frame + SetNextTop( aRectFnSet.GetBottom(aFly) ); + SwAnchoredObjList::size_type nFlyPos = GetPos( pAnchoredObj ); + + // LEFT and RIGHT, we grow the rectangle. + // We have some problems, when several frames are to be seen. + // At the moment, only the easier case is assumed: + // + LEFT means that the text must flow on the left of the frame, + // that is the frame expands to the right edge of the print area + // or to the next frame. + // + RIGHT is the opposite. + // Otherwise the set distance between text and frame is always + // added up. + switch( GetSurroundForTextWrap( pAnchoredObj ) ) + { + case css::text::WrapTextMode_LEFT : + { + CalcRightMargin( aFly, nFlyPos, rLine ); + break; + } + case css::text::WrapTextMode_RIGHT : + { + CalcLeftMargin( aFly, nFlyPos, rLine ); + break; + } + case css::text::WrapTextMode_NONE : + { + CalcRightMargin( aFly, nFlyPos, rLine ); + CalcLeftMargin( aFly, nFlyPos, rLine ); + break; + } + default: + break; + } + return aFly; +} + +// #i68520# + +// Wrap only on sides with at least 2cm space for the text +#define TEXT_MIN 1134 + +// Wrap on both sides up to a frame width of 1.5cm +#define FRAME_MAX 850 + +css::text::WrapTextMode SwTextFly::GetSurroundForTextWrap( const SwAnchoredObject* pAnchoredObj ) const +{ + const SwFrameFormat* pFormat = &(pAnchoredObj->GetFrameFormat()); + const SwFormatSurround &rFlyFormat = pFormat->GetSurround(); + css::text::WrapTextMode eSurroundForTextWrap = rFlyFormat.GetSurround(); + + if( rFlyFormat.IsAnchorOnly() && pAnchoredObj->GetAnchorFrame() != GetMaster() ) + { + const SwFormatAnchor& rAnchor = pFormat->GetAnchor(); + if ((RndStdIds::FLY_AT_PARA == rAnchor.GetAnchorId()) || + (RndStdIds::FLY_AT_CHAR == rAnchor.GetAnchorId())) + { + return css::text::WrapTextMode_NONE; + } + } + + // in cause of run-through and nowrap ignore smartly + if( css::text::WrapTextMode_THROUGH == eSurroundForTextWrap || + css::text::WrapTextMode_NONE == eSurroundForTextWrap ) + return eSurroundForTextWrap; + + // left is left and right is right + if (m_pCurrFrame->IsRightToLeft()) + { + if ( css::text::WrapTextMode_LEFT == eSurroundForTextWrap ) + eSurroundForTextWrap = css::text::WrapTextMode_RIGHT; + else if ( css::text::WrapTextMode_RIGHT == eSurroundForTextWrap ) + eSurroundForTextWrap = css::text::WrapTextMode_LEFT; + } + + // "ideal page wrap": + if ( css::text::WrapTextMode_DYNAMIC == eSurroundForTextWrap ) + { + SwRectFnSet aRectFnSet(m_pCurrFrame); + const tools::Long nCurrLeft = aRectFnSet.GetPrtLeft(*m_pCurrFrame); + const tools::Long nCurrRight = aRectFnSet.GetPrtRight(*m_pCurrFrame); + const SwRect& aRect( pAnchoredObj->GetObjRectWithSpaces() ); + tools::Long nFlyLeft = aRectFnSet.GetLeft(aRect); + tools::Long nFlyRight = aRectFnSet.GetRight(aRect); + + if ( nFlyRight < nCurrLeft || nFlyLeft > nCurrRight ) + eSurroundForTextWrap = css::text::WrapTextMode_PARALLEL; + else + { + tools::Long nLeft = nFlyLeft - nCurrLeft; + tools::Long nRight = nCurrRight - nFlyRight; + if( nFlyRight - nFlyLeft > FRAME_MAX ) + { + if( nLeft < nRight ) + nLeft = 0; + else + nRight = 0; + } + const int textMin = GetMaster()->GetDoc() + .getIDocumentSettingAccess().get(DocumentSettingId::SURROUND_TEXT_WRAP_SMALL ) + ? TEXT_MIN_SMALL : TEXT_MIN; + + // In case there is no space on either side, then css::text::WrapTextMode_PARALLEL + // gives the same result when doing the initial layout or a layout + // update after editing, so prefer that over css::text::WrapTextMode_NONE. + if (nLeft == 0 && nRight == 0) + return css::text::WrapTextMode_PARALLEL; + + if( nLeft < textMin ) + nLeft = 0; + if( nRight < textMin ) + nRight = 0; + if( nLeft ) + eSurroundForTextWrap = nRight ? css::text::WrapTextMode_PARALLEL : css::text::WrapTextMode_LEFT; + else + eSurroundForTextWrap = nRight ? css::text::WrapTextMode_RIGHT: css::text::WrapTextMode_NONE; + } + } + + return eSurroundForTextWrap; +} + +bool SwTextFly::IsAnyFrame( const SwRect &rLine ) const +{ + + SwSwapIfSwapped swap(const_cast(m_pCurrFrame)); + + OSL_ENSURE( m_bOn, "IsAnyFrame: Why?" ); + + return ForEach( rLine, nullptr, false ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/txtfrm.cxx b/sw/source/core/text/txtfrm.cxx new file mode 100644 index 0000000000..18eb78db83 --- /dev/null +++ b/sw/source/core/text/txtfrm.cxx @@ -0,0 +1,4219 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "itrform2.hxx" +#include "widorp.hxx" +#include "txtcache.hxx" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +namespace sw { + + MergedAttrIterBase::MergedAttrIterBase(SwTextFrame const& rFrame) + : m_pMerged(rFrame.GetMergedPara()) + , m_pNode(m_pMerged ? nullptr : rFrame.GetTextNodeFirst()) + , m_CurrentExtent(0) + , m_CurrentHint(0) + { + } + + SwTextAttr const* MergedAttrIter::NextAttr(SwTextNode const** ppNode) + { + if (m_pMerged) + { + while (m_CurrentExtent < m_pMerged->extents.size()) + { + sw::Extent const& rExtent(m_pMerged->extents[m_CurrentExtent]); + if (SwpHints const*const pHints = rExtent.pNode->GetpSwpHints()) + { + while (m_CurrentHint < pHints->Count()) + { + SwTextAttr *const pHint(pHints->Get(m_CurrentHint)); + if (rExtent.nEnd < pHint->GetStart() + // <= if it has no end or isn't empty + || (rExtent.nEnd == pHint->GetStart() + && (!pHint->GetEnd() + || *pHint->GetEnd() != pHint->GetStart()))) + { + break; + } + ++m_CurrentHint; + if (rExtent.nStart <= pHint->GetStart()) + { + if (ppNode) + { + *ppNode = rExtent.pNode; + } + return pHint; + } + } + } + ++m_CurrentExtent; + if (m_CurrentExtent < m_pMerged->extents.size() && + rExtent.pNode != m_pMerged->extents[m_CurrentExtent].pNode) + { + m_CurrentHint = 0; // reset + } + } + return nullptr; + } + else + { + SwpHints const*const pHints(m_pNode->GetpSwpHints()); + if (pHints) + { + if (m_CurrentHint < pHints->Count()) + { + SwTextAttr const*const pHint(pHints->Get(m_CurrentHint)); + ++m_CurrentHint; + if (ppNode) + { + *ppNode = m_pNode; + } + return pHint; + } + } + return nullptr; + } + } + + MergedAttrIterByEnd::MergedAttrIterByEnd(SwTextFrame const& rFrame) + : m_pNode(rFrame.GetMergedPara() ? nullptr : rFrame.GetTextNodeFirst()) + , m_CurrentHint(0) + { + if (!m_pNode) + { + MergedAttrIterReverse iter(rFrame); + SwTextNode const* pNode(nullptr); + while (SwTextAttr const* pHint = iter.PrevAttr(&pNode)) + { + m_Hints.emplace_back(pNode, pHint); + } + } + } + + SwTextAttr const* MergedAttrIterByEnd::NextAttr(SwTextNode const*& rpNode) + { + if (m_pNode) + { + SwpHints const*const pHints(m_pNode->GetpSwpHints()); + if (pHints) + { + if (m_CurrentHint < pHints->Count()) + { + SwTextAttr const*const pHint( + pHints->GetSortedByEnd(m_CurrentHint)); + ++m_CurrentHint; + rpNode = m_pNode; + return pHint; + } + } + return nullptr; + } + else + { + if (m_CurrentHint < m_Hints.size()) + { + auto const ret = m_Hints[m_Hints.size() - m_CurrentHint - 1]; + ++m_CurrentHint; + rpNode = ret.first; + return ret.second; + } + return nullptr; + } + } + + void MergedAttrIterByEnd::PrevAttr() + { + assert(0 < m_CurrentHint); // should only rewind as far as 0 + --m_CurrentHint; + } + + MergedAttrIterReverse::MergedAttrIterReverse(SwTextFrame const& rFrame) + : MergedAttrIterBase(rFrame) + { + if (m_pMerged) + { + m_CurrentExtent = m_pMerged->extents.size(); + SwpHints const*const pHints(0 < m_CurrentExtent + ? m_pMerged->extents[m_CurrentExtent-1].pNode->GetpSwpHints() + : nullptr); + if (pHints) + { + pHints->SortIfNeedBe(); + m_CurrentHint = pHints->Count(); + } + } + else + { + if (SwpHints const*const pHints = m_pNode->GetpSwpHints()) + { + pHints->SortIfNeedBe(); + m_CurrentHint = pHints->Count(); + } + } + } + + SwTextAttr const* MergedAttrIterReverse::PrevAttr(SwTextNode const** ppNode) + { + if (m_pMerged) + { + while (0 < m_CurrentExtent) + { + sw::Extent const& rExtent(m_pMerged->extents[m_CurrentExtent-1]); + if (SwpHints const*const pHints = rExtent.pNode->GetpSwpHints()) + { + while (0 < m_CurrentHint) + { + SwTextAttr *const pHint( + pHints->GetSortedByEnd(m_CurrentHint - 1)); + if (pHint->GetAnyEnd() < rExtent.nStart + // <= if it has end and isn't empty + || (pHint->GetEnd() + && *pHint->GetEnd() != pHint->GetStart() + && *pHint->GetEnd() == rExtent.nStart)) + { + break; + } + --m_CurrentHint; + if (pHint->GetAnyEnd() <= rExtent.nEnd) + { + if (ppNode) + { + *ppNode = rExtent.pNode; + } + return pHint; + } + } + } + --m_CurrentExtent; + if (0 < m_CurrentExtent && + rExtent.pNode != m_pMerged->extents[m_CurrentExtent-1].pNode) + { + SwpHints const*const pHints( + m_pMerged->extents[m_CurrentExtent-1].pNode->GetpSwpHints()); + m_CurrentHint = pHints ? pHints->Count() : 0; // reset + if (pHints) + pHints->SortIfNeedBe(); + } + } + return nullptr; + } + else + { + SwpHints const*const pHints(m_pNode->GetpSwpHints()); + if (pHints && 0 < m_CurrentHint) + { + SwTextAttr const*const pHint(pHints->GetSortedByEnd(m_CurrentHint - 1)); + --m_CurrentHint; + if (ppNode) + { + *ppNode = m_pNode; + } + return pHint; + } + return nullptr; + } + } + + bool FrameContainsNode(SwContentFrame const& rFrame, SwNodeOffset const nNodeIndex) + { + if (rFrame.IsTextFrame()) + { + SwTextFrame const& rTextFrame(static_cast(rFrame)); + if (sw::MergedPara const*const pMerged = rTextFrame.GetMergedPara()) + { + SwNodeOffset const nFirst(pMerged->pFirstNode->GetIndex()); + SwNodeOffset const nLast(pMerged->pLastNode->GetIndex()); + return (nFirst <= nNodeIndex && nNodeIndex <= nLast); + } + else + { + return rTextFrame.GetTextNodeFirst()->GetIndex() == nNodeIndex; + } + } + else + { + assert(rFrame.IsNoTextFrame()); + return static_cast(rFrame).GetNode()->GetIndex() == nNodeIndex; + } + } + + bool IsParaPropsNode(SwRootFrame const& rLayout, SwTextNode const& rNode) + { + if (rLayout.HasMergedParas()) + { + if (SwTextFrame const*const pFrame = static_cast(rNode.getLayoutFrame(&rLayout))) + { + sw::MergedPara const*const pMerged(pFrame->GetMergedPara()); + if (pMerged && pMerged->pParaPropsNode != &rNode) + { + return false; + } + } + } + return true; + } + + SwTextNode * + GetParaPropsNode(SwRootFrame const& rLayout, SwNode const& rPos) + { + const SwTextNode *const pTextNode(rPos.GetTextNode()); + if (pTextNode && !sw::IsParaPropsNode(rLayout, *pTextNode)) + { + return static_cast(pTextNode->getLayoutFrame(&rLayout))->GetMergedPara()->pParaPropsNode; + } + else + { + return const_cast(pTextNode); + } + } + + SwPosition + GetParaPropsPos(SwRootFrame const& rLayout, SwPosition const& rPos) + { + SwPosition pos(rPos); + SwTextNode const*const pNode(pos.GetNode().GetTextNode()); + if (pNode) + pos.Assign( *sw::GetParaPropsNode(rLayout, *pNode) ); + return pos; + } + + std::pair + GetFirstAndLastNode(SwRootFrame const& rLayout, SwNode const& rPos) + { + SwTextNode *const pTextNode(const_cast(rPos.GetTextNode())); + if (pTextNode && rLayout.HasMergedParas()) + { + if (SwTextFrame const*const pFrame = static_cast(pTextNode->getLayoutFrame(&rLayout))) + { + if (sw::MergedPara const*const pMerged = pFrame->GetMergedPara()) + { + return std::make_pair(pMerged->pFirstNode, const_cast(pMerged->pLastNode)); + } + } + } + return std::make_pair(pTextNode, pTextNode); + } + + SwTextNode const& GetAttrMerged(SfxItemSet & rFormatSet, + SwTextNode const& rNode, SwRootFrame const*const pLayout) + { + rNode.SwContentNode::GetAttr(rFormatSet); + if (pLayout && pLayout->HasMergedParas()) + { + auto pFrame = static_cast(rNode.getLayoutFrame(pLayout)); + if (sw::MergedPara const*const pMerged = pFrame ? pFrame->GetMergedPara() : nullptr) + { + if (pMerged->pFirstNode != &rNode) + { + rFormatSet.ClearItem(RES_PAGEDESC); + rFormatSet.ClearItem(RES_BREAK); + static_assert(RES_PAGEDESC + 1 == sal_uInt16(RES_BREAK), + "first-node items must be adjacent"); + SfxItemSetFixed firstSet(*rFormatSet.GetPool()); + pMerged->pFirstNode->SwContentNode::GetAttr(firstSet); + rFormatSet.Put(firstSet); + + } + if (pMerged->pParaPropsNode != &rNode) + { + for (sal_uInt16 i = RES_PARATR_BEGIN; i != RES_FRMATR_END; ++i) + { + if (i != RES_PAGEDESC && i != RES_BREAK) + { + rFormatSet.ClearItem(i); + } + } + for (sal_uInt16 i = XATTR_FILL_FIRST; i <= XATTR_FILL_LAST; ++i) + { + rFormatSet.ClearItem(i); + } + SfxItemSetFixed + propsSet(*rFormatSet.GetPool()); + pMerged->pParaPropsNode->SwContentNode::GetAttr(propsSet); + rFormatSet.Put(propsSet); + return *pMerged->pParaPropsNode; + } + // keep all the CHRATR/UNKNOWNATR anyway... + } + } + return rNode; + } + +} // namespace sw + +/// Switches width and height of the text frame +void SwTextFrame::SwapWidthAndHeight() +{ + { + SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*this); + + if ( ! mbIsSwapped ) + { + const tools::Long nPrtOfstX = aPrt.Pos().X(); + aPrt.Pos().setX( aPrt.Pos().Y() ); + + if( IsVertLR() ) + { + aPrt.Pos().setY( nPrtOfstX ); + } + else + { + aPrt.Pos().setY( getFrameArea().Width() - ( nPrtOfstX + aPrt.Width() ) ); + } + } + else + { + const tools::Long nPrtOfstY = aPrt.Pos().Y(); + aPrt.Pos().setY( aPrt.Pos().X() ); + + if( IsVertLR() ) + { + aPrt.Pos().setX( nPrtOfstY ); + } + else + { + aPrt.Pos().setX( getFrameArea().Height() - ( nPrtOfstY + aPrt.Height() ) ); + } + } + + const tools::Long nPrtWidth = aPrt.Width(); + aPrt.Width( aPrt.Height() ); + aPrt.Height( nPrtWidth ); + } + + { + const tools::Long nFrameWidth = getFrameArea().Width(); + SwFrameAreaDefinition::FrameAreaWriteAccess aFrm(*this); + aFrm.Width( aFrm.Height() ); + aFrm.Height( nFrameWidth ); + } + + mbIsSwapped = ! mbIsSwapped; +} + +/** + * Calculates the coordinates of a rectangle when switching from + * horizontal to vertical layout. + */ +void SwTextFrame::SwitchHorizontalToVertical( SwRect& rRect ) const +{ + // calc offset inside frame + tools::Long nOfstX, nOfstY; + if ( IsVertLR() ) + { + if (IsVertLRBT()) + { + // X and Y offsets here mean the position of the point that will be the top left corner + // after the switch. + nOfstX = rRect.Left() + rRect.Width() - getFrameArea().Left(); + nOfstY = rRect.Top() - getFrameArea().Top(); + } + else + { + nOfstX = rRect.Left() - getFrameArea().Left(); + nOfstY = rRect.Top() - getFrameArea().Top(); + } + } + else + { + nOfstX = rRect.Left() - getFrameArea().Left(); + nOfstY = rRect.Top() + rRect.Height() - getFrameArea().Top(); + } + + const tools::Long nWidth = rRect.Width(); + const tools::Long nHeight = rRect.Height(); + + if ( IsVertLR() ) + { + rRect.Left(getFrameArea().Left() + nOfstY); + } + else + { + if ( mbIsSwapped ) + rRect.Left( getFrameArea().Left() + getFrameArea().Height() - nOfstY ); + else + // frame is rotated + rRect.Left( getFrameArea().Left() + getFrameArea().Width() - nOfstY ); + } + + if (IsVertLRBT()) + { + if (mbIsSwapped) + rRect.Top(getFrameArea().Top() + getFrameArea().Width() - nOfstX); + else + rRect.Top(getFrameArea().Top() + getFrameArea().Height() - nOfstX); + } + else + rRect.Top(getFrameArea().Top() + nOfstX); + rRect.Width( nHeight ); + rRect.Height( nWidth ); +} + +/** + * Calculates the coordinates of a point when switching from + * horizontal to vertical layout. + */ +void SwTextFrame::SwitchHorizontalToVertical( Point& rPoint ) const +{ + if (IsVertLRBT()) + { + // The horizontal origo is the top left corner, the LRBT origo is the + // bottom left corner. Finally x and y has to be swapped. + SAL_WARN_IF(!mbIsSwapped, "sw.core", + "SwTextFrame::SwitchHorizontalToVertical, IsVertLRBT, not swapped"); + Point aPoint(rPoint); + rPoint.setX(getFrameArea().Left() + (aPoint.Y() - getFrameArea().Top())); + // This would be bottom - x delta, but bottom is top + height, finally + // width (and not height), as it's swapped. + rPoint.setY(getFrameArea().Top() + getFrameArea().Width() + - (aPoint.X() - getFrameArea().Left())); + return; + } + + // calc offset inside frame + const tools::Long nOfstX = rPoint.X() - getFrameArea().Left(); + const tools::Long nOfstY = rPoint.Y() - getFrameArea().Top(); + if ( IsVertLR() ) + rPoint.setX( getFrameArea().Left() + nOfstY ); + else + { + if ( mbIsSwapped ) + rPoint.setX( getFrameArea().Left() + getFrameArea().Height() - nOfstY ); + else + // calc rotated coords + rPoint.setX( getFrameArea().Left() + getFrameArea().Width() - nOfstY ); + } + + rPoint.setY( getFrameArea().Top() + nOfstX ); +} + +/** + * Calculates the a limit value when switching from + * horizontal to vertical layout. + */ +tools::Long SwTextFrame::SwitchHorizontalToVertical( tools::Long nLimit ) const +{ + Point aTmp( 0, nLimit ); + SwitchHorizontalToVertical( aTmp ); + return aTmp.X(); +} + +/** + * Calculates the coordinates of a rectangle when switching from + * vertical to horizontal layout. + */ +void SwTextFrame::SwitchVerticalToHorizontal( SwRect& rRect ) const +{ + tools::Long nOfstX; + + // calc offset inside frame + if ( IsVertLR() ) + nOfstX = rRect.Left() - getFrameArea().Left(); + else + { + if ( mbIsSwapped ) + nOfstX = getFrameArea().Left() + getFrameArea().Height() - ( rRect.Left() + rRect.Width() ); + else + nOfstX = getFrameArea().Left() + getFrameArea().Width() - ( rRect.Left() + rRect.Width() ); + } + + tools::Long nOfstY; + if (IsVertLRBT()) + { + // Note that mbIsSwapped only affects the frame area, not rRect, so rRect.Height() is used + // here unconditionally. + if (mbIsSwapped) + nOfstY = getFrameArea().Top() + getFrameArea().Width() - (rRect.Top() + rRect.Height()); + else + nOfstY = getFrameArea().Top() + getFrameArea().Height() - (rRect.Top() + rRect.Height()); + } + else + nOfstY = rRect.Top() - getFrameArea().Top(); + const tools::Long nWidth = rRect.Height(); + const tools::Long nHeight = rRect.Width(); + + // calc rotated coords + rRect.Left( getFrameArea().Left() + nOfstY ); + rRect.Top( getFrameArea().Top() + nOfstX ); + rRect.Width( nWidth ); + rRect.Height( nHeight ); +} + +/** + * Calculates the coordinates of a point when switching from + * vertical to horizontal layout. + */ +void SwTextFrame::SwitchVerticalToHorizontal( Point& rPoint ) const +{ + tools::Long nOfstX; + + // calc offset inside frame + if ( IsVertLR() ) + // X offset is Y - left. + nOfstX = rPoint.X() - getFrameArea().Left(); + else + { + // X offset is right - X. + if ( mbIsSwapped ) + nOfstX = getFrameArea().Left() + getFrameArea().Height() - rPoint.X(); + else + nOfstX = getFrameArea().Left() + getFrameArea().Width() - rPoint.X(); + } + + tools::Long nOfstY; + if (IsVertLRBT()) + { + // Y offset is bottom - Y. + if (mbIsSwapped) + nOfstY = getFrameArea().Top() + getFrameArea().Width() - rPoint.Y(); + else + nOfstY = getFrameArea().Top() + getFrameArea().Height() - rPoint.Y(); + } + else + // Y offset is Y - top. + nOfstY = rPoint.Y() - getFrameArea().Top(); + + // calc rotated coords + rPoint.setX( getFrameArea().Left() + nOfstY ); + rPoint.setY( getFrameArea().Top() + nOfstX ); +} + +/** + * Calculates the a limit value when switching from + * vertical to horizontal layout. + */ +tools::Long SwTextFrame::SwitchVerticalToHorizontal( tools::Long nLimit ) const +{ + Point aTmp( nLimit, 0 ); + SwitchVerticalToHorizontal( aTmp ); + return aTmp.Y(); +} + +SwFrameSwapper::SwFrameSwapper( const SwTextFrame* pTextFrame, bool bSwapIfNotSwapped ) + : pFrame( pTextFrame ), bUndo( false ) +{ + if (pFrame->IsVertical() && bSwapIfNotSwapped != pFrame->IsSwapped()) + { + bUndo = true; + const_cast(pFrame)->SwapWidthAndHeight(); + } +} + +SwFrameSwapper::~SwFrameSwapper() +{ + if ( bUndo ) + const_cast(pFrame)->SwapWidthAndHeight(); +} + +void SwTextFrame::SwitchLTRtoRTL( SwRect& rRect ) const +{ + SwSwapIfNotSwapped swap(const_cast(this)); + + tools::Long nWidth = rRect.Width(); + rRect.Left( 2 * ( getFrameArea().Left() + getFramePrintArea().Left() ) + + getFramePrintArea().Width() - rRect.Right() - 1 ); + + rRect.Width( nWidth ); +} + +void SwTextFrame::SwitchLTRtoRTL( Point& rPoint ) const +{ + SwSwapIfNotSwapped swap(const_cast(this)); + + rPoint.setX( 2 * ( getFrameArea().Left() + getFramePrintArea().Left() ) + getFramePrintArea().Width() - rPoint.X() - 1 ); +} + +SwLayoutModeModifier::SwLayoutModeModifier( const OutputDevice& rOutp ) : + m_rOut( rOutp ), m_nOldLayoutMode( rOutp.GetLayoutMode() ) +{ +} + +SwLayoutModeModifier::~SwLayoutModeModifier() +{ + const_cast(m_rOut).SetLayoutMode( m_nOldLayoutMode ); +} + +void SwLayoutModeModifier::Modify( bool bChgToRTL ) +{ + const_cast(m_rOut).SetLayoutMode( bChgToRTL ? + vcl::text::ComplexTextLayoutFlags::BiDiStrong | vcl::text::ComplexTextLayoutFlags::BiDiRtl : + vcl::text::ComplexTextLayoutFlags::BiDiStrong ); +} + +void SwLayoutModeModifier::SetAuto() +{ + const vcl::text::ComplexTextLayoutFlags nNewLayoutMode = m_nOldLayoutMode & ~vcl::text::ComplexTextLayoutFlags::BiDiStrong; + const_cast(m_rOut).SetLayoutMode( nNewLayoutMode ); +} + +SwDigitModeModifier::SwDigitModeModifier( const OutputDevice& rOutp, LanguageType eCurLang ) : + rOut( rOutp ), nOldLanguageType( rOutp.GetDigitLanguage() ) +{ + LanguageType eLang = eCurLang; + if (utl::ConfigManager::IsFuzzing()) + eLang = LANGUAGE_ENGLISH_US; + else + { + const SvtCTLOptions::TextNumerals nTextNumerals = SvtCTLOptions::GetCTLTextNumerals(); + + if ( SvtCTLOptions::NUMERALS_HINDI == nTextNumerals ) + eLang = LANGUAGE_ARABIC_SAUDI_ARABIA; + else if ( SvtCTLOptions::NUMERALS_ARABIC == nTextNumerals ) + eLang = LANGUAGE_ENGLISH; + else if ( SvtCTLOptions::NUMERALS_SYSTEM == nTextNumerals ) + eLang = ::GetAppLanguage(); + } + + const_cast(rOut).SetDigitLanguage( eLang ); +} + +SwDigitModeModifier::~SwDigitModeModifier() +{ + const_cast(rOut).SetDigitLanguage( nOldLanguageType ); +} + +void SwTextFrame::Init() +{ + OSL_ENSURE( !IsLocked(), "+SwTextFrame::Init: this is locked." ); + if( !IsLocked() ) + { + ClearPara(); + SetHasRotatedPortions(false); + // set flags directly to save a ResetPreps call, + // and thereby an unnecessary GetPara call + // don't set bOrphan, bLocked or bWait to false! + // bOrphan = bFlag7 = bFlag8 = false; + } +} + +SwTextFrame::SwTextFrame(SwTextNode * const pNode, SwFrame* pSib, + sw::FrameMode const eMode) + : SwContentFrame( pNode, pSib ) + , mnAllLines( 0 ) + , mnThisLines( 0 ) + , mnFlyAnchorOfst( 0 ) + , mnFlyAnchorOfstNoWrap( 0 ) + , mnFlyAnchorVertOfstNoWrap( 0 ) + , mnFootnoteLine( 0 ) + , mnHeightOfLastLine( 0 ) + , mnAdditionalFirstLineOffset( 0 ) + , mnOffset( 0 ) + , mnCacheIndex( USHRT_MAX ) + , mbLocked( false ) + , mbWidow( false ) + , mbJustWidow( false ) + , mbEmpty( false ) + , mbInFootnoteConnect( false ) + , mbFootnote( false ) + , mbRepaint( false ) + , mbHasRotatedPortions( false ) + , mbFieldFollow( false ) + , mbHasAnimation( false ) + , mbIsSwapped( false ) + , mbFollowFormatAllowed( true ) +{ + mnFrameType = SwFrameType::Txt; + // note: this may call SwClientNotify if it's in a list so do it last + // note: this may change this->pRegisteredIn to m_pMergedPara->listeners + m_pMergedPara = CheckParaRedlineMerge(*this, *pNode, eMode); +} + +void SwTextFrame::dumpAsXmlAttributes(xmlTextWriterPtr writer) const +{ + SwContentFrame::dumpAsXmlAttributes(writer); + + const SwTextNode *pTextNode = GetTextNodeFirst(); + (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "txtNodeIndex" ), "%" SAL_PRIdINT32, sal_Int32(pTextNode->GetIndex()) ); + + OString aMode = "Horizontal"_ostr; + if (IsVertLRBT()) + { + aMode = "VertBTLR"_ostr; + } + else if (IsVertLR()) + { + aMode = "VertLR"_ostr; + } + else if (IsVertical()) + { + aMode = "Vertical"_ostr; + } + (void)xmlTextWriterWriteAttribute(writer, BAD_CAST("WritingMode"), BAD_CAST(aMode.getStr())); +} + +void SwTextFrame::dumpAsXml(xmlTextWriterPtr writer) const +{ + (void)xmlTextWriterStartElement(writer, reinterpret_cast("txt")); + dumpAsXmlAttributes( writer ); + if ( HasFollow() ) + (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "follow" ), "%" SAL_PRIuUINT32, GetFollow()->GetFrameId() ); + + if (m_pPrecede != nullptr) + (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "precede" ), "%" SAL_PRIuUINT32, static_cast(m_pPrecede)->GetFrameId() ); + + (void)xmlTextWriterWriteAttribute(writer, BAD_CAST("offset"), BAD_CAST(OString::number(static_cast(mnOffset)).getStr())); + + sw::MergedPara const*const pMerged(GetMergedPara()); + if (pMerged) + { + (void)xmlTextWriterStartElement( writer, BAD_CAST( "merged" ) ); + (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "paraPropsNodeIndex" ), "%" SAL_PRIdINT32, sal_Int32(pMerged->pParaPropsNode->GetIndex()) ); + for (auto const& e : pMerged->extents) + { + (void)xmlTextWriterStartElement( writer, BAD_CAST( "extent" ) ); + (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "txtNodeIndex" ), "%" SAL_PRIdINT32, sal_Int32(e.pNode->GetIndex()) ); + (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "start" ), "%" SAL_PRIdINT32, e.nStart ); + (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "end" ), "%" SAL_PRIdINT32, e.nEnd ); + (void)xmlTextWriterEndElement( writer ); + } + (void)xmlTextWriterEndElement( writer ); + } + + (void)xmlTextWriterStartElement(writer, BAD_CAST("infos")); + dumpInfosAsXml(writer); + (void)xmlTextWriterEndElement(writer); + + // Dump Anchored objects if any + const SwSortedObjs* pAnchored = GetDrawObjs(); + if ( pAnchored && pAnchored->size() > 0 ) + { + (void)xmlTextWriterStartElement( writer, BAD_CAST( "anchored" ) ); + + for (SwAnchoredObject* pObject : *pAnchored) + { + pObject->dumpAsXml( writer ); + } + + (void)xmlTextWriterEndElement( writer ); + } + + // Dump the children + OUString aText = GetText( ); + for ( int i = 0; i < 32; i++ ) + { + aText = aText.replace( i, '*' ); + } + auto nTextOffset = static_cast(GetOffset()); + sal_Int32 nTextLength = aText.getLength() - nTextOffset; + if (const SwTextFrame* pTextFrameFollow = GetFollow()) + { + nTextLength = static_cast(pTextFrameFollow->GetOffset() - GetOffset()); + } + if (nTextLength > 0) + { + OString aText8 + = OUStringToOString(aText.subView(nTextOffset, nTextLength), RTL_TEXTENCODING_UTF8); + (void)xmlTextWriterWriteString( writer, + reinterpret_cast(aText8.getStr( )) ); + } + if (const SwParaPortion* pPara = GetPara()) + { + (void)xmlTextWriterStartElement(writer, BAD_CAST("SwParaPortion")); + TextFrameIndex nOffset(0); + const OUString& rText = GetText(); + (void)xmlTextWriterWriteFormatAttribute(writer, BAD_CAST("ptr"), "%p", pPara); + const SwLineLayout* pLine = pPara; + if (IsFollow()) + { + nOffset += GetOffset(); + } + while (pLine) + { + (void)xmlTextWriterStartElement(writer, BAD_CAST("SwLineLayout")); + pLine->dumpAsXmlAttributes(writer, rText, nOffset); + const SwLinePortion* pPor = pLine->GetFirstPortion(); + while (pPor) + { + pPor->dumpAsXml(writer, rText, nOffset); + pPor = pPor->GetNextPortion(); + } + (void)xmlTextWriterEndElement(writer); + pLine = pLine->GetNext(); + } + (void)xmlTextWriterEndElement(writer); + } + + (void)xmlTextWriterEndElement(writer); +} + +namespace sw { + +SwTextFrame * MakeTextFrame(SwTextNode & rNode, SwFrame *const pSibling, + sw::FrameMode const eMode) +{ + return new SwTextFrame(&rNode, pSibling, eMode); +} + +void RemoveFootnotesForNode( + SwRootFrame const& rLayout, SwTextNode const& rTextNode, + std::vector> const*const pExtents) +{ + if (pExtents && pExtents->empty()) + { + return; // nothing to do + } + const SwFootnoteIdxs &rFootnoteIdxs = rTextNode.GetDoc().GetFootnoteIdxs(); + size_t nPos = 0; + SwNodeOffset const nIndex = rTextNode.GetIndex(); + rFootnoteIdxs.SeekEntry( rTextNode, &nPos ); + if (nPos < rFootnoteIdxs.size()) + { + while (nPos && rTextNode == (rFootnoteIdxs[ nPos ]->GetTextNode())) + --nPos; + if (nPos || rTextNode != (rFootnoteIdxs[ nPos ]->GetTextNode())) + ++nPos; + } + size_t iter(0); + for ( ; nPos < rFootnoteIdxs.size(); ++nPos) + { + SwTextFootnote* pTextFootnote = rFootnoteIdxs[ nPos ]; + if (pTextFootnote->GetTextNode().GetIndex() > nIndex) + break; + if (pExtents) + { + while ((*pExtents)[iter].second <= pTextFootnote->GetStart()) + { + ++iter; + if (iter == pExtents->size()) + { + return; + } + } + if (pTextFootnote->GetStart() < (*pExtents)[iter].first) + { + continue; + } + } + pTextFootnote->DelFrames(&rLayout); + } +} + +} // namespace sw + +void SwTextFrame::DestroyImpl() +{ + // Remove associated SwParaPortion from s_pTextCache + ClearPara(); + + assert(!GetDoc().IsInDtor()); // this shouldn't be happening with ViewShell owning layout + if (!GetDoc().IsInDtor() && HasFootnote()) + { + if (m_pMergedPara) + { + SwTextNode const* pNode(nullptr); + for (auto const& e : m_pMergedPara->extents) + { + if (e.pNode != pNode) + { + pNode = e.pNode; + // sw_redlinehide: not sure if it's necessary to check + // if the nodes are still alive here, which would require + // accessing WriterMultiListener::m_vDepends + sw::RemoveFootnotesForNode(*getRootFrame(), *pNode, nullptr); + } + } + } + else + { + SwTextNode *const pNode(static_cast(GetDep())); + if (pNode) + { + sw::RemoveFootnotesForNode(*getRootFrame(), *pNode, nullptr); + } + } + } + + if (!GetDoc().IsInDtor()) + { + if (SwView* pView = GetActiveView()) + pView->GetEditWin().GetFrameControlsManager().RemoveControls(this); + } + + SwContentFrame::DestroyImpl(); +} + +SwTextFrame::~SwTextFrame() +{ + RemoveFromCache(); +} + +namespace sw { + +// 1. if real insert => correct nStart/nEnd for full nLen +// 2. if rl un-delete => do not correct nStart/nEnd but just include un-deleted +static TextFrameIndex UpdateMergedParaForInsert(MergedPara & rMerged, + bool const isRealInsert, + SwTextNode const& rNode, sal_Int32 const nIndex, sal_Int32 const nLen) +{ + assert(!isRealInsert || nLen); // can 0 happen? yes, for redline in empty node + assert(nIndex <= rNode.Len()); + assert(nIndex + nLen <= rNode.Len()); + assert(rMerged.pFirstNode->GetIndex() <= rNode.GetIndex() && rNode.GetIndex() <= rMerged.pLastNode->GetIndex()); + if (!nLen) + { + return TextFrameIndex(0); + } + OUStringBuffer text(rMerged.mergedText); + sal_Int32 nTFIndex(0); // index used for insertion at the end + sal_Int32 nInserted(0); + bool bInserted(false); + bool bFoundNode(false); + auto itInsert(rMerged.extents.end()); + for (auto it = rMerged.extents.begin(); it != rMerged.extents.end(); ++it) + { + if (it->pNode == &rNode) + { + if (isRealInsert) + { + bFoundNode = true; + if (it->nStart <= nIndex && nIndex <= it->nEnd) + { // note: this can happen only once + text.insert(nTFIndex + (nIndex - it->nStart), + rNode.GetText().subView(nIndex, nLen)); + it->nEnd += nLen; + nInserted = nLen; + assert(!bInserted); + bInserted = true; + } + else if (nIndex < it->nStart) + { + if (itInsert == rMerged.extents.end()) + { + itInsert = it; + } + it->nStart += nLen; + it->nEnd += nLen; + } + } + else + { + assert(it == rMerged.extents.begin() || (it-1)->pNode != &rNode || (it-1)->nEnd < nIndex); + if (nIndex + nLen < it->nStart) + { + itInsert = it; + break; + } + if (nIndex < it->nStart) + { + text.insert(nTFIndex, + rNode.GetText().subView(nIndex, it->nStart - nIndex)); + nInserted += it->nStart - nIndex; + it->nStart = nIndex; + bInserted = true; + } + assert(it->nStart <= nIndex); + if (nIndex <= it->nEnd) + { + nTFIndex += it->nEnd - it->nStart; + while (it->nEnd < nIndex + nLen) + { + auto *const pNext( + (it+1) != rMerged.extents.end() && (it+1)->pNode == it->pNode + ? &*(it+1) + : nullptr); + if (pNext && pNext->nStart <= nIndex + nLen) + { + text.insert(nTFIndex, + rNode.GetText().subView(it->nEnd, pNext->nStart - it->nEnd)); + nTFIndex += pNext->nStart - it->nEnd; + nInserted += pNext->nStart - it->nEnd; + pNext->nStart = it->nStart; + it = rMerged.extents.erase(it); + } + else + { + text.insert(nTFIndex, + rNode.GetText().subView(it->nEnd, nIndex + nLen - it->nEnd)); + nTFIndex += nIndex + nLen - it->nEnd; + nInserted += nIndex + nLen - it->nEnd; + it->nEnd = nIndex + nLen; + } + } + bInserted = true; + break; + } + } + } + else if (rNode.GetIndex() < it->pNode->GetIndex() || bFoundNode) + { + if (itInsert == rMerged.extents.end()) + { + itInsert = it; + } + break; + } + if (itInsert == rMerged.extents.end()) + { + nTFIndex += it->nEnd - it->nStart; + } + } +// assert((bFoundNode || rMerged.extents.empty()) && "text node not found - why is it sending hints to us"); + if (!bInserted) + { // must be in a gap + rMerged.extents.emplace(itInsert, const_cast(&rNode), nIndex, nIndex + nLen); + text.insert(nTFIndex, rNode.GetText().subView(nIndex, nLen)); + nInserted = nLen; + if (rMerged.extents.size() == 1 // also if it was empty! + || rMerged.pParaPropsNode->GetIndex() < rNode.GetIndex()) + { // text inserted after current para-props node + rMerged.pParaPropsNode->RemoveFromListRLHidden(); + rMerged.pParaPropsNode = &const_cast(rNode); + rMerged.pParaPropsNode->AddToListRLHidden(); + } + // called from SwRangeRedline::InvalidateRange() + if (rNode.GetRedlineMergeFlag() == SwNode::Merge::Hidden) + { + const_cast(rNode).SetRedlineMergeFlag(SwNode::Merge::NonFirst); + } + } + rMerged.mergedText = text.makeStringAndClear(); + return TextFrameIndex(nInserted); +} + +// 1. if real delete => correct nStart/nEnd for full nLen +// 2. if rl delete => do not correct nStart/nEnd but just exclude deleted +TextFrameIndex UpdateMergedParaForDelete(MergedPara & rMerged, + bool const isRealDelete, + SwTextNode const& rNode, sal_Int32 nIndex, sal_Int32 const nLen) +{ + assert(nIndex <= rNode.Len()); + assert(rMerged.pFirstNode->GetIndex() <= rNode.GetIndex() && rNode.GetIndex() <= rMerged.pLastNode->GetIndex()); + OUStringBuffer text(rMerged.mergedText); + sal_Int32 nTFIndex(0); + sal_Int32 nToDelete(nLen); + sal_Int32 nDeleted(0); + size_t nFoundNode(0); + size_t nErased(0); + auto it = rMerged.extents.begin(); + for (; it != rMerged.extents.end(); ) + { + bool bErase(false); + if (it->pNode == &rNode) + { + ++nFoundNode; + if (nIndex + nToDelete < it->nStart) + { + nToDelete = 0; + if (!isRealDelete) + { + break; + } + it->nStart -= nLen; + it->nEnd -= nLen; + } + else + { + if (nIndex < it->nStart) + { + // do not adjust nIndex into the text frame index space! + nToDelete -= it->nStart - nIndex; + nIndex = it->nStart; + // note: continue with the if check below, no else! + } + if (it->nStart <= nIndex && nIndex < it->nEnd) + { + sal_Int32 const nDeleteHere(nIndex + nToDelete <= it->nEnd + ? nToDelete + : it->nEnd - nIndex); + text.remove(nTFIndex + (nIndex - it->nStart), nDeleteHere); + bErase = nDeleteHere == it->nEnd - it->nStart; + if (bErase) + { + ++nErased; + assert(it->nStart == nIndex); + it = rMerged.extents.erase(it); + } + else if (isRealDelete) + { // adjust for deleted text + it->nStart -= (nLen - nToDelete); + it->nEnd -= (nLen - nToDelete + nDeleteHere); + if (it != rMerged.extents.begin() + && (it-1)->pNode == &rNode + && (it-1)->nEnd == it->nStart) + { // merge adjacent extents + nTFIndex += it->nEnd - it->nStart; + (it-1)->nEnd = it->nEnd; + it = rMerged.extents.erase(it); + bErase = true; // skip increment + } + } + else + { // exclude text marked as deleted + if (nIndex + nDeleteHere == it->nEnd) + { + it->nEnd -= nDeleteHere; + } + else + { + if (nIndex == it->nStart) + { + it->nStart += nDeleteHere; + } + else + { + sal_Int32 const nOldEnd(it->nEnd); + it->nEnd = nIndex; + it = rMerged.extents.emplace(it+1, + it->pNode, nIndex + nDeleteHere, nOldEnd); + } + assert(nDeleteHere == nToDelete); + } + } + nDeleted += nDeleteHere; + nToDelete -= nDeleteHere; + nIndex += nDeleteHere; + if (!isRealDelete && nToDelete == 0) + { + break; + } + } + } + } + else if (nFoundNode != 0) + { + break; + } + if (!bErase) + { + nTFIndex += it->nEnd - it->nStart; + ++it; + } + } +// assert(nFoundNode != 0 && "text node not found - why is it sending hints to us"); + assert(nIndex <= rNode.Len() + nLen); + // if there's a remaining deletion, it must be in gap at the end of the node +// can't do: might be last one in node was erased assert(nLen == 0 || rMerged.empty() || (it-1)->nEnd <= nIndex); + // note: if first node gets deleted then that must call DelFrames as + // pFirstNode is never updated + if (nErased && nErased == nFoundNode) + { // all visible text from node was erased +#if 1 + if (rMerged.pParaPropsNode == &rNode) + { + rMerged.pParaPropsNode->RemoveFromListRLHidden(); + rMerged.pParaPropsNode = rMerged.extents.empty() + ? const_cast(rMerged.pLastNode) + : rMerged.extents.front().pNode; + rMerged.pParaPropsNode->AddToListRLHidden(); + } +#endif +// NOPE must listen on all non-hidden nodes; particularly on pLastNode rMerged.listener.EndListening(&const_cast(rNode)); + } + rMerged.mergedText = text.makeStringAndClear(); + return TextFrameIndex(nDeleted); +} + +std::pair +MapViewToModel(MergedPara const& rMerged, TextFrameIndex const i_nIndex) +{ + sal_Int32 nIndex(i_nIndex); + sw::Extent const* pExtent(nullptr); + for (const auto& rExt : rMerged.extents) + { + pExtent = &rExt; + if (nIndex < (pExtent->nEnd - pExtent->nStart)) + { + return std::make_pair(pExtent->pNode, pExtent->nStart + nIndex); + } + nIndex = nIndex - (pExtent->nEnd - pExtent->nStart); + } + assert(nIndex == 0 && "view index out of bounds"); + return pExtent + ? std::make_pair(pExtent->pNode, pExtent->nEnd) //1-past-the-end index + : std::make_pair(const_cast(rMerged.pLastNode), rMerged.pLastNode->Len()); +} + +TextFrameIndex MapModelToView(MergedPara const& rMerged, SwTextNode const*const pNode, sal_Int32 const nIndex) +{ + assert(rMerged.pFirstNode->GetIndex() <= pNode->GetIndex() + && pNode->GetIndex() <= rMerged.pLastNode->GetIndex()); + sal_Int32 nRet(0); + bool bFoundNode(false); + for (auto const& e : rMerged.extents) + { + if (pNode->GetIndex() < e.pNode->GetIndex()) + { + return TextFrameIndex(nRet); + } + if (e.pNode == pNode) + { + if (e.nStart <= nIndex && nIndex <= e.nEnd) + { + return TextFrameIndex(nRet + (nIndex - e.nStart)); + } + else if (nIndex < e.nStart) + { + // in gap before this extent => map to 0 here TODO??? + return TextFrameIndex(nRet); + } + bFoundNode = true; + } + else if (bFoundNode) + { + break; + } + nRet += e.nEnd - e.nStart; + } + if (bFoundNode) + { + // must be in a gap at the end of the node + assert(nIndex <= pNode->Len()); + return TextFrameIndex(nRet); + } + else if (rMerged.extents.empty()) + { + assert(nIndex <= pNode->Len()); + return TextFrameIndex(0); + } + return TextFrameIndex(rMerged.mergedText.getLength()); +} + +} // namespace sw + +std::pair +SwTextFrame::MapViewToModel(TextFrameIndex const nIndex) const +{ +//nope assert(GetPara()); + sw::MergedPara const*const pMerged(GetMergedPara()); + if (pMerged) + { + return sw::MapViewToModel(*pMerged, nIndex); + } + else + { + return std::make_pair(static_cast(const_cast( + SwFrame::GetDep())), sal_Int32(nIndex)); + } +} + +SwPosition SwTextFrame::MapViewToModelPos(TextFrameIndex const nIndex) const +{ + std::pair const ret(MapViewToModel(nIndex)); + return SwPosition(*ret.first, ret.second); +} + +TextFrameIndex SwTextFrame::MapModelToView(SwTextNode const*const pNode, sal_Int32 const nIndex) const +{ +//nope assert(GetPara()); + sw::MergedPara const*const pMerged(GetMergedPara()); + if (pMerged) + { + return sw::MapModelToView(*pMerged, pNode, nIndex); + } + else + { + assert(static_cast(SwFrame::GetDep()) == pNode); + return TextFrameIndex(nIndex); + } +} + +TextFrameIndex SwTextFrame::MapModelToViewPos(SwPosition const& rPos) const +{ + SwTextNode const*const pNode(rPos.GetNode().GetTextNode()); + sal_Int32 const nIndex(rPos.GetContentIndex()); + return MapModelToView(pNode, nIndex); +} + +void SwTextFrame::SetMergedPara(std::unique_ptr p) +{ + SwTextNode *const pFirst(m_pMergedPara ? m_pMergedPara->pFirstNode : nullptr); + m_pMergedPara = std::move(p); + if (pFirst) + { + if (m_pMergedPara) + { + assert(pFirst == m_pMergedPara->pFirstNode); + } + else + { + pFirst->Add(this); // must register at node again + } + } + // postcondition: frame must be listening somewhere + assert(m_pMergedPara || GetDep()); +} + +const OUString& SwTextFrame::GetText() const +{ +//nope assert(GetPara()); + sw::MergedPara const*const pMerged(GetMergedPara()); + if (pMerged) + return pMerged->mergedText; + else + return static_cast(SwFrame::GetDep())->GetText(); +} + +SwTextNode const* SwTextFrame::GetTextNodeForParaProps() const +{ + // FIXME can GetPara be 0 ? yes... this is needed in SwContentNotify::SwContentNotify() which is called before any formatting is started +//nope assert(GetPara()); + sw::MergedPara const*const pMerged(GetMergedPara()); + if (pMerged) + { +// assert(pMerged->pFirstNode == pMerged->pParaPropsNode); // surprising news! + return pMerged->pParaPropsNode; + } + else + return static_cast(SwFrame::GetDep()); +} + +SwTextNode const* SwTextFrame::GetTextNodeForFirstText() const +{ + sw::MergedPara const*const pMerged(GetMergedPara()); + if (pMerged) + return pMerged->extents.empty() + ? pMerged->pFirstNode + : pMerged->extents.front().pNode; + else + return static_cast(SwFrame::GetDep()); +} + +SwTextNode const* SwTextFrame::GetTextNodeFirst() const +{ +//nope assert(GetPara()); + sw::MergedPara const*const pMerged(GetMergedPara()); + if (pMerged) + return pMerged->pFirstNode; + else + return static_cast(SwFrame::GetDep()); +} + +SwDoc const& SwTextFrame::GetDoc() const +{ + return GetTextNodeFirst()->GetDoc(); +} + +LanguageType SwTextFrame::GetLangOfChar(TextFrameIndex const nIndex, + sal_uInt16 const nScript, bool const bNoChar) const +{ + // a single character can be mapped uniquely! + std::pair const pos(MapViewToModel(nIndex)); + return pos.first->GetLang(pos.second, bNoChar ? 0 : 1, nScript); +} + +void SwTextFrame::ResetPreps() +{ + if ( GetCacheIdx() != USHRT_MAX ) + { + if (SwParaPortion *pPara = GetPara()) + pPara->ResetPreps(); + } +} + +bool SwTextFrame::IsHiddenNow() const +{ + SwFrameSwapper aSwapper( this, true ); + + if( !getFrameArea().Width() && isFrameAreaDefinitionValid() && GetUpper()->isFrameAreaDefinitionValid() ) // invalid when stack overflows (StackHack)! + { +// OSL_FAIL( "SwTextFrame::IsHiddenNow: thin frame" ); + return true; + } + + bool bHiddenCharsHidePara(false); + bool bHiddenParaField(false); + if (m_pMergedPara) + { + TextFrameIndex nHiddenStart(COMPLETE_STRING); + TextFrameIndex nHiddenEnd(0); + if (auto const pScriptInfo = GetScriptInfo()) + { + pScriptInfo->GetBoundsOfHiddenRange(TextFrameIndex(0), + nHiddenStart, nHiddenEnd); + } + else // ParaPortion is created in Format, but this is called earlier + { + SwScriptInfo aInfo; + aInfo.InitScriptInfo(*m_pMergedPara->pFirstNode, m_pMergedPara.get(), IsRightToLeft()); + aInfo.GetBoundsOfHiddenRange(TextFrameIndex(0), + nHiddenStart, nHiddenEnd); + } + if (TextFrameIndex(0) == nHiddenStart && + TextFrameIndex(GetText().getLength()) <= nHiddenEnd) + { + bHiddenCharsHidePara = true; + } + sw::MergedAttrIter iter(*this); + SwTextNode const* pNode(nullptr); + int nNewResultWeight = 0; + for (SwTextAttr const* pHint = iter.NextAttr(&pNode); pHint; pHint = iter.NextAttr(&pNode)) + { + if (pHint->Which() == RES_TXTATR_FIELD) + { + // see also SwpHints::CalcHiddenParaField() + const SwFormatField& rField = pHint->GetFormatField(); + int nCurWeight = pNode->GetDoc().FieldCanHideParaWeight(rField.GetField()->GetTyp()->Which()); + if (nCurWeight > nNewResultWeight) + { + nNewResultWeight = nCurWeight; + bHiddenParaField = pNode->GetDoc().FieldHidesPara(*rField.GetField()); + } + else if (nCurWeight == nNewResultWeight && bHiddenParaField) + { + // Currently, for both supported hiding types (HiddenPara, Database), "Don't hide" + // takes precedence - i.e., if there's a "Don't hide" field of that weight, we only + // care about fields of higher weight. + bHiddenParaField = pNode->GetDoc().FieldHidesPara(*rField.GetField()); + } + } + } + } + else + { + bHiddenCharsHidePara = static_cast(SwFrame::GetDep())->HasHiddenCharAttribute( true ); + bHiddenParaField = static_cast(SwFrame::GetDep())->IsHiddenByParaField(); + } + const SwViewShell* pVsh = getRootFrame()->GetCurrShell(); + + if ( pVsh && ( bHiddenCharsHidePara || bHiddenParaField ) ) + { + + if ( + ( bHiddenParaField && + ( !pVsh->GetViewOptions()->IsShowHiddenPara() && + !pVsh->GetViewOptions()->IsFieldName() ) ) || + ( bHiddenCharsHidePara && + !pVsh->GetViewOptions()->IsShowHiddenChar() ) ) + { + // in order to put the cursor in the body text, one paragraph must + // be visible - check this for the 1st body paragraph + if (IsInDocBody() && FindPrevCnt() == nullptr) + { + bool isAllHidden(true); + for (SwContentFrame const* pNext = FindNextCnt(true); + pNext != nullptr; pNext = pNext->FindNextCnt(true)) + { + if (!pNext->IsTextFrame() + || !static_cast(pNext)->IsHiddenNow()) + { + isAllHidden = false; + break; + } + } + if (isAllHidden) + { + SAL_INFO("sw.core", "unhiding one body paragraph"); + return false; + } + } + return true; + } + } + + return false; +} + +/// Removes Textfrm's attachments, when it's hidden +void SwTextFrame::HideHidden() +{ + OSL_ENSURE( !GetFollow() && IsHiddenNow(), + "HideHidden on visible frame of hidden frame has follow" ); + + HideFootnotes(GetOffset(), TextFrameIndex(COMPLETE_STRING)); + HideAndShowObjects(); + + // format information is obsolete + ClearPara(); +} + +void SwTextFrame::HideFootnotes(TextFrameIndex const nStart, TextFrameIndex const nEnd) +{ + SwPageFrame *pPage = nullptr; + sw::MergedAttrIter iter(*this); + SwTextNode const* pNode(nullptr); + for (SwTextAttr const* pHt = iter.NextAttr(&pNode); pHt; pHt = iter.NextAttr(&pNode)) + { + if (pHt->Which() == RES_TXTATR_FTN) + { + TextFrameIndex const nIdx(MapModelToView(pNode, pHt->GetStart())); + if (nEnd < nIdx) + break; + if (nStart <= nIdx) + { + if (!pPage) + pPage = FindPageFrame(); + pPage->RemoveFootnote( this, static_cast(pHt) ); + } + } + } +} + +/** + * as-character anchored graphics, which are used for a graphic bullet list. + * As long as these graphic bullet list aren't imported, do not hide a + * at-character anchored object, if + * (a) the document is an imported WW8 document - + * checked by checking certain compatibility options - + * (b) the paragraph is the last content in the document and + * (c) the anchor character is an as-character anchored graphic. + */ +bool sw_HideObj( const SwTextFrame& _rFrame, + const RndStdIds _eAnchorType, + SwFormatAnchor const& rFormatAnchor, + SwAnchoredObject* _pAnchoredObj ) +{ + bool bRet( true ); + + if (_eAnchorType == RndStdIds::FLY_AT_CHAR) + { + const IDocumentSettingAccess *const pIDSA = &_rFrame.GetDoc().getIDocumentSettingAccess(); + if ( !pIDSA->get(DocumentSettingId::USE_FORMER_TEXT_WRAPPING) && + !pIDSA->get(DocumentSettingId::OLD_LINE_SPACING) && + !pIDSA->get(DocumentSettingId::USE_FORMER_OBJECT_POS) && + pIDSA->get(DocumentSettingId::CONSIDER_WRAP_ON_OBJECT_POSITION) && + _rFrame.IsInDocBody() && !_rFrame.FindNextCnt() ) + { + SwTextNode const& rNode(*rFormatAnchor.GetAnchorNode()->GetTextNode()); + assert(FrameContainsNode(_rFrame, rNode.GetIndex())); + sal_Int32 const nObjAnchorPos(rFormatAnchor.GetAnchorContentOffset()); + const sal_Unicode cAnchorChar = nObjAnchorPos < rNode.Len() + ? rNode.GetText()[nObjAnchorPos] + : 0; + if (cAnchorChar == CH_TXTATR_BREAKWORD) + { + const SwTextAttr* const pHint( + rNode.GetTextAttrForCharAt(nObjAnchorPos, RES_TXTATR_FLYCNT)); + if ( pHint ) + { + const SwFrameFormat* pFrameFormat = + static_cast(pHint)->GetFlyCnt().GetFrameFormat(); + if ( pFrameFormat->Which() == RES_FLYFRMFMT ) + { + SwNodeIndex nContentIndex = *(pFrameFormat->GetContent().GetContentIdx()); + ++nContentIndex; + if ( nContentIndex.GetNode().IsNoTextNode() ) + { + bRet = false; + // set needed data structure values for object positioning + SwRectFnSet aRectFnSet(&_rFrame); + SwRect aLastCharRect( _rFrame.getFrameArea() ); + aRectFnSet.SetWidth( aLastCharRect, 1 ); + _pAnchoredObj->maLastCharRect = aLastCharRect; + _pAnchoredObj->mnLastTopOfLine = aRectFnSet.GetTop(aLastCharRect); + } + } + } + } + } + } + + return bRet; +} + +/** + * Hide/show objects + * + * Method hides respectively shows objects, which are anchored at paragraph, + * at/as a character of the paragraph, corresponding to the paragraph and + * paragraph portion visibility. + * + * - is called from HideHidden() - should hide objects in hidden paragraphs and + * - from Format_() - should hide/show objects in partly visible paragraphs + */ +void SwTextFrame::HideAndShowObjects() +{ + if ( GetDrawObjs() ) + { + if ( IsHiddenNow() ) + { + // complete paragraph is hidden. Thus, hide all objects + for (SwAnchoredObject* i : *GetDrawObjs()) + { + SdrObject* pObj = i->DrawObj(); + SwContact* pContact = static_cast(pObj->GetUserCall()); + // under certain conditions + const RndStdIds eAnchorType( pContact->GetAnchorId() ); + if ((eAnchorType != RndStdIds::FLY_AT_CHAR) || + sw_HideObj(*this, eAnchorType, pContact->GetAnchorFormat(), + i )) + { + pContact->MoveObjToInvisibleLayer( pObj ); + } + } + } + else + { + // paragraph is visible, but can contain hidden text portion. + // first we check if objects are allowed to be hidden: + const SwViewShell* pVsh = getRootFrame()->GetCurrShell(); + const bool bShouldBeHidden = !pVsh || !pVsh->GetWin() || + !pVsh->GetViewOptions()->IsShowHiddenChar(); + + // Thus, show all objects, which are anchored at paragraph and + // hide/show objects, which are anchored at/as character, according + // to the visibility of the anchor character. + for (SwAnchoredObject* i : *GetDrawObjs()) + { + SdrObject* pObj = i->DrawObj(); + SwContact* pContact = static_cast(pObj->GetUserCall()); + // Determine anchor type only once + const RndStdIds eAnchorType( pContact->GetAnchorId() ); + + if (eAnchorType == RndStdIds::FLY_AT_PARA) + { + pContact->MoveObjToVisibleLayer( pObj ); + } + else if ((eAnchorType == RndStdIds::FLY_AT_CHAR) || + (eAnchorType == RndStdIds::FLY_AS_CHAR)) + { + sal_Int32 nHiddenStart; + sal_Int32 nHiddenEnd; + const SwFormatAnchor& rAnchorFormat = pContact->GetAnchorFormat(); + SwScriptInfo::GetBoundsOfHiddenRange( + *rAnchorFormat.GetAnchorNode()->GetTextNode(), + rAnchorFormat.GetAnchorContentOffset(), nHiddenStart, nHiddenEnd); + // Under certain conditions + if ( nHiddenStart != COMPLETE_STRING && bShouldBeHidden && + sw_HideObj(*this, eAnchorType, rAnchorFormat, i)) + { + pContact->MoveObjToInvisibleLayer( pObj ); + } + else + pContact->MoveObjToVisibleLayer( pObj ); + } + else + { + OSL_FAIL( " - object not anchored at/inside paragraph!?" ); + } + } + } + } + + if (IsFollow()) + { + SwTextFrame *pMaster = FindMaster(); + OSL_ENSURE(pMaster, "SwTextFrame without master"); + if (pMaster) + pMaster->HideAndShowObjects(); + } +} + +/** + * Returns the first possible break point in the current line. + * This method is used in SwTextFrame::Format() to decide whether the previous + * line has to be formatted as well. + * nFound is <= nEndLine. + */ +TextFrameIndex SwTextFrame::FindBrk(std::u16string_view aText, + const TextFrameIndex nStart, + const TextFrameIndex nEnd) +{ + sal_Int32 nFound = sal_Int32(nStart); + const sal_Int32 nEndLine = std::min(sal_Int32(nEnd), sal_Int32(aText.size()) - 1); + + // Skip all leading blanks. + while( nFound <= nEndLine && ' ' == aText[nFound] ) + { + nFound++; + } + + // A tricky situation with the TextAttr-Dummy-character (in this case "$"): + // "Dr.$Meyer" at the beginning of the second line. Typing a blank after that + // doesn't result in the word moving into first line, even though that would work. + // For this reason we don't skip the dummy char. + while( nFound <= nEndLine && ' ' != aText[nFound] ) + { + nFound++; + } + + return TextFrameIndex(nFound); +} + +bool SwTextFrame::IsIdxInside(TextFrameIndex const nPos, TextFrameIndex const nLen) const +{ + if (nPos == TextFrameIndex(COMPLETE_STRING)) // the "not found" range + return false; +// Silence over-eager warning emitted at least by GCC trunk towards 6: +#if defined __GNUC__ && !defined __clang__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-overflow" +#endif + if (nLen != TextFrameIndex(COMPLETE_STRING) && GetOffset() > nPos + nLen) // the range preceded us +#if defined __GNUC__ && !defined __clang__ +#pragma GCC diagnostic pop +#endif + return false; + + if( !GetFollow() ) // the range doesn't precede us, + return true; // nobody follows us. + + TextFrameIndex const nMax = GetFollow()->GetOffset(); + + // either the range overlap or our text has been deleted + // sw_redlinehide: GetText() should be okay here because it has already + // been updated in the INS/DEL hint case + if (nMax > nPos || nMax > TextFrameIndex(GetText().getLength())) + return true; + + // changes made in the first line of a follow can modify the master + const SwParaPortion* pPara = GetFollow()->GetPara(); + return pPara && ( nPos <= nMax + pPara->GetLen() ); +} + +inline void SwTextFrame::InvalidateRange(const SwCharRange &aRange, const tools::Long nD) +{ + if ( IsIdxInside( aRange.Start(), aRange.Len() ) ) + InvalidateRange_( aRange, nD ); +} + +void SwTextFrame::InvalidateRange_( const SwCharRange &aRange, const tools::Long nD) +{ + if ( !HasPara() ) + { InvalidateSize(); + return; + } + + SetWidow( false ); + SwParaPortion *pPara = GetPara(); + + bool bInv = false; + if( 0 != nD ) + { + // In nDelta the differences between old and new + // linelengths are being added, that's why it's negative + // if chars have been added and positive, if chars have + // deleted + pPara->SetDelta(pPara->GetDelta() + nD); + bInv = true; + } + SwCharRange &rReformat = pPara->GetReformat(); + if(aRange != rReformat) { + if (TextFrameIndex(COMPLETE_STRING) == rReformat.Len()) + rReformat = aRange; + else + rReformat += aRange; + bInv = true; + } + if(bInv) + { + InvalidateSize(); + } +} + +void SwTextFrame::CalcLineSpace() +{ + OSL_ENSURE( ! IsVertical() || ! IsSwapped(), + "SwTextFrame::CalcLineSpace with swapped frame!" ); + + if( IsLocked() || !HasPara() ) + return; + + if( GetDrawObjs() || + GetTextNodeForParaProps()->GetSwAttrSet().GetFirstLineIndent().IsAutoFirst()) + { + Init(); + return; + } + + SwParaPortion *const pPara(GetPara()); + assert(pPara); + if (pPara->IsFixLineHeight()) + { + Init(); + return; + } + + Size aNewSize( getFramePrintArea().SSize() ); + + SwTextFormatInfo aInf( getRootFrame()->GetCurrShell()->GetOut(), this ); + SwTextFormatter aLine( this, &aInf ); + if( aLine.GetDropLines() ) + { + Init(); + return; + } + + aLine.Top(); + aLine.RecalcRealHeight(); + + aNewSize.setHeight( (aLine.Y() - getFrameArea().Top()) + aLine.GetLineHeight() ); + + SwTwips nDelta = aNewSize.Height() - getFramePrintArea().Height(); + // Underflow with free-flying frames + if( aInf.GetTextFly().IsOn() ) + { + SwRect aTmpFrame( getFrameArea() ); + if( nDelta < 0 ) + aTmpFrame.Height( getFramePrintArea().Height() ); + else + aTmpFrame.Height( aNewSize.Height() ); + if( aInf.GetTextFly().Relax( aTmpFrame ) ) + { + Init(); + return; + } + } + + if( !nDelta ) + return; + + SwTextFrameBreak aBreak( this ); + if( GetFollow() || aBreak.IsBreakNow( aLine ) ) + { + // if there is a Follow() or if we need to break here, reformat + Init(); + } + else + { + // everything is business as usual... + pPara->SetPrepAdjust(); + pPara->SetPrep(); + } +} + +static void lcl_SetWrong( SwTextFrame& rFrame, SwTextNode const& rNode, + sal_Int32 const nPos, sal_Int32 const nCnt, bool const bMove) +{ + if ( !rFrame.IsFollow() ) + { + SwTextNode& rTextNode = const_cast(rNode); + sw::GrammarContact* pGrammarContact = sw::getGrammarContactFor(rTextNode); + SwGrammarMarkUp* pWrongGrammar = pGrammarContact ? + pGrammarContact->getGrammarCheck( rTextNode, false ) : + rTextNode.GetGrammarCheck(); + bool bGrammarProxy = pWrongGrammar != rTextNode.GetGrammarCheck(); + if( bMove ) + { + if( rTextNode.GetWrong() ) + rTextNode.GetWrong()->Move( nPos, nCnt ); + if( pWrongGrammar ) + pWrongGrammar->MoveGrammar( nPos, nCnt ); + if( bGrammarProxy && rTextNode.GetGrammarCheck() ) + rTextNode.GetGrammarCheck()->MoveGrammar( nPos, nCnt ); + if( rTextNode.GetSmartTags() ) + rTextNode.GetSmartTags()->Move( nPos, nCnt ); + } + else + { + if( rTextNode.GetWrong() ) + rTextNode.GetWrong()->Invalidate( nPos, nCnt ); + if( pWrongGrammar ) + pWrongGrammar->Invalidate( nPos, nCnt ); + if( rTextNode.GetSmartTags() ) + rTextNode.GetSmartTags()->Invalidate( nPos, nCnt ); + } + const sal_Int32 nEnd = nPos + (nCnt > 0 ? nCnt : 1 ); + if ( !rTextNode.GetWrong() && !rTextNode.IsWrongDirty() ) + { + rTextNode.SetWrong( std::make_unique( WRONGLIST_SPELL ) ); + rTextNode.GetWrong()->SetInvalid( nPos, nEnd ); + } + if ( !rTextNode.GetSmartTags() && !rTextNode.IsSmartTagDirty() ) + { + rTextNode.SetSmartTags( std::make_unique( WRONGLIST_SMARTTAG ) ); + rTextNode.GetSmartTags()->SetInvalid( nPos, nEnd ); + } + rTextNode.SetWrongDirty(sw::WrongState::TODO); + rTextNode.SetGrammarCheckDirty( true ); + rTextNode.SetWordCountDirty( true ); + rTextNode.SetAutoCompleteWordDirty( true ); + rTextNode.SetSmartTagDirty( true ); + } + + SwRootFrame *pRootFrame = rFrame.getRootFrame(); + if (pRootFrame) + { + pRootFrame->SetNeedGrammarCheck( true ); + } + + SwPageFrame *pPage = rFrame.FindPageFrame(); + if( pPage ) + { + pPage->InvalidateSpelling(); + pPage->InvalidateAutoCompleteWords(); + pPage->InvalidateWordCount(); + pPage->InvalidateSmartTags(); + } +} + +static void lcl_SetScriptInval(SwTextFrame& rFrame, TextFrameIndex const nPos) +{ + if( rFrame.GetPara() ) + rFrame.GetPara()->GetScriptInfo().SetInvalidityA( nPos ); +} + +// note: SwClientNotify will be called once for every frame => just fix own Ofst +static void lcl_ModifyOfst(SwTextFrame & rFrame, + TextFrameIndex const nPos, TextFrameIndex const nLen, + TextFrameIndex (* op)(TextFrameIndex const&, TextFrameIndex const&)) +{ + assert(nLen != TextFrameIndex(COMPLETE_STRING)); + if (rFrame.IsFollow() && nPos < rFrame.GetOffset()) + { + rFrame.ManipOfst( std::max(nPos, op(rFrame.GetOffset(), nLen)) ); + assert(sal_Int32(rFrame.GetOffset()) <= rFrame.GetText().getLength()); + } +} + +namespace { + +void UpdateMergedParaForMove(sw::MergedPara & rMerged, + SwTextFrame & rTextFrame, + bool & o_rbRecalcFootnoteFlag, + SwTextNode const& rDestNode, + SwTextNode const& rNode, + sal_Int32 const nDestStart, + sal_Int32 const nSourceStart, + sal_Int32 const nLen) +{ + std::vector> deleted; + sal_Int32 const nSourceEnd(nSourceStart + nLen); + sal_Int32 nLastEnd(0); + for (const auto& rExt : rMerged.extents) + { + if (rExt.pNode == &rNode) + { + sal_Int32 const nStart(std::max(nLastEnd, nSourceStart)); + sal_Int32 const nEnd(std::min(rExt.nStart, nSourceEnd)); + if (nStart < nEnd) + { + deleted.emplace_back(nStart, nEnd); + } + nLastEnd = rExt.nEnd; + if (nSourceEnd <= rExt.nEnd) + { + break; + } + } + else if (rNode.GetIndex() < rExt.pNode->GetIndex()) + { + break; + } + } + if (nLastEnd != rNode.Len()) // without nLen, string yet to be removed + { + if (nLastEnd < nSourceEnd) + { + deleted.emplace_back(std::max(nLastEnd, nSourceStart), nSourceEnd); + } + } + if (deleted.empty()) + return; + + o_rbRecalcFootnoteFlag = true; + for (auto const& it : deleted) + { + sal_Int32 const nStart(it.first - nSourceStart + nDestStart); + TextFrameIndex const nDeleted = UpdateMergedParaForDelete(rMerged, false, + rDestNode, nStart, it.second - it.first); +//FIXME asserts valid for join - but if called from split, the new node isn't there yet and it will be added later... assert(nDeleted); +// assert(nDeleted == it.second - it.first); + if(nDeleted) + { + // InvalidateRange/lcl_SetScriptInval was called sufficiently for InsertText + lcl_SetWrong(rTextFrame, rDestNode, nStart, it.first - it.second, false); + TextFrameIndex const nIndex(sw::MapModelToView(rMerged, &rDestNode, nStart)); + lcl_ModifyOfst(rTextFrame, nIndex, nDeleted, &o3tl::operator-); + } + } +} + +} // namespace + +/** + * Related: fdo#56031 filter out attribute changes that don't matter for + * humans/a11y to stop flooding the destination mortal with useless noise + */ +#if !ENABLE_WASM_STRIP_ACCESSIBILITY +static bool isA11yRelevantAttribute(sal_uInt16 nWhich) +{ + return nWhich != RES_CHRATR_RSID; +} + +static bool hasA11yRelevantAttribute( const std::vector& rWhichFmtAttr ) +{ + for( sal_uInt16 nWhich : rWhichFmtAttr ) + if ( isA11yRelevantAttribute( nWhich ) ) + return true; + + return false; +} +#endif // ENABLE_WASM_STRIP_ACCESSIBILITY + +// Note: for now this overrides SwClient::SwClientNotify; the intermediary +// classes still override SwClient::Modify, which should continue to work +// as their implementation of SwClientNotify is SwClient's which calls Modify. +// Therefore we also don't need to call SwClient::SwClientNotify(rModify, rHint) +// because that's all it does, and this implementation calls +// SwContentFrame::SwClientNotify() when appropriate. +void SwTextFrame::SwClientNotify(SwModify const& rModify, SfxHint const& rHint) +{ + SfxPoolItem const* pOld(nullptr); + SfxPoolItem const* pNew(nullptr); + sw::MoveText const* pMoveText(nullptr); + sw::InsertText const* pInsertText(nullptr); + sw::DeleteText const* pDeleteText(nullptr); + sw::DeleteChar const* pDeleteChar(nullptr); + sw::RedlineDelText const* pRedlineDelText(nullptr); + sw::RedlineUnDelText const* pRedlineUnDelText(nullptr); + + sal_uInt16 nWhich = 0; + if (rHint.GetId() == SfxHintId::SwLegacyModify) + { + auto pHint = static_cast(&rHint); + pOld = pHint->m_pOld; + pNew = pHint->m_pNew; + nWhich = pHint->GetWhich(); + } + else if (rHint.GetId() == SfxHintId::SwInsertText) + { + pInsertText = static_cast(&rHint); + } + else if (rHint.GetId() == SfxHintId::SwDeleteText) + { + pDeleteText = static_cast(&rHint); + } + else if (rHint.GetId() == SfxHintId::SwDeleteChar) + { + pDeleteChar = static_cast(&rHint); + } + else if (rHint.GetId() == SfxHintId::SwDocPosUpdateAtIndex) + { + auto pDocPosAt = static_cast(&rHint); + Broadcast(SfxHint()); // notify SwAccessibleParagraph + if(IsLocked()) + return; + if(pDocPosAt->m_nDocPos > getFrameArea().Top()) + return; + TextFrameIndex const nIndex(MapModelToView( + &pDocPosAt->m_rNode, + pDocPosAt->m_nIndex)); + InvalidateRange(SwCharRange(nIndex, TextFrameIndex(1))); + return; + } + else if (rHint.GetId() == SfxHintId::SwVirtPageNumHint) + { + auto& rVirtPageNumHint = const_cast(static_cast(rHint)); + if(!IsInDocBody() || IsFollow() || rVirtPageNumHint.IsFound()) + return; + if(const SwPageFrame* pPage = FindPageFrame()) + pPage->UpdateVirtPageNumInfo(rVirtPageNumHint, this); + return; + } + else if (auto const pHt = dynamic_cast(&rHint)) + { + pMoveText = pHt; + } + else if (auto const pHynt = dynamic_cast(&rHint)) + { + pRedlineDelText = pHynt; + } + else if (auto const pHnt = dynamic_cast(&rHint)) + { + pRedlineUnDelText = pHnt; + } + else + { + assert(!"unexpected hint"); + } + + if (m_pMergedPara) + { + assert(m_pMergedPara->listener.IsListeningTo(&rModify)); + } + + SwTextNode const& rNode(static_cast(rModify)); + + // modifications concerning frame attributes are processed by the base class + if( IsInRange( aFrameFormatSetRange, nWhich ) || RES_FMT_CHG == nWhich ) + { + if (m_pMergedPara) + { // ignore item set changes that don't apply + SwTextNode const*const pAttrNode( + (nWhich == RES_PAGEDESC || nWhich == RES_BREAK) + ? m_pMergedPara->pFirstNode + : m_pMergedPara->pParaPropsNode); + if (pAttrNode != &rModify) + { + return; + } + } + SwContentFrame::SwClientNotify(rModify, sw::LegacyModifyHint(pOld, pNew)); + if( nWhich == RES_FMT_CHG && getRootFrame()->GetCurrShell() ) + { + // collection has changed + Prepare(); + InvalidatePrt_(); + lcl_SetWrong( *this, rNode, 0, COMPLETE_STRING, false ); + SetDerivedR2L( false ); + CheckDirChange(); + // Force complete paint due to existing indents. + SetCompletePaint(); + InvalidateLineNum(); + } + return; + } + + if (m_pMergedPara && m_pMergedPara->pParaPropsNode != &rModify) + { + if (isPARATR(nWhich) || isPARATR_LIST(nWhich)) // FRMATR handled above + { + return; // ignore it + } + } + + Broadcast(SfxHint()); // notify SwAccessibleParagraph + + // while locked ignore all modifications + if( IsLocked() ) + return; + + // save stack + // warning: one has to ensure that all variables are set + TextFrameIndex nPos; + TextFrameIndex nLen; + bool bSetFieldsDirty = false; + bool bRecalcFootnoteFlag = false; + + if (pRedlineDelText) + { + if (m_pMergedPara) + { + sal_Int32 const nNPos = pRedlineDelText->nStart; + sal_Int32 const nNLen = pRedlineDelText->nLen; + nPos = MapModelToView(&rNode, nNPos); + // update merged before doing anything else + nLen = UpdateMergedParaForDelete(*m_pMergedPara, false, rNode, nNPos, nNLen); + const sal_Int32 m = -nNLen; + if (nLen && IsIdxInside(nPos, nLen)) + { + InvalidateRange( SwCharRange(nPos, TextFrameIndex(1)), m ); + } + lcl_SetWrong( *this, rNode, nNPos, m, false ); + if (nLen) + { + lcl_SetScriptInval( *this, nPos ); + bSetFieldsDirty = bRecalcFootnoteFlag = true; + lcl_ModifyOfst(*this, nPos, nLen, &o3tl::operator-); + } + } + } + else if (pRedlineUnDelText) + { + if (m_pMergedPara) + { + sal_Int32 const nNPos = pRedlineUnDelText->nStart; + sal_Int32 const nNLen = pRedlineUnDelText->nLen; + nPos = MapModelToView(&rNode, nNPos); + nLen = UpdateMergedParaForInsert(*m_pMergedPara, false, rNode, nNPos, nNLen); + if (IsIdxInside(nPos, nLen)) + { + if (!nLen) + { + // Refresh NumPortions even when line is empty! + if (nPos) + InvalidateSize(); + else + Prepare(); + } + else + InvalidateRange_( SwCharRange( nPos, nLen ), nNLen ); + } + lcl_SetWrong( *this, rNode, nNPos, nNLen, false ); + lcl_SetScriptInval( *this, nPos ); + bSetFieldsDirty = true; + lcl_ModifyOfst(*this, nPos, nLen, &o3tl::operator+); + } + } + else if (pMoveText) + { + if (m_pMergedPara + && m_pMergedPara->pFirstNode->GetIndex() <= pMoveText->pDestNode->GetIndex() + && pMoveText->pDestNode->GetIndex() <= m_pMergedPara->pLastNode->GetIndex()) + { // if it's not 2 nodes in merged frame, assume the target node doesn't have frames at all + assert(abs(rNode.GetIndex() - pMoveText->pDestNode->GetIndex()) == SwNodeOffset(1)); + UpdateMergedParaForMove(*m_pMergedPara, + *this, + bRecalcFootnoteFlag, + *pMoveText->pDestNode, rNode, + pMoveText->nDestStart, + pMoveText->nSourceStart, + pMoveText->nLen); + } + else + { + // there is a situation where this is okay: from JoinNext, which will then call CheckResetRedlineMergeFlag, which will then create merged from scratch for this frame + // assert(!m_pMergedPara || !getRootFrame()->IsHideRedlines() || !pMoveText->pDestNode->getLayoutFrame(getRootFrame())); + } + } + else if (pInsertText) + { + nPos = MapModelToView(&rNode, pInsertText->nPos); + // unlike redlines, inserting into fieldmark must be explicitly handled + bool isHidden(false); + switch (getRootFrame()->GetFieldmarkMode()) + { + case sw::FieldmarkMode::ShowCommand: + isHidden = pInsertText->isInsideFieldmarkResult; + break; + case sw::FieldmarkMode::ShowResult: + isHidden = pInsertText->isInsideFieldmarkCommand; + break; + case sw::FieldmarkMode::ShowBoth: // just to avoid the warning + break; + } + if (!isHidden) + { + nLen = TextFrameIndex(pInsertText->nLen); + if (m_pMergedPara) + { + UpdateMergedParaForInsert(*m_pMergedPara, true, rNode, pInsertText->nPos, pInsertText->nLen); + } + if( IsIdxInside( nPos, nLen ) ) + { + if( !nLen ) + { + // Refresh NumPortions even when line is empty! + if( nPos ) + InvalidateSize(); + else + Prepare(); + } + else + InvalidateRange_( SwCharRange( nPos, nLen ), pInsertText->nLen ); + } + lcl_SetScriptInval( *this, nPos ); + bSetFieldsDirty = true; + lcl_ModifyOfst(*this, nPos, nLen, &o3tl::operator+); + } + lcl_SetWrong( *this, rNode, pInsertText->nPos, pInsertText->nLen, true ); + } + else if (pDeleteText) + { + nPos = MapModelToView(&rNode, pDeleteText->nStart); + if (m_pMergedPara) + { // update merged before doing anything else + nLen = UpdateMergedParaForDelete(*m_pMergedPara, true, rNode, pDeleteText->nStart, pDeleteText->nLen); + } + else + { + nLen = TextFrameIndex(pDeleteText->nLen); + } + const sal_Int32 m = -pDeleteText->nLen; + if ((!m_pMergedPara || nLen) && IsIdxInside(nPos, nLen)) + { + if( !nLen ) + InvalidateSize(); + else + InvalidateRange( SwCharRange(nPos, TextFrameIndex(1)), m ); + } + lcl_SetWrong( *this, rNode, pDeleteText->nStart, m, true ); + if (nLen) + { + lcl_SetScriptInval( *this, nPos ); + bSetFieldsDirty = bRecalcFootnoteFlag = true; + lcl_ModifyOfst(*this, nPos, nLen, &o3tl::operator-); + } + } + else if (pDeleteChar) + { + nPos = MapModelToView(&rNode, pDeleteChar->m_nPos); + if (m_pMergedPara) + { + nLen = UpdateMergedParaForDelete(*m_pMergedPara, true, rNode, pDeleteChar->m_nPos, 1); + } + else + { + nLen = TextFrameIndex(1); + } + lcl_SetWrong( *this, rNode, pDeleteChar->m_nPos, -1, true ); + if (nLen) + { + InvalidateRange( SwCharRange(nPos, nLen), -1 ); + lcl_SetScriptInval( *this, nPos ); + bSetFieldsDirty = bRecalcFootnoteFlag = true; + lcl_ModifyOfst(*this, nPos, nLen, &o3tl::operator-); + } + } + else switch (nWhich) + { + case RES_LINENUMBER: + { + assert(false); // should have been forwarded to SwContentFrame + InvalidateLineNum(); + } + break; + case RES_UPDATE_ATTR: + { + const SwUpdateAttr* pNewUpdate = static_cast(pNew); + + sal_Int32 const nNPos = pNewUpdate->getStart(); + sal_Int32 const nNLen = pNewUpdate->getEnd() - nNPos; + nPos = MapModelToView(&rNode, nNPos); + nLen = MapModelToView(&rNode, nNPos + nNLen) - nPos; + if( IsIdxInside( nPos, nLen ) ) + { + // We need to reformat anyways, even if the invalidated + // range is empty. + // E.g.: empty line, set 14 pt! + + // FootnoteNumbers need to be formatted + if( !nLen ) + nLen = TextFrameIndex(1); + + InvalidateRange_( SwCharRange( nPos, nLen) ); + const sal_uInt16 nTmp = pNewUpdate->getWhichAttr(); + + if( ! nTmp || RES_TXTATR_CHARFMT == nTmp || RES_TXTATR_INETFMT == nTmp || RES_TXTATR_AUTOFMT == nTmp || + RES_FMT_CHG == nTmp || RES_ATTRSET_CHG == nTmp ) + { + lcl_SetWrong( *this, rNode, nNPos, nNPos + nNLen, false ); + lcl_SetScriptInval( *this, nPos ); + } + } + +#if !ENABLE_WASM_STRIP_ACCESSIBILITY + if( isA11yRelevantAttribute( pNewUpdate->getWhichAttr() ) && + hasA11yRelevantAttribute( pNewUpdate->getFmtAttrs() ) ) + { + SwViewShell* pViewSh = getRootFrame() ? getRootFrame()->GetCurrShell() : nullptr; + if ( pViewSh ) + { + pViewSh->InvalidateAccessibleParaAttrs( *this ); + } + } +#endif + } + break; + case RES_OBJECTDYING: + break; + + case RES_PARATR_LINESPACING: + { + CalcLineSpace(); + InvalidateSize(); + InvalidatePrt_(); + if( IsInSct() && !GetPrev() ) + { + SwSectionFrame *pSect = FindSctFrame(); + if( pSect->ContainsAny() == this ) + pSect->InvalidatePrt(); + } + + // i#11859 + // (1) Also invalidate next frame on next page/column. + // (2) Skip empty sections and hidden paragraphs + // Thus, use method + InvalidateNextPrtArea(); + + SetCompletePaint(); + } + break; + + case RES_TXTATR_FIELD: + case RES_TXTATR_ANNOTATION: + { + sal_Int32 const nNPos = static_cast(pNew)->GetTextField()->GetStart(); + nPos = MapModelToView(&rNode, nNPos); + if (IsIdxInside(nPos, TextFrameIndex(1))) + { + if (SfxPoolItem::areSame( pNew, pOld )) + { + // only repaint + // opt: invalidate window? + InvalidatePage(); + SetCompletePaint(); + } + else + InvalidateRange_(SwCharRange(nPos, TextFrameIndex(1))); + } + bSetFieldsDirty = true; + // ST2 + if ( SwSmartTagMgr::Get().IsSmartTagsEnabled() ) + lcl_SetWrong( *this, rNode, nNPos, nNPos + 1, false ); + } + break; + + case RES_TXTATR_FTN : + { + if (!IsInFootnote()) + { // the hint may be sent from the anchor node, or from a + // node in the footnote; the anchor index is only valid in the + // anchor node! + assert(rNode == static_cast(pNew)->GetTextFootnote()->GetTextNode()); + nPos = MapModelToView(&rNode, + static_cast(pNew)->GetTextFootnote()->GetStart()); + } +#ifdef _MSC_VER + else nPos = TextFrameIndex(42); // shut up MSVC 2017 spurious warning C4701 +#endif + if (IsInFootnote() || IsIdxInside(nPos, TextFrameIndex(1))) + Prepare( PrepareHint::FootnoteInvalidation, static_cast(pNew)->GetTextFootnote() ); + break; + } + + case RES_ATTRSET_CHG: + { + InvalidateLineNum(); + + const SwAttrSet& rNewSet = *static_cast(pNew)->GetChgSet(); + int nClear = 0; + sal_uInt16 nCount = rNewSet.Count(); + + if( const SwFormatFootnote* pItem = rNewSet.GetItemIfSet( RES_TXTATR_FTN, false ) ) + { + nPos = MapModelToView(&rNode, pItem->GetTextFootnote()->GetStart()); + if (IsIdxInside(nPos, TextFrameIndex(1))) + Prepare( PrepareHint::FootnoteInvalidation, pNew ); + nClear = 0x01; + --nCount; + } + + if( const SwFormatField* pItem = rNewSet.GetItemIfSet( RES_TXTATR_FIELD, false ) ) + { + nPos = MapModelToView(&rNode, pItem->GetTextField()->GetStart()); + if (IsIdxInside(nPos, TextFrameIndex(1))) + { + const SfxPoolItem* pOldItem = pOld ? + &(static_cast(pOld)->GetChgSet()->Get(RES_TXTATR_FIELD)) : nullptr; + if (SfxPoolItem::areSame( pItem, pOldItem )) + { + InvalidatePage(); + SetCompletePaint(); + } + else + InvalidateRange_(SwCharRange(nPos, TextFrameIndex(1))); + } + nClear |= 0x02; + --nCount; + } + bool bLineSpace = SfxItemState::SET == rNewSet.GetItemState( + RES_PARATR_LINESPACING, false ), + bRegister = SfxItemState::SET == rNewSet.GetItemState( + RES_PARATR_REGISTER, false ); + if ( bLineSpace || bRegister ) + { + if (!m_pMergedPara || m_pMergedPara->pParaPropsNode == &rModify) + { + Prepare( bRegister ? PrepareHint::Register : PrepareHint::AdjustSizeWithoutFormatting ); + CalcLineSpace(); + InvalidateSize(); + InvalidatePrt_(); + + // i#11859 + // (1) Also invalidate next frame on next page/column. + // (2) Skip empty sections and hidden paragraphs + // Thus, use method + InvalidateNextPrtArea(); + + SetCompletePaint(); + } + nClear |= 0x04; + if ( bLineSpace ) + { + --nCount; + if ((!m_pMergedPara || m_pMergedPara->pParaPropsNode == &rModify) + && IsInSct() && !GetPrev()) + { + SwSectionFrame *pSect = FindSctFrame(); + if( pSect->ContainsAny() == this ) + pSect->InvalidatePrt(); + } + } + if ( bRegister ) + --nCount; + } + if ( SfxItemState::SET == rNewSet.GetItemState( RES_PARATR_SPLIT, + false )) + { + if (!m_pMergedPara || m_pMergedPara->pParaPropsNode == &rModify) + { + if (GetPrev()) + CheckKeep(); + Prepare(); + InvalidateSize(); + } + nClear |= 0x08; + --nCount; + } + + if( SfxItemState::SET == rNewSet.GetItemState( RES_BACKGROUND, false) + && (!m_pMergedPara || m_pMergedPara->pParaPropsNode == &rModify) + && !IsFollow() && GetDrawObjs() ) + { + SwSortedObjs *pObjs = GetDrawObjs(); + for ( size_t i = 0; GetDrawObjs() && i < pObjs->size(); ++i ) + { + SwAnchoredObject* pAnchoredObj = (*pObjs)[i]; + if ( auto pFly = pAnchoredObj->DynCastFlyFrame() ) + { + if( !pFly->IsFlyInContentFrame() ) + { + const SvxBrushItem &rBack = + pFly->GetAttrSet()->GetBackground(); + // #GetTransChg# + // following condition determines, if the fly frame + // "inherites" the background color of text frame. + // This is the case, if fly frame background + // color is "no fill"/"auto fill" and if the fly frame + // has no background graphic. + // Thus, check complete fly frame background + // color and *not* only its transparency value + if ( (rBack.GetColor() == COL_TRANSPARENT) && + rBack.GetGraphicPos() == GPOS_NONE ) + { + pFly->SetCompletePaint(); + pFly->InvalidatePage(); + } + } + } + } + } + + if ( SfxItemState::SET == + rNewSet.GetItemState( RES_TXTATR_CHARFMT, false ) ) + { + lcl_SetWrong( *this, rNode, 0, COMPLETE_STRING, false ); + lcl_SetScriptInval( *this, TextFrameIndex(0) ); + } + else if ( SfxItemState::SET == + rNewSet.GetItemState( RES_CHRATR_LANGUAGE, false ) || + SfxItemState::SET == + rNewSet.GetItemState( RES_CHRATR_CJK_LANGUAGE, false ) || + SfxItemState::SET == + rNewSet.GetItemState( RES_CHRATR_CTL_LANGUAGE, false ) ) + lcl_SetWrong( *this, rNode, 0, COMPLETE_STRING, false ); + else if ( SfxItemState::SET == + rNewSet.GetItemState( RES_CHRATR_FONT, false ) || + SfxItemState::SET == + rNewSet.GetItemState( RES_CHRATR_CJK_FONT, false ) || + SfxItemState::SET == + rNewSet.GetItemState( RES_CHRATR_CTL_FONT, false ) ) + lcl_SetScriptInval( *this, TextFrameIndex(0) ); + else if ( SfxItemState::SET == + rNewSet.GetItemState( RES_FRAMEDIR, false ) + && (!m_pMergedPara || m_pMergedPara->pParaPropsNode == &rModify)) + { + SetDerivedR2L( false ); + CheckDirChange(); + // Force complete paint due to existing indents. + SetCompletePaint(); + } + + if( nCount ) + { + if( getRootFrame()->GetCurrShell() ) + { + Prepare(); + InvalidatePrt_(); + } + + if (nClear || (m_pMergedPara && + (m_pMergedPara->pParaPropsNode != &rModify || + m_pMergedPara->pFirstNode != &rModify))) + { + assert(pOld); + SwAttrSetChg aOldSet( *static_cast(pOld) ); + SwAttrSetChg aNewSet( *static_cast(pNew) ); + + if (m_pMergedPara && m_pMergedPara->pParaPropsNode != &rModify) + { + for (sal_uInt16 i = RES_PARATR_BEGIN; i != RES_FRMATR_END; ++i) + { + if (i != RES_BREAK && i != RES_PAGEDESC) + { + aOldSet.ClearItem(i); + aNewSet.ClearItem(i); + } + } + for (sal_uInt16 i = XATTR_FILL_FIRST; i <= XATTR_FILL_LAST; ++i) + { + aOldSet.ClearItem(i); + aNewSet.ClearItem(i); + } + } + if (m_pMergedPara && m_pMergedPara->pFirstNode != &rModify) + { + aOldSet.ClearItem(RES_BREAK); + aNewSet.ClearItem(RES_BREAK); + aOldSet.ClearItem(RES_PAGEDESC); + aNewSet.ClearItem(RES_PAGEDESC); + } + + if( 0x01 & nClear ) + { + aOldSet.ClearItem( RES_TXTATR_FTN ); + aNewSet.ClearItem( RES_TXTATR_FTN ); + } + if( 0x02 & nClear ) + { + aOldSet.ClearItem( RES_TXTATR_FIELD ); + aNewSet.ClearItem( RES_TXTATR_FIELD ); + } + if ( 0x04 & nClear ) + { + if ( bLineSpace ) + { + aOldSet.ClearItem( RES_PARATR_LINESPACING ); + aNewSet.ClearItem( RES_PARATR_LINESPACING ); + } + if ( bRegister ) + { + aOldSet.ClearItem( RES_PARATR_REGISTER ); + aNewSet.ClearItem( RES_PARATR_REGISTER ); + } + } + if ( 0x08 & nClear ) + { + aOldSet.ClearItem( RES_PARATR_SPLIT ); + aNewSet.ClearItem( RES_PARATR_SPLIT ); + } + if (aOldSet.Count() || aNewSet.Count()) + { + SwContentFrame::SwClientNotify(rModify, sw::LegacyModifyHint(&aOldSet, &aNewSet)); + } + } + else + SwContentFrame::SwClientNotify(rModify, sw::LegacyModifyHint(pOld, pNew)); + } + +#if !ENABLE_WASM_STRIP_ACCESSIBILITY + if (isA11yRelevantAttribute(nWhich)) + { + SwViewShell* pViewSh = getRootFrame() ? getRootFrame()->GetCurrShell() : nullptr; + if ( pViewSh ) + { + pViewSh->InvalidateAccessibleParaAttrs( *this ); + } + } +#endif + } + break; + case RES_PARATR_SPLIT: + if ( GetPrev() ) + CheckKeep(); + Prepare(); + bSetFieldsDirty = true; + break; + case RES_FRAMEDIR : + assert(false); // should have been forwarded to SwContentFrame + SetDerivedR2L( false ); + CheckDirChange(); + break; + default: + { + Prepare(); + InvalidatePrt_(); + if ( !nWhich ) + { + // is called by e. g. HiddenPara with 0 + SwFrame *pNxt = FindNext(); + if ( nullptr != pNxt ) + pNxt->InvalidatePrt(); + } + } + } // switch + + if( bSetFieldsDirty ) + GetDoc().getIDocumentFieldsAccess().SetFieldsDirty( true, &rNode, SwNodeOffset(1) ); + + if ( bRecalcFootnoteFlag ) + CalcFootnoteFlag(); +} + +void SwTextFrame::PrepWidows( const sal_uInt16 nNeed, bool bNotify ) +{ + OSL_ENSURE(GetFollow() && nNeed, "+SwTextFrame::Prepare: lost all friends"); + + SwParaPortion *pPara = GetPara(); + if ( !pPara ) + return; + pPara->SetPrepWidows(); + + sal_uInt16 nHave = nNeed; + + // We yield a few lines and shrink in CalcPreps() + SwSwapIfNotSwapped swap( this ); + + SwTextSizeInfo aInf( this ); + SwTextMargin aLine( this, &aInf ); + aLine.Bottom(); + TextFrameIndex nTmpLen = aLine.GetCurr()->GetLen(); + while( nHave && aLine.PrevLine() ) + { + if( nTmpLen ) + --nHave; + nTmpLen = aLine.GetCurr()->GetLen(); + } + + // If it's certain that we can yield lines, the Master needs + // to check the widow rule + if( !nHave ) + { + bool bSplit = true; + if( !IsFollow() ) // only a master decides about orphans + { + const WidowsAndOrphans aWidOrp( this ); + bSplit = ( aLine.GetLineNr() >= aWidOrp.GetOrphansLines() && + aLine.GetLineNr() >= aLine.GetDropLines() ); + } + + if( bSplit ) + { + GetFollow()->SetOffset( aLine.GetEnd() ); + aLine.TruncLines( true ); + if( pPara->IsFollowField() ) + GetFollow()->SetFieldFollow( true ); + } + } + if ( bNotify ) + { + InvalidateSize_(); + InvalidatePage(); + } +} + +static bool lcl_ErgoVadis(SwTextFrame* pFrame, TextFrameIndex & rPos, const PrepareHint ePrep) +{ + const SwFootnoteInfo &rFootnoteInfo = pFrame->GetDoc().GetFootnoteInfo(); + if( ePrep == PrepareHint::ErgoSum ) + { + if( rFootnoteInfo.m_aErgoSum.isEmpty() ) + return false; + rPos = pFrame->GetOffset(); + } + else + { + if( rFootnoteInfo.m_aQuoVadis.isEmpty() ) + return false; + if( pFrame->HasFollow() ) + rPos = pFrame->GetFollow()->GetOffset(); + else + rPos = TextFrameIndex(pFrame->GetText().getLength()); + if( rPos ) + --rPos; // our last character + } + return true; +} + +// Silence over-eager warning emitted at least by GCC 5.3.1 +#if defined __GNUC__ && !defined __clang__ +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wstrict-overflow" +#endif +bool SwTextFrame::Prepare( const PrepareHint ePrep, const void* pVoid, + bool bNotify ) +{ + bool bParaPossiblyInvalid = false; + + SwFrameSwapper aSwapper( this, false ); + + if ( IsEmpty() ) + { + switch ( ePrep ) + { + case PrepareHint::BossChanged: + SetInvalidVert( true ); // Test + [[fallthrough]]; + case PrepareHint::WidowsOrphans: + case PrepareHint::Widows: + case PrepareHint::FootnoteInvalidationGone : return bParaPossiblyInvalid; + + case PrepareHint::FramePositionChanged : + { + // We also need an InvalidateSize for Areas (with and without columns), + // so that we format and bUndersized is set (if needed) + if( IsInFly() || IsInSct() ) + { + SwTwips nTmpBottom = GetUpper()->getFrameArea().Top() + + GetUpper()->getFramePrintArea().Bottom(); + if( nTmpBottom < getFrameArea().Bottom() ) + break; + } + // Are there any free-flying frames on this page? + SwTextFly aTextFly( this ); + if( aTextFly.IsOn() ) + { + // Does any free-flying frame overlap? + if ( aTextFly.Relax() || IsUndersized() ) + break; + } + if (GetTextNodeForParaProps()->GetSwAttrSet().GetRegister().GetValue()) + break; + + SwTextGridItem const*const pGrid(GetGridItem(FindPageFrame())); + if (pGrid && GetTextNodeForParaProps()->GetSwAttrSet().GetParaGrid().GetValue()) + break; + + // i#28701 - consider anchored objects + if ( GetDrawObjs() ) + break; + + return bParaPossiblyInvalid; + } + default: + break; + } + } + + // Split fly anchors are technically empty (have no SwParaPortion), but otherwise behave like + // other split text frames, which are non-empty. + bool bSplitFlyAnchor = GetOffset() == TextFrameIndex(0) && HasFollow() + && GetFollow()->GetOffset() == TextFrameIndex(0); + + if( !HasPara() && !bSplitFlyAnchor && PrepareHint::MustFit != ePrep ) + { + SetInvalidVert( true ); // Test + OSL_ENSURE( !IsLocked(), "SwTextFrame::Prepare: three of a perfect pair" ); + if ( bNotify ) + InvalidateSize(); + else + InvalidateSize_(); + return bParaPossiblyInvalid; + } + + // Get object from cache while locking + SwTextLineAccess aAccess( this ); + SwParaPortion *pPara = aAccess.GetPara(); + + switch( ePrep ) + { + case PrepareHint::FootnoteMove : + { + SwFrameAreaDefinition::FrameAreaWriteAccess aFrm(*this); + aFrm.Height(0); + } + + { + SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*this); + aPrt.Height(0); + } + + InvalidatePrt_(); + InvalidateSize_(); + [[fallthrough]]; + case PrepareHint::AdjustSizeWithoutFormatting : + pPara->SetPrepAdjust(); + if( IsFootnoteNumFrame() != pPara->IsFootnoteNum() || + IsUndersized() ) + { + InvalidateRange(SwCharRange(TextFrameIndex(0), TextFrameIndex(1)), 1); + if( GetOffset() && !IsFollow() ) + SetOffset_(TextFrameIndex(0)); + } + break; + case PrepareHint::MustFit : + pPara->SetPrepMustFit(true); + [[fallthrough]]; + case PrepareHint::WidowsOrphans : + pPara->SetPrepAdjust(); + break; + case PrepareHint::Widows : + // MustFit is stronger than anything else + if( pPara->IsPrepMustFit() ) + return bParaPossiblyInvalid; + // see comment in WidowsAndOrphans::FindOrphans and CalcPreps() + PrepWidows( *static_cast(pVoid), bNotify ); + break; + + case PrepareHint::FootnoteInvalidation : + { + SwTextFootnote const *pFootnote = static_cast(pVoid); + if( IsInFootnote() ) + { + // Am I the first TextFrame of a footnote? + if( !GetPrev() ) + // So we're a TextFrame of the footnote, which has + // to display the footnote number or the ErgoSum text + InvalidateRange(SwCharRange(TextFrameIndex(0), TextFrameIndex(1)), 1); + + if( !GetNext() ) + { + // We're the last Footnote; we need to update the + // QuoVadis texts now + const SwFootnoteInfo &rFootnoteInfo = GetDoc().GetFootnoteInfo(); + if( !pPara->UpdateQuoVadis( rFootnoteInfo.m_aQuoVadis ) ) + { + TextFrameIndex nPos = pPara->GetParLen(); + if( nPos ) + --nPos; + InvalidateRange( SwCharRange(nPos, TextFrameIndex(1)), 1); + } + } + } + else + { + // We are the TextFrame _with_ the footnote + TextFrameIndex const nPos = MapModelToView( + &pFootnote->GetTextNode(), pFootnote->GetStart()); + InvalidateRange(SwCharRange(nPos, TextFrameIndex(1)), 1); + } + break; + } + case PrepareHint::BossChanged : + { + // Test + { + SetInvalidVert( false ); + bool bOld = IsVertical(); + SetInvalidVert( true ); + if( bOld != IsVertical() ) + InvalidateRange(SwCharRange(GetOffset(), TextFrameIndex(COMPLETE_STRING))); + } + + if( HasFollow() ) + { + TextFrameIndex nNxtOfst = GetFollow()->GetOffset(); + if( nNxtOfst ) + --nNxtOfst; + InvalidateRange(SwCharRange( nNxtOfst, TextFrameIndex(1)), 1); + } + if( IsInFootnote() ) + { + TextFrameIndex nPos; + if( lcl_ErgoVadis( this, nPos, PrepareHint::QuoVadis ) ) + InvalidateRange( SwCharRange( nPos, TextFrameIndex(1)) ); + if( lcl_ErgoVadis( this, nPos, PrepareHint::ErgoSum ) ) + InvalidateRange( SwCharRange( nPos, TextFrameIndex(1)) ); + } + // If we have a page number field, we must invalidate those spots + SwTextNode const* pNode(nullptr); + sw::MergedAttrIter iter(*this); + TextFrameIndex const nEnd = GetFollow() + ? GetFollow()->GetOffset() : TextFrameIndex(COMPLETE_STRING); + for (SwTextAttr const* pHt = iter.NextAttr(&pNode); pHt; pHt = iter.NextAttr(&pNode)) + { + TextFrameIndex const nStart(MapModelToView(pNode, pHt->GetStart())); + if (nStart >= GetOffset()) + { + if (nStart >= nEnd) + break; + + // If we're flowing back and own a Footnote, the Footnote also flows + // with us. So that it doesn't obstruct us, we send ourselves + // an ADJUST_FRM. + // pVoid != 0 means MoveBwd() + const sal_uInt16 nWhich = pHt->Which(); + if (RES_TXTATR_FIELD == nWhich || + (HasFootnote() && pVoid && RES_TXTATR_FTN == nWhich)) + InvalidateRange(SwCharRange(nStart, TextFrameIndex(1)), 1); + } + } + // A new boss, a new chance for growing + if( IsUndersized() ) + { + InvalidateSize_(); + InvalidateRange(SwCharRange(GetOffset(), TextFrameIndex(1)), 1); + } + break; + } + + case PrepareHint::FramePositionChanged : + { + if ( isFramePrintAreaValid() ) + { + SwTextGridItem const*const pGrid(GetGridItem(FindPageFrame())); + if (pGrid && GetTextNodeForParaProps()->GetSwAttrSet().GetParaGrid().GetValue()) + InvalidatePrt(); + } + + // If we don't overlap with anybody: + // did any free-flying frame overlapped _before_ the position change? + bool bFormat = pPara->HasFly(); + if( !bFormat ) + { + if( IsInFly() ) + { + SwTwips nTmpBottom = GetUpper()->getFrameArea().Top() + + GetUpper()->getFramePrintArea().Bottom(); + if( nTmpBottom < getFrameArea().Bottom() ) + bFormat = true; + } + if( !bFormat ) + { + if ( GetDrawObjs() ) + { + const size_t nCnt = GetDrawObjs()->size(); + for ( size_t i = 0; i < nCnt; ++i ) + { + SwAnchoredObject* pAnchoredObj = (*GetDrawObjs())[i]; + // i#28701 - consider all + // to-character anchored objects + if ( pAnchoredObj->GetFrameFormat().GetAnchor().GetAnchorId() + == RndStdIds::FLY_AT_CHAR ) + { + bFormat = true; + break; + } + } + } + if( !bFormat ) + { + // Are there any free-flying frames on this page? + SwTextFly aTextFly( this ); + if( aTextFly.IsOn() ) + { + // Does any free-flying frame overlap? + const bool bRelaxed = aTextFly.Relax(); + bFormat = bRelaxed || IsUndersized(); + if (bRelaxed) + { + // It's possible that pPara was deleted above; retrieve it again + pPara = aAccess.GetPara(); + } + } + } + } + } + + if( bFormat ) + { + if( !IsLocked() ) + { + if( pPara->GetRepaint().HasArea() ) + SetCompletePaint(); + Init(); + pPara = nullptr; + InvalidateSize_(); + } + } + else + { + if (GetTextNodeForParaProps()->GetSwAttrSet().GetRegister().GetValue()) + bParaPossiblyInvalid = Prepare( PrepareHint::Register, nullptr, bNotify ); + // The Frames need to be readjusted, which caused by changes + // in position + else if( HasFootnote() ) + { + bParaPossiblyInvalid = Prepare( PrepareHint::AdjustSizeWithoutFormatting, nullptr, bNotify ); + InvalidateSize_(); + } + else + return bParaPossiblyInvalid; // So that there's no SetPrep() + + if (bParaPossiblyInvalid) + { + // It's possible that pPara was deleted above; retrieve it again + pPara = aAccess.GetPara(); + } + + } + break; + } + case PrepareHint::Register: + if (GetTextNodeForParaProps()->GetSwAttrSet().GetRegister().GetValue()) + { + pPara->SetPrepAdjust(); + CalcLineSpace(); + + // It's possible that pPara was deleted above; retrieve it again + bParaPossiblyInvalid = true; + pPara = aAccess.GetPara(); + + InvalidateSize(); + InvalidatePrt_(); + SwFrame* pNxt = GetIndNext(); + if ( nullptr != pNxt ) + { + pNxt->InvalidatePrt_(); + if ( pNxt->IsLayoutFrame() ) + pNxt->InvalidatePage(); + } + SetCompletePaint(); + } + break; + case PrepareHint::FootnoteInvalidationGone : + { + // If a Follow is calling us, because a footnote is being deleted, our last + // line has to be formatted, so that the first line of the Follow can flow up. + // Which had flowed to the next page to be together with the footnote (this is + // especially true for areas with columns) + OSL_ENSURE( GetFollow(), "PrepareHint::FootnoteInvalidationGone may only be called by Follow" ); + TextFrameIndex nPos = GetFollow()->GetOffset(); + if( IsFollow() && GetOffset() == nPos ) // If we don't have a mass of text, we call our + FindMaster()->Prepare( PrepareHint::FootnoteInvalidationGone ); // Master's Prepare + if( nPos ) + --nPos; // The char preceding our Follow + InvalidateRange(SwCharRange(nPos, TextFrameIndex(1))); + return bParaPossiblyInvalid; + } + case PrepareHint::ErgoSum: + case PrepareHint::QuoVadis: + { + TextFrameIndex nPos; + if( lcl_ErgoVadis( this, nPos, ePrep ) ) + InvalidateRange(SwCharRange(nPos, TextFrameIndex(1))); + } + break; + case PrepareHint::FlyFrameAttributesChanged: + { + if( pVoid ) + { + TextFrameIndex const nWhere = CalcFlyPos( static_cast(pVoid) ); + OSL_ENSURE( TextFrameIndex(COMPLETE_STRING) != nWhere, "Prepare: Why me?" ); + InvalidateRange(SwCharRange(nWhere, TextFrameIndex(1))); + return bParaPossiblyInvalid; + } + [[fallthrough]]; // else: continue with default case block + } + case PrepareHint::Clear: + default: + { + if( IsLocked() ) + { + if( PrepareHint::FlyFrameArrive == ePrep || PrepareHint::FlyFrameLeave == ePrep ) + { + TextFrameIndex const nLen = (GetFollow() + ? GetFollow()->GetOffset() + : TextFrameIndex(COMPLETE_STRING)) + - GetOffset(); + InvalidateRange( SwCharRange( GetOffset(), nLen ) ); + } + } + else + { + if( pPara->GetRepaint().HasArea() ) + SetCompletePaint(); + Init(); + pPara = nullptr; + if( GetOffset() && !IsFollow() ) + SetOffset_( TextFrameIndex(0) ); + if ( bNotify ) + InvalidateSize(); + else + InvalidateSize_(); + } + return bParaPossiblyInvalid; // no SetPrep() happened + } + } + if( pPara ) + { + pPara->SetPrep(); + } + + return bParaPossiblyInvalid; +} +#if defined __GNUC__ && !defined __clang__ +# pragma GCC diagnostic pop +#endif + +/** + * Small Helper class: + * Prepares a test format. + * The frame is changed in size and position, its SwParaPortion is moved aside + * and a new one is created. + * To achieve this, run formatting with bTestFormat flag set. + * In the destructor the TextFrame is reset to its original state. + */ +class SwTestFormat +{ + SwTextFrame *pFrame; + SwParaPortion *pOldPara; + SwRect aOldFrame, aOldPrt; +public: + SwTestFormat( SwTextFrame* pTextFrame, const SwFrame* pPrv, SwTwips nMaxHeight ); + ~SwTestFormat(); +}; + +SwTestFormat::SwTestFormat( SwTextFrame* pTextFrame, const SwFrame* pPre, SwTwips nMaxHeight ) + : pFrame( pTextFrame ) +{ + aOldFrame = pFrame->getFrameArea(); + aOldPrt = pFrame->getFramePrintArea(); + + SwRectFnSet aRectFnSet(pFrame); + SwTwips nLower = aRectFnSet.GetBottomMargin(*pFrame); + + { + // indeed, here the GetUpper()->getFramePrintArea() gets copied and manipulated + SwFrameAreaDefinition::FrameAreaWriteAccess aFrm(*pFrame); + aFrm.setSwRect(pFrame->GetUpper()->getFramePrintArea()); + aFrm += pFrame->GetUpper()->getFrameArea().Pos(); + aRectFnSet.SetHeight( aFrm, nMaxHeight ); + + if( pFrame->GetPrev() ) + { + aRectFnSet.SetPosY( + aFrm, + aRectFnSet.GetBottom(pFrame->GetPrev()->getFrameArea()) - ( aRectFnSet.IsVert() ? nMaxHeight + 1 : 0 ) ); + } + } + + SwBorderAttrAccess aAccess( SwFrame::GetCache(), pFrame ); + const SwBorderAttrs &rAttrs = *aAccess.Get(); + + { + SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*pFrame); + aRectFnSet.SetPosX(aPrt, rAttrs.CalcLeft( pFrame ) ); + } + + if( pPre ) + { + SwTwips nUpper = pFrame->CalcUpperSpace( &rAttrs, pPre ); + SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*pFrame); + aRectFnSet.SetPosY(aPrt, nUpper ); + } + + { + SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*pFrame); + aRectFnSet.SetHeight( aPrt, std::max( tools::Long(0) , aRectFnSet.GetHeight(pFrame->getFrameArea()) - aRectFnSet.GetTop(aPrt) - nLower ) ); + aRectFnSet.SetWidth( aPrt, aRectFnSet.GetWidth(pFrame->getFrameArea()) - ( rAttrs.CalcLeft( pFrame ) + rAttrs.CalcRight( pFrame ) ) ); + } + + pOldPara = pFrame->HasPara() ? pFrame->GetPara() : nullptr; + pFrame->SetPara( new SwParaPortion(), false ); + OSL_ENSURE( ! pFrame->IsSwapped(), "A frame is swapped before Format_" ); + + if ( pFrame->IsVertical() ) + pFrame->SwapWidthAndHeight(); + + SwTextFormatInfo aInf( pFrame->getRootFrame()->GetCurrShell()->GetOut(), pFrame, false, true, true ); + SwTextFormatter aLine( pFrame, &aInf ); + + pFrame->Format_( aLine, aInf ); + + if ( pFrame->IsVertical() ) + pFrame->SwapWidthAndHeight(); + + OSL_ENSURE( ! pFrame->IsSwapped(), "A frame is swapped after Format_" ); +} + +SwTestFormat::~SwTestFormat() +{ + { + SwFrameAreaDefinition::FrameAreaWriteAccess aFrm(*pFrame); + aFrm.setSwRect(aOldFrame); + } + + { + SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*pFrame); + aPrt.setSwRect(aOldPrt); + } + + pFrame->SetPara( pOldPara ); +} + +bool SwTextFrame::TestFormat( const SwFrame* pPrv, SwTwips &rMaxHeight, bool &bSplit ) +{ + PROTOCOL_ENTER( this, PROT::TestFormat, DbgAction::NONE, nullptr ) + + if( IsLocked() && GetUpper()->getFramePrintArea().Width() <= 0 ) + return false; + + SwTestFormat aSave( this, pPrv, rMaxHeight ); + + return SwTextFrame::WouldFit(rMaxHeight, bSplit, true, false); +} + +/** + * We should not and don't need to reformat. + * We assume that we already formatted and that the formatting + * data is still current. + * + * We also assume that the frame width of the Master and Follow + * are the same. That's why we're not calling FindBreak() for + * FindOrphans(). + * The required height is coming from nMaxHeight. + * + * @returns true if I can split + */ +bool SwTextFrame::WouldFit(SwTwips &rMaxHeight, bool &bSplit, bool bTst, bool bMoveBwd) +{ + OSL_ENSURE( ! IsVertical() || ! IsSwapped(), + "SwTextFrame::WouldFit with swapped frame" ); + SwRectFnSet aRectFnSet(this); + + if( IsLocked() ) + return false; + + // it can happen that the IdleCollector removed the cached information + if( !IsEmpty() ) + GetFormatted(); + + // i#27801 - correction: 'short cut' for empty paragraph + // can *not* be applied, if test format is in progress. The test format doesn't + // adjust the frame and the printing area - see method , + // which is called in + if ( IsEmpty() && !bTst ) + { + bSplit = false; + SwTwips nHeight = aRectFnSet.IsVert() ? getFramePrintArea().SSize().Width() : getFramePrintArea().SSize().Height(); + if( rMaxHeight < nHeight ) + return false; + else + { + rMaxHeight -= nHeight; + return true; + } + } + + // GetPara can still be 0 in edge cases + // We return true in order to be reformatted on the new Page + OSL_ENSURE( HasPara() || IsHiddenNow(), "WouldFit: GetFormatted() and then !HasPara()" ); + if( !HasPara() || ( !aRectFnSet.GetHeight(getFrameArea()) && IsHiddenNow() ) ) + return true; + + // Because the Orphan flag only exists for a short moment, we also check + // whether the Framesize is set to very huge by CalcPreps, in order to + // force a MoveFwd + if (IsWidow() || (aRectFnSet.IsVert() + ? (0 == getFrameArea().Left()) + : (sw::WIDOW_MAGIC - 20000 < getFrameArea().Bottom()))) + { + SetWidow(false); + if ( GetFollow() ) + { + // If we've ended up here due to a Widow request by our Follow, we check + // whether there's a Follow with a real height at all. + // Else (e.g. for newly created SctFrames) we ignore the IsWidow() and + // still check if we can find enough room + if (((!aRectFnSet.IsVert() && getFrameArea().Bottom() <= sw::WIDOW_MAGIC - 20000) || + ( aRectFnSet.IsVert() && 0 < getFrameArea().Left() ) ) && + ( GetFollow()->IsVertical() ? + !GetFollow()->getFrameArea().Width() : + !GetFollow()->getFrameArea().Height() ) ) + { + SwTextFrame* pFoll = GetFollow()->GetFollow(); + while( pFoll && + ( pFoll->IsVertical() ? + !pFoll->getFrameArea().Width() : + !pFoll->getFrameArea().Height() ) ) + pFoll = pFoll->GetFollow(); + if( pFoll ) + return false; + } + else + return false; + } + } + + SwSwapIfNotSwapped swap( this ); + + SwTextSizeInfo aInf( this ); + SwTextMargin aLine( this, &aInf ); + + WidowsAndOrphans aFrameBreak( this, rMaxHeight, bSplit ); + + bool bRet = true; + + aLine.Bottom(); + // is breaking necessary? + bSplit = !aFrameBreak.IsInside( aLine ); + if ( bSplit ) + bRet = !aFrameBreak.IsKeepAlways() && aFrameBreak.WouldFit(aLine, rMaxHeight, bTst, bMoveBwd); + else + { + // we need the total height including the current line + aLine.Top(); + do + { + rMaxHeight -= aLine.GetLineHeight(); + } while ( aLine.Next() ); + } + + return bRet; +} + +SwTwips SwTextFrame::GetParHeight() const +{ + OSL_ENSURE( ! IsVertical() || ! IsSwapped(), + "SwTextFrame::GetParHeight with swapped frame" ); + + if( !HasPara() ) + { // For non-empty paragraphs this is a special case + // For UnderSized we can simply just ask 1 Twip more + sal_uInt16 nRet = o3tl::narrowing(getFramePrintArea().SSize().Height()); + if( IsUndersized() ) + { + if( IsEmpty() || GetText().isEmpty() ) + nRet = o3tl::narrowing(EmptyHeight()); + else + ++nRet; + } + return nRet; + } + + // TODO: Refactor and improve code + const SwLineLayout* pLineLayout = GetPara(); + SwTwips nHeight = pLineLayout ? pLineLayout->GetRealHeight() : 0; + + // Is this paragraph scrolled? Our height until now is at least + // one line height too low then + if( GetOffset() && !IsFollow() ) + nHeight *= 2; + + while ( pLineLayout && pLineLayout->GetNext() ) + { + pLineLayout = pLineLayout->GetNext(); + nHeight = nHeight + pLineLayout->GetRealHeight(); + } + + return nHeight; +} + +/** + * @returns this _always_ in the formatted state! + */ +SwTextFrame* SwTextFrame::GetFormatted( bool bForceQuickFormat ) +{ + vcl::RenderContext* pRenderContext = getRootFrame()->GetCurrShell()->GetOut(); + SwSwapIfSwapped swap( this ); + + // In case the SwLineLayout was cleared out of the s_pTextCache, recreate it + // Not for empty paragraphs + if( !HasPara() && !(isFrameAreaDefinitionValid() && IsEmpty()) ) + { + // Calc() must be called, because frame position can be wrong + const bool bFormat = isFrameAreaSizeValid(); + Calc(pRenderContext); // calls Format() if invalid + + // If the flags were valid (hence bFormat=true), Calc did nothing, + // so Format() must be called manually in order to recreate + // the SwLineLayout that has been deleted from the + // SwTextFrame::s_pTextCache (hence !HasPara() above). + // Optimization with FormatQuick() + if( bFormat && !FormatQuick( bForceQuickFormat ) ) + Format(getRootFrame()->GetCurrShell()->GetOut()); + } + + return this; +} + +SwTwips SwTextFrame::CalcFitToContent() +{ + // i#31490 + // If we are currently locked, we better return with a + // fairly reasonable value: + if ( IsLocked() ) + return getFramePrintArea().Width(); + + SwParaPortion* pOldPara = GetPara(); + SwParaPortion *pDummy = new SwParaPortion(); + SetPara( pDummy, false ); + const SwPageFrame* pPage = FindPageFrame(); + + const Point aOldFramePos = getFrameArea().Pos(); + const SwTwips nOldFrameWidth = getFrameArea().Width(); + const SwTwips nOldPrtWidth = getFramePrintArea().Width(); + const SwTwips nPageWidth = GetUpper()->IsVertical() ? + pPage->getFramePrintArea().Height() : + pPage->getFramePrintArea().Width(); + + { + SwFrameAreaDefinition::FrameAreaWriteAccess aFrm(*this); + aFrm.Width( nPageWidth ); + } + + { + SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*this); + aPrt.Width( nPageWidth ); + } + + // i#25422 objects anchored as character in RTL + if ( IsRightToLeft() ) + { + SwFrameAreaDefinition::FrameAreaWriteAccess aFrm(*this); + aFrm.Pos().AdjustX(nOldFrameWidth - nPageWidth ); + } + + TextFrameLockGuard aLock( this ); + + SwTextFormatInfo aInf( getRootFrame()->GetCurrShell()->GetOut(), this, false, true, true ); + aInf.SetIgnoreFly( true ); + SwTextFormatter aLine( this, &aInf ); + SwHookOut aHook( aInf ); + + // i#54031 - assure minimum of MINLAY twips. + const SwTwips nMax = std::max( SwTwips(MINLAY), aLine.CalcFitToContent_() + 1 ); + + { + SwFrameAreaDefinition::FrameAreaWriteAccess aFrm(*this); + aFrm.Width( nOldFrameWidth ); + + // i#25422 objects anchored as character in RTL + if ( IsRightToLeft() ) + { + aFrm.Pos() = aOldFramePos; + } + } + + { + SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*this); + aPrt.Width( nOldPrtWidth ); + } + + SetPara( pOldPara ); + + return nMax; +} + +/** + * Simulate format for a list item paragraph, whose list level attributes + * are in LABEL_ALIGNMENT mode, in order to determine additional first + * line offset for the real text formatting due to the value of label + * adjustment attribute of the list level. + */ +void SwTextFrame::CalcAdditionalFirstLineOffset() +{ + if ( IsLocked() ) + return; + + // reset additional first line offset + mnAdditionalFirstLineOffset = 0; + + const SwTextNode* pTextNode( GetTextNodeForParaProps() ); + // sw_redlinehide: check that pParaPropsNode is the correct one + assert(pTextNode->IsNumbered(getRootFrame()) == pTextNode->IsNumbered(nullptr)); + if (!(pTextNode->IsNumbered(getRootFrame()) && + pTextNode->IsCountedInList() && pTextNode->GetNumRule())) + return; + + int nListLevel = pTextNode->GetActualListLevel(); + + if (nListLevel < 0) + nListLevel = 0; + + if (nListLevel >= MAXLEVEL) + nListLevel = MAXLEVEL - 1; + + const SwNumFormat& rNumFormat = + pTextNode->GetNumRule()->Get( o3tl::narrowing(nListLevel) ); + if ( rNumFormat.GetPositionAndSpaceMode() != SvxNumberFormat::LABEL_ALIGNMENT ) + return; + + // keep current paragraph portion and apply dummy paragraph portion + SwParaPortion* pOldPara = GetPara(); + SwParaPortion *pDummy = new SwParaPortion(); + SetPara( pDummy, false ); + + // lock paragraph + TextFrameLockGuard aLock( this ); + + // simulate text formatting + SwTextFormatInfo aInf( getRootFrame()->GetCurrShell()->GetOut(), this, false, true, true ); + aInf.SetIgnoreFly( true ); + SwTextFormatter aLine( this, &aInf ); + SwHookOut aHook( aInf ); + aLine.CalcFitToContent_(); + + // determine additional first line offset + const SwLinePortion* pFirstPortion = aLine.GetCurr()->GetFirstPortion(); + if ( pFirstPortion->InNumberGrp() && !pFirstPortion->IsFootnoteNumPortion() ) + { + SwTwips nNumberPortionWidth( pFirstPortion->Width() ); + + const SwLinePortion* pPortion = pFirstPortion->GetNextPortion(); + while ( pPortion && + pPortion->InNumberGrp() && !pPortion->IsFootnoteNumPortion()) + { + nNumberPortionWidth += pPortion->Width(); + pPortion = pPortion->GetNextPortion(); + } + + if ( ( IsRightToLeft() && + rNumFormat.GetNumAdjust() == SvxAdjust::Left ) || + ( !IsRightToLeft() && + rNumFormat.GetNumAdjust() == SvxAdjust::Right ) ) + { + mnAdditionalFirstLineOffset = -nNumberPortionWidth; + } + else if ( rNumFormat.GetNumAdjust() == SvxAdjust::Center ) + { + mnAdditionalFirstLineOffset = -(nNumberPortionWidth/2); + } + } + + // restore paragraph portion + SetPara( pOldPara ); +} + +/** + * Determine the height of the last line for the calculation of + * the proportional line spacing + * + * Height of last line will be stored in new member + * mnHeightOfLastLine and can be accessed via method + * GetHeightOfLastLine() + * + * @param _bUseFont force the usage of the former algorithm to + * determine the height of the last line, which + * uses the font + */ +void SwTextFrame::CalcHeightOfLastLine( const bool _bUseFont ) +{ + // i#71281 + // Invalidate printing area, if height of last line changes + const SwTwips nOldHeightOfLastLine( mnHeightOfLastLine ); + + // determine output device + SwViewShell* pVsh = getRootFrame()->GetCurrShell(); + OSL_ENSURE( pVsh, " - no SwViewShell" ); + + // i#78921 + // There could be no instance in the case of loading a binary + // StarOffice file format containing an embedded Writer document. + if ( !pVsh ) + { + return; + } + OutputDevice* pOut = pVsh->GetOut(); + const IDocumentSettingAccess *const pIDSA = &GetDoc().getIDocumentSettingAccess(); + if ( !pVsh->GetViewOptions()->getBrowseMode() || + pVsh->GetViewOptions()->IsPrtFormat() ) + { + pOut = GetDoc().getIDocumentDeviceAccess().getReferenceDevice( true ); + } + OSL_ENSURE( pOut, " - no OutputDevice" ); + + if ( !pOut ) + { + return; + } + + // determine height of last line + if ( _bUseFont || pIDSA->get(DocumentSettingId::OLD_LINE_SPACING ) ) + { + // former determination of last line height for proportional line + // spacing - take height of font set at the paragraph + // FIXME actually... must the font match across all nodes? + SwFont aFont( &GetTextNodeForParaProps()->GetSwAttrSet(), pIDSA ); + + // we must ensure that the font is restored correctly on the OutputDevice + // otherwise Last!=Owner could occur + if ( pLastFont ) + { + SwFntObj *pOldFont = pLastFont; + pLastFont = nullptr; + aFont.SetFntChg( true ); + aFont.ChgPhysFnt( pVsh, *pOut ); + mnHeightOfLastLine = aFont.GetHeight( pVsh, *pOut ); + assert(pLastFont && "coverity[var_deref_model] - pLastFont should be set in SwSubFont::ChgFnt"); + pLastFont->Unlock(); + pLastFont = pOldFont; + pLastFont->SetDevFont( pVsh, *pOut ); + } + else + { + vcl::Font aOldFont = pOut->GetFont(); + aFont.SetFntChg( true ); + aFont.ChgPhysFnt( pVsh, *pOut ); + mnHeightOfLastLine = aFont.GetHeight( pVsh, *pOut ); + assert(pLastFont && "coverity[var_deref_model] - pLastFont should be set in SwSubFont::ChgFnt"); + pLastFont->Unlock(); + pLastFont = nullptr; + pOut->SetFont( aOldFont ); + } + } + else + { + // new determination of last line height - take actually height of last line + // i#89000 + // assure same results, if paragraph is undersized + if ( IsUndersized() ) + { + mnHeightOfLastLine = 0; + } + else + { + bool bCalcHeightOfLastLine = true; + if ( ( !HasPara() && IsEmpty( ) ) || GetText().isEmpty() ) + { + mnHeightOfLastLine = EmptyHeight(); + bCalcHeightOfLastLine = false; + } + + if ( bCalcHeightOfLastLine ) + { + OSL_ENSURE( HasPara(), + " - missing paragraph portions." ); + const SwLineLayout* pLineLayout = GetPara(); + while ( pLineLayout && pLineLayout->GetNext() ) + { + // iteration to last line + pLineLayout = pLineLayout->GetNext(); + } + if ( pLineLayout ) + { + SwTwips nAscent, nDescent, nDummy1, nDummy2; + // i#47162 - suppress consideration of + // fly content portions and the line portion. + pLineLayout->MaxAscentDescent( nAscent, nDescent, + nDummy1, nDummy2, + nullptr, true ); + // i#71281 + // Suppress wrong invalidation of printing area, if method is + // called recursive. + // Thus, member is only set directly, if + // no recursive call is needed. + const SwTwips nNewHeightOfLastLine = nAscent + nDescent; + // i#47162 - if last line only contains + // fly content portions, is zero. + // In this case determine height of last line by the font + if ( nNewHeightOfLastLine == 0 ) + { + CalcHeightOfLastLine( true ); + } + else + { + mnHeightOfLastLine = nNewHeightOfLastLine; + } + } + } + } + } + // i#71281 + // invalidate printing area, if height of last line changes + if ( mnHeightOfLastLine != nOldHeightOfLastLine ) + { + InvalidatePrt(); + } +} + +/** + * Method returns the value of the inter line spacing for a text frame. + * Such a value exists for proportional line spacings ("1,5 Lines", + * "Double", "Proportional" and for leading line spacing ("Leading"). + * + * @param _bNoPropLineSpacing (default = false) control whether the + * value of a proportional line spacing is + * returned or not + */ +tools::Long SwTextFrame::GetLineSpace( const bool _bNoPropLineSpace ) const +{ + tools::Long nRet = 0; + + const SvxLineSpacingItem &rSpace = GetTextNodeForParaProps()->GetSwAttrSet().GetLineSpacing(); + + switch( rSpace.GetInterLineSpaceRule() ) + { + case SvxInterLineSpaceRule::Prop: + { + if ( _bNoPropLineSpace ) + { + break; + } + + // i#11860 - adjust spacing implementation for object positioning + // - compatibility to MS Word + nRet = GetHeightOfLastLine(); + + tools::Long nTmp = nRet; + nTmp *= rSpace.GetPropLineSpace(); + nTmp /= 100; + nTmp -= nRet; + if ( nTmp > 0 ) + nRet = nTmp; + else + nRet = 0; + } + break; + case SvxInterLineSpaceRule::Fix: + { + if ( rSpace.GetInterLineSpace() > 0 ) + nRet = rSpace.GetInterLineSpace(); + } + break; + default: + break; + } + return nRet; +} + +sal_uInt16 SwTextFrame::FirstLineHeight() const +{ + if ( !HasPara() ) + { + if( IsEmpty() && isFrameAreaDefinitionValid() ) + return IsVertical() ? o3tl::narrowing(getFramePrintArea().Width()) : o3tl::narrowing(getFramePrintArea().Height()); + return USHRT_MAX; + } + const SwParaPortion *pPara = GetPara(); + if ( !pPara ) + return USHRT_MAX; + + // tdf#146500 Lines with only fly overlap cannot be "moved", so the idea + // here is to continue until there's some text. + // FIXME ideally we want to count a fly to the line in which it is anchored + // - it may even be anchored in some other paragraph! SwFlyPortion doesn't + // have a pointer sadly so no way to find out. + sal_uInt16 nHeight(0); + for (SwLineLayout const* pLine = pPara; pLine; pLine = pLine->GetNext()) + { + nHeight += pLine->Height(); + if (::sw::FindNonFlyPortion(*pLine)) + { + break; + } + } + return nHeight; +} + +sal_Int32 SwTextFrame::GetLineCount(TextFrameIndex const nPos) +{ + sal_Int32 nRet = 0; + SwTextFrame *pFrame = this; + do + { + pFrame->GetFormatted(); + if( !pFrame->HasPara() ) + break; + SwTextSizeInfo aInf( pFrame ); + SwTextMargin aLine( pFrame, &aInf ); + if (TextFrameIndex(COMPLETE_STRING) == nPos) + aLine.Bottom(); + else + aLine.CharToLine( nPos ); + nRet = nRet + aLine.GetLineNr(); + pFrame = pFrame->GetFollow(); + } while ( pFrame && pFrame->GetOffset() <= nPos ); + return nRet; +} + +void SwTextFrame::ChgThisLines() +{ + // not necessary to format here (GetFormatted etc.), because we have to come from there! + sal_Int32 nNew = 0; + const SwLineNumberInfo &rInf = GetDoc().GetLineNumberInfo(); + if ( !GetText().isEmpty() && HasPara() ) + { + SwTextSizeInfo aInf( this ); + SwTextMargin aLine( this, &aInf ); + if ( rInf.IsCountBlankLines() ) + { + aLine.Bottom(); + nNew = aLine.GetLineNr(); + } + else + { + do + { + if( aLine.GetCurr()->HasContent() ) + ++nNew; + } while ( aLine.NextLine() ); + } + } + else if ( rInf.IsCountBlankLines() ) + nNew = 1; + + if ( nNew == mnThisLines ) + return; + + if (!IsInTab() && GetTextNodeForParaProps()->GetSwAttrSet().GetLineNumber().IsCount()) + { + mnAllLines -= mnThisLines; + mnThisLines = nNew; + mnAllLines += mnThisLines; + SwFrame *pNxt = GetNextContentFrame(); + while( pNxt && pNxt->IsInTab() ) + { + pNxt = pNxt->FindTabFrame(); + if( nullptr != pNxt ) + pNxt = pNxt->FindNextCnt(); + } + if( pNxt ) + pNxt->InvalidateLineNum(); + + // Extend repaint to the bottom. + if ( HasPara() ) + { + SwRepaint& rRepaint = GetPara()->GetRepaint(); + rRepaint.Bottom( std::max( rRepaint.Bottom(), + getFrameArea().Top()+getFramePrintArea().Bottom())); + } + } + else // Paragraphs which are not counted should not manipulate the AllLines. + mnThisLines = nNew; +} + +void SwTextFrame::RecalcAllLines() +{ + ValidateLineNum(); + + if ( IsInTab() ) + return; + + const sal_Int32 nOld = GetAllLines(); + const SwFormatLineNumber &rLineNum = GetTextNodeForParaProps()->GetSwAttrSet().GetLineNumber(); + sal_Int32 nNewNum; + const bool bRestart = GetDoc().GetLineNumberInfo().IsRestartEachPage(); + + if ( !IsFollow() && rLineNum.GetStartValue() && rLineNum.IsCount() ) + nNewNum = rLineNum.GetStartValue() - 1; + // If it is a follow or not has not be considered if it is a restart at each page; the + // restart should also take effect at follows. + else if ( bRestart && FindPageFrame()->FindFirstBodyContent() == this ) + { + nNewNum = 0; + } + else + { + SwContentFrame *pPrv = GetPrevContentFrame(); + while ( pPrv && + (pPrv->IsInTab() || pPrv->IsInDocBody() != IsInDocBody()) ) + pPrv = pPrv->GetPrevContentFrame(); + + // i#78254 Restart line numbering at page change + // First body content may be in table! + if ( bRestart && pPrv && pPrv->FindPageFrame() != FindPageFrame() ) + pPrv = nullptr; + + nNewNum = pPrv ? static_cast(pPrv)->GetAllLines() : 0; + } + if ( rLineNum.IsCount() ) + nNewNum += GetThisLines(); + + if ( nOld == nNewNum ) + return; + + mnAllLines = nNewNum; + SwContentFrame *pNxt = GetNextContentFrame(); + while ( pNxt && + (pNxt->IsInTab() || pNxt->IsInDocBody() != IsInDocBody()) ) + pNxt = pNxt->GetNextContentFrame(); + if ( pNxt ) + { + if ( pNxt->GetUpper() != GetUpper() ) + pNxt->InvalidateLineNum(); + else + pNxt->InvalidateLineNum_(); + } +} + +void SwTextFrame::VisitPortions( SwPortionHandler& rPH ) const +{ + const SwParaPortion* pPara = isFrameAreaDefinitionValid() ? GetPara() : nullptr; + + if (pPara) + { + if ( IsFollow() ) + rPH.Skip( GetOffset() ); + + const SwLineLayout* pLine = pPara; + while ( pLine ) + { + const SwLinePortion* pPor = pLine->GetFirstPortion(); + while ( pPor ) + { + pPor->HandlePortion( rPH ); + pPor = pPor->GetNextPortion(); + } + + rPH.LineBreak(); + pLine = pLine->GetNext(); + } + } + + rPH.Finish(); +} + +const SwScriptInfo* SwTextFrame::GetScriptInfo() const +{ + const SwParaPortion* pPara = GetPara(); + return pPara ? &pPara->GetScriptInfo() : nullptr; +} + +/** + * Helper function for SwTextFrame::CalcBasePosForFly() + */ +static SwTwips lcl_CalcFlyBasePos( const SwTextFrame& rFrame, SwRect aFlyRect, + SwTextFly const & rTextFly ) +{ + SwRectFnSet aRectFnSet(&rFrame); + SwTwips nRet = rFrame.IsRightToLeft() ? + aRectFnSet.GetRight(rFrame.getFrameArea()) : + aRectFnSet.GetLeft(rFrame.getFrameArea()); + + do + { + SwRect aRect = rTextFly.GetFrame( aFlyRect ); + if ( 0 != aRectFnSet.GetWidth(aRect) ) + { + if ( rFrame.IsRightToLeft() ) + { + if ( aRectFnSet.GetRight(aRect) - + aRectFnSet.GetRight(aFlyRect) >= 0 ) + { + aRectFnSet.SetRight( +aFlyRect, aRectFnSet.GetLeft(aRect) ); + nRet = aRectFnSet.GetLeft(aRect); + } + else + break; + } + else + { + if ( aRectFnSet.GetLeft(aFlyRect) - + aRectFnSet.GetLeft(aRect) >= 0 ) + { + aRectFnSet.SetLeft( +aFlyRect, aRectFnSet.GetRight(aRect) + 1 ); + nRet = aRectFnSet.GetRight(aRect); + } + else + break; + } + } + else + break; + } + while ( aRectFnSet.GetWidth(aFlyRect) > 0 ); + + return nRet; +} + +void SwTextFrame::CalcBaseOfstForFly() +{ + OSL_ENSURE( !IsVertical() || !IsSwapped(), + "SwTextFrame::CalcBasePosForFly with swapped frame!" ); + + if (!GetDoc().getIDocumentSettingAccess().get(DocumentSettingId::ADD_FLY_OFFSETS)) + return; + + SwRectFnSet aRectFnSet(this); + + SwRect aFlyRect( getFrameArea().Pos() + getFramePrintArea().Pos(), getFramePrintArea().SSize() ); + + // Get first 'real' line and adjust position and height of line rectangle. + // Correct behaviour if no 'real' line exists + // (empty paragraph with and without a dummy portion) + SwTwips nFlyAnchorVertOfstNoWrap = 0; + { + SwTwips nTop = aRectFnSet.GetTop(aFlyRect); + const SwLineLayout* pLay = GetPara(); + SwTwips nLineHeight = 200; + while( pLay && pLay->IsDummy() && pLay->GetNext() ) + { + nTop += pLay->Height(); + nFlyAnchorVertOfstNoWrap += pLay->Height(); + pLay = pLay->GetNext(); + } + if ( pLay ) + { + nLineHeight = pLay->Height(); + } + aRectFnSet.SetTopAndHeight( aFlyRect, nTop, nLineHeight ); + } + + SwTextFly aTextFly( this ); + aTextFly.SetIgnoreCurrentFrame( true ); + aTextFly.SetIgnoreContour( true ); + // ignore objects in page header|footer for + // text frames not in page header|footer + aTextFly.SetIgnoreObjsInHeaderFooter( true ); + SwTwips nRet1 = lcl_CalcFlyBasePos( *this, aFlyRect, aTextFly ); + aTextFly.SetIgnoreCurrentFrame( false ); + SwTwips nRet2 = lcl_CalcFlyBasePos( *this, aFlyRect, aTextFly ); + + // make values relative to frame start position + SwTwips nLeft = IsRightToLeft() ? + aRectFnSet.GetRight(getFrameArea()) : + aRectFnSet.GetLeft(getFrameArea()); + + mnFlyAnchorOfst = nRet1 - nLeft; + mnFlyAnchorOfstNoWrap = nRet2 - nLeft; + + if (!GetDoc().getIDocumentSettingAccess().get(DocumentSettingId::ADD_VERTICAL_FLY_OFFSETS)) + return; + + if (mnFlyAnchorOfstNoWrap > 0) + mnFlyAnchorVertOfstNoWrap = nFlyAnchorVertOfstNoWrap; +} + +SwTwips SwTextFrame::GetBaseVertOffsetForFly(bool bIgnoreFlysAnchoredAtThisFrame) const +{ + return bIgnoreFlysAnchoredAtThisFrame ? 0 : mnFlyAnchorVertOfstNoWrap; +} + +/** + * Repaint all text frames of the given text node + */ +void SwTextFrame::repaintTextFrames( const SwTextNode& rNode ) +{ + SwIterator aIter(rNode); + for( const SwTextFrame *pFrame = aIter.First(); pFrame; pFrame = aIter.Next() ) + { + SwRect aRec( pFrame->GetPaintArea() ); + const SwRootFrame *pRootFrame = pFrame->getRootFrame(); + SwViewShell *pCurShell = pRootFrame ? pRootFrame->GetCurrShell() : nullptr; + if( pCurShell ) + pCurShell->InvalidateWindows( aRec ); + } +} + +void SwTextFrame::UpdateOutlineContentVisibilityButton(SwWrtShell* pWrtSh) const +{ + if (pWrtSh && pWrtSh->GetViewOptions()->IsShowOutlineContentVisibilityButton() && + GetTextNodeFirst()->IsOutline()) + { + SwEditWin& rEditWin = pWrtSh->GetView().GetEditWin(); + SwFrameControlsManager& rMngr = rEditWin.GetFrameControlsManager(); + rMngr.SetOutlineContentVisibilityButton(this); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/txtftn.cxx b/sw/source/core/text/txtftn.cxx new file mode 100644 index 0000000000..c1fa749c93 --- /dev/null +++ b/sw/source/core/text/txtftn.cxx @@ -0,0 +1,1590 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "porftn.hxx" +#include "porfly.hxx" +#include "porlay.hxx" +#include +#include "itrform2.hxx" +#include +#include +#include "redlnitr.hxx" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +using namespace ::com::sun::star; + +bool SwTextFrame::IsFootnoteNumFrame_() const +{ + if (IsInTab()) + return false; // tdf#102073 first frame in cell doesn't have mpPrev set + const SwFootnoteFrame* pFootnote = FindFootnoteFrame()->GetMaster(); + while( pFootnote && !pFootnote->ContainsContent() ) + pFootnote = pFootnote->GetMaster(); + return !pFootnote; +} + +/** + * Looks for the TextFrame matching the SwTextFootnote within a master-follow chain + */ +SwTextFrame *SwTextFrame::FindFootnoteRef( const SwTextFootnote *pFootnote ) +{ + SwTextFrame *pFrame = this; + const bool bFwd = MapModelToView(&pFootnote->GetTextNode(), pFootnote->GetStart()) >= GetOffset(); + while( pFrame ) + { + if( SwFootnoteBossFrame::FindFootnote( pFrame, pFootnote ) ) + return pFrame; + pFrame = bFwd ? pFrame->GetFollow() : + pFrame->IsFollow() ? pFrame->FindMaster() : nullptr; + } + return pFrame; +} + +void SwTextFrame::SetHasRotatedPortions(bool bHasRotatedPortions) +{ + mbHasRotatedPortions = bHasRotatedPortions; +} + +#ifdef DBG_UTIL +void SwTextFrame::CalcFootnoteFlag(TextFrameIndex nStop) // For testing the SplitFrame +#else +void SwTextFrame::CalcFootnoteFlag() +#endif +{ + mbFootnote = false; + +#ifdef DBG_UTIL + const TextFrameIndex nEnd = nStop != TextFrameIndex(COMPLETE_STRING) + ? nStop + : GetFollow() ? GetFollow()->GetOffset() : TextFrameIndex(COMPLETE_STRING); +#else + const TextFrameIndex nEnd = GetFollow() + ? GetFollow()->GetOffset() + : TextFrameIndex(COMPLETE_STRING); +#endif + + SwTextNode const* pNode(nullptr); + sw::MergedAttrIter iter(*this); + for (SwTextAttr const* pHt = iter.NextAttr(&pNode); pHt; pHt = iter.NextAttr(&pNode)) + { + if ( pHt->Which() == RES_TXTATR_FTN ) + { + TextFrameIndex const nIdx(MapModelToView(pNode, pHt->GetStart())); + if ( nEnd < nIdx ) + break; + if( GetOffset() <= nIdx ) + { + mbFootnote = true; + break; + } + } + } +} + +bool SwTextFrame::CalcPrepFootnoteAdjust() +{ + OSL_ENSURE( HasFootnote(), "Who´s calling me?" ); + SwFootnoteBossFrame *pBoss = FindFootnoteBossFrame( true ); + const SwFootnoteFrame *pFootnote = pBoss->FindFirstFootnote( this ); + if (pFootnote && FTNPOS_CHAPTER != GetDoc().GetFootnoteInfo().m_ePos && + ( !pBoss->GetUpper()->IsSctFrame() || + !static_cast(pBoss->GetUpper())->IsFootnoteAtEnd() ) ) + { + const SwFootnoteContFrame *pCont = pBoss->FindFootnoteCont(); + bool bReArrange = true; + + SwRectFnSet aRectFnSet(this); + if ( pCont && aRectFnSet.YDiff( aRectFnSet.GetTop(pCont->getFrameArea()), + aRectFnSet.GetBottom(getFrameArea()) ) > 0 ) + { + pBoss->RearrangeFootnotes( aRectFnSet.GetBottom(getFrameArea()), false, + pFootnote->GetAttr() ); + ValidateBodyFrame(); + ValidateFrame(); + pFootnote = pBoss->FindFirstFootnote( this ); + } + else + bReArrange = false; + if( !pCont || !pFootnote || bReArrange != (pFootnote->FindFootnoteBossFrame() == pBoss) ) + { + SwTextFormatInfo aInf( getRootFrame()->GetCurrShell()->GetOut(), this ); + SwTextFormatter aLine( this, &aInf ); + aLine.TruncLines(); + SetPara( nullptr ); // May be deleted! + ResetPreps(); + return false; + } + } + return true; +} + +/** + * Local helper function. Checks if nLower should be taken as the boundary + * for the footnote. + */ +static SwTwips lcl_GetFootnoteLower( const SwTextFrame* pFrame, SwTwips nLower ) +{ + // nLower is an absolute value. It denotes the bottom of the line + // containing the footnote. + SwRectFnSet aRectFnSet(pFrame); + + OSL_ENSURE( !pFrame->IsVertical() || !pFrame->IsSwapped(), + "lcl_GetFootnoteLower with swapped frame" ); + + SwTwips nAdd; + SwTwips nRet = nLower; + + // Check if text is inside a table. + if ( pFrame->IsInTab() ) + { + // If pFrame is inside a table, we have to check if + // a) The table is not allowed to split or + // b) The table row is not allowed to split + + // Inside a table, there are no footnotes, + // see SwFrame::FindFootnoteBossFrame. So we don't have to check + // the case that pFrame is inside a (footnote collecting) section + // within the table. + const SwFrame* pRow = pFrame; + while( !pRow->IsRowFrame() || !pRow->GetUpper()->IsTabFrame() ) + pRow = pRow->GetUpper(); + const SwTabFrame* pTabFrame = static_cast(pRow->GetUpper()); + + OSL_ENSURE( pTabFrame && pRow && + pRow->GetUpper()->IsTabFrame(), "Upper of row should be tab" ); + + const bool bDontSplit = !pTabFrame->IsFollow() && + !pTabFrame->IsLayoutSplitAllowed(); + + SwTwips nMin = 0; + if ( bDontSplit ) + nMin = aRectFnSet.GetBottom(pTabFrame->getFrameArea()); + else if ( !static_cast(pRow)->IsRowSplitAllowed() ) + nMin = aRectFnSet.GetBottom(pRow->getFrameArea()); + + if ( nMin && aRectFnSet.YDiff( nMin, nLower ) > 0 ) + nRet = nMin; + + nAdd = aRectFnSet.GetBottomMargin(*pRow->GetUpper()); + } + else + nAdd = aRectFnSet.GetBottomMargin(*pFrame); + + if( nAdd > 0 ) + { + if ( aRectFnSet.IsVert() ) + nRet -= nAdd; + else + nRet += nAdd; + } + + // #i10770#: If there are fly frames anchored at previous paragraphs, + // the deadline should consider their lower borders. + const SwFrame* pStartFrame = pFrame->GetUpper()->GetLower(); + OSL_ENSURE( pStartFrame, "Upper has no lower" ); + SwTwips nFlyLower = aRectFnSet.IsVert() ? LONG_MAX : 0; + while ( pStartFrame != pFrame ) + { + OSL_ENSURE( pStartFrame, "Frame chain is broken" ); + if ( pStartFrame->GetDrawObjs() ) + { + const SwSortedObjs &rObjs = *pStartFrame->GetDrawObjs(); + for (SwAnchoredObject* pAnchoredObj : rObjs) + { + SwRect aRect( pAnchoredObj->GetObjRect() ); + + auto pFlyFrame = pAnchoredObj->DynCastFlyFrame(); + if ( !pFlyFrame || + pFlyFrame->isFrameAreaDefinitionValid() ) + { + const SwTwips nBottom = aRectFnSet.GetBottom(aRect); + if ( aRectFnSet.YDiff( nBottom, nFlyLower ) > 0 ) + nFlyLower = nBottom; + } + } + } + + pStartFrame = pStartFrame->GetNext(); + } + + if ( aRectFnSet.IsVert() ) + nRet = std::min( nRet, nFlyLower ); + else + nRet = std::max( nRet, nFlyLower ); + + return nRet; +} + +SwTwips SwTextFrame::GetFootnoteLine( const SwTextFootnote *pFootnote ) const +{ + OSL_ENSURE( ! IsVertical() || ! IsSwapped(), + "SwTextFrame::GetFootnoteLine with swapped frame" ); + + SwTextFrame *pThis = const_cast(this); + + if( !HasPara() ) + { + // #109071# GetFormatted() does not work here, because most probably + // the frame is currently locked. We return the previous value. + return pThis->mnFootnoteLine > 0 ? + pThis->mnFootnoteLine : + IsVertical() ? getFrameArea().Left() : getFrameArea().Bottom(); + } + + SwTwips nRet; + { + SwSwapIfNotSwapped swap(const_cast(this)); + + SwTextInfo aInf( pThis ); + SwTextIter aLine( pThis, &aInf ); + TextFrameIndex const nPos(MapModelToView( + &pFootnote->GetTextNode(), pFootnote->GetStart())); + aLine.CharToLine( nPos ); + + nRet = aLine.Y() + aLine.GetLineHeight(); + if( IsVertical() ) + nRet = SwitchHorizontalToVertical( nRet ); + } + + nRet = lcl_GetFootnoteLower( pThis, nRet ); + + pThis->mnFootnoteLine = nRet; + return nRet; +} + +/** + * Calculates the maximum reachable height for the TextFrame in the Footnote Area. + * The cell's bottom margin with the Footnote Reference limit's this height. + */ +SwTwips SwTextFrame::GetFootnoteFrameHeight_() const +{ + OSL_ENSURE( !IsFollow() && IsInFootnote(), "SwTextFrame::SetFootnoteLine: moon walk" ); + + const SwFootnoteFrame *pFootnoteFrame = FindFootnoteFrame(); + const SwTextFrame *pRef = static_cast(pFootnoteFrame->GetRef()); + const SwFootnoteBossFrame *pBoss = FindFootnoteBossFrame(); + if( pBoss != pRef->FindFootnoteBossFrame( !pFootnoteFrame->GetAttr()-> + GetFootnote().IsEndNote() ) ) + return 0; + + SwSwapIfSwapped swap(const_cast(this)); + + SwTwips nHeight = pRef->IsInFootnoteConnect() ? + 1 : pRef->GetFootnoteLine( pFootnoteFrame->GetAttr() ); + if( nHeight ) + { + // As odd as it may seem: the first Footnote on the page may not touch the + // Footnote Reference, when entering text in the Footnote Area. + const SwFrame *pCont = pFootnoteFrame->GetUpper(); + + // Height within the Container which we're allowed to consume anyways + SwRectFnSet aRectFnSet(pCont); + SwTwips nTmp = aRectFnSet.YDiff( aRectFnSet.GetPrtBottom(*pCont), + aRectFnSet.GetTop(getFrameArea()) ); + +#if OSL_DEBUG_LEVEL > 0 + if( nTmp < 0 ) + { + bool bInvalidPos = false; + const SwLayoutFrame* pTmp = GetUpper(); + while( !bInvalidPos && pTmp ) + { + bInvalidPos = !pTmp->isFrameAreaPositionValid() || + !pTmp->Lower()->isFrameAreaPositionValid(); + if( pTmp == pCont ) + break; + pTmp = pTmp->GetUpper(); + } + OSL_ENSURE( bInvalidPos, "Hanging below FootnoteCont" ); + } +#endif + + if ( aRectFnSet.YDiff( aRectFnSet.GetTop(pCont->getFrameArea()), nHeight) > 0 ) + { + // Growth potential of the container + if ( !pRef->IsInFootnoteConnect() ) + { + SwSaveFootnoteHeight aSave( const_cast(pBoss), nHeight ); + nHeight = const_cast(static_cast(pCont))->Grow( LONG_MAX, true ); + } + else + nHeight = const_cast(static_cast(pCont))->Grow( LONG_MAX, true ); + + nHeight += nTmp; + if( nHeight < 0 ) + nHeight = 0; + } + else + { // The container has to shrink + nTmp += aRectFnSet.YDiff( aRectFnSet.GetTop(pCont->getFrameArea()), nHeight); + if( nTmp > 0 ) + nHeight = nTmp; + else + nHeight = 0; + } + } + + return nHeight; +} + +SwTextFrame *SwTextFrame::FindQuoVadisFrame() +{ + // Check whether we're in a FootnoteFrame + if( GetIndPrev() || !IsInFootnote() ) + return nullptr; + + // To the preceding FootnoteFrame + SwFootnoteFrame *pFootnoteFrame = FindFootnoteFrame()->GetMaster(); + if( !pFootnoteFrame ) + return nullptr; + + // Now the last Content + SwContentFrame *pCnt = pFootnoteFrame->ContainsContent(); + if( !pCnt ) + return nullptr; + SwContentFrame *pLast; + do + { pLast = pCnt; + pCnt = pCnt->GetNextContentFrame(); + } while( pCnt && pFootnoteFrame->IsAnLower( pCnt ) ); + return static_cast(pLast); +} + +void SwTextFrame::RemoveFootnote(TextFrameIndex const nStart, TextFrameIndex const nLen) +{ + if ( !IsFootnoteAllowed() ) + return; + + bool bRollBack = nLen != TextFrameIndex(COMPLETE_STRING); + TextFrameIndex nEnd; + SwTextFrame* pSource; + if( bRollBack ) + { + nEnd = nStart + nLen; + pSource = GetFollow(); + if( !pSource ) + return; + } + else + { + nEnd = TextFrameIndex(COMPLETE_STRING); + pSource = this; + } + + SwPageFrame* pUpdate = nullptr; + bool bRemove = false; + SwFootnoteBossFrame *pFootnoteBoss = nullptr; + SwFootnoteBossFrame *pEndBoss = nullptr; + bool bFootnoteEndDoc = FTNPOS_CHAPTER == GetDoc().GetFootnoteInfo().m_ePos; + SwTextNode const* pNode(nullptr); + sw::MergedAttrIterReverse iter(*this); + for (SwTextAttr const* pHt = iter.PrevAttr(&pNode); pHt; pHt = iter.PrevAttr(&pNode)) + { + if (RES_TXTATR_FTN != pHt->Which()) + continue; + + TextFrameIndex const nIdx(MapModelToView(pNode, pHt->GetStart())); + if (nStart > nIdx) + break; + + if (nEnd >= nIdx) + { + SwTextFootnote const*const pFootnote(static_cast(pHt)); + const bool bEndn = pFootnote->GetFootnote().IsEndNote(); + + if (bEndn) + { + if (!pEndBoss) + pEndBoss = pSource->FindFootnoteBossFrame(); + } + else + { + if (!pFootnoteBoss) + { + pFootnoteBoss = pSource->FindFootnoteBossFrame( true ); + if( pFootnoteBoss->GetUpper()->IsSctFrame() ) + { + SwSectionFrame* pSect = static_cast( + pFootnoteBoss->GetUpper()); + if (pSect->IsFootnoteAtEnd()) + bFootnoteEndDoc = false; + } + } + } + + // We don't delete, but move instead. + // Three cases are to be considered: + // 1) There's neither Follow nor PrevFollow: + // -> RemoveFootnote() (maybe even a OSL_ENSURE(value)) + // + // 2) nStart > GetOffset, I have a Follow + // -> Footnote moves into Follow + // + // 3) nStart < GetOffset, I am a Follow + // -> Footnote moves into the PrevFollow + // + // Both need to be on one Page/in one Column + SwFootnoteFrame *pFootnoteFrame = SwFootnoteBossFrame::FindFootnote(pSource, pFootnote); + + if (pFootnoteFrame) + { + const bool bEndDoc = bEndn || bFootnoteEndDoc; + if( bRollBack ) + { + while (pFootnoteFrame) + { + pFootnoteFrame->SetRef( this ); + pFootnoteFrame = pFootnoteFrame->GetFollow(); + SetFootnote( true ); + } + } + else if (GetFollow()) + { + SwContentFrame *pDest = GetFollow(); + while (pDest->GetFollow() && static_cast(pDest-> + GetFollow())->GetOffset() <= nIdx) + pDest = pDest->GetFollow(); + OSL_ENSURE( !SwFootnoteBossFrame::FindFootnote( + pDest,pFootnote),"SwTextFrame::RemoveFootnote: footnote exists"); + + // Never deregister; always move + if (bEndDoc || + !pFootnoteFrame->FindFootnoteBossFrame()->IsBefore(pDest->FindFootnoteBossFrame(!bEndn)) + ) + { + SwPageFrame* pTmp = pFootnoteFrame->FindPageFrame(); + if( pUpdate && pUpdate != pTmp ) + pUpdate->UpdateFootnoteNum(); + pUpdate = pTmp; + while ( pFootnoteFrame ) + { + pFootnoteFrame->SetRef( pDest ); + pFootnoteFrame = pFootnoteFrame->GetFollow(); + } + } + else + { + pFootnoteBoss->MoveFootnotes( this, pDest, pFootnote ); + bRemove = true; + } + static_cast(pDest)->SetFootnote( true ); + + OSL_ENSURE( SwFootnoteBossFrame::FindFootnote( pDest, + pFootnote),"SwTextFrame::RemoveFootnote: footnote ChgRef failed"); + } + else + { + if (!bEndDoc || ( bEndn && pEndBoss->IsInSct() && + !SwLayouter::Collecting( &GetDoc(), + pEndBoss->FindSctFrame(), nullptr ) )) + { + if( bEndn ) + pEndBoss->RemoveFootnote( this, pFootnote ); + else + pFootnoteBoss->RemoveFootnote( this, pFootnote ); + bRemove = bRemove || !bEndDoc; + OSL_ENSURE( !SwFootnoteBossFrame::FindFootnote( this, pFootnote ), + "SwTextFrame::RemoveFootnote: can't get off that footnote" ); + } + } + } + } + } + if (pUpdate) + pUpdate->UpdateFootnoteNum(); + + // We break the oscillation + if (bRemove && !bFootnoteEndDoc && HasPara()) + { + ValidateBodyFrame(); + ValidateFrame(); + } + + // We call the RemoveFootnote from within the FindBreak, because the last line is + // to be passed to the Follow. The Offset of the Follow is, however, outdated; + // it'll be set soon. CalcFntFlag depends on a correctly set Follow Offset. + // Therefore we temporarily calculate the Follow Offset here + TextFrameIndex nOldOfst(COMPLETE_STRING); + if( HasFollow() && nStart > GetOffset() ) + { + nOldOfst = GetFollow()->GetOffset(); + GetFollow()->ManipOfst(nStart + (bRollBack ? nLen : TextFrameIndex(0))); + } + pSource->CalcFootnoteFlag(); + if (nOldOfst < TextFrameIndex(COMPLETE_STRING)) + GetFollow()->ManipOfst( nOldOfst ); +} + + +/** + * We basically only have two possibilities: + * + * a) The Footnote is already present + * => we move it, if another pSrcFrame has been found + * + * b) The Footnote is not present + * => we have it created for us + * + * Whether the Footnote ends up on our Page/Column, doesn't matter in this + * context. + * + * Optimization for Endnotes. + * + * Another problem: if the Deadline falls within the Footnote Area, we need + * to move the Footnote. + * + * @returns false on any type of error + */ +void SwTextFrame::ConnectFootnote( SwTextFootnote *pFootnote, const SwTwips nDeadLine ) +{ + OSL_ENSURE( !IsVertical() || !IsSwapped(), + "SwTextFrame::ConnectFootnote with swapped frame" ); + + mbFootnote = true; + mbInFootnoteConnect = true; // Just reset! + // See if pFootnote is an endnote on a separate endnote page. + const IDocumentSettingAccess& rSettings = GetDoc().getIDocumentSettingAccess(); + const bool bContinuousEndnotes = rSettings.get(DocumentSettingId::CONTINUOUS_ENDNOTES); + const bool bEnd = pFootnote->GetFootnote().IsEndNote(); + + // We want to store this value, because it is needed as a fallback + // in GetFootnoteLine(), if there is no paragraph information available + mnFootnoteLine = nDeadLine; + + // We always need a parent (Page/Column) + SwSectionFrame *pSect; + SwContentFrame *pContent = this; + if( bEnd && IsInSct() ) + { + pSect = FindSctFrame(); + if( pSect->IsEndnAtEnd() ) + pContent = pSect->FindLastContent( SwFindMode::EndNote ); + if( !pContent ) + pContent = this; + } + + SwFootnoteBossFrame *pBoss = pContent->FindFootnoteBossFrame( !bEnd ); + + pSect = pBoss->FindSctFrame(); + bool bDocEnd = bEnd ? !( pSect && pSect->IsEndnAtEnd() ) : + ( !( pSect && pSect->IsFootnoteAtEnd() ) && + FTNPOS_CHAPTER == GetDoc().GetFootnoteInfo().m_ePos); + + // Footnote can be registered with the Follow + SwContentFrame *pSrcFrame = FindFootnoteRef( pFootnote ); + + if( bDocEnd ) + { + if ((pSect || bContinuousEndnotes) && pSrcFrame) + { + SwFootnoteFrame *pFootnoteFrame = SwFootnoteBossFrame::FindFootnote( pSrcFrame, pFootnote ); + if (pFootnoteFrame && (pFootnoteFrame->IsInSct() || bContinuousEndnotes)) + { + // We either have a foot/endnote that goes to the end of the section or are in Word + // compatibility mode where endnotes go to the end of the document. Handle both + // cases by removing the footnote here, then later appending them to the correct + // last page of the document or section. + pBoss->RemoveFootnote( pSrcFrame, pFootnote ); + pSrcFrame = nullptr; + } + } + } + else if( bEnd && pSect ) + { + SwFootnoteFrame *pFootnoteFrame = pSrcFrame ? SwFootnoteBossFrame::FindFootnote( pSrcFrame, pFootnote ) : nullptr; + if( pFootnoteFrame && !pFootnoteFrame->GetUpper() ) + pFootnoteFrame = nullptr; + SwDoc *const pDoc = &GetDoc(); + if( SwLayouter::Collecting( pDoc, pSect, pFootnoteFrame ) ) + { + if( !pSrcFrame ) + { + SwFootnoteFrame *pNew = new SwFootnoteFrame(pDoc->GetDfltFrameFormat(),this,this,pFootnote); + SwNodeIndex aIdx( *pFootnote->GetStartNode(), 1 ); + ::InsertCnt_( pNew, pDoc, aIdx.GetIndex() ); + pDoc->getIDocumentLayoutAccess().GetLayouter()->CollectEndnote( pNew ); + } + else if( pSrcFrame != this ) + SwFootnoteBossFrame::ChangeFootnoteRef( pSrcFrame, pFootnote, this ); + mbInFootnoteConnect = false; + return; + } + else if (pSrcFrame && pFootnoteFrame) + { + SwFootnoteBossFrame *pFootnoteBoss = pFootnoteFrame->FindFootnoteBossFrame(); + if( !pFootnoteBoss->IsInSct() || + pFootnoteBoss->ImplFindSctFrame()->GetSection()!=pSect->GetSection() ) + { + pBoss->RemoveFootnote( pSrcFrame, pFootnote ); + pSrcFrame = nullptr; + } + } + } + + if( bDocEnd || bEnd ) + { + if( !pSrcFrame ) + pBoss->AppendFootnote( this, pFootnote ); + else if( pSrcFrame != this ) + SwFootnoteBossFrame::ChangeFootnoteRef( pSrcFrame, pFootnote, this ); + mbInFootnoteConnect = false; + return; + } + + SwSaveFootnoteHeight aHeight( pBoss, nDeadLine ); + + if( !pSrcFrame ) // No Footnote was found at all + pBoss->AppendFootnote( this, pFootnote ); + else + { + SwFootnoteFrame *pFootnoteFrame = SwFootnoteBossFrame::FindFootnote( pSrcFrame, pFootnote ); + SwFootnoteBossFrame *pFootnoteBoss = pFootnoteFrame->FindFootnoteBossFrame(); + + bool bBrutal = false; + + if( pFootnoteBoss == pBoss ) // Ref and Footnote are on the same Page/Column + { + SwFrame *pCont = pFootnoteFrame->GetUpper(); + + SwRectFnSet aRectFnSet(pCont); + tools::Long nDiff = aRectFnSet.YDiff( aRectFnSet.GetTop(pCont->getFrameArea()), + nDeadLine ); + + if( nDiff >= 0 ) + { + // If the Footnote has been registered to a Follow, we need to + // rewire it now too + if ( pSrcFrame != this ) + SwFootnoteBossFrame::ChangeFootnoteRef( pSrcFrame, pFootnote, this ); + + // We have some room left, so the Footnote can grow + if ( pFootnoteFrame->GetFollow() && nDiff > 0 ) + { + SwFrameDeleteGuard aDeleteGuard(pCont); + SwTwips nHeight = aRectFnSet.GetHeight(pCont->getFrameArea()); + pBoss->RearrangeFootnotes( nDeadLine, false, pFootnote ); + ValidateBodyFrame(); + ValidateFrame(); + SwViewShell *pSh = getRootFrame()->GetCurrShell(); + if ( pSh && nHeight == aRectFnSet.GetHeight(pCont->getFrameArea()) ) + // So that we don't miss anything + pSh->InvalidateWindows( pCont->getFrameArea() ); + } + mbInFootnoteConnect = false; + return; + } + else + bBrutal = true; + } + else + { + // Ref and Footnote are not on one Page; attempt to move is necessary + SwFrame* pTmp = this; + while( pTmp->GetNext() && pSrcFrame != pTmp ) + pTmp = pTmp->GetNext(); + if( pSrcFrame == pTmp ) + bBrutal = true; + else + { // If our Parent is in a column Area, but the Page already has a + // FootnoteContainer, we can only brute force it + if( pSect && pSect->FindFootnoteBossFrame( !bEnd )->FindFootnoteCont() ) + bBrutal = true; + + else if ( !pFootnoteFrame->GetPrev() || + pFootnoteBoss->IsBefore( pBoss ) + ) + { + SwFootnoteBossFrame *pSrcBoss = pSrcFrame->FindFootnoteBossFrame( !bEnd ); + pSrcBoss->MoveFootnotes( pSrcFrame, this, pFootnote ); + } + else + SwFootnoteBossFrame::ChangeFootnoteRef( pSrcFrame, pFootnote, this ); + } + } + + // The brute force method: Remove Footnote and append. + // We need to call SetFootnoteDeadLine(), as we can more easily adapt the + // nMaxFootnoteHeight after RemoveFootnote + if( bBrutal ) + { + pBoss->RemoveFootnote( pSrcFrame, pFootnote, false ); + std::unique_ptr pHeight(bEnd ? nullptr : new SwSaveFootnoteHeight( pBoss, nDeadLine )); + pBoss->AppendFootnote( this, pFootnote ); + } + } + + // In column Areas, that not yet reach the Page's border a RearrangeFootnotes is not + // useful yet, as the Footnote container has not yet been calculated + if( !pSect || !pSect->Growable() ) + { + // Validate environment, to avoid oscillation + SwSaveFootnoteHeight aNochmal( pBoss, nDeadLine ); + ValidateBodyFrame(); + pBoss->RearrangeFootnotes( nDeadLine, true ); + ValidateFrame(); + } + else if( pSect->IsFootnoteAtEnd() ) + { + ValidateBodyFrame(); + ValidateFrame(); + } + + mbInFootnoteConnect = false; +} + +/** + * The portion for the Footnote Reference in the Text + */ +SwFootnotePortion *SwTextFormatter::NewFootnotePortion( SwTextFormatInfo &rInf, + SwTextAttr *pHint ) +{ + OSL_ENSURE( ! m_pFrame->IsVertical() || m_pFrame->IsSwapped(), + "NewFootnotePortion with unswapped frame" ); + + SwTextFootnote *pFootnote = static_cast(pHint); + + if( !m_pFrame->IsFootnoteAllowed() ) + return new SwFootnotePortion("", pFootnote); + + const SwFormatFootnote& rFootnote = pFootnote->GetFootnote(); + SwDoc *const pDoc = &m_pFrame->GetDoc(); + + if( rInf.IsTest() ) + return new SwFootnotePortion(rFootnote.GetViewNumStr(*pDoc, m_pFrame->getRootFrame()), pFootnote); + + SwSwapIfSwapped swap(m_pFrame); + + sal_uInt16 nReal; + { + sal_uInt16 nOldReal = m_pCurr->GetRealHeight(); + sal_uInt16 nOldAscent = m_pCurr->GetAscent(); + sal_uInt16 nOldHeight = m_pCurr->Height(); + CalcRealHeight(); + nReal = m_pCurr->GetRealHeight(); + if( nReal < nOldReal ) + nReal = nOldReal; + m_pCurr->SetRealHeight( nOldReal ); + m_pCurr->Height( nOldHeight ); + m_pCurr->SetAscent( nOldAscent ); + } + + SwTwips nLower = Y() + nReal; + + const bool bVertical = m_pFrame->IsVertical(); + if( bVertical ) + nLower = m_pFrame->SwitchHorizontalToVertical( nLower ); + + nLower = lcl_GetFootnoteLower( m_pFrame, nLower ); + + // We just refresh. + // The Connect does not do anything useful in this case, but will + // mostly throw away the Footnote and create it anew. + if( !rInf.IsQuick() ) + m_pFrame->ConnectFootnote( pFootnote, nLower ); + + SwTextFrame *pScrFrame = m_pFrame->FindFootnoteRef( pFootnote ); + SwFootnoteBossFrame *pBoss = m_pFrame->FindFootnoteBossFrame( !rFootnote.IsEndNote() ); + SwFootnoteFrame *pFootnoteFrame = nullptr; + if( pScrFrame ) + pFootnoteFrame = SwFootnoteBossFrame::FindFootnote( pScrFrame, pFootnote ); + + // We see whether our Append has caused some Footnote to + // still be on the Page/Column. If not, our line disappears too, + // which will lead to the following undesired behaviour: + // Footnote1 still fits onto the Page/Column, but Footnote2 doesn't. + // The Footnote2 Reference remains on the Page/Column. The Footnote itself + // is on the next Page/Column. + // + // Exception: If the Page/Column cannot accommodate another line, + // the Footnote Reference should be moved to the next one. + if( !rFootnote.IsEndNote() ) + { + SwSectionFrame *pSct = pBoss->FindSctFrame(); + bool bAtSctEnd = pSct && pSct->IsFootnoteAtEnd(); + if( FTNPOS_CHAPTER != pDoc->GetFootnoteInfo().m_ePos || bAtSctEnd ) + { + SwFrame* pFootnoteCont = pBoss->FindFootnoteCont(); + // If the Parent is within an Area, it can only be a Column of this + // Area. If this one is not the first Column, we can avoid it. + if( !m_pFrame->IsInTab() && ( GetLineNr() > 1 || m_pFrame->GetPrev() || + ( !bAtSctEnd && m_pFrame->GetIndPrev() ) || + ( pSct && pBoss->GetPrev() ) ) ) + { + if( !pFootnoteCont ) + { + rInf.SetStop( true ); + return nullptr; + } + else + { + // There must not be any Footnote Containers in column Areas and at the same time on the + // Page/Page column + if( pSct && !bAtSctEnd ) // Is the Container in a (column) Area? + { + SwFootnoteBossFrame* pTmp = pBoss->FindSctFrame()->FindFootnoteBossFrame( true ); + SwFootnoteContFrame* pFootnoteC = pTmp->FindFootnoteCont(); + if( pFootnoteC ) + { + SwFootnoteFrame* pTmpFrame = static_cast(pFootnoteC->Lower()); + if( pTmpFrame && *pTmpFrame < pFootnote ) + { + rInf.SetStop( true ); + return nullptr; + } + } + } + // Is this the last Line that fits? + SwTwips nTmpBot = Y() + nReal * 2; + + if( bVertical ) + nTmpBot = m_pFrame->SwitchHorizontalToVertical( nTmpBot ); + + SwRectFnSet aRectFnSet(pFootnoteCont); + + const tools::Long nDiff = aRectFnSet.YDiff( + aRectFnSet.GetTop(pFootnoteCont->getFrameArea()), + nTmpBot ); + + if( pScrFrame && nDiff < 0 ) + { + if( pFootnoteFrame ) + { + SwFootnoteBossFrame *pFootnoteBoss = pFootnoteFrame->FindFootnoteBossFrame(); + if( pFootnoteBoss != pBoss ) + { + // We're in the last Line and the Footnote has moved + // to another Page. We also want to be on that Page! + rInf.SetStop( true ); + return nullptr; + } + } + } + } + } + } + } + // Finally: Create FootnotePortion and exit ... + SwFootnotePortion *pRet = new SwFootnotePortion( + rFootnote.GetViewNumStr(*pDoc, m_pFrame->getRootFrame()), + pFootnote, nReal ); + rInf.SetFootnoteInside( true ); + + return pRet; +} + +/** + * The portion for the Footnote Numbering in the Footnote Area + */ +SwNumberPortion *SwTextFormatter::NewFootnoteNumPortion( SwTextFormatInfo const &rInf ) const +{ + OSL_ENSURE( m_pFrame->IsInFootnote() && !m_pFrame->GetIndPrev() && !rInf.IsFootnoteDone(), + "This is the wrong place for a ftnnumber" ); + if( rInf.GetTextStart() != m_nStart || + rInf.GetTextStart() != rInf.GetIdx() ) + return nullptr; + + const SwFootnoteFrame* pFootnoteFrame = m_pFrame->FindFootnoteFrame(); + const SwTextFootnote* pFootnote = pFootnoteFrame->GetAttr(); + + // Aha! So we're in the Footnote Area! + SwFormatFootnote& rFootnote = const_cast(pFootnote->GetFootnote()); + + SwDoc *const pDoc = &m_pFrame->GetDoc(); + OUString aFootnoteText(rFootnote.GetViewNumStr(*pDoc, m_pFrame->getRootFrame(), true)); + + const SwEndNoteInfo* pInfo; + if( rFootnote.IsEndNote() ) + pInfo = &pDoc->GetEndNoteInfo(); + else + pInfo = &pDoc->GetFootnoteInfo(); + + const SwAttrSet* pParSet = &rInf.GetCharAttr(); + const IDocumentSettingAccess* pIDSA = &pDoc->getIDocumentSettingAccess(); + std::unique_ptr pNumFnt(new SwFont( pParSet, pIDSA )); + + // #i37142# + // Underline style of paragraph font should not be considered + // Overline style of paragraph font should not be considered + // Weight style of paragraph font should not be considered + // Posture style of paragraph font should not be considered + // See also #i18463# and SwTextFormatter::NewNumberPortion() + pNumFnt->SetUnderline( LINESTYLE_NONE ); + pNumFnt->SetOverline( LINESTYLE_NONE ); + pNumFnt->SetItalic( ITALIC_NONE, SwFontScript::Latin ); + pNumFnt->SetItalic( ITALIC_NONE, SwFontScript::CJK ); + pNumFnt->SetItalic( ITALIC_NONE, SwFontScript::CTL ); + pNumFnt->SetWeight( WEIGHT_NORMAL, SwFontScript::Latin ); + pNumFnt->SetWeight( WEIGHT_NORMAL, SwFontScript::CJK ); + pNumFnt->SetWeight( WEIGHT_NORMAL, SwFontScript::CTL ); + + const rtl::Reference xAnchor = rFootnote.getAnchor(*pDoc); + if (xAnchor.is()) + { + auto aAny = xAnchor->getPropertyValue("CharFontCharSet"); + sal_Int16 eCharSet; + if ((aAny >>= eCharSet) && eCharSet == awt::CharSet::SYMBOL) + { + OUString aFontName; + aAny = xAnchor->getPropertyValue("CharFontName"); + if (aAny >>= aFontName) + { + pNumFnt->SetName(aFontName, SwFontScript::Latin); + pNumFnt->SetName(aFontName, SwFontScript::CJK); + pNumFnt->SetName(aFontName, SwFontScript::CTL); + pNumFnt->SetCharSet(RTL_TEXTENCODING_SYMBOL, SwFontScript::Latin); + pNumFnt->SetCharSet(RTL_TEXTENCODING_SYMBOL, SwFontScript::CJK); + pNumFnt->SetCharSet(RTL_TEXTENCODING_SYMBOL, SwFontScript::CTL); + } + } + } + + const SwAttrSet& rSet = pInfo->GetCharFormat(*pDoc)->GetAttrSet(); + pNumFnt->SetDiffFnt(&rSet, pIDSA ); + pNumFnt->SetVertical( pNumFnt->GetOrientation(), m_pFrame->IsVertical() ); + + // tdf#85610 apply redline coloring to the footnote numbering in the footnote area + SwUnoInternalPaM aPam(*pDoc); + if ( ::sw::XTextRangeToSwPaM(aPam, xAnchor) ) + { + SwRedlineTable::size_type nRedlinePos = 0; + const SwRedlineTable& rTable = pDoc->getIDocumentRedlineAccess().GetRedlineTable(); + const SwRangeRedline* pRedline = rTable.FindAtPosition( *aPam.Start(), nRedlinePos ); + if (pRedline) + { + SwAttrPool& rPool = pDoc->GetAttrPool(); + SfxItemSetFixed aSet(rPool); + + std::size_t aAuthor = (1 < pRedline->GetStackCount()) + ? pRedline->GetAuthor( 1 ) + : pRedline->GetAuthor(); + + if ( RedlineType::Delete == pRedline->GetType() ) + SW_MOD()->GetDeletedAuthorAttr(aAuthor, aSet); + else + SW_MOD()->GetInsertAuthorAttr(aAuthor, aSet); + + if (const SvxColorItem* pItem = aSet.GetItemIfSet(RES_CHRATR_COLOR)) + pNumFnt->SetColor(pItem->GetValue()); + if (const SvxUnderlineItem* pItem = aSet.GetItemIfSet(RES_CHRATR_UNDERLINE)) + pNumFnt->SetUnderline(pItem->GetLineStyle()); + if (const SvxCrossedOutItem* pItem = aSet.GetItemIfSet(RES_CHRATR_CROSSEDOUT)) + pNumFnt->SetStrikeout( pItem->GetStrikeout() ); + } + } + + SwFootnoteNumPortion* pNewPor = new SwFootnoteNumPortion( aFootnoteText, std::move(pNumFnt) ); + pNewPor->SetLeft( !m_pFrame->IsRightToLeft() ); + return pNewPor; +} + +static OUString lcl_GetPageNumber( const SwPageFrame* pPage ) +{ + OSL_ENSURE( pPage, "GetPageNumber: Homeless TextFrame" ); + const sal_uInt16 nVirtNum = pPage->GetVirtPageNum(); + const SvxNumberType& rNum = pPage->GetPageDesc()->GetNumType(); + return rNum.GetNumStr( nVirtNum ); +} + +SwErgoSumPortion *SwTextFormatter::NewErgoSumPortion( SwTextFormatInfo const &rInf ) const +{ + // We cannot assume we're a Follow + if( !m_pFrame->IsInFootnote() || m_pFrame->GetPrev() || + rInf.IsErgoDone() || rInf.GetIdx() != m_pFrame->GetOffset() || + m_pFrame->ImplFindFootnoteFrame()->GetAttr()->GetFootnote().IsEndNote() ) + return nullptr; + + // we are in the footnote container + const SwFootnoteInfo &rFootnoteInfo = m_pFrame->GetDoc().GetFootnoteInfo(); + SwTextFrame *pQuoFrame = m_pFrame->FindQuoVadisFrame(); + if( !pQuoFrame ) + return nullptr; + const SwPageFrame* pPage = m_pFrame->FindPageFrame(); + const SwPageFrame* pQuoPage = pQuoFrame->FindPageFrame(); + if( pPage == pQuoFrame->FindPageFrame() ) + return nullptr; // If the QuoVadis is on the same Column/Page + const OUString aPage = lcl_GetPageNumber( pPage ); + SwParaPortion *pPara = pQuoFrame->GetPara(); + if( pPara ) + pPara->SetErgoSumNum( aPage ); + if( rFootnoteInfo.m_aErgoSum.isEmpty() ) + return nullptr; + SwErgoSumPortion *pErgo = new SwErgoSumPortion( rFootnoteInfo.m_aErgoSum, + lcl_GetPageNumber( pQuoPage ) ); + return pErgo; +} + +TextFrameIndex SwTextFormatter::FormatQuoVadis(TextFrameIndex const nOffset) +{ + OSL_ENSURE( ! m_pFrame->IsVertical() || ! m_pFrame->IsSwapped(), + "SwTextFormatter::FormatQuoVadis with swapped frame" ); + + if( !m_pFrame->IsInFootnote() || m_pFrame->ImplFindFootnoteFrame()->GetAttr()->GetFootnote().IsEndNote() ) + return nOffset; + + const SwFrame* pErgoFrame = m_pFrame->FindFootnoteFrame()->GetFollow(); + if( !pErgoFrame && m_pFrame->HasFollow() ) + pErgoFrame = m_pFrame->GetFollow(); + if( !pErgoFrame ) + return nOffset; + + if( pErgoFrame == m_pFrame->GetNext() ) + { + SwFrame *pCol = m_pFrame->FindColFrame(); + while( pCol && !pCol->GetNext() ) + pCol = pCol->GetUpper()->FindColFrame(); + if( pCol ) + return nOffset; + } + else + { + const SwPageFrame* pPage = m_pFrame->FindPageFrame(); + const SwPageFrame* pErgoPage = pErgoFrame->FindPageFrame(); + if( pPage == pErgoPage ) + return nOffset; // If the ErgoSum is on the same Page + } + + SwTextFormatInfo &rInf = GetInfo(); + const SwFootnoteInfo &rFootnoteInfo = m_pFrame->GetDoc().GetFootnoteInfo(); + if( rFootnoteInfo.m_aQuoVadis.isEmpty() ) + return nOffset; + + // A remark on QuoVadis/ErgoSum: + // We use the Font set for the Paragraph for these texts. + // Thus, we initialize: + // TODO: ResetFont(); + FeedInf( rInf ); + SeekStartAndChg( rInf, true ); + if( GetRedln() && m_pCurr->HasRedline() ) + { + std::pair const pos( + GetTextFrame()->MapViewToModel(nOffset)); + GetRedln()->Seek(*m_pFont, pos.first->GetIndex(), pos.second, 0); + } + + // A tricky special case: Flyfrms extend into the Line and are at the + // position we want to insert the Quovadis text + // Let's see if it is that bad indeed: + SwLinePortion *pPor = m_pCurr->GetFirstPortion(); + sal_uInt16 nLastLeft = 0; + while( pPor ) + { + if ( pPor->IsFlyPortion() ) + nLastLeft = static_cast(pPor)->GetFix() + + static_cast(pPor)->Width(); + pPor = pPor->GetNextPortion(); + } + + // The old game all over again: we want the Line to wrap around + // at a certain point, so we adjust the width. + // nLastLeft is now basically the right margin + const sal_uInt16 nOldRealWidth = rInf.RealWidth(); + rInf.RealWidth( nOldRealWidth - nLastLeft ); + + OUString aErgo = lcl_GetPageNumber( pErgoFrame->FindPageFrame() ); + SwQuoVadisPortion *pQuo = new SwQuoVadisPortion(rFootnoteInfo.m_aQuoVadis, aErgo ); + pQuo->SetAscent( rInf.GetAscent() ); + pQuo->Height( rInf.GetTextHeight() ); + pQuo->Format( rInf ); + sal_uInt16 nQuoWidth = pQuo->Width(); + SwLinePortion* pCurrPor = pQuo; + + while ( rInf.GetRest() ) + { + SwLinePortion* pFollow = rInf.GetRest(); + rInf.SetRest( nullptr ); + pCurrPor->Move( rInf ); + + OSL_ENSURE( pFollow->IsQuoVadisPortion(), + "Quo Vadis, rest of QuoVadisPortion" ); + + // format the rest and append it to the other QuoVadis parts + pFollow->Format( rInf ); + nQuoWidth = nQuoWidth + pFollow->Width(); + + pCurrPor->Append( pFollow ); + pCurrPor = pFollow; + } + + Right( Right() - nQuoWidth ); + + TextFrameIndex nRet; + { + SwSwapIfNotSwapped swap(m_pFrame); + + nRet = FormatLine( m_nStart ); + } + + Right( rInf.Left() + nOldRealWidth - 1 ); + + nLastLeft = nOldRealWidth - m_pCurr->Width(); + FeedInf( rInf ); + + // It's possible that there's a Margin Portion at the end, which would + // just cause a lot of trouble, when respanning + pPor = m_pCurr->FindLastPortion(); + SwGluePortion *pGlue = pPor->IsMarginPortion() ? static_cast(pPor) : nullptr; + if( pGlue ) + { + pGlue->Height( 0 ); + pGlue->Width( 0 ); + pGlue->SetLen(TextFrameIndex(0)); + pGlue->SetAscent( 0 ); + pGlue->SetNextPortion( nullptr ); + pGlue->SetFixWidth(0); + } + + // Luxury: We make sure the QuoVadis text appears on the right, by + // using Glues. + nLastLeft = nLastLeft - nQuoWidth; + if( nLastLeft ) + { + if( nLastLeft > pQuo->GetAscent() ) // Minimum distance + { + switch( GetAdjust() ) + { + case SvxAdjust::Block: + { + if( !m_pCurr->GetLen() || + CH_BREAK != GetInfo().GetChar(m_nStart + m_pCurr->GetLen() - TextFrameIndex(1))) + nLastLeft = pQuo->GetAscent(); + nQuoWidth = nQuoWidth + nLastLeft; + break; + } + case SvxAdjust::Right: + { + nLastLeft = pQuo->GetAscent(); + nQuoWidth = nQuoWidth + nLastLeft; + break; + } + case SvxAdjust::Center: + { + nQuoWidth = nQuoWidth + pQuo->GetAscent(); + tools::Long nDiff = nLastLeft - nQuoWidth; + if( nDiff < 0 ) + { + nLastLeft = pQuo->GetAscent(); + nQuoWidth = o3tl::narrowing(-nDiff + nLastLeft); + } + else + { + nQuoWidth = 0; + nLastLeft = sal_uInt16(( pQuo->GetAscent() + nDiff ) / 2); + } + break; + } + default: + nQuoWidth = nQuoWidth + nLastLeft; + } + } + else + nQuoWidth = nQuoWidth + nLastLeft; + if( nLastLeft ) + { + pGlue = new SwGluePortion(0); + pGlue->Width( nLastLeft ); + pPor->Append( pGlue ); + pPor = pPor->GetNextPortion(); + } + } + + // Finally: we insert the QuoVadis Portion + pCurrPor = pQuo; + while ( pCurrPor ) + { + // pPor->Append deletes the pPortion pointer of pPor. + // Therefore we have to keep a pointer to the next portion + pQuo = static_cast(pCurrPor->GetNextPortion()); + pPor->Append( pCurrPor ); + pPor = pPor->GetNextPortion(); + pCurrPor = pQuo; + } + + m_pCurr->Width( m_pCurr->Width() + nQuoWidth ); + + // And adjust again, due to the adjustment and due to the following special + // case: + // The DummyUser has set a smaller Font in the Line than the one used + // by the QuoVadis text ... + CalcAdjustLine( m_pCurr ); + + return nRet; +} + +/** + * This function creates a Line that reaches to the other Page Margin. + * DummyLines or DummyPortions make sure, that oscillations stop, because + * there's no way to flow back. + * They are used for Footnotes in paragraph-bound Frames and for Footnote + * oscillations + */ +void SwTextFormatter::MakeDummyLine() +{ + sal_uInt16 nRstHeight = GetFrameRstHeight(); + if( m_pCurr && nRstHeight > m_pCurr->Height() ) + { + SwLineLayout *pLay = new SwLineLayout; + nRstHeight = nRstHeight - m_pCurr->Height(); + pLay->Height( nRstHeight ); + pLay->SetAscent( nRstHeight ); + Insert( pLay ); + Next(); + } +} + +namespace { + +class SwFootnoteSave +{ + SwTextSizeInfo* m_pInf; + SwFont* m_pFnt; + std::unique_ptr m_pOld; + + SwFootnoteSave(const SwFootnoteSave&) = delete; + SwFootnoteSave& operator=(const SwFootnoteSave&) = delete; + +public: + SwFootnoteSave( const SwTextSizeInfo &rInf, + const SwTextFootnote *pTextFootnote, + const bool bApplyGivenScriptType, + const SwFontScript nGivenScriptType ); + ~SwFootnoteSave() COVERITY_NOEXCEPT_FALSE; +}; + +} + +SwFootnoteSave::SwFootnoteSave(const SwTextSizeInfo& rInf, const SwTextFootnote* pTextFootnote, + const bool bApplyGivenScriptType, + const SwFontScript nGivenScriptType) + : m_pInf(&const_cast(rInf)) + , m_pFnt(nullptr) +{ + if( pTextFootnote && rInf.GetTextFrame() ) + { + m_pFnt = const_cast(rInf).GetFont(); + m_pOld.reset(new SwFont(*m_pFnt)); + m_pOld->GetTox() = m_pFnt->GetTox(); + m_pFnt->GetTox() = 0; + SwFormatFootnote& rFootnote = const_cast(pTextFootnote->GetFootnote()); + const SwDoc *const pDoc = &rInf.GetTextFrame()->GetDoc(); + + // #i98418# + if ( bApplyGivenScriptType ) + { + m_pFnt->SetActual(nGivenScriptType); + } + else + { + // examine text and set script + OUString aTmpStr(rFootnote.GetViewNumStr(*pDoc, rInf.GetTextFrame()->getRootFrame())); + m_pFnt->SetActual(SwScriptInfo::WhichFont(0, aTmpStr)); + } + + const SwEndNoteInfo* pInfo; + if( rFootnote.IsEndNote() ) + pInfo = &pDoc->GetEndNoteInfo(); + else + pInfo = &pDoc->GetFootnoteInfo(); + const SwAttrSet& rSet = pInfo->GetAnchorCharFormat(const_cast(*pDoc))->GetAttrSet(); + m_pFnt->SetDiffFnt(&rSet, &pDoc->getIDocumentSettingAccess()); + + // we reduce footnote size, if we are inside a double line portion + if (!m_pOld->GetEscapement() && 50 == m_pOld->GetPropr()) + { + Size aSize = m_pFnt->GetSize(m_pFnt->GetActual()); + m_pFnt->SetSize(Size(aSize.Width() / 2, aSize.Height() / 2), m_pFnt->GetActual()); + } + + // set the correct rotation at the footnote font + if( const SvxCharRotateItem* pItem = rSet.GetItemIfSet( RES_CHRATR_ROTATE ) ) + m_pFnt->SetVertical(pItem->GetValue(), + rInf.GetTextFrame()->IsVertical()); + + m_pFnt->ChgPhysFnt(m_pInf->GetVsh(), *m_pInf->GetOut()); + + if( const SvxBrushItem* pItem = rSet.GetItemIfSet( RES_CHRATR_BACKGROUND ) ) + m_pFnt->SetBackColor(pItem->GetColor()); + } + else + m_pFnt = nullptr; +} + +SwFootnoteSave::~SwFootnoteSave() COVERITY_NOEXCEPT_FALSE +{ + if (m_pFnt) + { + // Put back SwFont + *m_pFnt = *m_pOld; + m_pFnt->GetTox() = m_pOld->GetTox(); + m_pFnt->ChgPhysFnt(m_pInf->GetVsh(), *m_pInf->GetOut()); + m_pOld.reset(); + } +} + +SwFootnotePortion::SwFootnotePortion( const OUString &rExpand, + SwTextFootnote *pFootn, sal_uInt16 nReal ) + : SwFieldPortion( rExpand, nullptr ) + , m_pFootnote(pFootn) + , m_nOrigHeight( nReal ) + // #i98418# + , mbPreferredScriptTypeSet( false ) + , mnPreferredScriptType( SwFontScript::Latin ) +{ + SetLen(TextFrameIndex(1)); + SetWhichPor( PortionType::Footnote ); +} + +bool SwFootnotePortion::GetExpText( const SwTextSizeInfo &, OUString &rText ) const +{ + rText = m_aExpand; + return true; +} + +bool SwFootnotePortion::Format( SwTextFormatInfo &rInf ) +{ + // #i98418# +// SwFootnoteSave aFootnoteSave( rInf, pFootnote ); + SwFootnoteSave aFootnoteSave( rInf, m_pFootnote, mbPreferredScriptTypeSet, mnPreferredScriptType ); + // the idx is manipulated in SwExpandPortion::Format + // this flag indicates, that a footnote is allowed to trigger + // an underflow during SwTextGuess::Guess + rInf.SetFakeLineStart( rInf.GetIdx() > rInf.GetLineStart() ); + const bool bFull = SwFieldPortion::Format( rInf ); + rInf.SetFakeLineStart( false ); + SetAscent( rInf.GetAscent() ); + Height( rInf.GetTextHeight() ); + rInf.SetFootnoteDone( !bFull ); + if( !bFull ) + rInf.SetParaFootnote(); + return bFull; +} + +void SwFootnotePortion::Paint( const SwTextPaintInfo &rInf ) const +{ + // #i98418# +// SwFootnoteSave aFootnoteSave( rInf, pFootnote ); + SwFootnoteSave aFootnoteSave( rInf, m_pFootnote, mbPreferredScriptTypeSet, mnPreferredScriptType ); + rInf.DrawViewOpt( *this, PortionType::Footnote ); + SwExpandPortion::Paint( rInf ); +} + +SwPosSize SwFootnotePortion::GetTextSize( const SwTextSizeInfo &rInfo ) const +{ + // #i98418# +// SwFootnoteSave aFootnoteSave( rInfo, pFootnote ); + SwFootnoteSave aFootnoteSave( rInfo, m_pFootnote, mbPreferredScriptTypeSet, mnPreferredScriptType ); + return SwExpandPortion::GetTextSize( rInfo ); +} + +// #i98418# +void SwFootnotePortion::SetPreferredScriptType( SwFontScript nPreferredScriptType ) +{ + mbPreferredScriptTypeSet = true; + mnPreferredScriptType = nPreferredScriptType; +} + +SwFieldPortion *SwQuoVadisPortion::Clone( const OUString &rExpand ) const +{ + return new SwQuoVadisPortion( rExpand, m_aErgo ); +} + +SwQuoVadisPortion::SwQuoVadisPortion( const OUString &rExp, OUString aStr ) + : SwFieldPortion( rExp ), m_aErgo(std::move(aStr)) +{ + SetLen(TextFrameIndex(0)); + SetWhichPor( PortionType::QuoVadis ); +} + +bool SwQuoVadisPortion::Format( SwTextFormatInfo &rInf ) +{ + // First try; maybe the Text fits + CheckScript( rInf ); + bool bFull = SwFieldPortion::Format( rInf ); + SetLen(TextFrameIndex(0)); + + if( bFull ) + { + // Second try; we make the String shorter + m_aExpand = "..."; + bFull = SwFieldPortion::Format( rInf ); + SetLen(TextFrameIndex(0)); + if( bFull ) + // Third try; we're done: we crush + Width( sal_uInt16(rInf.Width() - rInf.X()) ); + + // No multiline Fields for QuoVadis and ErgoSum + if( rInf.GetRest() ) + { + delete rInf.GetRest(); + rInf.SetRest( nullptr ); + } + } + return bFull; +} + +bool SwQuoVadisPortion::GetExpText( const SwTextSizeInfo &, OUString &rText ) const +{ + rText = m_aExpand; + // if this QuoVadisPortion has a follow, the follow is responsible for + // the ergo text. + if ( ! HasFollow() ) + rText += m_aErgo; + return true; +} + +void SwQuoVadisPortion::HandlePortion( SwPortionHandler& rPH ) const +{ + rPH.Special( GetLen(), m_aExpand + m_aErgo, GetWhichPor() ); +} + +void SwQuoVadisPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + // We _always_ want to output per DrawStretchText, because nErgo + // can quickly switch + if( PrtWidth() ) + { + rInf.DrawViewOpt( *this, PortionType::QuoVadis ); + SwTextSlot aDiffText( &rInf, this, true, false ); + SwFontSave aSave( rInf, m_pFont.get() ); + rInf.DrawText( *this, rInf.GetLen(), true ); + } +} + +SwFieldPortion *SwErgoSumPortion::Clone( const OUString &rExpand ) const +{ + return new SwErgoSumPortion( rExpand, std::u16string_view() ); +} + +SwErgoSumPortion::SwErgoSumPortion(const OUString &rExp, std::u16string_view rStr) + : SwFieldPortion( rExp ) +{ + SetLen(TextFrameIndex(0)); + m_aExpand += rStr; + + // One blank distance to the text + m_aExpand += " "; + SetWhichPor( PortionType::ErgoSum ); +} + +TextFrameIndex SwErgoSumPortion::GetModelPositionForViewPoint(const sal_uInt16) const +{ + return TextFrameIndex(0); +} + +bool SwErgoSumPortion::Format( SwTextFormatInfo &rInf ) +{ + const bool bFull = SwFieldPortion::Format( rInf ); + SetLen(TextFrameIndex(0)); + rInf.SetErgoDone( true ); + + // No multiline Fields for QuoVadis and ErgoSum + if( bFull && rInf.GetRest() ) + { + delete rInf.GetRest(); + rInf.SetRest( nullptr ); + } + + // We return false in order to get some text into the current line, + // even if it's full (better than looping) + return false; +} + +void SwParaPortion::SetErgoSumNum( const OUString& rErgo ) +{ + SwLineLayout *pLay = this; + while( pLay->GetNext() ) + { + pLay = pLay->GetNext(); + } + SwLinePortion *pPor = pLay; + SwQuoVadisPortion *pQuo = nullptr; + while( pPor && !pQuo ) + { + if ( pPor->IsQuoVadisPortion() ) + pQuo = static_cast(pPor); + pPor = pPor->GetNextPortion(); + } + if( pQuo ) + pQuo->SetNumber( rErgo ); +} + +/** + * Is called in SwTextFrame::Prepare() + */ +bool SwParaPortion::UpdateQuoVadis( std::u16string_view rQuo ) +{ + SwLineLayout *pLay = this; + while( pLay->GetNext() ) + { + pLay = pLay->GetNext(); + } + SwLinePortion *pPor = pLay; + SwQuoVadisPortion *pQuo = nullptr; + while( pPor && !pQuo ) + { + if ( pPor->IsQuoVadisPortion() ) + pQuo = static_cast(pPor); + pPor = pPor->GetNextPortion(); + } + + if( !pQuo ) + return false; + + return pQuo->GetQuoText() == rQuo; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/txthyph.cxx b/sw/source/core/text/txthyph.cxx new file mode 100644 index 0000000000..e9f6a9d0e6 --- /dev/null +++ b/sw/source/core/text/txthyph.cxx @@ -0,0 +1,582 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include +#include +#include +#include +#include +#include +#include "porhyph.hxx" +#include "inftxt.hxx" +#include "itrform2.hxx" +#include "guess.hxx" +#include + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::linguistic2; +using namespace ::com::sun::star::i18n; + +Reference< XHyphenatedWord > SwTextFormatInfo::HyphWord( + const OUString &rText, const sal_Int32 nMinTrail ) +{ + if( rText.getLength() < 4 || m_pFnt->IsSymbol(m_pVsh) ) + return nullptr; + Reference< XHyphenator > xHyph = ::GetHyphenator(); + Reference< XHyphenatedWord > xHyphWord; + + if( xHyph.is() ) + xHyphWord = xHyph->hyphenate( rText, + g_pBreakIt->GetLocale( m_pFnt->GetLanguage() ), + rText.getLength() - nMinTrail, GetHyphValues() ); + return xHyphWord; + +} + +/** + * We format a row for interactive hyphenation + */ +bool SwTextFrame::Hyphenate(SwInterHyphInfoTextFrame & rHyphInf) +{ + vcl::RenderContext* pRenderContext = getRootFrame()->GetCurrShell()->GetOut(); + OSL_ENSURE( ! IsVertical() || ! IsSwapped(),"swapped frame at SwTextFrame::Hyphenate" ); + + assert(g_pBreakIt && g_pBreakIt->GetBreakIter().is()); + + // We lock it, to start with + OSL_ENSURE( !IsLocked(), "SwTextFrame::Hyphenate: this is locked" ); + + // The frame::Frame must have a valid SSize! + Calc(pRenderContext); + GetFormatted(); + + bool bRet = false; + if( !IsEmpty() ) + { + // We always need to enable hyphenation + // Don't be afraid: the SwTextIter saves the old row in the hyphenate + TextFrameLockGuard aLock( this ); + + if ( IsVertical() ) + SwapWidthAndHeight(); + + SwTextFormatInfo aInf( getRootFrame()->GetCurrShell()->GetOut(), this, true ); // true for interactive hyph! + SwTextFormatter aLine( this, &aInf ); + aLine.CharToLine( rHyphInf.m_nStart ); + + // If we're within the first word of a row, it could've been hyphenated + // in the row earlier. + // That's why we go one row back. + if( aLine.Prev() ) + { + SwLinePortion *pPor = aLine.GetCurr()->GetFirstPortion(); + while( pPor->GetNextPortion() ) + pPor = pPor->GetNextPortion(); + if( pPor->GetWhichPor() == PortionType::SoftHyphen || + pPor->GetWhichPor() == PortionType::SoftHyphenStr ) + aLine.Next(); + } + + const TextFrameIndex nEnd = rHyphInf.m_nEnd; + while( !bRet && aLine.GetStart() < nEnd ) + { + bRet = aLine.Hyphenate( rHyphInf ); + if( !aLine.Next() ) + break; + } + + if ( IsVertical() ) + SwapWidthAndHeight(); + } + return bRet; +} + +/** + * We format a row for interactive hyphenation + * We can assume that we've already formatted. + * We just reformat the row, the hyphenator will be prepared like + * the UI expects it to be. + * TODO: We can of course optimize this a lot. + */ +void SetParaPortion( SwTextInfo *pInf, SwParaPortion *pRoot ) +{ + OSL_ENSURE( pRoot, "SetParaPortion: no root anymore" ); + pInf->m_pPara = pRoot; +} + +bool SwTextFormatter::Hyphenate(SwInterHyphInfoTextFrame & rHyphInf) +{ + SwTextFormatInfo &rInf = GetInfo(); + + // We never need to hyphenate anything in the last row + // Except for, if it contains a FlyPortion or if it's the + // last row of the Master + if( !GetNext() && !rInf.GetTextFly().IsOn() && !m_pFrame->GetFollow() ) + return false; + + TextFrameIndex nWrdStart = m_nStart; + + // We need to retain the old row + // E.g.: The attribute for hyphenation was not set, but + // it's always set in SwTextFrame::Hyphenate, because we want + // to set breakpoints. + SwLineLayout *pOldCurr = m_pCurr; + + InitCntHyph(); + + // 5298: IsParaLine() (ex.IsFirstLine) calls GetParaPortion(). + // We have to create the same conditions: in the first line + // we format SwParaPortions... + if( pOldCurr->IsParaPortion() ) + { + SwParaPortion *pPara = new SwParaPortion(); + SetParaPortion( &rInf, pPara ); + m_pCurr = pPara; + OSL_ENSURE( IsParaLine(), "SwTextFormatter::Hyphenate: not the first" ); + } + else + m_pCurr = new SwLineLayout(); + + nWrdStart = FormatLine( nWrdStart ); + + // You always should keep in mind that for example there are fields + // which can be hyphenated + if( m_pCurr->PrtWidth() && m_pCurr->GetLen() ) + { + // We must be prepared that there are FlyFrames in the line, + // at which line breaking is possible. So we search for the first + // HyphPortion in the specified range. + + SwLinePortion *pPos = m_pCurr->GetNextPortion(); + const TextFrameIndex nPamStart = rHyphInf.m_nStart; + nWrdStart = m_nStart; + const TextFrameIndex nEnd = rHyphInf.m_nEnd; + while( pPos ) + { + // Either we are above or we are running into a HyphPortion + // at the end of line or before a Fly. + if( nWrdStart >= nEnd ) + { + nWrdStart = TextFrameIndex(0); + break; + } + + if( nWrdStart >= nPamStart && pPos->InHyphGrp() + && ( !pPos->IsSoftHyphPortion() + || static_cast(pPos)->IsExpand() ) ) + { + nWrdStart = nWrdStart + pPos->GetLen(); + break; + } + + nWrdStart = nWrdStart + pPos->GetLen(); + pPos = pPos->GetNextPortion(); + } + // When pPos is null, no hyphen position was found. + if( !pPos ) + nWrdStart = TextFrameIndex(0); + } + else + // In case the whole line is zero-length, that's the same situation as + // above when the portion iteration ends without explicitly breaking + // from the loop. + nWrdStart = TextFrameIndex(0); + + // the old LineLayout is set again ... + delete m_pCurr; + m_pCurr = pOldCurr; + + if( pOldCurr->IsParaPortion() ) + { + SetParaPortion( &rInf, static_cast(pOldCurr) ); + OSL_ENSURE( IsParaLine(), "SwTextFormatter::Hyphenate: even not the first" ); + } + + if (nWrdStart == TextFrameIndex(0)) + return false; + + // nWrdStart contains the position in string that should be hyphenated + rHyphInf.m_nWordStart = nWrdStart; + + TextFrameIndex nLen(0); + const TextFrameIndex nEnd = nWrdStart; + + // we search forwards + Reference< XHyphenatedWord > xHyphWord; + + Boundary const aBound = g_pBreakIt->GetBreakIter()->getWordBoundary( + rInf.GetText(), sal_Int32(nWrdStart), + g_pBreakIt->GetLocale( rInf.GetFont()->GetLanguage() ), WordType::DICTIONARY_WORD, true ); + nWrdStart = TextFrameIndex(aBound.startPos); + nLen = TextFrameIndex(aBound.endPos) - nWrdStart; + if (nLen == TextFrameIndex(0)) + return false; + + OUString const aSelText(rInf.GetText().copy(sal_Int32(nWrdStart), sal_Int32(nLen))); + const sal_Int32 nMinTrail = (nWrdStart + nLen > nEnd) + ? sal_Int32(nWrdStart + nLen - nEnd) - 1 + : 0; + + //!! rHyphInf.SetHyphWord( ... ) must done here + xHyphWord = rInf.HyphWord( aSelText, nMinTrail ); + if ( xHyphWord.is() ) + { + rHyphInf.SetHyphWord( xHyphWord ); + rHyphInf.m_nWordStart = nWrdStart; + rHyphInf.m_nWordLen = nLen; + return true; + } + + return false; +} + +bool SwTextPortion::CreateHyphen( SwTextFormatInfo &rInf, SwTextGuess const &rGuess ) +{ + const Reference< XHyphenatedWord >& xHyphWord = rGuess.HyphWord(); + + OSL_ENSURE( !mpNextPortion, "SwTextPortion::CreateHyphen(): another portion, another planet..." ); + OSL_ENSURE( xHyphWord.is(), "SwTextPortion::CreateHyphen(): You are lucky! The code is robust here." ); + + if( rInf.IsHyphForbud() || + mpNextPortion || // robust + !xHyphWord.is() || // more robust + // multi-line fields can't be hyphenated interactively + ( rInf.IsInterHyph() && InFieldGrp() ) ) + return false; + + std::unique_ptr pHyphPor; + TextFrameIndex nPorEnd; + SwTextSizeInfo aInf( rInf ); + + // first case: hyphenated word has alternative spelling + if ( xHyphWord->isAlternativeSpelling() ) + { + SvxAlternativeSpelling aAltSpell = SvxGetAltSpelling( xHyphWord ); + OSL_ENSURE( aAltSpell.bIsAltSpelling, "no alternative spelling" ); + + OUString aAltText = aAltSpell.aReplacement; + nPorEnd = TextFrameIndex(aAltSpell.nChangedPos) + rGuess.BreakStart() - rGuess.FieldDiff(); + sal_Int32 nTmpLen = 0; + + // soft hyphen at alternative spelling position? + if( rInf.GetText()[sal_Int32(rInf.GetSoftHyphPos())] == CHAR_SOFTHYPHEN ) + { + pHyphPor.reset(new SwSoftHyphStrPortion( aAltText )); + nTmpLen = 1; + } + else { + pHyphPor.reset(new SwHyphStrPortion( aAltText )); + } + + // length of pHyphPor is adjusted + pHyphPor->SetLen( TextFrameIndex(aAltText.getLength() + 1) ); + static_cast(*pHyphPor) = pHyphPor->GetTextSize( rInf ); + pHyphPor->SetLen( TextFrameIndex(aAltSpell.nChangedLength + nTmpLen) ); + } + else + { + // second case: no alternative spelling + pHyphPor.reset(new SwHyphPortion); + pHyphPor->SetLen(TextFrameIndex(1)); + + static const void* nLastFontCacheId = nullptr; + static sal_uInt16 aMiniCacheH = 0, aMiniCacheW = 0; + const void* nTmpFontCacheId; + sal_uInt16 nFntIdx; + rInf.GetFont()->GetFontCacheId( nTmpFontCacheId, nFntIdx, rInf.GetFont()->GetActual() ); + if( !nLastFontCacheId || nLastFontCacheId != nTmpFontCacheId ) { + nLastFontCacheId = nTmpFontCacheId; + static_cast(*pHyphPor) = pHyphPor->GetTextSize( rInf ); + aMiniCacheH = pHyphPor->Height(); + aMiniCacheW = pHyphPor->Width(); + } else { + pHyphPor->Height( aMiniCacheH ); + pHyphPor->Width( aMiniCacheW ); + } + pHyphPor->SetLen(TextFrameIndex(0)); + + // values required for this + nPorEnd = TextFrameIndex(xHyphWord->getHyphenPos() + 1) + + rGuess.BreakStart() - rGuess.FieldDiff(); + } + + // portion end must be in front of us + // we do not put hyphens at start of line + if ( nPorEnd > rInf.GetIdx() || + ( nPorEnd == rInf.GetIdx() && rInf.GetLineStart() != rInf.GetIdx() ) ) + { + aInf.SetLen( nPorEnd - rInf.GetIdx() ); + pHyphPor->SetAscent( GetAscent() ); + SetLen( aInf.GetLen() ); + CalcTextSize( aInf ); + + Insert( pHyphPor.release() ); + + short nKern = rInf.GetFont()->CheckKerning(); + if( nKern ) + new SwKernPortion( *this, nKern ); + + return true; + } + + // last exit for the lost + pHyphPor.reset(); + BreakCut( rInf, rGuess ); + return false; +} + +bool SwHyphPortion::GetExpText( const SwTextSizeInfo &/*rInf*/, OUString &rText ) const +{ + rText = "-"; + return true; +} + +void SwHyphPortion::HandlePortion( SwPortionHandler& rPH ) const +{ + rPH.Special( GetLen(), OUString('-'), GetWhichPor() ); +} + +void SwHyphPortion::dumpAsXml(xmlTextWriterPtr pWriter, const OUString& rText, + TextFrameIndex& nOffset) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwHyphPortion")); + dumpAsXmlAttributes(pWriter, rText, nOffset); + nOffset += GetLen(); + + (void)xmlTextWriterEndElement(pWriter); +} + +bool SwHyphPortion::Format( SwTextFormatInfo &rInf ) +{ + const SwLinePortion *pLast = rInf.GetLast(); + Height( pLast->Height() ); + SetAscent( pLast->GetAscent() ); + OUString aText; + + if( !GetExpText( rInf, aText ) ) + return false; + + PrtWidth( rInf.GetTextSize( aText ).Width() ); + const bool bFull = rInf.Width() <= rInf.X() + PrtWidth(); + if( bFull && !rInf.IsUnderflow() ) { + Truncate(); + rInf.SetUnderflow( this ); + } + + return bFull; +} + +bool SwHyphStrPortion::GetExpText( const SwTextSizeInfo &, OUString &rText ) const +{ + rText = m_aExpand; + return true; +} + +void SwHyphStrPortion::HandlePortion( SwPortionHandler& rPH ) const +{ + rPH.Special( GetLen(), m_aExpand, GetWhichPor() ); +} + +SwLinePortion *SwSoftHyphPortion::Compress() { return this; } + +SwSoftHyphPortion::SwSoftHyphPortion() : + m_bExpand(false), m_nViewWidth(0) +{ + SetLen(TextFrameIndex(1)); + SetWhichPor( PortionType::SoftHyphen ); +} + +sal_uInt16 SwSoftHyphPortion::GetViewWidth( const SwTextSizeInfo &rInf ) const +{ + // Although we're in the const, nViewWidth should be calculated at + // the last possible moment + if( !Width() && rInf.OnWin() && rInf.GetOpt().IsSoftHyph() && !IsExpand() ) + { + if( !m_nViewWidth ) + const_cast(this)->m_nViewWidth + = rInf.GetTextSize(OUString('-')).Width(); + } + else + const_cast(this)->m_nViewWidth = 0; + return m_nViewWidth; +} + +/** + * Cases: + * + * 1) SoftHyph is in the line, ViewOpt off + * -> invisible, neighbors unchanged + * 2) SoftHyph is in the line, ViewOpt on + * -> visible, neighbors unchanged + * 3) SoftHyph is at the end of the line, ViewOpt on or off + * -> always visible, neighbors unchanged + */ +void SwSoftHyphPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + if( Width() ) + { + rInf.DrawViewOpt( *this, PortionType::SoftHyphen ); + SwExpandPortion::Paint( rInf ); + } +} + +/** + * We get the final width from the FormatEOL() + * + * During the underflow-phase we determine, whether or not + * there's an alternative spelling at all ... + * + * Case 1: "Au-to" + * 1) {Au}{-}{to}, {to} does not fit anymore => underflow + * 2) {-} calls hyphenate => no alternative + * 3) FormatEOL() and bFull = true + * + * Case 2: "Zuc-ker" + * 1) {Zuc}{-}{ker}, {ker} does not fit anymore => underflow + * 2) {-} calls hyphenate => alternative! + * 3) Underflow() and bFull = true + * 4) {Zuc} calls hyphenate => {Zuk}{-}{ker} + */ +bool SwSoftHyphPortion::Format( SwTextFormatInfo &rInf ) +{ + bool bFull = true; + + // special case for old German spelling + if( rInf.IsUnderflow() ) + { + if( rInf.GetSoftHyphPos() ) + return true; + + const bool bHyph = rInf.ChgHyph( true ); + if( rInf.IsHyphenate() ) + { + rInf.SetSoftHyphPos( rInf.GetIdx() ); + Width(0); + // if the soft hyphened word has an alternative spelling + // when hyphenated (old German spelling), the soft hyphen + // portion has to trigger an underflow + SwTextGuess aGuess; + bFull = rInf.IsInterHyph() || + !aGuess.AlternativeSpelling(rInf, rInf.GetIdx() - TextFrameIndex(1)); + } + rInf.ChgHyph( bHyph ); + + if( bFull && !rInf.IsHyphForbud() ) + { + rInf.SetSoftHyphPos(TextFrameIndex(0)); + FormatEOL( rInf ); + if ( rInf.GetFly() ) + rInf.GetRoot()->SetMidHyph( true ); + else + rInf.GetRoot()->SetEndHyph( true ); + } + else + { + rInf.SetSoftHyphPos( rInf.GetIdx() ); + Truncate(); + rInf.SetUnderflow( this ); + } + return true; + } + + rInf.SetSoftHyphPos(TextFrameIndex(0)); + SetExpand( true ); + bFull = SwHyphPortion::Format( rInf ); + SetExpand( false ); + if( !bFull ) + { + // By default, we do not have a width, but we do have a height + Width(0); + } + return bFull; +} + +/** + * Format End of Line + */ +void SwSoftHyphPortion::FormatEOL( SwTextFormatInfo &rInf ) +{ + if( IsExpand() ) + return; + + SetExpand( true ); + if( rInf.GetLast() == this ) + rInf.SetLast( FindPrevPortion( rInf.GetRoot() ) ); + + // We need to reset the old values + const SwTwips nOldX = rInf.X(); + TextFrameIndex const nOldIdx = rInf.GetIdx(); + rInf.X( rInf.X() - PrtWidth() ); + rInf.SetIdx( rInf.GetIdx() - GetLen() ); + const bool bFull = SwHyphPortion::Format( rInf ); + + // Shady business: We're allowed to get wider, but a Fly is also + // being processed, which needs a correct X position + if( bFull || !rInf.GetFly() ) + rInf.X( nOldX ); + else + rInf.X( nOldX + Width() ); + rInf.SetIdx( nOldIdx ); +} + +/** + * We're expanding: + * - if the special characters should be visible + * - if we're at the end of the line + * - if we're before a (real/emulated) line break + */ +bool SwSoftHyphPortion::GetExpText( const SwTextSizeInfo &rInf, OUString &rText ) const +{ + if( IsExpand() || ( rInf.OnWin() && rInf.GetOpt().IsSoftHyph() ) || + ( GetNextPortion() && ( GetNextPortion()->InFixGrp() || + GetNextPortion()->IsDropPortion() || GetNextPortion()->IsLayPortion() || + GetNextPortion()->IsParaPortion() || GetNextPortion()->IsBreakPortion() ) ) ) + { + return SwHyphPortion::GetExpText( rInf, rText ); + } + return false; +} + +void SwSoftHyphPortion::HandlePortion( SwPortionHandler& rPH ) const +{ + const PortionType nWhich = ! Width() ? + PortionType::SoftHyphenComp : + GetWhichPor(); + rPH.Special( GetLen(), OUString('-'), nWhich ); +} + +void SwSoftHyphStrPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + // Bug or feature?: + // {Zu}{k-}{ker}, {k-} will be gray instead of {-} + rInf.DrawViewOpt( *this, PortionType::SoftHyphen ); + SwHyphStrPortion::Paint( rInf ); +} + +SwSoftHyphStrPortion::SwSoftHyphStrPortion( std::u16string_view rStr ) + : SwHyphStrPortion( rStr ) +{ + SetLen(TextFrameIndex(1)); + SetWhichPor( PortionType::SoftHyphenStr ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/txtinit.cxx b/sw/source/core/text/txtinit.cxx new file mode 100644 index 0000000000..2b8bb2e95d --- /dev/null +++ b/sw/source/core/text/txtinit.cxx @@ -0,0 +1,60 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include +#include +#include +#include "pordrop.hxx" +#include +#include +#include + +SwCache *SwTextFrame::s_pTextCache = nullptr; +SwContourCache *pContourCache = nullptr; +SwDropCapCache *pDropCapCache = nullptr; + +// Are ONLY used in init.cxx. +// There we have extern void TextFinit() +// and extern void TextInit_(...) + +void TextInit_() +{ + pFntCache = new SwFntCache; // Cache for SwSubFont -> SwFntObj = { Font aFont, Font* pScrFont, Font* pPrtFont, OutputDevice* pPrinter, ... } + pSwFontCache = new SwFontCache; // Cache for SwTextFormatColl -> SwFontObj = { SwFont aSwFont, SfxPoolItem* pDefaultArray } + SwCache *pTextCache = new SwCache( 250 // Cache for SwTextFrame -> SwTextLine = { SwParaPortion* pLine } +#ifdef DBG_UTIL + , "static SwTextFrame::s_pTextCache"_ostr +#endif + ); + SwTextFrame::SetTextCache( pTextCache ); + PROTOCOL_INIT +} + +void TextFinit() +{ + PROTOCOL_STOP + delete SwTextFrame::GetTextCache(); + delete pSwFontCache; + delete pFntCache; + delete pContourCache; + SwDropPortion::DeleteDropCapCache(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/txtpaint.cxx b/sw/source/core/text/txtpaint.cxx new file mode 100644 index 0000000000..ccd9647bd9 --- /dev/null +++ b/sw/source/core/text/txtpaint.cxx @@ -0,0 +1,113 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include "txtpaint.hxx" +#include +#include +#include + +SwSaveClip::~SwSaveClip() +{ + // We recover the old state + if( !(m_pOut && m_bChg) ) + return; + + if ( m_pOut->GetConnectMetaFile() ) + m_pOut->Pop(); + else + { + if( m_bOn ) + m_pOut->SetClipRegion( m_aClip ); + else + m_pOut->SetClipRegion(); + } + m_bChg = false; +} + +void SwSaveClip::ChgClip_( const SwRect &rRect, const SwTextFrame* pFrame, + bool bEnlargeRect, + sal_Int32 nEnlargeTop, + sal_Int32 nEnlargeBottom ) +{ + SwRect aOldRect( rRect ); + const bool bVertical = pFrame && pFrame->IsVertical(); + + if ( pFrame && pFrame->IsRightToLeft() ) + pFrame->SwitchLTRtoRTL( const_cast(rRect) ); + + if ( bVertical ) + pFrame->SwitchHorizontalToVertical( const_cast(rRect) ); + + if ( !m_pOut || (!rRect.HasArea() && !m_pOut->IsClipRegion()) ) + { + const_cast(rRect) = aOldRect; + return; + } + + if ( !m_bChg ) + { + if ( m_pOut->GetConnectMetaFile() ) + m_pOut->Push(); + else if ( m_bOn ) + m_aClip = m_pOut->GetClipRegion(); + } + + if ( !rRect.HasArea() ) + m_pOut->SetClipRegion(); + else + { + tools::Rectangle aRect( rRect.SVRect() ); + + // Having underscores in our line, we enlarged the repaint area + // (see frmform.cxx) because for some fonts it could be too small. + // Consequently, we have to enlarge the clipping rectangle as well. + if ( bEnlargeRect && ! bVertical ) + aRect.AdjustBottom(40 ); + + // enlarge clip for paragraph margins at small fixed line height + if ( nEnlargeTop > 0 ) + aRect.AdjustTop( -nEnlargeTop ); + + if ( nEnlargeBottom > 0 ) + aRect.AdjustBottom( nEnlargeBottom ); + + // If the ClipRect is identical, nothing will happen + if( m_pOut->IsClipRegion() ) // no && because of Mac + { + if ( aRect == m_pOut->GetClipRegion().GetBoundRect() ) + { + const_cast(rRect) = aOldRect; + return; + } + } + + if( SwRootFrame::HasSameRect( rRect ) ) + m_pOut->SetClipRegion(); + else + { + const vcl::Region aClipRegion( aRect ); + m_pOut->SetClipRegion( aClipRegion ); + } + } + m_bChg = true; + + const_cast(rRect) = aOldRect; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/txtpaint.hxx b/sw/source/core/text/txtpaint.hxx new file mode 100644 index 0000000000..1f9700af4c --- /dev/null +++ b/sw/source/core/text/txtpaint.hxx @@ -0,0 +1,126 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include + +class SwRect; // SwSaveClip +class SwTextFrame; + +class SwSaveClip final +{ + vcl::Region m_aClip; + const bool m_bOn; + bool m_bChg; + + VclPtr m_pOut; + void ChgClip_( const SwRect &rRect, const SwTextFrame* pFrame, + bool bEnlargeRect, + sal_Int32 nEnlargeTop, + sal_Int32 nEnlargeBottom ); +public: + explicit SwSaveClip(OutputDevice* pOutDev) + : m_bOn(pOutDev && pOutDev->IsClipRegion()) + , m_bChg(false) + , m_pOut(pOutDev) + { + } + + ~SwSaveClip(); + void ChgClip( const SwRect &rRect, const SwTextFrame* pFrame = nullptr, + bool bEnlargeRect = false, + sal_Int32 nEnlargeTop = 0, + sal_Int32 nEnlargeBottom = 0) + { if( m_pOut ) ChgClip_( rRect, pFrame, + bEnlargeRect, nEnlargeTop, nEnlargeBottom ); } + bool IsOn() const { return m_bOn; } + bool IsChg() const { return m_bChg; } +}; + + +#ifdef DBG_UTIL + +class SwDbgOut +{ +protected: + VclPtr pOut; +public: + inline SwDbgOut( OutputDevice* pOutDev, const bool bOn ); +}; + +class DbgBackColor : public SwDbgOut +{ + Color aOldFillColor; +public: + DbgBackColor( OutputDevice* pOut, const bool bOn ); + ~DbgBackColor(); +}; + +class DbgRect : public SwDbgOut +{ +public: + DbgRect( OutputDevice* pOut, const tools::Rectangle &rRect, + const bool bOn, + Color eColor ); +}; + +inline SwDbgOut::SwDbgOut( OutputDevice* pOutDev, const bool bOn ) + :pOut( bOn ? pOutDev : nullptr ) +{ } + +inline DbgBackColor::DbgBackColor( OutputDevice* pOutDev, const bool bOn ) + :SwDbgOut( pOutDev, bOn ) +{ + if( pOut ) + { + aOldFillColor = pOut->GetFillColor(); + pOut->SetFillColor( COL_RED ); + } +} + +inline DbgBackColor::~DbgBackColor() +{ + if( pOut ) + { + pOut->SetFillColor( aOldFillColor ); + } +} + +inline DbgRect::DbgRect( OutputDevice* pOutDev, const tools::Rectangle &rRect, + const bool bOn, + Color eColor ) + : SwDbgOut( pOutDev, bOn ) +{ + if( pOut ) + { + const Color aColor( eColor ); + Color aLineColor = pOut->GetLineColor(); + pOut->SetLineColor( aColor ); + Color aFillColor = pOut->GetFillColor(); + pOut->SetFillColor( COL_TRANSPARENT ); + pOut->DrawRect( rRect ); + pOut->SetLineColor( aLineColor ); + pOut->SetFillColor( aFillColor ); + } +} + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/txttab.cxx b/sw/source/core/text/txttab.cxx new file mode 100644 index 0000000000..e7141aaec5 --- /dev/null +++ b/sw/source/core/text/txttab.cxx @@ -0,0 +1,663 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include "portab.hxx" +#include "inftxt.hxx" +#include "itrform2.hxx" +#include +#include "porfld.hxx" +#include + +/** + * #i24363# tab stops relative to indent + * + * Return the first tab stop that is > nSearchPos. + * If the tab stop is outside the print area, we + * return 0 if it is not the first tab stop. + */ +const SvxTabStop* SwLineInfo::GetTabStop(const SwTwips nSearchPos, SwTwips& nRight) const +{ + for( sal_uInt16 i = 0; i < m_oRuler->Count(); ++i ) + { + const SvxTabStop &rTabStop = m_oRuler->operator[](i); + if (nRight && rTabStop.GetTabPos() > nRight) + { + // Consider the first tabstop to always be in-bounds. + if (!i) + nRight = rTabStop.GetTabPos(); + return i ? nullptr : &rTabStop; + } + if( rTabStop.GetTabPos() > nSearchPos ) + { + if (!i && !nRight) + nRight = rTabStop.GetTabPos(); + return &rTabStop; + } + } + return nullptr; +} + +sal_uInt16 SwLineInfo::NumberOfTabStops() const +{ + return m_oRuler->Count(); +} + +SwTabPortion *SwTextFormatter::NewTabPortion( SwTextFormatInfo &rInf, bool bAuto ) const +{ + IDocumentSettingAccess const& rIDSA(rInf.GetTextFrame()->GetDoc().getIDocumentSettingAccess()); + const bool bTabOverSpacing = rIDSA.get(DocumentSettingId::TAB_OVER_SPACING); + const bool bTabsRelativeToIndent = rIDSA.get(DocumentSettingId::TABS_RELATIVE_TO_INDENT); + + // Update search location - since Center/Decimal tabstops' width is dependent on the following text. + SwTabPortion* pTmpLastTab = rInf.GetLastTab(); + if (pTmpLastTab && (pTmpLastTab->IsTabCenterPortion() || pTmpLastTab->IsTabDecimalPortion())) + pTmpLastTab->PostFormat(rInf); + + sal_Unicode cFill = 0; + sal_Unicode cDec = 0; + SvxTabAdjust eAdj; + + sal_uInt16 nNewTabPos; + bool bAutoTabStop = true; + { + const bool bRTL = m_pFrame->IsRightToLeft(); + // #i24363# tab stops relative to indent + // nTabLeft: The absolute value, the tab stops are relative to: Tabs origin. + + // #i91133# + const SwTwips nTabLeft = bRTL + ? m_pFrame->getFrameArea().Right() - + ( bTabsRelativeToIndent ? GetTabLeft() : 0 ) + : m_pFrame->getFrameArea().Left() + + ( bTabsRelativeToIndent ? GetTabLeft() : 0 ); + + // The absolute position, where we started the line formatting + SwTwips nLinePos = GetLeftMargin(); + if ( bRTL ) + { + Point aPoint( nLinePos, 0 ); + m_pFrame->SwitchLTRtoRTL( aPoint ); + nLinePos = aPoint.X(); + } + + // The current position, relative to the line start + SwTwips nTabPos = rInf.GetLastTab() ? rInf.GetLastTab()->GetTabPos() : 0; + if( nTabPos < rInf.X() ) + { + nTabPos = rInf.X(); + } + + // The current position in absolute coordinates + const SwTwips nCurrentAbsPos = bRTL ? + nLinePos - nTabPos : + nLinePos + nTabPos; + + SwTwips nMyRight; + if ( m_pFrame->IsVertLR() ) + nMyRight = Left(); + else + nMyRight = Right(); + + if ( m_pFrame->IsVertical() ) + { + Point aRightTop( nMyRight, m_pFrame->getFrameArea().Top() ); + m_pFrame->SwitchHorizontalToVertical( aRightTop ); + nMyRight = aRightTop.Y(); + } + + SwTwips nNextPos = 0; + bool bAbsoluteNextPos = false; + + // #i24363# tab stops relative to indent + // nSearchPos: The current position relative to the tabs origin + const SwTwips nSearchPos = bRTL ? + nTabLeft - nCurrentAbsPos : + nCurrentAbsPos - nTabLeft; + + // First, we examine the tab stops set at the paragraph style or + // any hard set tab stops: + // Note: If there are no user defined tab stops, there is always a + // default tab stop. + const SwTwips nOldRight = nMyRight; + // Accept left-tabstops beyond the paragraph margin for bTabOverSpacing + if (bTabOverSpacing) + nMyRight = 0; + const SvxTabStop* pTabStop = m_aLineInf.GetTabStop( nSearchPos, nMyRight ); + if (!nMyRight) + nMyRight = nOldRight; + if (pTabStop) + { + cFill = ' ' != pTabStop->GetFill() ? pTabStop->GetFill() : 0; + cDec = pTabStop->GetDecimal(); + eAdj = pTabStop->GetAdjustment(); + nNextPos = pTabStop->GetTabPos(); + if(!bTabsRelativeToIndent && eAdj == SvxTabAdjust::Default && nSearchPos < 0) + { + //calculate default tab position of default tabs in negative indent + nNextPos = ( nSearchPos / nNextPos ) * nNextPos; + } + else if (pTabStop->GetTabPos() > nMyRight + && pTabStop->GetAdjustment() != SvxTabAdjust::Left) + { + // A rather special situation. The tabstop found is: + // 1.) in a document compatible with MS formats + // 2.) not a left tabstop. + // 3.) not the first tabstop (in that case nMyRight was adjusted to match tabPos). + // 4.) beyond the end of the text area + // Therefore, they act like right-tabstops at the edge of the para area. + // This benefits DOCX 2013+, and doesn't hurt the earlier formats, + // since up till now these were just treated as automatic tabstops. + eAdj = SvxTabAdjust::Right; + bAbsoluteNextPos = true; + nNextPos = rInf.Width(); + } + bAutoTabStop = false; + } + else + { + sal_uInt16 nDefTabDist = m_aLineInf.GetDefTabStop(); + if( USHRT_MAX == nDefTabDist ) + { + const SvxTabStopItem& rTab = + m_pFrame->GetAttrSet()->GetPool()->GetDefaultItem( RES_PARATR_TABSTOP ); + if( rTab.Count() ) + nDefTabDist = o3tl::narrowing(rTab[0].GetTabPos()); + else + nDefTabDist = SVX_TAB_DEFDIST; + m_aLineInf.SetDefTabStop( nDefTabDist ); + } + SwTwips nCount = nSearchPos; + + // Minimum tab stop width is 1 + if (nDefTabDist <= 0) + nDefTabDist = 1; + + nCount /= nDefTabDist; + nNextPos = ( nCount < 0 || ( !nCount && nSearchPos <= 0 ) ) + ? ( nCount * nDefTabDist ) + : ( ( nCount + 1 ) * nDefTabDist ); + + // --> FME 2004-09-21 #117919 Minimum tab stop width is 1 or 51 twips: + const SwTwips nMinimumTabWidth = m_pFrame->GetDoc().getIDocumentSettingAccess().get(DocumentSettingId::TAB_COMPAT) ? 0 : 50; + if( ( bRTL && nTabLeft - nNextPos >= nCurrentAbsPos - nMinimumTabWidth ) || + ( !bRTL && nNextPos + nTabLeft <= nCurrentAbsPos + nMinimumTabWidth ) ) + { + nNextPos += nDefTabDist; + } + cFill = 0; + eAdj = SvxTabAdjust::Left; + } + + // #i115705# - correction and refactoring: + // overrule determined next tab stop position in order to apply + // a tab stop at the left margin under the following conditions: + // - the new tab portion is inside the hanging indent + // - a tab stop at the left margin is allowed + // - the determined next tab stop is a default tab stop position OR + // the determined next tab stop is beyond the left margin + { + tools::Long nLeftMarginTabPos = 0; + { + if ( !bTabsRelativeToIndent ) + { + if ( bRTL ) + { + Point aPoint( Left(), 0 ); + m_pFrame->SwitchLTRtoRTL( aPoint ); + nLeftMarginTabPos = m_pFrame->getFrameArea().Right() - aPoint.X(); + } + else + { + nLeftMarginTabPos = Left() - m_pFrame->getFrameArea().Left(); + } + } + if( m_pCurr->HasForcedLeftMargin() ) + { + SwLinePortion* pPor = m_pCurr->GetNextPortion(); + while( pPor && !pPor->IsFlyPortion() ) + { + pPor = pPor->GetNextPortion(); + } + if ( pPor ) + { + nLeftMarginTabPos += pPor->Width(); + } + } + } + const bool bNewTabPortionInsideHangingIndent = + bRTL ? nCurrentAbsPos > nTabLeft - nLeftMarginTabPos + : nCurrentAbsPos < nTabLeft + nLeftMarginTabPos; + if ( bNewTabPortionInsideHangingIndent ) + { + // If the paragraph is not inside a list having a list tab stop following + // the list label or no further tab stop found in such a paragraph or + // the next tab stop position does not equal the list tab stop, + // a tab stop at the left margin can be applied. If this condition is + // not hold, it is overruled by compatibility option TAB_AT_LEFT_INDENT_FOR_PARA_IN_LIST. + const bool bTabAtLeftMarginAllowed = + ( !m_aLineInf.IsListTabStopIncluded() || + !pTabStop || + nNextPos != m_aLineInf.GetListTabStopPosition() ) || + // compatibility option TAB_AT_LEFT_INDENT_FOR_PARA_IN_LIST: + m_pFrame->GetDoc().getIDocumentSettingAccess(). + get(DocumentSettingId::TAB_AT_LEFT_INDENT_FOR_PARA_IN_LIST); + if ( bTabAtLeftMarginAllowed ) + { + if ( !pTabStop || eAdj == SvxTabAdjust::Default || + ( nNextPos > nLeftMarginTabPos ) ) + { + eAdj = SvxTabAdjust::Default; + cFill = 0; + nNextPos = nLeftMarginTabPos; + } + } + } + } + + if (!bAbsoluteNextPos) + nNextPos += bRTL ? nLinePos - nTabLeft : nTabLeft - nLinePos; + OSL_ENSURE( nNextPos >= 0, "GetTabStop: Don't go back!" ); + nNewTabPos = sal_uInt16(nNextPos); + } + + SwTabPortion *pTabPor = nullptr; + if ( bAuto ) + { + if ( SvxTabAdjust::Decimal == eAdj && + 1 == m_aLineInf.NumberOfTabStops() ) + pTabPor = new SwAutoTabDecimalPortion( nNewTabPos, cDec, cFill ); + } + else + { + switch( eAdj ) + { + case SvxTabAdjust::Right : + { + pTabPor = new SwTabRightPortion( nNewTabPos, cFill ); + break; + } + case SvxTabAdjust::Center : + { + pTabPor = new SwTabCenterPortion( nNewTabPos, cFill ); + break; + } + case SvxTabAdjust::Decimal : + { + pTabPor = new SwTabDecimalPortion( nNewTabPos, cDec, cFill ); + break; + } + default: + { + OSL_ENSURE( SvxTabAdjust::Left == eAdj || SvxTabAdjust::Default == eAdj, + "+SwTextFormatter::NewTabPortion: unknown adjustment" ); + pTabPor = new SwTabLeftPortion( nNewTabPos, cFill, bAutoTabStop ); + break; + } + } + } + if (pTabPor) + rInf.UpdateTabSeen(pTabPor->GetWhichPor()); + + return pTabPor; +} + +/** + * The base class is initialized without setting anything + */ +SwTabPortion::SwTabPortion( const sal_uInt16 nTabPosition, const sal_Unicode cFillChar, const bool bAutoTab ) + : m_nTabPos(nTabPosition), m_cFill(cFillChar), m_bAutoTabStop( bAutoTab ) +{ + mnLineLength = TextFrameIndex(1); + OSL_ENSURE(!IsFilled() || ' ' != m_cFill, "SwTabPortion::CTOR: blanks ?!"); + SetWhichPor( PortionType::Tab ); +} + +bool SwTabPortion::Format( SwTextFormatInfo &rInf ) +{ + SwTabPortion *pLastTab = rInf.GetLastTab(); + if( pLastTab == this ) + return PostFormat( rInf ); + if( pLastTab ) + pLastTab->PostFormat( rInf ); + return PreFormat( rInf ); +} + +void SwTabPortion::FormatEOL( SwTextFormatInfo &rInf ) +{ + if( rInf.GetLastTab() == this ) + PostFormat( rInf ); +} + +bool SwTabPortion::PreFormat( SwTextFormatInfo &rInf ) +{ + OSL_ENSURE( rInf.X() <= GetTabPos(), "SwTabPortion::PreFormat: rush hour" ); + + // Here we settle down ... + SetFix( o3tl::narrowing(rInf.X()) ); + + IDocumentSettingAccess const& rIDSA(rInf.GetTextFrame()->GetDoc().getIDocumentSettingAccess()); + const bool bTabCompat = rIDSA.get(DocumentSettingId::TAB_COMPAT); + const bool bTabOverflow = rIDSA.get(DocumentSettingId::TAB_OVERFLOW); + const bool bTabOverMargin = rIDSA.get(DocumentSettingId::TAB_OVER_MARGIN); + const bool bTabOverSpacing = rIDSA.get(DocumentSettingId::TAB_OVER_SPACING); + const sal_Int32 nTextFrameWidth = rInf.GetTextFrame()->getFrameArea().Width(); + + // The minimal width of a tab is one blank at least. + // #i37686# In compatibility mode, the minimum width + // should be 1, even for non-left tab stops. + sal_uInt16 nMinimumTabWidth = 1; + if ( !bTabCompat ) + { + // #i89179# + // tab portion representing the list tab of a list label gets the + // same font as the corresponding number portion + std::optional< SwFontSave > oSave; + if ( GetLen() == TextFrameIndex(0) && + rInf.GetLast() && rInf.GetLast()->InNumberGrp() && + static_cast(rInf.GetLast())->HasFont() ) + { + const SwFont* pNumberPortionFont = + static_cast(rInf.GetLast())->GetFont(); + oSave.emplace( rInf, const_cast(pNumberPortionFont) ); + } + OUString aTmp( ' ' ); + SwTextSizeInfo aInf( rInf, &aTmp ); + nMinimumTabWidth = aInf.GetTextSize().Width(); + } + PrtWidth( nMinimumTabWidth ); + + // Break tab stop to next line if: + // 1. Minimal width does not fit to line anymore. + // 2. An underflow event was called for the tab portion. + bool bFull = ( bTabCompat && rInf.IsUnderflow() ) || + ( rInf.Width() <= rInf.X() + PrtWidth() && rInf.X() <= rInf.Width() ) ; + + // #95477# Rotated tab stops get the width of one blank + const Degree10 nDir = rInf.GetFont()->GetOrientation( rInf.GetTextFrame()->IsVertical() ); + + if( ! bFull && 0_deg10 == nDir ) + { + const PortionType nWhich = GetWhichPor(); + switch( nWhich ) + { + case PortionType::TabRight: + case PortionType::TabDecimal: + case PortionType::TabCenter: + { + if( PortionType::TabDecimal == nWhich ) + rInf.SetTabDecimal( + static_cast(this)->GetTabDecimal()); + rInf.SetLastTab( this ); + break; + } + case PortionType::TabLeft: + { + // handle this case in PostFormat + if ((bTabOverMargin || bTabOverSpacing) && GetTabPos() > rInf.Width() + && (!m_bAutoTabStop || (!bTabOverMargin && rInf.X() > rInf.Width()))) + { + if (bTabOverMargin || GetTabPos() < nTextFrameWidth) + { + rInf.SetLastTab(this); + break; + } + else + { + assert(!bTabOverMargin && bTabOverSpacing && GetTabPos() >= nTextFrameWidth); + bFull = true; + break; + } + } + + PrtWidth( o3tl::narrowing(GetTabPos() - rInf.X()) ); + bFull = rInf.Width() <= rInf.X() + PrtWidth(); + + // In tabulator compatibility mode, we reset the bFull flag + // if the tabulator is at the end of the paragraph and the + // tab stop position is outside the frame: + bool bAtParaEnd = rInf.GetIdx() + GetLen() == TextFrameIndex(rInf.GetText().getLength()); + if ( bFull && bTabCompat && + ( ( bTabOverflow && ( rInf.IsTabOverflow() || !m_bAutoTabStop ) ) || bAtParaEnd ) && + GetTabPos() >= nTextFrameWidth) + { + bFull = false; + if ( bTabOverflow && !m_bAutoTabStop ) + rInf.SetTabOverflow( true ); + } + + break; + } + default: OSL_ENSURE( false, "SwTabPortion::PreFormat: unknown adjustment" ); + } + } + + if( bFull ) + { + // We have to look for endless loops, if the width is smaller than one blank + if( rInf.GetIdx() == rInf.GetLineStart() && + // #119175# TabStop should be forced to current + // line if there is a fly reducing the line width: + !rInf.GetFly() ) + { + PrtWidth( o3tl::narrowing(rInf.Width() - rInf.X()) ); + SetFixWidth( PrtWidth() ); + } + else + { + Height( 0 ); + Width( 0 ); + SetLen( TextFrameIndex(0) ); + SetAscent( 0 ); + SetNextPortion( nullptr ); //????? + } + return true; + } + else + { + // A trick with impact: The new Tabportions now behave like + // FlyFrames, located in the line - including adjustment ! + SetFixWidth( PrtWidth() ); + return false; + } +} + +bool SwTabPortion::PostFormat( SwTextFormatInfo &rInf ) +{ + bool bTabOverMargin = rInf.GetTextFrame()->GetDoc().getIDocumentSettingAccess().get( + DocumentSettingId::TAB_OVER_MARGIN); + bool bTabOverSpacing = rInf.GetTextFrame()->GetDoc().getIDocumentSettingAccess().get( + DocumentSettingId::TAB_OVER_SPACING); + if (rInf.GetTextFrame()->IsInSct()) + bTabOverMargin = false; + + // If the tab position is larger than the right margin, it gets scaled down by default. + // However, if compat mode enabled, we allow tabs to go over the margin: the rest of the paragraph is not broken into lines. + const sal_uInt16 nRight + = bTabOverMargin + ? GetTabPos() + : bTabOverSpacing + ? std::min(GetTabPos(), rInf.GetTextFrame()->getFrameArea().Right()) + : std::min(GetTabPos(), rInf.Width()); + const SwLinePortion *pPor = GetNextPortion(); + + sal_uInt16 nPorWidth = 0; + while( pPor ) + { + nPorWidth = nPorWidth + pPor->Width(); + pPor = pPor->GetNextPortion(); + } + + const PortionType nWhich = GetWhichPor(); + const bool bTabCompat = rInf.GetTextFrame()->GetDoc().getIDocumentSettingAccess().get(DocumentSettingId::TAB_COMPAT); + + if ((bTabOverMargin || bTabOverSpacing) && PortionType::TabLeft == nWhich) + { + nPorWidth = 0; + } + + // #127428# Abandon dec. tab position if line is full + if ( bTabCompat && PortionType::TabDecimal == nWhich ) + { + sal_uInt16 nPrePorWidth = static_cast(this)->GetWidthOfPortionsUpToDecimalPosition(); + + // no value was set => no decimal character was found + if ( USHRT_MAX != nPrePorWidth ) + { + if ( !bTabOverMargin && nPrePorWidth && nPorWidth - nPrePorWidth > rInf.Width() - nRight ) + { + nPrePorWidth += nPorWidth - nPrePorWidth - ( rInf.Width() - nRight ); + } + + nPorWidth = nPrePorWidth - 1; + } + } + + if( PortionType::TabCenter == nWhich ) + { + // centered tabs are problematic: + // We have to detect how much fits into the line. + sal_uInt16 nNewWidth = nPorWidth /2; + if (!bTabOverMargin && !bTabOverSpacing && nNewWidth > rInf.Width() - nRight) + nNewWidth = nPorWidth - (rInf.Width() - nRight); + nPorWidth = nNewWidth; + } + + const sal_uInt16 nDiffWidth = nRight - GetFix(); + + if( nDiffWidth > nPorWidth ) + { + const sal_uInt16 nOldWidth = GetFixWidth(); + const sal_uInt16 nAdjDiff = nDiffWidth - nPorWidth; + if( nAdjDiff > GetFixWidth() ) + PrtWidth( nAdjDiff ); + // Don't be afraid: we have to move rInf further. + // The right-tab till now only had the width of one blank. + // Now that we stretched, the difference had to be added to rInf.X() ! + rInf.X( rInf.X() + PrtWidth() - nOldWidth ); + } + SetFixWidth( PrtWidth() ); + // reset last values + rInf.SetLastTab(nullptr); + if( PortionType::TabDecimal == nWhich ) + rInf.SetTabDecimal(0); + + return rInf.Width() <= rInf.X(); +} + +/** + * Ex: LineIter::DrawTab() + */ +void SwTabPortion::Paint( const SwTextPaintInfo &rInf ) const +{ + // #i89179# + // tab portion representing the list tab of a list label gets the + // same font as the corresponding number portion + std::optional< SwFontSave > oSave; + bool bAfterNumbering = false; + if (GetLen() == TextFrameIndex(0)) + { + const SwLinePortion* pPrevPortion = + const_cast(this)->FindPrevPortion( rInf.GetParaPortion() ); + if ( pPrevPortion && + pPrevPortion->InNumberGrp() && + static_cast(pPrevPortion)->HasFont() ) + { + const SwFont* pNumberPortionFont = + static_cast(pPrevPortion)->GetFont(); + oSave.emplace( rInf, const_cast(pNumberPortionFont) ); + bAfterNumbering = true; + } + } + rInf.DrawBackBrush( *this ); + if( !bAfterNumbering ) + rInf.DrawBorder( *this ); + + // do we have to repaint a post it portion? + if( rInf.OnWin() && mpNextPortion && !mpNextPortion->Width() ) + mpNextPortion->PrePaint( rInf, this ); + + // display special characters + if( rInf.OnWin() && rInf.GetOpt().IsTab() ) + { + // filled tabs are shaded in gray + if( IsFilled() ) + rInf.DrawViewOpt( *this, PortionType::Tab ); + else + rInf.DrawTab( *this ); + } + + // Tabs should be underlined at once + if( rInf.GetFont()->IsPaintBlank() ) + { + // Tabs with filling/filled tabs + const sal_uInt16 nCharWidth = rInf.GetTextSize(OUString(' ')).Width(); + + // Robust: + if( nCharWidth ) + { + // Always with kerning, also on printer! + sal_uInt16 nChar = Width() / nCharWidth; + OUStringBuffer aBuf(nChar); + comphelper::string::padToLength(aBuf, nChar, ' '); + rInf.DrawText(aBuf.makeStringAndClear(), *this, TextFrameIndex(0), + TextFrameIndex(nChar), true); + } + } + + // Display fill characters + if( !IsFilled() ) + return; + + // Tabs with filling/filled tabs + const sal_uInt16 nCharWidth = rInf.GetTextSize(OUString(m_cFill)).Width(); + OSL_ENSURE( nCharWidth, "!SwTabPortion::Paint: sophisticated tabchar" ); + + // Robust: + if( nCharWidth ) + { + // Always with kerning, also on printer! + sal_uInt16 nChar = Width() / nCharWidth; + if ( m_cFill == '_' ) + ++nChar; // to avoid gaps + OUStringBuffer aBuf(nChar); + comphelper::string::padToLength(aBuf, nChar, m_cFill); + rInf.DrawText(aBuf.makeStringAndClear(), *this, TextFrameIndex(0), + TextFrameIndex(nChar), true); + } +} + +void SwAutoTabDecimalPortion::Paint( const SwTextPaintInfo & ) const +{ +} + +void SwTabPortion::HandlePortion( SwPortionHandler& rPH ) const +{ + rPH.Text( GetLen(), GetWhichPor() ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/widorp.cxx b/sw/source/core/text/widorp.cxx new file mode 100644 index 0000000000..11e4193d7b --- /dev/null +++ b/sw/source/core/text/widorp.cxx @@ -0,0 +1,673 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "widorp.hxx" +#include +#include "itrtxt.hxx" +#include +#include +#include +#include +#include +#include +#include + +#undef WIDOWTWIPS + +namespace +{ + +// A Follow on the same page as its master is nasty. +bool IsNastyFollow( const SwTextFrame *pFrame ) +{ + OSL_ENSURE( !pFrame->IsFollow() || !pFrame->GetPrev() || + static_cast(pFrame->GetPrev())->GetFollow() == pFrame, + "IsNastyFollow: What is going on here?" ); + return pFrame->IsFollow() && pFrame->GetPrev(); +} + +} + +SwTextFrameBreak::SwTextFrameBreak( SwTextFrame *pNewFrame, const SwTwips nRst ) + : m_nRstHeight(nRst), m_pFrame(pNewFrame) +{ + SwSwapIfSwapped swap(m_pFrame); + SwRectFnSet aRectFnSet(m_pFrame); + m_nOrigin = aRectFnSet.GetPrtTop(*m_pFrame); + m_bKeep = !m_pFrame->IsMoveable() || IsNastyFollow( m_pFrame ); + if( !m_bKeep && m_pFrame->IsInSct() ) + { + const SwSectionFrame* const pSct = m_pFrame->FindSctFrame(); + m_bKeep = pSct->Lower()->IsColumnFrame() && !pSct->MoveAllowed( m_pFrame ); + } + m_bKeep = m_bKeep || !m_pFrame->GetTextNodeForParaProps()->GetSwAttrSet().GetSplit().GetValue() || + m_pFrame->GetTextNodeForParaProps()->GetSwAttrSet().GetKeep().GetValue(); + m_bBreak = false; + + if( !m_nRstHeight && !m_pFrame->IsFollow() && m_pFrame->IsInFootnote() && m_pFrame->HasPara() ) + { + m_nRstHeight = m_pFrame->GetFootnoteFrameHeight(); + m_nRstHeight += aRectFnSet.GetHeight(m_pFrame->getFramePrintArea()) - + aRectFnSet.GetHeight(m_pFrame->getFrameArea()); + if( m_nRstHeight < 0 ) + m_nRstHeight = 0; + } +} + +/** + * BP 18.6.93: Widows. + * In contrast to the first implementation the Widows are not calculated + * in advance but detected when formatting the split Follow. + * In Master the Widows-calculation is dropped completely + * (nWidows is manipulated). If the Follow detects that the + * Widows rule applies it sends a Prepare to its predecessor. + * A special problem is when the Widow rule applies but in Master + * there are some lines available. + * + * BP(22.07.92): Calculation of Widows and Orphans. + * The method returns true if one of the rules matches. + * + * One difficulty with Widows and different formats between + * Master- and Follow-Frame: + * Example: If the first column is 3cm and the second is 4cm and + * Widows is set to 3, the decision if the Widows rule matches can not + * be done until the Follow is formatted. Unfortunately this is crucial + * to decide if the whole paragraph goes to the next page or not. + */ +bool SwTextFrameBreak::IsInside( SwTextMargin const &rLine ) const +{ + bool bFit = false; + + SwSwapIfSwapped swap(m_pFrame); + SwRectFnSet aRectFnSet(m_pFrame); + // nOrigin is an absolute value, rLine refers to the swapped situation. + + SwTwips nTmpY; + if ( m_pFrame->IsVertical() ) + nTmpY = m_pFrame->SwitchHorizontalToVertical( rLine.Y() + rLine.GetLineHeight() ); + else + nTmpY = rLine.Y() + rLine.GetLineHeight(); + + SwTwips nLineHeight = aRectFnSet.YDiff( nTmpY , m_nOrigin ); + + // Calculate extra space for bottom border. + nLineHeight += aRectFnSet.GetBottomMargin(*m_pFrame); + + if( m_nRstHeight ) + bFit = m_nRstHeight >= nLineHeight; + else + { + // The Frame has a height to fit on the page. + SwTwips nHeight = + aRectFnSet.YDiff( aRectFnSet.GetPrtBottom(*m_pFrame->GetUpper()), m_nOrigin ); + SwTwips nDiff = nHeight - nLineHeight; + + // Hide whitespace may require not to insert a new page. + SwPageFrame* pPageFrame = m_pFrame->FindPageFrame(); + if (!pPageFrame->CheckPageHeightValidForHideWhitespace(nDiff)) + nDiff = 0; + + // If everything is inside the existing frame the result is true; + bFit = nDiff >= 0; + + // If it didn't fit, try to add the space of footnotes that are anchored + // in frames below (in next-chain of) this one as they will need to move + // forward anyway if this frame is split. + // - except if in tables (need to check if row is splittable? + // also, multiple columns looks difficult) + if (!bFit && !m_pFrame->IsInTab()) + { + if (SwFootnoteBossFrame const*const pBoss = m_pFrame->FindFootnoteBossFrame()) + { + if (SwFootnoteContFrame const*const pCont = pBoss->FindFootnoteCont()) + { + SwContentFrame const* pContent(m_pFrame); + while (pContent->HasFollow()) + { + pContent = pContent->GetFollow(); + } + // start with first text frame that isn't a follow + // (ignoring Keep attribute for now, MakeAll should handle it?) + pContent = pContent->GetNextContentFrame(); + ::std::set nextFrames; + while (pBoss->IsAnLower(pContent)) + { + nextFrames.insert(pContent); + pContent = pContent->GetNextContentFrame(); + } + SwTwips nNextFootnotes(0); + for (SwFootnoteFrame const* pFootnote = static_cast(pCont->Lower()); + pFootnote != nullptr; + pFootnote = static_cast(pFootnote->GetNext())) + { + SwContentFrame const*const pAnchor = pFootnote->GetRef(); + if (nextFrames.find(pAnchor) != nextFrames.end()) + { + nNextFootnotes += aRectFnSet.GetHeight(pFootnote->getFrameArea()); + } + } + bFit = 0 <= nDiff + nNextFootnotes; + SAL_INFO_IF(bFit, "sw.core", "no text frame break because ignoring " + << nNextFootnotes << " footnote height"); + } + } + } + if (!bFit && rLine.MaybeHasHints() && m_pFrame->GetFollow() + // tdf#153319 RemoveFootnote only works if this frame doesn't + && !rLine.GetNext() // contain the footnote portion + // if using same footnote container as the follow, pointless to try? + && m_pFrame->FindFootnoteBossFrame() != m_pFrame->GetFollow()->FindFootnoteBossFrame()) + { + // possibly a footnote that is anchored beyond the end of this + // (the last) line is in the way, try to remove it and check again + m_pFrame->RemoveFootnote(rLine.GetEnd()); + nHeight = aRectFnSet.YDiff( aRectFnSet.GetPrtBottom(*m_pFrame->GetUpper()), m_nOrigin ); + bFit = nHeight >= nLineHeight; + } + if ( !bFit ) + { + if ( rLine.GetNext() && + m_pFrame->IsInTab() && !m_pFrame->GetFollow() && !m_pFrame->GetIndNext() ) + { + // add additional space taken as lower space as last content in a table + // for all text lines except the last one. + nHeight += m_pFrame->CalcAddLowerSpaceAsLastInTableCell(); + bFit = nHeight >= nLineHeight; + } + } + if( !bFit ) + { + // The LineHeight exceeds the current Frame height. + // Call a test Grow to detect if the Frame could + // grow the requested area. + nHeight += m_pFrame->GrowTst( LONG_MAX ); + + // The Grow() returns the height by which the Upper of the TextFrame + // would let the TextFrame grow. + // The TextFrame itself can grow as much as it wants. + bFit = nHeight >= nLineHeight; + } + } + + return bFit; +} + +bool SwTextFrameBreak::IsBreakNow( SwTextMargin &rLine ) +{ + SwSwapIfSwapped swap(m_pFrame); + + // bKeep is stronger than IsBreakNow() + // Is there enough space ? + if( m_bKeep || IsInside( rLine ) ) + m_bBreak = false; + else + { + /* This class assumes that the SwTextMargin is processed from Top to + * Bottom. Because of performance reasons we stop splitting in the + * following cases: + * If only one line does not fit. + * Special case: with DummyPortions there is LineNr == 1, though we + * want to split. + */ + // Include DropLines + + bool bFirstLine = 1 == rLine.GetLineNr() && !rLine.GetPrev(); + m_bBreak = true; + + if (bFirstLine && m_pFrame->IsEmptyWithSplitFly()) + { + // Not really the first line, visually we may have a previous line (including the fly + // frame) already. + bFirstLine = false; + } + + if( ( bFirstLine && m_pFrame->GetIndPrev() ) + || ( rLine.GetLineNr() <= rLine.GetDropLines() ) ) + { + m_bKeep = true; + m_bBreak = false; + } + else if(bFirstLine && m_pFrame->IsInFootnote() && !m_pFrame->FindFootnoteFrame()->GetPrev()) + { + SwLayoutFrame* pTmp = m_pFrame->FindFootnoteBossFrame()->FindBodyCont(); + if( !pTmp || !pTmp->Lower() ) + m_bBreak = false; + } + } + + return m_bBreak; +} + +void SwTextFrameBreak::SetRstHeight( const SwTextMargin &rLine ) +{ + // Consider bottom margin + SwRectFnSet aRectFnSet(m_pFrame); + + m_nRstHeight = aRectFnSet.GetBottomMargin(*m_pFrame); + + if ( aRectFnSet.IsVert() ) + { + if ( m_pFrame->IsVertLR() ) + m_nRstHeight = aRectFnSet.YDiff( m_pFrame->SwitchHorizontalToVertical( rLine.Y() ) , m_nOrigin ); + else + m_nRstHeight += m_nOrigin - m_pFrame->SwitchHorizontalToVertical( rLine.Y() ); + } + else + m_nRstHeight += rLine.Y() - m_nOrigin; +} + +WidowsAndOrphans::WidowsAndOrphans( SwTextFrame *pNewFrame, const SwTwips nRst, + bool bChkKeep ) + : SwTextFrameBreak( pNewFrame, nRst ), m_nWidLines( 0 ), m_nOrphLines( 0 ) +{ + SwSwapIfSwapped swap(m_pFrame); + + if( m_bKeep ) + { + // If paragraph should not be split but is larger than + // the page, then bKeep is overruled. + if( bChkKeep && !m_pFrame->GetPrev() && !m_pFrame->IsInFootnote() && + m_pFrame->IsMoveable() && + ( !m_pFrame->IsInSct() || m_pFrame->FindSctFrame()->MoveAllowed(m_pFrame) ) ) + m_bKeep = false; + // Even if Keep is set, Orphans has to be respected. + // e.g. if there are chained frames where a Follow in the last frame + // receives a Keep, because it is not (forward) movable - + // nevertheless the paragraph can request lines from the Master + // because of the Orphan rule. + if( m_pFrame->IsFollow() ) + m_nWidLines = m_pFrame->GetTextNodeForParaProps()->GetSwAttrSet().GetWidows().GetValue(); + } + else + { + const SwAttrSet& rSet = m_pFrame->GetTextNodeForParaProps()->GetSwAttrSet(); + const SvxOrphansItem &rOrph = rSet.GetOrphans(); + if ( rOrph.GetValue() > 1 ) + m_nOrphLines = rOrph.GetValue(); + if ( m_pFrame->IsFollow() ) + m_nWidLines = rSet.GetWidows().GetValue(); + + } + + if ( !(m_bKeep || m_nWidLines || m_nOrphLines) ) + return; + + bool bResetFlags = false; + + bool bWordTableCell = false; + if (m_pFrame->IsInFly()) + { + // Enable widow / orphan control in Word-style table cells in split rows, at least inside + // flys. + const SwDoc& rDoc = m_pFrame->GetTextNodeForParaProps()->GetDoc(); + const IDocumentSettingAccess& rIDSA = rDoc.getIDocumentSettingAccess(); + bWordTableCell = rIDSA.get(DocumentSettingId::TABLE_ROW_KEEP); + } + + if ( m_pFrame->IsInTab() && !bWordTableCell ) + { + // For compatibility reasons, we disable Keep/Widows/Orphans + // inside splittable row frames: + if ( m_pFrame->GetNextCellLeaf() || m_pFrame->IsInFollowFlowRow() ) + { + const SwFrame* pTmpFrame = m_pFrame->GetUpper(); + while ( !pTmpFrame->IsRowFrame() ) + pTmpFrame = pTmpFrame->GetUpper(); + if ( static_cast(pTmpFrame)->IsRowSplitAllowed() ) + bResetFlags = true; + } + } + + if( m_pFrame->IsInFootnote() && !m_pFrame->GetIndPrev() ) + { + // Inside of footnotes there are good reasons to turn off the Keep attribute + // as well as Widows/Orphans. + SwFootnoteFrame *pFootnote = m_pFrame->FindFootnoteFrame(); + const bool bFt = !pFootnote->GetAttr()->GetFootnote().IsEndNote(); + if( !pFootnote->GetPrev() && + pFootnote->FindFootnoteBossFrame( bFt ) != pFootnote->GetRef()->FindFootnoteBossFrame( bFt ) + && ( !m_pFrame->IsInSct() || m_pFrame->FindSctFrame()->MoveAllowed(m_pFrame) ) ) + { + bResetFlags = true; + } + } + + if ( bResetFlags ) + { + m_bKeep = false; + m_nOrphLines = 0; + m_nWidLines = 0; + } +} + +/** + * The Find*-Methods do not only search, but adjust the SwTextMargin to the + * line where the paragraph should have a break and truncate the paragraph there. + * FindBreak() + */ +bool WidowsAndOrphans::FindBreak( SwTextFrame *pFrame, SwTextMargin &rLine, + bool bHasToFit ) +{ + // i#16128 - Why member _*and*_ parameter ?? + // Thus, assertion on situation, that these are different to figure out why. + OSL_ENSURE( m_pFrame == pFrame, " - pFrame != pFrame" ); + + SwSwapIfSwapped swap(m_pFrame); + + bool bRet = true; + sal_uInt16 nOldOrphans = m_nOrphLines; + if( bHasToFit ) + m_nOrphLines = 0; + rLine.Bottom(); + + if( !IsBreakNowWidAndOrp( rLine ) ) + bRet = false; + if( !FindWidows( pFrame, rLine ) ) + { + bool bBack = false; + + while( IsBreakNowWidAndOrp( rLine ) ) + { + if( rLine.PrevLine() ) + bBack = true; + else + break; + } + // Usually Orphans are not taken into account for HasToFit. + // But if Dummy-Lines are concerned and the Orphans rule is violated + // we make an exception: We leave behind one Dummyline and take + // the whole text to the next page/column. + if( rLine.GetLineNr() <= nOldOrphans && + rLine.GetInfo().GetParaPortion()->IsDummy() && + ( ( bHasToFit && bRet ) || IsBreakNow( rLine ) ) ) + rLine.Top(); + + rLine.TruncLines( true ); + bRet = bBack; + } + m_nOrphLines = nOldOrphans; + + return bRet; +} + +/** + * FindWidows positions the SwTextMargin of the Master to the line where to + * break by examining and formatting the Follow. + * Returns true if the Widows-rule matches, that means that the + * paragraph should not be split (keep) ! + */ +bool WidowsAndOrphans::FindWidows( SwTextFrame *pFrame, SwTextMargin &rLine ) +{ + OSL_ENSURE( ! pFrame->IsVertical() || ! pFrame->IsSwapped(), + "WidowsAndOrphans::FindWidows with swapped frame" ); + + if( !m_nWidLines || !pFrame->IsFollow() ) + return false; + + rLine.Bottom(); + + // We can still cut something off + SwTextFrame *pMaster = pFrame->FindMaster(); + OSL_ENSURE(pMaster, "+WidowsAndOrphans::FindWidows: Widows in a master?"); + if( !pMaster ) + return false; + + // If the first line of the Follow does not fit, the master + // probably is full of Dummies. In this case a PrepareHint::Widows would be fatal. + if( pMaster->GetOffset() == pFrame->GetOffset() ) + return false; + + // Remaining height of the master + SwRectFnSet aRectFnSet(pFrame); + + const SwTwips nDocPrtTop = aRectFnSet.GetPrtTop(*pFrame); + SwTwips nOldHeight; + SwTwips nTmpY = rLine.Y() + rLine.GetLineHeight(); + + if ( aRectFnSet.IsVert() ) + { + nTmpY = pFrame->SwitchHorizontalToVertical( nTmpY ); + nOldHeight = -aRectFnSet.GetHeight(pFrame->getFramePrintArea()); + } + else + nOldHeight = aRectFnSet.GetHeight(pFrame->getFramePrintArea()); + + const SwTwips nChg = aRectFnSet.YDiff( nTmpY, nDocPrtTop + nOldHeight ); + + // below the Widows-threshold... + if( rLine.GetLineNr() >= m_nWidLines ) + { + // Follow to Master I + // If the Follow *grows*, there is the chance for the Master to + // receive lines, that it was forced to hand over to the Follow lately: + // Prepare(Need); check that below nChg! + // (0W, 2O, 2M, 2F) + 1F = 3M, 2F + if( rLine.GetLineNr() > m_nWidLines && pFrame->IsJustWidow() ) + { + // If the Master is locked, it has probably just donated a line + // to us, we don't return that just because we turned it into + // multiple lines (e.g. via frames). + if( !pMaster->IsLocked() && pMaster->GetUpper() ) + { + const SwTwips nTmpRstHeight = aRectFnSet.BottomDist( pMaster->getFrameArea(), + aRectFnSet.GetPrtBottom(*pMaster->GetUpper()) ); + if ( nTmpRstHeight >= + rLine.GetInfo().GetParaPortion()->Height() ) + { + pMaster->Prepare( PrepareHint::AdjustSizeWithoutFormatting ); + pMaster->InvalidateSize_(); + pMaster->InvalidatePage(); + } + } + + pFrame->SetJustWidow( false ); + } + return false; + } + + // Follow to Master II + // If the Follow *shrinks*, maybe the Master can absorb the whole Orphan. + // (0W, 2O, 2M, 1F) - 1F = 3M, 0F -> PrepareHint::AdjustSizeWithoutFormatting + // (0W, 2O, 3M, 2F) - 1F = 2M, 2F -> PrepareHint::Widows + + if( 0 > nChg && !pMaster->IsLocked() && pMaster->GetUpper() ) + { + SwTwips nTmpRstHeight = aRectFnSet.BottomDist( pMaster->getFrameArea(), + aRectFnSet.GetPrtBottom(*pMaster->GetUpper()) ); + if( nTmpRstHeight >= rLine.GetInfo().GetParaPortion()->Height() ) + { + pMaster->Prepare( PrepareHint::AdjustSizeWithoutFormatting ); + pMaster->InvalidateSize_(); + pMaster->InvalidatePage(); + pFrame->SetJustWidow( false ); + return false; + } + } + + // Master to Follow + // If the Follow contains fewer lines than Widows after formatting, + // we still can move over some lines from the Master. If this triggers + // the Orphans rule of the Master, the Master frame must be Grow()n + // in its CalcPreps(), such that it won't fit onto its page anymore. + // But if the Master Frame can still lose a few lines, we need to + // do a Shrink() in the CalcPreps(); the Follow with the Widows then + // moves onto the page of the Master, but remains unsplit, so that + // it (finally) moves onto the next page. So much for the theory! + // + // We only request one line at a time for now, because a Master's line + // could result in multiple lines for us. + // Therefore, the CalcFollow() remains in control until the Follow got all + // necessary lines. + sal_Int32 nNeed = 1; // was: nWidLines - rLine.GetLineNr(); + + // Special case: Master cannot give lines to follow + // i#91421 + if ( !pMaster->GetIndPrev() ) + { + pMaster->ChgThisLines(); + sal_Int32 nLines = pMaster->GetThisLines(); + if(nLines == 0 && pMaster->HasPara()) + { + const SwParaPortion *pMasterPara = pMaster->GetPara(); + if(pMasterPara && pMasterPara->GetNext()) + nLines = 2; + } + if( nLines <= nNeed ) + return false; + + if (pFrame->IsInTab()) + { + const SwFrame* pRow = pFrame; + while (pRow && !pRow->IsRowFrame()) + { + pRow = pRow->GetUpper(); + } + + if (pRow && pRow->HasFixSize()) + { + // This is a follow frame and our side is fixed. + const SwAttrSet& rSet = pFrame->GetTextNodeForParaProps()->GetSwAttrSet(); + const SvxOrphansItem& rOrph = rSet.GetOrphans(); + if (nLines <= static_cast(rOrph.GetValue())) + { + // If the master gives us a line as part of widow control, then its orphan + // control will move everything to the follow, which is worse than having no + // widow / orphan control at all. Don't send a Widows prepare hint, in this + // case. + return true; + } + } + } + } + + pMaster->Prepare( PrepareHint::Widows, static_cast(&nNeed) ); + return true; +} + +namespace sw { + +auto FindNonFlyPortion(SwLineLayout const& rLine) -> bool +{ + for (SwLinePortion const* pPortion = rLine.GetFirstPortion(); + pPortion; pPortion = pPortion->GetNextPortion()) + { + switch (pPortion->GetWhichPor()) + { + case PortionType::Fly: + case PortionType::Glue: + case PortionType::Margin: + break; + default: + { + return true; + } + } + } + return false; +}; + +} // namespace sw + +bool WidowsAndOrphans::WouldFit( SwTextMargin &rLine, SwTwips &rMaxHeight, bool bTst, bool bMoveBwd ) +{ + // Here it does not matter, if pFrame is swapped or not. + // IsInside() takes care of itself + + // We expect that rLine is set to the last line + OSL_ENSURE( !rLine.GetNext(), "WouldFit: aLine::Bottom missed!" ); + sal_Int32 nLineCnt = rLine.GetLineNr(); + + // First satisfy the Orphans-rule and the wish for initials ... + const sal_uInt16 nMinLines = std::max( GetOrphansLines(), rLine.GetDropLines() ); + if ( nLineCnt < nMinLines ) + return false; + + rLine.Top(); + SwTwips nLineSum = rLine.GetLineHeight(); + + // tdf#146500 for MoveBwd(), want at least 1 line with non-fly + bool hasNonFly(!bMoveBwd); + if (!hasNonFly) + { + hasNonFly = ::sw::FindNonFlyPortion(*rLine.GetCurr()); + } + while (nMinLines > rLine.GetLineNr() || !hasNonFly) + { + if( !rLine.NextLine() ) + { + if (nMinLines > rLine.GetLineNr()) + return false; + else + break; + } + nLineSum += rLine.GetLineHeight(); + if (!hasNonFly) + { + hasNonFly = ::sw::FindNonFlyPortion(*rLine.GetCurr()); + } + } + + // We do not fit + if( !IsInside( rLine ) ) + return false; + + // Check the Widows-rule + if( !m_nWidLines && !m_pFrame->IsFollow() ) + { + // Usually we only have to check for Widows if we are a Follow. + // On WouldFit the rule has to be checked for the Master too, + // because we are just in the middle of calculating the break. + // In Ctor of WidowsAndOrphans the nWidLines are only calced for + // Follows from the AttrSet - so we catch up now: + const SwAttrSet& rSet = m_pFrame->GetTextNodeForParaProps()->GetSwAttrSet(); + m_nWidLines = rSet.GetWidows().GetValue(); + } + + // After Orphans/Initials, do enough lines remain for Widows? + // If we are currently doing a test formatting, we may not + // consider the widows rule for two reasons: + // 1. The columns may have different widths. + // Widow lines would have wrong width. + // 2. Test formatting is only done up to the given space. + // we do not have any lines for widows at all. + if( bTst || nLineCnt - nMinLines >= m_nWidLines ) + { + if( rMaxHeight >= nLineSum ) + { + rMaxHeight -= nLineSum; + return true; + } + } + return false; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/widorp.hxx b/sw/source/core/text/widorp.hxx new file mode 100644 index 0000000000..996a7fc913 --- /dev/null +++ b/sw/source/core/text/widorp.hxx @@ -0,0 +1,88 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#pragma once + +#include +#include "itrtxt.hxx" + +class SwTextFrame; + +class SwTextFrameBreak +{ +private: + SwTwips m_nRstHeight; + SwTwips m_nOrigin; +protected: + SwTextFrame *m_pFrame; + bool m_bBreak; + bool m_bKeep; +public: + SwTextFrameBreak( SwTextFrame *pFrame, const SwTwips nRst = 0 ); + bool IsBreakNow( SwTextMargin &rLine ); + bool IsKeepAlways() const { return m_bKeep; } + + void SetKeep( const bool bNew ) { m_bKeep = bNew; } + + bool IsInside( SwTextMargin const &rLine ) const; + + // In order to be able to handle special cases with Footnote. + // SetRstHeight sets the rest height for SwTextFrameBreak. This is needed + // to call TruncLines() without IsBreakNow() returning another value. + // We assume that rLine is pointing to the last non-fitting line. + + void SetRstHeight( const SwTextMargin &rLine ); +}; + +class WidowsAndOrphans : public SwTextFrameBreak +{ +private: + sal_uInt16 m_nWidLines, m_nOrphLines; + +public: + WidowsAndOrphans( SwTextFrame *pFrame, const SwTwips nRst = 0, + bool bCheckKeep = true ); + bool FindWidows( SwTextFrame *pFrame, SwTextMargin &rLine ); + sal_uInt16 GetOrphansLines() const + { return m_nOrphLines; } + void ClrOrphLines(){ m_nOrphLines = 0; } + + bool FindBreak( SwTextFrame *pFrame, SwTextMargin &rLine, bool bHasToFit ); + bool WouldFit( SwTextMargin &rLine, SwTwips &rMaxHeight, bool bTest, bool bMoveBwd ); + // i#16128 - This method is named this way to avoid confusion with + // base class method , which isn't virtual. + bool IsBreakNowWidAndOrp( SwTextMargin &rLine ) + { + bool isOnFirstLine = (rLine.GetLineNr() == 1 && !rLine.GetPrev()); + if ( isOnFirstLine && rLine.GetCurr()->IsDummy()) { + return IsBreakNow( rLine ); + } + if ( rLine.GetLineNr() > m_nOrphLines ) { + return IsBreakNow( rLine ); + } + return false; + } +}; + +namespace sw { + +auto FindNonFlyPortion(SwLineLayout const& rLine) -> bool; + +} // namespace sw + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/wrong.cxx b/sw/source/core/text/wrong.cxx new file mode 100644 index 0000000000..00be8d5fac --- /dev/null +++ b/sw/source/core/text/wrong.cxx @@ -0,0 +1,938 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include + +#include +#include +#include +#include + +#include + +SwWrongArea::SwWrongArea( OUString aType, WrongListType listType, + css::uno::Reference< css::container::XStringKeyMap > const & xPropertyBag, + sal_Int32 nPos, + sal_Int32 nLen) +: maType(std::move(aType)), mxPropertyBag(xPropertyBag), mnPos(nPos), mnLen(nLen), mpSubList(nullptr) +{ + mColor = getWrongAreaColor(listType, xPropertyBag); + mLineType = getWrongAreaLineType(listType, xPropertyBag); +} + +SwWrongArea::SwWrongArea( OUString aType, + css::uno::Reference< css::container::XStringKeyMap > const & xPropertyBag, + sal_Int32 nPos, + sal_Int32 nLen, + SwWrongList* pSubList) +: maType(std::move(aType)), mxPropertyBag(xPropertyBag), mnPos(nPos), mnLen(nLen), mpSubList(pSubList), mLineType(WRONGAREA_NONE) +{ + if (pSubList != nullptr) + { + mColor = getWrongAreaColor(pSubList->GetWrongListType(), xPropertyBag); + mLineType = getWrongAreaLineType(pSubList->GetWrongListType(), xPropertyBag); + } +} + +SwWrongList::SwWrongList( WrongListType eType ) : + meType (eType), + mnBeginInvalid(COMPLETE_STRING), // everything correct... (the invalid area starts beyond the string) + mnEndInvalid (COMPLETE_STRING) +{ + maList.reserve( 5 ); +} + +SwWrongList::~SwWrongList() +{ + ClearList(); +} + +SwWrongList* SwWrongList::Clone() +{ + SwWrongList* pClone = new SwWrongList( meType ); + pClone->CopyFrom( *this ); + return pClone; +} + +void SwWrongList::CopyFrom( const SwWrongList& rCopy ) +{ + maList = rCopy.maList; + meType = rCopy.meType; + mnBeginInvalid = rCopy.mnBeginInvalid; + mnEndInvalid = rCopy.mnEndInvalid; + for(SwWrongArea & i : maList) + { + if( i.mpSubList ) + i.mpSubList = i.mpSubList->Clone(); + } +} + +void SwWrongList::ClearList() +{ + for (SwWrongArea & i : maList) + { + delete i.mpSubList; + i.mpSubList = nullptr; + } + maList.clear(); +} + +/** If a word is incorrectly selected, this method returns begin and length of it. + + @param[in,out] rChk starting position of the word to check + @param[out] rLn length of the word + + @return if incorrectly selected, otherwise + */ +bool SwWrongList::InWrongWord( sal_Int32 &rChk, sal_Int32 &rLn ) const +{ + const sal_uInt16 nPos = GetWrongPos( rChk ); + if ( nPos >= Count() ) + return false; + const sal_Int32 nWrPos = Pos( nPos ); + if ( nWrPos <= rChk ) + { + rLn = Len( nPos ); + if( nWrPos + rLn <= rChk ) + return false; + rChk = nWrPos; + return true; + } + return false; +} + +/** Calculate first incorrectly selected area. + + @param[in,out] rChk starting position of the word to check + @param[in,out] rLn length of the word + + @return if incorrectly selected area was found, otherwise + */ +bool SwWrongList::Check( sal_Int32 &rChk, sal_Int32 &rLn ) const +{ + sal_uInt16 nPos = GetWrongPos( rChk ); + rLn += rChk; + + if( nPos == Count() ) + return false; + + sal_Int32 nWrPos = Pos( nPos ); + sal_Int32 nEnd = nWrPos + Len( nPos ); + if( nEnd == rChk ) + { + ++nPos; + if( nPos == Count() ) + return false; + + nWrPos = Pos( nPos ); + nEnd = nWrPos + Len( nPos ); + } + if( nEnd > rChk && nWrPos < rLn ) + { + if( nWrPos > rChk ) + rChk = nWrPos; + if( nEnd < rLn ) + rLn = nEnd; + rLn -= rChk; + return 0 != rLn; + } + return false; +} + +/** Find next incorrectly selected position. + + @param[in] rChk starting position of the word to check + + @return starting position of incorrectly selected area, otherwise + */ +sal_Int32 SwWrongList::NextWrong( sal_Int32 nChk ) const +{ + sal_Int32 nRet = COMPLETE_STRING; + sal_uInt16 nPos = GetWrongPos( nChk ); + if( nPos < Count() ) + { + nRet = Pos( nPos ); + if( nRet < nChk && nRet + Len( nPos ) <= nChk ) + { + if( ++nPos < Count() ) + nRet = Pos( nPos ); + else + nRet = COMPLETE_STRING; + } + } + if( nRet > GetBeginInv() && nChk < GetEndInv() ) + nRet = std::max(nChk, GetBeginInv()); + return nRet; +} + +/** Find the first position that is greater or equal to the given value. + + @note Resulting position might be behind the last element of the array. + @param[in] nValue value for comparison + + @return first position that is greater or equal to the given value + */ +sal_uInt16 SwWrongList::GetWrongPos( sal_Int32 nValue ) const +{ + sal_uInt16 nMax = Count(); + sal_uInt16 nMin = 0; + + if( nMax > 0 ) + { + // For smart tag lists, we may not use a binary search. We return the + // position of the first smart tag which covers nValue + if ( !maList[0].maType.isEmpty() || maList[0].mpSubList ) + { + auto aIter = std::find_if(maList.begin(), maList.end(), + [nValue](const SwWrongArea& rST) { + return (rST.mnPos <= nValue && nValue < rST.mnPos + rST.mnLen) + || (rST.mnPos > nValue); + }); + return o3tl::narrowing(std::distance(maList.begin(), aIter)); + } + + --nMax; + sal_uInt16 nMid = 0; + while( nMin <= nMax ) + { + nMid = nMin + ( nMax - nMin ) / 2; + const sal_Int32 nTmp = Pos( nMid ); + if( nTmp == nValue ) + { + nMin = nMid; + break; + } + else if( nTmp < nValue ) + { + if( nTmp + Len( nMid ) >= nValue ) + { + nMin = nMid; + break; + } + nMin = nMid + 1; + } + else if( nMid == 0 ) + { + break; + } + else + nMax = nMid - 1; + } + } + + // nMin now points to an index i into the wrong list which + // 1. nValue is inside [ Area[i].pos, Area[i].pos + Area[i].len ] (inclusive!!!) + // 2. nValue < Area[i].pos + + return nMin; +} + +void SwWrongList::Invalidate_( sal_Int32 nBegin, sal_Int32 nEnd ) +{ + if ( nBegin < GetBeginInv() ) + mnBeginInvalid = nBegin; + if ( nEnd > GetEndInv() || GetEndInv() == COMPLETE_STRING ) + mnEndInvalid = nEnd; +} + +void SwWrongList::SetInvalid( sal_Int32 nBegin, sal_Int32 nEnd ) +{ + mnBeginInvalid = nBegin; + mnEndInvalid = nEnd; +} + +/** Change all values after the given position. + + Needed after insert/deletion of characters. + + @param nPos position after that everything should be changed + @param nDiff amount how much the positions should be moved + */ +void SwWrongList::Move( sal_Int32 nPos, sal_Int32 nDiff ) +{ + sal_uInt16 i = GetWrongPos( nPos ); + if( nDiff < 0 ) + { + const sal_Int32 nEnd = nPos - nDiff; + sal_uInt16 nLst = i; + bool bJump = false; + while( nLst < Count() && Pos( nLst ) < nEnd ) + ++nLst; + if( nLst > i ) + { + const sal_Int32 nWrPos = Pos( nLst - 1 ); + if ( nWrPos <= nPos ) + { + sal_Int32 nWrLen = Len( nLst - 1 ); + // calculate new length of word + nWrLen = ( nEnd > nWrPos + nWrLen ) ? + nPos - nWrPos : + nWrLen + nDiff; + if( nWrLen ) + { + maList[--nLst].mnLen = nWrLen; + bJump = true; + } + } + } + Remove( i, nLst - i ); + + if ( bJump ) + ++i; + if( COMPLETE_STRING == GetBeginInv() ) + SetInvalid( nPos ? nPos - 1 : nPos, nPos + 1 ); + else + { + ShiftLeft( mnBeginInvalid, nPos, nEnd ); + if( mnEndInvalid != COMPLETE_STRING ) + ShiftLeft( mnEndInvalid, nPos, nEnd ); + Invalidate_( nPos ? nPos - 1 : nPos, nPos + 1 ); + } + } + else + { + const sal_Int32 nEnd = nPos + nDiff; + if( COMPLETE_STRING != GetBeginInv() ) + { + if( mnBeginInvalid > nPos ) + mnBeginInvalid += nDiff; + if( mnEndInvalid >= nPos && mnEndInvalid != COMPLETE_STRING ) + mnEndInvalid += nDiff; + } + // If the pointer is in the middle of a wrong word, + // invalidation must happen from the beginning of that word. + if( i < Count() ) + { + const sal_Int32 nWrPos = Pos( i ); + if (nPos >= nWrPos) + { + Invalidate( nWrPos, nEnd ); + const sal_Int32 nWrLen = Len( i ) + nDiff; + maList[i++].mnLen = nWrLen; + Invalidate( nWrPos, nWrPos + nWrLen ); + } + } + else + Invalidate( nPos, nEnd ); + } + while( i < Count() ) + { + maList[i++].mnPos += nDiff; + } +} + +// TODO: Complete documentation +/** Remove given range of entries + + For a given range [nPos, nPos + nLen[ and an index nIndex, this function + basically counts the number of SwWrongArea entries starting with nIndex + up to nPos + nLen. All these entries are removed. + + @param rStart ??? + @param rEnd ??? + @param nPos starting position of the range + @param nLen length of the range + @param nIndex index to start lookup at + @param nCursorPos ??? + + @return if ??? + */ +auto SwWrongList::Fresh( sal_Int32 &rStart, sal_Int32 &rEnd, sal_Int32 nPos, + sal_Int32 nLen, sal_uInt16 nIndex, sal_Int32 nCursorPos ) -> FreshState +{ + // length of word must be greater than 0 + // only report a spelling error if the cursor position is outside the word, + // so that the user is not annoyed while typing + FreshState eRet = nLen + ? (nCursorPos > nPos + nLen || nCursorPos < nPos) + ? FreshState::FRESH + : FreshState::CURSOR + : FreshState::NOTHING; + + sal_Int32 nWrPos = 0; + sal_Int32 nWrEnd = rEnd; + sal_uInt16 nCnt = nIndex; + if( nCnt < Count() ) + { + nWrPos = Pos( nCnt ); + if( nWrPos < nPos && rStart > nWrPos ) + rStart = nWrPos; + } + + while( nCnt < Count() ) + { + nWrPos = Pos( nCnt ); + if ( nWrPos >= nPos ) + break; + nWrEnd = nWrPos + Len( nCnt++ ); + } + + if( nCnt < Count() && nWrPos == nPos && Len( nCnt ) == nLen ) + { + ++nCnt; + eRet = FreshState::FRESH; + } + else + { + if (FreshState::FRESH == eRet) + { + if( rStart > nPos ) + rStart = nPos; + nWrEnd = nPos + nLen; + } + } + + nPos += nLen; + + if( nCnt < Count() ) + { + nWrPos = Pos( nCnt ); + if( nWrPos < nPos && rStart > nWrPos ) + rStart = nWrPos; + } + + while( nCnt < Count() ) + { + nWrPos = Pos( nCnt ); + if ( nWrPos >= nPos ) + break; + nWrEnd = nWrPos + Len( nCnt++ ); + } + + if( rEnd < nWrEnd ) + rEnd = nWrEnd; + + Remove( nIndex, nCnt - nIndex ); + + return eRet; +} + +void SwWrongList::Invalidate( sal_Int32 nBegin, sal_Int32 nEnd ) +{ + if (COMPLETE_STRING == GetBeginInv()) + SetInvalid( nBegin, nEnd ); + else + Invalidate_( nBegin, nEnd ); +} + +bool SwWrongList::InvalidateWrong( ) +{ + if( Count() ) + { + const sal_Int32 nFirst = Pos( 0 ); + const sal_Int32 nLast = Pos( Count() - 1 ) + Len( Count() - 1 ); + Invalidate( nFirst, nLast ); + return true; + } + return false; +} + +std::unique_ptr SwWrongList::SplitList( sal_Int32 nSplitPos ) +{ + std::unique_ptr pRet; + sal_uInt16 nLst = 0; + while( nLst < Count() && Pos( nLst ) < nSplitPos ) + ++nLst; + if( nLst ) + { + sal_Int32 nWrPos = Pos( nLst - 1 ); + sal_Int32 nWrLen = Len( nLst - 1 ); + if ( nWrPos+nWrLen > nSplitPos ) + { + nWrLen += nWrPos - nSplitPos; + maList[--nLst].mnPos = nSplitPos; + maList[nLst].mnLen = nWrLen; + } + } + if( nLst ) + { + if( WRONGLIST_GRAMMAR == GetWrongListType() ) + pRet.reset(new SwGrammarMarkUp()); + else + pRet.reset(new SwWrongList( GetWrongListType() )); + pRet->Insert(0, maList.begin(), ( nLst >= maList.size() ? maList.end() : maList.begin() + nLst ) ); + pRet->SetInvalid( GetBeginInv(), GetEndInv() ); + pRet->Invalidate_( nSplitPos ? nSplitPos - 1 : nSplitPos, nSplitPos ); + Remove( 0, nLst ); + } + if( COMPLETE_STRING == GetBeginInv() ) + SetInvalid( 0, 1 ); + else + { + ShiftLeft( mnBeginInvalid, 0, nSplitPos ); + if( mnEndInvalid != COMPLETE_STRING ) + ShiftLeft( mnEndInvalid, 0, nSplitPos ); + Invalidate_( 0, 1 ); + } + for (nLst = 0; nLst < Count(); ++nLst ) + { + maList[nLst].mnPos -= nSplitPos; + } + return pRet; +} + +void SwWrongList::JoinList( SwWrongList* pNext, sal_Int32 nInsertPos ) +{ + if (pNext) + { + OSL_ENSURE( GetWrongListType() == pNext->GetWrongListType(), "type mismatch with next list" ); + + sal_uInt16 nCnt = Count(); + pNext->Move( 0, nInsertPos ); + Insert(nCnt, pNext->maList.begin(), pNext->maList.end()); + + Invalidate( pNext->GetBeginInv(), pNext->GetEndInv() ); + if( nCnt && Count() > nCnt ) + { + sal_Int32 nWrPos = Pos( nCnt ); + sal_Int32 nWrLen = Len( nCnt ); + if( !nWrPos ) + { + nWrPos += nInsertPos; + nWrLen -= nInsertPos; + maList[nCnt].mnPos = nWrPos; + maList[nCnt].mnLen = nWrLen; + } + if( nWrPos == Pos( nCnt - 1 ) + Len( nCnt - 1 ) ) + { + nWrLen += Len( nCnt - 1 ); + maList[nCnt - 1].mnLen = nWrLen; + Remove( nCnt, 1 ); + } + } + } + Invalidate( nInsertPos ? nInsertPos - 1 : nInsertPos, nInsertPos + 1 ); +} + +void SwWrongList::InsertSubList( sal_Int32 nNewPos, sal_Int32 nNewLen, sal_uInt16 nWhere, SwWrongList* pSubList ) +{ + if (pSubList) + { + OSL_ENSURE( GetWrongListType() == pSubList->GetWrongListType(), "type mismatch with sub list" ); + } + std::vector::iterator i = maList.begin(); + if ( nWhere >= maList.size() ) + i = maList.end(); // robust + else + i += nWhere; + maList.insert(i, SwWrongArea( OUString(), nullptr, nNewPos, nNewLen, pSubList ) ); +} + +// New functions: Necessary because SwWrongList has been changed to use std::vector +void SwWrongList::Insert(sal_uInt16 nWhere, std::vector::iterator startPos, std::vector::iterator const & endPos) +{ + std::vector::iterator i = maList.begin(); + if ( nWhere >= maList.size() ) + i = maList.end(); // robust + else + i += nWhere; + maList.insert(i, startPos, endPos); // insert [startPos, endPos[ before i + + // ownership of the sublist is passed to maList, therefore we have to set the + // pSubList-Pointers to 0 + while ( startPos != endPos ) + { + (*startPos).mpSubList = nullptr; + ++startPos; + } +} + +void SwWrongList::Remove(sal_uInt16 nIdx, sal_uInt16 nLen ) +{ + if ( nIdx >= maList.size() ) return; + std::vector::iterator i1 = maList.begin(); + i1 += nIdx; + + std::vector::iterator i2 = i1; + if ( nIdx + nLen >= o3tl::narrowing(maList.size()) ) + i2 = maList.end(); // robust + else + i2 += nLen; + + std::vector::iterator iLoop = i1; + while ( iLoop != i2 ) + { + delete (*iLoop).mpSubList; + ++iLoop; + } + +#if OSL_DEBUG_LEVEL > 0 + const int nOldSize = Count(); +#endif + + maList.erase(i1, i2); + +#if OSL_DEBUG_LEVEL > 0 + OSL_ENSURE( Count() + nLen == nOldSize, "SwWrongList::Remove() trouble" ); +#endif +} + +void SwWrongList::RemoveEntry( sal_Int32 nBegin, sal_Int32 nEnd ) { + std::vector::const_iterator aEnd(maList.end()); + auto aDelIter = std::find_if(maList.cbegin(), aEnd, + [nBegin](const SwWrongArea& rST) { return rST.mnPos >= nBegin; }); + auto aIter = aDelIter; + if( WRONGLIST_GRAMMAR == GetWrongListType() ) + { + if( nBegin < nEnd ) + { + aIter = std::find_if(aDelIter, aEnd, + [nEnd](const SwWrongArea& rST) { return rST.mnPos >= nEnd; }); + } + } + else + { + aIter = std::find_if(aDelIter, aEnd, + [nBegin, nEnd](const SwWrongArea& rST) { + return (rST.mnPos != nBegin) || ((rST.mnPos + rST.mnLen) != nEnd); + }); + } + auto nDel = o3tl::narrowing(std::distance(aDelIter, aIter)); + if( nDel ) + { + auto nDelPos = o3tl::narrowing(std::distance(maList.cbegin(), aDelIter)); + Remove( nDelPos, nDel ); + } +} + +bool SwWrongList::LookForEntry( sal_Int32 nBegin, sal_Int32 nEnd ) { + auto aIter = std::find_if(maList.begin(), maList.end(), + [nBegin](const SwWrongArea& rST) { return rST.mnPos >= nBegin; }); + return aIter != maList.end() + && nBegin == (*aIter).mnPos + && nEnd == (*aIter).mnPos + (*aIter).mnLen; +} + +void SwWrongList::Insert( const OUString& rType, + css::uno::Reference< css::container::XStringKeyMap > const & xPropertyBag, + sal_Int32 nNewPos, sal_Int32 nNewLen ) +{ + auto aIter = std::find_if(maList.begin(), maList.end(), + [nNewPos](const SwWrongArea& rST) { return nNewPos <= rST.mnPos; }); + if ( aIter != maList.end() && nNewPos == (*aIter).mnPos ) + { + const sal_Int32 nSTPos = (*aIter).mnPos; + + aIter = std::find_if(aIter, maList.end(), + [nSTPos, nNewLen](const SwWrongArea& rST) { return rST.mnPos != nSTPos || nNewLen < rST.mnLen; }); + } + + maList.insert(aIter, SwWrongArea( rType, meType, xPropertyBag, nNewPos, nNewLen) ); +} + +namespace sw { + +WrongListIteratorBase::WrongListIteratorBase(SwTextFrame const& rFrame, + SwWrongList const* (SwTextNode::*pGetWrongList)() const) + : m_pGetWrongList(pGetWrongList) + , m_pMergedPara(rFrame.GetMergedPara()) + , m_CurrentExtent(0) + , m_CurrentIndex(0) + , m_pWrongList(m_pMergedPara + ? nullptr + : (rFrame.GetTextNodeFirst()->*pGetWrongList)()) +{ +} + +WrongListIteratorBase::WrongListIteratorBase(SwWrongList const& rWrongList) + : m_pGetWrongList(nullptr) + , m_pMergedPara(nullptr) + , m_CurrentExtent(0) + , m_CurrentIndex(0) + , m_pWrongList(&rWrongList) +{ +} + +WrongListIterator::WrongListIterator(SwTextFrame const& rFrame, + SwWrongList const* (SwTextNode::*pGetWrongList)() const) + : WrongListIteratorBase(rFrame, pGetWrongList) +{ +} + +WrongListIterator::WrongListIterator(SwWrongList const& rWrongList) + : WrongListIteratorBase(rWrongList) +{ +} + +bool WrongListIterator::Check(TextFrameIndex & rStart, TextFrameIndex & rLen) +{ + if (m_pMergedPara) + { + if (rStart < m_CurrentIndex) + { // rewind + m_CurrentExtent = 0; + m_CurrentIndex = TextFrameIndex(0); + } + while (m_CurrentExtent < m_pMergedPara->extents.size()) + { + sw::Extent const& rExtent(m_pMergedPara->extents[m_CurrentExtent]); + if (rStart + rLen <= m_CurrentIndex) + { + return false; + } + else if (rStart < m_CurrentIndex) + { + rLen -= m_CurrentIndex - rStart; + assert(0 < sal_Int32(rLen)); + rStart = m_CurrentIndex; + } + if (m_CurrentIndex <= rStart && + rStart < m_CurrentIndex + TextFrameIndex(rExtent.nEnd - rExtent.nStart)) + { + SwWrongList const*const pWrongList((rExtent.pNode->*m_pGetWrongList)()); + // found the extent containing start - first, call Check + sal_Int32 nStart(rExtent.nStart + sal_Int32(rStart - m_CurrentIndex)); // (m_CurrentIndex - m_CurrentNodeIndex)); + sal_Int32 nLen; + if (sal_Int32(rLen) < rExtent.nEnd - nStart) + { + nLen = sal_Int32(rLen); + } + else + { + sal_Int32 nInLen(rLen); + nLen = rExtent.nEnd - nStart; + nInLen -= nLen; + for (size_t i = m_CurrentExtent + 1; + i < m_pMergedPara->extents.size(); ++i) + { + sw::Extent const& rExtentEnd(m_pMergedPara->extents[i]); + if (rExtentEnd.pNode != rExtent.pNode) + { + break; + } + // add gap too + nLen += rExtentEnd.nStart - m_pMergedPara->extents[i-1].nEnd; + if (nInLen <= rExtentEnd.nEnd - rExtentEnd.nStart) + { + nLen += nInLen; + break; + } + nLen += rExtentEnd.nEnd - rExtentEnd.nStart; + nInLen -= rExtentEnd.nEnd - rExtentEnd.nStart; + } + } + if (pWrongList && pWrongList->Check(nStart, nLen)) + { + // check if there's overlap with this extent + if (rExtent.nStart <= nStart && nStart < rExtent.nEnd) + { + // yes - now compute end position / length + sal_Int32 const nEnd(nStart + nLen); + rStart = m_CurrentIndex + TextFrameIndex(nStart - rExtent.nStart); + TextFrameIndex const nOrigLen(rLen); + if (nEnd <= rExtent.nEnd) + { + rLen = TextFrameIndex(nEnd - nStart); + } + else // have to search other extents for the end... + { + rLen = TextFrameIndex(rExtent.nEnd - nStart); + for (size_t i = m_CurrentExtent + 1; + i < m_pMergedPara->extents.size(); ++i) + { + sw::Extent const& rExtentEnd(m_pMergedPara->extents[i]); + if (rExtentEnd.pNode != rExtent.pNode + || nEnd <= rExtentEnd.nStart) + { + break; + } + if (nEnd <= rExtentEnd.nEnd) + { + rLen += TextFrameIndex(nEnd - rExtentEnd.nStart); + break; + } + rLen += TextFrameIndex(rExtentEnd.nEnd - rExtentEnd.nStart); + } + } + assert(rLen <= nOrigLen); (void) nOrigLen; + return true; + } + } + } + m_CurrentIndex += TextFrameIndex(rExtent.nEnd - rExtent.nStart); + ++m_CurrentExtent; + } + return false; + } + else if (m_pWrongList) + { + sal_Int32 nStart(rStart); + sal_Int32 nLen(rLen); + bool const bRet(m_pWrongList->Check(nStart, nLen)); + rStart = TextFrameIndex(nStart); + rLen = TextFrameIndex(nLen); + return bRet; + } + return false; +} + +const SwWrongArea* +WrongListIterator::GetWrongElement(TextFrameIndex const nStart) +{ + if (m_pMergedPara) + { + if (nStart < m_CurrentIndex) + { // rewind + m_CurrentExtent = 0; + m_CurrentIndex = TextFrameIndex(0); + } + while (m_CurrentExtent < m_pMergedPara->extents.size()) + { + sw::Extent const& rExtent(m_pMergedPara->extents[m_CurrentExtent]); + if (m_CurrentIndex <= nStart && + nStart <= m_CurrentIndex + TextFrameIndex(rExtent.nEnd - rExtent.nStart)) + { + // note: the returned object isn't wrapped because fntcache.cxx + // does not look at its positions, only its formatting props + SwWrongList const*const pWrongList((rExtent.pNode->*m_pGetWrongList)()); + if (pWrongList) + { + sal_Int32 const nNStart(rExtent.nStart + sal_Int32(nStart - m_CurrentIndex)); // (m_CurrentIndex - m_CurrentNodeIndex)); + sal_Int16 const nPos(pWrongList->GetWrongPos(nNStart)); + return pWrongList->GetElement(nPos); + } + } + m_CurrentIndex += TextFrameIndex(rExtent.nEnd - rExtent.nStart); + ++m_CurrentExtent; + } + return nullptr; + } + else if (m_pWrongList) + { + sal_Int16 const nPos(m_pWrongList->GetWrongPos(sal_Int32(nStart))); + return m_pWrongList->GetElement(nPos); + } + return nullptr; +} + +WrongListIteratorCounter::WrongListIteratorCounter(SwTextFrame const& rFrame, + SwWrongList const* (SwTextNode::*pGetWrongList)() const) + : WrongListIteratorBase(rFrame, pGetWrongList) +{ +} + +WrongListIteratorCounter::WrongListIteratorCounter(SwWrongList const& rWrongList) + : WrongListIteratorBase(rWrongList) +{ +} + +sal_uInt16 WrongListIteratorCounter::GetElementCount() +{ + if (m_pMergedPara) + { + sal_uInt16 nRet(0); + m_CurrentExtent = 0; + m_CurrentIndex = TextFrameIndex(0); + SwNode const* pNode(nullptr); + sal_uInt16 InCurrentNode(0); + while (m_CurrentExtent < m_pMergedPara->extents.size()) + { + sw::Extent const& rExtent(m_pMergedPara->extents[m_CurrentExtent]); + if (rExtent.pNode != pNode) + { + InCurrentNode = 0; + pNode = rExtent.pNode; + } + SwWrongList const*const pWrongList((rExtent.pNode->*m_pGetWrongList)()); + for (; pWrongList && InCurrentNode < pWrongList->Count(); ++InCurrentNode) + { + SwWrongArea const*const pWrong(pWrongList->GetElement(InCurrentNode)); + TextFrameIndex const nExtentEnd( + m_CurrentIndex + TextFrameIndex(rExtent.nEnd - rExtent.nStart)); + if (nExtentEnd <= TextFrameIndex(pWrong->mnPos)) + { + break; // continue outer loop + } + if (m_CurrentIndex < TextFrameIndex(pWrong->mnPos + pWrong->mnLen)) + { + ++nRet; + } + } + m_CurrentIndex += TextFrameIndex(rExtent.nEnd - rExtent.nStart); + ++m_CurrentExtent; + } + return nRet; + } + else if (m_pWrongList) + { + return m_pWrongList->Count(); + } + return 0; +} + +std::optional> +WrongListIteratorCounter::GetElementAt(sal_uInt16 nIndex) +{ + if (m_pMergedPara) + { + m_CurrentExtent = 0; + m_CurrentIndex = TextFrameIndex(0); + SwNode const* pNode(nullptr); + sal_uInt16 InCurrentNode(0); + while (m_CurrentExtent < m_pMergedPara->extents.size()) + { + sw::Extent const& rExtent(m_pMergedPara->extents[m_CurrentExtent]); + if (rExtent.pNode != pNode) + { + InCurrentNode = 0; + pNode = rExtent.pNode; + } + SwWrongList const*const pWrongList((rExtent.pNode->*m_pGetWrongList)()); + for (; pWrongList && InCurrentNode < pWrongList->Count(); ++InCurrentNode) + { + SwWrongArea const*const pWrong(pWrongList->GetElement(InCurrentNode)); + TextFrameIndex const nExtentEnd( + m_CurrentIndex + TextFrameIndex(rExtent.nEnd - rExtent.nStart)); + if (nExtentEnd <= TextFrameIndex(pWrong->mnPos)) + { + break; // continue outer loop + } + if (m_CurrentIndex < TextFrameIndex(pWrong->mnPos + pWrong->mnLen)) + { + if (nIndex == 0) + { + return std::optional>( + std::pair( + m_CurrentIndex - TextFrameIndex(rExtent.nStart - + std::max(rExtent.nStart, pWrong->mnPos)), + m_CurrentIndex - TextFrameIndex(rExtent.nStart - + std::min(pWrong->mnPos + pWrong->mnLen, rExtent.nEnd)))); + } + --nIndex; + } + } + m_CurrentIndex += TextFrameIndex(rExtent.nEnd - rExtent.nStart); + ++m_CurrentExtent; + } + return std::optional>(); + } + else if (m_pWrongList) + { + SwWrongArea const*const pWrong(m_pWrongList->GetElement(nIndex)); + return std::optional>( + std::pair( + TextFrameIndex(pWrong->mnPos), + TextFrameIndex(pWrong->mnPos + pWrong->mnLen))); + } + return std::optional>(); +} + +} // namespace sw + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/core/text/xmldump.cxx b/sw/source/core/text/xmldump.cxx new file mode 100644 index 0000000000..a14c5a4851 --- /dev/null +++ b/sw/source/core/text/xmldump.cxx @@ -0,0 +1,203 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "porlay.hxx" + +const char* sw::PortionTypeToString(PortionType nType) +{ + switch (nType) + { + case PortionType::NONE: + return "PortionType::NONE"; + case PortionType::FlyCnt: + return "PortionType::FlyCnt"; + + case PortionType::Hole: + return "PortionType::Hole"; + case PortionType::TempEnd: + return "PortionType::TempEnd"; + case PortionType::Break: + return "PortionType::Break"; + case PortionType::Kern: + return "PortionType::Kern"; + case PortionType::Arrow: + return "PortionType::Arrow"; + case PortionType::Multi: + return "PortionType::Multi"; + case PortionType::HiddenText: + return "PortionType::HiddenText"; + case PortionType::ControlChar: + return "PortionType::ControlChar"; + case PortionType::Bookmark: + return "PortionType::Bookmark"; + + case PortionType::Text: + return "PortionType::Text"; + case PortionType::Lay: + return "PortionType::Lay"; + case PortionType::Para: + return "PortionType::Para"; + case PortionType::Hanging: + return "PortionType::Hanging"; + + case PortionType::Drop: + return "PortionType::Drop"; + case PortionType::Tox: + return "PortionType::Tox"; + case PortionType::IsoTox: + return "PortionType::IsoTox"; + case PortionType::Ref: + return "PortionType::Ref"; + case PortionType::IsoRef: + return "PortionType::IsoRef"; + case PortionType::Meta: + return "PortionType::Meta"; + case PortionType::ContentControl: + return "PortionType::ContentControl"; + case PortionType::FieldMark: + return "PortionType::FieldMark"; + case PortionType::FieldFormCheckbox: + return "PortionType::FieldFormCheckbox"; + case PortionType::InputField: + return "PortionType::InputField"; + + case PortionType::Expand: + return "PortionType::Expand"; + case PortionType::Blank: + return "PortionType::Blank"; + case PortionType::PostIts: + return "PortionType::PostIts"; + + case PortionType::Hyphen: + return "PortionType::Hyphen"; + case PortionType::HyphenStr: + return "PortionType::HyphenStr"; + case PortionType::SoftHyphen: + return "PortionType::SoftHyphen"; + case PortionType::SoftHyphenStr: + return "PortionType::SoftHyphenStr"; + case PortionType::SoftHyphenComp: + return "PortionType::SoftHyphenComp"; + + case PortionType::Field: + return "PortionType::Field"; + case PortionType::Hidden: + return "PortionType::Hidden"; + case PortionType::QuoVadis: + return "PortionType::QuoVadis"; + case PortionType::ErgoSum: + return "PortionType::ErgoSum"; + case PortionType::Combined: + return "PortionType::Combined"; + case PortionType::Footnote: + return "PortionType::Footnote"; + + case PortionType::FootnoteNum: + return "PortionType::FootnoteNum"; + case PortionType::Number: + return "PortionType::Number"; + case PortionType::Bullet: + return "PortionType::Bullet"; + case PortionType::GrfNum: + return "PortionType::GrfNum"; + + case PortionType::Glue: + return "PortionType::Glue"; + + case PortionType::Margin: + return "PortionType::Margin"; + + case PortionType::Fix: + return "PortionType::Fix"; + case PortionType::Fly: + return "PortionType::Fly"; + + case PortionType::Tab: + return "PortionType::Tab"; + + case PortionType::TabRight: + return "PortionType::TabRight"; + case PortionType::TabCenter: + return "PortionType::TabCenter"; + case PortionType::TabDecimal: + return "PortionType::TabDecimal"; + + case PortionType::TabLeft: + return "PortionType::TabLeft"; + default: + return "Unknown"; + } +} + +void SwFrame::dumpTopMostAsXml(xmlTextWriterPtr writer) const +{ + const SwFrame* pFrame = this; + while (pFrame->GetUpper()) + { + pFrame = pFrame->GetUpper(); + } + + pFrame->dumpAsXml(writer); +} + +void SwFrame::dumpInfosAsXml( xmlTextWriterPtr writer ) const +{ + // output the Frame + (void)xmlTextWriterStartElement( writer, BAD_CAST( "bounds" ) ); + getFrameArea().dumpAsXmlAttributes(writer); + (void)xmlTextWriterWriteAttribute(writer, BAD_CAST("mbFixSize"), BAD_CAST(OString::boolean(HasFixSize()).getStr())); + (void)xmlTextWriterWriteAttribute(writer, BAD_CAST("mbFrameAreaPositionValid"), BAD_CAST(OString::boolean(isFrameAreaPositionValid()).getStr())); + (void)xmlTextWriterWriteAttribute(writer, BAD_CAST("mbFrameAreaSizeValid"), BAD_CAST(OString::boolean(isFrameAreaSizeValid()).getStr())); + (void)xmlTextWriterWriteAttribute(writer, BAD_CAST("mbFramePrintAreaValid"), BAD_CAST(OString::boolean(isFramePrintAreaValid()).getStr())); + (void)xmlTextWriterEndElement( writer ); + + // output the print area + (void)xmlTextWriterStartElement( writer, BAD_CAST( "prtBounds" ) ); + getFramePrintArea().dumpAsXmlAttributes(writer); + (void)xmlTextWriterEndElement( writer ); +} + +void SwFrame::dumpAsXmlAttributes( xmlTextWriterPtr writer ) const +{ + (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "ptr" ), "%p", this ); + (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "id" ), "%" SAL_PRIuUINT32, GetFrameId() ); + (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "symbol" ), "%s", BAD_CAST( typeid( *this ).name( ) ) ); + if ( GetNext( ) ) + (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "next" ), "%" SAL_PRIuUINT32, GetNext()->GetFrameId() ); + if ( GetPrev( ) ) + (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "prev" ), "%" SAL_PRIuUINT32, GetPrev()->GetFrameId() ); + if ( GetUpper( ) ) + (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "upper" ), "%" SAL_PRIuUINT32, GetUpper()->GetFrameId() ); + if ( GetLower( ) ) + (void)xmlTextWriterWriteFormatAttribute( writer, BAD_CAST( "lower" ), "%" SAL_PRIuUINT32, GetLower()->GetFrameId() ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ -- cgit v1.2.3