xechart.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 "xerecord.hxx"
#include "xlchart.hxx"
#include "xlformula.hxx"
#include "xlstyle.hxx"
#include "xeroot.hxx"
#include "xestring.hxx"
 
#include <memory>
#include <map>
 
class Size;
namespace tools { class Rectangle; }
 
namespace com::sun::star {
    namespace awt
    {
        struct Rectangle;
    }
    namespace frame
    {
        class XModel;
    }
    namespace chart
    {
        class XAxis;
    }
    namespace chart2
    {
        struct ScaleData;
        class XChartDocument;
        class XDiagram;
        class XCoordinateSystem;
        class XChartType;
        class XDataSeries;
        class XAxis;
        class XTitle;
        class XFormattedString;
        class XRegressionCurve;
        namespace data
        {
            class XDataSequence;
            class XLabeledDataSequence;
        }
    }
}
 
// Common =====================================================================
 
struct XclExpChRootData;
class XclExpChChart;
 
class XclExpChRoot : public XclExpRoot
{
public:
    explicit            XclExpChRoot( const XclExpRoot& rRoot, XclExpChChart& rChartData );
    virtual             ~XclExpChRoot() override;
 
    XclExpChRoot(XclExpChRoot const &) = default;
    XclExpChRoot(XclExpChRoot &&) = default;
    XclExpChRoot & operator =(XclExpChRoot const &) = delete; // due to XclExpRoot
    XclExpChRoot & operator =(XclExpChRoot &&) = delete; // due to XclExpRoot
 
    const XclExpChRoot& GetChRoot() const { return *this; }
    css::uno::Reference< css::chart2::XChartDocument > const &
                        GetChartDocument() const;
    XclExpChChart&      GetChartData() const;
    const XclChTypeInfo& GetChartTypeInfo( XclChTypeId eType ) const;
    const XclChTypeInfo& GetChartTypeInfo( std::u16string_view rServiceName ) const;
 
    const XclChFormatInfo& GetFormatInfo( XclChObjectType eObjType ) const;
 
    void                InitConversion( css::uno::Reference< css::chart2::XChartDocument > const & xChartDoc,
                                        const tools::Rectangle& rChartRect ) const;
    void                FinishConversion() const;
 
    bool                IsSystemColor( const Color& rColor, sal_uInt16 nSysColorIdx ) const;
    void                SetSystemColor( Color& rColor, sal_uInt32& rnColorId, sal_uInt16 nSysColorIdx ) const;
 
    sal_Int32           CalcChartXFromHmm( sal_Int32 nPosX ) const;
    sal_Int32           CalcChartYFromHmm( sal_Int32 nPosY ) const;
    XclChRectangle      CalcChartRectFromHmm( const css::awt::Rectangle& rRect ) const;
 
    void                ConvertLineFormat(
                            XclChLineFormat& rLineFmt,
                            const ScfPropertySet& rPropSet,
                            XclChPropertyMode ePropMode ) const;
    bool                ConvertAreaFormat(
                            XclChAreaFormat& rAreaFmt,
                            const ScfPropertySet& rPropSet,
                            XclChPropertyMode ePropMode ) const;
    void                ConvertEscherFormat(
                            XclChEscherFormat& rEscherFmt,
                            XclChPicFormat& rPicFmt,
                            const ScfPropertySet& rPropSet,
                            XclChPropertyMode ePropMode ) const;
    sal_uInt16          ConvertFont(
                            const ScfPropertySet& rPropSet,
                            sal_Int16 nScript ) const;
 
    static sal_uInt16   ConvertPieRotation( const ScfPropertySet& rPropSet );
 
protected:
    void                RegisterFutureRecBlock( const XclChFrBlock& rFrBlock );
    void                InitializeFutureRecBlock( XclExpStream& rStrm );
    void                FinalizeFutureRecBlock( XclExpStream& rStrm );
 
private:
    typedef std::shared_ptr< XclExpChRootData > XclExpChRootDataRef;
    XclExpChRootDataRef mxChData;           
};
 
class XclExpChGroupBase : public XclExpRecord, protected XclExpChRoot
{
public:
    explicit            XclExpChGroupBase(
                            const XclExpChRoot& rRoot, sal_uInt16 nFrType,
                            sal_uInt16 nRecId, std::size_t nRecSize = 0 );
    virtual             ~XclExpChGroupBase() override;
 
    virtual void        Save( XclExpStream& rStrm ) override;
    virtual bool        HasSubRecords() const;
    virtual void        WriteSubRecords( XclExpStream& rStrm ) = 0;
 
protected:
    void                SetFutureRecordContext( sal_uInt16 nFrContext,
                            sal_uInt16 nFrValue1 = 0, sal_uInt16 nFrValue2 = 0 );
 
private:
    XclChFrBlock        maFrBlock;          
};
 
class XclExpChFutureRecordBase : public XclExpFutureRecord, protected XclExpChRoot
{
public:
    explicit            XclExpChFutureRecordBase( const XclExpChRoot& rRoot,
                            XclFutureRecType eRecType, sal_uInt16 nRecId, std::size_t nRecSize );
 
    virtual void        Save( XclExpStream& rStrm ) override;
};
 
// Frame formatting ===========================================================
 
class XclExpChFramePos : public XclExpRecord
{
public:
    explicit            XclExpChFramePos( sal_uInt16 nTLMode );
 
    XclChFramePos& GetFramePosData() { return maData; }
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclChFramePos       maData;             
};
 
typedef rtl::Reference< XclExpChFramePos > XclExpChFramePosRef;
 
class XclExpChLineFormat : public XclExpRecord
{
public:
    explicit            XclExpChLineFormat( const XclExpChRoot& rRoot );
 
    void                Convert( const XclExpChRoot& rRoot,
                            const ScfPropertySet& rPropSet, XclChObjectType eObjType );
    void         SetAuto( bool bAuto ) { ::set_flag( maData.mnFlags, EXC_CHLINEFORMAT_AUTO, bAuto ); }
    void         SetShowAxis( bool bShowAxis )
                            { ::set_flag( maData.mnFlags, EXC_CHLINEFORMAT_SHOWAXIS, bShowAxis ); }
    void                SetDefault( XclChFrameType eDefFrameType );
 
    bool         IsAuto() const { return ::get_flag( maData.mnFlags, EXC_CHLINEFORMAT_AUTO ); }
    bool         HasLine() const { return maData.mnPattern != EXC_CHLINEFORMAT_NONE; }
    bool                IsDefault( XclChFrameType eDefFrameType ) const;
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclChLineFormat     maData;             
    sal_uInt32          mnColorId;          
};
 
typedef rtl::Reference< XclExpChLineFormat > XclExpChLineFormatRef;
 
class XclExpChAreaFormat : public XclExpRecord
{
public:
    explicit            XclExpChAreaFormat( const XclExpChRoot& rRoot );
 
    bool                Convert( const XclExpChRoot& rRoot,
                            const ScfPropertySet& rPropSet, XclChObjectType eObjType );
    void         SetAuto( bool bAuto ) { ::set_flag( maData.mnFlags, EXC_CHAREAFORMAT_AUTO, bAuto ); }
    void                SetDefault( XclChFrameType eDefFrameType );
 
    bool         IsAuto() const { return ::get_flag( maData.mnFlags, EXC_CHAREAFORMAT_AUTO ); }
    bool         HasArea() const { return maData.mnPattern != EXC_PATT_NONE; }
    bool                IsDefault( XclChFrameType eDefFrameType ) const;
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclChAreaFormat     maData;             
    sal_uInt32          mnPattColorId;      
    sal_uInt32          mnBackColorId;      
};
 
typedef rtl::Reference< XclExpChAreaFormat > XclExpChAreaFormatRef;
 
class XclExpChEscherFormat : public XclExpChGroupBase
{
public:
    explicit            XclExpChEscherFormat( const XclExpChRoot& rRoot );
 
    void                Convert( const ScfPropertySet& rPropSet, XclChObjectType eObjType );
 
    bool                IsValid() const;
 
    virtual void        Save( XclExpStream& rStrm ) override;
    virtual bool        HasSubRecords() const override;
    virtual void        WriteSubRecords( XclExpStream& rStrm ) override;
 
private:
    sal_uInt32          RegisterColor( sal_uInt16 nPropId );
 
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclChEscherFormat   maData;             
    XclChPicFormat      maPicFmt;           
    sal_uInt32          mnColor1Id;         
    sal_uInt32          mnColor2Id;         
};
 
typedef rtl::Reference< XclExpChEscherFormat > XclExpChEscherFormatRef;
 
class XclExpChFrameBase
{
public:
    explicit            XclExpChFrameBase();
    virtual             ~XclExpChFrameBase();
 
protected:
    void                ConvertFrameBase( const XclExpChRoot& rRoot,
                            const ScfPropertySet& rPropSet, XclChObjectType eObjType );
    void                SetDefaultFrameBase( const XclExpChRoot& rRoot,
                            XclChFrameType eDefFrameType, bool bIsFrame );
 
    bool                IsDefaultFrameBase( XclChFrameType eDefFrameType ) const;
 
    void                WriteFrameRecords( XclExpStream& rStrm );
 
private:
    XclExpChLineFormatRef mxLineFmt;        
    XclExpChAreaFormatRef mxAreaFmt;        
    XclExpChEscherFormatRef mxEscherFmt;    
};
 
class XclExpChFrame : public XclExpChGroupBase, public XclExpChFrameBase
{
public:
    explicit            XclExpChFrame( const XclExpChRoot& rRoot, XclChObjectType eObjType );
 
    void                Convert( const ScfPropertySet& rPropSet );
    void                SetAutoFlags( bool bAutoPos, bool bAutoSize );
 
    bool                IsDefault() const;
    bool                IsDeleteable() const;
 
    virtual void        Save( XclExpStream& rStrm ) override;
    virtual void        WriteSubRecords( XclExpStream& rStrm ) override;
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclChFrame          maData;             
    XclChObjectType     meObjType;          
};
 
typedef rtl::Reference< XclExpChFrame > XclExpChFrameRef;
 
// Source links ===============================================================
 
class XclExpChSourceLink : public XclExpRecord, protected XclExpChRoot
{
public:
    explicit            XclExpChSourceLink( const XclExpChRoot& rRoot, sal_uInt8 nDestType );
 
    void                ConvertString( const OUString& aString );
    sal_uInt16          ConvertDataSequence( css::uno::Reference< css::chart2::data::XDataSequence > const & xDataSeq,
                                             bool bSplitToColumns, sal_uInt16 nDefCount = 0 );
    sal_uInt16          ConvertStringSequence( const css::uno::Sequence< css::uno::Reference< css::chart2::XFormattedString > >& rStringSeq );
    void                ConvertNumFmt( const ScfPropertySet& rPropSet, bool bPercent );
 
    void                AppendString( std::u16string_view rStr );
 
    bool         HasString() const { return mxString && !mxString->IsEmpty(); }
 
    virtual void        Save( XclExpStream& rStrm ) override;
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclChSourceLink     maData;             
    XclTokenArrayRef    mxLinkFmla;         
    XclExpStringRef     mxString;           
};
 
typedef rtl::Reference< XclExpChSourceLink > XclExpChSourceLinkRef;
 
// Text =======================================================================
 
class XclExpChFont : public XclExpUInt16Record
{
public:
    explicit            XclExpChFont( sal_uInt16 nFontIdx );
};
 
typedef rtl::Reference< XclExpChFont > XclExpChFontRef;
 
class XclExpChObjectLink : public XclExpRecord
{
public:
    explicit            XclExpChObjectLink( sal_uInt16 nLinkTarget, const XclChDataPointPos& rPointPos );
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclChObjectLink     maData;             
};
 
typedef rtl::Reference< XclExpChObjectLink > XclExpChObjectLinkRef;
 
class XclExpChFrLabelProps : public XclExpChFutureRecordBase
{
public:
    explicit            XclExpChFrLabelProps( const XclExpChRoot& rRoot );
 
    void                Convert(
                            const ScfPropertySet& rPropSet,
                            bool bShowCateg, bool bShowValue,
                            bool bShowPercent, bool bShowBubble );
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclChFrLabelProps   maData;             
};
 
typedef rtl::Reference< XclExpChFrLabelProps > XclExpChFrLabelPropsRef;
 
class XclExpChFontBase
{
public:
    virtual             ~XclExpChFontBase();
 
    virtual void SetFont( XclExpChFontRef xFont, const model::ComplexColor& rComplexColor, sal_uInt32 nColorId ) = 0;
    virtual void        SetRotation( sal_uInt16 nRotation ) = 0;
 
    void                ConvertFontBase( const XclExpChRoot& rRoot, sal_uInt16 nFontIdx );
    void                ConvertFontBase( const XclExpChRoot& rRoot, const ScfPropertySet& rPropSet );
    void                ConvertRotationBase( const ScfPropertySet& rPropSet, bool bSupportsStacked );
};
 
class XclExpChText : public XclExpChGroupBase, public XclExpChFontBase
{
public:
    explicit            XclExpChText( const XclExpChRoot& rRoot );
 
    virtual void SetFont( XclExpChFontRef xFont, model::ComplexColor const& rComplexColor, sal_uInt32 nColorId ) override;
    virtual void        SetRotation( sal_uInt16 nRotation ) override;
 
    void                ConvertTitle( css::uno::Reference< css::chart2::XTitle > const & xTitle, sal_uInt16 nTarget, const OUString* pSubTitle );
    void                ConvertLegend( const ScfPropertySet& rPropSet );
    bool                ConvertDataLabel( const ScfPropertySet& rPropSet,
                            const XclChTypeInfo& rTypeInfo, const XclChDataPointPos& rPointPos );
    void                ConvertTrendLineEquation( const ScfPropertySet& rPropSet, const XclChDataPointPos& rPointPos );
 
    bool         HasString() const { return mxSrcLink && mxSrcLink->HasString(); }
    sal_uInt16          GetAttLabelFlags() const;
 
    virtual void        WriteSubRecords( XclExpStream& rStrm ) override;
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclChText           maData;             
    XclExpChFramePosRef mxFramePos;         
    XclExpChSourceLinkRef mxSrcLink;        
    XclExpChFrameRef    mxFrame;            
    XclExpChFontRef     mxFont;             
    XclExpChObjectLinkRef mxObjLink;        
    XclExpChFrLabelPropsRef mxLabelProps;   
    sal_uInt32          mnTextColorId;      
};
 
typedef rtl::Reference< XclExpChText > XclExpChTextRef;
 
// Data series ================================================================
 
class XclExpChMarkerFormat : public XclExpRecord
{
public:
    explicit            XclExpChMarkerFormat( const XclExpChRoot& rRoot );
 
    void                Convert( const XclExpChRoot& rRoot,
                            const ScfPropertySet& rPropSet, sal_uInt16 nFormatIdx );
    void                ConvertStockSymbol( const XclExpChRoot& rRoot,
                            const ScfPropertySet& rPropSet, bool bCloseSymbol );
 
    bool         HasMarker() const { return maData.mnMarkerType != EXC_CHMARKERFORMAT_NOSYMBOL; }
    bool         HasLineColor() const { return !::get_flag( maData.mnFlags, EXC_CHMARKERFORMAT_NOLINE ); }
    bool         HasFillColor() const { return !::get_flag( maData.mnFlags, EXC_CHMARKERFORMAT_NOFILL ); }
 
private:
    void                RegisterColors( const XclExpChRoot& rRoot );
 
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclChMarkerFormat   maData;             
    sal_uInt32          mnLineColorId;      
    sal_uInt32          mnFillColorId;      
};
 
typedef rtl::Reference< XclExpChMarkerFormat > XclExpChMarkerFormatRef;
 
class XclExpChPieFormat : public XclExpUInt16Record
{
public:
    explicit            XclExpChPieFormat();
 
    void                Convert( const ScfPropertySet& rPropSet );
};
 
typedef rtl::Reference< XclExpChPieFormat > XclExpChPieFormatRef;
 
class XclExpCh3dDataFormat : public XclExpRecord
{
public:
    explicit            XclExpCh3dDataFormat();
 
    void                Convert( const ScfPropertySet& rPropSet );
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclCh3dDataFormat   maData;             
};
 
typedef rtl::Reference< XclExpCh3dDataFormat > XclExpCh3dDataFormatRef;
 
class XclExpChAttachedLabel : public XclExpUInt16Record
{
public:
    explicit            XclExpChAttachedLabel( sal_uInt16 nFlags );
};
 
typedef rtl::Reference< XclExpChAttachedLabel > XclExpChAttLabelRef;
 
class XclExpChDataFormat : public XclExpChGroupBase, public XclExpChFrameBase
{
public:
    explicit            XclExpChDataFormat( const XclExpChRoot& rRoot,
                            const XclChDataPointPos& rPointPos, sal_uInt16 nFormatIdx );
 
    void                ConvertDataSeries( const ScfPropertySet& rPropSet, const XclChExtTypeInfo& rTypeInfo );
    void                ConvertStockSeries( const ScfPropertySet& rPropSet, bool bCloseSymbol );
    void                ConvertLine( const ScfPropertySet& rPropSet, XclChObjectType eObjType );
 
    bool         IsSeriesFormat() const { return maData.maPointPos.mnPointIdx == EXC_CHDATAFORMAT_ALLPOINTS; }
 
    virtual void        WriteSubRecords( XclExpStream& rStrm ) override;
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclChDataFormat     maData;             
    XclExpChMarkerFormatRef mxMarkerFmt;    
    XclExpChPieFormatRef mxPieFmt;          
    XclExpRecordRef     mxSeriesFmt;        
    XclExpCh3dDataFormatRef mx3dDataFmt;    
    XclExpChAttLabelRef mxAttLabel;         
};
 
typedef rtl::Reference< XclExpChDataFormat > XclExpChDataFormatRef;
 
class XclExpChSerTrendLine : public XclExpRecord, protected XclExpChRoot
{
public:
    explicit            XclExpChSerTrendLine( const XclExpChRoot& rRoot );
 
    bool                Convert( css::uno::Reference< css::chart2::XRegressionCurve > const & xRegCurve,
                                 sal_uInt16 nSeriesIdx );
 
    const XclExpChDataFormatRef& GetDataFormat() const { return mxDataFmt; }
    const XclExpChTextRef& GetDataLabel() const { return mxLabel; }
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclChSerTrendLine   maData;             
    XclExpChDataFormatRef mxDataFmt;        
    XclExpChTextRef     mxLabel;            
};
 
typedef rtl::Reference< XclExpChSerTrendLine > XclExpChSerTrendLineRef;
 
class XclExpChSerErrorBar : public XclExpRecord, protected XclExpChRoot
{
public:
    explicit            XclExpChSerErrorBar( const XclExpChRoot& rRoot, sal_uInt8 nBarType );
 
    bool                Convert( XclExpChSourceLink& rValueLink, sal_uInt16& rnValueCount, const ScfPropertySet& rPropSet );
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclChSerErrorBar    maData;             
};
 
typedef rtl::Reference< XclExpChSerErrorBar > XclExpChSerErrorBarRef;
 
class XclExpChSeries : public XclExpChGroupBase
{
public:
    explicit            XclExpChSeries( const XclExpChRoot& rRoot, sal_uInt16 nSeriesIdx );
 
    bool                ConvertDataSeries(
                            css::uno::Reference< css::chart2::XDiagram > const & xDiagram,
                            css::uno::Reference< css::chart2::XDataSeries > const & xDataSeries,
                            const XclChExtTypeInfo& rTypeInfo,
                            sal_uInt16 nGroupIdx, sal_uInt16 nFormatIdx );
    bool                ConvertStockSeries(
                            css::uno::Reference< css::chart2::XDataSeries > const & xDataSeries,
                            std::u16string_view rValueRole,
                            sal_uInt16 nGroupIdx, sal_uInt16 nFormatIdx, bool bCloseSymbol );
    bool                ConvertTrendLine( const XclExpChSeries& rParent,
                                          css::uno::Reference< css::chart2::XRegressionCurve > const & xRegCurve );
    bool                ConvertErrorBar( const XclExpChSeries& rParent, const ScfPropertySet& rPropSet, sal_uInt8 nBarId );
    void                ConvertCategSequence( css::uno::Reference< css::chart2::data::XLabeledDataSequence > const & xCategSeq );
 
    virtual void        WriteSubRecords( XclExpStream& rStrm ) override;
 
private:
    void                InitFromParent( const XclExpChSeries& rParent );
    void                CreateTrendLines( css::uno::Reference< css::chart2::XDataSeries > const & xDataSeries );
    void                CreateErrorBars( const ScfPropertySet& rPropSet,
                            const OUString& rBarPropName,
                            sal_uInt8 nPosBarId, sal_uInt8 nNegBarId );
    void                CreateErrorBar( const ScfPropertySet& rPropSet,
                            const OUString& rShowPropName, sal_uInt8 nBarId );
 
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
 
private:
    XclChSeries         maData;             
    XclExpChSourceLinkRef mxTitleLink;      
    XclExpChSourceLinkRef mxValueLink;      
    XclExpChSourceLinkRef mxCategLink;      
    XclExpChSourceLinkRef mxBubbleLink;     
    XclExpChDataFormatRef mxSeriesFmt;      
    XclExpRecordList< XclExpChDataFormat >
                          maPointFmts;     
    XclExpChSerTrendLineRef mxTrendLine;    
    XclExpChSerErrorBarRef mxErrorBar;      
    sal_uInt16          mnGroupIdx;         
    sal_uInt16          mnSeriesIdx;        
    sal_uInt16          mnParentIdx;        
};
 
typedef rtl::Reference< XclExpChSeries > XclExpChSeriesRef;
 
// Chart type groups ==========================================================
 
class XclExpChType : public XclExpRecord, protected XclExpChRoot
{
public:
    explicit            XclExpChType( const XclExpChRoot& rRoot );
 
    void                Convert( css::uno::Reference< css::chart2::XDiagram > const & xDiagram,
                                 css::uno::Reference< css::chart2::XChartType > const & xChartType,
                                 sal_Int32 nApiAxesSetIdx, bool bSwappedAxesSet, bool bHasXLabels );
    void                SetStacked( bool bPercent );
 
    bool         IsValidType() const { return maTypeInfo.meTypeId != EXC_CHTYPEID_UNKNOWN; }
    const XclChTypeInfo& GetTypeInfo() const { return maTypeInfo; }
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclChType           maData;             
    XclChTypeInfo       maTypeInfo;         
};
 
class XclExpChChart3d : public XclExpRecord
{
public:
    explicit            XclExpChChart3d();
 
    void                Convert( const ScfPropertySet& rPropSet, bool b3dWallChart );
    void         SetClustered() { ::set_flag( maData.mnFlags, EXC_CHCHART3D_CLUSTER ); }
 
    bool         IsClustered() const { return ::get_flag( maData.mnFlags, EXC_CHCHART3D_CLUSTER ); }
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclChChart3d        maData;             
};
 
typedef rtl::Reference< XclExpChChart3d > XclExpChChart3dRef;
 
class XclExpChLegend : public XclExpChGroupBase
{
public:
    explicit            XclExpChLegend( const XclExpChRoot& rRoot );
 
    void                Convert( const ScfPropertySet& rPropSet );
 
    virtual void        WriteSubRecords( XclExpStream& rStrm ) override;
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclChLegend         maData;             
    XclExpChFramePosRef mxFramePos;         
    XclExpChTextRef     mxText;             
    XclExpChFrameRef    mxFrame;            
};
 
typedef rtl::Reference< XclExpChLegend > XclExpChLegendRef;
 
class XclExpChDropBar : public XclExpChGroupBase, public XclExpChFrameBase
{
public:
    explicit            XclExpChDropBar( const XclExpChRoot& rRoot, XclChObjectType eObjType );
 
    void                Convert( const ScfPropertySet& rPropSet );
 
    virtual void        WriteSubRecords( XclExpStream& rStrm ) override;
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclChObjectType     meObjType;          
};
 
typedef rtl::Reference< XclExpChDropBar > XclExpChDropBarRef;
 
class XclExpChTypeGroup : public XclExpChGroupBase
{
public:
    explicit            XclExpChTypeGroup( const XclExpChRoot& rRoot, sal_uInt16 nGroupIdx );
 
    void                ConvertType( css::uno::Reference< css::chart2::XDiagram > const & xDiagram,
                            css::uno::Reference< css::chart2::XChartType > const & xChartType,
                            sal_Int32 nApiAxesSetIdx, bool b3dChart, bool bSwappedAxesSet, bool bHasXLabels );
    void                ConvertSeries( css::uno::Reference< css::chart2::XDiagram > const & xDiagram,
                            css::uno::Reference< css::chart2::XChartType > const & xChartType,
                            sal_Int32 nGroupAxesSetIdx, bool bPercent, bool bConnectorLines );
    void                ConvertCategSequence( css::uno::Reference< css::chart2::data::XLabeledDataSequence > const & xCategSeq );
    void                ConvertLegend( const ScfPropertySet& rPropSet );
 
    bool         IsValidGroup() const { return !maSeries.IsEmpty() && maType.IsValidType(); }
    sal_uInt16   GetGroupIdx() const { return maData.mnGroupIdx; }
    const XclChExtTypeInfo& GetTypeInfo() const { return maTypeInfo; }
    bool         Is3dChart() const { return maTypeInfo.mb3dChart; }
    bool         Is3dWallChart() const { return Is3dChart() && (maTypeInfo.meTypeCateg != EXC_CHTYPECATEG_PIE); }
    bool         Is3dDeepChart() const { return Is3dWallChart() && mxChart3d && !mxChart3d->IsClustered(); }
    bool         IsCombinable2d() const { return !Is3dChart() && maTypeInfo.mbCombinable2d; }
 
    virtual void        WriteSubRecords( XclExpStream& rStrm ) override;
 
private:
    sal_uInt16          GetFreeFormatIdx() const;
    void                CreateDataSeries( css::uno::Reference< css::chart2::XDiagram > const & xDiagram,
                            css::uno::Reference< css::chart2::XDataSeries > const & xDataSeries );
    void                CreateAllStockSeries( css::uno::Reference< css::chart2::XChartType > const & xChartType,
                            css::uno::Reference< css::chart2::XDataSeries > const & xDataSeries );
    bool                CreateStockSeries( css::uno::Reference< css::chart2::XDataSeries > const & xDataSeries,
                            std::u16string_view rValueRole, bool bCloseSymbol );
 
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    typedef XclExpRecordList< XclExpChSeries >          XclExpChSeriesList;
 
    XclChTypeGroup      maData;             
    XclExpChType        maType;             
    XclChExtTypeInfo    maTypeInfo;         
    XclExpChSeriesList  maSeries;           
    XclExpChChart3dRef  mxChart3d;          
    XclExpChLegendRef   mxLegend;           
    XclExpChDropBarRef  mxUpBar;            
    XclExpChDropBarRef  mxDownBar;          
    std::map<sal_uInt16, std::unique_ptr<XclExpChLineFormat>>
                        m_ChartLines;     
};
 
typedef rtl::Reference< XclExpChTypeGroup > XclExpChTypeGroupRef;
 
// Axes =======================================================================
 
class XclExpChLabelRange : public XclExpRecord, protected XclExpChRoot
{
public:
    explicit            XclExpChLabelRange( const XclExpChRoot& rRoot );
 
    void                Convert( const css::chart2::ScaleData& rScaleData,
                            const ScfPropertySet& rChart1Axis, bool bMirrorOrient );
    void                ConvertAxisPosition( const ScfPropertySet& rPropSet );
    void         SetTicksBetweenCateg( bool bTicksBetween )
                            { ::set_flag( maLabelData.mnFlags, EXC_CHLABELRANGE_BETWEEN, bTicksBetween ); }
 
private:
    virtual void        Save( XclExpStream& rStrm ) override;
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclChLabelRange     maLabelData;        
    XclChDateRange      maDateData;         
};
 
typedef rtl::Reference< XclExpChLabelRange > XclExpChLabelRangeRef;
 
class XclExpChValueRange : public XclExpRecord, protected XclExpChRoot
{
public:
    explicit            XclExpChValueRange( const XclExpChRoot& rRoot );
 
    void                Convert( const css::chart2::ScaleData& rScaleData );
    void                ConvertAxisPosition( const ScfPropertySet& rPropSet );
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclChValueRange     maData;             
};
 
typedef rtl::Reference< XclExpChValueRange > XclExpChValueRangeRef;
 
class XclExpChTick : public XclExpRecord, protected XclExpChRoot
{
public:
    explicit            XclExpChTick( const XclExpChRoot& rRoot );
 
    void                Convert( const ScfPropertySet& rPropSet, const XclChExtTypeInfo& rTypeInfo, sal_uInt16 nAxisType );
    void SetFontColor(model::ComplexColor const& rComplexColor, sal_uInt32 nColorId);
 
    void                SetRotation( sal_uInt16 nRotation );
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclChTick           maData;             
    sal_uInt32          mnTextColorId;      
};
 
typedef rtl::Reference< XclExpChTick > XclExpChTickRef;
 
class XclExpChAxis : public XclExpChGroupBase, public XclExpChFontBase
{
public:
    explicit            XclExpChAxis( const XclExpChRoot& rRoot, sal_uInt16 nAxisType );
 
    virtual void SetFont( XclExpChFontRef xFont, model::ComplexColor const& rComplexColor, sal_uInt32 nColorId ) override;
    virtual void        SetRotation( sal_uInt16 nRotation ) override;
 
    void                Convert( css::uno::Reference< css::chart2::XAxis > const & xAxis,
                            css::uno::Reference< css::chart2::XAxis > const & xCrossingAxis,
                            css::uno::Reference< css::chart::XAxis > const & xChart1Axis,
                            const XclChExtTypeInfo& rTypeInfo );
    void                ConvertWall( css::uno::Reference< css::chart2::XDiagram > const & xDiagram );
 
    sal_uInt16   GetAxisType() const { return maData.mnType; }
    sal_Int32    GetApiAxisDimension() const { return maData.GetApiAxisDimension(); }
 
    virtual void        WriteSubRecords( XclExpStream& rStrm ) override;
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclChAxis           maData;             
    XclExpChLabelRangeRef mxLabelRange;     
    XclExpChValueRangeRef mxValueRange;     
    XclExpChTickRef     mxTick;             
    XclExpChFontRef     mxFont;             
    XclExpChLineFormatRef mxAxisLine;       
    XclExpChLineFormatRef mxMajorGrid;      
    XclExpChLineFormatRef mxMinorGrid;      
    XclExpChFrameRef    mxWallFrame;        
    sal_uInt16          mnNumFmtIdx;        
};
 
typedef rtl::Reference< XclExpChAxis > XclExpChAxisRef;
 
class XclExpChAxesSet : public XclExpChGroupBase
{
public:
    explicit            XclExpChAxesSet( const XclExpChRoot& rRoot, sal_uInt16 nAxesSetId );
 
    sal_uInt16          Convert( css::uno::Reference< css::chart2::XDiagram > const & xDiagram,
                                 sal_uInt16 nFirstGroupIdx );
 
    bool         IsValidAxesSet() const { return !maTypeGroups.IsEmpty(); }
    sal_uInt16   GetAxesSetId() const { return maData.mnAxesSetId; }
    sal_Int32    GetApiAxesSetIndex() const { return maData.GetApiAxesSetIndex(); }
    bool                Is3dChart() const;
 
    virtual void        WriteSubRecords( XclExpStream& rStrm ) override;
 
private:
    XclExpChTypeGroupRef GetFirstTypeGroup() const;
    XclExpChTypeGroupRef GetLastTypeGroup() const;
 
    void                ConvertAxis( XclExpChAxisRef& rxChAxis, sal_uInt16 nAxisType,
                            XclExpChTextRef& rxChAxisTitle, sal_uInt16 nTitleTarget,
                            css::uno::Reference< css::chart2::XCoordinateSystem > const & xCoordSystem,
                            const XclChExtTypeInfo& rTypeInfo,
                            sal_Int32 nCrossingAxisDim );
 
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclChAxesSet        maData;             
    XclExpChFramePosRef mxFramePos;         
    XclExpChAxisRef     mxXAxis;            
    XclExpChAxisRef     mxYAxis;            
    XclExpChAxisRef     mxZAxis;            
    XclExpChTextRef     mxXAxisTitle;       
    XclExpChTextRef     mxYAxisTitle;       
    XclExpChTextRef     mxZAxisTitle;       
    XclExpChFrameRef    mxPlotFrame;        
    XclExpRecordList< XclExpChTypeGroup >
                        maTypeGroups;     
};
 
typedef std::shared_ptr< XclExpChAxesSet > XclExpChAxesSetRef;
 
// The chart object ===========================================================
 
class XclExpChChart : public XclExpChGroupBase
{
public:
    explicit            XclExpChChart( const XclExpRoot& rRoot,
                            css::uno::Reference< css::chart2::XChartDocument > const & xChartDoc,
                            const tools::Rectangle& rChartRect );
 
    XclExpChSeriesRef   CreateSeries();
    void                RemoveLastSeries();
    void                SetDataLabel( XclExpChTextRef const & xText );
    void                SetManualPlotArea();
 
    virtual void        WriteSubRecords( XclExpStream& rStrm ) override;
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    typedef XclExpRecordList< XclExpChSeries >  XclExpChSeriesList;
 
    XclChRectangle      maRect;             
    XclExpChSeriesList  maSeries;           
    XclExpChFrameRef    mxFrame;            
    XclChProperties     maProps;            
    XclExpChAxesSetRef  mxPrimAxesSet;      
    XclExpChAxesSetRef  mxSecnAxesSet;      
    XclExpChTextRef     mxTitle;            
    XclExpRecordList< XclExpChText >
                        maLabels;           
};
 
class XclExpChartDrawing : public XclExpRecordBase, protected XclExpRoot
{
public:
    explicit            XclExpChartDrawing(
                            const XclExpRoot& rRoot,
                            const css::uno::Reference< css::frame::XModel >& rxModel,
                            const Size& rChartSize );
    virtual             ~XclExpChartDrawing() override;
 
    virtual void        Save( XclExpStream& rStrm ) override;
 
private:
    std::shared_ptr< XclExpObjectManager > mxObjMgr;
    rtl::Reference< XclExpRecordBase > mxObjRecs;
};
 
class XclExpChart : public XclExpSubStream, protected XclExpRoot
{
public:
    explicit            XclExpChart( const XclExpRoot& rRoot,
                            css::uno::Reference< css::frame::XModel > const & xModel,
                            const tools::Rectangle& rChartRect );
};
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */