xetable.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_SC_SOURCE_FILTER_INC_XETABLE_HXX
#define INCLUDED_SC_SOURCE_FILTER_INC_XETABLE_HXX

#include "xltable.hxx"

#include <vector>
#include "xladdress.hxx"
#include "xerecord.hxx"
#include "xestyle.hxx"
#include "xlformula.hxx"

#include <map>
#include <memory>
#include <unordered_map>
#include <o3tl/sorted_vector.hxx>

class XclExtLst;

/* ============================================================================
Export of cell tables including row and column description.
- Managing all used and formatted cells in a sheet.
- Row and column properties, i.e. width/height, visibility.
- Find default row formatting and default column formatting.
- Merged cell ranges.
============================================================================ */

// Helper records for cell records

class XclExpStringRec : public XclExpRecord
{
public:
    explicit            XclExpStringRec( const XclExpRoot& rRoot, const OUString& rResult );

private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;

private:
    XclExpStringRef     mxResult;
};

// Additional records for special formula ranges

class XclExpRangeFmlaBase : public XclExpRecord
{
public:
    bool                IsBasePos( sal_uInt16 nXclCol, sal_uInt32 nXclRow ) const;

    virtual XclTokenArrayRef CreateCellTokenArray( const XclExpRoot& rRoot ) const = 0;
    virtual bool        IsVolatile() const = 0;

protected:
    explicit            XclExpRangeFmlaBase(
                            sal_uInt16 nRecId, sal_uInt32 nRecSize, const ScAddress& rScPos );
    explicit            XclExpRangeFmlaBase(
                            sal_uInt16 nRecId, sal_uInt32 nRecSize, const ScRange& rScRange );

    void                Extend( const ScAddress& rScPos );

    void                WriteRangeAddress( XclExpStream& rStrm ) const;

protected:
    XclRange            maXclRange;     
    XclAddress          maBaseXclPos;   
};

typedef rtl::Reference< XclExpRangeFmlaBase > XclExpRangeFmlaRef;

// Array formulas =============================================================

class ScTokenArray;

class XclExpArray : public XclExpRangeFmlaBase
{
public:
    explicit            XclExpArray( const XclTokenArrayRef& xTokArr, const ScRange& rScRange );

    virtual XclTokenArrayRef CreateCellTokenArray( const XclExpRoot& rRoot ) const override;
    virtual bool        IsVolatile() const override;

private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;

private:
    XclTokenArrayRef    mxTokArr;       
};

typedef rtl::Reference< XclExpArray > XclExpArrayRef;

class XclExpArrayBuffer : protected XclExpRoot
{
public:
    explicit            XclExpArrayBuffer( const XclExpRoot& rRoot );

    XclExpArrayRef      CreateArray( const ScTokenArray& rScTokArr, const ScRange& rScRange );
    XclExpArrayRef FindArray( const ScTokenArray& rScTokArr, const ScAddress& rBasePos ) const;

private:
    typedef ::std::map< ScAddress, XclExpArrayRef > XclExpArrayMap;
    XclExpArrayMap      maRecMap;       
};

// Shared formulas ============================================================

class XclExpShrfmla : public XclExpRangeFmlaBase
{
public:
    explicit            XclExpShrfmla( const XclTokenArrayRef& xTokArr, const ScAddress& rScPos );

    void                ExtendRange( const ScAddress& rScPos );

    virtual XclTokenArrayRef CreateCellTokenArray( const XclExpRoot& rRoot ) const override;
    virtual bool        IsVolatile() const override;

private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;

private:
    XclTokenArrayRef    mxTokArr;       
    sal_uInt8           mnUsedCount;    
};

typedef rtl::Reference< XclExpShrfmla > XclExpShrfmlaRef;

class XclExpShrfmlaBuffer : protected XclExpRoot
{
public:
    explicit            XclExpShrfmlaBuffer( const XclExpRoot& rRoot );

    XclExpShrfmlaRef CreateOrExtendShrfmla( const ScFormulaCell& rScCell, const ScAddress& rScPos );

private:
    bool IsValidTokenArray( const ScTokenArray& rArray ) const;

    typedef std::unordered_map<const ScTokenArray*, XclExpShrfmlaRef> TokensType;
    typedef o3tl::sorted_vector<const ScTokenArray*> BadTokenArraysType;

    TokensType         maRecMap;    
    BadTokenArraysType maBadTokens; 
};

// Multiple operations ========================================================

class XclExpTableop : public XclExpRangeFmlaBase
{
public:
    explicit            XclExpTableop( const ScAddress& rScPos,
                            const XclMultipleOpRefs& rRefs, sal_uInt8 nScMode );

    bool                TryExtend( const ScAddress& rScPos, const XclMultipleOpRefs& rRefs );

    void                Finalize();

    virtual XclTokenArrayRef CreateCellTokenArray( const XclExpRoot& rRoot ) const override;
    virtual bool        IsVolatile() const override;
    virtual void        Save( XclExpStream& rStrm ) override;

private:
    bool                IsAppendable( sal_uInt16 nXclCol, sal_uInt16 nXclRow ) const;

    virtual void        WriteBody( XclExpStream& rStrm ) override;

private:
    sal_uInt16          mnLastAppXclCol;
    sal_uInt16          mnColInpXclCol; 
    sal_uInt32          mnColInpXclRow; 
    sal_uInt16          mnRowInpXclCol; 
    sal_uInt32          mnRowInpXclRow; 
    sal_uInt8           mnScMode;       
    bool                mbValid;        
};

typedef rtl::Reference< XclExpTableop > XclExpTableopRef;

class XclExpTableopBuffer : protected XclExpRoot
{
public:
    explicit            XclExpTableopBuffer( const XclExpRoot& rRoot );

    XclExpTableopRef    CreateOrExtendTableop(
                            const ScTokenArray& rScTokArr, const ScAddress& rScPos );

    void                Finalize();

private:
    XclExpTableopRef    TryCreate( const ScAddress& rScPos, const XclMultipleOpRefs& rRefs );

private:
    XclExpRecordList< XclExpTableop > maTableopList;  
};

// Cell records

class XclExpCellBase : public XclExpRecord
{
public:
    const XclAddress& GetXclPos() const { return maXclPos; }
    sal_uInt16   GetXclCol() const { return maXclPos.mnCol; }
    sal_uInt32   GetXclRow() const { return maXclPos.mnRow; }

    virtual sal_uInt16  GetLastXclCol() const = 0;
    virtual sal_uInt32  GetFirstXFId() const = 0;
    virtual bool        IsEmpty() const = 0;
    virtual bool        IsMultiLineText() const;

    virtual bool        TryMerge( const XclExpCellBase& rCell );
    virtual void        ConvertXFIndexes( const XclExpRoot& rRoot ) = 0;
    virtual void        GetBlankXFIndexes( ScfUInt16Vec& rXFIndexes ) const;
    virtual void        RemoveUnusedBlankCells( const ScfUInt16Vec& rXFIndexes );

protected:
    explicit            XclExpCellBase(
                            sal_uInt16 nRecId, std::size_t nContSize, const XclAddress& rXclPos );

    void         SetXclCol( sal_uInt16 nXclCol ) { maXclPos.mnCol = nXclCol; }

private:
    XclAddress          maXclPos;       
};

typedef rtl::Reference< XclExpCellBase > XclExpCellRef;

// Single cell records ========================================================

class XclExpSingleCellBase : public XclExpCellBase
{
public:
    virtual sal_uInt16  GetLastXclCol() const override;
    virtual sal_uInt32  GetFirstXFId() const override;
    virtual bool        IsEmpty() const override;
    virtual void        ConvertXFIndexes( const XclExpRoot& rRoot ) override;
    virtual void        Save( XclExpStream& rStrm ) override;

protected:
    explicit            XclExpSingleCellBase( sal_uInt16 nRecId, std::size_t nContSize,
                            const XclAddress& rXclPos, sal_uInt32 nXFId );

    explicit            XclExpSingleCellBase( const XclExpRoot& rRoot,
                            sal_uInt16 nRecId, std::size_t nContSize, const XclAddress& rXclPos,
                            const ScPatternAttr* pPattern, sal_Int16 nScript, sal_uInt32 nForcedXFId );

    void         SetContSize( std::size_t nContSize ) { mnContSize = nContSize; }
    std::size_t  GetContSize() const { return mnContSize; }

    void         SetXFId( sal_uInt32 nXFId ) { maXFId.mnXFId = nXFId; }
    sal_uInt32   GetXFId() const { return maXFId.mnXFId; }

private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
    virtual void        WriteContents( XclExpStream& rStrm ) = 0;

private:
    XclExpXFId          maXFId;         
    std::size_t         mnContSize;     
};

class XclExpNumberCell : public XclExpSingleCellBase
{
public:
    explicit            XclExpNumberCell( const XclExpRoot& rRoot, const XclAddress& rXclPos,
                            const ScPatternAttr* pPattern, sal_uInt32 nForcedXFId,
                            double fValue );

    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;
private:
    virtual void        WriteContents( XclExpStream& rStrm ) override;

private:
    double              mfValue;        
};

class XclExpBooleanCell : public XclExpSingleCellBase
{
public:
    explicit            XclExpBooleanCell( const XclExpRoot& rRoot, const XclAddress& rXclPos,
                            const ScPatternAttr* pPattern, sal_uInt32 nForcedXFId,
                            bool bValue );

    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;
private:
    virtual void        WriteContents( XclExpStream& rStrm ) override;

private:
    bool                mbValue;        
};

class XclExpHyperlinkHelper;
class EditTextObject;

class XclExpLabelCell : public XclExpSingleCellBase
{
public:
    explicit            XclExpLabelCell( const XclExpRoot& rRoot, const XclAddress& rXclPos,
                            const ScPatternAttr* pPattern, sal_uInt32 nForcedXFId,
                            const OUString& rStr );

    explicit            XclExpLabelCell( const XclExpRoot& rRoot, const XclAddress& rXclPos,
                            const ScPatternAttr* pPattern, sal_uInt32 nForcedXFId,
                            const EditTextObject* pEditText, XclExpHyperlinkHelper& rHlinkHelper );

    virtual bool        IsMultiLineText() const override;

    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;
private:
    void                Init( const XclExpRoot& rRoot,
                            const ScPatternAttr* pPattern, XclExpStringRef const & xText );

    virtual void        WriteContents( XclExpStream& rStrm ) override;

private:
    XclExpStringRef     mxText;         
    sal_uInt32          mnSstIndex;     
    bool                mbLineBreak;    
};

class ScFormulaCell;

class XclExpFormulaCell : public XclExpSingleCellBase
{
public:
    explicit            XclExpFormulaCell( const XclExpRoot& rRoot, const XclAddress& rXclPos,
                            const ScPatternAttr* pPattern, sal_uInt32 nForcedXFId,
                            const ScFormulaCell& rScFmlaCell,
                            XclExpArrayBuffer& rArrayBfr,
                            XclExpShrfmlaBuffer& rShrfmlaBfr,
                            XclExpTableopBuffer& rTableopBfr );

    virtual void        Save( XclExpStream& rStrm ) override;
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;

private:
    virtual void        WriteContents( XclExpStream& rStrm ) override;

private:
    ScFormulaCell&      mrScFmlaCell;   
    XclTokenArrayRef    mxTokArr;       
    XclExpRangeFmlaRef  mxAddRec;       
    XclExpRecordRef     mxStringRec;    
};

// Multiple cell records ======================================================

struct XclExpMultiXFId : public XclExpXFId
{
    sal_uInt16          mnCount;        

    explicit     XclExpMultiXFId( sal_uInt32 nXFId, sal_uInt16 nCount = 1 ) :
                            XclExpXFId( nXFId ), mnCount( nCount ) {}
};

class XclExpMultiCellBase : public XclExpCellBase
{
public:
    virtual sal_uInt16  GetLastXclCol() const override;
    virtual sal_uInt32  GetFirstXFId() const override;
    virtual bool        IsEmpty() const override;

    virtual void        ConvertXFIndexes( const XclExpRoot& rRoot ) override;
    virtual void        Save( XclExpStream& rStrm ) override;
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;

protected:
    explicit            XclExpMultiCellBase( sal_uInt16 nRecId, sal_uInt16 nMulRecId,
                            std::size_t nContSize, const XclAddress& rXclPos );

    sal_uInt16          GetCellCount() const;

    void                AppendXFId( const XclExpMultiXFId& rXFId );
    void                AppendXFId( const XclExpRoot& rRoot,
                            const ScPatternAttr* pPattern, sal_uInt16 nScript,
                            sal_uInt32 nForcedXFId, sal_uInt16 nCount = 1 );

    bool                TryMergeXFIds( const XclExpMultiCellBase& rCell );
    void                GetXFIndexes( ScfUInt16Vec& rXFIndexes ) const;

    void                RemoveUnusedXFIndexes( const ScfUInt16Vec& rXFIndexes );

private:
    virtual void        WriteContents( XclExpStream& rStrm, sal_uInt16 nRelCol ) = 0;
    virtual void        WriteXmlContents( XclExpXmlStream& rStrm, const XclAddress& rAddress, sal_uInt32 nXFId, sal_uInt16 nRelCol ) = 0;

private:
    typedef ::std::vector< XclExpMultiXFId > XclExpMultiXFIdDeq;

    sal_uInt16          mnMulRecId;     
    std::size_t         mnContSize;     
    XclExpMultiXFIdDeq  maXFIds;        
};

class XclExpBlankCell : public XclExpMultiCellBase
{
public:
    explicit            XclExpBlankCell( const XclAddress& rXclPos, const XclExpMultiXFId& rXFId );

    explicit            XclExpBlankCell( const XclExpRoot& rRoot,
                            const XclAddress& rXclPos, sal_uInt16 nLastXclCol,
                            const ScPatternAttr* pPattern, sal_uInt32 nForcedXFId );

    virtual bool        TryMerge( const XclExpCellBase& rCell ) override;
    virtual void        GetBlankXFIndexes( ScfUInt16Vec& rXFIndexes ) const override;
    virtual void        RemoveUnusedBlankCells( const ScfUInt16Vec& rXFIndexes ) override;

private:
    virtual void        WriteContents( XclExpStream& rStrm, sal_uInt16 nRelCol ) override;
    virtual void        WriteXmlContents( XclExpXmlStream& rStrm, const XclAddress& rAddress, sal_uInt32 nXFId, sal_uInt16 nRelCol ) override;
};

class XclExpRkCell : public XclExpMultiCellBase
{
public:
    explicit            XclExpRkCell( const XclExpRoot& rRoot, const XclAddress& rXclPos,
                            const ScPatternAttr* pPattern, sal_uInt32 nForcedXFId,
                            sal_Int32 nRkValue );

    virtual bool        TryMerge( const XclExpCellBase& rCell ) override;

private:
    virtual void        WriteContents( XclExpStream& rStrm, sal_uInt16 nRelCol ) override;
    virtual void        WriteXmlContents( XclExpXmlStream& rStrm, const XclAddress& rAddress, sal_uInt32 nXFId, sal_uInt16 nRelCol ) override;

private:
    ScfInt32Vec         maRkValues;     
};

// Rows and Columns

class ScOutlineArray;

class XclExpOutlineBuffer
{
public:
    bool         IsCollapsed() const { return mbCurrCollapse; }
    sal_uInt8    GetLevel() const { return ::std::min( mnCurrLevel, EXC_OUTLINE_MAX ); }

protected:
    explicit            XclExpOutlineBuffer( const XclExpRoot& rRoot, bool bRows );

    void                UpdateColRow( SCCOLROW nScPos );

private:
    struct XclExpLevelInfo
    {
        SCCOLROW            mnScEndPos;         
        bool                mbHidden;           
        explicit     XclExpLevelInfo() : mnScEndPos( 0 ), mbHidden( false ) {}
    };

    const ScOutlineArray* mpScOLArray;      
    std::vector< XclExpLevelInfo >
                        maLevelInfos;       
    sal_uInt8           mnCurrLevel;        
    bool                mbCurrCollapse;     
};

class XclExpColOutlineBuffer : public XclExpOutlineBuffer
{
public:
    explicit     XclExpColOutlineBuffer( const XclExpRoot& rRoot ) :
                            XclExpOutlineBuffer( rRoot, false ) {}

    void         Update( SCCOL nScCol )
                            { UpdateColRow( static_cast< SCCOLROW >( nScCol ) ); }
};

class XclExpRowOutlineBuffer : public XclExpOutlineBuffer
{
public:
    explicit     XclExpRowOutlineBuffer( const XclExpRoot& rRoot ) :
                            XclExpOutlineBuffer( rRoot, true ) {}

    void         Update( SCROW nScRow )
                            { UpdateColRow( static_cast< SCCOLROW >( nScRow ) ); }
};

class XclExpGuts : public XclExpRecord
{
public:
    explicit            XclExpGuts( const XclExpRoot& rRoot );

private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;

private:
    sal_uInt16          mnColLevels;    
    sal_uInt16          mnColWidth;     
    sal_uInt16          mnRowLevels;    
    sal_uInt16          mnRowWidth;     
};

class XclExpDimensions : public XclExpRecord
{
public:
    explicit            XclExpDimensions( const XclExpRoot& rRoot );

    void                SetDimensions(
                            sal_uInt16 nFirstUsedXclCol, sal_uInt32 nFirstUsedXclRow,
                            sal_uInt16 nFirstFreeXclCol, sal_uInt32 nFirstFreeXclRow );

    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;

private:
    const XclExpRoot&   mrRoot;
    sal_uInt32          mnFirstUsedXclRow;  
    sal_uInt32          mnFirstFreeXclRow;  
    sal_uInt16          mnFirstUsedXclCol;  
    sal_uInt16          mnFirstFreeXclCol;  
};

class XclExpDefcolwidth : public XclExpDoubleRecord, protected XclExpRoot
{
public:
    explicit            XclExpDefcolwidth( const XclExpRoot& rRoot );

    bool                IsDefWidth( sal_uInt16 nXclColWidth ) const;

    void                SetDefWidth( sal_uInt16 nXclColWidth, bool bXLS );

    virtual void        Save(XclExpStream& rStrm) override;
};

class XclExpColinfo : public XclExpRecord, protected XclExpRoot
{
public:
    explicit            XclExpColinfo( const XclExpRoot& rRoot,
                            SCCOL nScCol, SCROW nLastScRow,
                            XclExpColOutlineBuffer& rOutlineBfr );

    void                ConvertXFIndexes();

    bool                TryMerge( const XclExpColinfo& rColInfo );

    sal_uInt16   GetColWidth() const { return mnWidth; }
    sal_uInt16   GetXFIndex() const { return maXFId.mnXFIndex; }
    sal_uInt16   GetColCount() const { return mnLastXclCol - mnFirstXclCol + 1; }

    bool                IsDefault( const XclExpDefcolwidth& rDefColWidth );

    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;

private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;

private:
    XclExpXFId          maXFId;             
    bool                mbCustomWidth;      
    sal_uInt16          mnWidth;            
    sal_uInt16          mnScWidth;          
    sal_uInt16          mnFlags;            
    sal_uInt8           mnOutlineLevel;     
    sal_uInt16          mnFirstXclCol;      
    sal_uInt16          mnLastXclCol;       
};

class XclExpColinfoBuffer : public XclExpRecordBase, protected XclExpRoot
{
public:
    explicit            XclExpColinfoBuffer( const XclExpRoot& rRoot );

    void                Initialize( SCROW nLastScRow );
    void                Finalize( ScfUInt16Vec& rXFIndexes, bool bXLS );

    virtual void        Save( XclExpStream& rStrm ) override;
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;
    sal_uInt8           GetHighestOutlineLevel() const { return mnHighestOutlineLevel; }
    double              GetDefColWidth() const { return maDefcolwidth.GetValue(); }

private:
    typedef XclExpRecordList< XclExpColinfo >   XclExpColinfoList;
    typedef XclExpColinfoList::RecordRefType    XclExpColinfoRef;

    XclExpColinfoList   maColInfos;         
    XclExpDefcolwidth   maDefcolwidth;      
    XclExpColOutlineBuffer maOutlineBfr;    
    sal_uInt8           mnHighestOutlineLevel; 
};

class XclExpRow;

struct XclExpDefaultRowData
{
    sal_uInt16          mnFlags;            
    sal_uInt16          mnHeight;           

    explicit            XclExpDefaultRowData();
    explicit            XclExpDefaultRowData( const XclExpRow& rRow );

    bool         IsHidden() const { return ::get_flag( mnFlags, EXC_DEFROW_HIDDEN ); }
    bool         IsUnsynced() const { return ::get_flag( mnFlags, EXC_DEFROW_UNSYNCED ); }
};

class XclExpDefrowheight : public XclExpRecord
{
public:
    explicit            XclExpDefrowheight();

    void                SetDefaultData( const XclExpDefaultRowData& rDefData );
    XclExpDefaultRowData& GetDefaultData() { return maDefData; }
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;

private:
    XclExpDefaultRowData maDefData;         
};

class XclExpRow : public XclExpRecord, protected XclExpRoot
{
public:
    explicit            XclExpRow( const XclExpRoot& rRoot, sal_uInt32 nXclRow,
                            XclExpRowOutlineBuffer& rOutlineBfr, bool bAlwaysEmpty, bool bHidden, sal_uInt16 nHeight );

    sal_uInt32   GetXclRow() const { return mnXclRow; }
    sal_uInt16   GetHeight() const { return mnHeight; }
    bool         IsEmpty() const { return maCellList.IsEmpty(); }
    bool         IsHidden() const { return ::get_flag( mnFlags, EXC_ROW_HIDDEN ); }
    bool         IsUnsynced() const { return ::get_flag( mnFlags, EXC_ROW_UNSYNCED ); }
    bool         IsEnabled() const { return mbEnabled; }

    void                AppendCell( XclExpCellRef const & xCell, bool bIsMergedBase );

    void                Finalize( const ScfUInt16Vec& rColXFIndexes,
                                  bool bUpdateProgress );

    sal_uInt16          GetFirstUsedXclCol() const;
    sal_uInt16          GetFirstFreeXclCol() const;

    bool                IsDefaultable() const;
    void                DisableIfDefault( const XclExpDefaultRowData& rDefRowData );

    void                WriteCellList( XclExpStream& rStrm );

    virtual void        Save( XclExpStream& rStrm ) override;
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;

    sal_uInt32   GetXclRowRpt() const { return mnXclRowRpt; }
    void         SetXclRowRpt( sal_uInt32 nRpt ){ mnXclRowRpt = nRpt; }
private:
    void                InsertCell( XclExpCellRef xCell, size_t nPos, bool bIsMergedBase );

    virtual void        WriteBody( XclExpStream& rStrm ) override;

private:
    XclExpRecordList< XclExpCellBase >
                        maCellList;         
    sal_uInt32          mnXclRow;           
    sal_uInt16          mnHeight;           
    sal_uInt16          mnFlags;            
    sal_uInt16          mnXFIndex;          
    sal_uInt8           mnOutlineLevel;     
    sal_uInt32          mnXclRowRpt;
    sal_uInt32          mnCurrentRow;
    bool                mbAlwaysEmpty;      
    bool                mbEnabled;          
};

class XclExpRowBuffer : public XclExpRecordBase, protected XclExpRoot
{
public:
    explicit            XclExpRowBuffer( const XclExpRoot& rRoot );

    void                AppendCell( XclExpCellRef const & xCell, bool bIsMergedBase );
    void                CreateRows( SCROW nFirstFreeScRow );

    void                Finalize( XclExpDefaultRowData& rDefRowData, const ScfUInt16Vec& rColXFIndexes );

    virtual void        Save( XclExpStream& rStrm ) override;
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;

    XclExpDimensions&   GetDimensions() { return maDimensions; }
    sal_uInt8           GetHighestOutlineLevel() const { return mnHighestOutlineLevel; }

private:
    XclExpRow&          GetOrCreateRow( sal_uInt32 nXclRow, bool bRowAlwaysEmpty );

private:
    typedef std::shared_ptr<XclExpRow>  RowRef;
    typedef ::std::map<sal_uInt32, RowRef>  RowMap;

    RowMap              maRowMap;
    XclExpRowOutlineBuffer maOutlineBfr;    
    XclExpDimensions    maDimensions;       
    sal_uInt8           mnHighestOutlineLevel; 
};

// Cell Table

class XclExpNote;
class XclExpMergedcells;
class XclExpHyperlink;
class XclExpDval;

class XclExpCellTable : public XclExpRecordBase, protected XclExpRoot
{
public:
    explicit            XclExpCellTable( const XclExpRoot& rRoot );

    void                Finalize(bool bXLS);

    XclExpRecordRef     CreateRecord( sal_uInt16 nRecId ) const;
    virtual void        Save( XclExpStream& rStrm ) override;
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;

private:
    typedef XclExpRecordList< XclExpNote >      XclExpNoteList;
    typedef XclExpRecordList< XclExpHyperlink > XclExpHyperlinkList;

    typedef rtl::Reference< XclExpDefrowheight >       XclExpDefrowhRef;
    typedef rtl::Reference< XclExpNoteList >           XclExpNoteListRef;
    typedef rtl::Reference< XclExpMergedcells >        XclExpMergedcellsRef;
    typedef rtl::Reference< XclExpHyperlinkList >      XclExpHyperlinkRef;
    typedef rtl::Reference< XclExpDval >               XclExpDvalRef;
    typedef rtl::Reference< XclExtLst >                XclExtLstRef;

    XclExpColinfoBuffer maColInfoBfr;       
    XclExpRowBuffer     maRowBfr;           
    XclExpArrayBuffer   maArrayBfr;         
    XclExpShrfmlaBuffer maShrfmlaBfr;       
    XclExpTableopBuffer maTableopBfr;       
    XclExpDefrowhRef    mxDefrowheight;     
    XclExpRecordRef     mxGuts;             
    XclExpNoteListRef   mxNoteList;         
    XclExpMergedcellsRef mxMergedcells;     
    XclExpHyperlinkRef  mxHyperlinkList;    
    XclExpDvalRef       mxDval;             
    XclExtLstRef        mxExtLst;
};

#endif

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