rtfattributeoutput.cxx

Go to the documentation of this file.

/* -*- 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 "rtfattributeoutput.hxx"
#include <memory>
#include <cstring>
#include "rtfsdrexport.hxx"
#include "writerwordglue.hxx"
#include "ww8par.hxx"
#include <fmtcntnt.hxx>
#include <rtl/tencinfo.h>
#include <sal/log.hxx>
#include <sot/exchange.hxx>
#include <svtools/rtfkeywd.hxx>
#include <editeng/fontitem.hxx>
#include <editeng/tstpitem.hxx>
#include <editeng/adjustitem.hxx>
#include <editeng/spltitem.hxx>
#include <editeng/widwitem.hxx>
#include <editeng/postitem.hxx>
#include <editeng/wghtitem.hxx>
#include <editeng/kernitem.hxx>
#include <editeng/crossedoutitem.hxx>
#include <editeng/cmapitem.hxx>
#include <editeng/wrlmitem.hxx>
#include <editeng/udlnitem.hxx>
#include <editeng/langitem.hxx>
#include <editeng/escapementitem.hxx>
#include <editeng/fhgtitem.hxx>
#include <editeng/colritem.hxx>
#include <editeng/hyphenzoneitem.hxx>
#include <editeng/contouritem.hxx>
#include <editeng/shdditem.hxx>
#include <editeng/autokernitem.hxx>
#include <editeng/emphasismarkitem.hxx>
#include <editeng/twolinesitem.hxx>
#include <editeng/charscaleitem.hxx>
#include <editeng/charrotateitem.hxx>
#include <editeng/charreliefitem.hxx>
#include <editeng/paravertalignitem.hxx>
#include <editeng/blinkitem.hxx>
#include <editeng/charhiddenitem.hxx>
#include <editeng/boxitem.hxx>
#include <editeng/brushitem.hxx>
#include <editeng/ulspitem.hxx>
#include <editeng/shaditem.hxx>
#include <editeng/keepitem.hxx>
#include <editeng/frmdiritem.hxx>
#include <editeng/opaqitem.hxx>
#include <o3tl/unit_conversion.hxx>
#include <svx/svdouno.hxx>
#include <filter/msfilter/rtfutil.hxx>
#include <svx/xfillit0.hxx>
#include <svx/xflgrit.hxx>
#include <docufld.hxx>
#include <fmtclds.hxx>
#include <fmtrowsplt.hxx>
#include <fmtline.hxx>
#include <fmtanchr.hxx>
#include <ftninfo.hxx>
#include <htmltbl.hxx>
#include <ndgrf.hxx>
#include <pagedesc.hxx>
#include <swmodule.hxx>
#include <txtftn.hxx>
#include <txtinet.hxx>
#include <grfatr.hxx>
#include <ndole.hxx>
#include <lineinfo.hxx>
#include <redline.hxx>
#include <rtf.hxx>
#include <vcl/cvtgrf.hxx>
#include <oox/mathml/imexport.hxx>
#include <com/sun/star/i18n/ScriptType.hpp>
#include <svl/grabbagitem.hxx>
#include <frmatr.hxx>
#include <swtable.hxx>
#include <formatflysplit.hxx>
#include "rtfexport.hxx"
 
using namespace ::com::sun::star;
using namespace sw::util;
 
static OString OutTBLBorderLine(RtfExport const& rExport, const editeng::SvxBorderLine* pLine,
                                const char* pStr)
{
    OStringBuffer aRet;
    if (pLine && !pLine->isEmpty())
    {
        aRet.append(pStr);
        // single line
        switch (pLine->GetBorderLineStyle())
        {
            case SvxBorderLineStyle::SOLID:
            {
                if (SvxBorderLineWidth::Hairline == pLine->GetWidth())
                    aRet.append(OOO_STRING_SVTOOLS_RTF_BRDRHAIR);
                else
                    aRet.append(OOO_STRING_SVTOOLS_RTF_BRDRS);
            }
            break;
            case SvxBorderLineStyle::DOTTED:
                aRet.append(OOO_STRING_SVTOOLS_RTF_BRDRDOT);
                break;
            case SvxBorderLineStyle::DASHED:
                aRet.append(OOO_STRING_SVTOOLS_RTF_BRDRDASH);
                break;
            case SvxBorderLineStyle::DOUBLE:
            case SvxBorderLineStyle::DOUBLE_THIN:
                aRet.append(OOO_STRING_SVTOOLS_RTF_BRDRDB);
                break;
            case SvxBorderLineStyle::THINTHICK_SMALLGAP:
                aRet.append(OOO_STRING_SVTOOLS_RTF_BRDRTNTHSG);
                break;
            case SvxBorderLineStyle::THINTHICK_MEDIUMGAP:
                aRet.append(OOO_STRING_SVTOOLS_RTF_BRDRTNTHMG);
                break;
            case SvxBorderLineStyle::THINTHICK_LARGEGAP:
                aRet.append(OOO_STRING_SVTOOLS_RTF_BRDRTNTHLG);
                break;
            case SvxBorderLineStyle::THICKTHIN_SMALLGAP:
                aRet.append(OOO_STRING_SVTOOLS_RTF_BRDRTHTNSG);
                break;
            case SvxBorderLineStyle::THICKTHIN_MEDIUMGAP:
                aRet.append(OOO_STRING_SVTOOLS_RTF_BRDRTHTNMG);
                break;
            case SvxBorderLineStyle::THICKTHIN_LARGEGAP:
                aRet.append(OOO_STRING_SVTOOLS_RTF_BRDRTHTNLG);
                break;
            case SvxBorderLineStyle::EMBOSSED:
                aRet.append(OOO_STRING_SVTOOLS_RTF_BRDREMBOSS);
                break;
            case SvxBorderLineStyle::ENGRAVED:
                aRet.append(OOO_STRING_SVTOOLS_RTF_BRDRENGRAVE);
                break;
            case SvxBorderLineStyle::OUTSET:
                aRet.append(OOO_STRING_SVTOOLS_RTF_BRDROUTSET);
                break;
            case SvxBorderLineStyle::INSET:
                aRet.append(OOO_STRING_SVTOOLS_RTF_BRDRINSET);
                break;
            case SvxBorderLineStyle::FINE_DASHED:
                aRet.append(OOO_STRING_SVTOOLS_RTF_BRDRDASHSM);
                break;
            case SvxBorderLineStyle::DASH_DOT:
                aRet.append(OOO_STRING_SVTOOLS_RTF_BRDRDASHD);
                break;
            case SvxBorderLineStyle::DASH_DOT_DOT:
                aRet.append(OOO_STRING_SVTOOLS_RTF_BRDRDASHDD);
                break;
            case SvxBorderLineStyle::NONE:
            default:
                aRet.append(OOO_STRING_SVTOOLS_RTF_BRDRNONE);
                break;
        }
 
        double const fConverted(
            ::editeng::ConvertBorderWidthToWord(pLine->GetBorderLineStyle(), pLine->GetWidth()));
        if (255 >= pLine->GetWidth()) // That value comes from RTF specs
        {
            aRet.append(OOO_STRING_SVTOOLS_RTF_BRDRW
                        + OString::number(static_cast<sal_Int32>(fConverted)));
        }
        else
        {
            // use \brdrth to double the value range...
            aRet.append(OOO_STRING_SVTOOLS_RTF_BRDRTH OOO_STRING_SVTOOLS_RTF_BRDRW
                        + OString::number(static_cast<sal_Int32>(fConverted) / 2));
        }
 
        aRet.append(OOO_STRING_SVTOOLS_RTF_BRDRCF
                    + OString::number(static_cast<sal_Int32>(rExport.GetColor(pLine->GetColor()))));
    }
    else // tdf#129758 "no border" may be needed to override style
    {
        aRet.append(OString::Concat(pStr) + OOO_STRING_SVTOOLS_RTF_BRDRNONE);
    }
    return aRet.makeStringAndClear();
}
 
static OString OutBorderLine(RtfExport const& rExport, const editeng::SvxBorderLine* pLine,
                             const char* pStr, sal_uInt16 nDist,
                             SvxShadowLocation eShadowLocation = SvxShadowLocation::NONE)
{
    OStringBuffer aRet(OutTBLBorderLine(rExport, pLine, pStr));
    if (pLine)
    {
        aRet.append(OOO_STRING_SVTOOLS_RTF_BRSP + OString::number(static_cast<sal_Int32>(nDist)));
    }
    if (eShadowLocation == SvxShadowLocation::BottomRight)
        aRet.append(LO_STRING_SVTOOLS_RTF_BRDRSH);
    return aRet.makeStringAndClear();
}
 
void RtfAttributeOutput::RTLAndCJKState(bool bIsRTL, sal_uInt16 nScript)
{
    m_bIsRTL = bIsRTL;
    m_nScript = nScript;
    m_bControlLtrRtl = true;
}
 
sal_Int32 RtfAttributeOutput::StartParagraph(ww8::WW8TableNodeInfo::Pointer_t pTextNodeInfo,
                                             bool /*bGenerateParaId*/)
{
    if (m_bIsBeforeFirstParagraph && m_rExport.m_nTextTyp != TXT_HDFT)
        m_bIsBeforeFirstParagraph = false;
 
    // Output table/table row/table cell starts if needed
    if (pTextNodeInfo)
    {
        sal_uInt32 nRow = pTextNodeInfo->getRow();
        sal_uInt32 nCell = pTextNodeInfo->getCell();
 
        // New cell/row?
        if (m_nTableDepth > 0 && !m_bTableCellOpen)
        {
            ww8::WW8TableNodeInfoInner::Pointer_t pDeepInner(
                pTextNodeInfo->getInnerForDepth(m_nTableDepth));
            OSL_ENSURE(pDeepInner, "TableNodeInfoInner not found");
            // Make sure we always start a row between ending one and starting a cell.
            // In case of subtables, we may not get the first cell.
            if (pDeepInner && (pDeepInner->getCell() == 0 || m_bTableRowEnded))
            {
                StartTableRow(pDeepInner);
            }
 
            StartTableCell();
        }
 
        // Again, if depth was incremented, start a new table even if we skipped the first cell.
        if ((nRow == 0 && nCell == 0) || (m_nTableDepth == 0 && pTextNodeInfo->getDepth()))
        {
            // Do we have to start the table?
            // [If we are at the right depth already, it means that we
            // continue the table cell]
            sal_uInt32 nCurrentDepth = pTextNodeInfo->getDepth();
 
            if (nCurrentDepth > m_nTableDepth)
            {
                // Start all the tables that begin here
                for (sal_uInt32 nDepth = m_nTableDepth + 1; nDepth <= pTextNodeInfo->getDepth();
                     ++nDepth)
                {
                    ww8::WW8TableNodeInfoInner::Pointer_t pInner(
                        pTextNodeInfo->getInnerForDepth(nDepth));
 
                    m_bLastTable = (nDepth == pTextNodeInfo->getDepth());
                    StartTable();
                    StartTableRow(pInner);
                    StartTableCell();
                }
 
                m_nTableDepth = nCurrentDepth;
            }
        }
    }
 
    OSL_ENSURE(m_aRun.getLength() == 0, "m_aRun is not empty");
    return 0;
}
 
void RtfAttributeOutput::EndParagraph(ww8::WW8TableNodeInfoInner::Pointer_t pTextNodeInfoInner)
{
    bool bLastPara = false;
    if (m_rExport.m_nTextTyp == TXT_FTN || m_rExport.m_nTextTyp == TXT_EDN
        || m_rExport.m_rDoc.IsClipBoard())
    {
        // We're ending a paragraph that is the last paragraph of a footnote or endnote, or of clipboard.
        bLastPara
            = m_rExport.GetCurrentNodeIndex()
              && m_rExport.GetCurrentNodeIndex() == m_rExport.m_pCurPam->End()->GetNodeIndex();
    }
 
    FinishTableRowCell(pTextNodeInfoInner);
 
    RtfStringBuffer aParagraph;
 
    aParagraph.appendAndClear(m_aRun);
    aParagraph->append(m_aAfterRuns);
    m_aAfterRuns.setLength(0);
    if (m_bTableAfterCell)
        m_bTableAfterCell = false;
    else
    {
        aParagraph->append(SAL_NEWLINE_STRING);
        // RTF_PAR at the end of the footnote or clipboard, would cause an additional empty paragraph.
        if (!bLastPara)
        {
            aParagraph->append(OOO_STRING_SVTOOLS_RTF_PAR);
            aParagraph->append(' ');
        }
    }
    if (m_nColBreakNeeded)
    {
        aParagraph->append(OOO_STRING_SVTOOLS_RTF_COLUMN);
        m_nColBreakNeeded = false;
    }
 
    if (!m_bBufferSectionHeaders)
        aParagraph.makeStringAndClear(this);
    else
        m_aSectionHeaders.append(aParagraph.makeStringAndClear());
}
 
void RtfAttributeOutput::EmptyParagraph()
{
    m_rExport.Strm()
        .WriteOString(SAL_NEWLINE_STRING)
        .WriteOString(OOO_STRING_SVTOOLS_RTF_PAR)
        .WriteChar(' ');
}
 
void RtfAttributeOutput::SectionBreaks(const SwNode& rNode)
{
    SwNodeIndex aNextIndex(rNode, 1);
    if (rNode.IsTextNode())
    {
        OSL_ENSURE(m_aStyles.getLength() == 0, "m_aStyles is not empty");
 
        // output page/section breaks
        m_rExport.Strm().WriteOString(m_aSectionBreaks);
        m_aSectionBreaks.setLength(0);
        m_bBufferSectionBreaks = true;
 
        // output section headers / footers
        if (!m_bBufferSectionHeaders)
        {
            m_rExport.Strm().WriteOString(m_aSectionHeaders);
            m_aSectionHeaders.setLength(0);
        }
 
        if (aNextIndex.GetNode().IsTextNode())
        {
            const SwTextNode* pTextNode = static_cast<SwTextNode*>(&aNextIndex.GetNode());
            m_rExport.OutputSectionBreaks(pTextNode->GetpSwAttrSet(), *pTextNode);
            // Save the current page description for now, so later we will be able to access the previous one.
            m_pPrevPageDesc = pTextNode->FindPageDesc();
        }
        else if (aNextIndex.GetNode().IsTableNode())
        {
            const SwTableNode* pTableNode = static_cast<SwTableNode*>(&aNextIndex.GetNode());
            const SwFrameFormat* pFormat = pTableNode->GetTable().GetFrameFormat();
            m_rExport.OutputSectionBreaks(&(pFormat->GetAttrSet()), *pTableNode);
        }
        m_bBufferSectionBreaks = false;
    }
    else if (rNode.IsEndNode())
    {
        // End of something: make sure that it's the end of a table.
        assert(rNode.StartOfSectionNode()->IsTableNode());
        if (aNextIndex.GetNode().IsTextNode())
        {
            // Handle section break between a table and a text node following it.
            const SwTextNode* pTextNode = aNextIndex.GetNode().GetTextNode();
            m_rExport.OutputSectionBreaks(pTextNode->GetpSwAttrSet(), *pTextNode);
        }
    }
}
 
void RtfAttributeOutput::StartParagraphProperties()
{
    OStringBuffer aPar;
    if (!m_rExport.GetRTFFlySyntax())
    {
        aPar.append(OOO_STRING_SVTOOLS_RTF_PARD OOO_STRING_SVTOOLS_RTF_PLAIN " ");
    }
    if (!m_bBufferSectionHeaders)
        m_rExport.Strm().WriteOString(aPar);
    else
        m_aSectionHeaders.append(aPar);
}
 
void RtfAttributeOutput::EndParagraphProperties(
    const SfxItemSet& /*rParagraphMarkerProperties*/, const SwRedlineData* /*pRedlineData*/,
    const SwRedlineData* /*pRedlineParagraphMarkerDeleted*/,
    const SwRedlineData* /*pRedlineParagraphMarkerInserted*/)
{
    // Do not call MoveCharacterProperties(),
    // Otherwise associate properties in the paragraph style are ruined.
    const OString aProperties = m_aStyles.makeStringAndClear();
    m_rExport.Strm().WriteOString(aProperties);
}
 
void RtfAttributeOutput::StartRun(const SwRedlineData* pRedlineData, sal_Int32 /*nPos*/,
                                  bool bSingleEmptyRun)
{
    SAL_INFO("sw.rtf", __func__ << ", bSingleEmptyRun: " << bSingleEmptyRun);
 
    m_bInRun = true;
    m_bSingleEmptyRun = bSingleEmptyRun;
    if (!m_bSingleEmptyRun)
        m_aRun->append('{');
 
    // if there is some redlining in the document, output it
    Redline(pRedlineData);
 
    OSL_ENSURE(m_aRunText.getLength() == 0, "m_aRunText is not empty");
}
 
void RtfAttributeOutput::EndRun(const SwTextNode* /*pNode*/, sal_Int32 /*nPos*/, sal_Int32 /*nLen*/,
                                bool /*bLastRun*/)
{
    m_aRun->append(SAL_NEWLINE_STRING);
    m_aRun.appendAndClear(m_aRunText);
 
    if (m_bInRuby)
    {
        m_aRun->append(")}}{" OOO_STRING_SVTOOLS_RTF_FLDRSLT " {}}}");
        m_bInRuby = false;
    }
 
    if (!m_bSingleEmptyRun && m_bInRun)
        m_aRun->append('}');
    m_bInRun = false;
}
 
void RtfAttributeOutput::StartRunProperties()
{
    OSL_ENSURE(m_aStyles.getLength() == 0, "m_aStyles is not empty");
}
 
void RtfAttributeOutput::EndRunProperties(const SwRedlineData* /*pRedlineData*/)
{
    const OString aProperties = MoveCharacterProperties(true);
    m_aRun->append(aProperties);
}
 
OString RtfAttributeOutput::MoveCharacterProperties(bool aAutoWriteRtlLtr)
{
    const OString aAssocHich = m_aStylesAssocHich.makeStringAndClear();
    const OString aAssocDbch = m_aStylesAssocDbch.makeStringAndClear();
    const OString aAssocRtlch = m_aStylesAssocRtlch.makeStringAndClear();
    const OString aAssocLtrch = m_aStylesAssocLtrch.makeStringAndClear();
    const OString aNormal = m_aStyles.makeStringAndClear();
    OStringBuffer aBuf;
 
    if (aAutoWriteRtlLtr && !m_bControlLtrRtl)
    {
        m_bControlLtrRtl = !aAssocRtlch.isEmpty();
        m_bIsRTL = false;
        m_nScript = i18n::ScriptType::LATIN;
    }
 
    if (m_bIsRTL)
    {
        if (!aAssocRtlch.isEmpty())
        {
            aBuf.append(OOO_STRING_SVTOOLS_RTF_LTRCH + aAssocLtrch
                        + " " OOO_STRING_SVTOOLS_RTF_RTLCH + aAssocRtlch);
        }
    }
    else
    {
        if (!aAssocRtlch.isEmpty())
        {
            aBuf.append(OOO_STRING_SVTOOLS_RTF_RTLCH + aAssocRtlch
                        + " " OOO_STRING_SVTOOLS_RTF_LTRCH + aAssocLtrch);
        }
        if (!aAssocHich.isEmpty())
        {
            aBuf.append(OOO_STRING_SVTOOLS_RTF_HICH + aAssocHich);
        }
        if (!aNormal.isEmpty())
        {
            aBuf.append(OOO_STRING_SVTOOLS_RTF_LOCH + aNormal);
        }
        if (!aAssocDbch.isEmpty())
        {
            aBuf.append(OOO_STRING_SVTOOLS_RTF_DBCH + aAssocDbch);
        }
    }
 
    if (m_bControlLtrRtl)
    {
        m_bControlLtrRtl = false;
 
        switch (m_nScript)
        {
            case i18n::ScriptType::LATIN:
                aBuf.append(OOO_STRING_SVTOOLS_RTF_LOCH);
                break;
            case i18n::ScriptType::ASIAN:
                aBuf.append(OOO_STRING_SVTOOLS_RTF_DBCH);
                break;
            case i18n::ScriptType::COMPLEX:
                /* noop */
            default:
                /* should not happen? */
                break;
        }
    }
 
    return aBuf.makeStringAndClear();
}
 
void RtfAttributeOutput::RunText(const OUString& rText, rtl_TextEncoding /*eCharSet*/,
                                 const OUString& /*rSymbolFont*/)
{
    SAL_INFO("sw.rtf", __func__ << ", rText: " << rText);
    RawText(rText, m_rExport.GetCurrentEncoding());
}
 
OStringBuffer& RtfAttributeOutput::RunText() { return m_aRunText.getLastBuffer(); }
 
void RtfAttributeOutput::RawText(const OUString& rText, rtl_TextEncoding eCharSet)
{
    m_aRunText->append(msfilter::rtfutil::OutString(rText, eCharSet));
}
 
void RtfAttributeOutput::StartRuby(const SwTextNode& rNode, sal_Int32 /*nPos*/,
                                   const SwFormatRuby& rRuby)
{
    WW8Ruby aWW8Ruby(rNode, rRuby, GetExport());
    OUString aStr = FieldString(ww::eEQ) + "\\* jc" + OUString::number(aWW8Ruby.GetJC())
                    + " \\* \"Font:" + aWW8Ruby.GetFontFamily() + "\" \\* hps"
                    + OUString::number((aWW8Ruby.GetRubyHeight() + 5) / 10) + " \\o";
    if (aWW8Ruby.GetDirective())
    {
        aStr += "\\a" + OUStringChar(aWW8Ruby.GetDirective());
    }
    aStr += "(\\s\\up " + OUString::number((aWW8Ruby.GetBaseHeight() + 10) / 20 - 1) + "(";
    m_rExport.OutputField(nullptr, ww::eEQ, aStr, FieldFlags::Start | FieldFlags::CmdStart);
    aStr = rRuby.GetText() + "),";
    m_rExport.OutputField(nullptr, ww::eEQ, aStr, FieldFlags::NONE);
    m_bInRuby = true;
}
 
void RtfAttributeOutput::EndRuby(const SwTextNode& /*rNode*/, sal_Int32 /*nPos*/) {}
 
bool RtfAttributeOutput::StartURL(const OUString& rUrl, const OUString& rTarget)
{
    m_aURLs.push(rUrl);
    // Ignore hyperlink without a URL.
    if (!rUrl.isEmpty())
    {
        m_aRun->append('{');
        m_aRun->append(OOO_STRING_SVTOOLS_RTF_FIELD);
        m_aRun->append('{');
        m_aRun->append(OOO_STRING_SVTOOLS_RTF_IGNORE);
        m_aRun->append(OOO_STRING_SVTOOLS_RTF_FLDINST);
        m_aRun->append(" HYPERLINK ");
 
        m_aRun->append("\"");
        m_aRun->append(msfilter::rtfutil::OutString(rUrl, m_rExport.GetCurrentEncoding()));
        m_aRun->append("\" ");
 
        if (!rTarget.isEmpty())
        {
            m_aRun->append("\\\\t \"");
            m_aRun->append(msfilter::rtfutil::OutString(rTarget, m_rExport.GetCurrentEncoding()));
            m_aRun->append("\" ");
        }
 
        m_aRun->append("}");
        m_aRun->append("{" OOO_STRING_SVTOOLS_RTF_FLDRSLT " {");
    }
    return true;
}
 
bool RtfAttributeOutput::EndURL(bool const isAtEndOfParagraph)
{
    if (m_aURLs.empty())
    {
        return true;
    }
 
    const OUString& rURL = m_aURLs.top();
    if (!rURL.isEmpty())
    {
        // UGLY: usually EndRun is called earlier, but there is an extra
        // call to OutAttrWithRange() when at the end of the paragraph,
        // so in that special case the output needs to be appended to the
        // new run's text instead of the previous run
        if (isAtEndOfParagraph)
        {
            // close the fldrslt group
            m_aRunText->append("}}");
            // close the field group
            m_aRunText->append('}');
        }
        else
        {
            // close the fldrslt group
            m_aRun->append("}}");
            // close the field group
            m_aRun->append('}');
        }
    }
    m_aURLs.pop();
    return true;
}
 
void RtfAttributeOutput::FieldVanish(const OUString& /*rText*/, ww::eField /*eType*/,
                                     OUString const* /*pBookmarkName*/)
{
    SAL_INFO("sw.rtf", "TODO: " << __func__);
}
 
void RtfAttributeOutput::Redline(const SwRedlineData* pRedline)
{
    if (!pRedline)
        return;
 
    if (pRedline->GetType() == RedlineType::Insert)
    {
        m_aRun->append(OOO_STRING_SVTOOLS_RTF_REVISED);
        m_aRun->append(OOO_STRING_SVTOOLS_RTF_REVAUTH);
        m_aRun->append(static_cast<sal_Int32>(
            m_rExport.GetRedline(SW_MOD()->GetRedlineAuthor(pRedline->GetAuthor()))));
        m_aRun->append(OOO_STRING_SVTOOLS_RTF_REVDTTM);
    }
    else if (pRedline->GetType() == RedlineType::Delete)
    {
        m_aRun->append(OOO_STRING_SVTOOLS_RTF_DELETED);
        m_aRun->append(OOO_STRING_SVTOOLS_RTF_REVAUTHDEL);
        m_aRun->append(static_cast<sal_Int32>(
            m_rExport.GetRedline(SW_MOD()->GetRedlineAuthor(pRedline->GetAuthor()))));
        m_aRun->append(OOO_STRING_SVTOOLS_RTF_REVDTTMDEL);
    }
    m_aRun->append(static_cast<sal_Int32>(sw::ms::DateTime2DTTM(pRedline->GetTimeStamp())));
    m_aRun->append(' ');
}
 
void RtfAttributeOutput::FormatDrop(const SwTextNode& /*rNode*/,
                                    const SwFormatDrop& /*rSwFormatDrop*/, sal_uInt16 /*nStyle*/,
                                    ww8::WW8TableNodeInfo::Pointer_t /*pTextNodeInfo*/,
                                    ww8::WW8TableNodeInfoInner::Pointer_t /*pTextNodeInfoInner*/)
{
    SAL_INFO("sw.rtf", "TODO: " << __func__);
}
 
void RtfAttributeOutput::ParagraphStyle(sal_uInt16 nStyle)
{
    OString* pStyle = m_rExport.GetStyle(nStyle);
    OStringBuffer aStyle(OOO_STRING_SVTOOLS_RTF_S
                         + OString::number(static_cast<sal_Int32>(nStyle)));
    if (pStyle)
        aStyle.append(*pStyle);
    if (!m_bBufferSectionHeaders)
        m_rExport.Strm().WriteOString(aStyle);
    else
        m_aSectionHeaders.append(aStyle);
}
 
void RtfAttributeOutput::TableInfoCell(
    ww8::WW8TableNodeInfoInner::Pointer_t /*pTableTextNodeInfoInner*/)
{
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_INTBL);
    if (m_nTableDepth > 1)
    {
        m_aStyles.append(OOO_STRING_SVTOOLS_RTF_ITAP);
        m_aStyles.append(static_cast<sal_Int32>(m_nTableDepth));
    }
    m_bWroteCellInfo = true;
}
 
void RtfAttributeOutput::TableInfoRow(ww8::WW8TableNodeInfoInner::Pointer_t /*pTableTextNodeInfo*/)
{
    /* noop */
}
 
void RtfAttributeOutput::TablePositioning(SwFrameFormat* pFlyFormat)
{
    if (!pFlyFormat || !pFlyFormat->GetFlySplit().GetValue())
    {
        return;
    }
 
    switch (pFlyFormat->GetVertOrient().GetRelationOrient())
    {
        case text::RelOrientation::PAGE_PRINT_AREA:
            // relative to margin
            m_aRowDefs.append(LO_STRING_SVTOOLS_RTF_TPVMRG);
            break;
        case text::RelOrientation::PAGE_FRAME:
            // relative to page
            m_aRowDefs.append(LO_STRING_SVTOOLS_RTF_TPVPG);
            break;
        default:
            // text::RelOrientation::FRAME
            // relative to text
            m_aRowDefs.append(LO_STRING_SVTOOLS_RTF_TPVPARA);
            break;
    }
 
    switch (pFlyFormat->GetHoriOrient().GetRelationOrient())
    {
        case text::RelOrientation::FRAME:
            // relative to column
            m_aRowDefs.append(LO_STRING_SVTOOLS_RTF_TPHCOL);
            break;
        case text::RelOrientation::PAGE_PRINT_AREA:
            // relative to margin
            m_aRowDefs.append(LO_STRING_SVTOOLS_RTF_TPHMRG);
            break;
        default:
            // text::RelOrientation::PAGE_FRAME
            // relative to page
            m_aRowDefs.append(LO_STRING_SVTOOLS_RTF_TPHPG);
            break;
    }
 
    // Similar to RtfAttributeOutput::FormatHorizOrientation(), but for tables.
    switch (pFlyFormat->GetHoriOrient().GetHoriOrient())
    {
        case text::HoriOrientation::LEFT:
            // left
            m_aRowDefs.append(LO_STRING_SVTOOLS_RTF_TPOSXL);
            break;
        case text::HoriOrientation::CENTER:
            // centered
            m_aRowDefs.append(LO_STRING_SVTOOLS_RTF_TPOSXC);
            break;
        case text::HoriOrientation::RIGHT:
            // right
            m_aRowDefs.append(LO_STRING_SVTOOLS_RTF_TPOSXR);
            break;
        default:
            SwTwips nTPosX = pFlyFormat->GetHoriOrient().GetPos();
            m_aRowDefs.append(LO_STRING_SVTOOLS_RTF_TPOSX);
            m_aRowDefs.append(static_cast<sal_Int32>(nTPosX));
            break;
    }
 
    // Similar to RtfAttributeOutput::FormatVertOrientation(), but for tables.
    switch (pFlyFormat->GetVertOrient().GetVertOrient())
    {
        case text::VertOrientation::TOP:
            // up
            m_aRowDefs.append(LO_STRING_SVTOOLS_RTF_TPOSYT);
            break;
        case text::VertOrientation::CENTER:
            // centered
            m_aRowDefs.append(LO_STRING_SVTOOLS_RTF_TPOSYC);
            break;
        case text::VertOrientation::BOTTOM:
            // down
            m_aRowDefs.append(LO_STRING_SVTOOLS_RTF_TPOSYB);
            break;
        default:
            SwTwips nTPosY = pFlyFormat->GetVertOrient().GetPos();
            m_aRowDefs.append(LO_STRING_SVTOOLS_RTF_TPOSY);
            m_aRowDefs.append(static_cast<sal_Int32>(nTPosY));
            break;
    }
 
    // Similar to RtfAttributeOutput::FormatULSpace(), but for tables.
    sal_uInt16 nTdfrmtxtTop = pFlyFormat->GetULSpace().GetUpper();
    m_aRowDefs.append(LO_STRING_SVTOOLS_RTF_TDFRMTXTTOP);
    m_aRowDefs.append(static_cast<sal_Int32>(nTdfrmtxtTop));
    sal_uInt16 nTdfrmtxtBottom = pFlyFormat->GetULSpace().GetLower();
    m_aRowDefs.append(LO_STRING_SVTOOLS_RTF_TDFRMTXTBOTTOM);
    m_aRowDefs.append(static_cast<sal_Int32>(nTdfrmtxtBottom));
 
    // Similar to RtfAttributeOutput::FormatLRSpace(), but for tables.
    sal_uInt16 nTdfrmtxtLeft = pFlyFormat->GetLRSpace().GetLeft();
    m_aRowDefs.append(LO_STRING_SVTOOLS_RTF_TDFRMTXTLEFT);
    m_aRowDefs.append(static_cast<sal_Int32>(nTdfrmtxtLeft));
    sal_uInt16 nTdfrmtxtRight = pFlyFormat->GetLRSpace().GetRight();
    m_aRowDefs.append(LO_STRING_SVTOOLS_RTF_TDFRMTXTRIGHT);
    m_aRowDefs.append(static_cast<sal_Int32>(nTdfrmtxtRight));
}
 
void RtfAttributeOutput::TableDefinition(
    ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner)
{
    InitTableHelper(pTableTextNodeInfoInner);
 
    const SwTable* pTable = pTableTextNodeInfoInner->getTable();
    SwFrameFormat* pFormat = pTable->GetFrameFormat();
 
    m_aRowDefs.append(OOO_STRING_SVTOOLS_RTF_TROWD);
    TableOrientation(pTableTextNodeInfoInner);
    TableBidi(pTableTextNodeInfoInner);
    TableHeight(pTableTextNodeInfoInner);
    TableCanSplit(pTableTextNodeInfoInner);
 
    // Write table positioning properties in case this is a floating table.
    TablePositioning(pTable->GetTableNode()->GetFlyFormat());
 
    // Cell margins
    const SvxBoxItem& rBox = pFormat->GetBox();
    static const SvxBoxItemLine aBorders[] = { SvxBoxItemLine::TOP, SvxBoxItemLine::LEFT,
                                               SvxBoxItemLine::BOTTOM, SvxBoxItemLine::RIGHT };
 
    static const char* aRowPadNames[]
        = { OOO_STRING_SVTOOLS_RTF_TRPADDT, OOO_STRING_SVTOOLS_RTF_TRPADDL,
            OOO_STRING_SVTOOLS_RTF_TRPADDB, OOO_STRING_SVTOOLS_RTF_TRPADDR };
 
    static const char* aRowPadUnits[]
        = { OOO_STRING_SVTOOLS_RTF_TRPADDFT, OOO_STRING_SVTOOLS_RTF_TRPADDFL,
            OOO_STRING_SVTOOLS_RTF_TRPADDFB, OOO_STRING_SVTOOLS_RTF_TRPADDFR };
 
    for (int i = 0; i < 4; ++i)
    {
        m_aRowDefs.append(aRowPadUnits[i]);
        m_aRowDefs.append(sal_Int32(3));
        m_aRowDefs.append(aRowPadNames[i]);
        m_aRowDefs.append(static_cast<sal_Int32>(rBox.GetDistance(aBorders[i])));
    }
 
    // The cell-dependent properties
    const double fWidthRatio = m_pTableWrt->GetAbsWidthRatio();
    const SwWriteTableRows& aRows = m_pTableWrt->GetRows();
    sal_uInt32 nRow = pTableTextNodeInfoInner->getRow();
    if (nRow >= aRows.size())
    {
        SAL_WARN("sw.ww8", "RtfAttributeOutput::TableDefinition: out of range row: " << nRow);
        return;
    }
    SwWriteTableRow* pRow = aRows[nRow].get();
    SwTwips nSz = 0;
 
    // Not using m_nTableDepth, which is not yet incremented here.
    sal_uInt32 nCurrentDepth = pTableTextNodeInfoInner->getDepth();
    m_aCells[nCurrentDepth] = pRow->GetCells().size();
    for (sal_uInt32 i = 0; i < m_aCells[nCurrentDepth]; i++)
    {
        const SwWriteTableCell* const pCell = pRow->GetCells()[i].get();
        const SwFrameFormat* pCellFormat = pCell->GetBox()->GetFrameFormat();
 
        pTableTextNodeInfoInner->setCell(i);
        TableCellProperties(pTableTextNodeInfoInner);
 
        // Right boundary: this can't be in TableCellProperties as the old
        // value of nSz is needed.
        nSz += pCellFormat->GetFrameSize().GetWidth();
        m_aRowDefs.append(OOO_STRING_SVTOOLS_RTF_CELLX);
        m_aRowDefs.append(static_cast<sal_Int32>(pFormat->GetLRSpace().GetLeft()
                                                 + rtl::math::round(nSz * fWidthRatio)));
    }
}
 
void RtfAttributeOutput::TableDefaultBorders(
    ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner)
{
    /*
     * The function name is a bit misleading: given that we write borders
     * before each row, we just have borders, not default ones. Additionally,
     * this function actually writes borders for a specific cell only and is
     * called for each cell.
     */
 
    const SwWriteTableRows& aRows = m_pTableWrt->GetRows();
    SwWriteTableRow* pRow = aRows[pTableTextNodeInfoInner->getRow()].get();
    const SwWriteTableCell* const pCell
        = pRow->GetCells()[pTableTextNodeInfoInner->getCell()].get();
    const SwFrameFormat* pCellFormat = pCell->GetBox()->GetFrameFormat();
    const SvxBoxItem* pItem = pCellFormat->GetAttrSet().GetItemIfSet(RES_BOX);
    if (!pItem)
        return;
 
    auto& rBox = *pItem;
    static const SvxBoxItemLine aBorders[] = { SvxBoxItemLine::TOP, SvxBoxItemLine::LEFT,
                                               SvxBoxItemLine::BOTTOM, SvxBoxItemLine::RIGHT };
    static const char* aBorderNames[]
        = { OOO_STRING_SVTOOLS_RTF_CLBRDRT, OOO_STRING_SVTOOLS_RTF_CLBRDRL,
            OOO_STRING_SVTOOLS_RTF_CLBRDRB, OOO_STRING_SVTOOLS_RTF_CLBRDRR };
    //Yes left and top are swapped with each other for cell padding! Because
    //that's what the thundering annoying rtf export/import word xp does.
    static const char* aCellPadNames[]
        = { OOO_STRING_SVTOOLS_RTF_CLPADL, OOO_STRING_SVTOOLS_RTF_CLPADT,
            OOO_STRING_SVTOOLS_RTF_CLPADB, OOO_STRING_SVTOOLS_RTF_CLPADR };
    static const char* aCellPadUnits[]
        = { OOO_STRING_SVTOOLS_RTF_CLPADFL, OOO_STRING_SVTOOLS_RTF_CLPADFT,
            OOO_STRING_SVTOOLS_RTF_CLPADFB, OOO_STRING_SVTOOLS_RTF_CLPADFR };
    for (int i = 0; i < 4; ++i)
    {
        if (const editeng::SvxBorderLine* pLn = rBox.GetLine(aBorders[i]))
            m_aRowDefs.append(OutTBLBorderLine(m_rExport, pLn, aBorderNames[i]));
        if (rBox.GetDistance(aBorders[i]))
        {
            m_aRowDefs.append(aCellPadUnits[i]);
            m_aRowDefs.append(sal_Int32(3));
            m_aRowDefs.append(aCellPadNames[i]);
            m_aRowDefs.append(static_cast<sal_Int32>(rBox.GetDistance(aBorders[i])));
        }
    }
}
 
void RtfAttributeOutput::TableBackgrounds(
    ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner)
{
    const SwTable* pTable = pTableTextNodeInfoInner->getTable();
    const SwTableBox* pTableBox = pTableTextNodeInfoInner->getTableBox();
    const SwTableLine* pTableLine = pTableBox->GetUpper();
 
    Color aColor = COL_AUTO;
    auto pTableColorProp
        = pTable->GetFrameFormat()->GetAttrSet().GetItem<SvxBrushItem>(RES_BACKGROUND);
    if (pTableColorProp)
        aColor = pTableColorProp->GetColor();
 
    auto pRowColorProp
        = pTableLine->GetFrameFormat()->GetAttrSet().GetItem<SvxBrushItem>(RES_BACKGROUND);
    if (pRowColorProp && pRowColorProp->GetColor() != COL_AUTO)
        aColor = pRowColorProp->GetColor();
 
    const SwWriteTableRows& aRows = m_pTableWrt->GetRows();
    SwWriteTableRow* pRow = aRows[pTableTextNodeInfoInner->getRow()].get();
    const SwWriteTableCell* const pCell
        = pRow->GetCells()[pTableTextNodeInfoInner->getCell()].get();
    const SwFrameFormat* pCellFormat = pCell->GetBox()->GetFrameFormat();
    if (const SvxBrushItem* pBrushItem = pCellFormat->GetAttrSet().GetItemIfSet(RES_BACKGROUND))
    {
        if (pBrushItem->GetColor() != COL_AUTO)
            aColor = pBrushItem->GetColor();
    }
 
    if (!aColor.IsTransparent())
    {
        m_aRowDefs.append(OOO_STRING_SVTOOLS_RTF_CLCBPAT);
        m_aRowDefs.append(static_cast<sal_Int32>(m_rExport.GetColor(aColor)));
    }
}
 
void RtfAttributeOutput::TableRowRedline(
    ww8::WW8TableNodeInfoInner::Pointer_t /*pTableTextNodeInfoInner*/)
{
}
 
void RtfAttributeOutput::TableCellRedline(
    ww8::WW8TableNodeInfoInner::Pointer_t /*pTableTextNodeInfoInner*/)
{
}
 
void RtfAttributeOutput::TableHeight(ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner)
{
    const SwTableBox* pTabBox = pTableTextNodeInfoInner->getTableBox();
    const SwTableLine* pTabLine = pTabBox->GetUpper();
    const SwFrameFormat* pLineFormat = pTabLine->GetFrameFormat();
    const SwFormatFrameSize& rLSz = pLineFormat->GetFrameSize();
 
    if (!(SwFrameSize::Variable != rLSz.GetHeightSizeType() && rLSz.GetHeight()))
        return;
 
    sal_Int32 nHeight = 0;
 
    switch (rLSz.GetHeightSizeType())
    {
        case SwFrameSize::Fixed:
            nHeight = -rLSz.GetHeight();
            break;
        case SwFrameSize::Minimum:
            nHeight = rLSz.GetHeight();
            break;
        default:
            break;
    }
 
    if (nHeight)
    {
        m_aRowDefs.append(OOO_STRING_SVTOOLS_RTF_TRRH);
        m_aRowDefs.append(nHeight);
    }
}
 
void RtfAttributeOutput::TableCanSplit(
    ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner)
{
    const SwTableBox* pTabBox = pTableTextNodeInfoInner->getTableBox();
    const SwTableLine* pTabLine = pTabBox->GetUpper();
    const SwFrameFormat* pLineFormat = pTabLine->GetFrameFormat();
    const SwFormatRowSplit& rSplittable = pLineFormat->GetRowSplit();
 
    // The rtf default is to allow a row to break
    if (!rSplittable.GetValue())
        m_aRowDefs.append(OOO_STRING_SVTOOLS_RTF_TRKEEP);
}
 
void RtfAttributeOutput::TableBidi(ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner)
{
    const SwTable* pTable = pTableTextNodeInfoInner->getTable();
    const SwFrameFormat* pFrameFormat = pTable->GetFrameFormat();
 
    if (m_rExport.TrueFrameDirection(*pFrameFormat) != SvxFrameDirection::Horizontal_RL_TB)
        m_aRowDefs.append(OOO_STRING_SVTOOLS_RTF_LTRROW);
    else
        m_aRowDefs.append(OOO_STRING_SVTOOLS_RTF_RTLROW);
}
 
void RtfAttributeOutput::TableVerticalCell(
    ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner)
{
    const SwWriteTableRows& aRows = m_pTableWrt->GetRows();
    SwWriteTableRow* pRow = aRows[pTableTextNodeInfoInner->getRow()].get();
    const SwWriteTableCell* const pCell
        = pRow->GetCells()[pTableTextNodeInfoInner->getCell()].get();
    const SwFrameFormat* pCellFormat = pCell->GetBox()->GetFrameFormat();
 
    // Text direction.
    if (SvxFrameDirection::Vertical_RL_TB == m_rExport.TrueFrameDirection(*pCellFormat))
        m_aRowDefs.append(OOO_STRING_SVTOOLS_RTF_CLTXTBRL);
    else if (SvxFrameDirection::Vertical_LR_BT == m_rExport.TrueFrameDirection(*pCellFormat))
        m_aRowDefs.append(OOO_STRING_SVTOOLS_RTF_CLTXBTLR);
 
    // vertical merges
    if (pCell->GetRowSpan() > 1)
        m_aRowDefs.append(OOO_STRING_SVTOOLS_RTF_CLVMGF);
    else if (pCell->GetRowSpan() == 0)
        m_aRowDefs.append(OOO_STRING_SVTOOLS_RTF_CLVMRG);
 
    // vertical alignment
    const SwFormatVertOrient* pVertOrientItem
        = pCellFormat->GetAttrSet().GetItemIfSet(RES_VERT_ORIENT);
    if (!pVertOrientItem)
        return;
 
    switch (pVertOrientItem->GetVertOrient())
    {
        case text::VertOrientation::CENTER:
            m_aRowDefs.append(OOO_STRING_SVTOOLS_RTF_CLVERTALC);
            break;
        case text::VertOrientation::BOTTOM:
            m_aRowDefs.append(OOO_STRING_SVTOOLS_RTF_CLVERTALB);
            break;
        default:
            m_aRowDefs.append(OOO_STRING_SVTOOLS_RTF_CLVERTALT);
            break;
    }
}
 
void RtfAttributeOutput::TableNodeInfoInner(ww8::WW8TableNodeInfoInner::Pointer_t pNodeInfoInner)
{
    // This is called when the nested table ends in a cell, and there's no
    // paragraph behind that; so we must check for the ends of cell, rows,
    // and tables
    FinishTableRowCell(pNodeInfoInner);
}
 
void RtfAttributeOutput::TableOrientation(
    ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner)
{
    const SwTable* pTable = pTableTextNodeInfoInner->getTable();
    SwFrameFormat* pFormat = pTable->GetFrameFormat();
 
    OStringBuffer aTableAdjust(OOO_STRING_SVTOOLS_RTF_TRQL);
    switch (pFormat->GetHoriOrient().GetHoriOrient())
    {
        case text::HoriOrientation::CENTER:
            aTableAdjust.setLength(0);
            aTableAdjust.append(OOO_STRING_SVTOOLS_RTF_TRQC);
            break;
        case text::HoriOrientation::RIGHT:
            aTableAdjust.setLength(0);
            aTableAdjust.append(OOO_STRING_SVTOOLS_RTF_TRQR);
            break;
        case text::HoriOrientation::NONE:
        case text::HoriOrientation::LEFT_AND_WIDTH:
            aTableAdjust.append(OOO_STRING_SVTOOLS_RTF_TRLEFT);
            aTableAdjust.append(static_cast<sal_Int32>(pFormat->GetLRSpace().GetLeft()));
            break;
        default:
            break;
    }
 
    m_aRowDefs.append(aTableAdjust);
}
 
void RtfAttributeOutput::TableSpacing(
    ww8::WW8TableNodeInfoInner::Pointer_t /*pTableTextNodeInfoInner*/)
{
    SAL_INFO("sw.rtf", "TODO: " << __func__);
}
 
void RtfAttributeOutput::TableRowEnd(sal_uInt32 /*nDepth*/) { /* noop, see EndTableRow() */}
 
/*
 * Our private table methods.
 */
 
void RtfAttributeOutput::InitTableHelper(
    const ww8::WW8TableNodeInfoInner::Pointer_t& pTableTextNodeInfoInner)
{
    const SwTable* pTable = pTableTextNodeInfoInner->getTable();
    if (m_pTableWrt && pTable == m_pTableWrt->GetTable())
        return;
 
    tools::Long nPageSize = 0;
    bool bRelBoxSize = false;
 
    // Create the SwWriteTable instance to use col spans
    GetTablePageSize(pTableTextNodeInfoInner.get(), nPageSize, bRelBoxSize);
 
    const SwFrameFormat* pFormat = pTable->GetFrameFormat();
    const sal_uInt32 nTableSz = pFormat->GetFrameSize().GetWidth();
 
    const SwHTMLTableLayout* pLayout = pTable->GetHTMLTableLayout();
    if (pLayout && pLayout->IsExportable())
        m_pTableWrt = std::make_unique<SwWriteTable>(pTable, pLayout);
    else
        m_pTableWrt = std::make_unique<SwWriteTable>(pTable, pTable->GetTabLines(), nPageSize,
                                                     nTableSz, false);
}
 
void RtfAttributeOutput::StartTable()
{
    // To trigger calling InitTableHelper()
    m_pTableWrt.reset();
}
 
void RtfAttributeOutput::StartTableRow(
    const ww8::WW8TableNodeInfoInner::Pointer_t& pTableTextNodeInfoInner)
{
    sal_uInt32 nCurrentDepth = pTableTextNodeInfoInner->getDepth();
    SAL_INFO("sw.rtf", __func__ << ", (depth is " << nCurrentDepth << ")");
    m_bTableRowEnded = false;
 
    TableDefinition(pTableTextNodeInfoInner);
 
    if (!m_bLastTable)
        m_aTables.push_back(m_aRowDefs.makeStringAndClear());
 
    // We'll write the table definition for nested tables later
    if (nCurrentDepth > 1)
        return;
    // Empty the previous row closing buffer before starting the new one,
    // necessary for subtables.
    m_rExport.Strm().WriteOString(m_aAfterRuns);
    m_aAfterRuns.setLength(0);
    m_rExport.Strm().WriteOString(m_aRowDefs);
    m_aRowDefs.setLength(0);
}
 
void RtfAttributeOutput::StartTableCell() { m_bTableCellOpen = true; }
 
void RtfAttributeOutput::TableCellProperties(
    const ww8::WW8TableNodeInfoInner::Pointer_t& pTableTextNodeInfoInner)
{
    TableDefaultBorders(pTableTextNodeInfoInner);
    TableBackgrounds(pTableTextNodeInfoInner);
    TableVerticalCell(pTableTextNodeInfoInner);
}
 
void RtfAttributeOutput::EndTableCell()
{
    SAL_INFO("sw.rtf", __func__ << ", (depth is " << m_nTableDepth << ")");
 
    if (!m_bWroteCellInfo)
    {
        m_aAfterRuns.append(OOO_STRING_SVTOOLS_RTF_INTBL);
        m_aAfterRuns.append(OOO_STRING_SVTOOLS_RTF_ITAP);
        m_aAfterRuns.append(static_cast<sal_Int32>(m_nTableDepth));
    }
    if (m_nTableDepth > 1)
        m_aAfterRuns.append(OOO_STRING_SVTOOLS_RTF_NESTCELL);
    else
        m_aAfterRuns.append(OOO_STRING_SVTOOLS_RTF_CELL);
 
    m_bTableCellOpen = false;
    m_bTableAfterCell = true;
    m_bWroteCellInfo = false;
    if (m_aCells[m_nTableDepth] > 0)
        m_aCells[m_nTableDepth]--;
}
 
void RtfAttributeOutput::EndTableRow()
{
    SAL_INFO("sw.rtf", __func__ << ", (depth is " << m_nTableDepth << ")");
 
    if (m_nTableDepth > 1)
    {
        m_aAfterRuns.append(
            "{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_NESTTABLEPROPRS);
        if (!m_aRowDefs.isEmpty())
        {
            m_aAfterRuns.append(m_aRowDefs);
            m_aRowDefs.setLength(0);
        }
        else if (!m_aTables.empty())
        {
            m_aAfterRuns.append(m_aTables.back());
            m_aTables.pop_back();
        }
        m_aAfterRuns.append(OOO_STRING_SVTOOLS_RTF_NESTROW
                            "}"
                            "{" OOO_STRING_SVTOOLS_RTF_NONESTTABLES OOO_STRING_SVTOOLS_RTF_PAR "}");
    }
    else
    {
        if (!m_aTables.empty())
        {
            m_aAfterRuns.append(m_aTables.back());
            m_aTables.pop_back();
        }
        // Make sure that the first word of the next paragraph is not merged with the last control
        // word of this table row, happens with floating tables.
        m_aAfterRuns.append(OOO_STRING_SVTOOLS_RTF_ROW OOO_STRING_SVTOOLS_RTF_PARD " ");
    }
    m_bTableRowEnded = true;
}
 
void RtfAttributeOutput::EndTable()
{
    if (m_nTableDepth > 0)
    {
        m_nTableDepth--;
        m_pTableWrt.reset();
    }
 
    // We closed the table; if it is a nested table, the cell that contains it
    // still continues
    m_bTableCellOpen = true;
 
    // Cleans the table helper
    m_pTableWrt.reset();
}
 
void RtfAttributeOutput::FinishTableRowCell(const ww8::WW8TableNodeInfoInner::Pointer_t& pInner)
{
    if (!pInner)
        return;
 
    // Where are we in the table
    sal_uInt32 nRow = pInner->getRow();
 
    const SwTable* pTable = pInner->getTable();
    const SwTableLines& rLines = pTable->GetTabLines();
    sal_uInt16 nLinesCount = rLines.size();
 
    if (pInner->isEndOfCell())
        EndTableCell();
 
    // This is a line end
    if (pInner->isEndOfLine())
        EndTableRow();
 
    // This is the end of the table
    if (pInner->isEndOfLine() && (nRow + 1) == nLinesCount)
        EndTable();
}
 
void RtfAttributeOutput::StartStyles()
{
    m_rExport.Strm()
        .WriteOString(SAL_NEWLINE_STRING)
        .WriteChar('{')
        .WriteOString(OOO_STRING_SVTOOLS_RTF_COLORTBL);
    m_rExport.OutColorTable();
    OSL_ENSURE(m_aStylesheet.getLength() == 0, "m_aStylesheet is not empty");
    m_aStylesheet.append(SAL_NEWLINE_STRING);
    m_aStylesheet.append('{');
    m_aStylesheet.append(OOO_STRING_SVTOOLS_RTF_STYLESHEET);
}
 
void RtfAttributeOutput::EndStyles(sal_uInt16 /*nNumberOfStyles*/)
{
    m_rExport.Strm().WriteChar('}');
    m_rExport.Strm().WriteOString(m_aStylesheet);
    m_aStylesheet.setLength(0);
    m_rExport.Strm().WriteChar('}');
}
 
void RtfAttributeOutput::DefaultStyle() { /* noop, the default style is always 0 in RTF */}
 
void RtfAttributeOutput::StartStyle(const OUString& rName, StyleType eType, sal_uInt16 nBase,
                                    sal_uInt16 nNext, sal_uInt16 /*nLink*/, sal_uInt16 /*nWwId*/,
                                    sal_uInt16 nSlot, bool bAutoUpdate)
{
    SAL_INFO("sw.rtf", __func__ << ", rName = '" << rName << "'");
 
    m_aStylesheet.append('{');
    if (eType == STYLE_TYPE_PARA)
        m_aStylesheet.append(OOO_STRING_SVTOOLS_RTF_S);
    else
        m_aStylesheet.append(OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_CS);
    m_aStylesheet.append(static_cast<sal_Int32>(nSlot));
 
    if (nBase != 0x0FFF)
    {
        m_aStylesheet.append(OOO_STRING_SVTOOLS_RTF_SBASEDON);
        m_aStylesheet.append(static_cast<sal_Int32>(nBase));
    }
 
    m_aStylesheet.append(OOO_STRING_SVTOOLS_RTF_SNEXT);
    m_aStylesheet.append(static_cast<sal_Int32>(nNext));
 
    if (bAutoUpdate)
        m_aStylesheet.append(OOO_STRING_SVTOOLS_RTF_SAUTOUPD);
 
    m_rStyleName = rName;
    m_nStyleId = nSlot;
}
 
void RtfAttributeOutput::EndStyle()
{
    OString aStyles = MoveCharacterProperties();
    m_rExport.InsStyle(m_nStyleId, aStyles);
    m_aStylesheet.append(aStyles);
    m_aStylesheet.append(' ');
    m_aStylesheet.append(
        msfilter::rtfutil::OutString(m_rStyleName, m_rExport.GetCurrentEncoding()));
    m_aStylesheet.append(";}");
    m_aStylesheet.append(SAL_NEWLINE_STRING);
}
 
void RtfAttributeOutput::StartStyleProperties(bool /*bParProp*/, sal_uInt16 /*nStyle*/)
{
    /* noop */
}
 
void RtfAttributeOutput::EndStyleProperties(bool /*bParProp*/) { /* noop */}
 
void RtfAttributeOutput::OutlineNumbering(sal_uInt8 nLvl)
{
    if (nLvl >= WW8ListManager::nMaxLevel)
        nLvl = WW8ListManager::nMaxLevel - 1;
 
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_ILVL);
    m_aStyles.append(static_cast<sal_Int32>(nLvl));
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_OUTLINELEVEL);
    m_aStyles.append(static_cast<sal_Int32>(nLvl));
}
 
void RtfAttributeOutput::PageBreakBefore(bool bBreak)
{
    if (bBreak)
    {
        m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_PAGEBB);
    }
}
 
void RtfAttributeOutput::SectionBreak(sal_uInt8 nC, bool /*bBreakAfter*/,
                                      const WW8_SepInfo* pSectionInfo, bool /*bExtraPageBreak*/)
{
    switch (nC)
    {
        case msword::ColumnBreak:
            m_nColBreakNeeded = true;
            break;
        case msword::PageBreak:
            if (pSectionInfo)
                m_rExport.SectionProperties(*pSectionInfo);
            break;
    }
}
 
void RtfAttributeOutput::StartSection()
{
    if (m_bIsBeforeFirstParagraph)
        return;
 
    m_aSectionBreaks.append(OOO_STRING_SVTOOLS_RTF_SECT OOO_STRING_SVTOOLS_RTF_SECTD);
    if (!m_bBufferSectionBreaks)
    {
        m_rExport.Strm().WriteOString(m_aSectionBreaks);
        m_aSectionBreaks.setLength(0);
    }
}
 
void RtfAttributeOutput::EndSection()
{
    /*
     * noop, \sect must go to StartSection or Word won't notice multiple
     * columns...
     */
}
 
void RtfAttributeOutput::SectionFormProtection(bool bProtected)
{
    m_aSectionBreaks.append(OOO_STRING_SVTOOLS_RTF_SECTUNLOCKED);
    m_aSectionBreaks.append(static_cast<sal_Int32>(!bProtected));
}
 
void RtfAttributeOutput::SectionLineNumbering(sal_uLong nRestartNo,
                                              const SwLineNumberInfo& rLnNumInfo)
{
    m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_LINEMOD);
    m_rExport.Strm().WriteNumberAsString(rLnNumInfo.GetCountBy());
    m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_LINEX);
    m_rExport.Strm().WriteNumberAsString(rLnNumInfo.GetPosFromLeft());
    if (!rLnNumInfo.IsRestartEachPage())
        m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_LINECONT);
 
    if (nRestartNo > 0)
    {
        m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_LINESTARTS);
        m_rExport.Strm().WriteNumberAsString(nRestartNo);
    }
}
 
void RtfAttributeOutput::SectionTitlePage()
{
    /*
     * noop, handled in RtfExport::WriteHeaderFooter()
     */
}
 
void RtfAttributeOutput::SectionPageBorders(const SwFrameFormat* pFormat,
                                            const SwFrameFormat* /*pFirstPageFormat*/)
{
    const SvxBoxItem& rBox = pFormat->GetBox();
    editeng::WordBorderDistances aDistances;
    editeng::BorderDistancesToWord(rBox, m_aPageMargins, aDistances);
 
    if (aDistances.bFromEdge)
    {
        sal_uInt16 nOpt = (1 << 5);
        m_aSectionBreaks.append(OOO_STRING_SVTOOLS_RTF_PGBRDROPT);
        m_aSectionBreaks.append(static_cast<sal_Int32>(nOpt));
    }
 
    const editeng::SvxBorderLine* pLine = rBox.GetTop();
    if (pLine)
        m_aSectionBreaks.append(
            OutBorderLine(m_rExport, pLine, OOO_STRING_SVTOOLS_RTF_PGBRDRT, aDistances.nTop));
    pLine = rBox.GetBottom();
    if (pLine)
        m_aSectionBreaks.append(
            OutBorderLine(m_rExport, pLine, OOO_STRING_SVTOOLS_RTF_PGBRDRB, aDistances.nBottom));
    pLine = rBox.GetLeft();
    if (pLine)
        m_aSectionBreaks.append(
            OutBorderLine(m_rExport, pLine, OOO_STRING_SVTOOLS_RTF_PGBRDRL, aDistances.nLeft));
    pLine = rBox.GetRight();
    if (pLine)
        m_aSectionBreaks.append(
            OutBorderLine(m_rExport, pLine, OOO_STRING_SVTOOLS_RTF_PGBRDRR, aDistances.nRight));
}
 
void RtfAttributeOutput::SectionBiDi(bool bBiDi)
{
    m_rExport.Strm().WriteOString(bBiDi ? OOO_STRING_SVTOOLS_RTF_RTLSECT
                                        : OOO_STRING_SVTOOLS_RTF_LTRSECT);
}
 
void RtfAttributeOutput::SectionPageNumbering(sal_uInt16 nNumType,
                                              const ::std::optional<sal_uInt16>& oPageRestartNumber)
{
    if (oPageRestartNumber)
    {
        m_aSectionBreaks.append(OOO_STRING_SVTOOLS_RTF_PGNSTARTS);
        m_aSectionBreaks.append(static_cast<sal_Int32>(*oPageRestartNumber));
        m_aSectionBreaks.append(OOO_STRING_SVTOOLS_RTF_PGNRESTART);
    }
 
    const char* pStr = nullptr;
    switch (nNumType)
    {
        case SVX_NUM_CHARS_UPPER_LETTER:
        case SVX_NUM_CHARS_UPPER_LETTER_N:
            pStr = OOO_STRING_SVTOOLS_RTF_PGNUCLTR;
            break;
        case SVX_NUM_CHARS_LOWER_LETTER:
        case SVX_NUM_CHARS_LOWER_LETTER_N:
            pStr = OOO_STRING_SVTOOLS_RTF_PGNLCLTR;
            break;
        case SVX_NUM_ROMAN_UPPER:
            pStr = OOO_STRING_SVTOOLS_RTF_PGNUCRM;
            break;
        case SVX_NUM_ROMAN_LOWER:
            pStr = OOO_STRING_SVTOOLS_RTF_PGNLCRM;
            break;
 
        case SVX_NUM_ARABIC:
            pStr = OOO_STRING_SVTOOLS_RTF_PGNDEC;
            break;
    }
    if (pStr)
        m_aSectionBreaks.append(pStr);
}
 
void RtfAttributeOutput::SectionType(sal_uInt8 nBreakCode)
{
    SAL_INFO("sw.rtf", __func__ << ", nBreakCode = " << int(nBreakCode));
 
    /*
     * break code:   0 No break, 1 New column
     * 2 New page, 3 Even page, 4 Odd page
     */
    const char* sType = nullptr;
    switch (nBreakCode)
    {
        case 1:
            sType = OOO_STRING_SVTOOLS_RTF_SBKCOL;
            break;
        case 2:
            sType = OOO_STRING_SVTOOLS_RTF_SBKPAGE;
            break;
        case 3:
            sType = OOO_STRING_SVTOOLS_RTF_SBKEVEN;
            break;
        case 4:
            sType = OOO_STRING_SVTOOLS_RTF_SBKODD;
            break;
        default:
            sType = OOO_STRING_SVTOOLS_RTF_SBKNONE;
            break;
    }
    m_aSectionBreaks.append(sType);
    if (!m_bBufferSectionBreaks)
    {
        m_rExport.Strm().WriteOString(m_aSectionBreaks);
        m_aSectionBreaks.setLength(0);
    }
}
 
void RtfAttributeOutput::SectFootnoteEndnotePr()
{
    WriteFootnoteEndnotePr(true, m_rExport.m_rDoc.GetFootnoteInfo());
    WriteFootnoteEndnotePr(false, m_rExport.m_rDoc.GetEndNoteInfo());
}
 
void RtfAttributeOutput::WriteFootnoteEndnotePr(bool bFootnote, const SwEndNoteInfo& rInfo)
{
    const char* pOut = nullptr;
 
    if (bFootnote)
    {
        switch (rInfo.m_aFormat.GetNumberingType())
        {
            default:
                pOut = OOO_STRING_SVTOOLS_RTF_SFTNNAR;
                break;
            case SVX_NUM_CHARS_LOWER_LETTER:
            case SVX_NUM_CHARS_LOWER_LETTER_N:
                pOut = OOO_STRING_SVTOOLS_RTF_SFTNNALC;
                break;
            case SVX_NUM_CHARS_UPPER_LETTER:
            case SVX_NUM_CHARS_UPPER_LETTER_N:
                pOut = OOO_STRING_SVTOOLS_RTF_SFTNNAUC;
                break;
            case SVX_NUM_ROMAN_LOWER:
                pOut = OOO_STRING_SVTOOLS_RTF_SFTNNRLC;
                break;
            case SVX_NUM_ROMAN_UPPER:
                pOut = OOO_STRING_SVTOOLS_RTF_SFTNNRUC;
                break;
            case SVX_NUM_SYMBOL_CHICAGO:
                pOut = OOO_STRING_SVTOOLS_RTF_SFTNNCHI;
                break;
        }
    }
    else
    {
        switch (rInfo.m_aFormat.GetNumberingType())
        {
            default:
                pOut = OOO_STRING_SVTOOLS_RTF_SAFTNNAR;
                break;
            case SVX_NUM_CHARS_LOWER_LETTER:
            case SVX_NUM_CHARS_LOWER_LETTER_N:
                pOut = OOO_STRING_SVTOOLS_RTF_SAFTNNALC;
                break;
            case SVX_NUM_CHARS_UPPER_LETTER:
            case SVX_NUM_CHARS_UPPER_LETTER_N:
                pOut = OOO_STRING_SVTOOLS_RTF_SAFTNNAUC;
                break;
            case SVX_NUM_ROMAN_LOWER:
                pOut = OOO_STRING_SVTOOLS_RTF_SAFTNNRLC;
                break;
            case SVX_NUM_ROMAN_UPPER:
                pOut = OOO_STRING_SVTOOLS_RTF_SAFTNNRUC;
                break;
            case SVX_NUM_SYMBOL_CHICAGO:
                pOut = OOO_STRING_SVTOOLS_RTF_SAFTNNCHI;
                break;
        }
    }
 
    m_aSectionBreaks.append(pOut);
 
    if (!m_bBufferSectionBreaks)
    {
        m_rExport.Strm().WriteOString(m_aSectionBreaks);
        m_aSectionBreaks.setLength(0);
    }
}
 
void RtfAttributeOutput::NumberingDefinition(sal_uInt16 nId, const SwNumRule& /*rRule*/)
{
    m_rExport.Strm().WriteChar('{').WriteOString(OOO_STRING_SVTOOLS_RTF_LISTOVERRIDE);
    m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_LISTID);
    m_rExport.Strm().WriteNumberAsString(nId);
    m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_LISTOVERRIDECOUNT).WriteChar('0');
    m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_LS);
    m_rExport.Strm().WriteNumberAsString(nId).WriteChar('}');
}
 
void RtfAttributeOutput::StartAbstractNumbering(sal_uInt16 nId)
{
    m_rExport.Strm()
        .WriteChar('{')
        .WriteOString(OOO_STRING_SVTOOLS_RTF_LIST)
        .WriteOString(OOO_STRING_SVTOOLS_RTF_LISTTEMPLATEID);
    m_rExport.Strm().WriteNumberAsString(nId);
    m_nListId = nId;
}
 
void RtfAttributeOutput::EndAbstractNumbering()
{
    m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_LISTID);
    m_rExport.Strm().WriteNumberAsString(m_nListId).WriteChar('}').WriteOString(SAL_NEWLINE_STRING);
}
 
void RtfAttributeOutput::NumberingLevel(sal_uInt8 nLevel, sal_uInt16 nStart,
                                        sal_uInt16 nNumberingType, SvxAdjust eAdjust,
                                        const sal_uInt8* pNumLvlPos, sal_uInt8 nFollow,
                                        const wwFont* pFont, const SfxItemSet* pOutSet,
                                        sal_Int16 nIndentAt, sal_Int16 nFirstLineIndex,
                                        sal_Int16 /*nListTabPos*/, const OUString& rNumberingString,
                                        const SvxBrushItem* pBrush, bool /*isLegal*/)
{
    m_rExport.Strm().WriteOString(SAL_NEWLINE_STRING);
    if (nLevel > 8) // RTF knows only 9 levels
        m_rExport.Strm()
            .WriteOString(OOO_STRING_SVTOOLS_RTF_IGNORE)
            .WriteOString(OOO_STRING_SVTOOLS_RTF_SOUTLVL);
 
    m_rExport.Strm().WriteChar('{').WriteOString(OOO_STRING_SVTOOLS_RTF_LISTLEVEL);
 
    sal_uInt16 nVal = 0;
    switch (nNumberingType)
    {
        case SVX_NUM_ROMAN_UPPER:
            nVal = 1;
            break;
        case SVX_NUM_ROMAN_LOWER:
            nVal = 2;
            break;
        case SVX_NUM_CHARS_UPPER_LETTER:
        case SVX_NUM_CHARS_UPPER_LETTER_N:
            nVal = 3;
            break;
        case SVX_NUM_CHARS_LOWER_LETTER:
        case SVX_NUM_CHARS_LOWER_LETTER_N:
            nVal = 4;
            break;
        case SVX_NUM_FULL_WIDTH_ARABIC:
            nVal = 14;
            break;
        case SVX_NUM_CIRCLE_NUMBER:
            nVal = 18;
            break;
        case SVX_NUM_NUMBER_LOWER_ZH:
            nVal = 35;
            if (pOutSet)
            {
                const SvxLanguageItem& rLang = pOutSet->Get(RES_CHRATR_CJK_LANGUAGE);
                if (rLang.GetLanguage() == LANGUAGE_CHINESE_SIMPLIFIED)
                {
                    nVal = 39;
                }
            }
            break;
        case SVX_NUM_NUMBER_UPPER_ZH:
            nVal = 38;
            break;
        case SVX_NUM_NUMBER_UPPER_ZH_TW:
            nVal = 34;
            break;
        case SVX_NUM_TIAN_GAN_ZH:
            nVal = 30;
            break;
        case SVX_NUM_DI_ZI_ZH:
            nVal = 31;
            break;
        case SVX_NUM_NUMBER_TRADITIONAL_JA:
            nVal = 16;
            break;
        case SVX_NUM_AIU_FULLWIDTH_JA:
            nVal = 20;
            break;
        case SVX_NUM_AIU_HALFWIDTH_JA:
            nVal = 12;
            break;
        case SVX_NUM_IROHA_FULLWIDTH_JA:
            nVal = 21;
            break;
        case SVX_NUM_IROHA_HALFWIDTH_JA:
            nVal = 13;
            break;
        case style::NumberingType::HANGUL_SYLLABLE_KO:
            nVal = 24;
            break; // ganada
        case style::NumberingType::HANGUL_JAMO_KO:
            nVal = 25;
            break; // chosung
        case style::NumberingType::HANGUL_CIRCLED_SYLLABLE_KO:
            nVal = 24;
            break;
        case style::NumberingType::HANGUL_CIRCLED_JAMO_KO:
            nVal = 25;
            break;
        case style::NumberingType::NUMBER_HANGUL_KO:
            nVal = 42;
            break; // koreanCounting
        case style::NumberingType::NUMBER_DIGITAL_KO:
            nVal = 41; // koreanDigital
            break;
        case style::NumberingType::NUMBER_DIGITAL2_KO:
            nVal = 44; // koreanDigital2
            break;
        case style::NumberingType::NUMBER_LEGAL_KO:
            nVal = 43; // koreanLegal
            break;
 
        case SVX_NUM_BITMAP:
        case SVX_NUM_CHAR_SPECIAL:
            nVal = 23;
            break;
        case SVX_NUM_NUMBER_NONE:
            nVal = 255;
            break;
        case SVX_NUM_ARABIC_ZERO:
            nVal = 22;
            break;
    }
    m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_LEVELNFC);
    m_rExport.Strm().WriteNumberAsString(nVal);
 
    switch (eAdjust)
    {
        case SvxAdjust::Center:
            nVal = 1;
            break;
        case SvxAdjust::Right:
            nVal = 2;
            break;
        default:
            nVal = 0;
            break;
    }
    m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_LEVELJC);
    m_rExport.Strm().WriteNumberAsString(nVal);
 
    // bullet
    if (nNumberingType == SVX_NUM_BITMAP && pBrush)
    {
        int nIndex = m_rExport.GetGrfIndex(*pBrush);
        if (nIndex != -1)
        {
            m_rExport.Strm().WriteOString(LO_STRING_SVTOOLS_RTF_LEVELPICTURE);
            m_rExport.Strm().WriteNumberAsString(nIndex);
        }
    }
 
    m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_LEVELSTARTAT);
    m_rExport.Strm().WriteNumberAsString(nStart);
 
    m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_LEVELFOLLOW);
    m_rExport.Strm().WriteNumberAsString(nFollow);
 
    // leveltext group
    m_rExport.Strm().WriteChar('{').WriteOString(OOO_STRING_SVTOOLS_RTF_LEVELTEXT).WriteChar(' ');
 
    if (SVX_NUM_CHAR_SPECIAL == nNumberingType || SVX_NUM_BITMAP == nNumberingType)
    {
        m_rExport.Strm().WriteOString("\\'01");
        sal_Unicode cChar = rNumberingString[0];
        m_rExport.Strm().WriteOString("\\u");
        m_rExport.Strm().WriteNumberAsString(cChar);
        m_rExport.Strm().WriteOString(" ?");
    }
    else
    {
        m_rExport.Strm().WriteOString("\\'").WriteOString(
            msfilter::rtfutil::OutHex(rNumberingString.getLength(), 2));
        m_rExport.Strm().WriteOString(msfilter::rtfutil::OutString(rNumberingString,
                                                                   m_rExport.GetDefaultEncoding(),
                                                                   /*bUnicode =*/false));
    }
 
    m_rExport.Strm().WriteOString(";}");
 
    // write the levelnumbers
    m_rExport.Strm().WriteOString("{").WriteOString(OOO_STRING_SVTOOLS_RTF_LEVELNUMBERS);
    for (sal_uInt8 i = 0; i <= nLevel && pNumLvlPos[i]; ++i)
    {
        m_rExport.Strm().WriteOString("\\'").WriteOString(
            msfilter::rtfutil::OutHex(pNumLvlPos[i], 2));
    }
    m_rExport.Strm().WriteOString(";}");
 
    if (pOutSet)
    {
        if (pFont)
        {
            m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_F);
            m_rExport.Strm().WriteNumberAsString(m_rExport.m_aFontHelper.GetId(*pFont));
        }
        m_rExport.OutputItemSet(*pOutSet, false, true, i18n::ScriptType::LATIN,
                                m_rExport.m_bExportModeRTF);
        const OString aProperties = MoveCharacterProperties(true);
        m_rExport.Strm().WriteOString(aProperties);
    }
 
    m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_FI);
    m_rExport.Strm().WriteNumberAsString(nFirstLineIndex).WriteOString(OOO_STRING_SVTOOLS_RTF_LI);
    m_rExport.Strm().WriteNumberAsString(nIndentAt);
 
    m_rExport.Strm().WriteChar('}');
    if (nLevel > 8)
        m_rExport.Strm().WriteChar('}');
}
 
void RtfAttributeOutput::WriteField_Impl(const SwField* const pField, ww::eField /*eType*/,
                                         std::u16string_view rFieldCmd, FieldFlags nMode)
{
    // If there are no field instructions, don't export it as a field.
    bool bHasInstructions = !rFieldCmd.empty();
    if (FieldFlags::All == nMode)
    {
        if (bHasInstructions)
        {
            m_aRunText->append("{" OOO_STRING_SVTOOLS_RTF_FIELD);
            if (pField && (pField->GetSubType() & FIXEDFLD))
                m_aRunText->append(OOO_STRING_SVTOOLS_RTF_FLDLOCK);
            m_aRunText->append("{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_FLDINST
                               " ");
            m_aRunText->append(
                msfilter::rtfutil::OutString(rFieldCmd, m_rExport.GetCurrentEncoding()));
            m_aRunText->append("}{" OOO_STRING_SVTOOLS_RTF_FLDRSLT " ");
        }
        if (pField)
            m_aRunText->append(msfilter::rtfutil::OutString(pField->ExpandField(true, nullptr),
                                                            m_rExport.GetDefaultEncoding()));
        if (bHasInstructions)
            m_aRunText->append("}}");
    }
    else
    {
        if (nMode & FieldFlags::CmdStart)
        {
            m_aRunText->append("{" OOO_STRING_SVTOOLS_RTF_FIELD);
            m_aRunText->append("{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_FLDINST
                               // paragraph break closes group so open another one "inside" to
                               " {"); // prevent leaving the field instruction
        }
        if (bHasInstructions)
            m_aRunText->append(
                msfilter::rtfutil::OutString(rFieldCmd, m_rExport.GetCurrentEncoding()));
        if (nMode & FieldFlags::CmdEnd)
        {
            m_aRunText->append("}}{" OOO_STRING_SVTOOLS_RTF_FLDRSLT " {");
        }
        if (nMode & FieldFlags::Close)
        {
            m_aRunText->append("}}}");
        }
    }
}
 
void RtfAttributeOutput::WriteBookmarks_Impl(std::vector<OUString>& rStarts,
                                             std::vector<OUString>& rEnds)
{
    for (const auto& rStart : rStarts)
    {
        m_aRunText->append("{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_BKMKSTART " ");
        m_aRunText->append(msfilter::rtfutil::OutString(rStart, m_rExport.GetCurrentEncoding()));
        m_aRunText->append('}');
    }
    rStarts.clear();
 
    for (const auto& rEnd : rEnds)
    {
        m_aRunText->append("{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_BKMKEND " ");
        m_aRunText->append(msfilter::rtfutil::OutString(rEnd, m_rExport.GetCurrentEncoding()));
        m_aRunText->append('}');
    }
    rEnds.clear();
}
 
void RtfAttributeOutput::WriteAnnotationMarks_Impl(std::vector<OUString>& rStarts,
                                                   std::vector<OUString>& rEnds)
{
    for (const auto& rStart : rStarts)
    {
        OString rName = OUStringToOString(rStart, RTL_TEXTENCODING_UTF8);
 
        // Output the annotation mark
        const sal_Int32 nId = m_nNextAnnotationMarkId++;
        m_rOpenedAnnotationMarksIds[rName] = nId;
        m_aRun->append("{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_ATRFSTART " ");
        m_aRun->append(nId);
        m_aRun->append('}');
    }
    rStarts.clear();
 
    for (const auto& rEnd : rEnds)
    {
        OString rName = OUStringToOString(rEnd, RTL_TEXTENCODING_UTF8);
 
        // Get the id of the annotation mark
        auto it = m_rOpenedAnnotationMarksIds.find(rName);
        if (it != m_rOpenedAnnotationMarksIds.end())
        {
            const sal_Int32 nId = it->second;
            m_aRun->append("{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_ATRFEND " ");
            m_aRun->append(nId);
            m_aRun->append('}');
            m_rOpenedAnnotationMarksIds.erase(rName);
 
            if (m_aPostitFields.find(nId) != m_aPostitFields.end())
            {
                m_aRunText->append("{");
                m_nCurrentAnnotationMarkId = nId;
                PostitField(m_aPostitFields[nId]);
                m_nCurrentAnnotationMarkId = -1;
                m_aRunText->append("}");
            }
        }
    }
    rEnds.clear();
}
 
void RtfAttributeOutput::WriteHeaderFooter_Impl(const SwFrameFormat& rFormat, bool bHeader,
                                                const char* pStr, bool bTitlepg)
{
    OStringBuffer aSectionBreaks = m_aSectionBreaks;
    m_aSectionBreaks.setLength(0);
    RtfStringBuffer aRun = m_aRun;
    m_aRun.clear();
 
    m_aSectionHeaders.append(bHeader ? OOO_STRING_SVTOOLS_RTF_HEADERY
                                     : OOO_STRING_SVTOOLS_RTF_FOOTERY);
    m_aSectionHeaders.append(
        static_cast<sal_Int32>(m_rExport.m_pCurrentPageDesc->GetMaster().GetULSpace().GetUpper()));
    if (bTitlepg)
        m_aSectionHeaders.append(OOO_STRING_SVTOOLS_RTF_TITLEPG);
    m_aSectionHeaders.append('{');
    m_aSectionHeaders.append(pStr);
    m_bBufferSectionHeaders = true;
    m_rExport.WriteHeaderFooterText(rFormat, bHeader);
    m_bBufferSectionHeaders = false;
    m_aSectionHeaders.append('}');
 
    m_aSectionBreaks = aSectionBreaks;
    m_aRun = aRun;
}
 
namespace
{
void lcl_TextFrameShadow(std::vector<std::pair<OString, OString>>& rFlyProperties,
                         const SwFrameFormat& rFrameFormat)
{
    const SvxShadowItem& aShadowItem = rFrameFormat.GetShadow();
    if (aShadowItem.GetLocation() == SvxShadowLocation::NONE)
        return;
 
    rFlyProperties.push_back(std::make_pair<OString, OString>("fShadow", OString::number(1)));
 
    const Color& rColor = aShadowItem.GetColor();
    // We in fact need RGB to BGR, but the transformation is symmetric.
    rFlyProperties.push_back(std::make_pair<OString, OString>(
        "shadowColor", OString::number(wwUtility::RGBToBGR(rColor))));
 
    // Twips -> points -> EMUs -- hacky, the intermediate step hides rounding errors on roundtrip.
    OString aShadowWidth = OString::number(sal_Int32(aShadowItem.GetWidth() / 20) * 12700);
    OString aOffsetX;
    OString aOffsetY;
    switch (aShadowItem.GetLocation())
    {
        case SvxShadowLocation::TopLeft:
            aOffsetX = "-" + aShadowWidth;
            aOffsetY = "-" + aShadowWidth;
            break;
        case SvxShadowLocation::TopRight:
            aOffsetX = aShadowWidth;
            aOffsetY = "-" + aShadowWidth;
            break;
        case SvxShadowLocation::BottomLeft:
            aOffsetX = "-" + aShadowWidth;
            aOffsetY = aShadowWidth;
            break;
        case SvxShadowLocation::BottomRight:
            aOffsetX = aShadowWidth;
            aOffsetY = aShadowWidth;
            break;
        case SvxShadowLocation::NONE:
        case SvxShadowLocation::End:
            break;
    }
    if (!aOffsetX.isEmpty())
        rFlyProperties.emplace_back("shadowOffsetX", aOffsetX);
    if (!aOffsetY.isEmpty())
        rFlyProperties.emplace_back("shadowOffsetY", aOffsetY);
}
 
void lcl_TextFrameRelativeSize(std::vector<std::pair<OString, OString>>& rFlyProperties,
                               const SwFrameFormat& rFrameFormat)
{
    const SwFormatFrameSize& rSize = rFrameFormat.GetFrameSize();
 
    // Relative size of the Text Frame.
    const sal_uInt8 nWidthPercent = rSize.GetWidthPercent();
    if (nWidthPercent && nWidthPercent != SwFormatFrameSize::SYNCED)
    {
        rFlyProperties.push_back(
            std::make_pair<OString, OString>("pctHoriz", OString::number(nWidthPercent * 10)));
 
        OString aRelation;
        switch (rSize.GetWidthPercentRelation())
        {
            case text::RelOrientation::PAGE_FRAME:
                aRelation = "1"; // page
                break;
            default:
                aRelation = "0"; // margin
                break;
        }
        rFlyProperties.emplace_back(std::make_pair("sizerelh", aRelation));
    }
    const sal_uInt8 nHeightPercent = rSize.GetHeightPercent();
    if (!(nHeightPercent && nHeightPercent != SwFormatFrameSize::SYNCED))
        return;
 
    rFlyProperties.push_back(
        std::make_pair<OString, OString>("pctVert", OString::number(nHeightPercent * 10)));
 
    OString aRelation;
    switch (rSize.GetHeightPercentRelation())
    {
        case text::RelOrientation::PAGE_FRAME:
            aRelation = "1"; // page
            break;
        default:
            aRelation = "0"; // margin
            break;
    }
    rFlyProperties.emplace_back(std::make_pair("sizerelv", aRelation));
}
}
 
void RtfAttributeOutput::writeTextFrame(const ww8::Frame& rFrame, bool bTextBox)
{
    RtfStringBuffer aRunText;
    if (bTextBox)
    {
        m_rExport.setStream();
        aRunText = m_aRunText;
        m_aRunText.clear();
    }
 
    m_rExport.Strm().WriteOString("{" OOO_STRING_SVTOOLS_RTF_SHPTXT);
 
    {
        // Save table state, in case the inner text also contains a table.
        ww8::WW8TableInfo::Pointer_t pTableInfoOrig = m_rExport.m_pTableInfo;
        m_rExport.m_pTableInfo = std::make_shared<ww8::WW8TableInfo>();
        std::unique_ptr<SwWriteTable> pTableWrt(std::move(m_pTableWrt));
        sal_uInt32 nTableDepth = m_nTableDepth;
 
        m_nTableDepth = 0;
        /*
         * Save m_aRun as we should not lose the opening brace.
         * OTOH, just drop the contents of m_aRunText in case something
         * would be there, causing a problem later.
         */
        OString aSave = m_aRun.makeStringAndClear();
        // Also back m_bInRun and m_bSingleEmptyRun up.
        bool bInRunOrig = m_bInRun;
        m_bInRun = false;
        bool bSingleEmptyRunOrig = m_bSingleEmptyRun;
        m_bSingleEmptyRun = false;
        m_rExport.SetRTFFlySyntax(true);
 
        const SwFrameFormat& rFrameFormat = rFrame.GetFrameFormat();
        const SwNodeIndex* pNodeIndex = rFrameFormat.GetContent().GetContentIdx();
        SwNodeOffset nStt = pNodeIndex ? pNodeIndex->GetIndex() + 1 : SwNodeOffset(0);
        SwNodeOffset nEnd
            = pNodeIndex ? pNodeIndex->GetNode().EndOfSectionIndex() : SwNodeOffset(0);
        m_rExport.SaveData(nStt, nEnd);
        m_rExport.m_pParentFrame = &rFrame;
        m_rExport.WriteText();
        m_rExport.RestoreData();
 
        m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_PARD);
        m_rExport.SetRTFFlySyntax(false);
        m_aRun->append(aSave);
        m_aRunText.clear();
        m_bInRun = bInRunOrig;
        m_bSingleEmptyRun = bSingleEmptyRunOrig;
 
        // Restore table state.
        m_rExport.m_pTableInfo = pTableInfoOrig;
        m_pTableWrt = std::move(pTableWrt);
        m_nTableDepth = nTableDepth;
    }
 
    m_rExport.m_pParentFrame = nullptr;
 
    m_rExport.Strm().WriteChar('}'); // shptxt
 
    if (bTextBox)
    {
        m_aRunText = aRunText;
        m_aRunText->append(m_rExport.getStream());
        m_rExport.resetStream();
    }
}
 
class SaveRunState
{
private:
    RtfAttributeOutput& m_rRtf;
    RtfStringBuffer m_Run;
    RtfStringBuffer m_RunText;
    bool const m_bSingleEmptyRun;
    bool const m_bInRun;
 
public:
    explicit SaveRunState(RtfAttributeOutput& rRtf)
        : m_rRtf(rRtf)
        , m_Run(std::move(rRtf.m_aRun))
        , m_RunText(std::move(rRtf.m_aRunText))
        , m_bSingleEmptyRun(rRtf.m_bSingleEmptyRun)
        , m_bInRun(rRtf.m_bInRun)
    {
        m_rRtf.m_rExport.setStream();
    }
    ~SaveRunState()
    {
        m_rRtf.m_aRun = std::move(m_Run);
        m_rRtf.m_aRunText = std::move(m_RunText);
        m_rRtf.m_bSingleEmptyRun = m_bSingleEmptyRun;
        m_rRtf.m_bInRun = m_bInRun;
 
        m_rRtf.m_aRunText->append(m_rRtf.m_rExport.getStream());
        m_rRtf.m_rExport.resetStream();
    }
};
 
void RtfAttributeOutput::OutputFlyFrame_Impl(const ww8::Frame& rFrame, const Point& /*rNdTopLeft*/)
{
    const SwFrameFormat& rFrameFormat = rFrame.GetFrameFormat();
    if (rFrameFormat.GetFlySplit().GetValue())
    {
        // The frame can split: this was originally from a floating table, write it back as
        // such.
        SaveRunState aState(*this);
        const SwNodeIndex* pNodeIndex = rFrameFormat.GetContent().GetContentIdx();
        SwNodeOffset nStt = pNodeIndex ? pNodeIndex->GetIndex() + 1 : SwNodeOffset(0);
        SwNodeOffset nEnd
            = pNodeIndex ? pNodeIndex->GetNode().EndOfSectionIndex() : SwNodeOffset(0);
        m_rExport.SaveData(nStt, nEnd);
        GetExport().WriteText();
        m_rExport.RestoreData();
        return;
    }
 
    const SwNode* pNode = rFrame.GetContent();
    const SwGrfNode* pGrfNode = pNode ? pNode->GetGrfNode() : nullptr;
 
    switch (rFrame.GetWriterType())
    {
        case ww8::Frame::eTextBox:
        {
            // If this is a TextBox of a shape, then ignore: it's handled in RtfSdrExport::StartShape().
            if (RtfSdrExport::isTextBox(rFrame.GetFrameFormat()))
                break;
 
            SaveRunState const saved(*this);
 
            m_rExport.m_pParentFrame = &rFrame;
 
            m_rExport.Strm().WriteOString("{" OOO_STRING_SVTOOLS_RTF_SHP);
            m_rExport.Strm().WriteOString(
                "{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_SHPINST);
 
            // Shape properties.
            m_aFlyProperties.push_back(std::make_pair<OString, OString>(
                "shapeType", OString::number(ESCHER_ShpInst_TextBox)));
 
            // When a frame has some low height, but automatically expanded due
            // to lots of contents, this size contains the real size.
            const Size aSize = rFrame.GetSize();
            m_pFlyFrameSize = &aSize;
 
            m_rExport.m_bOutFlyFrameAttrs = true;
            m_rExport.SetRTFFlySyntax(true);
            m_rExport.OutputFormat(rFrame.GetFrameFormat(), false, false, true);
 
            // Write ZOrder.
            if (const SdrObject* pObject = rFrame.GetFrameFormat().FindRealSdrObject())
            {
                m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_SHPZ);
                m_rExport.Strm().WriteNumberAsString(pObject->GetOrdNum());
            }
 
            m_rExport.Strm().WriteOString(m_aRunText.makeStringAndClear());
            m_rExport.Strm().WriteOString(m_aStyles);
            m_aStyles.setLength(0);
            m_rExport.m_bOutFlyFrameAttrs = false;
            m_rExport.SetRTFFlySyntax(false);
            m_pFlyFrameSize = nullptr;
 
            lcl_TextFrameShadow(m_aFlyProperties, rFrameFormat);
            lcl_TextFrameRelativeSize(m_aFlyProperties, rFrameFormat);
 
            for (const std::pair<OString, OString>& rPair : m_aFlyProperties)
            {
                m_rExport.Strm().WriteOString("{" OOO_STRING_SVTOOLS_RTF_SP "{");
                m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_SN " ");
                m_rExport.Strm().WriteOString(rPair.first);
                m_rExport.Strm().WriteOString("}{" OOO_STRING_SVTOOLS_RTF_SV " ");
                m_rExport.Strm().WriteOString(rPair.second);
                m_rExport.Strm().WriteOString("}}");
            }
            m_aFlyProperties.clear();
 
            writeTextFrame(rFrame);
 
            m_rExport.Strm().WriteChar('}'); // shpinst
            m_rExport.Strm().WriteChar('}'); // shp
 
            m_rExport.Strm().WriteOString(SAL_NEWLINE_STRING);
        }
        break;
        case ww8::Frame::eGraphic:
            if (pGrfNode)
            {
                m_aRunText.append(dynamic_cast<const SwFlyFrameFormat*>(&rFrame.GetFrameFormat()),
                                  pGrfNode);
            }
            else if (!rFrame.IsInline())
            {
                m_rExport.m_pParentFrame = &rFrame;
                m_rExport.SetRTFFlySyntax(true);
                m_rExport.OutputFormat(rFrame.GetFrameFormat(), false, false, true);
                m_rExport.SetRTFFlySyntax(false);
                m_aRunText->append("{" OOO_STRING_SVTOOLS_RTF_IGNORE);
                m_rExport.OutputFormat(rFrame.GetFrameFormat(), false, false, true);
                m_aRunText->append('}');
                m_rExport.m_pParentFrame = nullptr;
            }
            break;
        case ww8::Frame::eDrawing:
        {
            const SdrObject* pSdrObj = rFrame.GetFrameFormat().FindRealSdrObject();
            if (pSdrObj)
            {
                m_aRunText->append("{" OOO_STRING_SVTOOLS_RTF_FIELD "{");
                m_aRunText->append(OOO_STRING_SVTOOLS_RTF_IGNORE);
                m_aRunText->append(OOO_STRING_SVTOOLS_RTF_FLDINST);
                m_aRunText->append(" SHAPE ");
                m_aRunText->append("}"
                                   "{" OOO_STRING_SVTOOLS_RTF_FLDRSLT);
 
                m_rExport.SdrExporter().AddSdrObject(*pSdrObj);
 
                m_aRunText->append('}');
                m_aRunText->append('}');
            }
        }
        break;
        case ww8::Frame::eFormControl:
        {
            const SdrObject* pObject = rFrameFormat.FindRealSdrObject();
 
            m_aRun->append("{" OOO_STRING_SVTOOLS_RTF_FIELD);
            m_aRun->append("{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_FLDINST);
 
            if (pObject && pObject->GetObjInventor() == SdrInventor::FmForm)
            {
                if (auto pFormObj = dynamic_cast<const SdrUnoObj*>(pObject))
                {
                    const uno::Reference<awt::XControlModel>& xControlModel
                        = pFormObj->GetUnoControlModel();
                    uno::Reference<lang::XServiceInfo> xInfo(xControlModel, uno::UNO_QUERY);
                    if (xInfo.is())
                    {
                        uno::Reference<beans::XPropertySet> xPropSet(xControlModel, uno::UNO_QUERY);
                        uno::Reference<beans::XPropertySetInfo> xPropSetInfo
                            = xPropSet->getPropertySetInfo();
                        OUString sName;
                        if (xInfo->supportsService("com.sun.star.form.component.CheckBox"))
                        {
                            m_aRun->append(OUStringToOString(FieldString(ww::eFORMCHECKBOX),
                                                             m_rExport.GetCurrentEncoding()));
                            m_aRun->append(
                                "{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_FORMFIELD
                                "{");
                            m_aRun->append(OOO_STRING_SVTOOLS_RTF_FFTYPE "1"); // 1 = checkbox
                            // checkbox size in half points, this seems to be always 20
                            m_aRun->append(OOO_STRING_SVTOOLS_RTF_FFHPS "20");
 
                            OUString aStr;
                            sName = "Name";
                            if (xPropSetInfo->hasPropertyByName(sName))
                            {
                                xPropSet->getPropertyValue(sName) >>= aStr;
                                m_aRun->append(
                                    "{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_FFNAME
                                    " ");
                                m_aRun->append(
                                    OUStringToOString(aStr, m_rExport.GetCurrentEncoding()));
                                m_aRun->append('}');
                            }
 
                            sName = "HelpText";
                            if (xPropSetInfo->hasPropertyByName(sName))
                            {
                                xPropSet->getPropertyValue(sName) >>= aStr;
                                m_aRun->append(OOO_STRING_SVTOOLS_RTF_FFOWNHELP);
                                m_aRun->append("{" OOO_STRING_SVTOOLS_RTF_IGNORE
                                                   OOO_STRING_SVTOOLS_RTF_FFHELPTEXT " ");
                                m_aRun->append(
                                    OUStringToOString(aStr, m_rExport.GetCurrentEncoding()));
                                m_aRun->append('}');
                            }
 
                            sName = "HelpF1Text";
                            if (xPropSetInfo->hasPropertyByName(sName))
                            {
                                xPropSet->getPropertyValue(sName) >>= aStr;
                                m_aRun->append(OOO_STRING_SVTOOLS_RTF_FFOWNSTAT);
                                m_aRun->append("{" OOO_STRING_SVTOOLS_RTF_IGNORE
                                                   OOO_STRING_SVTOOLS_RTF_FFSTATTEXT " ");
                                m_aRun->append(
                                    OUStringToOString(aStr, m_rExport.GetCurrentEncoding()));
                                m_aRun->append('}');
                            }
 
                            sal_Int16 nTemp = 0;
                            xPropSet->getPropertyValue("DefaultState") >>= nTemp;
                            m_aRun->append(OOO_STRING_SVTOOLS_RTF_FFDEFRES);
                            m_aRun->append(static_cast<sal_Int32>(nTemp));
                            xPropSet->getPropertyValue("State") >>= nTemp;
                            m_aRun->append(OOO_STRING_SVTOOLS_RTF_FFRES);
                            m_aRun->append(static_cast<sal_Int32>(nTemp));
 
                            m_aRun->append("}}");
 
                            // field result is empty, ffres already contains the form result
                            m_aRun->append("}{" OOO_STRING_SVTOOLS_RTF_FLDRSLT " ");
                        }
                        else if (xInfo->supportsService("com.sun.star.form.component.TextField"))
                        {
                            OStringBuffer aBuf;
                            OString aStr;
                            OUString aTmp;
                            const char* pStr;
 
                            m_aRun->append(OUStringToOString(FieldString(ww::eFORMTEXT),
                                                             m_rExport.GetCurrentEncoding()));
                            m_aRun->append(
                                "{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_DATAFIELD
                                " ");
                            for (int i = 0; i < 8; i++)
                                aBuf.append(char(0x00));
                            xPropSet->getPropertyValue("Name") >>= aTmp;
                            aStr = OUStringToOString(aTmp, m_rExport.GetCurrentEncoding());
                            aBuf.append(OStringChar(static_cast<char>(aStr.getLength())) + aStr
                                        + OStringChar(char(0x00)));
                            xPropSet->getPropertyValue("DefaultText") >>= aTmp;
                            aStr = OUStringToOString(aTmp, m_rExport.GetCurrentEncoding());
                            aBuf.append(static_cast<char>(aStr.getLength()));
                            aBuf.append(aStr);
                            for (int i = 0; i < 11; i++)
                                aBuf.append(char(0x00));
                            aStr = aBuf.makeStringAndClear();
                            pStr = aStr.getStr();
                            for (int i = 0; i < aStr.getLength(); i++, pStr++)
                                m_aRun->append(msfilter::rtfutil::OutHex(*pStr, 2));
                            m_aRun->append('}');
                            m_aRun->append("}{" OOO_STRING_SVTOOLS_RTF_FLDRSLT " ");
                            xPropSet->getPropertyValue("Text") >>= aTmp;
                            m_aRun->append(OUStringToOString(aTmp, m_rExport.GetCurrentEncoding()));
                            m_aRun->append('}');
                            m_aRun->append(
                                "{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_FORMFIELD
                                "{");
                            sName = "HelpText";
                            if (xPropSetInfo->hasPropertyByName(sName))
                            {
                                xPropSet->getPropertyValue(sName) >>= aTmp;
                                m_aRun->append(OOO_STRING_SVTOOLS_RTF_FFOWNHELP);
                                m_aRun->append("{" OOO_STRING_SVTOOLS_RTF_IGNORE
                                                   OOO_STRING_SVTOOLS_RTF_FFHELPTEXT " ");
                                m_aRun->append(
                                    OUStringToOString(aTmp, m_rExport.GetCurrentEncoding()));
                                m_aRun->append('}');
                            }
 
                            sName = "HelpF1Text";
                            if (xPropSetInfo->hasPropertyByName(sName))
                            {
                                xPropSet->getPropertyValue(sName) >>= aTmp;
                                m_aRun->append(OOO_STRING_SVTOOLS_RTF_FFOWNSTAT);
                                m_aRun->append("{" OOO_STRING_SVTOOLS_RTF_IGNORE
                                                   OOO_STRING_SVTOOLS_RTF_FFSTATTEXT " ");
                                m_aRun->append(
                                    OUStringToOString(aTmp, m_rExport.GetCurrentEncoding()));
                                m_aRun->append('}');
                            }
                            m_aRun->append("}");
                        }
                        else if (xInfo->supportsService("com.sun.star.form.component.ListBox"))
                        {
                            OUString aStr;
                            uno::Sequence<sal_Int16> aIntSeq;
                            uno::Sequence<OUString> aStrSeq;
 
                            m_aRun->append(OUStringToOString(FieldString(ww::eFORMDROPDOWN),
                                                             m_rExport.GetCurrentEncoding()));
                            m_aRun->append(
                                "{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_FORMFIELD
                                "{");
                            m_aRun->append(OOO_STRING_SVTOOLS_RTF_FFTYPE "2"); // 2 = list
                            m_aRun->append(OOO_STRING_SVTOOLS_RTF_FFHASLISTBOX);
 
                            xPropSet->getPropertyValue("DefaultSelection") >>= aIntSeq;
                            if (aIntSeq.hasElements())
                            {
                                m_aRun->append(OOO_STRING_SVTOOLS_RTF_FFDEFRES);
                                // a dropdown list can have only one 'selected item by default'
                                m_aRun->append(static_cast<sal_Int32>(aIntSeq[0]));
                            }
 
                            xPropSet->getPropertyValue("SelectedItems") >>= aIntSeq;
                            if (aIntSeq.hasElements())
                            {
                                m_aRun->append(OOO_STRING_SVTOOLS_RTF_FFRES);
                                // a dropdown list can have only one 'currently selected item'
                                m_aRun->append(static_cast<sal_Int32>(aIntSeq[0]));
                            }
 
                            sName = "Name";
                            if (xPropSetInfo->hasPropertyByName(sName))
                            {
                                xPropSet->getPropertyValue(sName) >>= aStr;
                                m_aRun->append(
                                    "{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_FFNAME
                                    " ");
                                m_aRun->append(
                                    OUStringToOString(aStr, m_rExport.GetCurrentEncoding()));
                                m_aRun->append('}');
                            }
 
                            sName = "HelpText";
                            if (xPropSetInfo->hasPropertyByName(sName))
                            {
                                xPropSet->getPropertyValue(sName) >>= aStr;
                                m_aRun->append(OOO_STRING_SVTOOLS_RTF_FFOWNHELP);
                                m_aRun->append("{" OOO_STRING_SVTOOLS_RTF_IGNORE
                                                   OOO_STRING_SVTOOLS_RTF_FFHELPTEXT " ");
                                m_aRun->append(
                                    OUStringToOString(aStr, m_rExport.GetCurrentEncoding()));
                                m_aRun->append('}');
                            }
 
                            sName = "HelpF1Text";
                            if (xPropSetInfo->hasPropertyByName(sName))
                            {
                                xPropSet->getPropertyValue(sName) >>= aStr;
                                m_aRun->append(OOO_STRING_SVTOOLS_RTF_FFOWNSTAT);
                                m_aRun->append("{" OOO_STRING_SVTOOLS_RTF_IGNORE
                                                   OOO_STRING_SVTOOLS_RTF_FFSTATTEXT " ");
                                m_aRun->append(
                                    OUStringToOString(aStr, m_rExport.GetCurrentEncoding()));
                                m_aRun->append('}');
                            }
 
                            xPropSet->getPropertyValue("StringItemList") >>= aStrSeq;
                            for (const auto& rStr : std::as_const(aStrSeq))
                                m_aRun->append(
                                    "{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_FFL " "
                                    + OUStringToOString(rStr, m_rExport.GetCurrentEncoding())
                                    + "}");
 
                            m_aRun->append("}}");
 
                            // field result is empty, ffres already contains the form result
                            m_aRun->append("}{" OOO_STRING_SVTOOLS_RTF_FLDRSLT " ");
                        }
                        else
                            SAL_INFO("sw.rtf", __func__ << " unhandled form control: '"
                                                        << xInfo->getImplementationName() << "'");
                        m_aRun->append('}');
                    }
                }
            }
 
            m_aRun->append('}');
        }
        break;
        case ww8::Frame::eOle:
        {
            const SdrObject* pSdrObj = rFrameFormat.FindRealSdrObject();
            if (pSdrObj)
            {
                SwNodeIndex aIdx(*rFrameFormat.GetContent().GetContentIdx(), 1);
                SwOLENode& rOLENd = *aIdx.GetNode().GetOLENode();
                FlyFrameOLE(dynamic_cast<const SwFlyFrameFormat*>(&rFrameFormat), rOLENd,
                            rFrame.GetLayoutSize());
            }
        }
        break;
        default:
            SAL_INFO("sw.rtf", __func__ << ": unknown type ("
                                        << static_cast<int>(rFrame.GetWriterType()) << ")");
            break;
    }
}
 
void RtfAttributeOutput::CharCaseMap(const SvxCaseMapItem& rCaseMap)
{
    switch (rCaseMap.GetValue())
    {
        case SvxCaseMap::SmallCaps:
            m_aStyles.append(OOO_STRING_SVTOOLS_RTF_SCAPS);
            break;
        case SvxCaseMap::Uppercase:
            m_aStyles.append(OOO_STRING_SVTOOLS_RTF_CAPS);
            break;
        default: // Something that rtf does not support
            m_aStyles.append(OOO_STRING_SVTOOLS_RTF_SCAPS);
            m_aStyles.append(sal_Int32(0));
            m_aStyles.append(OOO_STRING_SVTOOLS_RTF_CAPS);
            m_aStyles.append(sal_Int32(0));
            break;
    }
}
 
void RtfAttributeOutput::CharColor(const SvxColorItem& rColor)
{
    const Color aColor(rColor.GetValue());
 
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_CF);
    m_aStyles.append(static_cast<sal_Int32>(m_rExport.GetColor(aColor)));
}
 
void RtfAttributeOutput::CharContour(const SvxContourItem& rContour)
{
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_OUTL);
    if (!rContour.GetValue())
        m_aStyles.append(sal_Int32(0));
}
 
void RtfAttributeOutput::CharCrossedOut(const SvxCrossedOutItem& rCrossedOut)
{
    switch (rCrossedOut.GetStrikeout())
    {
        case STRIKEOUT_NONE:
            m_aStyles.append(OOO_STRING_SVTOOLS_RTF_STRIKE);
            m_aStyles.append(sal_Int32(0));
            break;
        case STRIKEOUT_DOUBLE:
            m_aStyles.append(OOO_STRING_SVTOOLS_RTF_STRIKED);
            m_aStyles.append(sal_Int32(1));
            break;
        default:
            m_aStyles.append(OOO_STRING_SVTOOLS_RTF_STRIKE);
            break;
    }
}
 
void RtfAttributeOutput::CharEscapement(const SvxEscapementItem& rEscapement)
{
    short nEsc = rEscapement.GetEsc();
    short nProp = rEscapement.GetProportionalHeight();
    sal_Int32 nProp100 = nProp * 100;
    if (DFLT_ESC_PROP == nProp || nProp < 1 || nProp > 100)
    {
        if (DFLT_ESC_SUB == nEsc || DFLT_ESC_AUTO_SUB == nEsc)
            m_aStyles.append(OOO_STRING_SVTOOLS_RTF_SUB);
        else if (DFLT_ESC_SUPER == nEsc || DFLT_ESC_AUTO_SUPER == nEsc)
            m_aStyles.append(OOO_STRING_SVTOOLS_RTF_SUPER);
        return;
    }
    if (DFLT_ESC_AUTO_SUPER == nEsc)
    {
        nEsc = .8 * (100 - nProp);
        ++nProp100; // A 1 afterwards means 'automatic' according to editeng/rtf/rtfitem.cxx
    }
    else if (DFLT_ESC_AUTO_SUB == nEsc)
    {
        nEsc = .2 * -(100 - nProp);
        ++nProp100;
    }
 
    const char* pUpDn;
 
    double fHeight = m_rExport.GetItem(RES_CHRATR_FONTSIZE).GetHeight();
 
    if (0 < nEsc)
        pUpDn = OOO_STRING_SVTOOLS_RTF_UP;
    else if (0 > nEsc)
    {
        pUpDn = OOO_STRING_SVTOOLS_RTF_DN;
        fHeight = -fHeight;
    }
    else
        return;
 
    m_aStyles.append('{');
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_IGNORE);
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_UPDNPROP);
    m_aStyles.append(nProp100);
    m_aStyles.append('}');
    m_aStyles.append(pUpDn);
 
    /*
     * Calculate the act. FontSize and the percentage of the displacement;
     * RTF file expects half points, while internally it's in twips.
     * Formally :            (FontSize * 1/20 ) pts         x * 2
     *                    -----------------------  = ------------
     *                      100%                       Escapement
     */
    m_aStyles.append(static_cast<sal_Int32>(round(fHeight * nEsc / 1000)));
}
 
void RtfAttributeOutput::CharFont(const SvxFontItem& rFont)
{
    // Insert \loch in MoveCharacterProperties
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_F);
    m_aStyles.append(static_cast<sal_Int32>(m_rExport.m_aFontHelper.GetId(rFont)));
 
    // Insert \hich in MoveCharacterProperties
    m_aStylesAssocHich.append(OOO_STRING_SVTOOLS_RTF_AF);
    m_aStylesAssocHich.append(static_cast<sal_Int32>(m_rExport.m_aFontHelper.GetId(rFont)));
 
    // FIXME: this may be a tad expensive... but the charset needs to be
    // consistent with what wwFont::WriteRtf() does
    sw::util::FontMapExport aTmp(rFont.GetFamilyName());
    sal_uInt8 nWindowsCharset = sw::ms::rtl_TextEncodingToWinCharsetRTF(
        aTmp.msPrimary, aTmp.msSecondary, rFont.GetCharSet());
    m_rExport.SetCurrentEncoding(rtl_getTextEncodingFromWindowsCharset(nWindowsCharset));
    if (m_rExport.GetCurrentEncoding() == RTL_TEXTENCODING_DONTKNOW)
        m_rExport.SetCurrentEncoding(m_rExport.GetDefaultEncoding());
}
 
void RtfAttributeOutput::CharFontSize(const SvxFontHeightItem& rFontSize)
{
    switch (rFontSize.Which())
    {
        case RES_CHRATR_FONTSIZE:
            m_aStyles.append(OOO_STRING_SVTOOLS_RTF_FS);
            m_aStyles.append(static_cast<sal_Int32>(rFontSize.GetHeight() / 10));
            break;
        case RES_CHRATR_CJK_FONTSIZE:
            m_aStylesAssocDbch.append(OOO_STRING_SVTOOLS_RTF_AFS);
            m_aStylesAssocDbch.append(static_cast<sal_Int32>(rFontSize.GetHeight() / 10));
            break;
        case RES_CHRATR_CTL_FONTSIZE:
            m_aStylesAssocRtlch.append(OOO_STRING_SVTOOLS_RTF_AFS);
            m_aStylesAssocRtlch.append(static_cast<sal_Int32>(rFontSize.GetHeight() / 10));
            break;
    }
}
 
void RtfAttributeOutput::CharKerning(const SvxKerningItem& rKerning)
{
    // in quarter points then in twips
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_EXPND);
    m_aStyles.append(static_cast<sal_Int32>(rKerning.GetValue() / 5));
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_EXPNDTW);
    m_aStyles.append(static_cast<sal_Int32>(rKerning.GetValue()));
}
 
void RtfAttributeOutput::CharLanguage(const SvxLanguageItem& rLanguage)
{
    switch (rLanguage.Which())
    {
        case RES_CHRATR_LANGUAGE:
            m_aStyles.append(OOO_STRING_SVTOOLS_RTF_LANG);
            m_aStyles.append(
                static_cast<sal_Int32>(static_cast<sal_uInt16>(rLanguage.GetLanguage())));
            m_aStylesAssocLtrch.append(OOO_STRING_SVTOOLS_RTF_LANG);
            m_aStylesAssocLtrch.append(
                static_cast<sal_Int32>(static_cast<sal_uInt16>(rLanguage.GetLanguage())));
            break;
        case RES_CHRATR_CJK_LANGUAGE:
            m_aStylesAssocDbch.append(OOO_STRING_SVTOOLS_RTF_LANGFE);
            m_aStylesAssocDbch.append(
                static_cast<sal_Int32>(static_cast<sal_uInt16>(rLanguage.GetLanguage())));
            m_aStylesAssocLtrch.append(OOO_STRING_SVTOOLS_RTF_LANGFE);
            m_aStylesAssocLtrch.append(
                static_cast<sal_Int32>(static_cast<sal_uInt16>(rLanguage.GetLanguage())));
            break;
        case RES_CHRATR_CTL_LANGUAGE:
            m_aStylesAssocRtlch.append(OOO_STRING_SVTOOLS_RTF_ALANG);
            m_aStylesAssocRtlch.append(
                static_cast<sal_Int32>(static_cast<sal_uInt16>(rLanguage.GetLanguage())));
            break;
    }
}
 
void RtfAttributeOutput::CharPosture(const SvxPostureItem& rPosture)
{
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_I);
    if (rPosture.GetPosture() == ITALIC_NONE)
        m_aStyles.append(sal_Int32(0));
}
 
void RtfAttributeOutput::CharShadow(const SvxShadowedItem& rShadow)
{
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_SHAD);
    if (!rShadow.GetValue())
        m_aStyles.append(sal_Int32(0));
}
 
void RtfAttributeOutput::CharUnderline(const SvxUnderlineItem& rUnderline)
{
    const char* pStr = nullptr;
    const SfxPoolItem* pItem = m_rExport.HasItem(RES_CHRATR_WORDLINEMODE);
    bool bWord = false;
    // No StaticWhichCast(RES_CHRATR_WORDLINEMODE), this may be for a postit, where the which ids
    // don't match.
    if (pItem)
        bWord = static_cast<const SvxWordLineModeItem*>(pItem)->GetValue();
    switch (rUnderline.GetLineStyle())
    {
        case LINESTYLE_SINGLE:
            pStr = bWord ? OOO_STRING_SVTOOLS_RTF_ULW : OOO_STRING_SVTOOLS_RTF_UL;
            break;
        case LINESTYLE_DOUBLE:
            pStr = OOO_STRING_SVTOOLS_RTF_ULDB;
            break;
        case LINESTYLE_NONE:
            pStr = OOO_STRING_SVTOOLS_RTF_ULNONE;
            break;
        case LINESTYLE_DOTTED:
            pStr = OOO_STRING_SVTOOLS_RTF_ULD;
            break;
        case LINESTYLE_DASH:
            pStr = OOO_STRING_SVTOOLS_RTF_ULDASH;
            break;
        case LINESTYLE_DASHDOT:
            pStr = OOO_STRING_SVTOOLS_RTF_ULDASHD;
            break;
        case LINESTYLE_DASHDOTDOT:
            pStr = OOO_STRING_SVTOOLS_RTF_ULDASHDD;
            break;
        case LINESTYLE_BOLD:
            pStr = OOO_STRING_SVTOOLS_RTF_ULTH;
            break;
        case LINESTYLE_WAVE:
            pStr = OOO_STRING_SVTOOLS_RTF_ULWAVE;
            break;
        case LINESTYLE_BOLDDOTTED:
            pStr = OOO_STRING_SVTOOLS_RTF_ULTHD;
            break;
        case LINESTYLE_BOLDDASH:
            pStr = OOO_STRING_SVTOOLS_RTF_ULTHDASH;
            break;
        case LINESTYLE_LONGDASH:
            pStr = OOO_STRING_SVTOOLS_RTF_ULLDASH;
            break;
        case LINESTYLE_BOLDLONGDASH:
            pStr = OOO_STRING_SVTOOLS_RTF_ULTHLDASH;
            break;
        case LINESTYLE_BOLDDASHDOT:
            pStr = OOO_STRING_SVTOOLS_RTF_ULTHDASHD;
            break;
        case LINESTYLE_BOLDDASHDOTDOT:
            pStr = OOO_STRING_SVTOOLS_RTF_ULTHDASHDD;
            break;
        case LINESTYLE_BOLDWAVE:
            pStr = OOO_STRING_SVTOOLS_RTF_ULHWAVE;
            break;
        case LINESTYLE_DOUBLEWAVE:
            pStr = OOO_STRING_SVTOOLS_RTF_ULULDBWAVE;
            break;
        default:
            break;
    }
 
    if (pStr)
    {
        m_aStyles.append(pStr);
        // NEEDSWORK looks like here rUnderline.GetColor() is always black,
        // even if the color in the odt is for example green...
        m_aStyles.append(OOO_STRING_SVTOOLS_RTF_ULC);
        m_aStyles.append(static_cast<sal_Int32>(m_rExport.GetColor(rUnderline.GetColor())));
    }
}
 
void RtfAttributeOutput::CharWeight(const SvxWeightItem& rWeight)
{
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_B);
    if (rWeight.GetWeight() != WEIGHT_BOLD)
        m_aStyles.append(sal_Int32(0));
}
 
void RtfAttributeOutput::CharAutoKern(const SvxAutoKernItem& rAutoKern)
{
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_KERNING);
    m_aStyles.append(static_cast<sal_Int32>(rAutoKern.GetValue() ? 1 : 0));
}
 
void RtfAttributeOutput::CharAnimatedText(const SvxBlinkItem& rBlink)
{
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_ANIMTEXT);
    m_aStyles.append(static_cast<sal_Int32>(rBlink.GetValue() ? 2 : 0));
}
 
void RtfAttributeOutput::CharBackground(const SvxBrushItem& rBrush)
{
    if (!rBrush.GetColor().IsTransparent())
    {
        m_aStyles.append(OOO_STRING_SVTOOLS_RTF_CHCBPAT);
        m_aStyles.append(static_cast<sal_Int32>(m_rExport.GetColor(rBrush.GetColor())));
    }
}
 
void RtfAttributeOutput::CharFontCJK(const SvxFontItem& rFont)
{
    // Insert \dbch in MoveCharacterProperties
    m_aStylesAssocDbch.append(OOO_STRING_SVTOOLS_RTF_AF);
    m_aStylesAssocDbch.append(static_cast<sal_Int32>(m_rExport.m_aFontHelper.GetId(rFont)));
}
 
void RtfAttributeOutput::CharFontSizeCJK(const SvxFontHeightItem& rFontSize)
{
    CharFontSize(rFontSize);
}
 
void RtfAttributeOutput::CharLanguageCJK(const SvxLanguageItem& rLanguageItem)
{
    CharLanguage(rLanguageItem);
}
 
void RtfAttributeOutput::CharPostureCJK(const SvxPostureItem& rPosture)
{
    m_aStylesAssocDbch.append(OOO_STRING_SVTOOLS_RTF_I);
    if (rPosture.GetPosture() == ITALIC_NONE)
        m_aStylesAssocDbch.append(sal_Int32(0));
}
 
void RtfAttributeOutput::CharWeightCJK(const SvxWeightItem& rWeight)
{
    m_aStylesAssocDbch.append(OOO_STRING_SVTOOLS_RTF_AB);
    if (rWeight.GetWeight() != WEIGHT_BOLD)
        m_aStylesAssocDbch.append(sal_Int32(0));
}
 
void RtfAttributeOutput::CharFontCTL(const SvxFontItem& rFont)
{
    // Insert \rtlch in MoveCharacterProperties
    m_aStylesAssocRtlch.append(OOO_STRING_SVTOOLS_RTF_AF);
    m_aStylesAssocRtlch.append(static_cast<sal_Int32>(m_rExport.m_aFontHelper.GetId(rFont)));
}
 
void RtfAttributeOutput::CharFontSizeCTL(const SvxFontHeightItem& rFontSize)
{
    CharFontSize(rFontSize);
}
 
void RtfAttributeOutput::CharLanguageCTL(const SvxLanguageItem& rLanguageItem)
{
    CharLanguage(rLanguageItem);
}
 
void RtfAttributeOutput::CharPostureCTL(const SvxPostureItem& rPosture)
{
    m_aStylesAssocRtlch.append(OOO_STRING_SVTOOLS_RTF_AI);
    if (rPosture.GetPosture() == ITALIC_NONE)
        m_aStylesAssocRtlch.append(sal_Int32(0));
}
 
void RtfAttributeOutput::CharWeightCTL(const SvxWeightItem& rWeight)
{
    m_aStylesAssocRtlch.append(OOO_STRING_SVTOOLS_RTF_AB);
    if (rWeight.GetWeight() != WEIGHT_BOLD)
        m_aStylesAssocRtlch.append(sal_Int32(0));
}
 
void RtfAttributeOutput::CharBidiRTL(const SfxPoolItem& /*rItem*/) {}
 
void RtfAttributeOutput::CharIdctHint(const SfxPoolItem& /*rItem*/) {}
 
void RtfAttributeOutput::CharRotate(const SvxCharRotateItem& rRotate)
{
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_HORZVERT);
    m_aStyles.append(static_cast<sal_Int32>(rRotate.IsFitToLine() ? 1 : 0));
}
 
void RtfAttributeOutput::CharEmphasisMark(const SvxEmphasisMarkItem& rEmphasisMark)
{
    FontEmphasisMark v = rEmphasisMark.GetEmphasisMark();
    if (v == FontEmphasisMark::NONE)
        m_aStyles.append(OOO_STRING_SVTOOLS_RTF_ACCNONE);
    else if (v == (FontEmphasisMark::Dot | FontEmphasisMark::PosAbove))
        m_aStyles.append(OOO_STRING_SVTOOLS_RTF_ACCDOT);
    else if (v == (FontEmphasisMark::Accent | FontEmphasisMark::PosAbove))
        m_aStyles.append(OOO_STRING_SVTOOLS_RTF_ACCCOMMA);
    else if (v == (FontEmphasisMark::Circle | FontEmphasisMark::PosAbove))
        m_aStyles.append(OOO_STRING_SVTOOLS_RTF_ACCCIRCLE);
    else if (v == (FontEmphasisMark::Dot | FontEmphasisMark::PosBelow))
        m_aStyles.append(OOO_STRING_SVTOOLS_RTF_ACCUNDERDOT);
}
 
void RtfAttributeOutput::CharTwoLines(const SvxTwoLinesItem& rTwoLines)
{
    if (!rTwoLines.GetValue())
        return;
 
    sal_Unicode cStart = rTwoLines.GetStartBracket();
    sal_Unicode cEnd = rTwoLines.GetEndBracket();
 
    sal_uInt16 nType;
    if (!cStart && !cEnd)
        nType = 0;
    else if ('{' == cStart || '}' == cEnd)
        nType = 4;
    else if ('<' == cStart || '>' == cEnd)
        nType = 3;
    else if ('[' == cStart || ']' == cEnd)
        nType = 2;
    else // all other kind of brackets
        nType = 1;
 
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_TWOINONE);
    m_aStyles.append(static_cast<sal_Int32>(nType));
}
 
void RtfAttributeOutput::CharScaleWidth(const SvxCharScaleWidthItem& rScaleWidth)
{
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_CHARSCALEX);
    m_aStyles.append(static_cast<sal_Int32>(rScaleWidth.GetValue()));
}
 
void RtfAttributeOutput::CharRelief(const SvxCharReliefItem& rRelief)
{
    const char* pStr;
    switch (rRelief.GetValue())
    {
        case FontRelief::Embossed:
            pStr = OOO_STRING_SVTOOLS_RTF_EMBO;
            break;
        case FontRelief::Engraved:
            pStr = OOO_STRING_SVTOOLS_RTF_IMPR;
            break;
        default:
            pStr = nullptr;
            break;
    }
 
    if (pStr)
        m_aStyles.append(pStr);
}
 
void RtfAttributeOutput::CharHidden(const SvxCharHiddenItem& rHidden)
{
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_V);
    if (!rHidden.GetValue())
        m_aStyles.append(sal_Int32(0));
}
 
void RtfAttributeOutput::CharBorder(const editeng::SvxBorderLine* pAllBorder,
                                    const sal_uInt16 nDist, const bool bShadow)
{
    m_aStyles.append(
        OutBorderLine(m_rExport, pAllBorder, OOO_STRING_SVTOOLS_RTF_CHBRDR, nDist,
                      bShadow ? SvxShadowLocation::BottomRight : SvxShadowLocation::NONE));
}
 
void RtfAttributeOutput::CharHighlight(const SvxBrushItem& rBrush)
{
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_HIGHLIGHT);
    m_aStyles.append(static_cast<sal_Int32>(msfilter::util::TransColToIco(rBrush.GetColor())));
}
 
void RtfAttributeOutput::TextINetFormat(const SwFormatINetFormat& rURL)
{
    if (rURL.GetValue().isEmpty())
        return;
 
    const SwCharFormat* pFormat;
    const SwTextINetFormat* pTextAtr = rURL.GetTextINetFormat();
 
    if (pTextAtr && nullptr != (pFormat = pTextAtr->GetCharFormat()))
    {
        sal_uInt16 nStyle = m_rExport.GetId(pFormat);
        OString* pString = m_rExport.GetStyle(nStyle);
        if (pString)
            m_aStyles.append(*pString);
    }
}
 
void RtfAttributeOutput::TextCharFormat(const SwFormatCharFormat& rCharFormat)
{
    sal_uInt16 nStyle = m_rExport.GetId(rCharFormat.GetCharFormat());
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_CS);
    m_aStyles.append(static_cast<sal_Int32>(nStyle));
    OString* pString = m_rExport.GetStyle(nStyle);
    if (pString)
        m_aStyles.append(*pString);
}
 
void RtfAttributeOutput::WriteTextFootnoteNumStr(const SwFormatFootnote& rFootnote)
{
    if (rFootnote.GetNumStr().isEmpty())
        m_aRun->append(OOO_STRING_SVTOOLS_RTF_CHFTN);
    else
        m_aRun->append(
            msfilter::rtfutil::OutString(rFootnote.GetNumStr(), m_rExport.GetCurrentEncoding()));
}
 
void RtfAttributeOutput::TextFootnote_Impl(const SwFormatFootnote& rFootnote)
{
    SAL_INFO("sw.rtf", __func__ << " start");
 
    m_aRun->append("{" OOO_STRING_SVTOOLS_RTF_SUPER " ");
    EndRunProperties(nullptr);
    m_aRun->append(' ');
    WriteTextFootnoteNumStr(rFootnote);
    m_aRun->append("{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_FOOTNOTE);
    if (rFootnote.IsEndNote() || m_rExport.m_rDoc.GetFootnoteInfo().m_ePos == FTNPOS_CHAPTER)
        m_aRun->append(OOO_STRING_SVTOOLS_RTF_FTNALT);
    m_aRun->append(' ');
    WriteTextFootnoteNumStr(rFootnote);
 
    /*
     * The footnote contains a whole paragraph, so we have to:
     * 1) Reset, then later restore the contents of our run buffer and run state.
     * 2) Buffer the output of the whole paragraph, as we do so for section headers already.
     */
    const SwNodeIndex* pIndex = rFootnote.GetTextFootnote()->GetStartNode();
    RtfStringBuffer aRun = m_aRun;
    m_aRun.clear();
    bool bInRunOrig = m_bInRun;
    m_bInRun = false;
    bool bSingleEmptyRunOrig = m_bSingleEmptyRun;
    m_bSingleEmptyRun = false;
    m_bBufferSectionHeaders = true;
    m_rExport.WriteSpecialText(pIndex->GetIndex() + 1, pIndex->GetNode().EndOfSectionIndex(),
                               !rFootnote.IsEndNote() ? TXT_FTN : TXT_EDN);
    m_bBufferSectionHeaders = false;
    m_bInRun = bInRunOrig;
    m_bSingleEmptyRun = bSingleEmptyRunOrig;
    m_aRun = aRun;
    m_aRun->append(m_aSectionHeaders);
    m_aSectionHeaders.setLength(0);
 
    m_aRun->append("}");
    m_aRun->append("}");
 
    SAL_INFO("sw.rtf", __func__ << " end");
}
 
void RtfAttributeOutput::ParaLineSpacing_Impl(short nSpace, short nMulti)
{
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_SL);
    m_aStyles.append(static_cast<sal_Int32>(nSpace));
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_SLMULT);
    m_aStyles.append(static_cast<sal_Int32>(nMulti));
}
 
void RtfAttributeOutput::ParaAdjust(const SvxAdjustItem& rAdjust)
{
    switch (rAdjust.GetAdjust())
    {
        case SvxAdjust::Left:
            m_aStyles.append(OOO_STRING_SVTOOLS_RTF_QL);
            break;
        case SvxAdjust::Right:
            m_aStyles.append(OOO_STRING_SVTOOLS_RTF_QR);
            break;
        case SvxAdjust::BlockLine:
        case SvxAdjust::Block:
            if (rAdjust.GetLastBlock() == SvxAdjust::Block)
                m_aStyles.append(OOO_STRING_SVTOOLS_RTF_QD);
            else
                m_aStyles.append(OOO_STRING_SVTOOLS_RTF_QJ);
            break;
        case SvxAdjust::Center:
            m_aStyles.append(OOO_STRING_SVTOOLS_RTF_QC);
            break;
        default:
            break;
    }
}
 
void RtfAttributeOutput::ParaSplit(const SvxFormatSplitItem& rSplit)
{
    if (!rSplit.GetValue())
        m_aStyles.append(OOO_STRING_SVTOOLS_RTF_KEEP);
}
 
void RtfAttributeOutput::ParaWidows(const SvxWidowsItem& rWidows)
{
    if (rWidows.GetValue())
        m_aStyles.append(OOO_STRING_SVTOOLS_RTF_WIDCTLPAR);
    else
        m_aStyles.append(OOO_STRING_SVTOOLS_RTF_NOWIDCTLPAR);
}
 
void RtfAttributeOutput::ParaTabStop(const SvxTabStopItem& rTabStop)
{
    tools::Long nOffset = m_rExport.GetParaTabStopOffset();
 
    for (sal_uInt16 n = 0; n < rTabStop.Count(); n++)
    {
        const SvxTabStop& rTS = rTabStop[n];
        if (SvxTabAdjust::Default != rTS.GetAdjustment())
        {
            const char* pFill = nullptr;
            switch (rTS.GetFill())
            {
                case cDfltFillChar:
                    break;
 
                case '.':
                    pFill = OOO_STRING_SVTOOLS_RTF_TLDOT;
                    break;
                case '_':
                    pFill = OOO_STRING_SVTOOLS_RTF_TLUL;
                    break;
                case '-':
                    pFill = OOO_STRING_SVTOOLS_RTF_TLTH;
                    break;
                case '=':
                    pFill = OOO_STRING_SVTOOLS_RTF_TLEQ;
                    break;
                default:
                    break;
            }
            if (pFill)
                m_aStyles.append(pFill);
 
            const char* pAdjStr = nullptr;
            switch (rTS.GetAdjustment())
            {
                case SvxTabAdjust::Right:
                    pAdjStr = OOO_STRING_SVTOOLS_RTF_TQR;
                    break;
                case SvxTabAdjust::Decimal:
                    pAdjStr = OOO_STRING_SVTOOLS_RTF_TQDEC;
                    break;
                case SvxTabAdjust::Center:
                    pAdjStr = OOO_STRING_SVTOOLS_RTF_TQC;
                    break;
                default:
                    break;
            }
            if (pAdjStr)
                m_aStyles.append(pAdjStr);
            m_aStyles.append(OOO_STRING_SVTOOLS_RTF_TX);
            m_aStyles.append(static_cast<sal_Int32>(rTS.GetTabPos() + nOffset));
        }
        else
        {
            m_aTabStop.append(OOO_STRING_SVTOOLS_RTF_DEFTAB);
            m_aTabStop.append(rTabStop[0].GetTabPos());
        }
    }
}
 
void RtfAttributeOutput::ParaHyphenZone(const SvxHyphenZoneItem& rHyphenZone)
{
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_HYPHPAR);
    m_aStyles.append(sal_Int32(rHyphenZone.IsHyphen()));
}
 
void RtfAttributeOutput::ParaNumRule_Impl(const SwTextNode* pTextNd, sal_Int32 nLvl,
                                          sal_Int32 nNumId)
{
    if (USHRT_MAX == nNumId || 0 == nNumId || nullptr == pTextNd)
        return;
 
    const SwNumRule* pRule = pTextNd->GetNumRule();
 
    if (!pRule || !pTextNd->IsInList())
        return;
 
    SAL_WARN_IF(pTextNd->GetActualListLevel() < 0 || pTextNd->GetActualListLevel() >= MAXLEVEL,
                "sw.rtf", "text node does not have valid list level");
 
    const SwNumFormat* pFormat = pRule->GetNumFormat(nLvl);
    if (!pFormat)
        pFormat = &pRule->Get(nLvl);
 
    const SfxItemSet& rNdSet = pTextNd->GetSwAttrSet();
 
    m_aStyles.append('{');
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_LISTTEXT);
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_PARD);
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_PLAIN);
    m_aStyles.append(' ');
 
    SvxFirstLineIndentItem firstLine(rNdSet.Get(RES_MARGIN_FIRSTLINE));
    SvxTextLeftMarginItem leftMargin(rNdSet.Get(RES_MARGIN_TEXTLEFT));
    leftMargin.SetTextLeft(leftMargin.GetTextLeft() + pFormat->GetIndentAt());
    firstLine.SetTextFirstLineOffset(pFormat->GetFirstLineOffset()); //TODO: overflow
 
    sal_uInt16 nStyle = m_rExport.GetId(pFormat->GetCharFormat());
    OString* pString = m_rExport.GetStyle(nStyle);
    if (pString)
        m_aStyles.append(*pString);
 
    {
        OUString sText;
        if (SVX_NUM_CHAR_SPECIAL == pFormat->GetNumberingType()
            || SVX_NUM_BITMAP == pFormat->GetNumberingType())
        {
            sal_UCS4 cBullet = pFormat->GetBulletChar();
            sText = OUString(&cBullet, 1);
        }
        else
            sText = pTextNd->GetNumString();
 
        if (!sText.isEmpty())
        {
            m_aStyles.append(' ');
            m_aStyles.append(msfilter::rtfutil::OutString(sText, m_rExport.GetDefaultEncoding()));
        }
 
        if (OUTLINE_RULE != pRule->GetRuleType())
        {
            if (!sText.isEmpty())
                m_aStyles.append(OOO_STRING_SVTOOLS_RTF_TAB);
            m_aStyles.append('}');
            m_aStyles.append(OOO_STRING_SVTOOLS_RTF_ILVL);
            if (nLvl > 8) // RTF knows only 9 levels
            {
                m_aStyles.append(sal_Int32(8));
                m_aStyles.append("{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_SOUTLVL);
                m_aStyles.append(nLvl);
                m_aStyles.append('}');
            }
            else
                m_aStyles.append(nLvl);
        }
        else
            m_aStyles.append(OOO_STRING_SVTOOLS_RTF_TAB "}");
        m_aStyles.append(OOO_STRING_SVTOOLS_RTF_LS);
        m_aStyles.append(static_cast<sal_Int32>(m_rExport.GetNumberingId(*pRule)) + 1);
        m_aStyles.append(' ');
    }
    FormatFirstLineIndent(firstLine);
    FormatTextLeftMargin(leftMargin);
}
 
void RtfAttributeOutput::ParaScriptSpace(const SfxBoolItem& rScriptSpace)
{
    if (!rScriptSpace.GetValue())
        return;
 
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_ASPALPHA);
}
 
void RtfAttributeOutput::ParaHangingPunctuation(const SfxBoolItem& /*rItem*/)
{
    SAL_INFO("sw.rtf", "TODO: " << __func__);
}
 
void RtfAttributeOutput::ParaForbiddenRules(const SfxBoolItem& /*rItem*/)
{
    SAL_INFO("sw.rtf", "TODO: " << __func__);
}
 
void RtfAttributeOutput::ParaVerticalAlign(const SvxParaVertAlignItem& rAlign)
{
    const char* pStr;
    switch (rAlign.GetValue())
    {
        case SvxParaVertAlignItem::Align::Top:
            pStr = OOO_STRING_SVTOOLS_RTF_FAHANG;
            break;
        case SvxParaVertAlignItem::Align::Bottom:
            pStr = OOO_STRING_SVTOOLS_RTF_FAVAR;
            break;
        case SvxParaVertAlignItem::Align::Center:
            pStr = OOO_STRING_SVTOOLS_RTF_FACENTER;
            break;
        case SvxParaVertAlignItem::Align::Baseline:
            pStr = OOO_STRING_SVTOOLS_RTF_FAROMAN;
            break;
 
        default:
            pStr = OOO_STRING_SVTOOLS_RTF_FAAUTO;
            break;
    }
    m_aStyles.append(pStr);
}
 
void RtfAttributeOutput::ParaSnapToGrid(const SvxParaGridItem& /*rGrid*/)
{
    SAL_INFO("sw.rtf", "TODO: " << __func__);
}
 
void RtfAttributeOutput::FormatFrameSize(const SwFormatFrameSize& rSize)
{
    if (m_rExport.m_bOutPageDescs)
    {
        m_aSectionBreaks.append(OOO_STRING_SVTOOLS_RTF_PGWSXN);
        m_aSectionBreaks.append(static_cast<sal_Int32>(rSize.GetWidth()));
        m_aSectionBreaks.append(OOO_STRING_SVTOOLS_RTF_PGHSXN);
        m_aSectionBreaks.append(static_cast<sal_Int32>(rSize.GetHeight()));
        if (!m_bBufferSectionBreaks)
        {
            m_rExport.Strm().WriteOString(m_aSectionBreaks);
            m_aSectionBreaks.setLength(0);
        }
    }
}
 
void RtfAttributeOutput::FormatPaperBin(const SvxPaperBinItem& /*rItem*/)
{
    SAL_INFO("sw.rtf", "TODO: " << __func__);
}
 
void RtfAttributeOutput::FormatFirstLineIndent(SvxFirstLineIndentItem const& rFirstLine)
{
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_FI);
    m_aStyles.append(static_cast<sal_Int32>(rFirstLine.GetTextFirstLineOffset()));
}
 
void RtfAttributeOutput::FormatTextLeftMargin(SvxTextLeftMarginItem const& rTextLeftMargin)
{
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_LI);
    m_aStyles.append(static_cast<sal_Int32>(rTextLeftMargin.GetTextLeft()));
    m_aStyles.append(OOO_STRING_SVTOOLS_RTF_LIN);
    m_aStyles.append(static_cast<sal_Int32>(rTextLeftMargin.GetTextLeft()));
}
 
void RtfAttributeOutput::FormatRightMargin(SvxRightMarginItem const& rRightMargin)
{
// (paragraph case, this will be an else branch once others are converted)
#if 0
    else
#endif
    {
        m_aStyles.append(OOO_STRING_SVTOOLS_RTF_RI);
        m_aStyles.append(static_cast<sal_Int32>(rRightMargin.GetRight()));
        m_aStyles.append(OOO_STRING_SVTOOLS_RTF_RIN);
        m_aStyles.append(static_cast<sal_Int32>(rRightMargin.GetRight()));
    }
}
 
void RtfAttributeOutput::FormatLRSpace(const SvxLRSpaceItem& rLRSpace)
{
    if (!m_rExport.m_bOutFlyFrameAttrs)
    {
        if (m_rExport.m_bOutPageDescs)
        {
            m_aPageMargins.nLeft = 0;
            m_aPageMargins.nRight = 0;
 
            if (const SvxBoxItem* pBoxItem = m_rExport.HasItem(RES_BOX))
            {
                m_aPageMargins.nLeft
                    = pBoxItem->CalcLineSpace(SvxBoxItemLine::LEFT, /*bEvenIfNoLine*/ true);
                m_aPageMargins.nRight
                    = pBoxItem->CalcLineSpace(SvxBoxItemLine::RIGHT, /*bEvenIfNoLine*/ true);
            }
 
            m_aPageMargins.nLeft += sal::static_int_cast<sal_uInt16>(rLRSpace.GetLeft());
            m_aPageMargins.nRight += sal::static_int_cast<sal_uInt16>(rLRSpace.GetRight());
 
            if (rLRSpace.GetLeft())
            {
                m_aSectionBreaks.append(OOO_STRING_SVTOOLS_RTF_MARGLSXN);
                m_aSectionBreaks.append(static_cast<sal_Int32>(m_aPageMargins.nLeft));
            }
            if (rLRSpace.GetRight())
            {
                m_aSectionBreaks.append(OOO_STRING_SVTOOLS_RTF_MARGRSXN);
                m_aSectionBreaks.append(static_cast<sal_Int32>(m_aPageMargins.nRight));
            }
            if (rLRSpace.GetGutterMargin())
            {
                m_aSectionBreaks.append(OOO_STRING_SVTOOLS_RTF_GUTTER);
                m_aSectionBreaks.append(static_cast<sal_Int32>(rLRSpace.GetGutterMargin()));
            }
            if (!m_bBufferSectionBreaks)
            {
                m_rExport.Strm().WriteOString(m_aSectionBreaks);
                m_aSectionBreaks.setLength(0);
            }
        }
        else
        {
            m_aStyles.append(OOO_STRING_SVTOOLS_RTF_LI);
            m_aStyles.append(static_cast<sal_Int32>(rLRSpace.GetTextLeft()));
            m_aStyles.append(OOO_STRING_SVTOOLS_RTF_RI);
            m_aStyles.append(static_cast<sal_Int32>(rLRSpace.GetRight()));
            m_aStyles.append(OOO_STRING_SVTOOLS_RTF_LIN);
            m_aStyles.append(static_cast<sal_Int32>(rLRSpace.GetTextLeft()));
            m_aStyles.append(OOO_STRING_SVTOOLS_RTF_RIN);
            m_aStyles.append(static_cast<sal_Int32>(rLRSpace.GetRight()));
            m_aStyles.append(OOO_STRING_SVTOOLS_RTF_FI);
            m_aStyles.append(static_cast<sal_Int32>(rLRSpace.GetTextFirstLineOffset()));
        }
    }
    else if (m_rExport.GetRTFFlySyntax())
    {
        // Wrap: top and bottom spacing, convert from twips to EMUs.
        m_aFlyProperties.push_back(std::make_pair<OString, OString>(
            "dxWrapDistLeft", OString::number(o3tl::convert(rLRSpace.GetLeft(), o3tl::Length::twip,
                                                            o3tl::Length::emu))));
        m_aFlyProperties.push_back(std::make_pair<OString, OString>(
            "dxWrapDistRight", OString::number(o3tl::convert(
                                   rLRSpace.GetRight(), o3tl::Length::twip, o3tl::Length::emu))));
    }
}
 
void RtfAttributeOutput::FormatULSpace(const SvxULSpaceItem& rULSpace)
{
    if (!m_rExport.m_bOutFlyFrameAttrs)
    {
        if (m_rExport.m_bOutPageDescs)
        {
            OSL_ENSURE(m_rExport.GetCurItemSet(), "Impossible");
            if (!m_rExport.GetCurItemSet())
                return;
 
            // If we export a follow page format, then our doc model has
            // separate header/footer distances for the first page and the
            // follow pages, but Word can have only a single distance. In case
            // the two values differ, work with the value from the first page
            // format to be in sync with the import.
            sw::util::HdFtDistanceGlue aDistances(m_rExport.GetFirstPageItemSet()
                                                      ? *m_rExport.GetFirstPageItemSet()
                                                      : *m_rExport.GetCurItemSet());
 
            if (aDistances.m_DyaTop)
            {
                m_aSectionBreaks.append(OOO_STRING_SVTOOLS_RTF_MARGTSXN);
                m_aSectionBreaks.append(static_cast<sal_Int32>(aDistances.m_DyaTop));
                m_aPageMargins.nTop = aDistances.m_DyaTop;
            }
            if (aDistances.HasHeader())
            {
                m_aSectionBreaks.append(OOO_STRING_SVTOOLS_RTF_HEADERY);
                m_aSectionBreaks.append(static_cast<sal_Int32>(aDistances.m_DyaHdrTop));
            }
 
            if (aDistances.m_DyaBottom)
            {
                m_aSectionBreaks.append(OOO_STRING_SVTOOLS_RTF_MARGBSXN);
                m_aSectionBreaks.append(static_cast<sal_Int32>(aDistances.m_DyaBottom));
                m_aPageMargins.nBottom = aDistances.m_DyaBottom;
            }
            if (aDistances.HasFooter())
            {
                m_aSectionBreaks.append(OOO_STRING_SVTOOLS_RTF_FOOTERY);
                m_aSectionBreaks.append(static_cast<sal_Int32>(aDistances.m_DyaHdrBottom));
            }
            if (!m_bBufferSectionBreaks)
            {
                m_rExport.Strm().WriteOString(m_aSectionBreaks);
                m_aSectionBreaks.setLength(0);
            }
        }
        else
        {
            // Spacing before.
            if (m_bParaBeforeAutoSpacing && m_nParaBeforeSpacing == rULSpace.GetUpper())
                m_aStyles.append(LO_STRING_SVTOOLS_RTF_SBAUTO "1");
            else if (m_bParaBeforeAutoSpacing && m_nParaBeforeSpacing == -1)
            {
                m_aStyles.append(LO_STRING_SVTOOLS_RTF_SBAUTO "0");
                m_aStyles.append(OOO_STRING_SVTOOLS_RTF_SB);
                m_aStyles.append(static_cast<sal_Int32>(rULSpace.GetUpper()));
            }
            else
            {
                m_aStyles.append(OOO_STRING_SVTOOLS_RTF_SB);
                m_aStyles.append(static_cast<sal_Int32>(rULSpace.GetUpper()));
            }
            m_bParaBeforeAutoSpacing = false;
 
            // Spacing after.
            if (m_bParaAfterAutoSpacing && m_nParaAfterSpacing == rULSpace.GetLower())
                m_aStyles.append(LO_STRING_SVTOOLS_RTF_SAAUTO "1");
            else if (m_bParaAfterAutoSpacing && m_nParaAfterSpacing == -1)
            {
                m_aStyles.append(LO_STRING_SVTOOLS_RTF_SAAUTO "0");
                m_aStyles.append(OOO_STRING_SVTOOLS_RTF_SA);
                m_aStyles.append(static_cast<sal_Int32>(rULSpace.GetLower()));
            }
            else
            {
                m_aStyles.append(OOO_STRING_SVTOOLS_RTF_SA);
                m_aStyles.append(static_cast<sal_Int32>(rULSpace.GetLower()));
            }
            m_bParaAfterAutoSpacing = false;
 
            // Contextual spacing.
            if (rULSpace.GetContext())
                m_aStyles.append(OOO_STRING_SVTOOLS_RTF_CONTEXTUALSPACE);
        }
    }
    else if (m_rExport.GetRTFFlySyntax())
    {
        // Wrap: top and bottom spacing, convert from twips to EMUs.
        m_aFlyProperties.push_back(std::make_pair<OString, OString>(
            "dyWrapDistTop", OString::number(o3tl::convert(rULSpace.GetUpper(), o3tl::Length::twip,
                                                           o3tl::Length::emu))));
        m_aFlyProperties.push_back(std::make_pair<OString, OString>(
            "dyWrapDistBottom", OString::number(o3tl::convert(
                                    rULSpace.GetLower(), o3tl::Length::twip, o3tl::Length::emu))));
    }
}
 
void RtfAttributeOutput::FormatSurround(const SwFormatSurround& rSurround)
{
    if (m_rExport.m_bOutFlyFrameAttrs && !m_rExport.GetRTFFlySyntax())
    {
        css::text::WrapTextMode eSurround = rSurround.GetSurround();
        bool bGold = css::text::WrapTextMode_DYNAMIC == eSurround;
        if (bGold)
            eSurround = css::text::WrapTextMode_PARALLEL;
        RTFSurround aMC(bGold, static_cast<sal_uInt8>(eSurround));
        m_aRunText->append(OOO_STRING_SVTOOLS_RTF_FLYMAINCNT);
        m_aRunText->append(static_cast<sal_Int32>(aMC.GetValue()));
    }
    else if (m_rExport.m_bOutFlyFrameAttrs && m_rExport.GetRTFFlySyntax())
    {
        // See DocxSdrExport::startDMLAnchorInline() for SwFormatSurround -> WR / WRK mappings.
        sal_Int32 nWr = -1;
        std::optional<sal_Int32> oWrk;
        switch (rSurround.GetValue())
        {
            case css::text::WrapTextMode_NONE:
                nWr = 1; // top and bottom
                break;
            case css::text::WrapTextMode_THROUGH:
                nWr = 3; // none
                break;
            case css::text::WrapTextMode_PARALLEL:
                nWr = 2; // around
                oWrk = 0; // both sides
                break;
            case css::text::WrapTextMode_DYNAMIC:
            default:
                nWr = 2; // around
                oWrk = 3; // largest
                break;
        }
 
        if (rSurround.IsContour())
            nWr = 4; // tight
 
        m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_SHPWR);
        m_rExport.Strm().WriteNumberAsString(nWr);
        if (oWrk)
        {
            m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_SHPWRK);
            m_rExport.Strm().WriteNumberAsString(*oWrk);
        }
    }
}
 
void RtfAttributeOutput::FormatVertOrientation(const SwFormatVertOrient& rFlyVert)
{
    if (!(m_rExport.m_bOutFlyFrameAttrs && m_rExport.GetRTFFlySyntax()))
        return;
 
    switch (rFlyVert.GetRelationOrient())
    {
        case text::RelOrientation::PAGE_FRAME:
            m_aFlyProperties.push_back(
                std::make_pair<OString, OString>("posrelv", OString::number(1)));
            break;
        default:
            m_aFlyProperties.push_back(
                std::make_pair<OString, OString>("posrelv", OString::number(2)));
            m_rExport.Strm()
                .WriteOString(OOO_STRING_SVTOOLS_RTF_SHPBYPARA)
                .WriteOString(OOO_STRING_SVTOOLS_RTF_SHPBYIGNORE);
            break;
    }
 
    switch (rFlyVert.GetVertOrient())
    {
        case text::VertOrientation::TOP:
        case text::VertOrientation::LINE_TOP:
            m_aFlyProperties.push_back(
                std::make_pair<OString, OString>("posv", OString::number(1)));
            break;
        case text::VertOrientation::BOTTOM:
        case text::VertOrientation::LINE_BOTTOM:
            m_aFlyProperties.push_back(
                std::make_pair<OString, OString>("posv", OString::number(3)));
            break;
        case text::VertOrientation::CENTER:
        case text::VertOrientation::LINE_CENTER:
            m_aFlyProperties.push_back(
                std::make_pair<OString, OString>("posv", OString::number(2)));
            break;
        default:
            break;
    }
 
    m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_SHPTOP);
    m_rExport.Strm().WriteNumberAsString(rFlyVert.GetPos());
    if (m_pFlyFrameSize)
    {
        m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_SHPBOTTOM);
        m_rExport.Strm().WriteNumberAsString(rFlyVert.GetPos() + m_pFlyFrameSize->Height());
    }
}
 
void RtfAttributeOutput::FormatHorizOrientation(const SwFormatHoriOrient& rFlyHori)
{
    if (!(m_rExport.m_bOutFlyFrameAttrs && m_rExport.GetRTFFlySyntax()))
        return;
 
    switch (rFlyHori.GetRelationOrient())
    {
        case text::RelOrientation::PAGE_FRAME:
            m_aFlyProperties.push_back(
                std::make_pair<OString, OString>("posrelh", OString::number(1)));
            break;
        default:
            m_aFlyProperties.push_back(
                std::make_pair<OString, OString>("posrelh", OString::number(2)));
            m_rExport.Strm()
                .WriteOString(OOO_STRING_SVTOOLS_RTF_SHPBXCOLUMN)
                .WriteOString(OOO_STRING_SVTOOLS_RTF_SHPBXIGNORE);
            break;
    }
 
    switch (rFlyHori.GetHoriOrient())
    {
        case text::HoriOrientation::LEFT:
            m_aFlyProperties.push_back(
                std::make_pair<OString, OString>("posh", OString::number(1)));
            break;
        case text::HoriOrientation::CENTER:
            m_aFlyProperties.push_back(
                std::make_pair<OString, OString>("posh", OString::number(2)));
            break;
        case text::HoriOrientation::RIGHT:
            m_aFlyProperties.push_back(
                std::make_pair<OString, OString>("posh", OString::number(3)));
            break;
        default:
            break;
    }
 
    m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_SHPLEFT);
    m_rExport.Strm().WriteNumberAsString(rFlyHori.GetPos());
    if (m_pFlyFrameSize)
    {
        m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_SHPRIGHT);
        m_rExport.Strm().WriteNumberAsString(rFlyHori.GetPos() + m_pFlyFrameSize->Width());
    }
}
 
void RtfAttributeOutput::FormatAnchor(const SwFormatAnchor& rAnchor)
{
    if (m_rExport.GetRTFFlySyntax())
        return;
 
    RndStdIds eId = rAnchor.GetAnchorId();
    m_aRunText->append(OOO_STRING_SVTOOLS_RTF_FLYANCHOR);
    m_aRunText->append(static_cast<sal_Int32>(eId));
    switch (eId)
    {
        case RndStdIds::FLY_AT_PAGE:
            m_aRunText->append(OOO_STRING_SVTOOLS_RTF_FLYPAGE);
            m_aRunText->append(static_cast<sal_Int32>(rAnchor.GetPageNum()));
            break;
        case RndStdIds::FLY_AT_PARA:
        case RndStdIds::FLY_AS_CHAR:
            m_aRunText->append(OOO_STRING_SVTOOLS_RTF_FLYCNTNT);
            break;
        default:
            break;
    }
}
 
void RtfAttributeOutput::FormatBackground(const SvxBrushItem& rBrush)
{
    if (m_rExport.GetRTFFlySyntax())
    {
        const Color& rColor = rBrush.GetColor();
        // We in fact need RGB to BGR, but the transformation is symmetric.
        m_aFlyProperties.push_back(std::make_pair<OString, OString>(
            "fillColor", OString::number(wwUtility::RGBToBGR(rColor))));
    }
    else if (!rBrush.GetColor().IsTransparent())
    {
        m_aStyles.append(OOO_STRING_SVTOOLS_RTF_CBPAT);
        m_aStyles.append(static_cast<sal_Int32>(m_rExport.GetColor(rBrush.GetColor())));
    }
}
 
void RtfAttributeOutput::FormatFillStyle(const XFillStyleItem& rFillStyle)
{
    m_oFillStyle = rFillStyle.GetValue();
}
 
void RtfAttributeOutput::FormatFillGradient(const XFillGradientItem& rFillGradient)
{
    if (*m_oFillStyle != drawing::FillStyle_GRADIENT)
        return;
 
    m_aFlyProperties.push_back(std::make_pair<OString, OString>(
        "fillType", OString::number(7))); // Shade using the fillAngle
 
    const basegfx::BGradient& rGradient(rFillGradient.GetGradientValue());
    const basegfx::BColorStops& rColorStops(rGradient.GetColorStops());
 
    // MCGR: It would be best to export the full MCGR definition here
    // with all ColorStops in rColorStops, but rtf does not support this.
    // Best thing to do and to stay compatible is to export front/back
    // colors as start/end and - when more than two ColorStops are defined -
    // guess that GradientStyle_AXIAL is used and thus create a "fillFocus"
    // entry
    // NOTE: I also found that loading file from testTextframeGradient
    // "textframe-gradient.rtf" and save-as *inverts* the gradient, so I
    // exchanged here fillColor/fillBackColor to get the correct order
    const Color aStartColor(rColorStops.front().getStopColor());
    m_aFlyProperties.push_back(std::make_pair<OString, OString>(
        "fillColor", OString::number(wwUtility::RGBToBGR(aStartColor))));
 
    if (rColorStops.size() < 3)
    {
        // two-color version, use back as 2nd color
        const Color aEndColor(rColorStops.back().getStopColor());
        m_aFlyProperties.push_back(std::make_pair<OString, OString>(
            "fillBackColor", OString::number(wwUtility::RGBToBGR(aEndColor))));
    }
    else
    {
        // assume what was formally GradientStyle_AXIAL, see above and also refer to
        // FillModel::pushToPropMap 'fFocus' value and usage.
        // The 2nd color is the in-between color, use it
        const Color aEndColor(rColorStops[1].getStopColor());
        m_aFlyProperties.push_back(std::make_pair<OString, OString>(
            "fillBackColor", OString::number(wwUtility::RGBToBGR(aEndColor))));
        m_aFlyProperties.push_back(
            std::make_pair<OString, OString>("fillFocus", OString::number(50)));
    }
}
 
void RtfAttributeOutput::FormatBox(const SvxBoxItem& rBox)
{
    static const SvxBoxItemLine aBorders[] = { SvxBoxItemLine::TOP, SvxBoxItemLine::LEFT,
                                               SvxBoxItemLine::BOTTOM, SvxBoxItemLine::RIGHT };
    static const char* aBorderNames[]
        = { OOO_STRING_SVTOOLS_RTF_BRDRT, OOO_STRING_SVTOOLS_RTF_BRDRL,
            OOO_STRING_SVTOOLS_RTF_BRDRB, OOO_STRING_SVTOOLS_RTF_BRDRR };
 
    sal_uInt16 const nDist = rBox.GetSmallestDistance();
 
    if (m_rExport.GetRTFFlySyntax())
    {
        // Borders: spacing to contents, convert from twips to EMUs.
        m_aFlyProperties.push_back(std::make_pair<OString, OString>(
            "dxTextLeft", OString::number(o3tl::convert(rBox.GetDistance(SvxBoxItemLine::LEFT),
                                                        o3tl::Length::twip, o3tl::Length::emu))));
        m_aFlyProperties.push_back(std::make_pair<OString, OString>(
            "dyTextTop", OString::number(o3tl::convert(rBox.GetDistance(SvxBoxItemLine::TOP),
                                                       o3tl::Length::twip, o3tl::Length::emu))));
        m_aFlyProperties.push_back(std::make_pair<OString, OString>(
            "dxTextRight", OString::number(o3tl::convert(rBox.GetDistance(SvxBoxItemLine::RIGHT),
                                                         o3tl::Length::twip, o3tl::Length::emu))));
        m_aFlyProperties.push_back(std::make_pair<OString, OString>(
            "dyTextBottom", OString::number(o3tl::convert(rBox.GetDistance(SvxBoxItemLine::BOTTOM),
                                                          o3tl::Length::twip, o3tl::Length::emu))));
 
        const editeng::SvxBorderLine* pLeft = rBox.GetLine(SvxBoxItemLine::LEFT);
        const editeng::SvxBorderLine* pRight = rBox.GetLine(SvxBoxItemLine::RIGHT);
        const editeng::SvxBorderLine* pTop = rBox.GetLine(SvxBoxItemLine::TOP);
        const editeng::SvxBorderLine* pBottom = rBox.GetLine(SvxBoxItemLine::BOTTOM);
 
        if (!pLeft && !pRight && !pBottom && !pTop)
        {
            // fLine has default 'true', so need to write it out in case of no border.
            m_aFlyProperties.push_back(std::make_pair<OString, OString>("fLine", "0"));
            return;
        }
 
        // RTF has the flags fTopLine, fBottomLine, fLeftLine and fRightLine to disable single border
        // lines. But Word cannot disable single border lines. So we do not use them. In case of
        // single border lines it is better to draw all four borders than drawing none. So we look
        // whether a border line exists, which is effectively drawn.
        const editeng::SvxBorderLine* pBorder = nullptr;
        if (pTop && pTop->GetBorderLineStyle() != SvxBorderLineStyle::NONE)
            pBorder = pTop;
        else if (pBottom && pBottom->GetBorderLineStyle() != SvxBorderLineStyle::NONE)
            pBorder = pBottom;
        else if (pLeft && pLeft->GetBorderLineStyle() != SvxBorderLineStyle::NONE)
            pBorder = pLeft;
        else if (pRight && pRight->GetBorderLineStyle() != SvxBorderLineStyle::NONE)
            pBorder = pRight;
 
        if (!pBorder)
        {
            m_aFlyProperties.push_back(std::make_pair<OString, OString>("fLine", "0"));
            return;
        }
 
        const Color& rColor = pBorder->GetColor();
        // We in fact need RGB to BGR, but the transformation is symmetric.
        m_aFlyProperties.push_back(std::make_pair<OString, OString>(
            "lineColor", OString::number(wwUtility::RGBToBGR(rColor))));
 
        double const fConverted(
            editeng::ConvertBorderWidthToWord(pBorder->GetBorderLineStyle(), pBorder->GetWidth()));
        sal_Int32 nWidth = o3tl::convert(fConverted, o3tl::Length::twip, o3tl::Length::emu);
        m_aFlyProperties.push_back(
            std::make_pair<OString, OString>("lineWidth", OString::number(nWidth)));
 
        return;
    }
 
    if (rBox.GetTop() && rBox.GetBottom() && rBox.GetLeft() && rBox.GetRight()
        && *rBox.GetTop() == *rBox.GetBottom() && *rBox.GetTop() == *rBox.GetLeft()
        && *rBox.GetTop() == *rBox.GetRight() && nDist == rBox.GetDistance(SvxBoxItemLine::TOP)
        && nDist == rBox.GetDistance(SvxBoxItemLine::LEFT)
        && nDist == rBox.GetDistance(SvxBoxItemLine::BOTTOM)
        && nDist == rBox.GetDistance(SvxBoxItemLine::RIGHT))
        m_aSectionBreaks.append(
            OutBorderLine(m_rExport, rBox.GetTop(), OOO_STRING_SVTOOLS_RTF_BOX, nDist));
    else
    {
        SvxShadowLocation eShadowLocation = SvxShadowLocation::NONE;
        if (const SvxShadowItem* pItem = GetExport().HasItem(RES_SHADOW))
            eShadowLocation = pItem->GetLocation();
 
        const SvxBoxItemLine* pBrd = aBorders;
        const char** pBrdNms = aBorderNames;
        for (int i = 0; i < 4; ++i, ++pBrd, ++pBrdNms)
        {
            editeng::SvxBorderLine const* const pLn = rBox.GetLine(*pBrd);
            m_aSectionBreaks.append(
                OutBorderLine(m_rExport, pLn, *pBrdNms, rBox.GetDistance(*pBrd), eShadowLocation));
        }
    }
 
    if (!m_bBufferSectionBreaks)
    {
        m_aStyles.append(m_aSectionBreaks);
        m_aSectionBreaks.setLength(0);
    }
}
 
void RtfAttributeOutput::FormatColumns_Impl(sal_uInt16 nCols, const SwFormatCol& rCol, bool bEven,
                                            SwTwips nPageSize)
{
    m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_COLS);
    m_rExport.Strm().WriteNumberAsString(nCols);
 
    if (rCol.GetLineAdj() != COLADJ_NONE)
        m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_LINEBETCOL);
 
    if (bEven)
    {
        m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_COLSX);
        m_rExport.Strm().WriteNumberAsString(rCol.GetGutterWidth(true));
    }
    else
    {
        const SwColumns& rColumns = rCol.GetColumns();
        for (sal_uInt16 n = 0; n < nCols;)
        {
            m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_COLNO);
            m_rExport.Strm().WriteNumberAsString(n + 1);
 
            m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_COLW);
            m_rExport.Strm().WriteNumberAsString(rCol.CalcPrtColWidth(n, nPageSize));
 
            if (++n != nCols)
            {
                m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_COLSR);
                m_rExport.Strm().WriteNumberAsString(rColumns[n - 1].GetRight()
                                                     + rColumns[n].GetLeft());
            }
        }
    }
}
 
void RtfAttributeOutput::FormatKeep(const SvxFormatKeepItem& rItem)
{
    if (rItem.GetValue())
        m_aStyles.append(OOO_STRING_SVTOOLS_RTF_KEEPN);
}
 
void RtfAttributeOutput::FormatTextGrid(const SwTextGridItem& /*rGrid*/)
{
    SAL_INFO("sw.rtf", "TODO: " << __func__);
}
 
void RtfAttributeOutput::FormatLineNumbering(const SwFormatLineNumber& rNumbering)
{
    if (!rNumbering.IsCount())
        m_aStyles.append(OOO_STRING_SVTOOLS_RTF_NOLINE);
}
 
void RtfAttributeOutput::FormatFrameDirection(const SvxFrameDirectionItem& rDirection)
{
    SvxFrameDirection nDir = rDirection.GetValue();
    if (nDir == SvxFrameDirection::Environment)
        nDir = GetExport().GetDefaultFrameDirection();
 
    if (m_rExport.m_bOutPageDescs)
    {
        if (nDir == SvxFrameDirection::Vertical_RL_TB)
        {
            m_aSectionBreaks.append(OOO_STRING_SVTOOLS_RTF_STEXTFLOW);
            m_aSectionBreaks.append(static_cast<sal_Int32>(1));
            if (!m_bBufferSectionBreaks)
            {
                m_rExport.Strm().WriteOString(m_aSectionBreaks);
                m_aSectionBreaks.setLength(0);
            }
        }
        return;
    }
 
    if (m_rExport.GetRTFFlySyntax())
    {
        if (nDir == SvxFrameDirection::Vertical_RL_TB)
        {
            // Top to bottom non-ASCII font
            m_aFlyProperties.push_back(std::make_pair<OString, OString>("txflTextFlow", "3"));
        }
        else if (rDirection.GetValue() == SvxFrameDirection::Vertical_LR_BT)
        {
            // Bottom to top non-ASCII font
            m_aFlyProperties.push_back(std::make_pair<OString, OString>("txflTextFlow", "2"));
        }
        return;
    }
 
    if (nDir == SvxFrameDirection::Horizontal_RL_TB)
        m_aStyles.append(OOO_STRING_SVTOOLS_RTF_RTLPAR);
    else
        m_aStyles.append(OOO_STRING_SVTOOLS_RTF_LTRPAR);
}
 
void RtfAttributeOutput::ParaGrabBag(const SfxGrabBagItem& rItem)
{
    const std::map<OUString, css::uno::Any>& rMap = rItem.GetGrabBag();
    for (const auto& rValue : rMap)
    {
        if (rValue.first == "ParaTopMarginBeforeAutoSpacing")
        {
            m_bParaBeforeAutoSpacing = true;
            rValue.second >>= m_nParaBeforeSpacing;
            m_nParaBeforeSpacing = o3tl::toTwips(m_nParaBeforeSpacing, o3tl::Length::mm100);
        }
        else if (rValue.first == "ParaBottomMarginAfterAutoSpacing")
        {
            m_bParaAfterAutoSpacing = true;
            rValue.second >>= m_nParaAfterSpacing;
            m_nParaAfterSpacing = o3tl::toTwips(m_nParaAfterSpacing, o3tl::Length::mm100);
        }
    }
}
 
void RtfAttributeOutput::CharGrabBag(const SfxGrabBagItem& /*rItem*/) {}
 
void RtfAttributeOutput::ParaOutlineLevel(const SfxUInt16Item& /*rItem*/) {}
 
void RtfAttributeOutput::WriteExpand(const SwField* pField)
{
    OUString sCmd; // for optional Parameters
    switch (pField->GetTyp()->Which())
    {
        //#i119803# Export user field for RTF filter
        case SwFieldIds::User:
            sCmd = pField->GetTyp()->GetName();
            m_rExport.OutputField(pField, ww::eNONE, sCmd);
            break;
        default:
            m_rExport.OutputField(pField, ww::eUNKNOWN, sCmd);
            break;
    }
}
 
void RtfAttributeOutput::RefField(const SwField& /*rField*/, const OUString& /*rRef*/)
{
    SAL_INFO("sw.rtf", "TODO: " << __func__);
}
 
void RtfAttributeOutput::HiddenField(const SwField& /*rField*/)
{
    SAL_INFO("sw.rtf", "TODO: " << __func__);
}
 
void RtfAttributeOutput::SetField(const SwField& /*rField*/, ww::eField /*eType*/,
                                  const OUString& /*rCmd*/)
{
    SAL_INFO("sw.rtf", "TODO: " << __func__);
}
 
void RtfAttributeOutput::PostitField(const SwField* pField)
{
    const SwPostItField& rPField = *static_cast<const SwPostItField*>(pField);
 
    OString aName = OUStringToOString(rPField.GetName(), RTL_TEXTENCODING_UTF8);
    auto it = m_rOpenedAnnotationMarksIds.find(aName);
    if (it != m_rOpenedAnnotationMarksIds.end())
    {
        // In case this field is inside annotation marks, we want to write the
        // annotation itself after the annotation mark is closed, not here.
        m_aPostitFields[it->second] = &rPField;
        return;
    }
 
    m_aRunText->append("{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_ATNID " ");
    m_aRunText->append(OUStringToOString(rPField.GetInitials(), m_rExport.GetCurrentEncoding()));
    m_aRunText->append("}");
    m_aRunText->append("{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_ATNAUTHOR " ");
    m_aRunText->append(OUStringToOString(rPField.GetPar1(), m_rExport.GetCurrentEncoding()));
    m_aRunText->append("}");
    m_aRunText->append(OOO_STRING_SVTOOLS_RTF_CHATN);
 
    m_aRunText->append("{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_ANNOTATION);
 
    if (m_nCurrentAnnotationMarkId != -1)
    {
        m_aRunText->append("{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_ATNREF " ");
        m_aRunText->append(m_nCurrentAnnotationMarkId);
        m_aRunText->append('}');
    }
    m_aRunText->append("{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_ATNDATE " ");
    m_aRunText->append(static_cast<sal_Int32>(sw::ms::DateTime2DTTM(rPField.GetDateTime())));
    m_aRunText->append('}');
    if (const OutlinerParaObject* pObject = rPField.GetTextObject())
        m_rExport.SdrExporter().WriteOutliner(*pObject, TXT_ATN);
    m_aRunText->append('}');
}
 
bool RtfAttributeOutput::DropdownField(const SwField* /*pField*/)
{
    // this is handled in OutputFlyFrame_Impl()
    return true;
}
 
bool RtfAttributeOutput::PlaceholderField(const SwField* pField)
{
    m_aRunText->append("{" OOO_STRING_SVTOOLS_RTF_FIELD
                       "{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_FLDINST
                       " MACROBUTTON  None ");
    RunText(pField->GetPar1());
    m_aRunText->append("}}");
    return false; // do not expand
}
 
RtfAttributeOutput::RtfAttributeOutput(RtfExport& rExport)
    : AttributeOutputBase("") // ConvertURL isn't used now in RTF output
    , m_rExport(rExport)
    , m_pPrevPageDesc(nullptr)
    , m_nStyleId(0)
    , m_nListId(0)
    , m_bIsRTL(false)
    , m_nScript(i18n::ScriptType::LATIN)
    , m_bControlLtrRtl(false)
    , m_nNextAnnotationMarkId(0)
    , m_nCurrentAnnotationMarkId(-1)
    , m_bTableCellOpen(false)
    , m_nTableDepth(0)
    , m_bTableAfterCell(false)
    , m_nColBreakNeeded(false)
    , m_bBufferSectionBreaks(false)
    , m_bBufferSectionHeaders(false)
    , m_bLastTable(true)
    , m_bWroteCellInfo(false)
    , m_bTableRowEnded(false)
    , m_bIsBeforeFirstParagraph(true)
    , m_bSingleEmptyRun(false)
    , m_bInRun(false)
    , m_bInRuby(false)
    , m_pFlyFrameSize(nullptr)
    , m_bParaBeforeAutoSpacing(false)
    , m_nParaBeforeSpacing(0)
    , m_bParaAfterAutoSpacing(false)
    , m_nParaAfterSpacing(0)
{
}
 
RtfAttributeOutput::~RtfAttributeOutput() = default;
 
MSWordExportBase& RtfAttributeOutput::GetExport() { return m_rExport; }
 
// These are used by wwFont::WriteRtf()
 
void RtfAttributeOutput::StartFont(std::u16string_view rFamilyName) const
{
    // write the font name hex-encoded, but without Unicode - Word at least
    // cannot read *both* Unicode and fallback as written by OutString
    m_rExport.Strm().WriteOString(
        msfilter::rtfutil::OutString(rFamilyName, m_rExport.GetCurrentEncoding(), false));
}
 
void RtfAttributeOutput::EndFont() const
{
    m_rExport.Strm().WriteOString(";}");
    m_rExport.SetCurrentEncoding(m_rExport.GetDefaultEncoding());
}
 
void RtfAttributeOutput::FontAlternateName(std::u16string_view rName) const
{
    m_rExport.Strm()
        .WriteChar('{')
        .WriteOString(OOO_STRING_SVTOOLS_RTF_IGNORE)
        .WriteOString(OOO_STRING_SVTOOLS_RTF_FALT)
        .WriteChar(' ');
    // write the font name hex-encoded, but without Unicode - Word at least
    // cannot read *both* Unicode and fallback as written by OutString
    m_rExport.Strm()
        .WriteOString(msfilter::rtfutil::OutString(rName, m_rExport.GetCurrentEncoding(), false))
        .WriteChar('}');
}
 
void RtfAttributeOutput::FontCharset(sal_uInt8 nCharSet) const
{
    m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_FCHARSET);
    m_rExport.Strm().WriteNumberAsString(nCharSet);
    m_rExport.Strm().WriteChar(' ');
    m_rExport.SetCurrentEncoding(rtl_getTextEncodingFromWindowsCharset(nCharSet));
}
 
void RtfAttributeOutput::FontFamilyType(FontFamily eFamily, const wwFont& rFont) const
{
    m_rExport.Strm().WriteChar('{').WriteOString(OOO_STRING_SVTOOLS_RTF_F);
 
    const char* pStr = OOO_STRING_SVTOOLS_RTF_FNIL;
    switch (eFamily)
    {
        case FAMILY_ROMAN:
            pStr = OOO_STRING_SVTOOLS_RTF_FROMAN;
            break;
        case FAMILY_SWISS:
            pStr = OOO_STRING_SVTOOLS_RTF_FSWISS;
            break;
        case FAMILY_MODERN:
            pStr = OOO_STRING_SVTOOLS_RTF_FMODERN;
            break;
        case FAMILY_SCRIPT:
            pStr = OOO_STRING_SVTOOLS_RTF_FSCRIPT;
            break;
        case FAMILY_DECORATIVE:
            pStr = OOO_STRING_SVTOOLS_RTF_FDECOR;
            break;
        default:
            break;
    }
    m_rExport.Strm().WriteNumberAsString(m_rExport.m_aFontHelper.GetId(rFont)).WriteOString(pStr);
}
 
void RtfAttributeOutput::FontPitchType(FontPitch ePitch) const
{
    m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_FPRQ);
 
    sal_uInt16 nVal = 0;
    switch (ePitch)
    {
        case PITCH_FIXED:
            nVal = 1;
            break;
        case PITCH_VARIABLE:
            nVal = 2;
            break;
        default:
            break;
    }
    m_rExport.Strm().WriteNumberAsString(nVal);
}
 
static void lcl_AppendSP(OStringBuffer& rBuffer, std::string_view cName, std::u16string_view rValue,
                         const RtfExport& rExport)
{
    rBuffer.append("{" OOO_STRING_SVTOOLS_RTF_SP "{"); // "{\sp{"
    rBuffer.append(OOO_STRING_SVTOOLS_RTF_SN " "); //" \sn "
    rBuffer.append(cName); //"PropName"
    rBuffer.append("}{" OOO_STRING_SVTOOLS_RTF_SV " ");
    // "}{ \sv "
    rBuffer.append(msfilter::rtfutil::OutString(rValue, rExport.GetCurrentEncoding()));
    rBuffer.append("}}");
}
 
static OString ExportPICT(const SwFlyFrameFormat* pFlyFrameFormat, const Size& rOrig,
                          const Size& rRendered, const Size& rMapped, const SwCropGrf& rCr,
                          const char* pBLIPType, const sal_uInt8* pGraphicAry, sal_uInt64 nSize,
                          const RtfExport& rExport, SvStream* pStream = nullptr,
                          bool bWritePicProp = true, const SwAttrSet* pAttrSet = nullptr)
{
    OStringBuffer aRet;
    if (pBLIPType && nSize && pGraphicAry)
    {
        bool bIsWMF = std::strcmp(pBLIPType, OOO_STRING_SVTOOLS_RTF_WMETAFILE) == 0;
 
        aRet.append("{" OOO_STRING_SVTOOLS_RTF_PICT);
 
        if (pFlyFrameFormat && bWritePicProp)
        {
            OUString sDescription = pFlyFrameFormat->GetObjDescription();
            //write picture properties - wzDescription at first
            //looks like: "{\*\picprop{\sp{\sn PropertyName}{\sv PropertyValue}}}"
            aRet.append(
                "{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_PICPROP); //"{\*\picprop
            lcl_AppendSP(aRet, "wzDescription", sDescription, rExport);
            OUString sName = pFlyFrameFormat->GetObjTitle();
            lcl_AppendSP(aRet, "wzName", sName, rExport);
 
            if (pAttrSet)
            {
                MirrorGraph eMirror = pAttrSet->Get(RES_GRFATR_MIRRORGRF).GetValue();
                if (eMirror == MirrorGraph::Vertical || eMirror == MirrorGraph::Both)
                    // Mirror on the vertical axis is a horizontal flip.
                    lcl_AppendSP(aRet, "fFlipH", u"1", rExport);
            }
 
            aRet.append("}"); //"}"
        }
 
        tools::Long nXCroppedSize = rOrig.Width() - (rCr.GetLeft() + rCr.GetRight());
        tools::Long nYCroppedSize = rOrig.Height() - (rCr.GetTop() + rCr.GetBottom());
        /* Graphic with a zero height or width, typically copied from webpages, caused crashes. */
        if (!nXCroppedSize)
            nXCroppedSize = 100;
        if (!nYCroppedSize)
            nYCroppedSize = 100;
 
        //Given the original size and taking cropping into account
        //first, how much has the original been scaled to get the
        //final rendered size
        aRet.append(
            OOO_STRING_SVTOOLS_RTF_PICSCALEX
            + OString::number(static_cast<sal_Int32>((100 * rRendered.Width()) / nXCroppedSize))
            + OOO_STRING_SVTOOLS_RTF_PICSCALEY
            + OString::number(static_cast<sal_Int32>((100 * rRendered.Height()) / nYCroppedSize))
 
            + OOO_STRING_SVTOOLS_RTF_PICCROPL + OString::number(rCr.GetLeft())
            + OOO_STRING_SVTOOLS_RTF_PICCROPR + OString::number(rCr.GetRight())
            + OOO_STRING_SVTOOLS_RTF_PICCROPT + OString::number(rCr.GetTop())
            + OOO_STRING_SVTOOLS_RTF_PICCROPB + OString::number(rCr.GetBottom())
 
            + OOO_STRING_SVTOOLS_RTF_PICW + OString::number(static_cast<sal_Int32>(rMapped.Width()))
            + OOO_STRING_SVTOOLS_RTF_PICH
            + OString::number(static_cast<sal_Int32>(rMapped.Height()))
 
            + OOO_STRING_SVTOOLS_RTF_PICWGOAL
            + OString::number(static_cast<sal_Int32>(rOrig.Width()))
            + OOO_STRING_SVTOOLS_RTF_PICHGOAL
            + OString::number(static_cast<sal_Int32>(rOrig.Height()))
 
            + pBLIPType);
        if (bIsWMF)
        {
            aRet.append(sal_Int32(8));
            msfilter::rtfutil::StripMetafileHeader(pGraphicAry, nSize);
        }
        aRet.append(SAL_NEWLINE_STRING);
        if (pStream)
        {
            pStream->WriteOString(aRet);
            aRet.setLength(0);
        }
        if (pStream)
            msfilter::rtfutil::WriteHex(pGraphicAry, nSize, pStream);
        else
            aRet.append(msfilter::rtfutil::WriteHex(pGraphicAry, nSize));
        aRet.append('}');
        if (pStream)
        {
            pStream->WriteOString(aRet);
            aRet.setLength(0);
        }
    }
    return aRet.makeStringAndClear();
}
 
void RtfAttributeOutput::FlyFrameOLEReplacement(const SwFlyFrameFormat* pFlyFrameFormat,
                                                SwOLENode& rOLENode, const Size& rSize)
{
    m_aRunText->append("{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_SHPPICT);
    Size aSize(rOLENode.GetTwipSize());
    Size aRendered(aSize);
    aRendered.setWidth(rSize.Width());
    aRendered.setHeight(rSize.Height());
    const Graphic* pGraphic = rOLENode.GetGraphic();
    Size aMapped(pGraphic->GetPrefSize());
    auto& rCr = rOLENode.GetAttr(RES_GRFATR_CROPGRF);
    const char* pBLIPType = OOO_STRING_SVTOOLS_RTF_PNGBLIP;
    const sal_uInt8* pGraphicAry = nullptr;
    SvMemoryStream aStream;
    if (GraphicConverter::Export(aStream, *pGraphic, ConvertDataFormat::PNG) != ERRCODE_NONE)
        SAL_WARN("sw.rtf", "failed to export the graphic");
    sal_uInt32 nSize = aStream.TellEnd();
    pGraphicAry = static_cast<sal_uInt8 const*>(aStream.GetData());
    m_aRunText->append(ExportPICT(pFlyFrameFormat, aSize, aRendered, aMapped, rCr, pBLIPType,
                                  pGraphicAry, nSize, m_rExport));
    m_aRunText->append("}"); // shppict
    m_aRunText->append("{" OOO_STRING_SVTOOLS_RTF_NONSHPPICT);
    pBLIPType = OOO_STRING_SVTOOLS_RTF_WMETAFILE;
    SvMemoryStream aWmfStream;
    if (GraphicConverter::Export(aWmfStream, *pGraphic, ConvertDataFormat::WMF) != ERRCODE_NONE)
        SAL_WARN("sw.rtf", "failed to export the graphic");
    nSize = aWmfStream.TellEnd();
    pGraphicAry = static_cast<sal_uInt8 const*>(aWmfStream.GetData());
    m_aRunText->append(ExportPICT(pFlyFrameFormat, aSize, aRendered, aMapped, rCr, pBLIPType,
                                  pGraphicAry, nSize, m_rExport));
    m_aRunText->append("}"); // nonshppict
}
 
bool RtfAttributeOutput::FlyFrameOLEMath(const SwFlyFrameFormat* pFlyFrameFormat,
                                         SwOLENode& rOLENode, const Size& rSize)
{
    uno::Reference<embed::XEmbeddedObject> xObj(rOLENode.GetOLEObj().GetOleRef());
    sal_Int64 nAspect = rOLENode.GetAspect();
    svt::EmbeddedObjectRef aObjRef(xObj, nAspect);
    SvGlobalName aObjName(aObjRef->getClassID());
 
    if (!SotExchange::IsMath(aObjName))
        return false;
 
    m_aRunText->append("{" LO_STRING_SVTOOLS_RTF_MMATH " ");
    uno::Reference<util::XCloseable> xClosable = xObj->getComponent();
    if (!xClosable.is())
        return false;
    auto pBase = dynamic_cast<oox::FormulaImExportBase*>(xClosable.get());
    SAL_WARN_IF(!pBase, "sw.rtf", "Math OLE object cannot write out RTF");
    if (pBase)
    {
        OStringBuffer aBuf;
        pBase->writeFormulaRtf(aBuf, m_rExport.GetCurrentEncoding());
        m_aRunText->append(aBuf);
    }
 
    // Replacement graphic.
    m_aRunText->append("{" LO_STRING_SVTOOLS_RTF_MMATHPICT " ");
    FlyFrameOLEReplacement(pFlyFrameFormat, rOLENode, rSize);
    m_aRunText->append("}"); // mmathPict
    m_aRunText->append("}"); // mmath
 
    return true;
}
 
void RtfAttributeOutput::FlyFrameOLE(const SwFlyFrameFormat* pFlyFrameFormat, SwOLENode& rOLENode,
                                     const Size& rSize)
{
    if (FlyFrameOLEMath(pFlyFrameFormat, rOLENode, rSize))
        return;
 
    FlyFrameOLEReplacement(pFlyFrameFormat, rOLENode, rSize);
}
 
void RtfAttributeOutput::FlyFrameGraphic(const SwFlyFrameFormat* pFlyFrameFormat,
                                         const SwGrfNode* pGrfNode)
{
    SvMemoryStream aStream;
    const sal_uInt8* pGraphicAry = nullptr;
    sal_uInt32 nSize = 0;
 
    const Graphic& rGraphic(pGrfNode->GetGrf());
 
    // If there is no graphic there is not much point in parsing it
    if (rGraphic.GetType() == GraphicType::NONE)
        return;
 
    ConvertDataFormat aConvertDestinationFormat = ConvertDataFormat::WMF;
    const char* pConvertDestinationBLIPType = OOO_STRING_SVTOOLS_RTF_WMETAFILE;
 
    GfxLink aGraphicLink;
    const char* pBLIPType = nullptr;
    if (rGraphic.IsGfxLink())
    {
        aGraphicLink = rGraphic.GetGfxLink();
        nSize = aGraphicLink.GetDataSize();
        pGraphicAry = aGraphicLink.GetData();
        switch (aGraphicLink.GetType())
        {
            // #i15508# trying to add BMP type for better exports, need to check if this works
            // checked, does not work. Also need to reset pGraphicAry to NULL to force conversion
            // to PNG, else the BMP array will be used.
            // It may work using direct DIB data, but that needs to be checked eventually
            //
            // #i15508# before GfxLinkType::NativeBmp was added the graphic data
            // (to be hold in pGraphicAry) was not available; thus for now to stay
            // compatible, keep it that way by assigning NULL value to pGraphicAry
            case GfxLinkType::NativeBmp:
                //    pBLIPType = OOO_STRING_SVTOOLS_RTF_WBITMAP;
                pGraphicAry = nullptr;
                break;
 
            case GfxLinkType::NativeJpg:
                pBLIPType = OOO_STRING_SVTOOLS_RTF_JPEGBLIP;
                break;
            case GfxLinkType::NativePng:
                pBLIPType = OOO_STRING_SVTOOLS_RTF_PNGBLIP;
                break;
            case GfxLinkType::NativeWmf:
                pBLIPType = aGraphicLink.IsEMF() ? OOO_STRING_SVTOOLS_RTF_EMFBLIP
                                                 : OOO_STRING_SVTOOLS_RTF_WMETAFILE;
                break;
            case GfxLinkType::NativeGif:
                // GIF is not supported by RTF, but we override default conversion to WMF, PNG seems fits better here.
                aConvertDestinationFormat = ConvertDataFormat::PNG;
                pConvertDestinationBLIPType = OOO_STRING_SVTOOLS_RTF_PNGBLIP;
                break;
            default:
                break;
        }
    }
 
    GraphicType eGraphicType = rGraphic.GetType();
    if (!pGraphicAry)
    {
        if (ERRCODE_NONE
            == GraphicConverter::Export(aStream, rGraphic,
                                        (eGraphicType == GraphicType::Bitmap)
                                            ? ConvertDataFormat::PNG
                                            : ConvertDataFormat::WMF))
        {
            pBLIPType = (eGraphicType == GraphicType::Bitmap) ? OOO_STRING_SVTOOLS_RTF_PNGBLIP
                                                              : OOO_STRING_SVTOOLS_RTF_WMETAFILE;
            nSize = aStream.TellEnd();
            pGraphicAry = static_cast<sal_uInt8 const*>(aStream.GetData());
        }
    }
 
    Size aMapped(eGraphicType == GraphicType::Bitmap ? rGraphic.GetSizePixel()
                                                     : rGraphic.GetPrefSize());
 
    auto& rCr = pGrfNode->GetAttr(RES_GRFATR_CROPGRF);
 
    //Get original size in twips
    Size aSize(pGrfNode->GetTwipSize());
    Size aRendered(aSize);
 
    const SwFormatFrameSize& rS = pFlyFrameFormat->GetFrameSize();
    aRendered.setWidth(rS.GetWidth());
    aRendered.setHeight(rS.GetHeight());
 
    ww8::Frame* pFrame = nullptr;
    for (auto& rFrame : m_rExport.m_aFrames)
    {
        if (pFlyFrameFormat == &rFrame.GetFrameFormat())
        {
            pFrame = &rFrame;
            break;
        }
    }
 
    /*
       If the graphic is not of type WMF then we will have to store two
       graphics, one in the native format wrapped in shppict, and the other in
       the wmf format wrapped in nonshppict, so as to keep wordpad happy. If it's
       a wmf already then we don't need any such wrapping
       */
    bool bIsWMF = pBLIPType && std::strcmp(pBLIPType, OOO_STRING_SVTOOLS_RTF_WMETAFILE) == 0;
    const SwAttrSet* pAttrSet = pGrfNode->GetpSwAttrSet();
    if (!pFrame || pFrame->IsInline())
    {
        if (!bIsWMF)
            m_rExport.Strm().WriteOString(
                "{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_SHPPICT);
    }
    else
    {
        m_rExport.Strm().WriteOString(
            "{" OOO_STRING_SVTOOLS_RTF_SHP
            "{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_SHPINST);
        m_pFlyFrameSize = &aRendered;
        m_rExport.m_pParentFrame = pFrame;
        m_rExport.m_bOutFlyFrameAttrs = true;
        m_rExport.SetRTFFlySyntax(true);
        m_rExport.OutputFormat(pFrame->GetFrameFormat(), false, false, true);
        m_rExport.m_bOutFlyFrameAttrs = false;
        m_rExport.SetRTFFlySyntax(false);
        m_rExport.m_pParentFrame = nullptr;
        m_pFlyFrameSize = nullptr;
        std::vector<std::pair<OString, OString>> aFlyProperties{
            { "shapeType", OString::number(ESCHER_ShpInst_PictureFrame) },
 
            { "wzDescription", msfilter::rtfutil::OutString(pFlyFrameFormat->GetObjDescription(),
                                                            m_rExport.GetCurrentEncoding()) },
            { "wzName", msfilter::rtfutil::OutString(pFlyFrameFormat->GetObjTitle(),
                                                     m_rExport.GetCurrentEncoding()) }
        };
 
        // If we have a wrap polygon, then handle that here.
        if (pFlyFrameFormat->GetSurround().IsContour())
        {
            if (const SwNoTextNode* pNd
                = sw::util::GetNoTextNodeFromSwFrameFormat(*pFlyFrameFormat))
            {
                const tools::PolyPolygon* pPolyPoly = pNd->HasContour();
                if (pPolyPoly && pPolyPoly->Count())
                {
                    tools::Polygon aPoly = sw::util::CorrectWordWrapPolygonForExport(
                        *pPolyPoly, pNd, /*bCorrectCrop=*/true);
                    OStringBuffer aVerticies;
                    for (sal_uInt16 i = 0; i < aPoly.GetSize(); ++i)
                        aVerticies.append(";(" + OString::number(aPoly[i].X()) + ","
                                          + OString::number(aPoly[i].Y()) + ")");
                    aFlyProperties.push_back(std::make_pair<OString, OString>(
                        "pWrapPolygonVertices",
                        "8;" + OString::number(aPoly.GetSize()) + aVerticies));
                }
            }
        }
 
        // Below text, behind document, opaque: they all refer to the same thing.
        if (!pFlyFrameFormat->GetOpaque().GetValue())
            aFlyProperties.push_back(std::make_pair<OString, OString>("fBehindDocument", "1"));
 
        if (pAttrSet)
        {
            if (Degree10 nRot10 = pAttrSet->Get(RES_GRFATR_ROTATION).GetValue())
            {
                // See writerfilter::rtftok::RTFSdrImport::applyProperty(),
                // positive rotation angles are clockwise in RTF, we have them
                // as counter-clockwise.
                // Additionally, RTF type is 0..360*2^16, our is 0..360*10.
                sal_Int32 nRot = nRot10.get() * -1 * RTF_MULTIPLIER / 10;
                aFlyProperties.emplace_back("rotation", OString::number(nRot));
            }
        }
 
        for (const std::pair<OString, OString>& rPair : aFlyProperties)
        {
            m_rExport.Strm().WriteOString("{" OOO_STRING_SVTOOLS_RTF_SP "{");
            m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_SN " ");
            m_rExport.Strm().WriteOString(rPair.first);
            m_rExport.Strm().WriteOString("}{" OOO_STRING_SVTOOLS_RTF_SV " ");
            m_rExport.Strm().WriteOString(rPair.second);
            m_rExport.Strm().WriteOString("}}");
        }
        m_rExport.Strm().WriteOString("{" OOO_STRING_SVTOOLS_RTF_SP "{" OOO_STRING_SVTOOLS_RTF_SN
                                      " pib"
                                      "}{" OOO_STRING_SVTOOLS_RTF_SV " ");
    }
 
    bool bWritePicProp = !pFrame || pFrame->IsInline();
    if (pBLIPType)
        ExportPICT(pFlyFrameFormat, aSize, aRendered, aMapped, rCr, pBLIPType, pGraphicAry, nSize,
                   m_rExport, &m_rExport.Strm(), bWritePicProp, pAttrSet);
    else
    {
        aStream.Seek(0);
        if (GraphicConverter::Export(aStream, rGraphic, aConvertDestinationFormat) != ERRCODE_NONE)
            SAL_WARN("sw.rtf", "failed to export the graphic");
        pBLIPType = pConvertDestinationBLIPType;
        nSize = aStream.TellEnd();
        pGraphicAry = static_cast<sal_uInt8 const*>(aStream.GetData());
 
        ExportPICT(pFlyFrameFormat, aSize, aRendered, aMapped, rCr, pBLIPType, pGraphicAry, nSize,
                   m_rExport, &m_rExport.Strm(), bWritePicProp, pAttrSet);
    }
 
    if (!pFrame || pFrame->IsInline())
    {
        if (!bIsWMF)
        {
            m_rExport.Strm().WriteOString("}"
                                          "{" OOO_STRING_SVTOOLS_RTF_NONSHPPICT);
 
            aStream.Seek(0);
            if (GraphicConverter::Export(aStream, rGraphic, ConvertDataFormat::WMF) != ERRCODE_NONE)
                SAL_WARN("sw.rtf", "failed to export the graphic");
            pBLIPType = OOO_STRING_SVTOOLS_RTF_WMETAFILE;
            nSize = aStream.TellEnd();
            pGraphicAry = static_cast<sal_uInt8 const*>(aStream.GetData());
 
            ExportPICT(pFlyFrameFormat, aSize, aRendered, aMapped, rCr, pBLIPType, pGraphicAry,
                       nSize, m_rExport, &m_rExport.Strm());
 
            m_rExport.Strm().WriteChar('}');
        }
    }
    else
        m_rExport.Strm().WriteOString("}}}}"); // Close SV, SP, SHPINST and SHP.
 
    m_rExport.Strm().WriteOString(SAL_NEWLINE_STRING);
}
 
void RtfAttributeOutput::BulletDefinition(int /*nId*/, const Graphic& rGraphic, Size aSize)
{
    m_rExport.Strm().WriteOString("{" OOO_STRING_SVTOOLS_RTF_IGNORE OOO_STRING_SVTOOLS_RTF_SHPPICT);
    m_rExport.Strm().WriteOString("{" OOO_STRING_SVTOOLS_RTF_PICT OOO_STRING_SVTOOLS_RTF_PNGBLIP);
 
    m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_PICWGOAL);
    m_rExport.Strm().WriteNumberAsString(aSize.Width());
    m_rExport.Strm().WriteOString(OOO_STRING_SVTOOLS_RTF_PICHGOAL);
    m_rExport.Strm().WriteNumberAsString(aSize.Height());
 
    m_rExport.Strm().WriteOString(SAL_NEWLINE_STRING);
    const sal_uInt8* pGraphicAry = nullptr;
    SvMemoryStream aStream;
    if (GraphicConverter::Export(aStream, rGraphic, ConvertDataFormat::PNG) != ERRCODE_NONE)
        SAL_WARN("sw.rtf", "failed to export the numbering picture bullet");
    sal_uInt32 nSize = aStream.TellEnd();
    pGraphicAry = static_cast<sal_uInt8 const*>(aStream.GetData());
    msfilter::rtfutil::WriteHex(pGraphicAry, nSize, &m_rExport.Strm());
    m_rExport.Strm().WriteOString("}}"); // pict, shppict
}
 
void RtfAttributeOutput::SectionRtlGutter(const SfxBoolItem& rRtlGutter)
{
    if (!rRtlGutter.GetValue())
    {
        return;
    }
 
    m_rExport.Strm().WriteOString(LO_STRING_SVTOOLS_RTF_RTLGUTTER);
}
 
void RtfAttributeOutput::TextLineBreak(const SwFormatLineBreak& rLineBreak)
{
    // Text wrapping break of type:
    m_aStyles.append(LO_STRING_SVTOOLS_RTF_LBR);
    m_aStyles.append(static_cast<sal_Int32>(rLineBreak.GetEnumValue()));
 
    // Write the linebreak itself.
    RunText("\x0b");
}
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */