xichart.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 <salhelper/simplereferenceobject.hxx>
#include <set>
#include <map>
#include <memory>
#include <vector>

#include <types.hxx>
#include "xlchart.hxx"
#include "xlstyle.hxx"
#include "xiescher.hxx"
#include "xistring.hxx"

namespace com::sun::star {
    namespace awt
    {
        struct Rectangle;
    }
    namespace frame
    {
        class XModel;
    }
    namespace drawing
    {
        class XShape;
    }
    namespace chart2
    {
        struct ScaleData;
        class XChartDocument;
        class XDiagram;
        class XCoordinateSystem;
        class XChartType;
        class XDataSeries;
        class XRegressionCurve;
        class XAxis;
        class XLegend;
        class XTitle;
        class XFormattedString;
        namespace data
        {
            class XDataProvider;
            class XDataSequence;
            class XLabeledDataSequence;
        }
    }
}

struct XclObjLineData;
struct XclObjFillData;

// Common =====================================================================

struct XclImpChRootData;
class XclImpChChart;
class ScTokenArray;

class XclImpChRoot : public XclImpRoot
{
public:
    explicit            XclImpChRoot( const XclImpRoot& rRoot, XclImpChChart& rChartData );
    virtual             ~XclImpChRoot() override;

    XclImpChRoot(XclImpChRoot const &) = default;
    XclImpChRoot(XclImpChRoot &&) = default;
    XclImpChRoot & operator =(XclImpChRoot const &) = delete; // due to XclImpRoot
    XclImpChRoot & operator =(XclImpChRoot &&) = delete; // due to XclImpRoot

    const XclImpChRoot& GetChRoot() const { return *this; }
    XclImpChChart&      GetChartData() const;
    const XclChTypeInfo& GetChartTypeInfo( XclChTypeId eType ) const;
    const XclChTypeInfo& GetChartTypeInfo( sal_uInt16 nRecId ) const;
    const XclChFormatInfo& GetFormatInfo( XclChObjectType eObjType ) const;

    Color               GetFontAutoColor() const;
    Color               GetSeriesLineAutoColor( sal_uInt16 nFormatIdx ) const;
    Color               GetSeriesFillAutoColor( sal_uInt16 nFormatIdx ) const;

    void                InitConversion(
                            const css::uno::Reference< css::chart2::XChartDocument>& xChartDoc,
                            const tools::Rectangle& rChartRect ) const;

    void                FinishConversion( XclImpDffConverter& rDffConv ) const;

    css::uno::Reference< css::chart2::data::XDataProvider >
                        GetDataProvider() const;
    css::uno::Reference< css::drawing::XShape >
                        GetTitleShape( const XclChTextKey& rTitleKey ) const;

    sal_Int32           CalcHmmFromChartX( sal_Int32 nPosX ) const;
    sal_Int32           CalcHmmFromChartY( sal_Int32 nPosY ) const;
    css::awt::Rectangle CalcHmmFromChartRect( const XclChRectangle& rRect ) const;

    double              CalcRelativeFromHmmX( sal_Int32 nPosX ) const;
    double              CalcRelativeFromHmmY( sal_Int32 nPosY ) const;

    double              CalcRelativeFromChartX( sal_Int32 nPosX ) const;
    double              CalcRelativeFromChartY( sal_Int32 nPosY ) const;

    void                ConvertLineFormat(
                            ScfPropertySet& rPropSet,
                            const XclChLineFormat& rLineFmt,
                            XclChPropertyMode ePropMode ) const;
    void                ConvertAreaFormat(
                            ScfPropertySet& rPropSet,
                            const XclChAreaFormat& rAreaFmt,
                            XclChPropertyMode ePropMode ) const;
    void                ConvertEscherFormat(
                            ScfPropertySet& rPropSet,
                            const XclChEscherFormat& rEscherFmt,
                            const XclChPicFormat* pPicFmt,
                            sal_uInt32 nDffFillType,
                            XclChPropertyMode ePropMode ) const;
    void                ConvertFont(
                            ScfPropertySet& rPropSet,
                            sal_uInt16 nFontIdx,
                            const Color* pFontColor = nullptr ) const;

    static void         ConvertPieRotation(
                            ScfPropertySet& rPropSet,
                            sal_uInt16 nAngle );

private:
    typedef std::shared_ptr< XclImpChRootData > XclImpChRootDataRef;
    XclImpChRootDataRef mxChData;           
};

class XclImpChGroupBase
{
public:
    XclImpChGroupBase() = default;
    XclImpChGroupBase(XclImpChGroupBase const &) = default;
    XclImpChGroupBase(XclImpChGroupBase &&) = default;
    XclImpChGroupBase & operator =(XclImpChGroupBase const &) = default;
    XclImpChGroupBase & operator =(XclImpChGroupBase &&) = default;

    virtual             ~XclImpChGroupBase();

    void                ReadRecordGroup( XclImpStream& rStrm );

    static void         SkipBlock( XclImpStream& rStrm );

    virtual void        ReadHeaderRecord( XclImpStream& rStrm ) = 0;
    virtual void        ReadSubRecord( XclImpStream& rStrm ) = 0;
};

// Frame formatting ===========================================================

class XclImpChFramePos
{
public:
    void                ReadChFramePos( XclImpStream& rStrm );

    const XclChFramePos& GetFramePosData() const { return maData; }

private:
    XclChFramePos       maData;             
};

typedef std::shared_ptr< XclImpChFramePos > XclImpChFramePosRef;

class XclImpChLineFormat : public salhelper::SimpleReferenceObject
{
public:
    explicit     XclImpChLineFormat() {}
    explicit     XclImpChLineFormat( const XclChLineFormat& rLineFmt ) : maData( rLineFmt ) {}

    // this class is stored both ref-counted and by value
    XclImpChLineFormat(XclImpChLineFormat const & rOther)
        : salhelper::SimpleReferenceObject(), maData(rOther.maData) {}
    XclImpChLineFormat(XclImpChLineFormat && rOther)
        : salhelper::SimpleReferenceObject(), maData(std::move(rOther.maData)) {}
    XclImpChLineFormat& operator=(XclImpChLineFormat const & rOther)
        { maData = rOther.maData; return *this; }
    XclImpChLineFormat& operator=(XclImpChLineFormat && rOther) noexcept
        { maData = std::move(rOther.maData); return *this; }

    void                ReadChLineFormat( XclImpStream& rStrm );

    bool         IsAuto() const { return ::get_flag( maData.mnFlags, EXC_CHLINEFORMAT_AUTO ); }
    bool         HasLine() const { return IsAuto() || (maData.mnPattern != EXC_CHLINEFORMAT_NONE); }
    sal_Int16    GetWeight() const { return (IsAuto() || !HasLine()) ? EXC_CHLINEFORMAT_SINGLE : maData.mnWeight; }
    bool         IsShowAxis() const { return ::get_flag( maData.mnFlags, EXC_CHLINEFORMAT_SHOWAXIS ); }

    void                Convert( const XclImpChRoot& rRoot,
                            ScfPropertySet& rPropSet, XclChObjectType eObjType,
                            sal_uInt16 nFormatIdx = EXC_CHDATAFORMAT_UNKNOWN ) const;

private:
    XclChLineFormat     maData;             
};

typedef rtl::Reference< XclImpChLineFormat > XclImpChLineFormatRef;

class XclImpChAreaFormat
{
public:
    explicit     XclImpChAreaFormat() {}
    explicit     XclImpChAreaFormat( const XclChAreaFormat& rAreaFmt ) : maData( rAreaFmt ) {}

    void                ReadChAreaFormat( XclImpStream& rStrm );

    bool         IsAuto() const { return ::get_flag( maData.mnFlags, EXC_CHAREAFORMAT_AUTO ); }
    bool         HasArea() const { return IsAuto() || (maData.mnPattern != EXC_PATT_NONE); }

    void                Convert( const XclImpChRoot& rRoot,
                            ScfPropertySet& rPropSet, XclChObjectType eObjType,
                            sal_uInt16 nFormatIdx ) const;

private:
    XclChAreaFormat     maData;             
};

typedef std::shared_ptr< XclImpChAreaFormat > XclImpChAreaFormatRef;

class XclImpChEscherFormat : public XclImpChGroupBase
{
public:
    explicit            XclImpChEscherFormat( const XclImpRoot& rRoot );

    virtual void        ReadHeaderRecord( XclImpStream& rStrm ) override;
    virtual void        ReadSubRecord( XclImpStream& rStrm ) override;

    void                Convert( const XclImpChRoot& rRoot, ScfPropertySet& rPropSet,
                            XclChObjectType eObjType, bool bUsePicFmt ) const;

private:
    XclChEscherFormat   maData;             
    XclChPicFormat      maPicFmt;           
    sal_uInt32          mnDffFillType;      
};

typedef std::shared_ptr< XclImpChEscherFormat > XclImpChEscherFormatRef;

class XclImpChFrameBase : public XclImpChGroupBase
{
public:
    explicit     XclImpChFrameBase() {}
    explicit            XclImpChFrameBase( const XclChFormatInfo& rFmtInfo );

    virtual void        ReadSubRecord( XclImpStream& rStrm ) override;

    bool         IsAutoLine() const { return !mxLineFmt || mxLineFmt->IsAuto(); }
    bool         HasLine() const { return IsAutoLine() || mxLineFmt->HasLine(); }
    sal_Int16    GetLineWeight() const { return mxLineFmt ? mxLineFmt->GetWeight() : EXC_CHLINEFORMAT_SINGLE; }

    bool         IsAutoArea() const { return !mxEscherFmt && (!mxAreaFmt || mxAreaFmt->IsAuto()); }

protected:
    void                ConvertLineBase( const XclImpChRoot& rRoot,
                            ScfPropertySet& rPropSet, XclChObjectType eObjType,
                            sal_uInt16 nFormatIdx = EXC_CHDATAFORMAT_UNKNOWN ) const;
    void                ConvertAreaBase( const XclImpChRoot& rRoot,
                            ScfPropertySet& rPropSet, XclChObjectType eObjType,
                            sal_uInt16 nFormatIdx = EXC_CHDATAFORMAT_UNKNOWN, bool bUsePicFmt = false ) const;
    void                ConvertFrameBase( const XclImpChRoot& rRoot,
                            ScfPropertySet& rPropSet, XclChObjectType eObjType,
                            sal_uInt16 nFormatIdx = EXC_CHDATAFORMAT_UNKNOWN, bool bUsePicFmt = false ) const;

protected:
    XclImpChLineFormatRef mxLineFmt;        
    XclImpChAreaFormatRef mxAreaFmt;        
    XclImpChEscherFormatRef mxEscherFmt;    
};

class XclImpChFrame : public XclImpChFrameBase, protected XclImpChRoot
{
public:
    explicit            XclImpChFrame(
                            const XclImpChRoot& rRoot,
                            XclChObjectType eObjType );

    virtual void        ReadHeaderRecord( XclImpStream& rStrm ) override;

    void                UpdateObjFrame( const XclObjLineData& rLineData, const XclObjFillData& rFillData );

    void                Convert( ScfPropertySet& rPropSet, bool bUsePicFmt = false ) const;

private:
    XclChFrame          maData;             
    XclChObjectType     meObjType;          
};

typedef std::shared_ptr< XclImpChFrame > XclImpChFrameRef;

// Source links ===============================================================

class XclImpChSourceLink : protected XclImpChRoot
{
public:
    explicit            XclImpChSourceLink( const XclImpChRoot& rRoot );
    virtual             ~XclImpChSourceLink() override;

    void                ReadChSourceLink( XclImpStream& rStrm );
    void                SetString( const OUString& rString );
    void                SetTextFormats( const XclFormatRunVec& rFormats );

    sal_uInt8    GetDestType() const { return maData.mnDestType; }
    sal_uInt8    GetLinkType() const { return maData.mnLinkType; }

    bool         HasString() const { return mxString && !mxString->IsEmpty(); }
    OUString            GetString() const {
        if (mxString) return mxString->GetText();
        return OUString();
    }
    sal_uInt16          GetCellCount() const;

    void                ConvertNumFmt( ScfPropertySet& rPropSet, bool bPercent ) const;

    css::uno::Reference< css::chart2::data::XDataSequence >
                        CreateDataSequence( const OUString& rRole ) const;
    css::uno::Sequence< css::uno::Reference< css::chart2::XFormattedString > >
                        CreateStringSequence( const XclImpChRoot& rRoot,
                            sal_uInt16 nLeadFontIdx, const Color& rLeadFontColor ) const;

    void                FillSourceLink(::std::vector<ScTokenRef>& rTokens) const;

private:
    XclChSourceLink     maData;             
    XclImpStringRef     mxString;           
    std::shared_ptr< ScTokenArray> mxTokenArray;     
};

typedef std::shared_ptr< XclImpChSourceLink > XclImpChSourceLinkRef;

// Text =======================================================================

class XclImpChFontBase
{
public:
    XclImpChFontBase() = default;
    XclImpChFontBase(XclImpChFontBase const &) = default;
    XclImpChFontBase(XclImpChFontBase &&) = default;
    XclImpChFontBase & operator =(XclImpChFontBase const &) = default;
    XclImpChFontBase & operator =(XclImpChFontBase &&) = default;

    virtual             ~XclImpChFontBase();

    virtual sal_uInt16  GetFontIndex() const = 0;
    virtual Color       GetFontColor() const = 0;
    virtual sal_uInt16  GetRotation() const = 0;

    void                ConvertFontBase( const XclImpChRoot& rRoot, ScfPropertySet& rPropSet ) const;
    void                ConvertRotationBase( ScfPropertySet& rPropSet, bool bSupportsStacked ) const;
};

class XclImpChFont
{
public:
    explicit            XclImpChFont();
    void                ReadChFont( XclImpStream& rStrm );

    sal_uInt16   GetFontIndex() const { return mnFontIdx; }

private:
    sal_uInt16          mnFontIdx;          
};

typedef std::shared_ptr< XclImpChFont > XclImpChFontRef;

class XclImpChText : public XclImpChGroupBase, public XclImpChFontBase, protected XclImpChRoot
{
public:
    explicit            XclImpChText( const XclImpChRoot& rRoot );

    virtual void        ReadHeaderRecord( XclImpStream& rStrm ) override;
    virtual void        ReadSubRecord( XclImpStream& rStrm ) override;

    virtual sal_uInt16  GetFontIndex() const override;
    virtual Color       GetFontColor() const override;
    virtual sal_uInt16  GetRotation() const override;

    void                SetString( const OUString& rString );
    void                UpdateText( const XclImpChText* pParentText );
    void                UpdateDataLabel( bool bCateg, bool bValue, bool bPercent );

    sal_uInt16   GetLinkTarget() const { return maObjLink.mnTarget; }
    const XclChDataPointPos& GetPointPos() const { return maObjLink.maPointPos; }
    bool         HasString() const { return mxSrcLink && mxSrcLink->HasString(); }
    bool         IsDeleted() const { return ::get_flag( maData.mnFlags, EXC_CHTEXT_DELETED ); }

    void                ConvertFont( ScfPropertySet& rPropSet ) const;
    void                ConvertRotation( ScfPropertySet& rPropSet, bool bSupportsStacked ) const;
    void                ConvertFrame( ScfPropertySet& rPropSet ) const;
    void                ConvertNumFmt( ScfPropertySet& rPropSet, bool bPercent ) const;
    void                ConvertDataLabel( ScfPropertySet& rPropSet, const XclChTypeInfo& rTypeInfo, const ScfPropertySet* pGlobalPropSet ) const;
    css::uno::Reference< css::chart2::XTitle >
                        CreateTitle() const;
    void                ConvertTitlePosition( const XclChTextKey& rTitleKey ) const;

private:
    using               XclImpChRoot::ConvertFont;

    void                ReadChFrLabelProps( XclImpStream& rStrm );

private:
    typedef std::shared_ptr< XclChFrLabelProps > XclChFrLabelPropsRef;

    XclChText           maData;             
    XclChObjectLink     maObjLink;          
    XclFormatRunVec     maFormats;          
    XclImpChFramePosRef mxFramePos;         
    XclImpChSourceLinkRef mxSrcLink;        
    XclImpChFrameRef    mxFrame;            
    XclImpChFontRef     mxFont;             
    XclChFrLabelPropsRef mxLabelProps;      
};

typedef std::shared_ptr< XclImpChText > XclImpChTextRef;

// Data series ================================================================

class XclImpChMarkerFormat
{
public:
    void                ReadChMarkerFormat( XclImpStream& rStrm );

    bool         IsAuto() const { return ::get_flag( maData.mnFlags, EXC_CHMARKERFORMAT_AUTO ); }

    void                Convert( const XclImpChRoot& rRoot, ScfPropertySet& rPropSet,
                            sal_uInt16 nFormatIdx, sal_Int16 nLineWeight ) const;
    void                ConvertColor( const XclImpChRoot& rRoot,
                            ScfPropertySet& rPropSet, sal_uInt16 nFormatIdx ) const;

private:
    XclChMarkerFormat   maData;             
};

typedef std::shared_ptr< XclImpChMarkerFormat > XclImpChMarkerFormatRef;

class XclImpChPieFormat
{
public:
    explicit            XclImpChPieFormat();
    void                ReadChPieFormat( XclImpStream& rStrm );
    void                Convert( ScfPropertySet& rPropSet ) const;

private:
    sal_uInt16          mnPieDist;          
};

typedef std::shared_ptr< XclImpChPieFormat > XclImpChPieFormatRef;

class XclImpChSeriesFormat
{
public:
    explicit            XclImpChSeriesFormat();
    void                ReadChSeriesFormat( XclImpStream& rStrm );
    bool         HasSpline() const { return ::get_flag( mnFlags, EXC_CHSERIESFORMAT_SMOOTHED ); }

private:
    sal_uInt16          mnFlags;            
};

typedef std::shared_ptr< XclImpChSeriesFormat > XclImpChSeriesFormatRef;

class XclImpCh3dDataFormat
{
public:
    void                ReadCh3dDataFormat( XclImpStream& rStrm );
    void                Convert( ScfPropertySet& rPropSet ) const;

private:
    XclCh3dDataFormat   maData;             
};

typedef std::shared_ptr< XclImpCh3dDataFormat > XclImpCh3dDataFormatRef;

class XclImpChAttachedLabel : protected XclImpChRoot
{
public:
    explicit            XclImpChAttachedLabel( const XclImpChRoot& rRoot );
    void                ReadChAttachedLabel( XclImpStream& rStrm );
    XclImpChTextRef     CreateDataLabel( const XclImpChText* pParent ) const;

private:
    sal_uInt16          mnFlags;            
};

typedef std::shared_ptr< XclImpChAttachedLabel > XclImpChAttLabelRef;

class XclImpChDataFormat : public XclImpChFrameBase, protected XclImpChRoot
{
public:
    explicit            XclImpChDataFormat( const XclImpChRoot& rRoot );

    virtual void        ReadHeaderRecord( XclImpStream& rStrm ) override;
    virtual void        ReadSubRecord( XclImpStream& rStrm ) override;

    void                SetPointPos( const XclChDataPointPos& rPointPos, sal_uInt16 nFormatIdx );
    void         SetDataLabel( XclImpChTextRef xLabel ) { mxLabel = xLabel; }

    void                UpdateGroupFormat( const XclChExtTypeInfo& rTypeInfo );
    void                UpdateSeriesFormat( const XclChExtTypeInfo& rTypeInfo, const XclImpChDataFormat* pGroupFmt );
    void                UpdatePointFormat( const XclChExtTypeInfo& rTypeInfo, const XclImpChDataFormat* pSeriesFmt );
    void                UpdateTrendLineFormat();

    const XclChDataPointPos& GetPointPos() const { return maData.maPointPos; }
    sal_uInt16   GetFormatIdx() const { return maData.mnFormatIdx; }
    bool         IsAutoMarker() const { return !mxMarkerFmt || mxMarkerFmt->IsAuto(); }
    bool         HasSpline() const { return mxSeriesFmt && mxSeriesFmt->HasSpline(); }
    const XclImpChText* GetDataLabel() const { return mxLabel.get(); }

    void                Convert( ScfPropertySet& rPropSet, const XclChExtTypeInfo& rTypeInfo, const ScfPropertySet* pGlobalPropSet = nullptr ) const;
    void                ConvertLine( ScfPropertySet& rPropSet, XclChObjectType eObjType ) const;
    void                ConvertArea( ScfPropertySet& rPropSet, sal_uInt16 nFormatIdx ) const;

private:
    void                RemoveUnusedFormats( const XclChExtTypeInfo& rTypeInfo );
    void                UpdateDataLabel( const XclImpChDataFormat* pParentFmt );

private:
    XclChDataFormat     maData;             
    XclImpChMarkerFormatRef mxMarkerFmt;    
    XclImpChPieFormatRef mxPieFmt;          
    XclImpChSeriesFormatRef mxSeriesFmt;    
    XclImpCh3dDataFormatRef mx3dDataFmt;    
    XclImpChAttLabelRef mxAttLabel;         
    XclImpChTextRef     mxLabel;            
};

typedef std::shared_ptr< XclImpChDataFormat > XclImpChDataFormatRef;

class XclImpChSerTrendLine : protected XclImpChRoot
{
public:
    explicit            XclImpChSerTrendLine( const XclImpChRoot& rRoot );

    void                ReadChSerTrendLine( XclImpStream& rStrm );
    void         SetDataFormat( XclImpChDataFormatRef xDataFmt ) { mxDataFmt = xDataFmt; }

    void         SetTrendlineName( const OUString& aTrendlineName) { maTrendLineName = aTrendlineName; }

    css::uno::Reference< css::chart2::XRegressionCurve >
                        CreateRegressionCurve() const;

private:
    OUString  maTrendLineName;
    XclChSerTrendLine maData;               
    XclImpChDataFormatRef mxDataFmt;        
};

typedef std::shared_ptr< XclImpChSerTrendLine > XclImpChSerTrendLineRef;

class XclImpChSerErrorBar : protected XclImpChRoot
{
public:
    explicit            XclImpChSerErrorBar( const XclImpChRoot& rRoot );

    void                ReadChSerErrorBar( XclImpStream& rStrm );
    void                SetSeriesData(
                            XclImpChSourceLinkRef const & xValueLink,
                            XclImpChDataFormatRef const & xDataFmt );

    sal_uInt8    GetBarType() const { return maData.mnBarType; }
    css::uno::Reference< css::chart2::data::XLabeledDataSequence >
                        CreateValueSequence() const;

    static css::uno::Reference< css::beans::XPropertySet >
                        CreateErrorBar(
                            const XclImpChSerErrorBar* pPosBar,
                            const XclImpChSerErrorBar* pNegBar );

private:
    XclChSerErrorBar    maData;             
    XclImpChSourceLinkRef mxValueLink;      
    XclImpChDataFormatRef mxDataFmt;        
};


class XclImpChSeries : public XclImpChGroupBase, protected XclImpChRoot
{
public:
    explicit            XclImpChSeries( const XclImpChRoot& rRoot, sal_uInt16 nSeriesIdx );

    virtual void        ReadHeaderRecord( XclImpStream& rStrm ) override;
    virtual void        ReadSubRecord( XclImpStream& rStrm ) override;

    void                SetDataFormat( const XclImpChDataFormatRef& xDataFmt );
    void                SetDataLabel( const XclImpChTextRef& xLabel );
    void                AddChildSeries( const XclImpChSeries& rSeries );
    void                FinalizeDataFormats();

    sal_uInt16   GetGroupIdx() const { return mnGroupIdx; }
    sal_uInt16   GetParentIdx() const { return mnParentIdx; }
    bool         HasParentSeries() const { return mnParentIdx != EXC_CHSERIES_INVALID; }
    bool         HasChildSeries() const { return !maTrendLines.empty() || !m_ErrorBars.empty(); }
    OUString            GetTitle() const { return mxTitleLink ? mxTitleLink->GetString() : OUString(); }

    bool         HasSpline() const { return mxSeriesFmt && mxSeriesFmt->HasSpline(); }

    css::uno::Reference< css::chart2::data::XLabeledDataSequence >
                        CreateValueSequence( const OUString& rValueRole ) const;
    css::uno::Reference< css::chart2::data::XLabeledDataSequence >
                        CreateCategSequence( const OUString& rCategRole ) const;
    css::uno::Reference< css::chart2::XDataSeries >
                        CreateDataSeries() const;

    void                FillAllSourceLinks(::std::vector<ScTokenRef>& rTokens) const;

private:
    void                ReadChSourceLink( XclImpStream& rStrm );
    void                ReadChDataFormat( XclImpStream& rStrm );
    void                ReadChSerParent( XclImpStream& rStrm );
    void                ReadChSerTrendLine( XclImpStream& rStrm );
    void                ReadChSerErrorBar( XclImpStream& rStrm );

    void                ReadChLegendException( XclImpStream& rStrm );
    XclImpChDataFormatRef CreateDataFormat( sal_uInt16 nPointIdx, sal_uInt16 nFormatIdx );

    void                ConvertTrendLines( css::uno::Reference< css::chart2::XDataSeries > const & xDataSeries ) const;
    css::uno::Reference< css::beans::XPropertySet >
                        CreateErrorBar( sal_uInt8 nPosBarId, sal_uInt8 nNegBarId ) const;

private:
    typedef ::std::map<sal_uInt16, XclImpChDataFormatRef> XclImpChDataFormatMap;
    typedef ::std::map<sal_uInt16, XclImpChTextRef>       XclImpChTextMap;
    typedef ::std::map<sal_uInt8, std::unique_ptr<XclImpChSerErrorBar>> XclImpChSerErrorBarMap;

    XclChSeries         maData;             
    XclImpChSourceLinkRef mxValueLink;      
    XclImpChSourceLinkRef mxCategLink;      
    XclImpChSourceLinkRef mxTitleLink;      
    XclImpChSourceLinkRef mxBubbleLink;     
    XclImpChDataFormatRef mxSeriesFmt;      
    XclImpChDataFormatMap maPointFmts;      
    XclImpChTextMap     maLabels;           
    std::vector< XclImpChSerTrendLineRef > maTrendLines;  
    XclImpChSerErrorBarMap m_ErrorBars;     
    sal_uInt16          mnGroupIdx;         
    sal_uInt16          mnSeriesIdx;        
    sal_uInt16          mnParentIdx;        
    bool                mbLabelDeleted;     
};

typedef std::shared_ptr< XclImpChSeries > XclImpChSeriesRef;

// Chart type groups ==========================================================

class XclImpChType : protected XclImpChRoot
{
public:
    explicit            XclImpChType( const XclImpChRoot& rRoot );

    void                ReadChType( XclImpStream& rStrm );
    void                Finalize( bool bStockChart );

    sal_uInt16   GetRecId() const { return mnRecId; }
    const XclChTypeInfo& GetTypeInfo() const { return maTypeInfo; }
    bool                IsStacked() const;
    bool                IsPercent() const;
    bool                HasCategoryLabels() const;

    css::uno::Reference< css::chart2::XCoordinateSystem >
                        CreateCoordSystem( bool b3dChart ) const;
    css::uno::Reference< css::chart2::XChartType >
                        CreateChartType( css::uno::Reference< css::chart2::XDiagram > const & xDiagram, bool b3dChart ) const;

private:
    XclChType           maData;             
    sal_uInt16          mnRecId;            
    XclChTypeInfo       maTypeInfo;         
};

class XclImpChChart3d
{
public:
    void                ReadChChart3d( XclImpStream& rStrm );
    bool         IsClustered() const { return ::get_flag( maData.mnFlags, EXC_CHCHART3D_CLUSTER ); }
    void                Convert( ScfPropertySet& rPropSet, bool b3dWallChart ) const;

private:
    XclChChart3d        maData;             
};

typedef std::shared_ptr< XclImpChChart3d > XclImpChChart3dRef;

class XclImpChLegend : public XclImpChGroupBase, protected XclImpChRoot
{
public:
    explicit            XclImpChLegend( const XclImpChRoot& rRoot );

    virtual void        ReadHeaderRecord( XclImpStream& rStrm ) override;
    virtual void        ReadSubRecord( XclImpStream& rStrm ) override;
    void                Finalize();

    css::uno::Reference< css::chart2::XLegend >
                        CreateLegend() const;

private:
    XclChLegend         maData;             
    XclImpChFramePosRef mxFramePos;         
    XclImpChTextRef     mxText;             
    XclImpChFrameRef    mxFrame;            
};

typedef std::shared_ptr< XclImpChLegend > XclImpChLegendRef;

class XclImpChDropBar : public XclImpChFrameBase
{
public:
    explicit            XclImpChDropBar( sal_uInt16 nDropBar );

    virtual void        ReadHeaderRecord( XclImpStream& rStrm ) override;

    void                Convert( const XclImpChRoot& rRoot, ScfPropertySet& rPropSet ) const;

private:
    sal_uInt16          mnDropBar;          
    sal_uInt16          mnBarDist;          
};


class XclImpChTypeGroup : public XclImpChGroupBase, protected XclImpChRoot
{
public:
    explicit            XclImpChTypeGroup( const XclImpChRoot& rRoot );

    virtual void        ReadHeaderRecord( XclImpStream& rStrm ) override;
    virtual void        ReadSubRecord( XclImpStream& rStrm ) override;
    void                Finalize();

    void                AddSeries( XclImpChSeriesRef const & xSeries );
    void                SetUsedFormatIndex( sal_uInt16 nFormatIdx );
    sal_uInt16          PopUnusedFormatIndex();

    sal_uInt16   GetGroupIdx() const { return maData.mnGroupIdx; }
    const XclChExtTypeInfo& GetTypeInfo() const { return maTypeInfo; }
    bool         IsValidGroup() const { return !maSeries.empty(); }
    bool         IsPercent() const { return maType.IsPercent(); }
    bool         Is3dChart() const { return mxChart3d && maTypeInfo.mbSupports3d; }
    bool         Is3dWallChart() const { return Is3dChart() && (maTypeInfo.meTypeCateg != EXC_CHTYPECATEG_PIE); }
    bool         Is3dDeepChart() const { return Is3dWallChart() && mxChart3d && !mxChart3d->IsClustered(); }
    bool         HasCategoryLabels() const { return maType.HasCategoryLabels(); }
    bool                HasVarPointFormat() const;
    bool                HasConnectorLines() const;

    const XclImpChLegendRef& GetLegend() const { return mxLegend; }
    const XclImpChDataFormatRef& GetGroupFormat() const { return mxGroupFmt; }
    OUString            GetSingleSeriesTitle() const;

    void                ConvertChart3d( ScfPropertySet& rPropSet ) const;
    css::uno::Reference< css::chart2::XCoordinateSystem >
                        CreateCoordSystem() const;
    css::uno::Reference< css::chart2::XChartType >
                        CreateChartType( css::uno::Reference< css::chart2::XDiagram > const & xDiagram, sal_Int32 nApiAxesSetIdx ) const;
    css::uno::Reference< css::chart2::data::XLabeledDataSequence >
                        CreateCategSequence() const;

private:
    void                ReadChDropBar( XclImpStream& rStrm );
    void                ReadChChartLine( XclImpStream& rStrm );
    void                ReadChDataFormat( XclImpStream& rStrm );

    bool         HasDropBars() const { return !m_DropBars.empty(); }

    void                InsertDataSeries( css::uno::Reference< css::chart2::XChartType > const & xChartType,
                                          css::uno::Reference< css::chart2::XDataSeries > const & xSeries,
                                          sal_Int32 nApiAxesSetIdx ) const;
    void                CreateDataSeries( css::uno::Reference< css::chart2::XChartType > const & xChartType,
                                          sal_Int32 nApiAxesSetIdx ) const;
    void                CreateStockSeries( css::uno::Reference< css::chart2::XChartType > const & xChartType,
                                           sal_Int32 nApiAxesSetIdx ) const;

private:
    typedef ::std::vector< XclImpChSeriesRef >               XclImpChSeriesVec;
    typedef ::std::map<sal_uInt16, std::unique_ptr<XclImpChDropBar>> XclImpChDropBarMap;
    typedef ::std::map<sal_uInt16, XclImpChLineFormat> XclImpChLineFormatMap;

    XclChTypeGroup      maData;             
    XclImpChType        maType;             
    XclChExtTypeInfo    maTypeInfo;         
    XclImpChSeriesVec   maSeries;           
    XclImpChSeriesRef   mxFirstSeries;      
    XclImpChChart3dRef  mxChart3d;          
    XclImpChLegendRef   mxLegend;           
    XclImpChDropBarMap  m_DropBars;         
    XclImpChLineFormatMap m_ChartLines;     
    XclImpChDataFormatRef mxGroupFmt;       
    std::set< sal_uInt16 >
                        maUnusedFormats;    
};

typedef std::shared_ptr< XclImpChTypeGroup > XclImpChTypeGroupRef;

// Axes =======================================================================

class XclImpChLabelRange : protected XclImpChRoot
{
public:
    explicit            XclImpChLabelRange( const XclImpChRoot& rRoot );
    void                ReadChLabelRange( XclImpStream& rStrm );
    void                ReadChDateRange( XclImpStream& rStrm );
    void                Convert( ScfPropertySet& rPropSet, css::chart2::ScaleData& rScaleData, bool bMirrorOrient ) const;
    void                ConvertAxisPosition( ScfPropertySet& rPropSet, bool b3dChart ) const;

private:
    XclChLabelRange     maLabelData;        
    XclChDateRange      maDateData;         
};

typedef std::shared_ptr< XclImpChLabelRange > XclImpChLabelRangeRef;

class XclImpChValueRange : protected XclImpChRoot
{
public:
    explicit            XclImpChValueRange( const XclImpChRoot& rRoot );
    void                ReadChValueRange( XclImpStream& rStrm );
    void                Convert( css::chart2::ScaleData& rScaleData, bool bMirrorOrient ) const;
    void                ConvertAxisPosition( ScfPropertySet& rPropSet ) const;

private:
    XclChValueRange     maData;             
};

typedef std::shared_ptr< XclImpChValueRange > XclImpChValueRangeRef;

class XclImpChTick : protected XclImpChRoot
{
public:
    explicit            XclImpChTick( const XclImpChRoot& rRoot );
    void                ReadChTick( XclImpStream& rStrm );

    bool         HasLabels() const { return maData.mnLabelPos != EXC_CHTICK_NOLABEL; }
    Color               GetFontColor() const;
    sal_uInt16          GetRotation() const;

    void                Convert( ScfPropertySet& rPropSet ) const;

private:
    XclChTick           maData;             
};

typedef std::shared_ptr< XclImpChTick > XclImpChTickRef;

class XclImpChAxis : public XclImpChGroupBase, public XclImpChFontBase, protected XclImpChRoot
{
public:
    explicit            XclImpChAxis( const XclImpChRoot& rRoot, sal_uInt16 nAxisType = EXC_CHAXIS_NONE );

    virtual void        ReadHeaderRecord( XclImpStream& rStrm ) override;
    virtual void        ReadSubRecord( XclImpStream& rStrm ) override;
    void                Finalize();

    virtual sal_uInt16  GetFontIndex() const override;
    virtual Color       GetFontColor() const override;
    virtual sal_uInt16  GetRotation() const override;

    sal_uInt16   GetAxisType() const { return maData.mnType; }
    sal_Int32    GetApiAxisDimension() const { return maData.GetApiAxisDimension(); }

    css::uno::Reference< css::chart2::XAxis >
                        CreateAxis( const XclImpChTypeGroup& rTypeGroup, const XclImpChAxis* pCrossingAxis ) const;
    void                ConvertWall( ScfPropertySet& rPropSet ) const;
    void                ConvertAxisPosition( ScfPropertySet& rPropSet, const XclImpChTypeGroup& rTypeGroup ) const;

private:
    void                ReadChAxisLine( XclImpStream& rStrm );
    void                CreateWallFrame();

private:
    XclChAxis           maData;             
    XclImpChLabelRangeRef mxLabelRange;     
    XclImpChValueRangeRef mxValueRange;     
    XclImpChTickRef     mxTick;             
    XclImpChFontRef     mxFont;             
    XclImpChLineFormatRef mxAxisLine;       
    XclImpChLineFormatRef mxMajorGrid;      
    XclImpChLineFormatRef mxMinorGrid;      
    XclImpChFrameRef    mxWallFrame;        
    sal_uInt16          mnNumFmtIdx;        
};

typedef std::shared_ptr< XclImpChAxis > XclImpChAxisRef;

class XclImpChAxesSet : public XclImpChGroupBase, protected XclImpChRoot
{
public:
    explicit            XclImpChAxesSet( const XclImpChRoot& rRoot, sal_uInt16 nAxesSetId );

    virtual void        ReadHeaderRecord( XclImpStream& rStrm ) override;
    virtual void        ReadSubRecord( XclImpStream& rStrm ) override;
    void                Finalize();

    bool         IsValidAxesSet() const { return !maTypeGroups.empty(); }
    sal_uInt16   GetAxesSetId() const { return maData.mnAxesSetId; }
    sal_Int32    GetApiAxesSetIndex() const { return maData.GetApiAxesSetIndex(); }

    const XclImpChFramePosRef& GetPlotAreaFramePos() const { return mxFramePos; }
    XclImpChTypeGroupRef GetTypeGroup( sal_uInt16 nGroupIdx ) const;
    XclImpChTypeGroupRef GetFirstTypeGroup() const;
    XclImpChLegendRef   GetLegend() const;
    OUString            GetSingleSeriesTitle() const;

    void                Convert( css::uno::Reference< css::chart2::XDiagram > const & xDiagram ) const;
    void                ConvertTitlePositions() const;

private:
    void                ReadChAxis( XclImpStream& rStrm );
    void                ReadChText( XclImpStream& rStrm );
    void                ReadChPlotFrame( XclImpStream& rStrm );
    void                ReadChTypeGroup( XclImpStream& rStrm );

    css::uno::Reference< css::chart2::XCoordinateSystem >
                        CreateCoordSystem( css::uno::Reference< css::chart2::XDiagram > const & xDiagram ) const;
    void                ConvertAxis( XclImpChAxisRef const & xChAxis, XclImpChTextRef const & xChAxisTitle,
                                     css::uno::Reference< css::chart2::XCoordinateSystem > const & xCoordSystem,
                                     const XclImpChAxis* pCrossingAxis ) const;
    css::uno::Reference< css::chart2::XAxis >
                        CreateAxis( const XclImpChAxis& rChAxis, const XclImpChAxis* pCrossingAxis ) const;
    void                ConvertBackground( css::uno::Reference< css::chart2::XDiagram > const & xDiagram ) const;

private:
    typedef ::std::map<sal_uInt16, XclImpChTypeGroupRef> XclImpChTypeGroupMap;

    XclChAxesSet        maData;             
    XclImpChFramePosRef mxFramePos;         
    XclImpChAxisRef     mxXAxis;            
    XclImpChAxisRef     mxYAxis;            
    XclImpChAxisRef     mxZAxis;            
    XclImpChTextRef     mxXAxisTitle;       
    XclImpChTextRef     mxYAxisTitle;       
    XclImpChTextRef     mxZAxisTitle;       
    XclImpChFrameRef    mxPlotFrame;        
    XclImpChTypeGroupMap maTypeGroups;      
};

typedef std::shared_ptr< XclImpChAxesSet > XclImpChAxesSetRef;

// The chart object ===========================================================

class XclImpChChart : public XclImpChGroupBase, protected XclImpChRoot
{
public:
    explicit            XclImpChChart( const XclImpRoot& rRoot );
    virtual             ~XclImpChChart() override;

    virtual void        ReadHeaderRecord( XclImpStream& rStrm ) override;
    virtual void        ReadSubRecord( XclImpStream& rStrm ) override;
    void                ReadChDefaultText( XclImpStream& rStrm );
    void                ReadChDataFormat( XclImpStream& rStrm );

    void                UpdateObjFrame( const XclObjLineData& rLineData, const XclObjFillData& rFillData );

    XclImpChTypeGroupRef GetTypeGroup( sal_uInt16 nGroupIdx ) const;
    const XclImpChText*  GetDefaultText( XclChTextType eTextType ) const;
    bool                IsManualPlotArea() const;
    static std::size_t GetProgressSize() { return 2 * EXC_CHART_PROGRESS_SIZE; }

    void                Convert(
        const css::uno::Reference< css::chart2::XChartDocument>& xChartDoc,
        XclImpDffConverter& rDffConv,
        const OUString& rObjName,
        const tools::Rectangle& rChartRect ) const;

private:
    void                ReadChSeries( XclImpStream& rStrm );
    void                ReadChProperties( XclImpStream& rStrm );
    void                ReadChAxesSet( XclImpStream& rStrm );
    void                ReadChText( XclImpStream& rStrm );

    void                Finalize();
    void                FinalizeSeries();
    void                FinalizeDataFormats();
    void                FinalizeTitle();

    css::uno::Reference<css::chart2::XDiagram>
        CreateDiagram() const;

private:
    typedef ::std::vector< XclImpChSeriesRef >                   XclImpChSeriesVec;
    typedef ::std::map<XclChDataPointPos, XclImpChDataFormatRef> XclImpChDataFormatMap;
    typedef ::std::map<sal_uInt16, std::unique_ptr<XclImpChText>> XclImpChTextMap;

    XclChRectangle      maRect;             
    XclImpChSeriesVec   maSeries;           
    XclImpChDataFormatMap maDataFmts;       
    XclImpChFrameRef    mxFrame;            
    XclChProperties     maProps;            
    XclImpChTextMap     m_DefTexts;         
    XclImpChAxesSetRef  mxPrimAxesSet;      
    XclImpChAxesSetRef  mxSecnAxesSet;      
    XclImpChTextRef     mxTitle;            
    XclImpChLegendRef   mxLegend;           
};

typedef std::shared_ptr< XclImpChChart > XclImpChChartRef;

class XclImpChartDrawing : public XclImpDrawing
{
public:
    explicit            XclImpChartDrawing( const XclImpRoot& rRoot, bool bOwnTab );

    void                ConvertObjects(
                            XclImpDffConverter& rDffConv,
                            const css::uno::Reference< css::frame::XModel >& rxModel,
                            const tools::Rectangle& rChartRect );

    virtual tools::Rectangle   CalcAnchorRect( const XclObjAnchor& rAnchor, bool bDffAnchor ) const override;
    virtual void        OnObjectInserted( const XclImpDrawObjBase& rDrawObj ) override;

private:
    tools::Rectangle           maChartRect;        
    SCTAB               mnScTab;            
    bool                mbOwnTab;           
};

class XclImpChart : protected XclImpRoot
{
public:
    explicit            XclImpChart( const XclImpRoot& rRoot, bool bOwnTab );
    virtual             ~XclImpChart() override;

    void                ReadChartSubStream( XclImpStream& rStrm );
    void                UpdateObjFrame( const XclObjLineData& rLineData, const XclObjFillData& rFillData );

    std::size_t         GetProgressSize() const;
    bool         IsPivotChart() const { return mbIsPivotChart; }

    void                Convert( css::uno::Reference< css::frame::XModel > const & xModel,
                            XclImpDffConverter& rDffConv,
                            const OUString& rObjName,
                            const tools::Rectangle& rChartRect ) const;

private:
    XclImpChartDrawing& GetChartDrawing();
    void                ReadChChart( XclImpStream& rStrm );

private:
    typedef std::shared_ptr< XclImpChartDrawing > XclImpChartDrawingRef;

    XclImpChChartRef    mxChartData;        
    XclImpChartDrawingRef mxChartDrawing;   
    bool                mbOwnTab;           
    bool                mbIsPivotChart;     
};

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