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 <editeng/boxitem.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, sal_Int32 nLen,
                bool bLastRun = false) override;
 
    void StartRunProperties() override;
 
    void EndRunProperties(const SwRedlineData* pRedlineData) override;
 
    void RunText(const OUString& rText, rtl_TextEncoding eCharSet = RTL_TEXTENCODING_UTF8,
                 const OUString& rSymbolFont = OUString()) 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 TablePositioning(SwFrameFormat* pFlyFormat);
    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 nSlot,
                    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, //For i120928,to export graphic of bullet
                        bool isLegal) override;
 
    void WriteField_Impl(const SwField* pField, ww::eField eType, std::u16string_view 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;
 
    virtual void FormatFirstLineIndent(const SvxFirstLineIndentItem& rFirstLine) override;
    virtual void FormatTextLeftMargin(const SvxTextLeftMarginItem& rTextLeftMargin) override;
    virtual void FormatRightMargin(const SvxRightMarginItem& rRightMargin) 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;
 
    editeng::WordPageMargins m_aPageMargins;
 
public:
    explicit RtfAttributeOutput(RtfExport& rExport);
 
    ~RtfAttributeOutput() override;
 
    MSWordExportBase& GetExport() override;
 
    // These are used by wwFont::WriteRtf()
    void StartFont(std::u16string_view rFamilyName) const;
 
    void EndFont() const;
 
    void FontAlternateName(std::u16string_view 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: */