diff options
Diffstat (limited to 'sw/source/filter/html/htmlatr.cxx')
-rw-r--r-- | sw/source/filter/html/htmlatr.cxx | 3467 |
1 files changed, 3467 insertions, 0 deletions
diff --git a/sw/source/filter/html/htmlatr.cxx b/sw/source/filter/html/htmlatr.cxx new file mode 100644 index 0000000000..9f67d1ee03 --- /dev/null +++ b/sw/source/filter/html/htmlatr.cxx @@ -0,0 +1,3467 @@ +/* -*- 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 <hintids.hxx> +#include <com/sun/star/i18n/ScriptType.hpp> +#include <com/sun/star/i18n/XBreakIterator.hpp> +#include <comphelper/string.hxx> +#include <utility> +#include <vcl/svapp.hxx> +#include <svtools/htmlout.hxx> +#include <svtools/htmlkywd.hxx> +#include <svtools/htmltokn.h> +#include <svl/whiter.hxx> +#include <sfx2/event.hxx> +#include <sfx2/htmlmode.hxx> +#include <editeng/escapementitem.hxx> +#include <editeng/formatbreakitem.hxx> +#include <editeng/boxitem.hxx> +#include <editeng/ulspitem.hxx> +#include <editeng/udlnitem.hxx> +#include <editeng/crossedoutitem.hxx> +#include <editeng/blinkitem.hxx> +#include <editeng/colritem.hxx> +#include <editeng/fontitem.hxx> +#include <editeng/fhgtitem.hxx> +#include <editeng/postitem.hxx> +#include <editeng/wghtitem.hxx> +#include <editeng/adjustitem.hxx> +#include <editeng/lrspitem.hxx> +#include <editeng/langitem.hxx> +#include <editeng/frmdiritem.hxx> +#include <fchrfmt.hxx> +#include <fmtautofmt.hxx> +#include <fmtfsize.hxx> +#include <fmtclds.hxx> +#include <fmtpdsc.hxx> +#include <fmtflcnt.hxx> +#include <fmtinfmt.hxx> +#include <txatbase.hxx> +#include <frmatr.hxx> +#include <charfmt.hxx> +#include <fmtfld.hxx> +#include <doc.hxx> +#include <IDocumentStylePoolAccess.hxx> +#include <pam.hxx> +#include <ndtxt.hxx> +#include <paratr.hxx> +#include <poolfmt.hxx> +#include <pagedesc.hxx> +#include <swtable.hxx> +#include <fldbas.hxx> +#include <breakit.hxx> +#include "htmlatr.hxx" +#include "htmlnum.hxx" +#include "wrthtml.hxx" +#include "htmlfly.hxx" +#include <numrule.hxx> +#include <rtl/character.hxx> +#include <osl/diagnose.h> +#include <deque> + +#include <svtools/HtmlWriter.hxx> +#include <o3tl/string_view.hxx> + +#include <memory> +#include <algorithm> + +using namespace css; + +HTMLOutEvent const aAnchorEventTable[] = +{ + { OOO_STRING_SVTOOLS_HTML_O_SDonclick, OOO_STRING_SVTOOLS_HTML_O_onclick, SvMacroItemId::OnClick }, + { OOO_STRING_SVTOOLS_HTML_O_SDonmouseover, OOO_STRING_SVTOOLS_HTML_O_onmouseover, SvMacroItemId::OnMouseOver }, + { OOO_STRING_SVTOOLS_HTML_O_SDonmouseout, OOO_STRING_SVTOOLS_HTML_O_onmouseout, SvMacroItemId::OnMouseOut }, + { nullptr, nullptr, SvMacroItemId::NONE } +}; + +static SwHTMLWriter& OutHTML_SvxAdjust( SwHTMLWriter& rWrt, const SfxPoolItem& rHt ); + +sal_uInt16 SwHTMLWriter::GetDefListLvl( std::u16string_view rNm, sal_uInt16 nPoolId ) +{ + if( nPoolId == RES_POOLCOLL_HTML_DD ) + { + return 1 | HTML_DLCOLL_DD; + } + else if( nPoolId == RES_POOLCOLL_HTML_DT ) + { + return 1 | HTML_DLCOLL_DT; + } + + OUString sDTDD = OOO_STRING_SVTOOLS_HTML_dt " "; + if( o3tl::starts_with(rNm, sDTDD) ) + // DefinitionList - term + return o3tl::narrowing<sal_uInt16>(o3tl::toInt32(rNm.substr( sDTDD.getLength() ))) | HTML_DLCOLL_DT; + + sDTDD = OOO_STRING_SVTOOLS_HTML_dd " "; + if( o3tl::starts_with(rNm, sDTDD) ) + // DefinitionList - definition + return o3tl::narrowing<sal_uInt16>(o3tl::toInt32(rNm.substr( sDTDD.getLength() ))) | HTML_DLCOLL_DD; + + return 0; +} + +void SwHTMLWriter::OutAndSetDefList( sal_uInt16 nNewLvl ) +{ + // possibly, we first need to start a new list + if( m_nDefListLvl < nNewLvl ) + { + // output </pre> for the previous(!) paragraph, if required. + // Preferable, the <pre> is exported by OutHTML_SwFormatOff for the + // previous paragraph already, but that's not possible, because a very + // deep look at the next paragraph (this one) is required to figure + // out that a def list starts here. + + ChangeParaToken( HtmlTokenId::NONE ); + + // write according to the level difference + for( sal_uInt16 i=m_nDefListLvl; i<nNewLvl; i++ ) + { + if (IsLFPossible()) + OutNewLine(); + HTMLOutFuncs::Out_AsciiTag( Strm(), Concat2View(GetNamespace() + OOO_STRING_SVTOOLS_HTML_deflist) ); + HTMLOutFuncs::Out_AsciiTag( Strm(), Concat2View(GetNamespace() + OOO_STRING_SVTOOLS_HTML_dd) ); + IncIndentLevel(); + SetLFPossible(true); + } + } + else if( m_nDefListLvl > nNewLvl ) + { + for( sal_uInt16 i=nNewLvl ; i < m_nDefListLvl; i++ ) + { + DecIndentLevel(); + if (IsLFPossible()) + OutNewLine(); + HTMLOutFuncs::Out_AsciiTag( Strm(), Concat2View(GetNamespace() + OOO_STRING_SVTOOLS_HTML_dd), false ); + HTMLOutFuncs::Out_AsciiTag( Strm(), Concat2View(GetNamespace() + OOO_STRING_SVTOOLS_HTML_deflist), false ); + SetLFPossible(true); + } + } + + m_nDefListLvl = nNewLvl; +} + +void SwHTMLWriter::ChangeParaToken( HtmlTokenId nNew ) +{ + if( nNew != m_nLastParaToken && HtmlTokenId::PREFORMTXT_ON == m_nLastParaToken ) + { + HTMLOutFuncs::Out_AsciiTag( Strm(), Concat2View(GetNamespace() + OOO_STRING_SVTOOLS_HTML_preformtxt), false ); + SetLFPossible(true); + } + m_nLastParaToken = nNew; +} + +sal_uInt16 SwHTMLWriter::GetCSS1ScriptForScriptType( sal_uInt16 nScriptType ) +{ + sal_uInt16 nRet = CSS1_OUTMODE_ANY_SCRIPT; + + switch( nScriptType ) + { + case i18n::ScriptType::LATIN: + nRet = CSS1_OUTMODE_WESTERN; + break; + case i18n::ScriptType::ASIAN: + nRet = CSS1_OUTMODE_CJK; + break; + case i18n::ScriptType::COMPLEX: + nRet = CSS1_OUTMODE_CTL; + break; + } + + return nRet; +} + +// a single output function should be enough for all formats +/* + * Output the formats as follows + * - output the tag for formats for which a corresponding HTML tag exist + * - for all the other formats, output a paragraph tag <P> and set bUserFormat + * - if a paragraph alignment is set for the supplied ItemSet of the node or + * for the ItemSet of the format, output an ALIGN=xxx if HTML allows it + * - In all cases, hard attribute is written as STYLE option. + * If bUserFormat is not set, only the supplied ItemSet is considered. + * Otherwise, attributes of the format are output as well. + */ + +namespace { + +struct SwHTMLTextCollOutputInfo +{ + OString aToken; // End token to be output + std::optional<SfxItemSet> moItemSet; // hard attribute + + bool bInNumberBulletList; // in an enumerated list; + bool bParaPossible; // a </P> may be output additionally + bool bOutPara; // a </P> is supposed to be output + bool bOutDiv; // write a </DIV> + + SwHTMLTextCollOutputInfo() : + bInNumberBulletList( false ), + bParaPossible( false ), + bOutPara( false ), + bOutDiv( false ) + {} + + bool HasParaToken() const { return aToken.getLength()==1 && aToken[0]=='P'; } + bool ShouldOutputToken() const { return bOutPara || !HasParaToken(); } +}; + +} + +SwHTMLFormatInfo::SwHTMLFormatInfo( const SwFormat *pF, SwDoc *pDoc, SwDoc *pTemplate, + bool bOutStyles, + LanguageType eDfltLang, + sal_uInt16 nCSS1Script ) + : pFormat(pF) + , nLeftMargin(0) + , nRightMargin(0) + , nFirstLineIndent(0) + , nTopMargin(0) + , nBottomMargin(0) + , bScriptDependent( false ) +{ + sal_uInt16 nRefPoolId = 0; + // Get the selector of the format + sal_uInt16 nDeep = SwHTMLWriter::GetCSS1Selector( pFormat, aToken, aClass, + nRefPoolId ); + OSL_ENSURE( nDeep ? !aToken.isEmpty() : aToken.isEmpty(), + "Something seems to be wrong with this token!" ); + OSL_ENSURE( nDeep ? nRefPoolId != 0 : nRefPoolId == 0, + "Something seems to be wrong with the comparison style!" ); + + bool bTextColl = pFormat->Which() == RES_TXTFMTCOLL || + pFormat->Which() == RES_CONDTXTFMTCOLL; + + const SwFormat *pReferenceFormat = nullptr; // Comparison format + if( nDeep != 0 ) + { + // It's an HTML-tag style or this style is derived from such + // a style. + if( !bOutStyles ) + { + // if no styles are exported, it may be necessary to additionally + // write hard attribute + switch( nDeep ) + { + case CSS1_FMT_ISTAG: + case CSS1_FMT_CMPREF: + // for HTML-tag styles the differences to the original + // (if available) + pReferenceFormat = SwHTMLWriter::GetTemplateFormat( nRefPoolId, + &pTemplate->getIDocumentStylePoolAccess() ); + break; + + default: + // otherwise, the differences to the HTML-tag style of the + // original or the ones to the current document, if it the + // HTML-tag style is not available + if( pTemplate ) + pReferenceFormat = SwHTMLWriter::GetTemplateFormat( nRefPoolId, + &pTemplate->getIDocumentStylePoolAccess() ); + else + pReferenceFormat = SwHTMLWriter::GetParentFormat( *pFormat, nDeep ); + break; + } + } + } + else if( bTextColl ) + { + // HTML-tag styles that are not derived from a paragraph style + // must be exported as hard attribute relative to the text-body + // style. For a 'not-styles' export, the one of the HTML style + // should be used as a reference + if( !bOutStyles && pTemplate ) + pReferenceFormat = pTemplate->getIDocumentStylePoolAccess().GetTextCollFromPool( RES_POOLCOLL_TEXT, false ); + else + pReferenceFormat = pDoc->getIDocumentStylePoolAccess().GetTextCollFromPool( RES_POOLCOLL_TEXT, false ); + } + + if( pReferenceFormat || nDeep==0 ) + { + moItemSet.emplace( *pFormat->GetAttrSet().GetPool(), + pFormat->GetAttrSet().GetRanges() ); + // if the differences to a different style are supposed to be + // written, hard attribute is necessary. This is always true + // for styles that are not derived from HTML-tag styles. + + moItemSet->Set( pFormat->GetAttrSet() ); + + if( pReferenceFormat ) + SwHTMLWriter::SubtractItemSet( *moItemSet, pReferenceFormat->GetAttrSet(), true ); + + // delete ItemSet that is empty straight away. This will save work + // later on + if( !moItemSet->Count() ) + { + moItemSet.reset(); + } + } + + if( !bTextColl ) + return; + + if( bOutStyles ) + { + // We have to add hard attributes for any script dependent + // item that is not accessed by the style + static const sal_uInt16 aWhichIds[3][4] = + { + { RES_CHRATR_FONT, RES_CHRATR_FONTSIZE, + RES_CHRATR_POSTURE, RES_CHRATR_WEIGHT }, + { RES_CHRATR_CJK_FONT, RES_CHRATR_CJK_FONTSIZE, + RES_CHRATR_CJK_POSTURE, RES_CHRATR_CJK_WEIGHT }, + { RES_CHRATR_CTL_FONT, RES_CHRATR_CTL_FONTSIZE, + RES_CHRATR_CTL_POSTURE, RES_CHRATR_CTL_WEIGHT } + }; + + sal_uInt16 nRef = 0; + sal_uInt16 aSets[2] = {0,0}; + switch( nCSS1Script ) + { + case CSS1_OUTMODE_WESTERN: + nRef = 0; + aSets[0] = 1; + aSets[1] = 2; + break; + case CSS1_OUTMODE_CJK: + nRef = 1; + aSets[0] = 0; + aSets[1] = 2; + break; + case CSS1_OUTMODE_CTL: + nRef = 2; + aSets[0] = 0; + aSets[1] = 1; + break; + } + for( int i=0; i<4; ++i ) + { + const SfxPoolItem& rRef = pFormat->GetFormatAttr( aWhichIds[nRef][i] ); + for(sal_uInt16 nSet : aSets) + { + const SfxPoolItem& rSet = pFormat->GetFormatAttr( aWhichIds[nSet][i] ); + if( rSet != rRef ) + { + if( !moItemSet ) + moItemSet.emplace( *pFormat->GetAttrSet().GetPool(), + pFormat->GetAttrSet().GetRanges() ); + moItemSet->Put( rSet ); + } + } + } + } + + // remember all the different default spacings from the style or + // the comparison style. + SvxFirstLineIndentItem const& rFirstLine( + (pReferenceFormat ? pReferenceFormat : pFormat)->GetFirstLineIndent()); + SvxTextLeftMarginItem const& rTextLeftMargin( + (pReferenceFormat ? pReferenceFormat : pFormat)->GetTextLeftMargin()); + SvxRightMarginItem const& rRightMargin( + (pReferenceFormat ? pReferenceFormat : pFormat)->GetRightMargin()); + nLeftMargin = rTextLeftMargin.GetTextLeft(); + nRightMargin = rRightMargin.GetRight(); + nFirstLineIndent = rFirstLine.GetTextFirstLineOffset(); + + const SvxULSpaceItem &rULSpace = + (pReferenceFormat ? pReferenceFormat : pFormat)->GetULSpace(); + nTopMargin = rULSpace.GetUpper(); + nBottomMargin = rULSpace.GetLower(); + + // export language if it differs from the default language + TypedWhichId<SvxLanguageItem> nWhichId = + SwHTMLWriter::GetLangWhichIdFromScript( nCSS1Script ); + const SvxLanguageItem& rLang = pFormat->GetFormatAttr( nWhichId ); + LanguageType eLang = rLang.GetLanguage(); + if( eLang != eDfltLang ) + { + if( !moItemSet ) + moItemSet.emplace( *pFormat->GetAttrSet().GetPool(), + pFormat->GetAttrSet().GetRanges() ); + moItemSet->Put( rLang ); + } + + static const TypedWhichId<SvxLanguageItem> aWhichIds[3] = + { RES_CHRATR_LANGUAGE, RES_CHRATR_CJK_LANGUAGE, + RES_CHRATR_CTL_LANGUAGE }; + for(const TypedWhichId<SvxLanguageItem>& i : aWhichIds) + { + if( i != nWhichId ) + { + const SvxLanguageItem& rTmpLang = pFormat->GetFormatAttr(i); + if( rTmpLang.GetLanguage() != eLang ) + { + if( !moItemSet ) + moItemSet.emplace( *pFormat->GetAttrSet().GetPool(), + pFormat->GetAttrSet().GetRanges() ); + moItemSet->Put( rTmpLang ); + } + } + } + +} + +SwHTMLFormatInfo::~SwHTMLFormatInfo() +{ +} + +static void OutHTML_SwFormat( SwHTMLWriter& rWrt, const SwFormat& rFormat, + const SfxItemSet *pNodeItemSet, + SwHTMLTextCollOutputInfo& rInfo ) +{ + OSL_ENSURE( RES_CONDTXTFMTCOLL==rFormat.Which() || RES_TXTFMTCOLL==rFormat.Which(), + "not a paragraph style" ); + + // First, some flags + sal_uInt16 nNewDefListLvl = 0; + sal_uInt16 nNumStart = USHRT_MAX; + bool bForceDL = false; + bool bDT = false; + rInfo.bInNumberBulletList = false; // Are we in a list? + bool bNumbered = false; // The current paragraph is numbered + bool bPara = false; // the current token is <P> + rInfo.bParaPossible = false; // a <P> may be additionally output + bool bNoEndTag = false; // don't output an end tag + + rWrt.m_bNoAlign = false; // no ALIGN=... possible + + if (rWrt.mbXHTML) + { + rWrt.m_bNoAlign = true; + } + + sal_uInt8 nBulletGrfLvl = 255; // The bullet graphic we want to output + + // Are we in a bulleted or numbered list? + const SwTextNode* pTextNd = rWrt.m_pCurrentPam->GetPointNode().GetTextNode(); + + SwHTMLNumRuleInfo aNumInfo; + if( rWrt.GetNextNumInfo() ) + { + aNumInfo = *rWrt.GetNextNumInfo(); + rWrt.ClearNextNumInfo(); + } + else + { + aNumInfo.Set( *pTextNd ); + } + + if( aNumInfo.GetNumRule() ) + { + rInfo.bInNumberBulletList = true; + nNewDefListLvl = 0; + + // is the current paragraph numbered? + bNumbered = aNumInfo.IsNumbered(); + sal_uInt8 nLvl = aNumInfo.GetLevel(); + + OSL_ENSURE( pTextNd->GetActualListLevel() == nLvl, + "Remembered Num level is wrong" ); + OSL_ENSURE( bNumbered == pTextNd->IsCountedInList(), + "Remembered numbering state is wrong" ); + + if( bNumbered ) + { + nBulletGrfLvl = nLvl; // only temporarily!!! + // #i57919# + // correction of re-factoring done by cws swnumtree: + // - <nNumStart> has to contain the restart value, if the + // numbering is restarted at this text node. Value <USHRT_MAX> + // indicates, that no additional restart value has to be written. + if ( pTextNd->IsListRestart() ) + { + nNumStart = static_cast< sal_uInt16 >(pTextNd->GetActualListStartValue()); + } + OSL_ENSURE( rWrt.m_nLastParaToken == HtmlTokenId::NONE, + "<PRE> was not closed before <LI>." ); + } + } + + // Now, we're getting the token and, if necessary, the class + std::unique_ptr<SwHTMLFormatInfo> pTmpInfo(new SwHTMLFormatInfo(&rFormat)); + SwHTMLFormatInfo *pFormatInfo; + SwHTMLFormatInfos::iterator it = rWrt.m_TextCollInfos.find( pTmpInfo ); + if (it != rWrt.m_TextCollInfos.end()) + { + pFormatInfo = it->get(); + } + else + { + pFormatInfo = new SwHTMLFormatInfo( &rFormat, rWrt.m_pDoc, rWrt.m_xTemplate.get(), + rWrt.m_bCfgOutStyles, rWrt.m_eLang, + rWrt.m_nCSS1Script ); + rWrt.m_TextCollInfos.insert(std::unique_ptr<SwHTMLFormatInfo>(pFormatInfo)); + if( rWrt.m_aScriptParaStyles.count( rFormat.GetName() ) ) + pFormatInfo->bScriptDependent = true; + } + + // Now, we define what is possible due to the token + HtmlTokenId nToken = HtmlTokenId::NONE; // token for tag change + bool bOutNewLine = false; // only output a single LF? + if( !pFormatInfo->aToken.isEmpty() ) + { + // It is an HTML-tag style or the style is derived from such a + // style. + rInfo.aToken = pFormatInfo->aToken; + + if (rInfo.aToken == OOO_STRING_SVTOOLS_HTML_address) + { + rInfo.bParaPossible = true; + rWrt.m_bNoAlign = true; + } + else if (rInfo.aToken == OOO_STRING_SVTOOLS_HTML_blockquote) + { + rInfo.bParaPossible = true; + rWrt.m_bNoAlign = true; + } + else if (rInfo.aToken == OOO_STRING_SVTOOLS_HTML_parabreak) + { + bPara = true; + } + else if (rInfo.aToken == OOO_STRING_SVTOOLS_HTML_preformtxt) + { + if (HtmlTokenId::PREFORMTXT_ON == rWrt.m_nLastParaToken) + { + bOutNewLine = true; + } + else + { + nToken = HtmlTokenId::PREFORMTXT_ON; + rWrt.m_bNoAlign = true; + bNoEndTag = true; + } + } + else if (rInfo.aToken == OOO_STRING_SVTOOLS_HTML_dt || rInfo.aToken == OOO_STRING_SVTOOLS_HTML_dd) + { + bDT = rInfo.aToken == OOO_STRING_SVTOOLS_HTML_dt; + rInfo.bParaPossible = !bDT; + rWrt.m_bNoAlign = true; + bForceDL = true; + } + } + else + { + // all styles that do not correspond to an HTML tag, or that are + // not derived from it, are exported as <P> + + rInfo.aToken = OOO_STRING_SVTOOLS_HTML_parabreak ""_ostr; + bPara = true; + } + + // If necessary, take the hard attribute from the style + if( pFormatInfo->moItemSet ) + { + OSL_ENSURE(!rInfo.moItemSet, "Where does this ItemSet come from?"); + rInfo.moItemSet.emplace( *pFormatInfo->moItemSet ); + } + + // additionally, add the hard attribute from the paragraph + if( pNodeItemSet ) + { + if (rInfo.moItemSet) + rInfo.moItemSet->Put( *pNodeItemSet ); + else + rInfo.moItemSet.emplace( *pNodeItemSet ); + } + + // we will need the lower spacing of the paragraph later on + const SvxULSpaceItem& rULSpace = + pNodeItemSet ? pNodeItemSet->Get(RES_UL_SPACE) + : rFormat.GetULSpace(); + + if( (rWrt.m_bOutHeader && + rWrt.m_pCurrentPam->GetPoint()->GetNodeIndex() == + rWrt.m_pCurrentPam->GetMark()->GetNodeIndex()) || + rWrt.m_bOutFooter ) + { + if( rWrt.m_bCfgOutStyles ) + { + SvxULSpaceItem aULSpaceItem( rULSpace ); + if( rWrt.m_bOutHeader ) + aULSpaceItem.SetLower( rWrt.m_nHeaderFooterSpace ); + else + aULSpaceItem.SetUpper( rWrt.m_nHeaderFooterSpace ); + + if (!rInfo.moItemSet) + { + rInfo.moItemSet.emplace(*rFormat.GetAttrSet().GetPool(), svl::Items<RES_UL_SPACE, RES_UL_SPACE>); + } + rInfo.moItemSet->Put( aULSpaceItem ); + } + rWrt.m_bOutHeader = false; + rWrt.m_bOutFooter = false; + } + + if( bOutNewLine ) + { + // output a line break (without indentation) at the beginning of the + // paragraph, only + rInfo.aToken.clear(); // don't output an end tag + rWrt.Strm().WriteOString( SAL_NEWLINE_STRING ); + + return; + } + + // should an ALIGN=... be written? + const SvxAdjustItem* pAdjItem = nullptr; + + if( rInfo.moItemSet ) + pAdjItem = rInfo.moItemSet->GetItemIfSet( RES_PARATR_ADJUST, false ); + + // Consider the lower spacing of the paragraph? (never in the last + // paragraph of tables) + bool bUseParSpace = !rWrt.m_bOutTable || + (rWrt.m_pCurrentPam->GetPoint()->GetNodeIndex() != + rWrt.m_pCurrentPam->GetMark()->GetNodeIndex()); + // If styles are exported, indented paragraphs become definition lists + SvxFirstLineIndentItem const& rFirstLine( + pNodeItemSet ? pNodeItemSet->Get(RES_MARGIN_FIRSTLINE) + : rFormat.GetFirstLineIndent()); + SvxTextLeftMarginItem const& rTextLeftMargin( + pNodeItemSet ? pNodeItemSet->Get(RES_MARGIN_TEXTLEFT) + : rFormat.GetTextLeftMargin()); + if( (!rWrt.m_bCfgOutStyles || bForceDL) && !rInfo.bInNumberBulletList ) + { + sal_Int32 nLeftMargin; + if( bForceDL ) + nLeftMargin = rTextLeftMargin.GetTextLeft(); + else + nLeftMargin = rTextLeftMargin.GetTextLeft() > pFormatInfo->nLeftMargin + ? rTextLeftMargin.GetTextLeft() - pFormatInfo->nLeftMargin + : 0; + + if( nLeftMargin > 0 && rWrt.m_nDefListMargin > 0 ) + { + nNewDefListLvl = static_cast< sal_uInt16 >((nLeftMargin + (rWrt.m_nDefListMargin/2)) / + rWrt.m_nDefListMargin); + if( nNewDefListLvl == 0 && bForceDL && !bDT ) + nNewDefListLvl = 1; + } + else + { + // If the left margin is 0 or negative, emulating indent + // with <dd> does not work. We then set a def list only if + // the dd style is used. + nNewDefListLvl = (bForceDL&& !bDT) ? 1 : 0; + } + + bool bIsNextTextNode = + rWrt.m_pDoc->GetNodes()[rWrt.m_pCurrentPam->GetPoint()->GetNodeIndex()+1] + ->IsTextNode(); + + if( bForceDL && bDT ) + { + // Instead of a DD we must use a DT from the level above this one. + nNewDefListLvl++; + } + else if( !nNewDefListLvl && !rWrt.m_bCfgOutStyles && bPara && + rULSpace.GetLower()==0 && + ((bUseParSpace && bIsNextTextNode) || rWrt.m_nDefListLvl==1) && + (!pAdjItem || SvxAdjust::Left==pAdjItem->GetAdjust()) ) + { + // Export paragraphs without a lower spacing as DT + nNewDefListLvl = 1; + bDT = true; + rInfo.bParaPossible = false; + rWrt.m_bNoAlign = true; + } + } + + if( nNewDefListLvl != rWrt.m_nDefListLvl ) + rWrt.OutAndSetDefList( nNewDefListLvl ); + + // if necessary, start a bulleted or numbered list + if( rInfo.bInNumberBulletList ) + { + OSL_ENSURE( !rWrt.m_nDefListLvl, "DL cannot be inside OL!" ); + OutHTML_NumberBulletListStart( rWrt, aNumInfo ); + + if( bNumbered ) + { + if( !rWrt.m_aBulletGrfs[nBulletGrfLvl].isEmpty() ) + bNumbered = false; + else + nBulletGrfLvl = 255; + } + } + + // Take the defaults of the style, because they don't need to be + // exported + rWrt.m_nDfltLeftMargin = pFormatInfo->nLeftMargin; + rWrt.m_nDfltRightMargin = pFormatInfo->nRightMargin; + rWrt.m_nDfltFirstLineIndent = pFormatInfo->nFirstLineIndent; + + if( rInfo.bInNumberBulletList ) + { + if( !rWrt.IsHTMLMode( HTMLMODE_LSPACE_IN_NUMBER_BULLET ) ) + rWrt.m_nDfltLeftMargin = rTextLeftMargin.GetTextLeft(); + + // In numbered lists, don't output a first line indent. + rWrt.m_nFirstLineIndent = rFirstLine.GetTextFirstLineOffset(); + } + + if( rInfo.bInNumberBulletList && bNumbered && bPara && !rWrt.m_bCfgOutStyles ) + { + // a single LI doesn't have spacing + rWrt.m_nDfltTopMargin = 0; + rWrt.m_nDfltBottomMargin = 0; + } + else if( rWrt.m_nDefListLvl && bPara ) + { + // a single DD doesn't have spacing, as well + rWrt.m_nDfltTopMargin = 0; + rWrt.m_nDfltBottomMargin = 0; + } + else + { + rWrt.m_nDfltTopMargin = pFormatInfo->nTopMargin; + // if in the last paragraph of a table the lower paragraph spacing + // is changed, Netscape doesn't get it. That's why we don't + // export anything here for now, by setting this spacing to the + // default value. + if( rWrt.m_bCfgNetscape4 && !bUseParSpace ) + rWrt.m_nDfltBottomMargin = rULSpace.GetLower(); + else + rWrt.m_nDfltBottomMargin = pFormatInfo->nBottomMargin; + } + + if( rWrt.m_nDefListLvl ) + { + rWrt.m_nLeftMargin = + (rWrt.m_nDefListLvl-1) * rWrt.m_nDefListMargin; + } + + if (rWrt.IsLFPossible() && !rWrt.m_bFirstLine) + rWrt.OutNewLine(); // paragraph tag on a new line + rInfo.bOutPara = false; + + // this is now our new token + rWrt.ChangeParaToken( nToken ); + + bool bHasParSpace = bUseParSpace && rULSpace.GetLower() > 0; + // XHTML doesn't allow character children for <blockquote>. + bool bXhtmlBlockQuote = rWrt.mbXHTML && rInfo.aToken == OOO_STRING_SVTOOLS_HTML_blockquote; + + // if necessary, start a new list item + bool bNumberedForListItem = bNumbered; + if (!bNumberedForListItem) + { + // Open a list also for the leading unnumbered nodes (= list headers in ODF terminology); + // to do that, detect if this unnumbered node is the first in this list + const auto& rPrevListInfo = rWrt.GetNumInfo(); + if (rPrevListInfo.GetNumRule() != aNumInfo.GetNumRule() || aNumInfo.IsRestart(rPrevListInfo) + || rPrevListInfo.GetDepth() < aNumInfo.GetDepth()) + bNumberedForListItem = true; + } + if( rInfo.bInNumberBulletList && bNumberedForListItem ) + { + OStringBuffer sOut(rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_li); + if (!bNumbered) + { + // Handles list headers (<text:list-header> ODF element) + sOut.append(" " OOO_STRING_SVTOOLS_HTML_O_style "=\"display: block\""); + } + else if (USHRT_MAX != nNumStart) + sOut.append(" " OOO_STRING_SVTOOLS_HTML_O_value "=\"" + OString::number(nNumStart) + + "\""); + HTMLOutFuncs::Out_AsciiTag(rWrt.Strm(), sOut); + } + + if( rWrt.m_nDefListLvl > 0 && !bForceDL ) + { + OString aTag = bDT ? OOO_STRING_SVTOOLS_HTML_dt : OOO_STRING_SVTOOLS_HTML_dd; + HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), Concat2View(rWrt.GetNamespace() + aTag) ); + } + + if( pAdjItem && + rWrt.IsHTMLMode( HTMLMODE_NO_CONTROL_CENTERING ) && + rWrt.HasControls() ) + { + // The align=... attribute does behave strange in netscape + // if there are controls in a paragraph, because the control and + // all text behind the control does not recognize this attribute. + OString sOut = "<" + rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_division; + rWrt.Strm().WriteOString( sOut ); + + rWrt.m_bTextAttr = false; + rWrt.m_bOutOpts = true; + OutHTML_SvxAdjust( rWrt, *pAdjItem ); + rWrt.Strm().WriteChar( '>' ); + pAdjItem = nullptr; + rWrt.m_bNoAlign = false; + rInfo.bOutDiv = true; + rWrt.IncIndentLevel(); + rWrt.SetLFPossible(true); + rWrt.OutNewLine(); + } + + // for BLOCKQUOTE, ADDRESS and DD we output another paragraph token, if + // - no styles are written and + // - a lower spacing or a paragraph alignment exists + // Also, XHTML does not allow character children in this context. + OString aToken = rInfo.aToken; + if( (!rWrt.m_bCfgOutStyles || rWrt.mbXHTML) && rInfo.bParaPossible && !bPara && + (bHasParSpace || bXhtmlBlockQuote || pAdjItem) ) + { + HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), Concat2View(rWrt.GetNamespace() + rInfo.aToken) ); + aToken = OOO_STRING_SVTOOLS_HTML_parabreak ""_ostr; + bPara = true; + rWrt.m_bNoAlign = false; + } + + LanguageType eLang; + if (rInfo.moItemSet) + { + const SvxLanguageItem& rLangItem = rInfo.moItemSet->Get(SwHTMLWriter::GetLangWhichIdFromScript(rWrt.m_nCSS1Script)); + eLang = rLangItem.GetLanguage(); + } + else + eLang = rWrt.m_eLang; + + if( rInfo.moItemSet ) + { + static const TypedWhichId<SvxLanguageItem> aWhichIds[3] = { RES_CHRATR_LANGUAGE, RES_CHRATR_CJK_LANGUAGE, RES_CHRATR_CTL_LANGUAGE }; + + for(auto const & i : aWhichIds) + { + // export language if it differs from the default language only. + const SvxLanguageItem* pTmpItem = rInfo.moItemSet->GetItemIfSet( i ); + if( pTmpItem && pTmpItem->GetLanguage() == eLang ) + rInfo.moItemSet->ClearItem( i ); + } + } + + // and the text direction + SvxFrameDirection nDir = rWrt.GetHTMLDirection( + (pNodeItemSet ? pNodeItemSet->Get( RES_FRAMEDIR ) + : rFormat.GetFrameDir() ).GetValue() ); + + // We only write a <P>, if + // - we are not inside OL/UL/DL, or + // - the paragraph of an OL/UL is not numbered or + // - styles are not exported and + // - a lower spacing, or + // - a paragraph alignment exists, or + // - styles are exported and + // - the text body style was changed, or + // - a user format is exported, or + // - a paragraph attribute exists + if( !bPara || + (!rInfo.bInNumberBulletList && !rWrt.m_nDefListLvl) || + (rInfo.bInNumberBulletList && !bNumbered) || + (!rWrt.m_bCfgOutStyles && + (bHasParSpace || bXhtmlBlockQuote || pAdjItem || + (eLang != LANGUAGE_DONTKNOW && eLang != rWrt.m_eLang))) || + nDir != rWrt.m_nDirection || + rWrt.m_bCfgOutStyles ) + { + // now, options are output + rWrt.m_bTextAttr = false; + rWrt.m_bOutOpts = true; + + OString sOut = "<" + rWrt.GetNamespace() + aToken; + + if( eLang != LANGUAGE_DONTKNOW && eLang != rWrt.m_eLang ) + { + rWrt.Strm().WriteOString( sOut ); + sOut = ""_ostr; + rWrt.OutLanguage( eLang ); + } + + if( nDir != rWrt.m_nDirection ) + { + if( !sOut.isEmpty() ) + { + rWrt.Strm().WriteOString( sOut ); + sOut = ""_ostr; + } + rWrt.OutDirection( nDir ); + } + + if( rWrt.m_bCfgOutStyles && + (!pFormatInfo->aClass.isEmpty() || pFormatInfo->bScriptDependent) ) + { + sOut += " " OOO_STRING_SVTOOLS_HTML_O_class "=\""; + rWrt.Strm().WriteOString( sOut ); + sOut = ""_ostr; + OUString aClass( pFormatInfo->aClass ); + if( pFormatInfo->bScriptDependent ) + { + if( !aClass.isEmpty() ) + aClass += "-"; + switch( rWrt.m_nCSS1Script ) + { + case CSS1_OUTMODE_WESTERN: + aClass += "western"; + break; + case CSS1_OUTMODE_CJK: + aClass += "cjk"; + break; + case CSS1_OUTMODE_CTL: + aClass += "ctl"; + break; + } + } + HTMLOutFuncs::Out_String( rWrt.Strm(), aClass ); + sOut += "\""; + } + rWrt.Strm().WriteOString( sOut ); + sOut = ""_ostr; + + std::string_view sStyle; + if (rWrt.IsSpacePreserve()) + { + if (rWrt.mbXHTML) + rWrt.Strm().WriteOString(" xml:space=\"preserve\""); + else + sStyle = "white-space: pre-wrap"; + } + + // if necessary, output alignment + if( !rWrt.m_bNoAlign && pAdjItem ) + OutHTML_SvxAdjust( rWrt, *pAdjItem ); + + rWrt.m_bParaDotLeaders = bPara && rWrt.m_bCfgPrintLayout && rWrt.indexOfDotLeaders( + pTextNd->GetAnyFormatColl().GetPoolFormatId(), pTextNd->GetText()) > -1; + + // and now, if necessary, the STYLE options + if (rWrt.m_bCfgOutStyles && rInfo.moItemSet) + { + OutCSS1_ParaTagStyleOpt(rWrt, *rInfo.moItemSet, sStyle); + } + + if (rWrt.m_bParaDotLeaders) { + sOut += " " OOO_STRING_SVTOOLS_HTML_O_class "=\"" + sCSS2_P_CLASS_leaders "\"><" + OOO_STRING_SVTOOLS_HTML_O_span; + rWrt.Strm().WriteOString( sOut ); + sOut = ""_ostr; + } + + rWrt.Strm().WriteChar( '>' ); + + // is a </P> supposed to be written? + rInfo.bOutPara = + bPara && + ( rWrt.m_bCfgOutStyles || bHasParSpace ); + + // if no end tag is supposed to be written, delete it + if( bNoEndTag ) + rInfo.aToken.clear(); + } + + if( nBulletGrfLvl != 255 ) + { + OSL_ENSURE( aNumInfo.GetNumRule(), "Where is the numbering gone???" ); + OSL_ENSURE( nBulletGrfLvl < MAXLEVEL, "There are not this many layers." ); + const SwNumFormat& rNumFormat = aNumInfo.GetNumRule()->Get(nBulletGrfLvl); + OutHTML_BulletImage( rWrt, OOO_STRING_SVTOOLS_HTML_image, rNumFormat.GetBrush(), + rWrt.m_aBulletGrfs[nBulletGrfLvl]); + } + + rWrt.GetNumInfo() = aNumInfo; + + // reset the defaults + rWrt.m_nDfltLeftMargin = 0; + rWrt.m_nDfltRightMargin = 0; + rWrt.m_nDfltFirstLineIndent = 0; + rWrt.m_nDfltTopMargin = 0; + rWrt.m_nDfltBottomMargin = 0; + rWrt.m_nLeftMargin = 0; + rWrt.m_nFirstLineIndent = 0; +} + +static void OutHTML_SwFormatOff( SwHTMLWriter& rWrt, const SwHTMLTextCollOutputInfo& rInfo ) +{ + // if there is no token, we don't need to output anything + if( rInfo.aToken.isEmpty() ) + { + rWrt.FillNextNumInfo(); + const SwHTMLNumRuleInfo& rNextInfo = *rWrt.GetNextNumInfo(); + // a bulleted list must be closed in PRE as well + if( rInfo.bInNumberBulletList ) + { + + const SwHTMLNumRuleInfo& rNRInfo = rWrt.GetNumInfo(); + if( rNextInfo.GetNumRule() != rNRInfo.GetNumRule() || + rNextInfo.GetDepth() != rNRInfo.GetDepth() || + rNextInfo.IsNumbered() || rNextInfo.IsRestart(rNRInfo) ) + rWrt.ChangeParaToken( HtmlTokenId::NONE ); + OutHTML_NumberBulletListEnd( rWrt, rNextInfo ); + } + else if( rNextInfo.GetNumRule() != nullptr ) + rWrt.ChangeParaToken( HtmlTokenId::NONE ); + + return; + } + + if( rInfo.ShouldOutputToken() ) + { + if (rWrt.IsPrettyPrint() && rWrt.IsLFPossible()) + rWrt.OutNewLine( true ); + + // if necessary, for BLOCKQUOTE, ADDRESS and DD another paragraph token + // is output, if + // - no styles are written and + // - a lower spacing exists + if( rInfo.bParaPossible && rInfo.bOutPara ) + HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), Concat2View(rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_parabreak), false ); + + HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), Concat2View(rWrt.GetNamespace() + rInfo.aToken), false ); + rWrt.SetLFPossible( + rInfo.aToken != OOO_STRING_SVTOOLS_HTML_dt && + rInfo.aToken != OOO_STRING_SVTOOLS_HTML_dd && + rInfo.aToken != OOO_STRING_SVTOOLS_HTML_li); + } + if( rInfo.bOutDiv ) + { + rWrt.DecIndentLevel(); + if (rWrt.IsLFPossible()) + rWrt.OutNewLine(); + HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), Concat2View(rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_division), false ); + rWrt.SetLFPossible(true); + } + + // if necessary, close the list item, then close a bulleted or numbered list + if( rInfo.bInNumberBulletList ) + { + rWrt.FillNextNumInfo(); + OutHTML_NumberBulletListEnd( rWrt, *rWrt.GetNextNumInfo() ); + } +} + +namespace { + +class HTMLStartEndPos +{ + sal_Int32 m_nStart; + sal_Int32 m_nEnd; + std::unique_ptr<SfxPoolItem> m_pItem; + +public: + + HTMLStartEndPos( const SfxPoolItem& rItem, sal_Int32 nStt, sal_Int32 nE ); + + const SfxPoolItem* GetItem() const { return m_pItem.get(); } + + void SetStart(sal_Int32 nStt) { m_nStart = nStt; } + sal_Int32 GetStart() const { return m_nStart; } + + sal_Int32 GetEnd() const { return m_nEnd; } + void SetEnd(sal_Int32 nE) { m_nEnd = nE; } +}; + +} + +HTMLStartEndPos::HTMLStartEndPos(const SfxPoolItem& rItem, sal_Int32 nStt, sal_Int32 nE) + : m_nStart(nStt) + , m_nEnd(nE) + , m_pItem(rItem.Clone()) +{} + +typedef std::vector<HTMLStartEndPos *> HTMLStartEndPositions; + +namespace { + +enum HTMLOnOffState { HTML_NOT_SUPPORTED, // unsupported Attribute + HTML_REAL_VALUE, // Attribute with value + HTML_ON_VALUE, // Attribute is On-Tag + HTML_OFF_VALUE, // Attribute is Off-Tag + HTML_CHRFMT_VALUE, // Attribute for character format + HTML_COLOR_VALUE, // Attribute for foreground color + HTML_STYLE_VALUE, // Attribute must be exported as style + HTML_DROPCAP_VALUE, // DropCap-Attribute + HTML_AUTOFMT_VALUE }; // Attribute for automatic character styles + +class HTMLEndPosLst +{ + HTMLStartEndPositions m_aStartLst; // list, sorted for start positions + HTMLStartEndPositions m_aEndLst; // list, sorted for end positions + std::deque<sal_Int32> m_aScriptChgLst; // positions where script changes + // 0 is not contained in this list, + // but the text length + // the script that is valid up to the position + // contained in aScriptChgList at the same index + std::vector<sal_uInt16> m_aScriptLst; + + SwDoc* m_pDoc; // the current document + SwDoc* m_pTemplate; // the HTML template (or 0) + std::optional<Color> m_xDefaultColor; // the default foreground colors + std::set<OUString>& m_rScriptTextStyles; + + sal_uLong m_nHTMLMode; + bool m_bOutStyles : 1; // are styles exported + + // Insert/remove a SttEndPos in/from the Start and End lists. + // The end position is known. + void InsertItem_( HTMLStartEndPos *pPos, HTMLStartEndPositions::size_type nEndPos ); + void RemoveItem_( HTMLStartEndPositions::size_type nEndPos ); + + // determine the 'type' of the attribute + HTMLOnOffState GetHTMLItemState( const SfxPoolItem& rItem ); + + // does a specific OnTag item exist + bool ExistsOnTagItem( sal_uInt16 nWhich, sal_Int32 nPos ); + + // does an item exist that can be used to disable an attribute that + // is exported the same way as the supplied item in the same range? + bool ExistsOffTagItem( sal_uInt16 nWhich, sal_Int32 nStartPos, + sal_Int32 nEndPos ); + + // adapt the end of a split item + void FixSplittedItem( HTMLStartEndPos *pPos, sal_Int32 nNewEnd, + HTMLStartEndPositions::size_type nStartPos ); + + // insert an attribute in the lists and, if necessary, split it + void InsertItem( const SfxPoolItem& rItem, sal_Int32 nStart, + sal_Int32 nEnd ); + + // split an already existing attribute + void SplitItem( const SfxPoolItem& rItem, sal_Int32 nStart, + sal_Int32 nEnd ); + + // Insert without taking care of script + void InsertNoScript( const SfxPoolItem& rItem, sal_Int32 nStart, + sal_Int32 nEnd, SwHTMLFormatInfos& rFormatInfos, + bool bParaAttrs ); + + const SwHTMLFormatInfo *GetFormatInfo( const SwFormat& rFormat, + SwHTMLFormatInfos& rFormatInfos ); + +public: + + HTMLEndPosLst( SwDoc *pDoc, SwDoc* pTemplate, std::optional<Color> xDfltColor, + bool bOutStyles, sal_uLong nHTMLMode, + const OUString& rText, std::set<OUString>& rStyles ); + ~HTMLEndPosLst(); + + // insert an attribute + void Insert( const SfxPoolItem& rItem, sal_Int32 nStart, sal_Int32 nEnd, + SwHTMLFormatInfos& rFormatInfos, bool bParaAttrs=false ); + void Insert( const SfxItemSet& rItemSet, sal_Int32 nStart, sal_Int32 nEnd, + SwHTMLFormatInfos& rFormatInfos, bool bDeep, + bool bParaAttrs=false ); + void Insert( const SwDrawFrameFormat& rFormat, sal_Int32 nPos, + SwHTMLFormatInfos& rFormatInfos ); + + sal_uInt16 GetScriptAtPos( sal_Int32 nPos, + sal_uInt16 nWeak ); + + void OutStartAttrs( SwHTMLWriter& rWrt, sal_Int32 nPos ); + void OutEndAttrs( SwHTMLWriter& rWrt, sal_Int32 nPos ); + + bool IsHTMLMode(sal_uLong nMode) const { return (m_nHTMLMode & nMode) != 0; } +}; + +} + +void HTMLEndPosLst::InsertItem_( HTMLStartEndPos *pPos, HTMLStartEndPositions::size_type nEndPos ) +{ + // Insert the attribute in the Start list behind all attributes that + // were started before, or at the same position. + sal_Int32 nStart = pPos->GetStart(); + HTMLStartEndPositions::size_type i {0}; + + while (i < m_aStartLst.size() && m_aStartLst[i]->GetStart() <= nStart) + ++i; + m_aStartLst.insert(m_aStartLst.begin() + i, pPos); + + // the position in the End list was supplied + m_aEndLst.insert(m_aEndLst.begin() + nEndPos, pPos); +} + +void HTMLEndPosLst::RemoveItem_( HTMLStartEndPositions::size_type nEndPos ) +{ + HTMLStartEndPos* pPos = m_aEndLst[nEndPos]; + + // now, we are looking for it in the Start list + HTMLStartEndPositions::iterator it = std::find(m_aStartLst.begin(), m_aStartLst.end(), pPos); + OSL_ENSURE(it != m_aStartLst.end(), "Item not found in Start List!"); + if (it != m_aStartLst.end()) + m_aStartLst.erase(it); + + m_aEndLst.erase(m_aEndLst.begin() + nEndPos); + + delete pPos; +} + +HTMLOnOffState HTMLEndPosLst::GetHTMLItemState( const SfxPoolItem& rItem ) +{ + HTMLOnOffState eState = HTML_NOT_SUPPORTED; + switch( rItem.Which() ) + { + case RES_CHRATR_POSTURE: + case RES_CHRATR_CJK_POSTURE: + case RES_CHRATR_CTL_POSTURE: + switch( static_cast<const SvxPostureItem&>(rItem).GetPosture() ) + { + case ITALIC_NORMAL: + eState = HTML_ON_VALUE; + break; + case ITALIC_NONE: + eState = HTML_OFF_VALUE; + break; + default: + if( IsHTMLMode(HTMLMODE_SOME_STYLES) ) + eState = HTML_STYLE_VALUE; + break; + } + break; + + case RES_CHRATR_CROSSEDOUT: + switch( rItem.StaticWhichCast(RES_CHRATR_CROSSEDOUT).GetStrikeout() ) + { + case STRIKEOUT_SINGLE: + case STRIKEOUT_DOUBLE: + eState = HTML_ON_VALUE; + break; + case STRIKEOUT_NONE: + eState = HTML_OFF_VALUE; + break; + default: + ; + } + break; + + case RES_CHRATR_ESCAPEMENT: + switch( static_cast<SvxEscapement>(rItem.StaticWhichCast(RES_CHRATR_ESCAPEMENT).GetEnumValue()) ) + { + case SvxEscapement::Superscript: + case SvxEscapement::Subscript: + eState = HTML_ON_VALUE; + break; + case SvxEscapement::Off: + eState = HTML_OFF_VALUE; + break; + default: + ; + } + break; + + case RES_CHRATR_UNDERLINE: + switch( rItem.StaticWhichCast(RES_CHRATR_UNDERLINE).GetLineStyle() ) + { + case LINESTYLE_SINGLE: + eState = HTML_ON_VALUE; + break; + case LINESTYLE_NONE: + eState = HTML_OFF_VALUE; + break; + default: + if( IsHTMLMode(HTMLMODE_SOME_STYLES) ) + eState = HTML_STYLE_VALUE; + break; + } + break; + + case RES_CHRATR_OVERLINE: + case RES_CHRATR_HIDDEN: + if( IsHTMLMode(HTMLMODE_SOME_STYLES) ) + eState = HTML_STYLE_VALUE; + break; + + case RES_CHRATR_WEIGHT: + case RES_CHRATR_CJK_WEIGHT: + case RES_CHRATR_CTL_WEIGHT: + switch( static_cast<const SvxWeightItem&>(rItem).GetWeight() ) + { + case WEIGHT_BOLD: + eState = HTML_ON_VALUE; + break; + case WEIGHT_NORMAL: + eState = HTML_OFF_VALUE; + break; + default: + if( IsHTMLMode(HTMLMODE_SOME_STYLES) ) + eState = HTML_STYLE_VALUE; + break; + } + break; + + case RES_CHRATR_BLINK: + eState = rItem.StaticWhichCast(RES_CHRATR_BLINK).GetValue() ? HTML_ON_VALUE + : HTML_OFF_VALUE; + break; + + case RES_CHRATR_COLOR: + eState = HTML_COLOR_VALUE; + break; + + case RES_CHRATR_FONT: + case RES_CHRATR_FONTSIZE: + case RES_CHRATR_LANGUAGE: + case RES_CHRATR_CJK_FONT: + case RES_CHRATR_CJK_FONTSIZE: + case RES_CHRATR_CJK_LANGUAGE: + case RES_CHRATR_CTL_FONT: + case RES_CHRATR_CTL_FONTSIZE: + case RES_CHRATR_CTL_LANGUAGE: + case RES_TXTATR_INETFMT: + eState = HTML_REAL_VALUE; + break; + + case RES_TXTATR_CHARFMT: + eState = HTML_CHRFMT_VALUE; + break; + + case RES_TXTATR_AUTOFMT: + eState = HTML_AUTOFMT_VALUE; + break; + + case RES_CHRATR_CASEMAP: + eState = HTML_STYLE_VALUE; + break; + + case RES_CHRATR_KERNING: + eState = HTML_STYLE_VALUE; + break; + + case RES_CHRATR_BACKGROUND: + if( IsHTMLMode(HTMLMODE_SOME_STYLES) ) + eState = HTML_STYLE_VALUE; + break; + + case RES_PARATR_DROP: + eState = HTML_DROPCAP_VALUE; + break; + + case RES_CHRATR_BOX: + if( IsHTMLMode(HTMLMODE_SOME_STYLES) ) + eState = HTML_STYLE_VALUE; + break; + } + + return eState; +} + +bool HTMLEndPosLst::ExistsOnTagItem( sal_uInt16 nWhich, sal_Int32 nPos ) +{ + for (auto pTest : m_aStartLst) + { + if( pTest->GetStart() > nPos ) + { + // this attribute, and all attributes that follow, start later + break; + } + else if( pTest->GetEnd() > nPos ) + { + // the attribute starts before, or at, the current position and + // ends after it + const SfxPoolItem *pItem = pTest->GetItem(); + if( pItem->Which() == nWhich && + HTML_ON_VALUE == GetHTMLItemState(*pItem) ) + { + // an OnTag attribute was found + return true; + } + } + } + + return false; +} + +bool HTMLEndPosLst::ExistsOffTagItem( sal_uInt16 nWhich, sal_Int32 nStartPos, + sal_Int32 nEndPos ) +{ + if( nWhich != RES_CHRATR_CROSSEDOUT && + nWhich != RES_CHRATR_UNDERLINE && + nWhich != RES_CHRATR_BLINK ) + { + return false; + } + + for (auto pTest : m_aStartLst) + { + if( pTest->GetStart() > nStartPos ) + { + // this attribute, and all attributes that follow, start later + break; + } + else if( pTest->GetStart()==nStartPos && + pTest->GetEnd()==nEndPos ) + { + // the attribute starts before or at the current position and + // ends after it + const SfxPoolItem *pItem = pTest->GetItem(); + sal_uInt16 nTstWhich = pItem->Which(); + if( (nTstWhich == RES_CHRATR_CROSSEDOUT || + nTstWhich == RES_CHRATR_UNDERLINE || + nTstWhich == RES_CHRATR_BLINK) && + HTML_OFF_VALUE == GetHTMLItemState(*pItem) ) + { + // an OffTag attribute was found that is exported the same + // way as the current item + return true; + } + } + } + + return false; +} + +void HTMLEndPosLst::FixSplittedItem( HTMLStartEndPos *pPos, sal_Int32 nNewEnd, + HTMLStartEndPositions::size_type nStartPos ) +{ + // fix the end position accordingly + pPos->SetEnd( nNewEnd ); + + // remove the item from the End list + HTMLStartEndPositions::iterator it = std::find(m_aEndLst.begin(), m_aEndLst.end(), pPos); + OSL_ENSURE(it != m_aEndLst.end(), "Item not found in End List!"); + if (it != m_aEndLst.end()) + m_aEndLst.erase(it); + + // from now on, it is closed as the last one at the corresponding position + HTMLStartEndPositions::size_type nEndPos {0}; + while (nEndPos < m_aEndLst.size() && m_aEndLst[nEndPos]->GetEnd() <= nNewEnd) + ++nEndPos; + m_aEndLst.insert(m_aEndLst.begin() + nEndPos, pPos); + + // now, adjust the attributes that got started afterwards + for (HTMLStartEndPositions::size_type i = nStartPos + 1; i < m_aStartLst.size(); ++i) + { + HTMLStartEndPos* pTest = m_aStartLst[i]; + sal_Int32 nTestEnd = pTest->GetEnd(); + if( pTest->GetStart() >= nNewEnd ) + { + // the Test attribute and all the following ones start, after the + // split attribute ends + break; + } + else if( nTestEnd > nNewEnd ) + { + // the Test attribute starts before the split attribute + // ends, and ends afterwards, i.e., it must be split, as well + + // set the new end + pTest->SetEnd( nNewEnd ); + + // remove the attribute from the End list + it = std::find(m_aEndLst.begin(), m_aEndLst.end(), pTest); + OSL_ENSURE(it != m_aEndLst.end(), "Item not found in End List!"); + if (it != m_aEndLst.end()) + m_aEndLst.erase(it); + + // it now ends as the first attribute in the respective position. + // We already know this position in the End list. + m_aEndLst.insert(m_aEndLst.begin() + nEndPos, pTest); + + // insert the 'rest' of the attribute + InsertItem( *pTest->GetItem(), nNewEnd, nTestEnd ); + } + } +} + +void HTMLEndPosLst::InsertItem( const SfxPoolItem& rItem, sal_Int32 nStart, + sal_Int32 nEnd ) +{ + HTMLStartEndPositions::size_type i; + for (i = 0; i < m_aEndLst.size(); i++) + { + HTMLStartEndPos* pTest = m_aEndLst[i]; + sal_Int32 nTestEnd = pTest->GetEnd(); + if( nTestEnd <= nStart ) + { + // the Test attribute ends, before the new one starts + continue; + } + else if( nTestEnd < nEnd ) + { + if( pTest->GetStart() < nStart ) + { + // the Test attribute ends, before the new one ends. Thus, the + // new attribute must be split. + InsertItem_( new HTMLStartEndPos( rItem, nStart, nTestEnd ), i ); + nStart = nTestEnd; + } + } + else + { + // the Test attribute (and all that follow) ends, before the new + // one ends + break; + } + } + + // one attribute must still be inserted + InsertItem_( new HTMLStartEndPos( rItem, nStart, nEnd ), i ); +} + +void HTMLEndPosLst::SplitItem( const SfxPoolItem& rItem, sal_Int32 nStart, + sal_Int32 nEnd ) +{ + sal_uInt16 nWhich = rItem.Which(); + + // first, we must search for the old items by using the start list and + // determine the new item range + + for (HTMLStartEndPositions::size_type i = 0; i < m_aStartLst.size(); ++i) + { + HTMLStartEndPos* pTest = m_aStartLst[i]; + sal_Int32 nTestStart = pTest->GetStart(); + sal_Int32 nTestEnd = pTest->GetEnd(); + + if( nTestStart >= nEnd ) + { + // this attribute, and all that follow, start later + break; + } + else if( nTestEnd > nStart ) + { + // the Test attribute ends in the range that must be deleted + const SfxPoolItem *pItem = pTest->GetItem(); + + // only the corresponding OnTag attributes have to be considered + if( pItem->Which() == nWhich && + HTML_ON_VALUE == GetHTMLItemState( *pItem ) ) + { + bool bDelete = true; + + if( nTestStart < nStart ) + { + // the start of the new attribute corresponds to the new + // end of the attribute + FixSplittedItem( pTest, nStart, i ); + bDelete = false; + } + else + { + // the Test item only starts after the new end of the + // attribute. Therefore, it can be completely erased. + m_aStartLst.erase(m_aStartLst.begin() + i); + i--; + + HTMLStartEndPositions::iterator it + = std::find(m_aEndLst.begin(), m_aEndLst.end(), pTest); + OSL_ENSURE(it != m_aEndLst.end(), "Item not found in End List!"); + if (it != m_aEndLst.end()) + m_aEndLst.erase(it); + } + + // if necessary, insert the second part of the split + // attribute + if( nTestEnd > nEnd ) + { + InsertItem( *pTest->GetItem(), nEnd, nTestEnd ); + } + + if( bDelete ) + delete pTest; + } + } + } +} + +const SwHTMLFormatInfo *HTMLEndPosLst::GetFormatInfo( const SwFormat& rFormat, + SwHTMLFormatInfos& rFormatInfos ) +{ + SwHTMLFormatInfo *pFormatInfo; + std::unique_ptr<SwHTMLFormatInfo> pTmpInfo(new SwHTMLFormatInfo(&rFormat)); + SwHTMLFormatInfos::iterator it = rFormatInfos.find( pTmpInfo ); + if (it != rFormatInfos.end()) + { + pFormatInfo = it->get(); + } + else + { + pFormatInfo = new SwHTMLFormatInfo(&rFormat, m_pDoc, m_pTemplate, m_bOutStyles); + rFormatInfos.insert(std::unique_ptr<SwHTMLFormatInfo>(pFormatInfo)); + if (m_rScriptTextStyles.count(rFormat.GetName())) + pFormatInfo->bScriptDependent = true; + } + + return pFormatInfo; +} + +HTMLEndPosLst::HTMLEndPosLst(SwDoc* pD, SwDoc* pTempl, std::optional<Color> xDfltCol, bool bStyles, + sal_uLong nMode, const OUString& rText, std::set<OUString>& rStyles) + : m_pDoc(pD) + , m_pTemplate(pTempl) + , m_xDefaultColor(std::move(xDfltCol)) + , m_rScriptTextStyles(rStyles) + , m_nHTMLMode(nMode) + , m_bOutStyles(bStyles) +{ + sal_Int32 nEndPos = rText.getLength(); + sal_Int32 nPos = 0; + while( nPos < nEndPos ) + { + sal_uInt16 nScript = g_pBreakIt->GetBreakIter()->getScriptType( rText, nPos ); + nPos = g_pBreakIt->GetBreakIter()->endOfScript( rText, nPos, nScript ); + m_aScriptChgLst.push_back(nPos); + m_aScriptLst.push_back(nScript); + } +} + +HTMLEndPosLst::~HTMLEndPosLst() +{ + OSL_ENSURE(m_aStartLst.empty(), "Start List not empty in destructor"); + OSL_ENSURE(m_aEndLst.empty(), "End List not empty in destructor"); +} + +void HTMLEndPosLst::InsertNoScript( const SfxPoolItem& rItem, + sal_Int32 nStart, sal_Int32 nEnd, + SwHTMLFormatInfos& rFormatInfos, bool bParaAttrs ) +{ + // no range ?? in that case, don't take it, it will never take effect !! + if( nStart == nEnd ) + return; + + bool bSet = false, bSplit = false; + switch( GetHTMLItemState(rItem) ) + { + case HTML_ON_VALUE: + // output the attribute, if it isn't 'on', already + if( !ExistsOnTagItem( rItem.Which(), nStart ) ) + bSet = true; + break; + + case HTML_OFF_VALUE: + // If the corresponding attribute is 'on', split it. + // Additionally, output it as Style, if it is not set for the + // whole paragraph, because in that case it was already output + // together with the paragraph tag. + if( ExistsOnTagItem( rItem.Which(), nStart ) ) + bSplit = true; + bSet = m_bOutStyles && !bParaAttrs && !ExistsOffTagItem(rItem.Which(), nStart, nEnd); + break; + + case HTML_REAL_VALUE: + // we can always output the attribute + bSet = true; + break; + + case HTML_STYLE_VALUE: + // We can only output the attribute as CSS1. If it is set for + // the paragraph, it was already output with the paragraph tag. + // The only exception is the character-background attribute. This + // attribute must always be handled like a Hint. + bSet = m_bOutStyles + && (!bParaAttrs || rItem.Which() == RES_CHRATR_BACKGROUND + || rItem.Which() == RES_CHRATR_BOX || rItem.Which() == RES_CHRATR_OVERLINE); + break; + + case HTML_CHRFMT_VALUE: + { + OSL_ENSURE( RES_TXTATR_CHARFMT == rItem.Which(), + "Not a character style after all" ); + const SwFormatCharFormat& rChrFormat = rItem.StaticWhichCast(RES_TXTATR_CHARFMT); + const SwCharFormat* pFormat = rChrFormat.GetCharFormat(); + + const SwHTMLFormatInfo *pFormatInfo = GetFormatInfo( *pFormat, rFormatInfos ); + if( !pFormatInfo->aToken.isEmpty() ) + { + // output the character style tag before the hard + // attributes + InsertItem( rItem, nStart, nEnd ); + } + if( pFormatInfo->moItemSet ) + { + Insert( *pFormatInfo->moItemSet, nStart, nEnd, + rFormatInfos, true, bParaAttrs ); + } + } + break; + + case HTML_AUTOFMT_VALUE: + { + OSL_ENSURE( RES_TXTATR_AUTOFMT == rItem.Which(), + "Not an automatic style, after all" ); + const SwFormatAutoFormat& rAutoFormat = rItem.StaticWhichCast(RES_TXTATR_AUTOFMT); + const std::shared_ptr<SfxItemSet>& pSet = rAutoFormat.GetStyleHandle(); + if( pSet ) + Insert( *pSet, nStart, nEnd, rFormatInfos, true, bParaAttrs ); + } + break; + + case HTML_COLOR_VALUE: + // A foreground color as a paragraph attribute is only exported if + // it is not the same as the default color. + { + OSL_ENSURE( RES_CHRATR_COLOR == rItem.Which(), + "Not a foreground color, after all" ); + Color aColor( rItem.StaticWhichCast(RES_CHRATR_COLOR).GetValue() ); + if( COL_AUTO == aColor ) + aColor = COL_BLACK; + bSet = !bParaAttrs || !m_xDefaultColor || !m_xDefaultColor->IsRGBEqual(aColor); + } + break; + + case HTML_DROPCAP_VALUE: + { + OSL_ENSURE( RES_PARATR_DROP == rItem.Which(), + "Not a drop cap, after all" ); + const SwFormatDrop& rDrop = rItem.StaticWhichCast(RES_PARATR_DROP); + nEnd = nStart + rDrop.GetChars(); + if (!m_bOutStyles) + { + // At least use the attributes of the character style + const SwCharFormat *pCharFormat = rDrop.GetCharFormat(); + if( pCharFormat ) + { + Insert( pCharFormat->GetAttrSet(), nStart, nEnd, + rFormatInfos, true, bParaAttrs ); + } + } + else + { + bSet = true; + } + } + break; + default: + ; + } + + if( bSet ) + InsertItem( rItem, nStart, nEnd ); + if( bSplit ) + SplitItem( rItem, nStart, nEnd ); +} + +void HTMLEndPosLst::Insert( const SfxPoolItem& rItem, + sal_Int32 nStart, sal_Int32 nEnd, + SwHTMLFormatInfos& rFormatInfos, bool bParaAttrs ) +{ + bool bDependsOnScript = false, bDependsOnAnyScript = false; + sal_uInt16 nScript = i18n::ScriptType::LATIN; + switch( rItem.Which() ) + { + case RES_CHRATR_FONT: + case RES_CHRATR_FONTSIZE: + case RES_CHRATR_LANGUAGE: + case RES_CHRATR_POSTURE: + case RES_CHRATR_WEIGHT: + bDependsOnScript = true; + nScript = i18n::ScriptType::LATIN; + break; + + case RES_CHRATR_CJK_FONT: + case RES_CHRATR_CJK_FONTSIZE: + case RES_CHRATR_CJK_LANGUAGE: + case RES_CHRATR_CJK_POSTURE: + case RES_CHRATR_CJK_WEIGHT: + bDependsOnScript = true; + nScript = i18n::ScriptType::ASIAN; + break; + + case RES_CHRATR_CTL_FONT: + case RES_CHRATR_CTL_FONTSIZE: + case RES_CHRATR_CTL_LANGUAGE: + case RES_CHRATR_CTL_POSTURE: + case RES_CHRATR_CTL_WEIGHT: + bDependsOnScript = true; + nScript = i18n::ScriptType::COMPLEX; + break; + case RES_TXTATR_CHARFMT: + { + const SwFormatCharFormat& rChrFormat = rItem.StaticWhichCast(RES_TXTATR_CHARFMT); + const SwCharFormat* pFormat = rChrFormat.GetCharFormat(); + const SwHTMLFormatInfo *pFormatInfo = GetFormatInfo( *pFormat, rFormatInfos ); + if( pFormatInfo->bScriptDependent ) + { + bDependsOnScript = true; + bDependsOnAnyScript = true; + } + } + break; + case RES_TXTATR_INETFMT: + { + if (GetFormatInfo(*m_pDoc->getIDocumentStylePoolAccess().GetCharFormatFromPool( + RES_POOLCHR_INET_NORMAL), + rFormatInfos) + ->bScriptDependent + || GetFormatInfo(*m_pDoc->getIDocumentStylePoolAccess().GetCharFormatFromPool( + RES_POOLCHR_INET_VISIT), + rFormatInfos) + ->bScriptDependent) + { + bDependsOnScript = true; + bDependsOnAnyScript = true; + } + } + break; + } + + if( bDependsOnScript ) + { + sal_Int32 nPos = nStart; + for (size_t i = 0; i < m_aScriptChgLst.size(); i++) + { + sal_Int32 nChgPos = m_aScriptChgLst[i]; + if( nPos >= nChgPos ) + { + // the hint starts behind or at the next script change, + // so we may continue with this position. + continue; + } + if( nEnd <= nChgPos ) + { + // the (rest of) the hint ends before or at the next script + // change, so we can insert it, but only if it belongs + // to the current script. + if (bDependsOnAnyScript || nScript == m_aScriptLst[i]) + InsertNoScript( rItem, nPos, nEnd, rFormatInfos, + bParaAttrs ); + break; + } + + // the hint starts before the next script change and ends behind + // it, so we can insert a hint up to the next script change and + // continue with the rest of the hint. + if (bDependsOnAnyScript || nScript == m_aScriptLst[i]) + InsertNoScript( rItem, nPos, nChgPos, rFormatInfos, bParaAttrs ); + nPos = nChgPos; + } + } + else + { + InsertNoScript( rItem, nStart, nEnd, rFormatInfos, bParaAttrs ); + } +} + +void HTMLEndPosLst::Insert( const SfxItemSet& rItemSet, + sal_Int32 nStart, sal_Int32 nEnd, + SwHTMLFormatInfos& rFormatInfos, + bool bDeep, bool bParaAttrs ) +{ + SfxWhichIter aIter( rItemSet ); + + sal_uInt16 nWhich = aIter.FirstWhich(); + while( nWhich ) + { + const SfxPoolItem *pItem; + if( SfxItemState::SET == aIter.GetItemState( bDeep, &pItem ) ) + { + Insert( *pItem, nStart, nEnd, rFormatInfos, bParaAttrs ); + } + + nWhich = aIter.NextWhich(); + } +} + +void HTMLEndPosLst::Insert( const SwDrawFrameFormat& rFormat, sal_Int32 nPos, + SwHTMLFormatInfos& rFormatInfos ) +{ + const SdrObject* pTextObj = SwHTMLWriter::GetMarqueeTextObj( rFormat ); + + if( !pTextObj ) + return; + + // get the edit engine attributes of the object as SW attributes and + // insert them as hints. Because of the amount of Hints the styles + // are not considered! + const SfxItemSet& rFormatItemSet = rFormat.GetAttrSet(); + SfxItemSetFixed<RES_CHRATR_BEGIN, RES_CHRATR_END> aItemSet( *rFormatItemSet.GetPool() ); + SwHTMLWriter::GetEEAttrsFromDrwObj( aItemSet, pTextObj ); + bool bOutStylesOld = m_bOutStyles; + m_bOutStyles = false; + Insert( aItemSet, nPos, nPos+1, rFormatInfos, false ); + m_bOutStyles = bOutStylesOld; +} + +sal_uInt16 HTMLEndPosLst::GetScriptAtPos( sal_Int32 nPos, sal_uInt16 nWeak ) +{ + sal_uInt16 nRet = CSS1_OUTMODE_ANY_SCRIPT; + + size_t nScriptChgs = m_aScriptChgLst.size(); + size_t i=0; + while (i < nScriptChgs && nPos >= m_aScriptChgLst[i]) + i++; + OSL_ENSURE( i < nScriptChgs, "script list is too short" ); + if( i < nScriptChgs ) + { + if (i18n::ScriptType::WEAK == m_aScriptLst[i]) + nRet = nWeak; + else + nRet = SwHTMLWriter::GetCSS1ScriptForScriptType(m_aScriptLst[i]); + } + + return nRet; +} + +void HTMLEndPosLst::OutStartAttrs( SwHTMLWriter& rWrt, sal_Int32 nPos ) +{ + rWrt.m_bTagOn = true; + + // Character border attribute must be the first which is written out + // because of border merge. + HTMLStartEndPositions::size_type nCharBoxIndex = 0; + while (nCharBoxIndex < m_aStartLst.size() + && m_aStartLst[nCharBoxIndex]->GetItem()->Which() != RES_CHRATR_BOX) + { + ++nCharBoxIndex; + } + + // the attributes of the start list are sorted in ascending order + for (HTMLStartEndPositions::size_type i = 0; i < m_aStartLst.size(); ++i) + { + HTMLStartEndPos *pPos = nullptr; + if (nCharBoxIndex < m_aStartLst.size()) + { + if( i == 0 ) + pPos = m_aStartLst[nCharBoxIndex]; + else if( i == nCharBoxIndex ) + pPos = m_aStartLst[0]; + else + pPos = m_aStartLst[i]; + } + else + pPos = m_aStartLst[i]; + + sal_Int32 nStart = pPos->GetStart(); + if( nStart > nPos ) + { + // this attribute, and all that follow, will be opened later on + break; + } + else if( nStart == nPos ) + { + // output the attribute + sal_uInt16 nCSS1Script = rWrt.m_nCSS1Script; + sal_uInt16 nWhich = pPos->GetItem()->Which(); + if( RES_TXTATR_CHARFMT == nWhich || + RES_TXTATR_INETFMT == nWhich || + RES_PARATR_DROP == nWhich ) + { + rWrt.m_nCSS1Script = GetScriptAtPos( nPos, nCSS1Script ); + } + HTMLOutFuncs::FlushToAscii( rWrt.Strm() ); // was one time only - do we still need it? + Out( aHTMLAttrFnTab, *pPos->GetItem(), rWrt ); + rWrt.maStartedAttributes[pPos->GetItem()->Which()]++; + rWrt.m_nCSS1Script = nCSS1Script; + } + } +} + +void HTMLEndPosLst::OutEndAttrs( SwHTMLWriter& rWrt, sal_Int32 nPos ) +{ + rWrt.m_bTagOn = false; + + // the attributes in the End list are sorted in ascending order + HTMLStartEndPositions::size_type i {0}; + while (i < m_aEndLst.size()) + { + HTMLStartEndPos* pPos = m_aEndLst[i]; + sal_Int32 nEnd = pPos->GetEnd(); + + if( SAL_MAX_INT32 == nPos || nEnd == nPos ) + { + HTMLOutFuncs::FlushToAscii( rWrt.Strm() ); // was one time only - do we still need it? + // Skip closing span if next character span has the same border (border merge) + bool bSkipOut = false; + if( pPos->GetItem()->Which() == RES_CHRATR_BOX ) + { + HTMLStartEndPositions::iterator it + = std::find(m_aStartLst.begin(), m_aStartLst.end(), pPos); + OSL_ENSURE(it != m_aStartLst.end(), "Item not found in Start List!"); + if (it != m_aStartLst.end()) + ++it; + while (it != m_aStartLst.end()) + { + HTMLStartEndPos *pEndPos = *it; + if( pEndPos->GetItem()->Which() == RES_CHRATR_BOX && + *static_cast<const SvxBoxItem*>(pEndPos->GetItem()) == + *static_cast<const SvxBoxItem*>(pPos->GetItem()) ) + { + pEndPos->SetStart(pPos->GetStart()); + bSkipOut = true; + break; + } + ++it; + } + } + if( !bSkipOut ) + { + Out( aHTMLAttrFnTab, *pPos->GetItem(), rWrt ); + rWrt.maStartedAttributes[pPos->GetItem()->Which()]--; + } + RemoveItem_( i ); + } + else if( nEnd > nPos ) + { + // this attribute, and all that follow, are closed later on + break; + } + else + { + // The attribute is closed before the current position. This + // is not allowed, but we can handle it anyway. + OSL_ENSURE( nEnd >= nPos, + "The attribute should've been closed a long time ago" ); + i++; + } + } +} + +static constexpr bool IsLF(sal_Unicode ch) { return ch == '\n'; } + +static constexpr bool IsWhitespaceExcludingLF(sal_Unicode ch) +{ + return ch == ' ' || ch == '\t' || ch == '\r'; +} + +static constexpr bool IsWhitespaceIncludingLF(sal_Unicode ch) +{ + return IsWhitespaceExcludingLF(ch) || IsLF(ch); +} + +static bool NeedPreserveWhitespace(std::u16string_view str, bool xml) +{ + if (str.empty()) + return false; + // leading / trailing spaces + // A leading / trailing \n would turn into a leading / trailing <br/>, + // and will not disappear, even without space preserving option + if (IsWhitespaceExcludingLF(str.front()) || IsWhitespaceExcludingLF(str.back())) + return true; + for (size_t i = 0; i < str.size(); ++i) + { + if (xml) + { + // No need to consider \n, which convert to <br/>, when it's after a space + // (but handle it *before* a space) + if (IsWhitespaceIncludingLF(str[i])) + { + do + { + ++i; + if (i == str.size()) + return false; + } while (IsLF(str[i])); + if (IsWhitespaceExcludingLF(str[i])) + return true; // Second whitespace in a row + } + } + else // html + { + // Only consider \n, when an adjacent space is not \n - which would be eaten + // without a space preserving option + if (IsWhitespaceExcludingLF(str[i])) + { + ++i; + if (i == str.size()) + return false; + if (IsWhitespaceIncludingLF(str[i])) + return true; // Any whitespace after a non-LF whitespace + } + else if (IsLF(str[i])) + { + do + { + ++i; + if (i == str.size()) + return false; + } + while (IsLF(str[i])); + if (IsWhitespaceExcludingLF(str[i])) + return true; // A non-LF whitespace after a LF + } + } + } + return false; +} + +/* Output of the nodes*/ +SwHTMLWriter& OutHTML_SwTextNode( SwHTMLWriter& rWrt, const SwContentNode& rNode ) +{ + const SwTextNode * pNd = &static_cast<const SwTextNode&>(rNode); + + const OUString& rStr = pNd->GetText(); + sal_Int32 nEnd = rStr.getLength(); + + // special case: empty node and HR style (horizontal rule) + // output a <HR>, only + sal_uInt16 nPoolId = pNd->GetAnyFormatColl().GetPoolFormatId(); + + // Handle horizontal rule <hr> + if (!nEnd && + (RES_POOLCOLL_HTML_HR==nPoolId || pNd->GetAnyFormatColl().GetName() == OOO_STRING_SVTOOLS_HTML_horzrule)) + { + // then, the paragraph-anchored graphics/OLE objects in the paragraph + // MIB 8.7.97: We enclose the line in a <PRE>. This means that the + // spacings are wrong, but otherwise we get an empty paragraph + // after the <HR> which is even uglier. + rWrt.ChangeParaToken( HtmlTokenId::NONE ); + + // Output all the nodes that are anchored to a frame + rWrt.OutFlyFrame( rNode.GetIndex(), 0, HtmlPosition::Any ); + + if (rWrt.IsLFPossible()) + rWrt.OutNewLine(); // paragraph tag on a new line + + rWrt.SetLFPossible(true); + + HtmlWriter aHtml(rWrt.Strm(), rWrt.maNamespace); + aHtml.prettyPrint(rWrt.IsPrettyPrint()); + aHtml.start(OOO_STRING_SVTOOLS_HTML_horzrule ""_ostr); + + const SfxItemSet* pItemSet = pNd->GetpSwAttrSet(); + if( !pItemSet ) + { + aHtml.end(); + return rWrt; + } + if (pItemSet->GetItemIfSet(RES_MARGIN_FIRSTLINE, false) + || pItemSet->GetItemIfSet(RES_MARGIN_TEXTLEFT, false) + || pItemSet->GetItemIfSet(RES_MARGIN_RIGHT, false)) + { + SvxFirstLineIndentItem const& rFirstLine(pItemSet->Get(RES_MARGIN_FIRSTLINE)); + SvxTextLeftMarginItem const& rTextLeftMargin(pItemSet->Get(RES_MARGIN_TEXTLEFT)); + SvxRightMarginItem const& rRightMargin(pItemSet->Get(RES_MARGIN_RIGHT)); + sal_Int32 const nLeft(rTextLeftMargin.GetLeft(rFirstLine)); + sal_Int32 const nRight(rRightMargin.GetRight()); + if( nLeft || nRight ) + { + const SwFrameFormat& rPgFormat = + rWrt.m_pDoc->getIDocumentStylePoolAccess().GetPageDescFromPool + ( RES_POOLPAGE_HTML, false )->GetMaster(); + const SwFormatFrameSize& rSz = rPgFormat.GetFrameSize(); + const SvxLRSpaceItem& rLR = rPgFormat.GetLRSpace(); + const SwFormatCol& rCol = rPgFormat.GetCol(); + + tools::Long nPageWidth = rSz.GetWidth() - rLR.GetLeft() - rLR.GetRight(); + + if( 1 < rCol.GetNumCols() ) + nPageWidth /= rCol.GetNumCols(); + + const SwTableNode* pTableNd = pNd->FindTableNode(); + if( pTableNd ) + { + const SwTableBox* pBox = pTableNd->GetTable().GetTableBox( + pNd->StartOfSectionIndex() ); + if( pBox ) + nPageWidth = pBox->GetFrameFormat()->GetFrameSize().GetWidth(); + } + + OString sWidth = OString::number(SwHTMLWriter::ToPixel(nPageWidth - nLeft - nRight)); + aHtml.attribute(OOO_STRING_SVTOOLS_HTML_O_width, sWidth); + + if( !nLeft ) + aHtml.attribute(OOO_STRING_SVTOOLS_HTML_O_align, OOO_STRING_SVTOOLS_HTML_AL_left); + else if( !nRight ) + aHtml.attribute(OOO_STRING_SVTOOLS_HTML_O_align, OOO_STRING_SVTOOLS_HTML_AL_right); + else + aHtml.attribute(OOO_STRING_SVTOOLS_HTML_O_align, OOO_STRING_SVTOOLS_HTML_AL_center); + } + } + + if( const SvxBoxItem* pBoxItem = pItemSet->GetItemIfSet( RES_BOX, false )) + { + const editeng::SvxBorderLine* pBorderLine = pBoxItem->GetBottom(); + if( pBorderLine ) + { + sal_uInt16 nWidth = pBorderLine->GetScaledWidth(); + OString sWidth = OString::number(SwHTMLWriter::ToPixel(nWidth)); + aHtml.attribute(OOO_STRING_SVTOOLS_HTML_O_size, sWidth); + + const Color& rBorderColor = pBorderLine->GetColor(); + if( !rBorderColor.IsRGBEqual( COL_GRAY ) ) + { + HtmlWriterHelper::applyColor(aHtml, OOO_STRING_SVTOOLS_HTML_O_color, rBorderColor); + } + + if( !pBorderLine->GetInWidth() ) + { + aHtml.attribute(OOO_STRING_SVTOOLS_HTML_O_noshade, OOO_STRING_SVTOOLS_HTML_O_noshade); + } + } + } + aHtml.end(); + return rWrt; + } + + // Do not export the empty nodes with 2pt fonts and standard style that + // are inserted before tables and sections, but do export bookmarks + // and paragraph anchored frames. + if( !nEnd && (nPoolId == RES_POOLCOLL_STANDARD || + nPoolId == RES_POOLCOLL_TABLE || + nPoolId == RES_POOLCOLL_TABLE_HDLN) ) + { + // The current node is empty and contains the standard style ... + const SvxFontHeightItem* pFontHeightItem; + const SfxItemSet* pItemSet = pNd->GetpSwAttrSet(); + if( pItemSet && pItemSet->Count() && + (pFontHeightItem = pItemSet->GetItemIfSet( RES_CHRATR_FONTSIZE, false )) && + 40 == pFontHeightItem->GetHeight() ) + { + // ... moreover, the 2pt font is set ... + SwNodeOffset nNdPos = rWrt.m_pCurrentPam->GetPoint()->GetNodeIndex(); + const SwNode *pNextNd = rWrt.m_pDoc->GetNodes()[nNdPos+1]; + const SwNode *pPrevNd = rWrt.m_pDoc->GetNodes()[nNdPos-1]; + bool bStdColl = nPoolId == RES_POOLCOLL_STANDARD; + if( ( bStdColl && (pNextNd->IsTableNode() || pNextNd->IsSectionNode()) ) || + ( !bStdColl && + pNextNd->IsEndNode() && + pPrevNd->IsStartNode() && + SwTableBoxStartNode == pPrevNd->GetStartNode()->GetStartNodeType() ) ) + { + // ... and it is located before a table or a section + rWrt.OutBookmarks(); + rWrt.SetLFPossible(rWrt.m_nLastParaToken == HtmlTokenId::NONE); + + // Output all frames that are anchored to this node + rWrt.OutFlyFrame( rNode.GetIndex(), 0, HtmlPosition::Any ); + rWrt.SetLFPossible(false); + + return rWrt; + } + } + } + + // catch PageBreaks and PageDescs + bool bPageBreakBehind = false; + if( rWrt.m_bCfgFormFeed && + !(rWrt.m_bOutTable || rWrt.m_bOutFlyFrame) && + rWrt.m_pStartNdIdx->GetIndex() != rWrt.m_pCurrentPam->GetPoint()->GetNodeIndex() ) + { + bool bPageBreakBefore = false; + const SfxItemSet* pItemSet = pNd->GetpSwAttrSet(); + + if( pItemSet ) + { + const SwFormatPageDesc* pPageDescItem = pItemSet->GetItemIfSet( RES_PAGEDESC ); + if( pPageDescItem && pPageDescItem->GetPageDesc() ) + { + bPageBreakBefore = true; + } + else if( const SvxFormatBreakItem* pItem = pItemSet->GetItemIfSet( RES_BREAK ) ) + { + switch( pItem->GetBreak() ) + { + case SvxBreak::PageBefore: + bPageBreakBefore = true; + break; + case SvxBreak::PageAfter: + bPageBreakBehind = true; + break; + case SvxBreak::PageBoth: + bPageBreakBefore = true; + bPageBreakBehind = true; + break; + default: + break; + } + } + } + + if( bPageBreakBefore ) + rWrt.Strm().WriteChar( '\f' ); + } + + // if necessary, open a form + rWrt.OutForm(); + + // Output the page-anchored frames that are 'anchored' to this node + bool bFlysLeft = rWrt.OutFlyFrame( rNode.GetIndex(), 0, HtmlPosition::Prefix ); + + // Output all frames that are anchored to this node that are supposed to + // be written before the paragraph tag. + if( bFlysLeft ) + { + bFlysLeft = rWrt.OutFlyFrame( rNode.GetIndex(), 0, HtmlPosition::Before ); + } + + if( rWrt.m_pCurrentPam->GetPoint()->GetNode() == rWrt.m_pCurrentPam->GetMark()->GetNode() ) + { + nEnd = rWrt.m_pCurrentPam->GetMark()->GetContentIndex(); + } + + // are there any hard attributes that must be written as options? + rWrt.m_bTagOn = true; + + // now, output the tag of the paragraph + const SwFormat& rFormat = pNd->GetAnyFormatColl(); + SwHTMLTextCollOutputInfo aFormatInfo; + bool bOldLFPossible = rWrt.IsLFPossible(); + bool bOldSpacePreserve = rWrt.IsSpacePreserve(); + if (rWrt.IsPreserveSpacesOnWritePrefSet()) + rWrt.SetSpacePreserve(NeedPreserveWhitespace(rStr, rWrt.mbReqIF)); + OutHTML_SwFormat( rWrt, rFormat, pNd->GetpSwAttrSet(), aFormatInfo ); + + // If we didn't open a new line before the paragraph tag, we do that now + rWrt.SetLFPossible(rWrt.m_nLastParaToken == HtmlTokenId::NONE); + if (!bOldLFPossible && rWrt.IsLFPossible()) + rWrt.OutNewLine(); + + // then, the bookmarks (including end tag) + rWrt.m_bOutOpts = false; + rWrt.OutBookmarks(); + + // now it's a good opportunity again for an LF - if it is still allowed + // FIXME: for LOK case we set rWrt.m_nWishLineLen as -1, for now keep old flow + // when LOK side will be fixed - don't insert new line at the beginning + if( rWrt.IsLFPossible() && rWrt.IsPrettyPrint() && rWrt.m_nWishLineLen >= 0 && + rWrt.GetLineLen() >= rWrt.m_nWishLineLen ) + { + rWrt.OutNewLine(); + } + rWrt.SetLFPossible(false); + + // find text that originates from an outline numbering + sal_Int32 nOffset = 0; + OUString aOutlineText; + OUString aFullText; + + // export numbering string as plain text only for the outline numbering, + // because the outline numbering isn't exported as a numbering - see <SwHTMLNumRuleInfo::Set(..)> + if ( pNd->IsOutline() && + pNd->GetNumRule() == pNd->GetDoc().GetOutlineNumRule() ) + { + aOutlineText = pNd->GetNumString(); + nOffset = nOffset + aOutlineText.getLength(); + aFullText = aOutlineText; + } + OUString aFootEndNoteSym; + if( rWrt.m_pFormatFootnote ) + { + aFootEndNoteSym = rWrt.GetFootEndNoteSym( *rWrt.m_pFormatFootnote ); + nOffset = nOffset + aFootEndNoteSym.getLength(); + aFullText += aFootEndNoteSym; + } + + // Table of Contents or other paragraph with dot leaders? + sal_Int32 nIndexTab = rWrt.indexOfDotLeaders( nPoolId, rStr ); + if (nIndexTab > -1) + // skip part after the tabulator (page number) + nEnd = nIndexTab; + + // are there any hard attributes that must be written as tags? + aFullText += rStr; + HTMLEndPosLst aEndPosLst( rWrt.m_pDoc, rWrt.m_xTemplate.get(), + rWrt.m_xDfltColor, rWrt.m_bCfgOutStyles, + rWrt.GetHTMLMode(), aFullText, + rWrt.m_aScriptTextStyles ); + if( aFormatInfo.moItemSet ) + { + aEndPosLst.Insert( *aFormatInfo.moItemSet, 0, nEnd + nOffset, + rWrt.m_CharFormatInfos, false, true ); + } + + if( !aOutlineText.isEmpty() || rWrt.m_pFormatFootnote ) + { + // output paragraph attributes, so that the text gets the attributes of + // the paragraph. + aEndPosLst.OutStartAttrs( rWrt, 0 ); + + // Theoretically, we would have to consider the character style of + // the numbering. Because it cannot be set via the UI, let's ignore + // it for now. + + if( !aOutlineText.isEmpty() ) + HTMLOutFuncs::Out_String( rWrt.Strm(), aOutlineText ); + + if( rWrt.m_pFormatFootnote ) + { + rWrt.OutFootEndNoteSym( *rWrt.m_pFormatFootnote, aFootEndNoteSym, + aEndPosLst.GetScriptAtPos( aOutlineText.getLength(), rWrt.m_nCSS1Script ) ); + rWrt.m_pFormatFootnote = nullptr; + } + } + + // for now, correct the start. I.e., if we only output part of the sentence, + // the attributes must be correct there, as well!! + rWrt.m_bTextAttr = true; + + size_t nAttrPos = 0; + sal_Int32 nStrPos = rWrt.m_pCurrentPam->GetPoint()->GetContentIndex(); + const SwTextAttr * pHt = nullptr; + const size_t nCntAttr = pNd->HasHints() ? pNd->GetSwpHints().Count() : 0; + if( nCntAttr && nStrPos > ( pHt = pNd->GetSwpHints().Get(0) )->GetStart() ) + { + // Ok, there are earlier attributes that we must output + do { + aEndPosLst.OutEndAttrs( rWrt, nStrPos + nOffset ); + + nAttrPos++; + if( pHt->Which() == RES_TXTATR_FIELD + || pHt->Which() == RES_TXTATR_ANNOTATION ) + continue; + + if ( pHt->End() && !pHt->HasDummyChar() ) + { + const sal_Int32 nHtEnd = *pHt->End(), + nHtStt = pHt->GetStart(); + if( !rWrt.m_bWriteAll && nHtEnd <= nStrPos ) + continue; + + // don't consider empty hints at the beginning - or should we ?? + if( nHtEnd == nHtStt ) + continue; + + // add attribute to the list + if( rWrt.m_bWriteAll ) + aEndPosLst.Insert( pHt->GetAttr(), nHtStt + nOffset, + nHtEnd + nOffset, + rWrt.m_CharFormatInfos ); + else + { + sal_Int32 nTmpStt = nHtStt < nStrPos ? nStrPos : nHtStt; + sal_Int32 nTmpEnd = std::min(nHtEnd, nEnd); + aEndPosLst.Insert( pHt->GetAttr(), nTmpStt + nOffset, + nTmpEnd + nOffset, + rWrt.m_CharFormatInfos ); + } + continue; + // but don't output it, that will be done later !! + } + + } while( nAttrPos < nCntAttr && nStrPos > + ( pHt = pNd->GetSwpHints().Get( nAttrPos ) )->GetStart() ); + + // so, let's output all collected attributes from the string pos on + aEndPosLst.OutEndAttrs( rWrt, nStrPos + nOffset ); + aEndPosLst.OutStartAttrs( rWrt, nStrPos + nOffset ); + } + + bool bWriteBreak = (HtmlTokenId::PREFORMTXT_ON != rWrt.m_nLastParaToken); + if (bWriteBreak && (pNd->GetNumRule() || rWrt.mbReqIF)) + { + // One line-break is exactly one <br> in the ReqIF case. + bWriteBreak = false; + } + + { + // Tabs are leading till there is a non-tab since the start of the paragraph. + bool bLeadingTab = true; + for( ; nStrPos < nEnd; nStrPos++ ) + { + // output the frames that are anchored to the current position + if( bFlysLeft ) + { + aEndPosLst.OutEndAttrs( rWrt, nStrPos + nOffset ); + bFlysLeft = rWrt.OutFlyFrame( rNode.GetIndex(), + nStrPos, HtmlPosition::Inside ); + } + + bool bOutChar = true; + const SwTextAttr * pTextHt = nullptr; + if (nAttrPos < nCntAttr && pHt->GetStart() == nStrPos) + { + do { + if ( pHt->End() && !pHt->HasDummyChar() ) + { + if( *pHt->End() != nStrPos ) + { + // insert hints with end, if they don't start + // an empty range (hints that don't start a range + // are ignored) + aEndPosLst.Insert( pHt->GetAttr(), nStrPos + nOffset, + *pHt->End() + nOffset, + rWrt.m_CharFormatInfos ); + } + } + else + { + // hints without an end are output last + OSL_ENSURE( !pTextHt, "Why is there already an attribute without an end?" ); + if( rWrt.m_nTextAttrsToIgnore>0 ) + { + rWrt.m_nTextAttrsToIgnore--; + } + else + { + pTextHt = pHt; + SwFieldIds nFieldWhich; + if( RES_TXTATR_FIELD != pHt->Which() + || ( SwFieldIds::Postit != (nFieldWhich = static_cast<const SwFormatField&>(pHt->GetAttr()).GetField()->Which()) + && SwFieldIds::Script != nFieldWhich ) ) + { + bWriteBreak = false; + } + } + bOutChar = false; // don't output 255 + } + } while( ++nAttrPos < nCntAttr && nStrPos == + ( pHt = pNd->GetSwpHints().Get( nAttrPos ) )->GetStart() ); + } + + // Additionally, some draw formats can bring attributes + if( pTextHt && RES_TXTATR_FLYCNT == pTextHt->Which() ) + { + const SwFrameFormat* pFrameFormat = + pTextHt->GetAttr().StaticWhichCast(RES_TXTATR_FLYCNT).GetFrameFormat(); + + if( RES_DRAWFRMFMT == pFrameFormat->Which() ) + aEndPosLst.Insert( *static_cast<const SwDrawFrameFormat *>(pFrameFormat), + nStrPos + nOffset, + rWrt.m_CharFormatInfos ); + } + + aEndPosLst.OutEndAttrs( rWrt, nStrPos + nOffset ); + aEndPosLst.OutStartAttrs( rWrt, nStrPos + nOffset ); + + if( pTextHt ) + { + rWrt.SetLFPossible(rWrt.m_nLastParaToken == HtmlTokenId::NONE && + nStrPos > 0 && + rStr[nStrPos-1] == ' '); + sal_uInt16 nCSS1Script = rWrt.m_nCSS1Script; + rWrt.m_nCSS1Script = aEndPosLst.GetScriptAtPos( + nStrPos + nOffset, nCSS1Script ); + HTMLOutFuncs::FlushToAscii( rWrt.Strm() ); + Out( aHTMLAttrFnTab, pTextHt->GetAttr(), rWrt ); + rWrt.m_nCSS1Script = nCSS1Script; + rWrt.SetLFPossible(false); + } + + if( bOutChar ) + { + sal_uInt32 c = rStr[nStrPos]; + if( rtl::isHighSurrogate(c) && nStrPos < nEnd - 1 ) + { + const sal_Unicode d = rStr[nStrPos + 1]; + if( rtl::isLowSurrogate(d) ) + { + c = rtl::combineSurrogates(c, d); + nStrPos++; + } + } + + // try to split a line after about 255 characters + // at a space character unless in a PRE-context + if( ' ' == c && rWrt.m_nLastParaToken == HtmlTokenId::NONE && !rWrt.IsSpacePreserve() ) + { + sal_Int32 nLineLen; + nLineLen = rWrt.GetLineLen(); + + sal_Int32 nWordLen = rStr.indexOf( ' ', nStrPos+1 ); + if( nWordLen == -1 ) + nWordLen = nEnd; + nWordLen -= nStrPos; + + if( rWrt.IsPrettyPrint() && rWrt.m_nWishLineLen >= 0 && + (nLineLen >= rWrt.m_nWishLineLen || + (nLineLen+nWordLen) >= rWrt.m_nWishLineLen ) ) + { + HTMLOutFuncs::FlushToAscii( rWrt.Strm() ); + rWrt.OutNewLine(); + bOutChar = false; + } + } + + if( bOutChar ) + { + if( 0x0a == c ) + { + HTMLOutFuncs::FlushToAscii( rWrt.Strm() ); + HtmlWriter aHtml(rWrt.Strm(), rWrt.maNamespace); + aHtml.prettyPrint(rWrt.IsPrettyPrint()); + aHtml.single(OOO_STRING_SVTOOLS_HTML_linebreak ""_ostr); + } + else if (c == CH_TXT_ATR_FORMELEMENT) + { + // Placeholder for a single-point fieldmark. + + SwPosition aMarkPos = *rWrt.m_pCurrentPam->GetPoint(); + aMarkPos.AdjustContent( nStrPos - aMarkPos.GetContentIndex() ); + rWrt.OutPointFieldmarks(aMarkPos); + } + else + { + bool bConsumed = false; + if (c == '\t') + { + if (bLeadingTab && rWrt.m_nLeadingTabWidth.has_value()) + { + // Consume a tab if it's leading and we know the number of NBSPs to + // be used as a replacement. + for (sal_Int32 i = 0; i < *rWrt.m_nLeadingTabWidth; ++i) + { + rWrt.Strm().WriteOString(" "); + } + bConsumed = true; + } + } + else + { + // Not a tab -> later tabs are no longer leading. + bLeadingTab = false; + } + + if (!bConsumed) + { + HTMLOutFuncs::Out_Char(rWrt.Strm(), c); + } + } + + if (!rWrt.mbReqIF) + { + // if a paragraph's last character is a hard line break + // then we need to add an extra <br> + // because browsers like Mozilla wouldn't add a line for the next paragraph + bWriteBreak = (0x0a == c) && + (HtmlTokenId::PREFORMTXT_ON != rWrt.m_nLastParaToken); + } + } + } + } + HTMLOutFuncs::FlushToAscii( rWrt.Strm() ); + } + + aEndPosLst.OutEndAttrs( rWrt, SAL_MAX_INT32 ); + + // Output the frames that are anchored to the last position + if( bFlysLeft ) + bFlysLeft = rWrt.OutFlyFrame( rNode.GetIndex(), + nEnd, HtmlPosition::Inside ); + OSL_ENSURE( !bFlysLeft, "Not all frames were saved!" ); + + rWrt.m_bTextAttr = false; + + if( bWriteBreak ) + { + bool bEndOfCell = rWrt.m_bOutTable && + rWrt.m_pCurrentPam->GetPoint()->GetNodeIndex() == + rWrt.m_pCurrentPam->GetMark()->GetNodeIndex(); + + if( bEndOfCell && !nEnd && + rWrt.IsHTMLMode(HTMLMODE_NBSP_IN_TABLES) ) + { + // If the last paragraph of a table cell is empty and we export + // for the MS-IE, we write a instead of a <BR> + rWrt.Strm().WriteChar( '&' ).WriteOString( OOO_STRING_SVTOOLS_HTML_S_nbsp ).WriteChar( ';' ); + } + else + { + HtmlWriter aHtml(rWrt.Strm(), rWrt.maNamespace); + aHtml.prettyPrint(rWrt.IsPrettyPrint()); + aHtml.single(OOO_STRING_SVTOOLS_HTML_linebreak ""_ostr); + const SvxULSpaceItem& rULSpace = pNd->GetSwAttrSet().Get(RES_UL_SPACE); + if (rULSpace.GetLower() > 0 && !bEndOfCell) + { + aHtml.single(OOO_STRING_SVTOOLS_HTML_linebreak ""_ostr); + } + rWrt.SetLFPossible(true); + } + } + + if( rWrt.m_bClearLeft || rWrt.m_bClearRight ) + { + const char* pString; + if( rWrt.m_bClearLeft ) + { + if( rWrt.m_bClearRight ) + pString = OOO_STRING_SVTOOLS_HTML_AL_all; + else + pString = OOO_STRING_SVTOOLS_HTML_AL_left; + } + else + { + pString = OOO_STRING_SVTOOLS_HTML_AL_right; + } + + HtmlWriter aHtml(rWrt.Strm(), rWrt.maNamespace); + aHtml.prettyPrint(rWrt.IsPrettyPrint()); + aHtml.start(OOO_STRING_SVTOOLS_HTML_linebreak ""_ostr); + aHtml.attribute(OOO_STRING_SVTOOLS_HTML_O_clear, pString); + aHtml.end(); + + rWrt.m_bClearLeft = false; + rWrt.m_bClearRight = false; + + rWrt.SetLFPossible(true); + } + + // if an LF is not allowed already, it is allowed once the paragraphs + // ends with a ' ' + if (!rWrt.IsLFPossible() && + rWrt.m_nLastParaToken == HtmlTokenId::NONE && + nEnd > 0 && ' ' == rStr[nEnd-1] ) + rWrt.SetLFPossible(true); + + // dot leaders: print the skipped page number in a different span element + if (nIndexTab > -1) { + OString sOut = OUStringToOString(rStr.subView(nIndexTab + 1), RTL_TEXTENCODING_ASCII_US); + rWrt.Strm().WriteOString( Concat2View("</span><span>" + sOut + "</span>") ); + } + + rWrt.m_bTagOn = false; + OutHTML_SwFormatOff( rWrt, aFormatInfo ); + rWrt.SetSpacePreserve(bOldSpacePreserve); + + // if necessary, close a form + rWrt.OutForm( false ); + + if( bPageBreakBehind ) + rWrt.Strm().WriteChar( '\f' ); + + return rWrt; +} + +// In CSS, "px" is 1/96 of inch: https://www.w3.org/TR/css3-values/#absolute-lengths +sal_uInt32 SwHTMLWriter::ToPixel(sal_uInt32 nTwips) +{ + // if there is a Twip, there should be a pixel as well + return nTwips + ? std::max(o3tl::convert(nTwips, o3tl::Length::twip, o3tl::Length::px), sal_Int64(1)) + : 0; +} + +Size SwHTMLWriter::ToPixel(Size aTwips) +{ + return Size(ToPixel(aTwips.Width()), ToPixel(aTwips.Height())); +} + +static SwHTMLWriter& OutHTML_CSS1Attr( SwHTMLWriter& rWrt, const SfxPoolItem& rHt ) +{ + // if hints are currently written, we try to write the hint as an + // CSS1 attribute + + if( rWrt.m_bCfgOutStyles && rWrt.m_bTextAttr ) + OutCSS1_HintSpanTag( rWrt, rHt ); + + return rWrt; +} + +/* File CHRATR.HXX: */ + +static SwHTMLWriter& OutHTML_SvxColor( SwHTMLWriter& rWrt, const SfxPoolItem& rHt ) +{ + if( rWrt.m_bOutOpts ) + return rWrt; + + if( !rWrt.m_bTextAttr && rWrt.m_bCfgOutStyles && rWrt.m_bCfgPreferStyles ) + { + // don't write the font color as a tag, if styles are preferred to + // normal tags + return rWrt; + } + + if( rWrt.m_bTagOn ) + { + Color aColor( static_cast<const SvxColorItem&>(rHt).GetValue() ); + if( COL_AUTO == aColor ) + aColor = COL_BLACK; + + if (rWrt.mbXHTML) + { + OString sOut = "<" + rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_span + " " OOO_STRING_SVTOOLS_HTML_O_style "="; + rWrt.Strm().WriteOString(sOut); + HTMLOutFuncs::Out_Color(rWrt.Strm(), aColor, /*bXHTML=*/true).WriteChar('>'); + } + else + { + OString sOut = "<" + rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_font " " + OOO_STRING_SVTOOLS_HTML_O_color "="; + rWrt.Strm().WriteOString( sOut ); + HTMLOutFuncs::Out_Color( rWrt.Strm(), aColor ).WriteChar( '>' ); + } + } + else + { + if (rWrt.mbXHTML) + HTMLOutFuncs::Out_AsciiTag( + rWrt.Strm(), Concat2View(rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_span), false); + else + HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), Concat2View(rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_font), false ); + } + + return rWrt; +} + +static SwHTMLWriter& OutHTML_SwPosture( SwHTMLWriter& rWrt, const SfxPoolItem& rHt ) +{ + if( rWrt.m_bOutOpts ) + return rWrt; + + const FontItalic nPosture = static_cast<const SvxPostureItem&>(rHt).GetPosture(); + if( ITALIC_NORMAL == nPosture ) + { + HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), Concat2View(rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_italic), rWrt.m_bTagOn ); + } + else if( rWrt.m_bCfgOutStyles && rWrt.m_bTextAttr ) + { + // maybe as CSS1 attribute? + OutCSS1_HintSpanTag( rWrt, rHt ); + } + + return rWrt; +} + +static SwHTMLWriter& OutHTML_SvxFont( SwHTMLWriter& rWrt, const SfxPoolItem& rHt ) +{ + if( rWrt.m_bOutOpts ) + return rWrt; + + if (IgnorePropertyForReqIF(rWrt.mbReqIF, "font-family", "")) + { + return rWrt; + } + + if( rWrt.m_bTagOn ) + { + OUString aNames; + SwHTMLWriter::PrepareFontList( static_cast<const SvxFontItem&>(rHt), aNames, 0, + rWrt.IsHTMLMode(HTMLMODE_FONT_GENERIC) ); + if (rWrt.mbXHTML) + { + OString sOut = "<" + rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_span + " " OOO_STRING_SVTOOLS_HTML_O_style "=\"font-family: "; + rWrt.Strm().WriteOString(sOut); + HTMLOutFuncs::Out_String(rWrt.Strm(), aNames) + .WriteOString("\">"); + } + else + { + OString sOut = "<" + rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_font " " + OOO_STRING_SVTOOLS_HTML_O_face "=\""; + rWrt.Strm().WriteOString( sOut ); + HTMLOutFuncs::Out_String( rWrt.Strm(), aNames ) + .WriteOString( "\">" ); + } + } + else + { + if (rWrt.mbXHTML) + HTMLOutFuncs::Out_AsciiTag( + rWrt.Strm(), Concat2View(rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_span), false); + else + HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), Concat2View(rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_font), false ); + } + + return rWrt; +} + +static SwHTMLWriter& OutHTML_SvxFontHeight( SwHTMLWriter& rWrt, const SfxPoolItem& rHt ) +{ + if( rWrt.m_bOutOpts ) + return rWrt; + + if (IgnorePropertyForReqIF(rWrt.mbReqIF, "font-size", "")) + { + return rWrt; + } + + if( rWrt.m_bTagOn ) + { + if (rWrt.mbXHTML) + { + OString sOut = "<" + rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_span; + + sal_uInt32 nHeight = static_cast<const SvxFontHeightItem&>(rHt).GetHeight(); + // Twips -> points. + sal_uInt16 nSize = nHeight / 20; + sOut += " " OOO_STRING_SVTOOLS_HTML_O_style "=\"font-size: " + + OString::number(static_cast<sal_Int32>(nSize)) + "pt\""; + rWrt.Strm().WriteOString(sOut); + } + else + { + OString sOut = "<" + rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_font; + + sal_uInt32 nHeight = static_cast<const SvxFontHeightItem&>(rHt).GetHeight(); + sal_uInt16 nSize = rWrt.GetHTMLFontSize( nHeight ); + sOut += " " OOO_STRING_SVTOOLS_HTML_O_size "=\"" + + OString::number(static_cast<sal_Int32>(nSize)) + "\""; + rWrt.Strm().WriteOString( sOut ); + + if( rWrt.m_bCfgOutStyles && rWrt.m_bTextAttr ) + { + // always export font size as CSS option, too + OutCSS1_HintStyleOpt( rWrt, rHt ); + } + } + rWrt.Strm().WriteChar( '>' ); + } + else + { + if (rWrt.mbXHTML) + HTMLOutFuncs::Out_AsciiTag( + rWrt.Strm(), Concat2View(rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_span), false); + else + HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), Concat2View(rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_font), false ); + } + + return rWrt; +} + +static SwHTMLWriter& OutHTML_SvxLanguage( SwHTMLWriter& rWrt, const SfxPoolItem& rHt ) +{ + if( rWrt.m_bOutOpts ) + return rWrt; + + LanguageType eLang = static_cast<const SvxLanguageItem &>(rHt).GetLanguage(); + if( LANGUAGE_DONTKNOW == eLang ) + return rWrt; + + if( rWrt.m_bTagOn ) + { + OString sOut = "<" + rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_span; + rWrt.Strm().WriteOString( sOut ); + rWrt.OutLanguage( static_cast<const SvxLanguageItem &>(rHt).GetLanguage() ); + rWrt.Strm().WriteChar( '>' ); + } + else + { + HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), Concat2View(rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_span), false ); + } + + return rWrt; +} +static SwHTMLWriter& OutHTML_SwWeight( SwHTMLWriter& rWrt, const SfxPoolItem& rHt ) +{ + if( rWrt.m_bOutOpts ) + return rWrt; + + const FontWeight nBold = static_cast<const SvxWeightItem&>(rHt).GetWeight(); + if( WEIGHT_BOLD == nBold ) + { + HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), Concat2View(rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_bold), rWrt.m_bTagOn ); + } + else if( rWrt.m_bCfgOutStyles && rWrt.m_bTextAttr ) + { + // maybe as CSS1 attribute ? + OutCSS1_HintSpanTag( rWrt, rHt ); + } + + return rWrt; +} + +static SwHTMLWriter& OutHTML_SwCrossedOut( SwHTMLWriter& rWrt, const SfxPoolItem& rHt ) +{ + if( rWrt.m_bOutOpts ) + return rWrt; + + // Because of Netscape, we output STRIKE and not S! + const FontStrikeout nStrike = static_cast<const SvxCrossedOutItem&>(rHt).GetStrikeout(); + if( STRIKEOUT_NONE != nStrike && !rWrt.mbReqIF ) + { + HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), Concat2View(rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_strike), rWrt.m_bTagOn ); + } + else if( rWrt.m_bCfgOutStyles && rWrt.m_bTextAttr ) + { + // maybe as CSS1 attribute? + OutCSS1_HintSpanTag( rWrt, rHt ); + } + + return rWrt; +} + +static SwHTMLWriter& OutHTML_SvxEscapement( SwHTMLWriter& rWrt, const SfxPoolItem& rHt ) +{ + if( rWrt.m_bOutOpts ) + return rWrt; + + const SvxEscapement eEscape = + static_cast<SvxEscapement>(static_cast<const SvxEscapementItem&>(rHt).GetEnumValue()); + OString aTag; + switch( eEscape ) + { + case SvxEscapement::Superscript: aTag = OOO_STRING_SVTOOLS_HTML_superscript ""_ostr; break; + case SvxEscapement::Subscript: aTag = OOO_STRING_SVTOOLS_HTML_subscript ""_ostr; break; + default: + ; + } + + if( !aTag.isEmpty() ) + { + HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), Concat2View(rWrt.GetNamespace() + aTag), rWrt.m_bTagOn ); + } + else if( rWrt.m_bCfgOutStyles && rWrt.m_bTextAttr ) + { + // maybe as CSS1 attribute? + OutCSS1_HintSpanTag( rWrt, rHt ); + } + + return rWrt; +} + +static SwHTMLWriter& OutHTML_SwUnderline( SwHTMLWriter& rWrt, const SfxPoolItem& rHt ) +{ + if( rWrt.m_bOutOpts ) + return rWrt; + + const FontLineStyle eUnder = static_cast<const SvxUnderlineItem&>(rHt).GetLineStyle(); + if( LINESTYLE_NONE != eUnder && !rWrt.mbReqIF ) + { + HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), Concat2View(rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_underline), rWrt.m_bTagOn ); + } + else if( rWrt.m_bCfgOutStyles && rWrt.m_bTextAttr ) + { + // maybe as CSS1 attribute? + OutCSS1_HintSpanTag( rWrt, rHt ); + } + + return rWrt; +} + +static SwHTMLWriter& OutHTML_SwFlyCnt( SwHTMLWriter& rWrt, const SfxPoolItem& rHt ) +{ + const SwFormatFlyCnt& rFlyCnt = static_cast<const SwFormatFlyCnt&>(rHt); + + const SwFrameFormat& rFormat = *rFlyCnt.GetFrameFormat(); + const SdrObject *pSdrObj = nullptr; + + SwHTMLFrameType eType = rWrt.GuessFrameType( rFormat, pSdrObj ); + AllHtmlFlags nMode = getHTMLOutFrameAsCharTable(eType, rWrt.m_nExportMode); + rWrt.OutFrameFormat( nMode, rFormat, pSdrObj ); + return rWrt; +} + +// This is now our Blink item. Blinking is activated by setting the item to +// true! +static SwHTMLWriter& OutHTML_SwBlink( SwHTMLWriter& rWrt, const SfxPoolItem& rHt ) +{ + if( rWrt.m_bOutOpts ) + return rWrt; + + if( static_cast<const SvxBlinkItem&>(rHt).GetValue() ) + { + HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), Concat2View(rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_blink), rWrt.m_bTagOn ); + } + else if( rWrt.m_bCfgOutStyles && rWrt.m_bTextAttr ) + { + // maybe as CSS1 attribute? + OutCSS1_HintSpanTag( rWrt, rHt ); + } + + return rWrt; +} + +SwHTMLWriter& OutHTML_INetFormat( SwHTMLWriter& rWrt, const SwFormatINetFormat& rINetFormat, bool bOn ) +{ + OUString aURL( rINetFormat.GetValue() ); + const SvxMacroTableDtor *pMacTable = rINetFormat.GetMacroTable(); + bool bEvents = pMacTable != nullptr && !pMacTable->empty(); + + // Anything to output at all? + if( aURL.isEmpty() && !bEvents && rINetFormat.GetName().isEmpty() ) + return rWrt; + + // bOn controls if we are writing the opening or closing tag + if( !bOn ) + { + HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), Concat2View(rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_anchor), false ); + return rWrt; + } + + OString sOut("<" + rWrt.GetNamespace() + OOO_STRING_SVTOOLS_HTML_anchor); + + bool bScriptDependent = false; + { + const SwCharFormat* pFormat = rWrt.m_pDoc->getIDocumentStylePoolAccess().GetCharFormatFromPool( + RES_POOLCHR_INET_NORMAL ); + std::unique_ptr<SwHTMLFormatInfo> pFormatInfo(new SwHTMLFormatInfo(pFormat)); + auto const it = rWrt.m_CharFormatInfos.find( pFormatInfo ); + if (it != rWrt.m_CharFormatInfos.end()) + { + bScriptDependent = (*it)->bScriptDependent; + } + } + if( !bScriptDependent ) + { + const SwCharFormat* pFormat = rWrt.m_pDoc->getIDocumentStylePoolAccess().GetCharFormatFromPool( + RES_POOLCHR_INET_VISIT ); + std::unique_ptr<SwHTMLFormatInfo> pFormatInfo(new SwHTMLFormatInfo(pFormat)); + auto const it = rWrt.m_CharFormatInfos.find( pFormatInfo ); + if (it != rWrt.m_CharFormatInfos.end()) + { + bScriptDependent = (*it)->bScriptDependent; + } + } + + if( bScriptDependent ) + { + sOut += " " OOO_STRING_SVTOOLS_HTML_O_class "=\""; + const char* pStr = nullptr; + switch( rWrt.m_nCSS1Script ) + { + case CSS1_OUTMODE_WESTERN: + pStr = "western"; + break; + case CSS1_OUTMODE_CJK: + pStr = "cjk"; + break; + case CSS1_OUTMODE_CTL: + pStr = "ctl"; + break; + } + sOut += pStr + OString::Concat("\""); + } + + rWrt.Strm().WriteOString( sOut ); + sOut = ""_ostr; + + OUString sRel; + + if( !aURL.isEmpty() || bEvents ) + { + OUString sTmp( aURL.toAsciiUpperCase() ); + sal_Int32 nPos = sTmp.indexOf( "\" REL=" ); + if( nPos >= 0 ) + { + sRel = aURL.copy( nPos+1 ); + aURL = aURL.copy( 0, nPos); + } + aURL = comphelper::string::strip(aURL, ' '); + + sOut += " " OOO_STRING_SVTOOLS_HTML_O_href "=\""; + rWrt.Strm().WriteOString( sOut ); + rWrt.OutHyperlinkHRefValue( aURL ); + sOut = "\""_ostr; + } + + if( !rINetFormat.GetName().isEmpty() ) + { + sOut += " " OOO_STRING_SVTOOLS_HTML_O_name "=\""; + rWrt.Strm().WriteOString( sOut ); + HTMLOutFuncs::Out_String( rWrt.Strm(), rINetFormat.GetName() ); + sOut = "\""_ostr; + } + + const OUString& rTarget = rINetFormat.GetTargetFrame(); + if( !rTarget.isEmpty() ) + { + sOut += " " OOO_STRING_SVTOOLS_HTML_O_target "=\""; + rWrt.Strm().WriteOString( sOut ); + HTMLOutFuncs::Out_String( rWrt.Strm(), rTarget ); + sOut = "\""_ostr; + } + + if( !sRel.isEmpty() ) + sOut += OUStringToOString(sRel, RTL_TEXTENCODING_ASCII_US); + + if( !sOut.isEmpty() ) + rWrt.Strm().WriteOString( sOut ); + + if( bEvents ) + HTMLOutFuncs::Out_Events( rWrt.Strm(), *pMacTable, aAnchorEventTable, + rWrt.m_bCfgStarBasic ); + rWrt.Strm().WriteOString( ">" ); + + return rWrt; +} + +static SwHTMLWriter& OutHTML_SwFormatINetFormat( SwHTMLWriter& rWrt, const SfxPoolItem& rHt ) +{ + if( rWrt.m_bOutOpts ) + return rWrt; + + const SwFormatINetFormat& rINetFormat = static_cast<const SwFormatINetFormat&>(rHt); + + if( rWrt.m_bTagOn ) + { + // if necessary, temporarily close an attribute that is still open + if( !rWrt.m_aINetFormats.empty() ) + { + SwFormatINetFormat *pINetFormat = + rWrt.m_aINetFormats.back(); + OutHTML_INetFormat( rWrt, *pINetFormat, false ); + } + + // now, open the new one + OutHTML_INetFormat( rWrt, rINetFormat, true ); + + // and remember it + SwFormatINetFormat *pINetFormat = new SwFormatINetFormat( rINetFormat ); + rWrt.m_aINetFormats.push_back( pINetFormat ); + } + else + { + OutHTML_INetFormat( rWrt, rINetFormat, false ); + + OSL_ENSURE( rWrt.m_aINetFormats.size(), "there must be a URL attribute missing" ); + if( !rWrt.m_aINetFormats.empty() ) + { + // get its own attribute from the stack + SwFormatINetFormat *pINetFormat = rWrt.m_aINetFormats.back(); + rWrt.m_aINetFormats.pop_back(); + delete pINetFormat; + } + + if( !rWrt.m_aINetFormats.empty() ) + { + // there is still an attribute on the stack that must be reopened + SwFormatINetFormat *pINetFormat = rWrt.m_aINetFormats.back(); + OutHTML_INetFormat( rWrt, *pINetFormat, true ); + } + } + + return rWrt; +} + +static SwHTMLWriter& OutHTML_SwTextCharFormat( SwHTMLWriter& rWrt, const SfxPoolItem& rHt ) +{ + if( rWrt.m_bOutOpts ) + return rWrt; + + const SwFormatCharFormat& rChrFormat = static_cast<const SwFormatCharFormat&>(rHt); + const SwCharFormat* pFormat = rChrFormat.GetCharFormat(); + + if( !pFormat ) + { + return rWrt; + } + + std::unique_ptr<SwHTMLFormatInfo> pTmpInfo(new SwHTMLFormatInfo(pFormat)); + SwHTMLFormatInfos::const_iterator it = rWrt.m_CharFormatInfos.find(pTmpInfo); + if (it == rWrt.m_CharFormatInfos.end()) + return rWrt; + + const SwHTMLFormatInfo *pFormatInfo = it->get(); + OSL_ENSURE( pFormatInfo, "Why is there no information about the character style?" ); + + if( rWrt.m_bTagOn ) + { + OString sOut = "<" + rWrt.GetNamespace(); + if( !pFormatInfo->aToken.isEmpty() ) + sOut += pFormatInfo->aToken; + else + sOut += OOO_STRING_SVTOOLS_HTML_span; + + if( rWrt.m_bCfgOutStyles && + (!pFormatInfo->aClass.isEmpty() || pFormatInfo->bScriptDependent) ) + { + sOut += " " OOO_STRING_SVTOOLS_HTML_O_class "=\""; + rWrt.Strm().WriteOString( sOut ); + OUString aClass( pFormatInfo->aClass ); + if( pFormatInfo->bScriptDependent ) + { + if( !aClass.isEmpty() ) + aClass += "-"; + switch( rWrt.m_nCSS1Script ) + { + case CSS1_OUTMODE_WESTERN: + aClass += "western"; + break; + case CSS1_OUTMODE_CJK: + aClass += "cjk"; + break; + case CSS1_OUTMODE_CTL: + aClass += "ctl"; + break; + } + } + HTMLOutFuncs::Out_String( rWrt.Strm(), aClass ); + sOut = "\""_ostr; + } + sOut += ">"; + rWrt.Strm().WriteOString( sOut ); + } + else + { + OString aTag = !pFormatInfo->aToken.isEmpty() ? pFormatInfo->aToken.getStr() + : OOO_STRING_SVTOOLS_HTML_span; + HTMLOutFuncs::Out_AsciiTag(rWrt.Strm(), Concat2View(rWrt.GetNamespace() + aTag), false); + } + + return rWrt; +} + +static SwHTMLWriter& OutHTML_SvxAdjust( SwHTMLWriter& rWrt, const SfxPoolItem& rHt ) +{ + if( !rWrt.m_bOutOpts || !rWrt.m_bTagOn ) + return rWrt; + + const SvxAdjustItem& rAdjust = static_cast<const SvxAdjustItem&>(rHt); + const char* pStr = nullptr; + switch( rAdjust.GetAdjust() ) + { + case SvxAdjust::Center: pStr = OOO_STRING_SVTOOLS_HTML_AL_center; break; + case SvxAdjust::Left: pStr = OOO_STRING_SVTOOLS_HTML_AL_left; break; + case SvxAdjust::Right: pStr = OOO_STRING_SVTOOLS_HTML_AL_right; break; + case SvxAdjust::Block: pStr = OOO_STRING_SVTOOLS_HTML_AL_justify; break; + default: + ; + } + if( pStr ) + { + OString sOut = OString::Concat(" " OOO_STRING_SVTOOLS_HTML_O_align "=\"") + + pStr + "\""; + rWrt.Strm().WriteOString( sOut ); + } + + return rWrt; +} + +/* + * here, define the table for the HTML function pointers to the output + * functions. + */ + +SwAttrFnTab aHTMLAttrFnTab = { +/* RES_CHRATR_CASEMAP */ OutHTML_CSS1Attr, +/* RES_CHRATR_CHARSETCOLOR */ nullptr, +/* RES_CHRATR_COLOR */ OutHTML_SvxColor, +/* RES_CHRATR_CONTOUR */ nullptr, +/* RES_CHRATR_CROSSEDOUT */ OutHTML_SwCrossedOut, +/* RES_CHRATR_ESCAPEMENT */ OutHTML_SvxEscapement, +/* RES_CHRATR_FONT */ OutHTML_SvxFont, +/* RES_CHRATR_FONTSIZE */ OutHTML_SvxFontHeight, +/* RES_CHRATR_KERNING */ OutHTML_CSS1Attr, +/* RES_CHRATR_LANGUAGE */ OutHTML_SvxLanguage, +/* RES_CHRATR_POSTURE */ OutHTML_SwPosture, +/* RES_CHRATR_UNUSED1*/ nullptr, +/* RES_CHRATR_SHADOWED */ nullptr, +/* RES_CHRATR_UNDERLINE */ OutHTML_SwUnderline, +/* RES_CHRATR_WEIGHT */ OutHTML_SwWeight, +/* RES_CHRATR_WORDLINEMODE */ nullptr, +/* RES_CHRATR_AUTOKERN */ nullptr, +/* RES_CHRATR_BLINK */ OutHTML_SwBlink, +/* RES_CHRATR_NOHYPHEN */ nullptr, // New: don't hyphenate +/* RES_CHRATR_UNUSED2 */ nullptr, +/* RES_CHRATR_BACKGROUND */ OutHTML_CSS1Attr, // New: character background +/* RES_CHRATR_CJK_FONT */ OutHTML_SvxFont, +/* RES_CHRATR_CJK_FONTSIZE */ OutHTML_SvxFontHeight, +/* RES_CHRATR_CJK_LANGUAGE */ OutHTML_SvxLanguage, +/* RES_CHRATR_CJK_POSTURE */ OutHTML_SwPosture, +/* RES_CHRATR_CJK_WEIGHT */ OutHTML_SwWeight, +/* RES_CHRATR_CTL_FONT */ OutHTML_SvxFont, +/* RES_CHRATR_CTL_FONTSIZE */ OutHTML_SvxFontHeight, +/* RES_CHRATR_CTL_LANGUAGE */ OutHTML_SvxLanguage, +/* RES_CHRATR_CTL_POSTURE */ OutHTML_SwPosture, +/* RES_CHRATR_CTL_WEIGHT */ OutHTML_SwWeight, +/* RES_CHRATR_ROTATE */ nullptr, +/* RES_CHRATR_EMPHASIS_MARK */ nullptr, +/* RES_CHRATR_TWO_LINES */ nullptr, +/* RES_CHRATR_SCALEW */ nullptr, +/* RES_CHRATR_RELIEF */ nullptr, +/* RES_CHRATR_HIDDEN */ OutHTML_CSS1Attr, +/* RES_CHRATR_OVERLINE */ OutHTML_CSS1Attr, +/* RES_CHRATR_RSID */ nullptr, +/* RES_CHRATR_BOX */ OutHTML_CSS1Attr, +/* RES_CHRATR_SHADOW */ nullptr, +/* RES_CHRATR_HIGHLIGHT */ nullptr, +/* RES_CHRATR_GRABBAG */ nullptr, +/* RES_CHRATR_BIDIRTL */ nullptr, +/* RES_CHRATR_IDCTHINT */ nullptr, + +/* RES_TXTATR_REFMARK */ nullptr, +/* RES_TXTATR_TOXMARK */ nullptr, +/* RES_TXTATR_META */ nullptr, +/* RES_TXTATR_METAFIELD */ nullptr, +/* RES_TXTATR_AUTOFMT */ nullptr, +/* RES_TXTATR_INETFMT */ OutHTML_SwFormatINetFormat, +/* RES_TXTATR_CHARFMT */ OutHTML_SwTextCharFormat, +/* RES_TXTATR_CJK_RUBY */ nullptr, +/* RES_TXTATR_UNKNOWN_CONTAINER */ nullptr, +/* RES_TXTATR_INPUTFIELD */ OutHTML_SwFormatField, +/* RES_TXTATR_CONTENTCONTROL */ nullptr, + +/* RES_TXTATR_FIELD */ OutHTML_SwFormatField, +/* RES_TXTATR_FLYCNT */ OutHTML_SwFlyCnt, +/* RES_TXTATR_FTN */ OutHTML_SwFormatFootnote, +/* RES_TXTATR_ANNOTATION */ OutHTML_SwFormatField, +/* RES_TXTATR_LINEBREAK */ OutHTML_SwFormatLineBreak, +/* RES_TXTATR_DUMMY1 */ nullptr, // Dummy: + +/* RES_PARATR_LINESPACING */ nullptr, +/* RES_PARATR_ADJUST */ OutHTML_SvxAdjust, +/* RES_PARATR_SPLIT */ nullptr, +/* RES_PARATR_ORPHANS */ nullptr, +/* RES_PARATR_WIDOWS */ nullptr, +/* RES_PARATR_TABSTOP */ nullptr, +/* RES_PARATR_HYPHENZONE*/ nullptr, +/* RES_PARATR_DROP */ OutHTML_CSS1Attr, +/* RES_PARATR_REGISTER */ nullptr, // new: register-true +/* RES_PARATR_NUMRULE */ nullptr, // Dummy: +/* RES_PARATR_SCRIPTSPACE */ nullptr, // Dummy: +/* RES_PARATR_HANGINGPUNCTUATION */ nullptr, // Dummy: +/* RES_PARATR_FORBIDDEN_RULES */ nullptr, // new +/* RES_PARATR_VERTALIGN */ nullptr, // new +/* RES_PARATR_SNAPTOGRID*/ nullptr, // new +/* RES_PARATR_CONNECT_TO_BORDER */ nullptr, // new +/* RES_PARATR_OUTLINELEVEL */ nullptr, +/* RES_PARATR_RSID */ nullptr, +/* RES_PARATR_GRABBAG */ nullptr, + +/* RES_PARATR_LIST_ID */ nullptr, // new +/* RES_PARATR_LIST_LEVEL */ nullptr, // new +/* RES_PARATR_LIST_ISRESTART */ nullptr, // new +/* RES_PARATR_LIST_RESTARTVALUE */ nullptr, // new +/* RES_PARATR_LIST_ISCOUNTED */ nullptr, // new + +/* RES_FILL_ORDER */ nullptr, +/* RES_FRM_SIZE */ nullptr, +/* RES_PAPER_BIN */ nullptr, +/* RES_MARGIN_FIRSTLINE */ nullptr, +/* RES_MARGIN_TEXTLEFT */ nullptr, +/* RES_MARGIN_RIGHT */ nullptr, +/* RES_MARGIN_LEFT */ nullptr, +/* RES_MARGIN_GUTTER */ nullptr, +/* RES_MARGIN_GUTTER_RIGHT */ nullptr, +/* RES_LR_SPACE */ nullptr, +/* RES_UL_SPACE */ nullptr, +/* RES_PAGEDESC */ nullptr, +/* RES_BREAK */ nullptr, +/* RES_CNTNT */ nullptr, +/* RES_HEADER */ nullptr, +/* RES_FOOTER */ nullptr, +/* RES_PRINT */ nullptr, +/* RES_OPAQUE */ nullptr, +/* RES_PROTECT */ nullptr, +/* RES_SURROUND */ nullptr, +/* RES_VERT_ORIENT */ nullptr, +/* RES_HORI_ORIENT */ nullptr, +/* RES_ANCHOR */ nullptr, +/* RES_BACKGROUND */ nullptr, +/* RES_BOX */ nullptr, +/* RES_SHADOW */ nullptr, +/* RES_FRMMACRO */ nullptr, +/* RES_COL */ nullptr, +/* RES_KEEP */ nullptr, +/* RES_URL */ nullptr, +/* RES_EDIT_IN_READONLY */ nullptr, +/* RES_LAYOUT_SPLIT */ nullptr, +/* RES_CHAIN */ nullptr, +/* RES_TEXTGRID */ nullptr, +/* RES_LINENUMBER */ nullptr, +/* RES_FTN_AT_TXTEND */ nullptr, +/* RES_END_AT_TXTEND */ nullptr, +/* RES_COLUMNBALANCE */ nullptr, +/* RES_FRAMEDIR */ nullptr, +/* RES_HEADER_FOOTER_EAT_SPACING */ nullptr, +/* RES_ROW_SPLIT */ nullptr, +/* RES_FLY_SPLIT */ nullptr, +/* RES_FOLLOW_TEXT_FLOW */ nullptr, +/* RES_COLLAPSING_BORDERS */ nullptr, +/* RES_WRAP_INFLUENCE_ON_OBJPOS */ nullptr, +/* RES_AUTO_STYLE */ nullptr, +/* RES_FRMATR_STYLE_NAME */ nullptr, +/* RES_FRMATR_CONDITIONAL_STYLE_NAME */ nullptr, +/* RES_FRMATR_GRABBAG */ nullptr, +/* RES_TEXT_VERT_ADJUST */ nullptr, +/* RES_BACKGROUND_FULL_SIZE */ nullptr, +/* RES_RTL_GUTTER */ nullptr, +/* RES_DECORATIVE */ nullptr, + +/* RES_GRFATR_MIRRORGRF */ nullptr, +/* RES_GRFATR_CROPGRF */ nullptr, +/* RES_GRFATR_ROTATION */ nullptr, +/* RES_GRFATR_LUMINANCE */ nullptr, +/* RES_GRFATR_CONTRAST */ nullptr, +/* RES_GRFATR_CHANNELR */ nullptr, +/* RES_GRFATR_CHANNELG */ nullptr, +/* RES_GRFATR_CHANNELB */ nullptr, +/* RES_GRFATR_GAMMA */ nullptr, +/* RES_GRFATR_INVERT */ nullptr, +/* RES_GRFATR_TRANSPARENCY */ nullptr, +/* RES_GRFATR_DRWAMODE */ nullptr, +/* RES_GRFATR_DUMMY3 */ nullptr, +/* RES_GRFATR_DUMMY4 */ nullptr, +/* RES_GRFATR_DUMMY5 */ nullptr, + +/* RES_BOXATR_FORMAT */ nullptr, +/* RES_BOXATR_FORMULA */ nullptr, +/* RES_BOXATR_VALUE */ nullptr +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |