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 .
 */
 
#pragma once
 
#include "xltable.hxx"
 
#include <vector>
#include "xladdress.hxx"
#include "xecontent.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, size_t nStartAllNotFound );
 
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, size_t nStartAllNotFound );
 
    sal_uInt16          GetStartColAllDefaultCell() const;
 
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, size_t nStartAllNotFound ) override;
 
    using               XclExpMultiCellBase::GetStartColAllDefaultCell;
 
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,
                                  ScfUInt16Vec& aXFIndexes,
                                  size_t nStartColAllDefault,
                                  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,
                                  size_t nStartColAllDefault );
 
    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;
};
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */