docxattributeoutput.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_DOCXATTRIBUTEOUTPUT_HXX
#define INCLUDED_SW_SOURCE_FILTER_WW8_DOCXATTRIBUTEOUTPUT_HXX
 
#include <memory>
#include <string_view>
 
#include "attributeoutputbase.hxx"
#include "fields.hxx"
#include <IMark.hxx>
#include "docxexport.hxx"
#include <wrtswtbl.hxx>
#include <redline.hxx>
 
#include <editeng/boxitem.hxx>
#include <sax/fshelper.hxx>
#include <sax/fastattribs.hxx>
#include <vcl/vclenum.hxx>
#include <svx/xenum.hxx>
 
#include <fldbas.hxx>
 
#include <vector>
#include <optional>
#include <o3tl/sorted_vector.hxx>
#include <oox/export/vmlexport.hxx>
#include <oox/export/drawingml.hxx>
#include "docxtablestyleexport.hxx"
 
#include <com/sun/star/table/BorderLine2.hpp>
#include <com/sun/star/drawing/FillStyle.hpp>
 
class SwGrfNode;
class SdrObject;
enum class SvxBoxItemLine;
enum class SwLineBreakClear;
class SwContentControl;
 
namespace docx { class FootnotesList; }
namespace oox::drawingml { class DrawingML; }
 
struct FieldInfos
{
    std::shared_ptr<const SwField> pField;
    const ::sw::mark::IFieldmark* pFieldmark;
    ww::eField  eType;
    bool        bOpen;
    bool        bSep;
    bool        bClose;
    OUString    sCmd;
    FieldInfos()
        : pFieldmark(nullptr), eType(ww::eUNKNOWN)
        , bOpen(false), bSep(false), bClose(false)
    {}
};
 
enum DocxColBreakStatus
{
    COLBRK_NONE,
    COLBRK_POSTPONE,
    COLBRK_WRITEANDPOSTPONE,
    COLBRK_WRITE
};
 
struct OutputBorderOptions
{
    sal_Int32           tag = 0;
    bool                bUseStartEnd = false;
    bool                bWriteTag = true;
    bool                bWriteDistance = false;
    SvxShadowLocation   aShadowLocation = SvxShadowLocation::NONE;
    std::shared_ptr<editeng::WordBorderDistances> pDistances;
};
 
struct DocxTableExportContext;
 
struct TableReference
{
    bool m_bTableCellOpen;
 
    bool m_bTableCellParaSdtOpen;
 
    sal_uInt32 m_nTableDepth;
 
    TableReference()
        : m_bTableCellOpen(false),
        m_bTableCellParaSdtOpen(false),
        m_nTableDepth(0)
    {
    }
};
 
class FramePrHelper
{
    ww8::Frame* m_pFrame;
    sal_Int32 m_nTableDepth;
    bool m_bUseFrameBorders;
    bool m_bUseFrameBackground;
    bool m_bUseFrameTextDirection;
 
public:
    FramePrHelper()
        : m_pFrame(nullptr)
        , m_nTableDepth(0)
        , m_bUseFrameBorders(true)
        , m_bUseFrameBackground(true)
        , m_bUseFrameTextDirection(true)
    {}
 
    ww8::Frame* Frame() { return m_pFrame; }
    void SetFrame(ww8::Frame* pSet, sal_Int32 nTableDepth = -1);
    bool UseFrameBorders(sal_Int32 nTableDepth);
    void SetUseFrameBorders(bool bSet) { m_bUseFrameBorders = bSet; }
    bool UseFrameBackground();
    void SetUseFrameBackground(bool bSet) { m_bUseFrameBackground = bSet; }
    bool UseFrameTextDirection(sal_Int32 nTableDepth);
    void SetUseFrameTextDirection(bool bSet) { m_bUseFrameTextDirection = bSet; }
};
 
class SdtBlockHelper
{
public:
    SdtBlockHelper()
        : m_nId(0)
        , m_bStartedSdt(false)
        , m_bShowingPlaceHolder(false)
        , m_nTabIndex(0)
        , m_nSdtPrToken(0)
    {}
 
    sal_Int32 m_nId;
    bool m_bStartedSdt;
    rtl::Reference<sax_fastparser::FastAttributeList> m_pTokenChildren;
    rtl::Reference<sax_fastparser::FastAttributeList> m_pTokenAttributes;
    rtl::Reference<sax_fastparser::FastAttributeList> m_pTextAttrs;
    rtl::Reference<sax_fastparser::FastAttributeList> m_pDataBindingAttrs;
    OUString m_aColor;
    OUString m_aAppearance;
    OUString m_aPlaceHolderDocPart;
    bool m_bShowingPlaceHolder;
    OUString m_aAlias;
    OUString m_aTag;
    sal_Int32 m_nTabIndex;
    OUString m_aLock;
    sal_Int32 m_nSdtPrToken;
 
    void DeleteAndResetTheLists();
 
    void WriteSdtBlock(const ::sax_fastparser::FSHelperPtr& pSerializer, bool bRunTextIsOn, bool bParagraphHasDrawing);
    void WriteExtraParams(const ::sax_fastparser::FSHelperPtr& pSerializer);
 
    void EndSdtBlock(const ::sax_fastparser::FSHelperPtr& pSerializer);
 
    void GetSdtParamsFromGrabBag(const uno::Sequence<beans::PropertyValue>& aGrabBagSdt);
};
 
class DocxAttributeOutput : public AttributeOutputBase, public oox::vml::VMLTextExport, public oox::drawingml::DMLTextExport
{
public:
    virtual void RTLAndCJKState( bool bIsRTL, sal_uInt16 nScript ) override;
 
    virtual sal_Int32 StartParagraph(ww8::WW8TableNodeInfo::Pointer_t pTextNodeInfo,
                                     bool bGenerateParaId) override;
 
    virtual void EndParagraph( ww8::WW8TableNodeInfoInner::Pointer_t pTextNodeInfoInner ) override;
 
    virtual void EmptyParagraph() override;
 
    virtual void SectionBreaks(const SwNode& rNode) override;
 
    virtual void StartParagraphProperties() override;
 
    virtual void EndParagraphProperties(const SfxItemSet& rParagraphMarkerProperties, const SwRedlineData* pRedlineData, const SwRedlineData* pRedlineParagraphMarkerDeleted, const SwRedlineData* pRedlineParagraphMarkerInserted) override;
 
    virtual void StartRun( const SwRedlineData* pRedlineData, sal_Int32 nPos, bool bSingleEmptyRun = false ) override;
 
    virtual void EndRun(const SwTextNode* pNode, sal_Int32 nPos, sal_Int32 nLen, bool bLastRun = false) override;
 
    virtual void StartRunProperties() override;
 
    virtual void EndRunProperties( const SwRedlineData* pRedlineData ) override;
 
    virtual bool FootnoteEndnoteRefTag() override;
 
    virtual void SectFootnoteEndnotePr() override;
 
    virtual void WritePostitFieldReference() override;
 
    virtual void RunText( const OUString& rText, rtl_TextEncoding eCharSet = RTL_TEXTENCODING_UTF8, const OUString& rSymbolFont = OUString() ) override;
 
    virtual void RawText(const OUString& rText, rtl_TextEncoding eCharSet) override;
 
    virtual void StartRuby( const SwTextNode& rNode, sal_Int32 nPos, const SwFormatRuby& rRuby ) override;
 
    virtual void EndRuby(const SwTextNode& rNode, sal_Int32 nPos) override;
 
    virtual bool StartURL( const OUString& rUrl, const OUString& rTarget ) override;
 
    virtual bool EndURL(bool) override;
 
    virtual void FieldVanish(const OUString& rText, ww::eField eType, OUString const*) override;
 
    virtual void Redline( const SwRedlineData* pRedline ) override;
 
    void StartRedline( const SwRedlineData * pRedlineData, bool bLastRun );
 
    void EndRedline( const SwRedlineData * pRedlineData, bool bLastRun );
 
    virtual void SetStateOfFlyFrame( FlyProcessingState nStateOfFlyFrame ) override;
    virtual void SetAnchorIsLinkedToNode( bool bAnchorLinkedToNode ) override;
    virtual bool IsFlyProcessingPostponed() override;
    virtual void ResetFlyProcessingFlag() override;
 
    virtual void FormatDrop( const SwTextNode& rNode, const SwFormatDrop& rSwFormatDrop, sal_uInt16 nStyle, ww8::WW8TableNodeInfo::Pointer_t pTextNodeInfo, ww8::WW8TableNodeInfoInner::Pointer_t pTextNodeInfoInner ) override;
 
    virtual void ParagraphStyle( sal_uInt16 nStyle ) override;
 
    virtual void TableInfoCell( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner ) override;
    virtual void TableInfoRow( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner ) override;
    virtual void TableDefinition( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner ) override;
    virtual void TableDefaultBorders( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner ) override;
    void TableDefaultCellMargins( ww8::WW8TableNodeInfoInner::Pointer_t const & pTableTextNodeInfoInner );
    virtual void TableBackgrounds( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner ) override;
    virtual void TableRowRedline( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner ) override;
    virtual void TableCellRedline( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner ) override;
    virtual void TableHeight( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner ) override;
    virtual void TableCanSplit( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner ) override;
    virtual void TableBidi( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner ) override;
    virtual void TableVerticalCell( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner ) override;
    virtual void TableNodeInfoInner( ww8::WW8TableNodeInfoInner::Pointer_t pNodeInfoInner ) override;
    virtual void TableOrientation( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner ) override;
    virtual void TableSpacing( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner ) override;
    virtual void TableRowEnd( sal_uInt32 nDepth ) override;
 
    virtual void StartStyles() override;
 
    virtual void EndStyles( sal_uInt16 nNumberOfStyles ) override;
 
    virtual void DefaultStyle() override;
 
    void DocDefaults( );
 
    void LatentStyles();
 
    void OutputDefaultItem(const SfxPoolItem& rHt);
 
    virtual 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;
 
    virtual void EndStyle() override;
 
    virtual void StartStyleProperties( bool bParProp, sal_uInt16 nStyle ) override;
 
    virtual void EndStyleProperties( bool bParProp ) override;
 
    virtual void OutlineNumbering(sal_uInt8 nLvl) override;
 
    virtual void PageBreakBefore( bool bBreak ) override;
 
    virtual void SectionBreak( sal_uInt8 nC, bool bBreakAfter, const WW8_SepInfo* pSectionInfo = nullptr, bool bExtraPageBreak = false ) override;
 
    // preserve DOCX page vertical alignment
    virtual void TextVerticalAdjustment( const css::drawing::TextVerticalAdjust ) override;
 
    virtual void StartSection() override;
 
    virtual void EndSection() override;
 
    virtual void SectionFormProtection( bool bProtected ) override;
 
    virtual void SectionLineNumbering( sal_uLong nRestartNo, const SwLineNumberInfo& rLnNumInfo ) override;
 
    virtual void SectionTitlePage() override;
 
    virtual void SectionPageBorders( const SwFrameFormat* pFormat, const SwFrameFormat* pFirstPageFormat ) override;
 
    virtual void SectionBiDi( bool bBiDi ) override;
 
    virtual void SectionPageNumbering( sal_uInt16 nNumType, const ::std::optional<sal_uInt16>& oPageRestartNumber ) override;
 
    virtual void SectionType( sal_uInt8 nBreakCode ) override;
 
    void StartFont( const OUString& rFamilyName ) const;
 
    void EndFont() const;
 
    void FontAlternateName( const OUString& rName ) const;
 
    void FontCharset( sal_uInt8 nCharSet, rtl_TextEncoding nEncoding ) const;
 
    void FontFamilyType( FontFamily eFamily ) const;
 
    void FontPitchType( FontPitch ePitch ) const;
 
    void EmbedFont( std::u16string_view name, FontFamily family, FontPitch pitch );
 
    virtual void NumberingDefinition( sal_uInt16 nId, const SwNumRule &rRule ) override;
 
    virtual void OverrideNumberingDefinition( SwNumRule const& rRule,
            sal_uInt16 nNum, sal_uInt16 nAbstractNum,
            const std::map< size_t, size_t > & rLevelOverrides ) override;
 
    virtual void StartAbstractNumbering( sal_uInt16 nId ) override;
 
    virtual void EndAbstractNumbering() override;
 
    virtual 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,
        bool isLegal ) override;
 
    void WriteField_Impl(const SwField* pField, ww::eField eType,
            const OUString& rFieldCmd, FieldFlags nMode,
            OUString const* pBookmarkName = nullptr);
    void WriteFormData_Impl( const ::sw::mark::IFieldmark& rFieldmark );
 
    void WriteBookmarks_Impl( std::vector< OUString >& rStarts, std::vector< OUString >& rEnds, const SwRedlineData* pRedlineData = nullptr );
    void WriteFinalBookmarks_Impl( std::vector< OUString >& rStarts, std::vector< OUString >& rEnds );
    void WriteAnnotationMarks_Impl( std::vector< OUString >& rStarts, std::vector< OUString >& rEnds );
    void EndParaSdtBlock();
 
    void WriteFloatingTable(ww8::Frame const* pParentFrame);
 
private:
    void InitCollectedParagraphProperties();
 
    void WriteCollectedParagraphProperties();
 
    void InitCollectedRunProperties();
 
    void WriteCollectedRunProperties();
 
    void FlyFrameGraphic( const SwGrfNode* pGrfNode, const Size& rSize, const SwFlyFrameFormat* pOLEFrameFormat, SwOLENode* pOLENode, const SdrObject* pSdrObj = nullptr);
    void WriteSrcRect(const css::uno::Reference<css::beans::XPropertySet>& xShapePropSet,
                      const SwFrameFormat* pFrameFormat);
    void WriteOLE2Obj( const SdrObject* pSdrObj, SwOLENode& rNode, const Size& rSize, const SwFlyFrameFormat* pFlyFrameFormat, const sal_Int8 nFormulaAlignment);
    bool WriteOLEChart( const SdrObject* pSdrObj, const Size& rSize, const SwFlyFrameFormat* pFlyFrameFormat);
    bool WriteOLEMath( const SwOLENode& rNode, const sal_Int8 nAlign );
    void PostponeOLE( SwOLENode& rNode, const Size& rSize, const SwFlyFrameFormat* pFlyFrameFormat );
    void WriteOLE( SwOLENode& rNode, const Size& rSize, const SwFlyFrameFormat* rFlyFrameFormat );
    void WriteOLEShape(const SwFlyFrameFormat& rFrameFormat, const Size& rSize,
                       std::string_view rShapeId, const OUString& rImageId);
    static OString GetOLEStyle(const SwFlyFrameFormat& rFormat, const Size& rSize);
    void ExportOLESurround(const SwFormatSurround& rWrap);
 
    void WriteActiveXControl(const SdrObject* pObject, const SwFrameFormat& rFrameFormat, bool bInsideRun);
    bool ExportAsActiveXControl(const SdrObject* pObject) const;
 
    void InitTableHelper( ww8::WW8TableNodeInfoInner::Pointer_t const & pTableTextNodeInfoInner );
    void StartTable( ww8::WW8TableNodeInfoInner::Pointer_t const & pTableTextNodeInfoInner );
    void StartTableRow( ww8::WW8TableNodeInfoInner::Pointer_t const & pTableTextNodeInfoInner );
    void StartTableCell( ww8::WW8TableNodeInfoInner::Pointer_t const & pTableTextNodeInfoInner, sal_uInt32 nCell, sal_uInt32 nRow );
    void TableCellProperties( ww8::WW8TableNodeInfoInner::Pointer_t const & pTableTextNodeInfoInner, sal_uInt32 nCell, sal_uInt32 nRow );
    void EndTableCell( sal_uInt32 nCell );
    void EndTableRow( );
    void EndTable();
    void SyncNodelessCells(ww8::WW8TableNodeInfoInner::Pointer_t const & pInner, sal_Int32 nCell, sal_uInt32 nRow);
    void PopulateFrameProperties(const SwFrameFormat* pFrameFormat, const Size& rSize);
    static bool TextBoxIsFramePr(const SwFrameFormat& rFrameFormat);
    void FinishTableRowCell( ww8::WW8TableNodeInfoInner::Pointer_t const & pInner, bool bForceEmptyParagraph = false );
 
    void WriteFFData( const FieldInfos& rInfos );
    void WritePendingPlaceholder();
 
    void EmbedFontStyle( std::u16string_view name, int tag, FontFamily family, FontItalic italic, FontWeight weight,
        FontPitch pitch );
 
    static OString TransHighlightColor( sal_uInt8 nIco );
protected:
 
    virtual void OutputFlyFrame_Impl( const ww8::Frame& rFormat, const Point& rNdTopLeft ) override;
 
    virtual void CharCaseMap( const SvxCaseMapItem& rCaseMap ) override;
 
    virtual void CharColor( const SvxColorItem& rColor) override;
 
    virtual void CharContour( const SvxContourItem& rContour ) override;
 
    virtual void CharCrossedOut( const SvxCrossedOutItem& rCrossedOut ) override;
 
    virtual void CharEscapement( const SvxEscapementItem& rEscapement ) override;
 
    virtual void CharFont( const SvxFontItem& rFont ) override;
 
    virtual void CharFontSize( const SvxFontHeightItem& rFontSize ) override;
 
    virtual void CharKerning( const SvxKerningItem& rKerning ) override;
 
    virtual void CharLanguage( const SvxLanguageItem& rLanguage ) override;
 
    virtual void CharPosture( const SvxPostureItem& rPosture ) override;
 
    virtual void CharShadow( const SvxShadowedItem& rShadow ) override;
 
    virtual void CharUnderline( const SvxUnderlineItem& rUnderline ) override;
 
    virtual void CharWeight( const SvxWeightItem& rWeight ) override;
 
    virtual void CharAutoKern( const SvxAutoKernItem& ) override;
 
    virtual void CharAnimatedText( const SvxBlinkItem& rBlink ) override;
 
    virtual void CharBackground( const SvxBrushItem& rBrush ) override;
 
    virtual void CharFontCJK( const SvxFontItem& rFont ) override;
 
    virtual void CharFontSizeCJK( const SvxFontHeightItem& rFontSize ) override { CharFontSize( rFontSize ); }
 
    virtual void CharLanguageCJK( const SvxLanguageItem& rLanguageItem ) override { CharLanguage( rLanguageItem ); }
 
    virtual void CharPostureCJK( const SvxPostureItem& rPosture ) override;
 
    virtual void CharWeightCJK( const SvxWeightItem& rWeight ) override;
 
    virtual void CharFontCTL( const SvxFontItem& rFont ) override;
 
    virtual void CharFontSizeCTL( const SvxFontHeightItem& rFontSize ) override { CharFontSize( rFontSize ); }
 
    virtual void CharLanguageCTL( const SvxLanguageItem& rLanguageItem ) override { CharLanguage( rLanguageItem); }
 
    virtual void CharPostureCTL( const SvxPostureItem& rWeight ) override;
 
    virtual void CharWeightCTL( const SvxWeightItem& rWeight ) override;
 
    virtual void CharBidiRTL( const SfxPoolItem& ) override;
 
    virtual void CharIdctHint( const SfxPoolItem& ) override;
 
    virtual void CharRotate( const SvxCharRotateItem& rRotate ) override;
 
    virtual void CharEmphasisMark( const SvxEmphasisMarkItem& rEmphasisMark ) override;
 
    virtual void CharTwoLines( const SvxTwoLinesItem& rTwoLines ) override;
 
    virtual void CharScaleWidth( const SvxCharScaleWidthItem& rScaleWidth ) override;
 
    virtual void CharRelief( const SvxCharReliefItem& rRelief) override;
 
    virtual void CharHidden( const SvxCharHiddenItem& rHidden ) override;
 
    virtual void CharBorder( const ::editeng::SvxBorderLine* pAllBorder, const sal_uInt16 nDist, const bool bShadow ) override;
 
    virtual void CharHighlight( const SvxBrushItem& rHighlight ) override;
 
    virtual void TextINetFormat( const SwFormatINetFormat& ) override;
 
    virtual void TextCharFormat( const SwFormatCharFormat& ) override;
 
    virtual void TextFootnote_Impl( const SwFormatFootnote& ) override;
 
    void FootnoteEndnoteReference();
 
    virtual void ParaLineSpacing_Impl( short nSpace, short nMulti ) override;
 
    virtual void ParaAdjust( const SvxAdjustItem& rAdjust ) override;
 
    virtual void ParaSplit( const SvxFormatSplitItem& rSplit ) override;
 
    virtual void ParaWidows( const SvxWidowsItem& rWidows ) override;
 
    virtual void ParaTabStop( const SvxTabStopItem& rTabStop ) override;
 
    virtual void ParaHyphenZone( const SvxHyphenZoneItem& ) override;
 
    virtual void ParaNumRule_Impl( const SwTextNode *pTextNd, sal_Int32 nLvl, sal_Int32 nNumId ) override;
 
    virtual void ParaScriptSpace( const SfxBoolItem& ) override;
 
    virtual void ParaHangingPunctuation( const SfxBoolItem& ) override;
 
    virtual void ParaForbiddenRules( const SfxBoolItem& ) override;
 
    virtual void ParaVerticalAlign( const SvxParaVertAlignItem& rAlign ) override;
 
    virtual void ParaSnapToGrid( const SvxParaGridItem& ) override;
 
    virtual void FormatFrameSize( const SwFormatFrameSize& ) override;
 
    virtual void FormatPaperBin( const SvxPaperBinItem& ) override;
 
    virtual void FormatFirstLineIndent(const SvxFirstLineIndentItem & rFirstLine) override;
    virtual void FormatTextLeftMargin(const SvxTextLeftMarginItem & rTextLeftMargin) override;
    virtual void FormatRightMargin(const SvxRightMarginItem & rRightMargin) override;
 
    virtual void FormatLRSpace( const SvxLRSpaceItem& rLRSpace ) override;
 
    virtual void FormatULSpace( const SvxULSpaceItem& rULSpace ) override;
 
    virtual void FormatSurround( const SwFormatSurround& ) override;
 
    virtual void FormatVertOrientation( const SwFormatVertOrient& ) override;
 
    virtual void FormatHorizOrientation( const SwFormatHoriOrient& ) override;
 
    virtual void FormatAnchor( const SwFormatAnchor& ) override;
 
    virtual void FormatBackground( const SvxBrushItem& ) override;
 
    virtual void FormatFillStyle( const XFillStyleItem& ) override;
 
    virtual void FormatFillGradient( const XFillGradientItem& ) override;
 
    virtual void FormatBox( const SvxBoxItem& ) override;
 
    virtual void FormatColumns_Impl( sal_uInt16 nCols, const SwFormatCol & rCol, bool bEven, SwTwips nPageSize ) override;
 
    virtual void FormatKeep( const SvxFormatKeepItem& ) override;
 
    virtual void FormatTextGrid( const SwTextGridItem& ) override;
 
    virtual void FormatLineNumbering( const SwFormatLineNumber& ) override;
 
    virtual void FormatFrameDirection( const SvxFrameDirectionItem& ) override;
 
    virtual void ParaGrabBag( const SfxGrabBagItem& ) override;
 
    virtual void CharGrabBag( const SfxGrabBagItem& ) override;
 
    // Sfx item RES_PARATR_OUTLINELEVEL
    virtual void ParaOutlineLevel( const SfxUInt16Item& ) override;
 
    virtual void WriteExpand( const SwField* pField ) override;
 
    virtual void RefField( const SwField& rField, const OUString& rRef ) override;
    virtual void HiddenField( const SwField& rField ) override;
    virtual void SetField( const SwField& rField, ww::eField eType, const OUString& rCmd ) override;
    virtual void PostitField( const SwField* pField ) override;
    virtual bool DropdownField( const SwField* pField ) override;
    virtual bool PlaceholderField( const SwField* pField ) override;
 
    virtual bool AnalyzeURL( const OUString& rURL, const OUString& rTarget, OUString* pLinkURL, OUString* pMark ) override;
 
    virtual void WriteBookmarkInActParagraph( const OUString& rName, sal_Int32 nFirstRunPos, sal_Int32 nLastRunPos ) override;
 
    void SectionRtlGutter( const SfxBoolItem& rRtlGutter) override;
 
    void TextLineBreak(const SwFormatLineBreak& rLineBreak) override;
 
    void WriteLineBreak();
 
private:
 
    void DoWriteBookmarkTagStart(std::u16string_view bookmarkName);
    void DoWriteBookmarkTagEnd(sal_Int32 nId);
    void DoWriteMoveRangeTagStart(std::u16string_view bookmarkName,
            bool bFrom, const SwRedlineData* pRedlineData);
    void DoWriteMoveRangeTagEnd(sal_Int32 nId, bool bFrom);
    void DoWriteBookmarksStart(std::vector<OUString>& rStarts, const SwRedlineData* pRedlineData = nullptr);
    void DoWriteBookmarksEnd(std::vector<OUString>& rEnds);
    void DoWriteBookmarkStartIfExist(sal_Int32 nRunPos);
    void DoWriteBookmarkEndIfExist(sal_Int32 nRunPos);
 
    void DoWritePermissionTagStart(std::u16string_view permission);
    void DoWritePermissionTagEnd(std::u16string_view permission);
    void DoWritePermissionsStart();
    void DoWritePermissionsEnd();
 
    void DoWriteAnnotationMarks( );
    void WritePostponedGraphic();
    void WritePostponedMath(const SwOLENode* pObject, sal_Int8 /*nAlign*/);
    void WritePostponedFormControl(const SdrObject* pObject);
    void WritePostponedActiveXControl(bool bInsideRun);
    void WritePostponedDiagram();
    void WritePostponedChart();
    void WritePostponedOLE();
    void WritePostponedDMLDrawing();
    void WritePostponedCustomShape();
    void WriteFlyFrame(const ww8::Frame& rFrame);
 
    void WriteFormDateStart(const OUString& sFullDate, const OUString& sDateFormat, const OUString& sLang, const uno::Sequence<beans::PropertyValue>& aGrabBagSdt);
    void WriteSdtPlainText(const OUString& sValue, const uno::Sequence<beans::PropertyValue>& aGrabBagSdt);
    void WriteSdtDropDownStart(const OUString& rName, OUString const& rSelected, uno::Sequence<OUString> const& rListItems);
    void WriteSdtDropDownEnd(OUString const& rSelected, uno::Sequence<OUString> const& rListItems);
    void WriteContentControlStart();
    void WriteContentControlEnd();
 
    void StartField_Impl( const SwTextNode* pNode, sal_Int32 nPos, FieldInfos const & rInfos, bool bWriteRun = false );
    void DoWriteCmd( std::u16string_view rCmd );
    void CmdField_Impl( const SwTextNode* pNode, sal_Int32 nPos, FieldInfos const & rInfos, bool bWriteRun );
    void CmdEndField_Impl( const SwTextNode* pNode, sal_Int32 nPos, bool bWriteRun );
    void EndField_Impl( const SwTextNode* pNode, sal_Int32 nPos, FieldInfos& rInfos );
    void DoWriteFieldRunProperties( const SwTextNode* pNode, sal_Int32 nPos, bool bWriteCombChars = false );
 
    DocxExport &m_rExport;
 
    ::sax_fastparser::FSHelperPtr m_pSerializer;
 
    oox::drawingml::DrawingML &m_rDrawingML;
 
    rtl::Reference<sax_fastparser::FastAttributeList> m_pFontsAttrList;
    rtl::Reference<sax_fastparser::FastAttributeList> m_pEastAsianLayoutAttrList;
    rtl::Reference<sax_fastparser::FastAttributeList> m_pCharLangAttrList;
    rtl::Reference<sax_fastparser::FastAttributeList> m_pSectionSpacingAttrList;
    rtl::Reference<sax_fastparser::FastAttributeList> m_pLRSpaceAttrList;
    rtl::Reference<sax_fastparser::FastAttributeList> m_pParagraphSpacingAttrList;
    rtl::Reference<sax_fastparser::FastAttributeList> m_pHyperlinkAttrList;
    std::shared_ptr<SwContentControl> m_pContentControl;
    bool m_bEndCharSdt;
    rtl::Reference<sax_fastparser::FastAttributeList> m_pColorAttrList;
    sal_uInt8 m_nCharTransparence = 0;
    rtl::Reference<sax_fastparser::FastAttributeList> m_pBackgroundAttrList;
    OUString m_sOriginalBackgroundColor;
    OUString m_hyperLinkAnchor;
    bool m_endPageRef;
    std::unique_ptr<docx::FootnotesList> m_pFootnotesList;
    std::unique_ptr<docx::FootnotesList> m_pEndnotesList;
    int m_footnoteEndnoteRefTag;
    OUString m_footnoteCustomLabel;
    std::unique_ptr< const WW8_SepInfo > m_pSectionInfo;
 
    const SwRedlineData *m_pRedlineData;
 
    sal_Int32 m_nRedlineId;
 
    bool m_bOpenedSectPr;
    bool m_bHadSectPr;
 
    bool m_bRunTextIsOn;
 
    bool m_bWritingHeaderFooter;
    bool m_bAnchorLinkedToNode;
 
    bool m_bWritingField;
 
    bool m_bPreventDoubleFieldsHandling;
    std::vector< FieldInfos > m_Fields;
    OUString m_sFieldBkm;
    sal_Int32 m_nNextBookmarkId;
    sal_Int32 m_nNextAnnotationMarkId;
 
    sal_Int32 m_nNextParaId = 1; // MUST be greater than 0
 
    OUString m_sRawText;
 
    sal_uInt32 m_nEmbedFlyLevel;
 
    std::vector<ww8::Frame> m_vPostponedFlys;
 
    std::vector<OUString> m_rBookmarksStart;
    std::vector<OUString> m_rBookmarksEnd;
    SwRedlineData* m_pMoveRedlineData;
 
    std::vector<OUString> m_rFinalBookmarksStart;
    std::vector<OUString> m_rFinalBookmarksEnd;
 
    std::multimap<sal_Int32, OUString> m_aBookmarksOfParagraphStart;
    std::multimap<sal_Int32, OUString> m_aBookmarksOfParagraphEnd;
 
    std::vector<OUString> m_rPermissionsStart;
    std::vector<OUString> m_rPermissionsEnd;
 
    std::vector<OUString> m_rAnnotationMarksStart;
    std::vector<OUString> m_rAnnotationMarksEnd;
 
    std::map<OUString, sal_Int32> m_rOpenedBookmarksIds;
 
    OUString m_sLastOpenedBookmark;
 
    std::unordered_set<sal_Int32> m_rSavedBookmarksIds;
 
    std::map<OUString, sal_Int32> m_rOpenedAnnotationMarksIds;
 
    OUString m_sLastOpenedAnnotationMark;
 
    std::map<OUString, std::vector<OUString> > m_aSeqBookmarksNames;
 
    std::vector<css::beans::PropertyValue> m_aTextEffectsGrabBag;
 
    std::unique_ptr<SwWriteTable> m_xTableWrt;
 
    FramePrHelper m_aFramePr;
 
    bool m_bParagraphOpened;
    bool m_bParagraphFrameOpen;
    bool m_bIsFirstParagraph;
    bool m_bAlternateContentChoiceOpen;
    bool m_bPostponedProcessingFly;
 
    // Remember that a column break has to be opened at the
    // beginning of the next paragraph
    DocxColBreakStatus m_nColBreakStatus;
 
    // Remember that a page break has to be opened at the
    // beginning of the next paragraph
    bool m_bPostponedPageBreak;
 
    // This paragraph must end with page break
    bool m_bPageBreakAfter = false;
 
    std::stack< std::vector<ww8::Frame> > m_aFramesOfParagraph;
    o3tl::sorted_vector<const SwFrameFormat*> m_aFloatingTablesOfParagraph;
    sal_Int32 m_nTextFrameLevel;
 
    // close of hyperlink needed
    bool m_closeHyperlinkInThisRun;
    bool m_closeHyperlinkInPreviousRun;
    // Count nested HyperLinks
    std::vector<sal_Int32> m_nHyperLinkCount;
    sal_Int16 m_nFieldsInHyperlink;
 
    // If the exported numbering rule defines the outlines
    bool m_bExportingOutline;
 
    struct PostponedGraphic
    {
        PostponedGraphic( const SwGrfNode* n, Size s, const SdrObject* sObj )
            : grfNode( n ), size( s ), pSdrObj(sObj) {};
 
        const SwGrfNode* grfNode;
        Size size;
        const SdrObject* pSdrObj;
    };
    std::optional< std::vector<PostponedGraphic> > m_oPostponedGraphic;
    struct PostponedDiagram
    {
        PostponedDiagram( const SdrObject* o, const SwFrameFormat* frm ) : object( o ), frame( frm ) {};
        const SdrObject* object;
        const SwFrameFormat* frame;
    };
    std::optional< std::vector<PostponedDiagram> > m_oPostponedDiagrams;
 
    struct PostponedDrawing
    {
        PostponedDrawing( const SdrObject* sdrObj, const SwFrameFormat* frm) : object( sdrObj ), frame( frm ) {};
        const SdrObject* object;
        const SwFrameFormat* frame;
    };
    std::optional< std::vector<PostponedDrawing> > m_oPostponedDMLDrawings;
    std::optional< std::vector<PostponedDrawing> > m_oPostponedCustomShape;
 
    struct PostponedOLE
    {
        PostponedOLE( SwOLENode* rObject, const Size& rSize, const SwFlyFrameFormat* rFrame ) : object( rObject ), size( rSize ), frame( rFrame ) {};
        SwOLENode* object;
        const Size size;
        const SwFlyFrameFormat* frame;
    };
    std::optional< std::vector<PostponedOLE> > m_oPostponedOLEs;
 
    struct PostponedMathObjects
    {
        SwOLENode* pMathObject;
        sal_Int8 nMathObjAlignment;
    };
    std::vector<PostponedMathObjects> m_aPostponedMaths;
    unsigned int m_nChartCount;
    struct PostponedChart
    {
        PostponedChart( const SdrObject* sdrObject, const Size& rSize, const SwFlyFrameFormat* rFrame ) : object(sdrObject), size(rSize), frame(rFrame) {};
        const SdrObject* object;
        const Size size;
        const SwFlyFrameFormat* frame;
    };
    std::vector<PostponedChart> m_aPostponedCharts;
    std::vector<const SdrObject*> m_aPostponedFormControls;
    std::vector<PostponedDrawing> m_aPostponedActiveXControls;
    const SwField* m_PendingPlaceholder;
 
    enum class ParentStatus
    {
        None,
        IsParent,
        HasParent
    };
    struct PostItDOCXData{
        sal_Int32 id;
        sal_Int32 lastParaId = 0; // [MS-DOCX] 2.5.3.1 CT_CommentEx needs paraId attribute
        ParentStatus parentStatus = ParentStatus::None;
        size_t parentIndex = 0;
    };
    std::vector<std::pair<const SwPostItField*, PostItDOCXData>> m_postitFields;
    unsigned int m_postitFieldsMaxId;
    int m_anchorId;
    int m_nextFontId;
    struct EmbeddedFontRef
    {
        OString relId;
        OString fontKey;
    };
 
    TableReference m_tableReference;
 
    std::map< OUString, EmbeddedFontRef > m_FontFilesMap; // font file url to data
 
    // Remember first cell (used for default borders/margins) of each table
    std::vector<ww8::WW8TableNodeInfoInner::Pointer_t> m_TableFirstCells;
    // Remember last open and closed cells on each level
    std::vector<sal_Int32> m_LastOpenCell;
    std::vector<sal_Int32> m_LastClosedCell;
 
    std::optional<css::drawing::FillStyle> m_oFillStyle;
    bool m_bIgnoreNextFill;
 
    editeng::WordPageMargins m_pageMargins;
 
    std::shared_ptr<DocxTableStyleExport> m_pTableStyleExport;
    // flag to check if auto spacing was set in original file
    bool m_bParaBeforeAutoSpacing,m_bParaAfterAutoSpacing;
    // store hardcoded value which was set during import.
    sal_Int32 m_nParaBeforeSpacing,m_nParaAfterSpacing;
 
    SdtBlockHelper m_aParagraphSdt;
    SdtBlockHelper m_aRunSdt;
 
    FlyProcessingState m_nStateOfFlyFrame;
 
    OUString m_aStartedParagraphSdtPrAlias;
 
    std::vector<std::map<SvxBoxItemLine, css::table::BorderLine2>> m_aTableStyleConfs;
 
    std::optional<SwLineBreakClear> m_oLineBreakClear;
 
public:
    DocxAttributeOutput( DocxExport &rExport, const ::sax_fastparser::FSHelperPtr& pSerializer, oox::drawingml::DrawingML* pDrawingML );
 
    virtual ~DocxAttributeOutput() override;
 
    virtual DocxExport& GetExport() override;
    const DocxExport& GetExport() const { return const_cast< DocxAttributeOutput* >( this )->GetExport(); }
 
    void SetSerializer( ::sax_fastparser::FSHelperPtr const & pSerializer );
 
    const ::sax_fastparser::FSHelperPtr& GetSerializer( ) const { return m_pSerializer; }
 
    bool HasFootnotes() const;
 
    bool HasEndnotes() const;
 
    void FootnotesEndnotes( bool bFootnotes );
 
    static void WriteFootnoteEndnotePr( ::sax_fastparser::FSHelperPtr const & fs, int tag, const SwEndNoteInfo& info, int listtag );
 
    bool HasPostitFields() const;
    enum class hasProperties { no, yes };
    hasProperties WritePostitFields();
    void WritePostItFieldsResolved();
 
    virtual void WriteOutliner(const OutlinerParaObject& rParaObj) override;
    virtual void WriteVMLTextBox(css::uno::Reference<css::drawing::XShape> xShape) override;
    virtual void WriteTextBox(css::uno::Reference<css::drawing::XShape> xShape) override;
    virtual css::uno::Reference<css::text::XTextFrame> GetUnoTextFrame(
        css::uno::Reference<css::drawing::XShape> xShape) override;
    virtual oox::drawingml::DrawingML& GetDrawingML() override;
    virtual bool MaybeOutputBrushItem(SfxItemSet const&) override;
 
    void BulletDefinition(int nId, const Graphic& rGraphic, Size aSize) override;
 
    void SetWritingHeaderFooter( bool bWritingHeaderFooter )    {   m_bWritingHeaderFooter = bWritingHeaderFooter;   }
    bool GetWritingHeaderFooter( ) const  {   return m_bWritingHeaderFooter;  }
    void SetAlternateContentChoiceOpen( bool bAltContentChoiceOpen ) { m_bAlternateContentChoiceOpen = bAltContentChoiceOpen; }
    bool IsAlternateContentChoiceOpen( ) const { return m_bAlternateContentChoiceOpen; }
    void GetSdtEndBefore(const SdrObject* pSdrObj);
    bool IsFirstParagraph() const { return m_bIsFirstParagraph; }
 
    void pushToTableExportContext(DocxTableExportContext& rContext);
    void popFromTableExportContext(DocxTableExportContext const & rContext);
 
    static OString convertToOOXMLHoriOrient(sal_Int16 nOrient, bool bIsPosToggle);
    static OString convertToOOXMLVertOrient(sal_Int16 nOrient);
    static OString convertToOOXMLVertOrientRel(sal_Int16 nOrientRel);
    static OString convertToOOXMLHoriOrientRel(sal_Int16 nOrientRel);
    static void ImplCellMargins( sax_fastparser::FSHelperPtr const & pSerializer, const SvxBoxItem& rBox, sal_Int32 tag, bool bUseStartEnd, const SvxBoxItem* pDefaultMargins = nullptr);
    template <class... Args>
    static void AddToAttrList(rtl::Reference<sax_fastparser::FastAttributeList>& pAttrList, Args&&... args)
    {
        if (!pAttrList)
            pAttrList = sax_fastparser::FastSerializerHelper::createAttrList();
        pAttrList->add(std::forward<Args>(args)...);
    }
 
    static const sal_Int32 Tag_StartParagraph_1 = 1;
    static const sal_Int32 Tag_StartParagraph_2 = 2;
    static const sal_Int32 Tag_WriteSdtBlock = 3;
    static const sal_Int32 Tag_StartParagraphProperties = 4;
    static const sal_Int32 Tag_InitCollectedParagraphProperties = 5;
    static const sal_Int32 Tag_StartRun_1 = 6;
    static const sal_Int32 Tag_StartRun_2 = 7;
    static const sal_Int32 Tag_StartRun_3 = 8;
    static const sal_Int32 Tag_EndRun_1 = 9;
    static const sal_Int32 Tag_EndRun_2 = 10;
    static const sal_Int32 Tag_StartRunProperties = 11;
    static const sal_Int32 Tag_InitCollectedRunProperties = 12;
    static const sal_Int32 Tag_Redline_1 = 13;
    static const sal_Int32 Tag_Redline_2 = 14;
    static const sal_Int32 Tag_TableDefinition = 15;
    static const sal_Int32 Tag_OutputFlyFrame = 16;
    static const sal_Int32 Tag_StartSection = 17;
};
 
struct DocxTableExportContext
{
    DocxAttributeOutput& m_rOutput;
    ww8::WW8TableInfo::Pointer_t m_pTableInfo;
    bool m_bTableCellOpen;
    bool m_bStartedParaSdt;
    bool m_bStartedRunSdt;
    sal_uInt32 m_nTableDepth;
    sal_Int32 m_nHyperLinkCount = 0;
    DocxTableExportContext(DocxAttributeOutput& rOutput) : m_rOutput(rOutput) { m_rOutput.pushToTableExportContext(*this); }
    ~DocxTableExportContext() { m_rOutput.popFromTableExportContext(*this); }
};
 
namespace docx {
 
rtl::Reference<sax_fastparser::FastAttributeList> SurroundToVMLWrap(SwFormatSurround const& rSurround);
 
}
 
#endif // INCLUDED_SW_SOURCE_FILTER_WW8_DOCXATTRIBUTEOUTPUT_HXX
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */