// CHTSTD.H
//
// Copyright (c) 1997-1999 Symbian Ltd.  All rights reserved.
//

#if !defined(__CHTSTD_H__)
#define __CHTSTD_H__

#if !defined(__E32STD_H__)
#include <e32std.h>
#endif
#if !defined(__E32BASE_H__)
#include <e32base.h>
#endif
#if !defined(__BACELL_H__)
#include <bacell.h>
#endif
#if !defined(__GDI_H__)
#include <gdi.h>
#endif

const TInt KChartBaseTimeHigh=13960314;
const TInt KChartBaseTimeLow=2328109056;

struct SLimits
	{
	TReal iLowerLimit;
	TReal iUpperLimit;
	};

struct SChartAxesLimits
	{
	SLimits iXAxis;
	SLimits iYAxis;
	};

// MChartTable

class MChartTable
	{
public:
	virtual TReal Value(const TCellRef& aCell) const=0;
	virtual const TDesC* Label(const TCellRef& aCell) const=0;
	virtual TRangeRef DataRangeLimits() const=0;
	virtual TBool IsEmpty(const TCellRef& aCell) const=0;
	};

// CChartAxes

class CChartAxes : public CBase
	{
	friend class CChartManager;
public:
	enum TTickName {EMajorTick,EMinorTick};
	enum TTickType {ETickAcross,ETickInside,ETickOutside,ETickNone};
	enum TGridPosition {EGridMajor,EGridMinor};
	enum TAxisType {EAxisValue,EAxisLabel,EAxisNone}; 
	enum TAxisFormat {EGeneral,EFixed,EScientific,ECurrency,EPercent,ETriad,EDate,ETime};
	enum TAxisName {EXAxis,EYAxis};
	enum {EMaxNumber=16};
	enum {EMajorTickLength=10};
	enum {EMinorTickLength=5};
	enum {EMaxAxisTitleLength=32};
public:	
	IMPORT_C static CChartAxes* NewL(const MChartTable* aChartTable);
	IMPORT_C static CChartAxes* NewL(const CChartAxes* aAxes);
	IMPORT_C virtual ~CChartAxes();
	IMPORT_C void PreDraw(CGraphicsContext* aGc) const;
	IMPORT_C void PostDraw(CGraphicsContext* aGc);
	IMPORT_C TStreamId StoreL(CStreamStore& aStore) const;
	IMPORT_C void RestoreL(const CStreamStore& aStore,TStreamId aStreamId);
	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;
	IMPORT_C void InternalizeL(RReadStream& aStream);
	IMPORT_C void SetChartInsets();
public:
	IMPORT_C void SetMajorTickType(TAxisName aAxisName,TTickType aTickType);
	IMPORT_C TTickType MajorTickType(TAxisName aAxisName) const;
	IMPORT_C void SetMinorTickType(TAxisName aAxisName,TTickType aTickType);
	IMPORT_C TTickType MinorTickType(TAxisName aAxisName) const;
	IMPORT_C void SetMajorTickSeparation(TAxisName aAxisName,TReal aTickSeparation);
	IMPORT_C TReal MajorTickSeparation(TAxisName aAxisName) const;
	IMPORT_C void SetMinorTicksPerMajorTick(TAxisName aAxisName,TInt aNoMinorTicks);
	IMPORT_C TInt MinorTicksPerMajorTick(TAxisName aAxisName);
	IMPORT_C void SetShowMajorGridLines(TAxisName aAxisName,TBool aState);
	IMPORT_C TBool ShowMajorGridLines(TAxisName aAxisName) const; 
	IMPORT_C void SetShowMinorGridLines(TAxisName aAxisName,TBool aState);
	IMPORT_C TBool ShowMinorGridLines(TAxisName aAxisName) const;
	IMPORT_C void SetShowAxisLine(TAxisName aAxisName,TBool aState);
	IMPORT_C TBool ShowAxisLine(TAxisName aAxisName) const; 
	IMPORT_C void SetShowAxisTitle(TAxisName aAxisName,TBool aState);
	IMPORT_C TBool ShowAxisTitle(TAxisName aAxisName) const;
	IMPORT_C void SetAxisType(TAxisName aAxisName,TAxisType aAxisType);
	IMPORT_C TAxisType AxisType(TAxisName aAxisName) const;
	IMPORT_C void SetAxisFormat(TAxisName aAxisName,TAxisFormat aAxisFormat);
	IMPORT_C TAxisFormat AxisFormat(TAxisName aAxisName) const;
	IMPORT_C void SetAxisLabelRange(TAxisName aAxisName,const TRangeRef& aRangeRef);
	IMPORT_C TRangeRef AxisLabelRange(TAxisName aAxisName);
	IMPORT_C void SetLabelBetweenTicks(TAxisName aAxisName,TBool aState);
	IMPORT_C TBool LabelBetweenTicks(TAxisName aAxisName) const;
	IMPORT_C void SetAxisTicksPerLabel(TAxisName aAxisName,TInt aTicksPerLabel);
	IMPORT_C TBool AxisTicksPerLabel(TAxisName aAxisName) const;
	IMPORT_C void SetUpperAndLowerLimits(TAxisName aAxisName,TReal aUpperLimit,TReal aLowerLimit);
	IMPORT_C TReal LowerLimit(TAxisName aAxisName) const;
	IMPORT_C TReal UpperLimit(TAxisName aAxisName) const;
	IMPORT_C void SetDecimalPlaces(TAxisName aAxisName,TInt aDecimalPlaces);
	IMPORT_C TInt DecimalPlaces(TAxisName aAxisName) const;
	IMPORT_C void SetAxisCrossValue(TAxisName aAxisName,TReal aAxisCrossValue);
	IMPORT_C TReal AxisCrossValue(TAxisName aAxisName) const;
	IMPORT_C void SetAxisTitle(TAxisName aAxisName,HBufC* aTitle);
	IMPORT_C const TDesC* AxisTitle(TAxisName aAxisName)const;
	IMPORT_C void SetChartTitle(HBufC* aTitle);
	IMPORT_C void SwapAxes();
	IMPORT_C void SetLogarithmicAxis(TAxisName aAxisName,TBool aStatus);
	IMPORT_C TBool LogarithmicAxis(TAxisName aAxisName) const;
	IMPORT_C void SetTitleFontUlSt(TFontUnderline aUnderline,TFontStrikethrough aStrikethrough);
	IMPORT_C void TitleFontUlSt(TFontUnderline& aUnderline,TFontStrikethrough& aStrikethrough) const;
	IMPORT_C void SetFontUlSt(TFontUnderline aUnderline,TFontStrikethrough aStrikethrough);
	IMPORT_C void FontUlSt(TFontUnderline& aUnderline,TFontStrikethrough& aStrikethrough) const;
	inline TRect ChartRect() const;
	IMPORT_C void SetDrawableRect(const TRect& aChartRect);
	inline TRect DrawableRect() const;
	inline void SetTitleFont(CFont* aFont);
	inline void SetFont(CFont* aFont);
	IMPORT_C void SetIs3D(TBool aState);
	inline TBool Is3D() const;
	inline const TPoint& AxisCrossPoint() const;
	inline const TDesC* ChartTitle() const;
	inline const MChartTable* ChartTable() const;
	IMPORT_C void SetTextColor(TRgb aColor);
	inline TRgb TextColor() const;
	IMPORT_C void SetLineColor(TRgb aColor);
	inline TRgb LineColor() const;
	IMPORT_C void SetBackgroundColor(TRgb aColor);
	inline TRgb BackgroundColor() const;
	IMPORT_C TInt MapX(TReal aX) const;
	IMPORT_C TInt MapY(TReal aY) const;
	IMPORT_C TInt NoXPixelsBetweenTicks() const;
	IMPORT_C TInt NoYPixelsBetweenTicks() const;
	IMPORT_C TInt PixelBorder() const;
	inline CFont* Font() const;
	inline void SetPieChart(TBool aPieChart);
	inline TBool HasChanged() const;
private:
	CChartAxes();
	void ConstructL(const MChartTable* aChartTable);
	void ConstructL(const CChartAxes* aAxes);
	void SetChartRectForGraphsWithAxes();
	void SetChartRectForPie();
	void SetStateOfFlags(TAxisName aAxisName,TBool aState,TInt aFlagField);
	void FormatValue(TDes& aDes,TReal aValue,TAxisFormat aAxisFormat,TInt aDecimalPlaces) const;
	void FormatCurrency(TDes &aDes,TReal aCurrencyAmount) const;
	TInt LabelDistance(TTickType aTickType) const;
	void DrawChartTitle(CGraphicsContext* aGc) const;
	void DrawXAxisLine(CGraphicsContext* aGc) const;
	void DrawYAxisLine(CGraphicsContext* aGc) const;
	void DrawXAxisTicks(CGraphicsContext* aGc) const;
	void DrawYAxisTicks(CGraphicsContext* aGc) const;
	void DrawXTicks(CGraphicsContext* aGc,TPoint& from,TPoint& to,TReal tickValue,TInt aTickCount) const;
	void DrawYTicks(CGraphicsContext* aGc,TPoint& from,TPoint& to,TReal tickValue,TInt aTickCount) const;
	void DrawXAxisLabel(CGraphicsContext* aGc,const TRangeRef::TIter& aIter,TInt aXTickPosition,TInt aXTickSeparation) const;
	void DrawYAxisLabel(CGraphicsContext* aGc,const TRangeRef::TIter& aIter,TInt aYTickPosition) const;
	void DrawXAxisTitle(CGraphicsContext* aGc) const;
	void DrawYAxisTitle(CGraphicsContext* aGc) const;
	void DrawXAxisGridLine(CGraphicsContext* aGc) const;
	void DrawYAxisGridLine(CGraphicsContext* aGc) const;
	void DrawXAxisLabels(CGraphicsContext* aGc) const;
	void DrawYAxisLabels(CGraphicsContext* aGc) const;
	void DrawXAxisDataLabels(CGraphicsContext* aGc) const;
	void DrawYAxisDataLabels(CGraphicsContext* aGc) const;
	void DrawXAxisTextLabels(CGraphicsContext* aGc) const;
	void DrawYAxisTextLabels(CGraphicsContext* aGc) const;
	void Draw3DAxis(CGraphicsContext* aGc,const TPoint& twoDAxisStart,const TPoint& twoDAxisEnd) const;
private:
	class TAxisInfo
		{
	public:
		TAxisInfo();
		void InternalizeL(RReadStream& aStream);
		void ExternalizeL(RWriteStream& aStream) const;
		void CopySettingsL(const TAxisInfo& aAxisInfo);
		TReal MajorTickSeparation(TInt aTickCount) const;
		TInt TickCount() const;
	public:
		enum {	EShowMajorGridLines=0x04,EShowMinorGridLines=0x08,
				EShowAxisTitle=0x10,EShowAxisLine=0x20,
				ELabelBetweenTicks=0x40};
		TUint32 iFlags;
	 	TTickType iMajorTickType;
		TTickType iMinorTickType;
		TAxisType iAxisType;
		TAxisFormat iAxisFormat;
		TInt iDecimalPlaces;
		HBufC* iAxisTitle;
		TReal iMajorTickSeparation; 
		TReal iLowerLimit;
		TReal iUpperLimit;
		TReal iAxisCrossValue;
		TInt iMinorTicksPerMajorTick;
		TInt iTicksPerLabel;
		TRangeRef iLabelRange;
		TBool iLogarithmic;
		};
private:
	enum {ETitleFontUl=0x1,ETitleFontSt=0x2,EFontUl=0x4,EFontSt=0x8};
private:
	const MChartTable* iChartTable;
	TBool iIs3D;
	TPoint iAxisCrossPoint;
	TRect iChartRect; // diagram drawn in here
	TRect iDrawableRect; // includes diagram and lables
	TInt iWidthY; // used when positioning the y axis title only
	HBufC* iChartTitle;
	TAxisInfo iXAxis;
	TAxisInfo iYAxis;
	CFont* iFont;
	CFont* iTitleFont;
	TBool iPieChart;
	TRgb iTextColor;
	TRgb iLineColor;
	TRgb iBackgroundColor;
	TUint32 iFontsUlSt;
	TBool iChanged;
private:
    __DECLARE_TEST;
	};

class CChartDiagram;

class CChartManager : public CBase
	{
public:
	enum TLimitType {ELimitAutomatic,ELimitUserDefinedUpper,ELimitUserDefinedLower,ELimitUserDefined};
	enum TLegendType {ELegendNone,ELegendTopLeft,ELegendTop,ELegendTopRight,ELegendRight,ELegendBottomRight,ELegendBottom,ELegendBottomLeft,ELegendLeft,ELegendCenter};
public:
	IMPORT_C static CChartManager* NewL(CChartAxes* aChartAxes);
	IMPORT_C static CChartManager* NewL(const CChartManager* aManager);
	IMPORT_C virtual ~CChartManager();
	IMPORT_C TStreamId StoreL(CStreamStore& aStore) const;
	IMPORT_C void RestoreL(const CStreamStore& aStore,TStreamId aStreamId);
	IMPORT_C void StoreComponentsL(CStreamStore& aStore,CStoreMap& aMap) const;
	IMPORT_C void RestoreComponentsL(const CStreamStore& aStore);
	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;
	IMPORT_C void InternalizeL(RReadStream& aStream);
	IMPORT_C virtual void DrawSetupL(CGraphicsContext* aGc);
	IMPORT_C virtual void Draw(CGraphicsContext* aGc);
	IMPORT_C virtual TBool DrawItem(CGraphicsContext* aGc);
	IMPORT_C void DrawComplete(CGraphicsContext* aGc);
	IMPORT_C void AddDiagramL(CChartDiagram* aDiagram);
	IMPORT_C void RemoveDiagram(TInt aDiagramNumber);
	IMPORT_C void CalculateAxisLimits(TBool aStacked=EFalse);
	IMPORT_C void SetAxisLimitType(CChartAxes::TAxisName aAxisName,TLimitType aType);
	IMPORT_C TLimitType AxisLimitType(CChartAxes::TAxisName aAxisName);
	IMPORT_C void SetShowDiagram(TInt aDiagramNumber,TBool aState);
	IMPORT_C TBool ShowDiagram(TInt aDiagramNumber) const;
	IMPORT_C TInt NoDiagrams() const;
	IMPORT_C CChartDiagram* Diagram(TInt aDiagramNumber) const;
	IMPORT_C void SetDefaultLegendName(HBufC* aDefaultName);
	IMPORT_C void SetChartName(HBufC* aChartName);
	IMPORT_C TBool HasChanged() const;
	inline void SetDeviceMap(MGraphicsDeviceMap* aMap);
	inline const TDesC* DefaultLegendName() const;
	IMPORT_C void SetTitleFontSpec(const TFontSpec& aFontSpec);
	inline void TitleFontSpec(TFontSpec& aFontSpec) const;
	IMPORT_C void SetFontSpec(const TFontSpec& aFontSpec);
	inline void FontSpec(TFontSpec& aFontSpec) const;
	IMPORT_C void SetLegendType(TLegendType aLegendType);
	inline TLegendType LegendType() const;
	inline CChartAxes* Axes() const;
	IMPORT_C void SetPhysicalSize(const TRect& aRect);
	inline TRect PhysicalSize() const;
	inline const TDesC* ChartName() const;
private:
	CChartManager();
	void DrawLegend(CGraphicsContext* aGc);
	void CopySettingsL(const CChartManager* aManager);
	SChartAxesLimits UpperAndLowerLimits();
	SChartAxesLimits UpperAndLowerStackedLimits();
	void ModifyLimits(SLimits& aLimits,const SLimits& aTmpLimits);
	void SetUpperAndLowerLimits(CChartAxes::TAxisName aAxisName,TReal aUpperLimit,TReal aLowerLimit);
	static TReal AutoTickSeparation(const TReal& aAxisRange);
	static void RoundToNearestMultiple(TReal& aValue,const TReal& aStep,TBool aRoundUp,TBool aLogAxis);
private:
	TLimitType iXAxisLimitType;
	TLimitType iYAxisLimitType;
	TFontSpec iFontSpec;
	TFontSpec iTitleFontSpec;
	CFont* iFont;
	CFont* iTitleFont;
	MGraphicsDeviceMap* iMap;
	CChartAxes* iChartAxes;
	CArrayFixFlat<CChartDiagram*>* iDiagramArray;
	TInt iMaxDiagrams;
	TInt iCurrentDiagram;
	TInt iMaxItems;
	TInt iCurrentItem;
	TReal iNegativeBaseValue;
	TReal iPositiveBaseValue;
	TLegendType iLegendType;
	HBufC* iDefaultLegendName;
	TRect iPhysicalSize;
	HBufC* iChartName;
private:
	TStreamId iAxesId;
	TStreamId* iDiagramIds;
	TInt iNoDiagramIds;
	TInt iDiagramType;
	TBool iChanged;
	};

class CChartDiagram : public CBase
	{
	friend class CChartManager;
public:
	enum TDiagramType {ELine,EColumn,EStackColumn,EBar,EStackBar,EScatter,EPie};
	enum TPointSymbol {ENone,EDiagonalCross,ESquare,EDiamond,ECross,ECircle};
	enum TFillStyle {ESolidFill,EHorizontalFill,EVerticalFill,ESquareFill,EForwardFill,ERearwardFill,EDiamondFill};
	enum TDataLabelAlignment {EAbove,ECenter,ERight,EBelow,ELeft};
	enum TDataLabelType {EData,ELabel,ENoDataLabel}; 
	class TSymbology
		{
	public:
		IMPORT_C TSymbology();
		IMPORT_C void InternalizeL(RReadStream& aStream);
		IMPORT_C void ExternalizeL(RWriteStream& aStream) const;
		IMPORT_C CGraphicsContext::TBrushStyle FillStyle() const;
		IMPORT_C void IncSettings();
	public:
		TRgb iPointColor;
		TPointSymbol iPointSymbol;
		TRgb iLineColor;
		TInt iLineWidth;
		TBool iShowLine;
		TRgb iFillColor;
		TFillStyle iFillStyle;
		};
public:
	virtual SChartAxesLimits DataLimits()=0;
	virtual TBool DrawItem(CGraphicsContext* aGc,TInt aItemNumber,TReal& aPositiveBaseValue,TReal& aNegativeBaseValue)=0;
	virtual TDiagramType Type() const=0;
	IMPORT_C virtual void SetScatterDataRange(const TRangeRef& aRange);
	IMPORT_C virtual void ScatterDataRange(TRangeRef& aRange) const;
	IMPORT_C virtual void SetShowDataAsPercentages(TBool aState);
	IMPORT_C virtual TBool ShowDataAsPercentages() const;
	IMPORT_C static CChartDiagram* NewL(TDiagramType aType,const CChartAxes* aChartAxes);
	IMPORT_C virtual ~CChartDiagram();
	IMPORT_C virtual void CopySettings(const CChartDiagram& aDiagram);
	IMPORT_C TStreamId StoreL(CStreamStore& aStore) const;
	IMPORT_C void RestoreL(const CStreamStore& aStore,TStreamId aStreamId);
	IMPORT_C virtual void ExternalizeL(RWriteStream& aStream) const;
	IMPORT_C virtual void InternalizeL(RReadStream& aStream);
	IMPORT_C void SetName(HBufC* aName);
	IMPORT_C void SetLabelRange(const TRangeRef& aDataLabelRange);
	IMPORT_C void SetDataRange(const TRangeRef& aRange);
	IMPORT_C virtual void DrawSetup(TInt aTotalNumberOfDiagrams,TInt aDiagramCount);
	IMPORT_C TBool IsRangeValid(const TRangeRef& aRange) const;
	inline TInt Items() const;
	inline const TDesC* Name() const;
	IMPORT_C void SetSymbology(const TSymbology& aSymbology);
	inline const TSymbology& Symbology() const;
	IMPORT_C void SetDataLabelAlignment(TDataLabelAlignment aDataLabelAlignment);
	inline TDataLabelAlignment DataLabelAlignment() const;
	IMPORT_C void SetDataLabelType(TDataLabelType aDataLabelType);
	inline TDataLabelType DataLabelType() const;
	IMPORT_C void SetShowDiagram(TBool aState);
	inline TBool ShowDiagram() const;
	inline TRangeRef LabelRange() const;
	inline TRangeRef DataRange() const;
	inline TBool HasChanged() const;
protected:
	IMPORT_C CChartDiagram(const CChartAxes* aChartAxes);
	IMPORT_C SLimits UpperAndLowerAxisLimits(const TRangeRef& aRange);
	IMPORT_C void Draw3DRectangle(CGraphicsContext* aGc,const TRect& aRect,TBool aDrawTop,TBool aDrawSide) const;
	IMPORT_C void DrawDataLabel(CGraphicsContext* aGc,const TCellRef& aCell,const TPoint& aPosition,TReal aData) const;
	IMPORT_C void DrawLegendSymbol(CGraphicsContext* aGc,const TPoint& aPosition) const;
private:
	TReal Value(TInt aIndex) const;
	static void DrawLegendDiagonalCross(CGraphicsContext* aGc,const TPoint& aPosition,TInt aSize);
	static void DrawLegendSquare(CGraphicsContext* aGc,const TPoint& aPosition,TInt aSize);	
	static void DrawLegendDiamond(CGraphicsContext* aGc,const TPoint& aPosition,TInt aSize);	
	static void DrawLegendCross(CGraphicsContext* aGc,const TPoint& aPosition,TInt aSize);	
	static void DrawLegendCircle(CGraphicsContext* aGc,const TPoint& aPosition,TInt aSize);
protected:
	TBool iShowDiagram;
	TRangeRef iDataRange;
	TRangeRef iLabelRange;
	TDataLabelAlignment iDataLabelAlignment;
	TDataLabelType iDataLabelType;
	const MChartTable* iChartTable;
	const CChartAxes* iChartAxes;
	TSymbology iSymbology;
	TRangeRef::TIter iRangeIter;
	TRangeRef::TIter iLabelRangeIter;
	HBufC* iName;
	TBool iChanged;
	};

class CChartLineBase : public CChartDiagram
	{
protected:
	IMPORT_C CChartLineBase(const CChartAxes* aChartAxes);
	IMPORT_C ~CChartLineBase();
	IMPORT_C virtual void DrawSetup(TInt aTotalNumberOfDiagrams,TInt aDiagramCount);
protected:
	TPoint iLastPoint;
	};

class CChartLine : public CChartLineBase
	{
public:
	IMPORT_C CChartLine(const CChartAxes* aChartAxes);
	virtual void DrawSetup(TInt aTotalNumberOfDiagrams,TInt aDiagramCount);
	virtual SChartAxesLimits DataLimits();
	virtual TBool DrawItem(CGraphicsContext* aGc,TInt aItemNumber,TReal& aPositiveBaseValue,TReal& aNegativeBaseValue);
	virtual TDiagramType Type() const {return(ELine);}
private:
	TInt iPosition;
	TInt i3dLineWidth;
	};

class CChartScatter : public CChartLineBase
	{
public:
	IMPORT_C CChartScatter(const CChartAxes* aChartAxes);
	virtual void CopySettings(const CChartDiagram& aDiagram);
	virtual TBool DrawItem(CGraphicsContext* aGc,TInt aItemNumber,TReal& aPositiveBaseValue,TReal& aNegativeBaseValue);
	virtual SChartAxesLimits DataLimits();
	virtual void DrawSetup(TInt aTotalNumberOfDiagrams,TInt aDiagramCount);
	virtual void SetScatterDataRange(const TRangeRef& aRange);
	virtual void ScatterDataRange(TRangeRef& aRange) const;
	virtual TDiagramType Type() const {return(EScatter);}
	virtual void ExternalizeL(RWriteStream& aStream) const;
	virtual void InternalizeL(RReadStream& aStream);
private:
	TRangeRef iScatterDataRange;
	TRangeRef::TIter iScatterDataIter;
	};

class CChartColumn : public CChartDiagram
	{
public:
	IMPORT_C CChartColumn(const CChartAxes* aChartAxes,TBool aStackColumn=EFalse);
	virtual SChartAxesLimits DataLimits();
	virtual void DrawSetup(TInt aTotalNumberOfDiagrams,TInt aDiagramCount);
	virtual TBool DrawItem(CGraphicsContext* aGc,TInt aItemNumber,TReal& aPositiveBaseValue,TReal& aNegativeBaseValue);
	virtual TDiagramType Type() const {return(iStackColumn?EStackColumn:EColumn);}
private:
	void DrawColumn(CGraphicsContext* aGc,TInt aXPos);
	void DrawStack(CGraphicsContext* aGc,TInt aXPos,TReal& aPositiveBaseValue,TReal& aNegativeBaseValue);
private:
	TInt iColumnWidth;
	TInt iPositionOffset;
	TBool iStackColumn;
	};

class CChartBar : public CChartDiagram
	{
public:
	IMPORT_C CChartBar(const CChartAxes* aChartAxes,TBool aStackBar=EFalse);
	virtual SChartAxesLimits DataLimits();
	virtual void DrawSetup(TInt aTotalNumberOfDiagrams,TInt aDiagramCount);
	virtual TBool DrawItem(CGraphicsContext* aGc,TInt aItemNumber,TReal& aPositiveBaseValue,TReal& aNegativeBaseValue);
	virtual TDiagramType Type() const {return(iStackBar?EStackBar:EBar);}
private:
	void DrawBar(CGraphicsContext* aGc,TInt aYPos);
	void DrawStack(CGraphicsContext* aGc,TInt aYPos,TReal& aPositiveBaseValue,TReal& aNegativeBaseValue);
private:
	TInt iBarHeight;
	TInt iPositionOffset;
	TBool iStackBar;
	};

class CChartPie : public CChartDiagram
	{
public:
	IMPORT_C CChartPie(const CChartAxes* aChartAxes);
	virtual void CopySettings(const CChartDiagram& aDiagram);
	virtual SChartAxesLimits DataLimits();
	virtual void DrawSetup(TInt aTotalNumberOfDiagrams,TInt aDiagramCount);
	virtual TBool DrawItem(CGraphicsContext* aGc,TInt aItemNumber,TReal& aPositiveBaseValue,TReal& aNegativeBaseValue);
	virtual void SetShowDataAsPercentages(TBool aState);
	virtual TBool ShowDataAsPercentages() const;
	virtual TDiagramType Type() const {return(EPie);}
	virtual void ExternalizeL(RWriteStream& aStream) const;
	virtual void InternalizeL(RReadStream& aStream);
private:
	TInt MaxLabelWidth();
	void DrawWholePie(CGraphicsContext* aGc,TInt a3dDepth);
	void DrawDataLabels(CGraphicsContext* aGc,TReal aTheta,TReal aData,TReal aRadius) const;
	TPoint SetTextPosition(TReal aTheta,TReal aRadius,TInt aOffset) const;
	void ScaleForPerspective(TReal& aX,TReal& aY) const;
	static void SetSinAndCosForTheta(TReal& aSinTheta,TReal& aCosTheta,TReal aTheta);
private:
	TRect iPieRect;
	TReal iStartX;
	TReal iStartY;
	TReal iSum;
	TBool iShowDataAsPercentages;
	TReal iThetaTotal;
	};

#include <chtstd.inl>
#endif