rtfattributeoutput.hxx

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 .
 */

#ifndef INCLUDED_SW_SOURCE_FILTER_WW8_RTFATTRIBUTEOUTPUT_HXX
#define INCLUDED_SW_SOURCE_FILTER_WW8_RTFATTRIBUTEOUTPUT_HXX

#include <memory>
#include <com/sun/star/drawing/FillStyle.hpp>

#include "attributeoutputbase.hxx"
#include "rtfstringbuffer.hxx"

#include <wrtswtbl.hxx>

#include <rtl/strbuf.hxx>

#include <optional>

class SwGrfNode;
class SwOLENode;
class SwFlyFrameFormat;
class RtfExport;

class RtfAttributeOutput : public AttributeOutputBase
{
    friend class RtfStringBufferValue;
    friend class SaveRunState;

public:
    void RTLAndCJKState(bool bIsRTL, sal_uInt16 nScript) override;

    sal_Int32 StartParagraph(ww8::WW8TableNodeInfo::Pointer_t pTextNodeInfo,
                             bool bGenerateParaId) override;

    void EndParagraph(ww8::WW8TableNodeInfoInner::Pointer_t pTextNodeInfoInner) override;

    void EmptyParagraph() override;

    void SectionBreaks(const SwNode& rNode) override;

    void StartParagraphProperties() override;

    void EndParagraphProperties(const SfxItemSet& rParagraphMarkerProperties,
                                const SwRedlineData* pRedlineData,
                                const SwRedlineData* pRedlineParagraphMarkerDeleted,
                                const SwRedlineData* pRedlineParagraphMarkerInserted) override;

    void StartRun(const SwRedlineData* pRedlineData, sal_Int32 nPos,
                  bool bSingleEmptyRun = false) override;

    void EndRun(const SwTextNode* pNode, sal_Int32 nPos, bool bLastRun = false) override;

    void StartRunProperties() override;

    void EndRunProperties(const SwRedlineData* pRedlineData) override;

    void RunText(const OUString& rText, rtl_TextEncoding eCharSet = RTL_TEXTENCODING_UTF8) override;

    // Access to (anyway) private buffers, used by the sdr exporter
    OStringBuffer& RunText();
    OString MoveCharacterProperties(bool aAutoWriteRtlLtr = false);

    void RawText(const OUString& rText, rtl_TextEncoding eCharSet) override;

    void StartRuby(const SwTextNode& rNode, sal_Int32 nPos, const SwFormatRuby& rRuby) override;

    void EndRuby(const SwTextNode& rNode, sal_Int32 nPos) override;

    bool StartURL(const OUString& rUrl, const OUString& rTarget) override;

    bool EndURL(bool isAtEndOfParagraph) override;

    void FieldVanish(const OUString& rText, ww::eField eType,
                     OUString const* pBookmarkName) override;

    void Redline(const SwRedlineData* pRedline) override;

    void FormatDrop(const SwTextNode& rNode, const SwFormatDrop& rSwFormatDrop, sal_uInt16 nStyle,
                    ww8::WW8TableNodeInfo::Pointer_t pTextNodeInfo,
                    ww8::WW8TableNodeInfoInner::Pointer_t pTextNodeInfoInner) override;

    void ParagraphStyle(sal_uInt16 nStyle) override;

    void TableInfoCell(ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner) override;
    void TableInfoRow(ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner) override;
    void TableDefinition(ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner) override;
    void
    TableDefaultBorders(ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner) override;
    void TableBackgrounds(ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner) override;
    void TableRowRedline(ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner) override;
    void TableCellRedline(ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner) override;
    void TableHeight(ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner) override;
    void TableCanSplit(ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner) override;
    void TableBidi(ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner) override;
    void TableVerticalCell(ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner) override;
    void TableNodeInfoInner(ww8::WW8TableNodeInfoInner::Pointer_t pNodeInfoInner) override;
    void TableOrientation(ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner) override;
    void TableSpacing(ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner) override;
    void TableRowEnd(sal_uInt32 nDepth) override;

    void StartStyles() override;

    void EndStyles(sal_uInt16 nNumberOfStyles) override;

    void DefaultStyle() override;

    void StartStyle(const OUString& rName, StyleType eType, sal_uInt16 nBase, sal_uInt16 nNext,
                    sal_uInt16 nLink, sal_uInt16 nWwId, sal_uInt16 nId, bool bAutoUpdate) override;

    void EndStyle() override;

    void StartStyleProperties(bool bParProp, sal_uInt16 nStyle) override;

    void EndStyleProperties(bool bParProp) override;

    void OutlineNumbering(sal_uInt8 nLvl) override;

    void PageBreakBefore(bool bBreak) override;

    void SectionBreak(sal_uInt8 nC, bool bBreakAfter, const WW8_SepInfo* pSectionInfo = nullptr,
                      bool bExtraPageBreak = false) override;

    void StartSection() override;

    void EndSection() override;

    void SectionFormProtection(bool bProtected) override;

    void SectionLineNumbering(sal_uLong nRestartNo, const SwLineNumberInfo& rLnNumInfo) override;

    void SectionTitlePage() override;

    void SectionPageBorders(const SwFrameFormat* pFormat,
                            const SwFrameFormat* pFirstPageFormat) override;

    void SectionBiDi(bool bBiDi) override;

    void SectionPageNumbering(sal_uInt16 nNumType,
                              const ::std::optional<sal_uInt16>& oPageRestartNumber) override;

    void SectionType(sal_uInt8 nBreakCode) override;

    void SectFootnoteEndnotePr() override;

    void WriteFootnoteEndnotePr(bool bFootnote, const SwEndNoteInfo& rInfo);

    void NumberingDefinition(sal_uInt16 nId, const SwNumRule& rRule) override;

    void StartAbstractNumbering(sal_uInt16 nId) override;

    void EndAbstractNumbering() override;

    void
    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) override; //For i120928,to export graphic of bullet

    void WriteField_Impl(const SwField* pField, ww::eField eType, const OUString& rFieldCmd,
                         FieldFlags nMode);
    void WriteBookmarks_Impl(std::vector<OUString>& rStarts, std::vector<OUString>& rEnds);
    void WriteAnnotationMarks_Impl(std::vector<OUString>& rStarts, std::vector<OUString>& rEnds);
    void WriteHeaderFooter_Impl(const SwFrameFormat& rFormat, bool bHeader, const char* pStr,
                                bool bTitlepg);
    void WriteBookmarkInActParagraph(const OUString& /*rName*/, sal_Int32 /*nFirstRunPos*/,
                                     sal_Int32 /*nLastRunPos*/) override{};

protected:
    void OutputFlyFrame_Impl(const ww8::Frame& rFrame, const Point& rNdTopLeft) override;

    void CharCaseMap(const SvxCaseMapItem& rCaseMap) override;

    void CharColor(const SvxColorItem& rColor) override;

    void CharContour(const SvxContourItem& rContour) override;

    void CharCrossedOut(const SvxCrossedOutItem& rCrossedOut) override;

    void CharEscapement(const SvxEscapementItem& rEscapement) override;

    void CharFont(const SvxFontItem& rFont) override;

    void CharFontSize(const SvxFontHeightItem& rFontSize) override;

    void CharKerning(const SvxKerningItem& rKerning) override;

    void CharLanguage(const SvxLanguageItem& rLanguage) override;

    void CharPosture(const SvxPostureItem& rPosture) override;

    void CharShadow(const SvxShadowedItem& rShadow) override;

    void CharUnderline(const SvxUnderlineItem& rUnderline) override;

    void CharWeight(const SvxWeightItem& rWeight) override;

    void CharAutoKern(const SvxAutoKernItem& rAutoKern) override;

    void CharAnimatedText(const SvxBlinkItem& rBlink) override;

    void CharBackground(const SvxBrushItem& rBrush) override;

    void CharFontCJK(const SvxFontItem& rFont) override;

    void CharFontSizeCJK(const SvxFontHeightItem& rFontSize) override;

    void CharLanguageCJK(const SvxLanguageItem& rLanguageItem) override;

    void CharPostureCJK(const SvxPostureItem& rPosture) override;

    void CharWeightCJK(const SvxWeightItem& rWeight) override;

    void CharFontCTL(const SvxFontItem& rFont) override;

    void CharFontSizeCTL(const SvxFontHeightItem& rFontSize) override;

    void CharLanguageCTL(const SvxLanguageItem& rLanguageItem) override;

    void CharPostureCTL(const SvxPostureItem& rPosture) override;

    void CharWeightCTL(const SvxWeightItem& rWeight) override;

    void CharBidiRTL(const SfxPoolItem& rItem) override;

    void CharIdctHint(const SfxPoolItem& rItem) override;

    void CharRotate(const SvxCharRotateItem& rRotate) override;

    void CharEmphasisMark(const SvxEmphasisMarkItem& rEmphasisMark) override;

    void CharTwoLines(const SvxTwoLinesItem& rTwoLines) override;

    void CharScaleWidth(const SvxCharScaleWidthItem& rScaleWidth) override;

    void CharRelief(const SvxCharReliefItem& rRelief) override;

    void CharHidden(const SvxCharHiddenItem& rHidden) override;

    void CharBorder(const ::editeng::SvxBorderLine* pAllBorder, sal_uInt16 nDist,
                    bool bShadow) override;

    void CharHighlight(const SvxBrushItem& rBrush) override;

    void TextINetFormat(const SwFormatINetFormat& rURL) override;

    void TextCharFormat(const SwFormatCharFormat& rCharFormat) override;

    void TextFootnote_Impl(const SwFormatFootnote& rFootnote) override;

    void ParaLineSpacing_Impl(short nSpace, short nMulti) override;

    void ParaAdjust(const SvxAdjustItem& rAdjust) override;

    void ParaSplit(const SvxFormatSplitItem& rSplit) override;

    void ParaWidows(const SvxWidowsItem& rWidows) override;

    void ParaTabStop(const SvxTabStopItem& rTabStop) override;

    void ParaHyphenZone(const SvxHyphenZoneItem& rHyphenZone) override;

    void ParaNumRule_Impl(const SwTextNode* pTextNd, sal_Int32 nLvl, sal_Int32 nNumId) override;

    void ParaScriptSpace(const SfxBoolItem& rScriptSpace) override;

    void ParaHangingPunctuation(const SfxBoolItem& rItem) override;

    void ParaForbiddenRules(const SfxBoolItem& rItem) override;

    void ParaVerticalAlign(const SvxParaVertAlignItem& rAlign) override;

    void ParaSnapToGrid(const SvxParaGridItem& rItem) override;

    void FormatFrameSize(const SwFormatFrameSize& rSize) override;

    void FormatPaperBin(const SvxPaperBinItem& rItem) override;

    void FormatLRSpace(const SvxLRSpaceItem& rLRSpace) override;

    void FormatULSpace(const SvxULSpaceItem& rULSpace) override;

    void FormatSurround(const SwFormatSurround& rSurround) override;

    void FormatVertOrientation(const SwFormatVertOrient& rFlyVert) override;

    void FormatHorizOrientation(const SwFormatHoriOrient& rFlyHori) override;

    void FormatAnchor(const SwFormatAnchor& rAnchor) override;

    void FormatBackground(const SvxBrushItem& rBrush) override;

    void FormatFillStyle(const XFillStyleItem& rFillStyle) override;

    void FormatFillGradient(const XFillGradientItem& rFillGradient) override;

    void FormatBox(const SvxBoxItem& rBox) override;

    void FormatColumns_Impl(sal_uInt16 nCols, const SwFormatCol& rCol, bool bEven,
                            SwTwips nPageSize) override;

    void FormatKeep(const SvxFormatKeepItem& rItem) override;

    void FormatTextGrid(const SwTextGridItem& rItem) override;

    void FormatLineNumbering(const SwFormatLineNumber& rNumbering) override;

    void FormatFrameDirection(const SvxFrameDirectionItem& rDirection) override;

    void ParaGrabBag(const SfxGrabBagItem& rItem) override;

    void CharGrabBag(const SfxGrabBagItem& rItem) override;

    void ParaOutlineLevel(const SfxUInt16Item& rItem) override;

    void WriteExpand(const SwField* pField) override;

    void RefField(const SwField& rField, const OUString& rRef) override;
    void HiddenField(const SwField& rField) override;
    void SetField(const SwField& rField, ww::eField eType, const OUString& rCmd) override;
    void PostitField(const SwField* pField) override;
    bool DropdownField(const SwField* pField) override;
    bool PlaceholderField(const SwField* pField) override;

    void SectionRtlGutter(const SfxBoolItem& rRtlGutter) override;

    void TextLineBreak(const SwFormatLineBreak& rLineBreak) override;

private:
    RtfExport& m_rExport;

    OStringBuffer m_aTabStop;

    const SwPageDesc* m_pPrevPageDesc;

    void FlyFrameGraphic(const SwFlyFrameFormat* pFlyFrameFormat, const SwGrfNode* pGrfNode);
    void FlyFrameOLE(const SwFlyFrameFormat* pFlyFrameFormat, SwOLENode& rOLENode,
                     const Size& rSize);
    void FlyFrameOLEReplacement(const SwFlyFrameFormat* pFlyFrameFormat, SwOLENode& rOLENode,
                                const Size& rSize);
    bool FlyFrameOLEMath(const SwFlyFrameFormat* pFlyFrameFormat, SwOLENode& rOLENode,
                         const Size& rSize);

    /*
     * Table methods.
     */
    void InitTableHelper(const ww8::WW8TableNodeInfoInner::Pointer_t& pTableTextNodeInfoInner);
    void StartTable();
    void StartTableRow(const ww8::WW8TableNodeInfoInner::Pointer_t& pTableTextNodeInfoInner);
    void StartTableCell();
    void TableCellProperties(const ww8::WW8TableNodeInfoInner::Pointer_t& pTableTextNodeInfoInner);
    void EndTableCell();
    void EndTableRow();
    void EndTable();

    void FinishTableRowCell(const ww8::WW8TableNodeInfoInner::Pointer_t& pInner);

    void WriteTextFootnoteNumStr(const SwFormatFootnote& rFootnote);

    /*
     * Current style name and its ID.
     */
    OUString m_rStyleName;
    sal_uInt16 m_nStyleId;
    /*
     * Current list ID.
     */
    sal_uInt16 m_nListId;
    /*
     * This is needed because the call order is: run text, run properties, paragraph properties.
     * What we need is the opposite.
     */
    RtfStringBuffer m_aRun;
    RtfStringBuffer m_aRunText;
    /*
     * This is written after runs.
     */
    OStringBuffer m_aAfterRuns;
    /*
     * Same for colors and stylesheets: first we just want to output colors,
     * need to buffer the stylesheet table to output it after the color one.
     */
    OStringBuffer m_aStylesheet;
    /*
     * This one just holds the style commands in the current style.
     */
    OStringBuffer m_aStyles;
    /*
     * This is the same as m_aStyles but the contents of it is Assoc.
     */
    OStringBuffer m_aStylesAssocHich;
    OStringBuffer m_aStylesAssocDbch;
    OStringBuffer m_aStylesAssocRtlch;
    OStringBuffer m_aStylesAssocLtrch;

    bool m_bIsRTL;
    sal_uInt16 m_nScript;
    bool m_bControlLtrRtl;

    sal_Int32 m_nNextAnnotationMarkId;
    sal_Int32 m_nCurrentAnnotationMarkId;
    std::map<OString, sal_Int32> m_rOpenedAnnotationMarksIds;

    /*
     * The current table helper.
     */
    std::unique_ptr<SwWriteTable> m_pTableWrt;

    /*
     * Remember if we are in an open cell, or not.
     */
    bool m_bTableCellOpen;

    /*
     * Remember the current table depth.
     */
    sal_uInt32 m_nTableDepth;

    /*
     * Remember if we wrote a \cell or not.
     */
    bool m_bTableAfterCell;

    /*
     * For late output of row definitions.
     */
    OStringBuffer m_aRowDefs;

    /*
     * Is a column break needed after the next \par?
     */
    bool m_nColBreakNeeded;

    /*
     * If section breaks should be buffered to m_aSectionBreaks
     */
    bool m_bBufferSectionBreaks;
    OStringBuffer m_aSectionBreaks;

    /*
     * If section headers (and footers) should be buffered to
     * m_aSectionHeaders.
     */
    bool m_bBufferSectionHeaders;
    OStringBuffer m_aSectionHeaders;

    /*
     * Support for starting multiple tables at the same cell.
     * If the current table is the last started one.
     */
    bool m_bLastTable;
    /*
     * List of already started but not yet defined tables (need to be defined
     * after the nested tables).
     */
    std::vector<OString> m_aTables;
    /*
     * If cell info is already output.
     */
    bool m_bWroteCellInfo;

    bool m_bTableRowEnded;

    std::map<sal_uInt32, sal_uInt32> m_aCells;

    bool m_bIsBeforeFirstParagraph;

    bool m_bSingleEmptyRun;

    bool m_bInRun;

    bool m_bInRuby;

    std::map<sal_uInt16, const SwPostItField*> m_aPostitFields;

    const Size* m_pFlyFrameSize;

    std::vector<std::pair<OString, OString>> m_aFlyProperties;

    std::optional<css::drawing::FillStyle> m_oFillStyle;

    std::stack<OUString> m_aURLs;

    bool m_bParaBeforeAutoSpacing;
    sal_Int32 m_nParaBeforeSpacing;
    bool m_bParaAfterAutoSpacing;
    sal_Int32 m_nParaAfterSpacing;

public:
    explicit RtfAttributeOutput(RtfExport& rExport);

    ~RtfAttributeOutput() override;

    MSWordExportBase& GetExport() override;

    // These are used by wwFont::WriteRtf()
    void StartFont(const OUString& rFamilyName) const;

    void EndFont() const;

    void FontAlternateName(const OUString& rName) const;

    void FontCharset(sal_uInt8 nCharSet) const;

    void FontFamilyType(FontFamily eFamily, const wwFont& rFont) const;

    void FontPitchType(FontPitch ePitch) const;

    void BulletDefinition(int nId, const Graphic& rGraphic, Size aSize) override;

    void writeTextFrame(const ww8::Frame& rFrame, bool bTextBox = false);

    OStringBuffer& GetTabStop() { return m_aTabStop; }

    const SwPageDesc* GetPrevPageDesc() const { return m_pPrevPageDesc; }
};

#endif // INCLUDED_SW_SOURCE_FILTER_WW8_RTFATTRIBUTEOUTPUT_HXX

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */