ChartContext.h

Go to the documentation of this file.

//==============================================================================================
//  FILENAME    :   ChartContext.h
//  AUTHOR      :   Liang Liu
//  CREATION    :   2008-06-13
//  Copyright (C) MicroStrategy Incorporated 2008
//  All Rights Reserved
//==============================================================================================
#ifndef MsiChart_ChartContext_h
#define MsiChart_ChartContext_h

#include "FormatLine.h"
#include "FormatFill.h"
#include "FormatFont.h"
#include "../Common.h"
#include "CEModuleMain.h"
#include "ChartCanvas.h"
#include "../Dataset.h"
#include "Point2D.h"
#include "Vector2D.h"

#include "PDCHeader/PDCfstream"
#include "PDCHeader/PDCmap"
//struct tagVARIANT;
//typedef struct tagVARIANT VARIANT;
#include "FormatManager.h"
#include "ChartContextHelper.h"

#ifndef _VE_CE
#import "CGCanvas.h"
#endif


namespace MsiChart
{
#ifndef DPI
#define DPI 96      //  Usually 96DPI on Windows
#endif

#define POINTSOFONEINCH 72  //  1pt = 1/72 inch

#define TDGVirtualXMIN  (-16383)
#define TDGVirtualXMAX  16383
#define TDGVirtualYMIN  (-16383)
#define TDGVirtualYMAX  16383

    extern const Rect2D gDefaultTitlePosition;
    extern const Rect2D gDefaultSubtitlePosition;
    extern const Rect2D gDefaultFootnotePosition;
    extern const TripleId gNullTripleId;

    const Int32 gMaxTextLength = 255;
    const Int32 gDefaultUniformAxisMargin = 2;

    const Int32 gVirtualMarkerSize = 2;

    struct ChartAdvFormat;
    class Chart;

    enum EnumCollectionType
    {
        CT_NO_COLLECTION,

        // General collection types
        CT_LINE,
        CT_GENERAL_SHAPE,
        CT_TEXT,

        // The following 6 collection types are only used by ABL chart for convenience to apply enhanced series effect.
        CT_VERTICAL_AREA,
        CT_VERTICAL_BAR,
        CT_HORIZONTAL_AREA,
        CT_HORIZONTAL_BAR,
        CT_DEPTH_LINE_OR_LINE_MARKER,

        CT_NO_FORMAT
    };

    enum EnumChartComponent
    {
        CC_STATIC = 1,
        CC_DYNAMIC = 2,
        CC_ALL = 3, //the default
    };

    //  enum EnumLineJoinType
    //  {
    //      LJT_MITER = 0,
    //      LJT_BEVEL = 1,
    //      LJT_ROUND = 2,
    //  };

    enum EnumGraphMatrixLayoutType
    {
        GMLT_NORMAL = 0,
        GMLT_FIT_CONTENT = 1,
        GMLT_FIT_WINDOW = 2,
    };

    enum EnumGraphMatrixMarkerInChartType
    {
        GMMS_FROM_LINE_CHART_AS_LINE,
        GMMS_FROM_LINE_CHART_AS_DOT_IN_LINE,
        GMMS_FROM_LINE_CHART_AS_LINE_ONE_DOT,
        GMMS_FROM_LINE_CHART_AS_NONE_LINE,
        GMMS_FROM_BAR_CHART,
        GMMS_FROM_BUBBLE_CHART,
        GMMS_FROM_GRID_CHART,
        GMMS_FROM_TICK_SINGLE_METRIC,
        GMMS_FROM_TICK_DOUBLE_METRIC,
        GMMS_FROM_TICK_NONE_METRIC,
        GMMS_FROM_PIE,
    };

    typedef enum
    {
        GMAL_NONE,
        GMAL_GRID,
        GMAL_VALUE_SCATTER,
        GMAL_VALUE_BUBBLE,
        GMAL_ABL_VERTICAL,
        GMAL_ABL_HORIZONTAL,
        GMAL_INVALID,
    }EnumGraphMatrixAxisLayoutType;

    typedef enum
    {
        GMMGT_UNDEFINED = 0,
        GMMGT_AREA,
        GMMGT_BAR,
        GMMGT_LINE,
        GMMGT_SCATTER,
        GMMGT_BUBBLE,
        GMMGT_PIE,
        GMMGT_GRID,
        GMMGT_UNKNOWN,
    }EnumGraphMatrixMajorGraphType;

    typedef enum   {
    _COMBINED = -2,
    _GENERIC,
    _AREA,
    _BAR,
    _LINE2,
    _STEPLINE,
    _CIRCLE,
    _RECTANGLE,
    _SQUARE,
    _TICKER,
    _PIESLICE,
    _POLYGON,
    _PIE,
    _BULLET,
    _CURVE,
    _DEFAULT = 100
    } EnumShapeType;
    
    typedef enum   {
        Axis_x1,
        Axis_x2,
        Axis_y1,
        Axis_y2,
    } EnumAxis;
    
    struct PropertyKey
    {
        Int32 mPropertyId;
        Int32 mObjectId;
        Int32 mSeriesId;

        PropertyKey(Int32 iPropertyId = -1, Int32 iObjectId = gNullObjectId, Int32 iSeriesId = gNullSeriesId)
        : mPropertyId(iPropertyId), mObjectId(iObjectId), mSeriesId(iSeriesId)
        {
        }

        bool operator < (const PropertyKey& iKey) const
        {
            if (mPropertyId < iKey.mPropertyId)
                return true;
            if (mPropertyId > iKey.mPropertyId)
                return false;

            if (mObjectId < iKey.mObjectId)
                return true;
            if (mObjectId > iKey.mObjectId)
                return false;

            return (mSeriesId < iKey.mSeriesId);
        }
    };

    struct ThresholdCache
    {
        Int32 mSeriesId;
        Int32 mGroupId;
        bool mUseThreshold;
        FormatFill::Ptr mFormatFillPtr;
        ThresholdCache();
        void Reset();
    };

    struct MetricFormatFillCache
    {
        bool mValid;                    
        FormatFill::Ptr mFormatFillPtr; 

        MetricFormatFillCache() : mValid(false), mFormatFillPtr(NULL) {}
    };

    struct DatasetState
    {
        bool mIsSliced;
        bool mIsSliceEnabled;
        Int32 mBeginGroup;
        Int32 mEndGroup;
        DatasetState();
        void Reset();
    };

    struct AxesState
    {
        bool mIsY1InZoomState;  
        bool mIsO1InZoomState;  
        bool mIsO1SwipedOutOfZoom;      
        bool mIsY1RangeBeforeZoomReady;
        bool mIsO1RangeBeforeZoomReady;
        bool mUseManualGroupRange;
        Int32 mLastGroupID; 
        Int32 mValueAxisAreaWidth;
        Int32 mSuggestedDataAreaStartX; //Used in zooming state for time series
        Int32 mTopMargin;
        Int32 mO1LabelLevel;
        Int32 mSwipeOffsetOutOfZoom;
        double mY1LogicalMin;   
        double mY1LogicalMax;   
        double mO1LogicalMin;   
        double mO1LogicalMax;   
        double mY1LogicalMinBeforeZoom; 
        double mY1LogicalMaxBeforeZoom; 
        double mO1LogicalMinBeforeZoom; 
        double mO1LogicalMaxBeforeZoom; 
        double mO1InitLogicalMin;
        double mO1InitLogicalMax;
        std::vector<MBase::String>  mScrollViewLabels;
        std::vector<Int32>          mScrollViewLabelIds;
        std::vector<Rect2D>         mScrollViewLabelRects;
        DatasetState mInitDatasetState;
        AxesState();
        void Reset();
    };

    struct UniformAxisContext
    {
        Int32 mDataAreaLeftMargin;      
        Int32 mDataAreaRightMargin;     
        Int32 mDataAreaTopMargin;       
        Int32 mDataAreaBottomMargin;    
        Int32 mGraphHeight;             
        bool mIsAxisTitleAndLabelRequired;  
        double mMinValue;               
        double mMaxValue;               
        double mXMinValue;              
        double mXMaxValue;              
        double mZMinValue;              
        double mZMaxValue;              
        Int32 mLabelWidthLimitY;        
        Int32 mLabelWidthLimitX;        
        //Get the PrimaryMetricIndex from widget
        Int32 mXMetrixIndex;
        Int32 mYMetrixIndex;
        Int32 mZMetrixIndex;

        Int32 mX2MetrixIndex;
        Int32 mY2MetrixIndex;

        double mY2MinValue;             
        double mY2MaxValue;             
        double mX2MinValue;             
        double mX2MaxValue;             

        Int32 mSecondaryDataAreaLeftMargin;     
        Int32 mSecondaryDataAreaRightMargin;        
        Int32 mSecondaryDataAreaTopMargin;      
        Int32 mSecondaryDataAreaBottomMargin;   

        std::vector<Int32> mAxisHostMetricSet[4];  

        // Metric Valid
        bool mIsXValid;
        bool mIsYValid;
        bool mIsZValid;
        bool mIsX2Valid;
        bool mIsY2Valid;
        bool mIsZ2Valid;

        UniformAxisContext();
    };

    struct GraphMatrixContext
    {
        const static Int32 sVisualElementBound = 1;

        Int32 mDataGroup;    //< Data groups for one series.

        EnumDssGraphMatrixSizeMode  mSizeMode;  //How the size should be computed.
        double mMaxSizeVal;
        double mMinSizeVal;
        Int32 mSizeIndex;                       //Size index for non-bubble chart.

        EnumDssGraphMatrixElementSizeMode mMaxElementSizeMode;
        EnumDssGraphMatrixElementSizeMode mMinElementSizeMode;
        double mMaxElementSize;                 //used in size = specific
        double mMinElementSize;                 //used in size = proprotional
        bool mIsMinElementSizeAsRatioToMax;     //whether min size is a ratio to max element size.
        double mEstGraphWidth;
        double mEstGraphHeight;

        // Use fixed Marker size for GridChart in special case
        Int32 mFixMarkerSizeFromWidget;

        EnumDssGraphMatrixColorMode mColorMode; //How the marker should be colored
        Int32 mColorArity;                      //Used in ByX or ByY
        double mMaxColorVal;
        double mMinColorVal;
        std::vector<Int32> mColors;
        Int32 mColorIndex;

        Int32 mMarkerShape;
        Int32 mMaxAutoBarWidth;             
        double mRatioToMaxRadius;           
        double mLineSizeInput;              

        Int32 mBubbleBourndaryPadding;      
        Int32 mTickSizeInFD;                
        std::vector<Int32> mVecXValueAxisLowPaddingSet;  
        std::vector<Int32> mVecXValueAxisHighPaddingSet; 
        std::vector<Int32> mVecYValueAxisLowPaddingSet;  //< The lowPadding for y axis
        std::vector<Int32> mVecYValueAxisHighPaddingSet; //< The highPadding for y axis
        std::vector<Int32> mExtraPaddings;               //< Extra paddings for axis.

        bool mIsXDropZoneEmpty;
        bool mIsYDropZoneEmpty;
        bool mIsSeriesUniformInColor;           
        bool mShouldXAxisLabelRotate;
        EnumDssGraphMatrixMetricCategory mAddedMetricToTooltip; 
        EnumGraphMatrixLayoutType mLayoutMode;  
        Int32 mCachedMaxElementSize;

        bool mHasChartWithOnlyDataMarkers;

        //Data Label Support
        bool mIsNeedRotateDataLabel;  //cached rotate state for Data Label in vertical Bar Chart
        bool mIsNeedAdjustAxis;
        double mAxisAdjustedValue;
        bool mIsDataLabelEnabled;

        //Custom Min/Max Support, only used in ABL chart.
        bool mIsSizebyCustomMinMaxEnabled;

        std::vector<Int32> mRowColorByUnits;
        std::vector<Int32> mColColorByUnits;
        std::vector<Int32> mBubbleSizeByIndexSet;
        std::set<double> mShownValueTickSet[2]; 
        std::set<Int32> mCondesedMetricsSet;    
        Int32 mCondenseMode;                    
        Int32 mCondenseLimit;                   

        EnumGraphMatrixAxisLayoutType mAxisLayout;           
        ChartContext* mpChartContext;           

        Int32 mLabelStaggerStart;
        Int32 mLabelStaggerEnd;

        //Combination Graph Support
        bool mIsCombinationGraph;
        //Dual Axis Graph
        bool mIsDualAxisGraph;
        
        EnumDssGraphMatrixXAxisLabelRotation mXAxisLabelRotation;

        //pie chart specific
        bool mIsPieSliced;                      //< If there is any unit in the slice drop zone.
        bool mIsPieMetricSliced;                //< If metrics object is in the slice drop zone.
        bool mIsSliceDropzoneHasTemplateMetric; //< If template-metrics is in the slice drop zone.
        bool mIsColorbyDropzoneHasTemplateMetric; //< If template-metrics is in the colorby drop zone.
        bool mIsXDropzoneHasTemplateMetric; //< If template-metrics is in the X drop zone.
        bool mIsYDropzoneHasTemplateMetric; //< If template-metrics is in the Y drop zone.
        bool mIsBreakbyDropzoneHasTemplateMetric; //< If template-metric is in the Breakby dropzone.
        bool mIsRowOrColDropzoneHasTemplateMetric; //< If template-metrics is in the Row or Col drop zone.
        bool mIsEmptyXAxisDropWithTemplateMetric; //< If X-Dropzone empty and has TemplateMetric.
        bool mIsEmptyYAxisDropWithTemplateMetric; //< If Y-Dropzone empty and has TemplateMetric.
        bool mIsEmptyXAxisDropZone;
        bool mIsEmptyYAxisDropZone;
        bool mMarkerShown;
        Int32 mPieGroupSectionCount;
        Int32 mPieSeriesSectionCount;
        Int32 mCurrentPieSliceIndex;
        Int32 mCurrentPieAngleIndex;
        Int32 GetCurrentPieSlice();
        void SetCurrentPieSlice(Int32 iPieSliceIndex);
        Int32 GetCurrentAngleIndex();
        void SetCurrentAngleIndex(Int32 iAngleIndex);

        //Refactor ColorBy Mode for GraphMatrix
        std::vector<std::pair<Int32, Int32> > *mColorByKeyUnitsPair;
        std::map<std::string, Int32> *mColorByMap;
        std::map<int, bool> *mHasAreaBarInAxis;

        std::vector<std::pair<double, double> > mBubbleSizeRangeSet;
        std::set<TripleId> mIsolaetdDotsInNormalLineChart;   //<< The <Sid, Gid> pair to record the isolated dots in a normal line graph
        std::map<Int32, double> mValueAxisZoomScales;   

        bool IsColorValid() {return mColors.size() == mColorArity;}
        GraphMatrixContext();

        Int32 mCategoryAxisLableInteval;
        double ToRatio(double iVal, bool iIsUseZeroAsBoundaryValue = false);
        double ToRatioEX(double iVal, bool iIsUseAbsValue = false);
        
        double GetSizebyPieRadius(double iVal, double iMax, double iMin, double maxRadius);

        static double ToRatio(double iVal, double iMax, double iMin, bool iIsUseZeroAsBoundaryValue);

        Int32 GetSizeByIndex(Int32 iIndex, bool iIsBubbleChart = false);

        Int32 GetMaxMarkerSize(EnumGraphMatrixMarkerInChartType iChartType, bool iIsVertical, Int32 iUnitCount, bool iIsBubbleChart = false);

        Int32 GetMaxElementSizeInLineChart(bool iIsVertical, Int32 iGroupCount, bool iIsIsolatedDotInLine = false, bool iIsLineShapeInCombinationChart = false);

        /*This function handles the size-by logic by considering the min value depends on different cases.
         @param iDataVal, the corresponding data value from dataset.
         @param iRatio, the iRatio val/max_val
         @param iMaxSize, the max size one element can acchieve.
         @return the scaled result.
         */
        double GetScaledSize(double iDataVal, double iMaxSize);
        double GetScaledSizeWithRatio(double iRatio, double iMaxSize);

        Int32 GetValueAxisPadding(bool iIsXAxis, bool iIsHighPadding, Int32 iRequiredPadding = 0, Int32 iPaddingIndex = 0);
        void UpdateValueAxisPadding(bool iIsXAxis, bool iIsHighPadding, Int32 iPaddingValue);

        bool IsIsolatedDot(const TripleId& irId);
        bool IsIsolatedDotInLine(const TripleId& irId);
        void AddToIsolatedDotList(const TripleId& irTripleId);

        Int32 GetCondensedTextLimit(Int32 iFormatType);

        FormatFill::Ptr GetBaseGradientFillForGM(unsigned char iAlpha = 255);

        FormatFill::Ptr UpdateGradientEffectForGM(const TripleId& irLineId, FormatFill::Ptr iFillPtr, Dataset::Ptr iDataset, double iAngle, unsigned char iAlpha = 255);

        FormatFill::Ptr UpdateStepGradientEffectForGM(const TripleId& irLineId, FormatFill::Ptr iFillPtr, Dataset::Ptr iDataset, Int32 iGroupInterval , unsigned char iAlpha = 255);

        /* To make the line/shape a bit thicker to fit PM's requirement.
         @param iOriginValue, the value to be adjusted.
         @return the result that is adjusted.
         */
        Int32 GetAdjustThicknessValue(Int32 iOriginValue);

        //After dataset refactor, we add angleindex and sliceindex for pie slice objec, so we don't need to change the group and series id for pie slice in different subgroup.
        //TripleId GetLogicalTripleId(const TripleId& irRealId);
        //TripleId GetRealTripleId(Int32 iGroupSubIndex, Int32 iSeriesSubIndex, const TripleId& iBaseId);

        double GetValueAxisZoomScale(Int32 iValueAxisId);

    protected:
        Int32 hGetLogicalId(Int32 iInputId);
        double hGetMaxRadiusRatio(Int32 chartType);

    };

    class ValueAxis;
    class GraphObject;
    class LayerObject;
    typedef MSynch::SmartPtr<LayerObject> LayerObjectPtr;
    class Transformer;
    class ChartContext
    {
    public:
        typedef ChartContext* Ptr;
        //typedef MSynch::SmartPtr<ChartContext> Ptr;

        ChartContext(Dataset::Ptr iDatasetPtr);
        virtual ~ChartContext();

        void RefreshGraphMatrixContext();

        void SetChartOffset(Int32 iXOffset, Int32 iYOffset);

        //  void GetStringExtent(const MBase::String& irString, FormatFont::Ptr iFormatFontPtr, Int32& orWidth,Int32& orHeight);

        //  void ApplyFontFormat(FormatFont::Ptr iFormatFontPtr);

        //  Transformation between Device and Virtual world
        Rect2D DVRect(const Rect2D& irImageRect) const;
        Rect2D VDRect(const Rect2D& irVirtualRect) const;

        Point2D DVPoint(const Point2D& irImagePoint) const;
        Point2D VDPoint(const Point2D& irVirtualPoint) const;
        Int32 VDWidth(Int32 iVirtualWidth) const;
        Int32 VDHeight(Int32 iVirtualHeight) const;
        Int32 DVWidth(Int32 iImageWidth) const;
        Int32 DVHeight(Int32 iImageHeight) const;

        // Transformation of Radius
        Int32 VDRadius(Int32 iVirtualRadius) const;

        // Transformation between 3DG Virtual and MSTR Virtual
        void TDGToMSTRPoint(Int32 iX, Int32 iY, Point2D& orPoint) const;
        void MSTRToTDGPoint(const Point2D& irPoint, Int32& orX, Int32& orY) const;
        void TDGToMSTRRect(Int32 iTop, Int32 iLeft, Int32 iBottom, Int32 iRight, Rect2D& orRect) const;
        void MSTRToTDGRect(const Rect2D& irRect, Int32& orTop, Int32& orLeft, Int32& orBottom, Int32& orRight) const;
        void TDGToMSTRHeight(Int32 iTDGHeight, Int32& orMSTRHeight) const;

        //Access
        void SetGraphSize(Int32 iGraphWidth, Int32 iGraphHeight);
        Int32 GetGraphWidth() const;
        Int32 GetGraphHeight() const;
        void SetProjectionArea(const Rect2D& irProjectionArea);
        void SetManualLayout(bool iManualLayout);
        bool IsManualLayout() const;
        void SetRecalculateFrame(bool iRecalculate);
        bool IsRecalculateFrame() const;
        void SetLineWidthOdd(bool iIsLineWidthOdd);
        bool NeedAdjustedLinePath() const;
        void SetAbsoluteFontLineSize(bool iAbsolute);
        bool IsAbsoluteFontLineSize() const;
        void SetAdvancedChartTypeSupport(bool iAdvancedChartTypeSupport);
        bool HasAdvancedChartTypeSupport() const;
        bool IsAdvancedChartType() const;

        void SetDataset(Dataset::Ptr iDatasetPtr);
        Dataset::Ptr GetDataset();

        double GetZoomScale(bool iIsHonest = true);

        void VDFontSize(Int32& iorSize) const;
        void DVFontSize(Int32& iorSize) const;
        void VDLineWidth(Int32& iorSize) const;

        //Factory methods for FormatLine/FormatFill/FormatFont
        virtual FormatLine::Ptr GetFormatLine(const TripleId& irTripleId, Int32 iCollectionType, EnumShapeType iShape = _GENERIC) const = 0;
        virtual FormatFill::Ptr GetFormatFill(const TripleId& irTripleId, Int32 iCollectionType, EnumShapeType iShape = _GENERIC) const = 0;
        virtual FormatFill::Ptr GetMetricFormatFill(const TripleId& irTripleId);
        virtual FormatFont::Ptr GetFormatFont(const TripleId& irTripleId) const = 0;
        virtual bool GetProperty(Int32 iPropertyId, const TripleId& irTripleId, CComVariant* opValue) const;
        virtual void PutProperty(Int32 iPropertyId, const TripleId& irTripleId, CComVariant* ipValue);

        bool GetLocation(Int32 iPropertyId, Int32* opTop, Int32* opLeft, Int32* opBottom, Int32* opRight);

        bool GetLocation(Int32 iPropertyId, Rect2D* opRect);

        void PutLocation(Int32 iPropertyId, Int32 iTop, Int32 iLeft, Int32 iBottom, Int32 iRight);

        void PutLocation(Int32 iPropertyId, const Rect2D& iRect);

        virtual void PutChartEngine(Chart* ipChart);

        FormatFill::Ptr GetThresholdFillColor(Int32 iSeriesId, Int32 iGroupId);//, CComVariant* opValue);

        void UpdateLineColorWithThreshold(const TripleId& irTripleId, FormatLine* iopFormatLine, Int32 iCollectionType);
        void ParseValueToFormat(VARIANT& irValue, ChartAdvFormat& orFormat);


        //1.    Transform Primitives
        //1.1 SaveState
        void SaveState();
        //1.2 Rotate
        void Rotate(const Point2D& irAnchor, double iRadian);
        //1.3 Scale
        void Scale(const double iX, const double iY);
        //1.3 Restore state
        void RestoreState();

        //1.4 Clip
        void Clip();

        //2.    Draw Primitives
        //2.1 Polgyon
        template<class T>
        void DrawPolygon(const std::vector< Point<T> >& irPoints, bool iIsLinePath = true, bool iIsCurveAnimation = false, FPoint2D* iBasePoint = NULL, unsigned char iLineStyle = LS_SOLID);
        //2.2 Straight line
        template<class T>
        void DrawStraightLine(const Point<T>& irStartPoint, const Point<T>& irEndPoint);
        //2.3 Poly line
        template<class T>
        void DrawPolyLine(const std::vector< Point<T> >& irPoints, bool iIsLinePath = true, bool iIsCurveAnimation = false, FPoint2D* iBasePoint = NULL, unsigned char iLineStyle = LS_SOLID);
        //2.4 Rectangle
        void DrawRectangle(const Rect2D& irRect, bool iIsLinePath);
        //2.5 Arc
        void DrawArc(const FPoint2D& irCenter, const float iRadius, const float iStartAngle, const float iEndAngle, bool iNewPath = true);
        void DrawArcNegative(const FPoint2D& irCenter, const float iRadius, const float iEndAngle, const float iStartAngle, bool iNewPath = true);
        //2.6 Sector
        void DrawSector(const FPoint2D& irCenter, const float iRadius, const float iStartAngle, const float iEndAngle);
        
        /*
         
         */
        void DrawSectorStroke(const FPoint2D& irCenter, const float iRadius, const float iStartAngle, const float iEndAngle);
        void DrawRingSector(const FPoint2D& irCenter, const float iOutRadius, const float iInRadius, const float iStartAngle, const float iEndAngle);
        //2.7 Cylinder (for pie)
        void DrawCylinder(const FPoint2D& irCenter, const float iRadius, const float iStartAngle, const float iEndAngle, const float iDepth);
        //      /**
        //      Draw a string using Cairo.
        //      @param irPoint The anchor point of the string.
        //      @param ipString The string to be drawn.
        //      */
        //      void DrawString(const Point2D& irPoint, const char* ipString);
        //2.8 Bevel effect
        template<class T>
        void ApplyDonutToRing(const Point<T>& irCenter, T iOuterRadius, T iInnerRadius, const FormatFill::Ptr iFormatFillPtr, EnumRadientGradientUsage iUsage = RG_RING, bool iHasExtraPara = false, int iExtraDepth = 0, int iExtraIntensity = 0);
        void ApplyBeveledFrameToRectangle(const Rect2D& irRect, double iRotationAngle, Int32 iBevelDepth, const RGBColor& irLTColor, Int32 iLTAlpha, const RGBColor& irRBColor, Int32 iRBAlpha);
#ifdef _VE_CE
        //Draw gauge marker
        void DrawGaugeMarker(FPoint2D* iBasePoint, Int32& iMarkerSize, Int32& iMarkerShape, float iAngle, short iSize);

        template<class T>
        void DrawDashedLine(const Point<T>& irStartPoint, const Point<T>& irEndPoint, std::vector<double>& ipLinePattern);

        void ApplyDonutToRect(const Point<double>& irStartPoint, const Point<double>& irEndPoint, const FormatFill::Ptr iFormatFillPtr);
#endif

        void NewPath();
        void ClosePath();

        void MoveTo(double iX, double iY, bool iIsCurveAnimation = false, FPoint2D* iBasePoint = NULL);

        void LineTo(double iX, double iY, bool iIsCurveAnimation = false, FPoint2D* iBasePoint = NULL);
#ifdef _VE_CE

        void BezierCurveTo(double iCP1X, double iCP1Y, double iCP2X, double iCP2Y, double iX, double iY);
#endif

        void SetRGBAFill(float iRed, float iGreen, float iBlue, float iAlpha);

        void SetRGBAStroke(float iRed, float iGreen, float iBlue, float iAlpha);

        void FillPath();

        void StrokePath();

        void SetLineDash(double* ipLinePattern, Int32 iDashNumber);

        void SetLineWidth(Int32 iLineWidth);

        void SetFontSize( Int32 iFontSize);
        void SetFontScale(double iRatio = 1.0);
        double GetFontScale() const;


        void SetLineJoin(EnumLineJoinType iLineJoinType);

        EnumLineJoinType GetLineJoin();

        bool SaveSurfaceToFile(Int32 iFormat, FILE* ipOutFile);
        bool SaveSurfaceToMemory(Int32 iFormat, char*& oprMemory, unsigned Int32& orSize);

#ifdef _VE_CE
        bool SaveSurfaceToString(std::string& orGraphDesc);
        bool SaveSurfaceToVEObjects(std::vector<MVE::VEFormatList>& ioFormatList, std::vector<MVE::VEUnitList>& ioUnitList);
#endif

        void CalculateDepthOffset(Int32 iDepth, Int32 iAngle, Int32& orOffsetX, Int32& orOffsetY, bool iAbsoluteDepth = false) const;
        Int32 NormalDirection(const TVector2D<Int32>& iSideDirection, Int32 iDepthDirection);

        double Square(double iNumber) const;

        Int32 GetGraphType() const;

        bool IsVertical() const;

        bool IsDualAxis() const;

        Int32 DialogSizeToPixelSize(Int32 iDialogSize) const;

        void SplitRect(const Rect2D& irRect, bool iIsVertical, Int32 iPercentage, Rect2D& orRectTopRight, Rect2D& orRectBottomLeft) const;

        void GetAxisAutoNumberFormat(ChartAdvFormat& orFormat);
        void GetAxisAutoNumberFormat(ChartAdvFormat& orFormat, const std::vector<Int32>& irMetricSet);

        void GetAxisAutoNumberFormat(ChartAdvFormat& orFormat, const TripleId& irTripleId);

        Int32 GetGraphMajorType() const;

        Int32 PtSizeToPixelSize(Int32 iPtSize) const;
        Int32 PixelSizeToPtSize(Int32 iPixelSize) const;

        bool IsReverseSeriesOrder(ValueAxis* ipValueAxis, bool iIsVertical, Int32 iDepthDirection) const;

        bool IsReverseGroupOrder(bool iIsVertical, Int32 iDepthDirection) const;

        cairo_surface_t* CreatePDFSurfaceForStream();

        cairo_surface_t* CreateSVGSurfaceForStream();

        Point2D GetPointByAngleRadiusCenter(double iAngle, double iRadius, const Point2D& irCenter) const;
        bool RectangleIntersection(const Rect2D& irRectA, const Rect2D& irRectB, Rect2D& orRect) const;

        void RectangleUnion(const Rect2D& irRectA, const Rect2D& irRectB, Rect2D& orRect) const;

        Transformer* GetTransformer();
#ifndef _VE_CE

        void SetCGContext(CGContext* ipCGContext);
#endif
        bool GetIsCategoryXAxisForPartialRendering();
        void SetIsCategoryXAxisForPartialRendering(bool isForPartialRendering);

        bool IsParetoChart() const;

        bool IsStackedChart() const;

        double VectorToAngle(const DVector2D& irVector) const;

        void SetImageFormat(Int32 iFormat);

        Int32 GetImageFormat() const;

        void SetPushGroup(bool iPushGroupFlag);

        bool GetPushGroup() const;

        bool CheckRiserCountLimit(const TripleId& irTripleId) const;

        double DoubleToFixedPointNumber(double iValue) const;

        bool IsVectorGraph() const;

        virtual bool IsGenericContext() const = 0;

        void SetChartComponent(EnumChartComponent iChartComponent);

        EnumChartComponent GetChartComponent() const;

        AxesState* GetAxesState();
        void RestoreZoomState(Dataset* ipDataset);

        void SaveDatasetState(Dataset* ipDataset);
        void RestoreDataset(Dataset* ipDataset);

        void SetValueAxisShown(bool iIsValueAxisShown);

        bool IsValueAxisShown() const;

        void EnableAnimation(bool iUseAnimation);

        bool IsAnimationEnabled() const;

        bool IsUseAnimation() const;

        void SetAnimationDuration(double iSeconds);

        double GetAnimationDuration() const;

        // lasso selections
        void EnterGrayoutMode();
        void ExitGrayoutMode();
        bool IsGrayoutMode() const;
        void EnterDuplicateMode();
        void ExitDuplicateMode();
        bool IsDuplicateMode() const;

        void SetTemplateNodeKey(const std::string& irKey);
        std::string GetTemplateNodeKey() const;

        void SetTimeSeriesChart(bool iIsTimeSeries);
        bool IsTimeSeriesChart() const;

        void SetIntegrity(Int32 iIntegrity);
        Int32 GetIntegrity();

        void HideAxisElements(bool iHide);
        bool IsHidingAxisElements() const;

        void EnableMicroChart(bool iIsMicroChart);
        bool IsMicroChart() const;

        void EnableGraphMatrix(bool iIsGraphMatrix);

        bool IsGraphMatrix() const;

        EnumWidgetType GetWidgetType();

        void EnableVIDocument(bool iIsVIDocument);

        bool IsVIDocument() const;

        void EnableVoiceOver(bool iIsVoiceOverMode);

        bool IsVoiceOver() const;

        bool IsLegendByGroup() const;


        //bool IsGridChartWithVariousColoring() const;

        void EnableUniformAxis(bool iUseUniformAxis);
        bool IsUniformAxisMode() const;
        bool IsUADataAreaOutput();

        void SetEntireness(bool iIsEntireChart);
        bool IsEntireChart() const;

        void SetImageUsage(Int32 iImageUsage);
        Int32 GetImageUsage() const;

        void SetFormatManager(FormatManager::Ptr iFormatManagerPtr);

        FormatManager::Ptr GetFormatManager() const;

        UniformAxisContext* GetUniformAxisContext();

        GraphMatrixContext* GetGraphMatrixContext();

        Int32 GetChartXOffset() const;
        Int32 GetChartYOffset() const;
#ifndef _VE_CE

        CGContext* GetPrivateCGContext();
#endif

        void SetFontAntiAlias(bool iFontAntiAlias);

        bool IsFontAntiAlias() const;

        void SetBackgroundOpaque(bool iBackgroundOpaque);

        bool IsBackgroundOpaque() const;

        // Get current Frame of Graph, used for GM Partial rendering
        bool GetCurrentGraphFrame(Rect2D& iorRect) const;
        void SetCurrentGraphFrame(Int32 iX, Int32 iY, Int32 iWidth, Int32 iHeight);

        void SetApplyMetricFormatting(bool iApplyMetricFormatting);

        bool GetApplyMetricFormatting() const;

        bool IsBackgroundBright(bool iIsRecursive = true) const;

        void RemoveZeroEdgeInPolygon(std::vector<Point2D>& iorPolygon) const;

        void Reset();

        void AnimationDidFinished();

        void DisableAnimationForZoom(bool iDisableAnimation);

        bool IsAnimationDisabledForZoom();

        bool IsDataLabels(const TripleId& irId) const;

        void SetHighlightSelectedObjects(LayerObjectPtr iHighlightLayerObjectPtr);
        void GetHighLightSelectedObjects(LayerObjectPtr &orHighlightLayerObjectPtr);
        void ResetHighlightObjectList(std::vector<TripleId>* ipInputList);
        void GetHighLightObjectList(std::vector<TripleId>& iorCurrentList);
        bool isBarAreaInAxis(const TripleId& irId);

#ifdef _VE_CE
        void AddNeedle(char iNeedleStyle, Point2D iBasePoint, short iAngle, float iSize);
        void FillSimple(const FormatFill* ipFill, float iDarkerFactor, RGBColor* iColor = NULL, bool iHasExtraPara = false);
        void FillPattern(const FormatFill* ipFill);
        void FillGradient(const FormatFill* ipFill, const Rect2D& irBoundingRect, float iDarkerFactor);
        void FillEdgeType(const FormatFill* ipFill, const std::vector<Point2D>& irPolygon);
        void FillDonutOrSphere(const FormatFill* ipFill, const Rect2D& irBoundingRect, bool iIsCircularShape);
        void FillBorderMetallic(const FormatFill* ipFill, short iBorderUse, double iCPX, double iCPY, double iRadius, double iThickness);
        void FillRadientGradient(const FormatFill* ipFill, EnumRadientGradientUsage iRGUsage, double iCPX, double iCPY, double iInnerRadius, double iOuterRadius, bool iHasExtraPara = false, int iExtraDepth = 0, int iExtraIntensity = 0);
        void MakeDarker(const FormatFill* ipFill, float iFactor);
        void RestoreColor(const FormatFill* ipFill);
        void ApplyLineFormat(const FormatLine* ipLine);
        void AddFormatedText(const FormatFont* ipFont, const Point2D& irStartPoint, const std::string& irString);
        void BeginFirstFrame();
        void BeginLastFrame();
        void EndFrame();
        void EndUnit();
#else

        CGContext* mpCGContext;

        CGPath* mpCGPath;

#endif
        LayerObject* mpBaseLayerObject;

        LayerObject* mpTopRendererLayer;    

        bool mIsCategoryXAxisNeedPartialRendering;

        Transformer* mpTransformer;
        void* mpGridGraphViewer;

        void* mpOldChartManager;

        void* mpChartManager;

        void* mpGMCEContext;   //This is the GMCEContext from Widget

        float mGMHeightScaleRatio;
        float mGMWidthScaseRatio;
        bool  mIsTextAsShape;

        RGBColor GetSeriesColorFromPalette(Int32 iSeriesId) const;

        RGBColor* GetDefaultContrastColor(Int32 iColorUsage = -1) const;
        
        void SetHasCurvePolygon(bool iHasCurvePolygon);
        bool HasCurvePolygon() const;

        bool IsIsolatedDot(const TripleId& irId);
        bool IsIsolatedDotInLine(const TripleId& irId);

        void UpdateZoomScale(void* ipView);

        void UpdateHighScaleFactorToViews(void* ipView);
        void UpdateHighScaleFactorToViews();

        bool IsAnimationPossible(double iZoomScale);


        bool IsSubView(void* ipChildView, void* ipBaseView, bool iIsRecursive);
        bool IsBarChart() const;
        bool IsBulletChart() const;
        bool IsLineChart() const;
        bool IsAreaChart() const;
        bool IsPercentChart() const;
        bool IsPieChart() const;
        bool IsCategoryPie() const;
        EnumGraphMatrixMajorGraphType GetGraphMatrixGraphMajorType() const;

        void SetNeedColorColOffset(bool iIsNeedColorColOffset);

        bool IsBudgeting() const;

        ThemeType GetGraphThemes() const;

        void SetHover(const TripleId &iTripleId, bool iIsHover);
        bool GetHover(const TripleId &iTripleId) const;

        virtual float GetMemoryUsageEstimation() const;

        bool IsAxesStateNULL() const;
        void SetCanvas(ChartCanvas *ipCanvas);
        ChartCanvas* GetCanvas();
        Rect2D GetGraphFrame();
        RGBColor GetColorById(const TripleId& irTripleId, float& orAlpha) const;
    protected:
        void UpdateFormatLine(const TripleId& irTripleId, FormatLine* iopFormatLine) const;
        void UpdateFormatFill(const TripleId& irTripleId, FormatFill* iopFormatFill, Int32 iCollectionType) const;
        void UpdateFormatFont(const TripleId& irTripleId, FormatFont* iopFormatFont) const;

        Int32 MapObject(Int32 iObjectId) const;

        bool IsVerticalBar() const;
        std::map<PropertyKey, CComVariant> mPropertyMap;

        bool NoAdjustOfFontSize(const TripleId& irTripleId) const;
        bool NoAdjustOfLineWidth(const TripleId& irTripleId) const;

        Int32 mGraphWidth;  
        Int32 mGraphHeight; 
        Int32 mImageFormat;             
        Int32 mUniformAxisLeftMargin;       
        Int32 mUniformAxisTopMargin;        
        Int32 mUniformAxisBottomMargin;     


        EnumChartComponent mChartComponent;

        Int32 mGraphType;   
        Int32 mImageUsage;      
        Dataset::Ptr mDatasetPtr;   

        bool mIsLineWidthOdd;
        bool mAbsoluteFontLineSize;
        bool mManualLayoutMode; 
        bool mRecalculateFrame; 
        bool mPushGroupFlag;    
        bool mIsValueAxisShown; 
        bool mIsFontAntiAlias;
        bool mUseAnimation;     
        bool mUseAnimationForZoom; 
        bool mHasAnimatedObject;
        bool mIsTimeSeriesChart;    
        bool mIsMicroChart;         
        bool mIsUniformAxisMode;    
        bool mIsEntireChart;        
        bool mIsGraphMatrix;        
        bool mIsVIDocument;
        bool mAdvancedChartTypeSupport;
        bool mHasCurvePolygon;      
        bool mIsVoiceOver;          
        bool mIsBackgroundOpaque;   
        double mAnimationDuration;
        double mFontScaleRatio;       

        bool mIsNeedColorColOffset;
        bool mShouldHideAxisElements; 
        bool mApplyMetricFormatting;    

        bool mIsGrayoutMode; 
        bool mIsDuplicated; 

        AxesState* mpAxesState;
        DatasetState* mpDatasetState;
        UniformAxisContext* mpUniformAxisContext;
        GraphMatrixContext* mpGraphMatrixContext;

        // Very Large chart, we draw a small view cover current screen, this offset is current screen view to origin chart.
        Int32 mChartXOffset;
        Int32 mChartYOffset;

        // Used in time series chart, indicating which part of chart will be rendered.
        Int32 mChartIntegrity;

        ChartAdvFormat* mpAxisAutoNumberFormat; 
        std::map<std::vector<Int32>, ChartAdvFormat*> mGMAxisAutoNumberFormatSet; 
        std::map<TripleId, ChartAdvFormat*> mAxisAutoNumberFormatSet;

        ThresholdCache mThresholdCache;

        std::vector<MetricFormatFillCache> mMetricFormatFillCache;  

        std::string mTemplateNodeKey;

        FormatManager::Ptr mFormatManagerPtr;

        EnumLineJoinType mLineJoinType;

        ChartCanvas  * mpCanvas;

    private:
        void hApplyEnhancedSeriesEffect(FormatFill* iopFormatFill, Int32 iCollectionType) const;

        void hMoveTo(double iX, double iY, bool iIsLinePath, bool iIsCurveAnimation = false, FPoint2D* iBasePoint = NULL);
        void hLineTo(double iX, double iY, bool iIsLinePath, bool iIsCurveAnimation = false, FPoint2D* iBasePoint = NULL);

        void hReleaseStreamBuffer();

        void hParseValueContent(std::wfstream& irFile, const CComVariant& irValue);

        void hParseParrayContent(std::wfstream& irFile, const CComVariant& irValue);

        void hFinalizeVectorGraphSurface();
        Int32 hParseValueToFormat(const MBase::String& irFormatString, ChartAdvFormat& orFormat);

#ifndef _VE_CE
        CGContext* mpPrivateCGContext;

        //  FontKey mPublicFontKey;     ///< Maintains current font key(mpCGContext). This is used by GetStringExtent() method.
        //  FontKey mPrivateFontKey;    ///< Maintains current font key(mpPrivateCairo). This is used by GetStringExtent() method.
#endif
        LayerObjectPtr mpHighlightLayerObjectPtr;

        //Keep a record of the current highlighted graph objects.
        std::vector<TripleId> mHighLightedObjectList;

        std::map<TripleId, bool> mTripleIdHoverMap;

        Rect2D mGraphFrame;

        ChartContextHelper *mpChartContextHelper;
    };

    inline Rect2D ChartContext::GetGraphFrame()
    {
        return mGraphFrame;
    }
    inline Int32 ChartContext::VDWidth(Int32 iVirtualWidth) const
    {
        return static_cast<Int32>(static_cast<double>(iVirtualWidth * mGraphWidth) / gVirtualCoordinateWidth + 0.5);
    }

    inline Int32 ChartContext::VDHeight(Int32 iVirtualHeight) const
    {
        Int32 lGraphHeight = mGraphHeight;
        if (mIsUniformAxisMode && !mIsEntireChart)
        {
            _ASSERTE(mpUniformAxisContext != NULL);
            lGraphHeight = mpUniformAxisContext->mGraphHeight;
        }
        return static_cast<Int32>(static_cast<double>(iVirtualHeight * lGraphHeight) / gVirtualCoordinateHeight + 0.5);
    }

    inline Int32 ChartContext::DVWidth(Int32 iImageWidth) const
    {
        return static_cast<Int32>(static_cast<double>(iImageWidth * gVirtualCoordinateWidth) / mGraphWidth + 0.5);
    }

    inline Int32 ChartContext::DVHeight(Int32 iImageHeight) const
    {
        return static_cast<Int32>(static_cast<double>(iImageHeight * gVirtualCoordinateHeight) / mGraphHeight + 0.5);
    }

    inline void ChartContext::SetLineWidthOdd(bool iIsLineWidthOdd)
    {
        mIsLineWidthOdd = iIsLineWidthOdd;
    }
    inline bool ChartContext::NeedAdjustedLinePath() const
    {
        return mIsLineWidthOdd && (mImageFormat != PFT_PDF) && (mImageFormat != PFT_SVG);
    }

    inline bool ChartContext::IsVectorGraph() const
    {
        return (mImageFormat == PFT_PDF) || (mImageFormat == PFT_SVG);
    }

    inline void ChartContext::SetGraphSize(Int32 iGraphWidth, Int32 iGraphHeight)
    {
        mGraphWidth = iGraphWidth;
        mGraphHeight = iGraphHeight;
        
        //Init graph frame if not initilized, temp solution
        if (mGraphFrame.height == -1 && mGraphFrame.width == -1) {
            mGraphFrame.x = mGraphFrame.y = 0;
            mGraphFrame.height = iGraphHeight;
            mGraphFrame.width = iGraphWidth;
        }
    }

    inline Int32 ChartContext::GetGraphWidth() const
    {
        return mGraphWidth;
    }

    inline Int32 ChartContext::GetGraphHeight() const
    {
        return mGraphHeight;
    }

    inline void ChartContext::SetManualLayout(bool iManualLayout)
    {
        mManualLayoutMode = iManualLayout;
    }

    inline bool ChartContext::IsManualLayout() const
    {
        return mManualLayoutMode;
    }

    inline void ChartContext::SetRecalculateFrame(bool iRecalculate)
    {
        mRecalculateFrame = iRecalculate;
    }

    inline bool ChartContext::IsRecalculateFrame() const
    {
        return mRecalculateFrame;
    }

    inline void ChartContext::SetAbsoluteFontLineSize(bool iAbsolute)
    {
        mAbsoluteFontLineSize = iAbsolute;
    }

    inline bool ChartContext::IsAbsoluteFontLineSize() const
    {
        return mAbsoluteFontLineSize;
    }

    inline double ChartContext::Square(double iNumber) const
    {
        return iNumber * iNumber;
    }
    inline Int32 ChartContext::GetGraphType() const
    {
        return mGraphType;
    }

    inline Int32 ChartContext::DialogSizeToPixelSize(Int32 iDialogSize) const
    {
        return iDialogSize * std::min(mGraphWidth, mGraphHeight) / 2000;
    }
    inline void ChartContext::SetDataset(Dataset::Ptr iDatasetPtr)
    {
        mDatasetPtr = iDatasetPtr;
    }
    inline Dataset::Ptr ChartContext::GetDataset()
    {
        return mDatasetPtr;
    }


    inline void ChartContext::SetChartComponent(EnumChartComponent iChartComponent)
    {
        mChartComponent = iChartComponent;
    }

    inline EnumChartComponent ChartContext::GetChartComponent() const
    {
        return mChartComponent;
    }

    template<class T>
    void ChartContext::DrawPolygon(const std::vector< Point<T> >& irPoints, bool iIsLinePath, bool iIsCurveAnimation, FPoint2D* iBasePoint, unsigned char iLineStyle)
    {
        Int32 lNumberOfPoints = (Int32)irPoints.size();
        if(lNumberOfPoints < 3)
            return;

        NewPath();
        if (iIsLinePath && NeedAdjustedLinePath())
        {
            std::vector<FPoint2D> lAdjustedPoints;
            for(Int32 i = 0; i < lNumberOfPoints; ++i)
            {
                lAdjustedPoints.push_back(irPoints[i]);
            }

            Int32 lPreviousIndex = lNumberOfPoints - 1;
            for(Int32 i = 0; i < lNumberOfPoints; ++i)
            {
                Int32 lNextIndex = (i + 1 == lNumberOfPoints) ? 0 : i + 1;
                if (irPoints[i].x == irPoints[lPreviousIndex].x || irPoints[i].x == irPoints[lNextIndex].x)
                {
                    lAdjustedPoints[i].x += 0.5f;
                }
                if (irPoints[i].y == irPoints[lPreviousIndex].y || irPoints[i].y == irPoints[lNextIndex].y)
                {
                    lAdjustedPoints[i].y += 0.5f;
                }
                lPreviousIndex = i;
            }
            DrawPolyLine(lAdjustedPoints, false, iIsCurveAnimation, iBasePoint, iLineStyle);
        }
        else
        {
            DrawPolyLine(irPoints, false, iIsCurveAnimation, iBasePoint, iLineStyle);
        }
        ClosePath();
    }

    template<class T>
    void ChartContext::DrawStraightLine(const Point<T>& irStartPoint, const Point<T>& irEndPoint)
    {
        NewPath();
        hMoveTo(irStartPoint.x, irStartPoint.y, true);
        hLineTo(irEndPoint.x, irEndPoint.y, true);
    }

    template<class T>
    void ChartContext::DrawPolyLine(const std::vector< Point<T> >& irPoints, bool iIsLinePath, bool iIsCurveAnimation, FPoint2D* iBasePoint, unsigned char iLineStyle)
    {
        Int32 lNumberOfPoints = (Int32)irPoints.size();
        if(lNumberOfPoints<=0)
            return;
        NewPath();
        hMoveTo(irPoints[0].x, irPoints[0].y, iIsLinePath, iIsCurveAnimation, iBasePoint);
        Int32 lPreviousIndex = 0;
        for(Int32 i = 1; i < lNumberOfPoints; ++i)
        {
            // If the current point is not the last point and is on a vertical or horizontal segement formed by the prevous and the next point,
            // do not put it into the path.
            if ((i + 1 == lNumberOfPoints) || irPoints[i].IsOnVerOrHorSegment(irPoints[lPreviousIndex], irPoints[i + 1]) == false)
            {
                hLineTo(irPoints[i].x, irPoints[i].y, iIsLinePath, iIsCurveAnimation, iBasePoint);
                lPreviousIndex = i;
            }
        }
#ifdef _VE_CE
        if(!iIsLinePath)
        {
            if(irPoints[0].IsOnVerOrHorSegment(irPoints[lPreviousIndex], irPoints[1]) == false)
            {
                hLineTo(irPoints[0].x, irPoints[0].y, iIsLinePath, iIsCurveAnimation, iBasePoint);
            }
        }
#endif
    }

    template<class T>
    void ChartContext::ApplyDonutToRing(const Point<T>& irCenter, T iOuterRadius, T iInnerRadius, const FormatFill::Ptr iFormatFillPtr, EnumRadientGradientUsage iUsage, bool iHasExtraPara, int iExtraDepth, int iExtraIntensity)
    {
#ifdef _VE_CE
        double lCX = irCenter.x;
        double lCY = irCenter.y;

        double lMiddleRadius = iInnerRadius + (1.0 - (1.0 - iFormatFillPtr->mFillBevel.mDepth * 0.01)) * (iOuterRadius - iInnerRadius);

        SaveState();
        Clip();

        const short lMargin = 1;
        if (iUsage != RG_BORDERRING)
        {
            FillRadientGradient(iFormatFillPtr.Get(), RG_RING, lCX, lCY, iInnerRadius > lMargin ? iInnerRadius - lMargin : 0, lMiddleRadius);
            FillRadientGradient(iFormatFillPtr.Get(), RG_RING, lCX, lCY, iOuterRadius + lMargin, lMiddleRadius);
        }
        else
        {
            FillRadientGradient(iFormatFillPtr.Get(), RG_BORDERRING, lCX, lCY, iInnerRadius > lMargin ? iInnerRadius - lMargin : 0, iOuterRadius + lMargin, iHasExtraPara, iExtraDepth, iExtraIntensity);
        }

        RestoreState();
#else
        //  CGColorSpaceRef lColorspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
        CGColorSpaceRef lColorspace = CGColorSpaceCreateDeviceRGB();
        double lMiddleRadius = iInnerRadius + (1.0 - (1.0 - iFormatFillPtr->mFillBevel.mDepth * 0.01)) * (iOuterRadius - iInnerRadius);

        size_t lNumOfLocations = 2;
        CGFloat lLocations[2] = { 0.0, 1.0 };
        float lTransparency = iFormatFillPtr->mFillBevel.mIntensity * 0.01f * iFormatFillPtr->mAlpha / 255.0f;
        CGFloat lComponents[8] = { 0.0, 0.0, 0.0, lTransparency,
            1.0, 1.0, 1.0, lTransparency
        };
        CGGradientRef lGradient = CGGradientCreateWithColorComponents (lColorspace, lComponents, lLocations, lNumOfLocations);

        CGPoint lCenter = CGPointMake(irCenter.x, irCenter.y);

        SaveState();
        Clip();

        // 429813 Add some margin at boundary to make the boundary look smoother.
        const Int32 lMargin = 1;
        CGContextDrawRadialGradient(mpCGContext, lGradient, lCenter,
                                    iInnerRadius > lMargin ? iInnerRadius - lMargin : 0,
                                    lCenter, lMiddleRadius, 0);
        CGContextDrawRadialGradient(mpCGContext, lGradient, lCenter,
                                    iOuterRadius + lMargin,
                                    lCenter, lMiddleRadius, 0);
        RestoreState();

        CGGradientRelease(lGradient);
        CGColorSpaceRelease(lColorspace);
#endif
    }
    inline bool ChartContext::IsParetoChart() const
    {
        return mGraphType == DssGraphTypePareto || mGraphType == DssGraphTypePareto_Percent;
    }
    inline void ChartContext::SetImageFormat(Int32 iFormat)
    {
        mImageFormat = iFormat;
    }
    inline Int32 ChartContext::GetImageFormat() const
    {
        return mImageFormat;
    }
    inline void ChartContext::SetPushGroup(bool iPushGroupFlag)
    {
        mPushGroupFlag = iPushGroupFlag;
    }
    inline bool ChartContext::GetPushGroup() const
    {
        return mPushGroupFlag;
    }
    inline void ChartContext::SetValueAxisShown(bool iIsValueAxisShown)
    {
        mIsValueAxisShown = iIsValueAxisShown;
    }
    inline bool ChartContext::IsValueAxisShown() const
    {
        return mIsValueAxisShown;
    }

    inline void ChartContext::EnableAnimation(bool iUseAnimation)
    {
        mUseAnimation = iUseAnimation;
    }

    inline void ChartContext::DisableAnimationForZoom(bool iDisableAnimation)
    {
        mUseAnimationForZoom = !iDisableAnimation;
    }
    inline bool ChartContext::IsUseAnimation() const
    {
        return mUseAnimation;
    }
    inline bool ChartContext::IsAnimationDisabledForZoom()
    {
        return !mUseAnimationForZoom;
    }

    inline void ChartContext::SetAnimationDuration(double iSeconds)
    {
        mAnimationDuration = iSeconds;
    }
    inline double ChartContext::GetAnimationDuration() const
    {
        return mAnimationDuration;
    }
    inline void ChartContext::EnterGrayoutMode()
    {
        mIsGrayoutMode = true;
    }
    inline void ChartContext::ExitGrayoutMode()
    {
        mIsGrayoutMode = false;
    }
    inline bool ChartContext::IsGrayoutMode() const
    {
        return mIsGrayoutMode;
    }
    inline void ChartContext::EnterDuplicateMode()
    {
        mIsDuplicated = true;
    }
    inline void ChartContext::ExitDuplicateMode()
    {
        mIsDuplicated = false;
    }
    inline bool ChartContext::IsDuplicateMode() const
    {
        return mIsDuplicated;
    }
    inline std::string ChartContext::GetTemplateNodeKey() const
    {
        return mTemplateNodeKey;
    }

    inline void ChartContext::SetFormatManager(FormatManager::Ptr iFormatManagerPtr)
    {
        mFormatManagerPtr = iFormatManagerPtr;
    }
    inline FormatManager::Ptr ChartContext::GetFormatManager() const
    {
        return mFormatManagerPtr;
    }

    inline void ChartContext::SetIntegrity(Int32 iIntegrity)
    {
        mChartIntegrity = iIntegrity;
    }
    inline Int32 ChartContext::GetIntegrity()
    {
        return mChartIntegrity;
    }

    inline void ChartContext::SetTimeSeriesChart(bool iIsTimeSeries)
    {
        mIsTimeSeriesChart = iIsTimeSeries;
        if (mIsTimeSeriesChart)
        {
            mGraphType = DssGraphTypeVertical_Line_Absolute;
        }
    }
    inline bool ChartContext::IsTimeSeriesChart() const
    {
        return mIsTimeSeriesChart;
    }

    inline void ChartContext::EnableMicroChart(bool iIsMicroChart)
    {
        mIsMicroChart = iIsMicroChart;
    }
    inline bool ChartContext::IsMicroChart() const
    {
        return mIsMicroChart;
    }

    inline void ChartContext::EnableVoiceOver(bool iIsVoiceOverMode)
    {
        mIsVoiceOver = iIsVoiceOverMode;
    }

    inline bool ChartContext::IsVoiceOver() const
    {
        return mIsVoiceOver;
    }

    inline void ChartContext::EnableGraphMatrix(bool iIsGraphMatrix)
    {
        mIsGraphMatrix = iIsGraphMatrix;
    }

    inline bool ChartContext::IsGraphMatrix() const
    {
        return mIsGraphMatrix;
    }

    inline void ChartContext::EnableVIDocument(bool iIsVIDocument)
    {
        mIsVIDocument = iIsVIDocument;
    }

    inline bool ChartContext::IsVIDocument() const
    {
        return mIsVIDocument;
    }

    inline void ChartContext::SetNeedColorColOffset(bool iIsNeedColorColOffset)
    {
        mIsNeedColorColOffset = iIsNeedColorColOffset;
    }

    inline void ChartContext::SetImageUsage(Int32 iImageUsage)
    {
        mImageUsage = iImageUsage;
    }
    inline Int32 ChartContext::GetImageUsage() const
    {
        return mImageUsage;
    }
    inline void ChartContext::EnableUniformAxis(bool iUseUniformAxis)
    {
        mIsUniformAxisMode = iUseUniformAxis;
    }
    inline bool ChartContext::IsUniformAxisMode() const
    {
        return mIsUniformAxisMode;
    }
    inline void ChartContext::SetEntireness(bool iIsEntireChart)
    {
        mIsEntireChart = iIsEntireChart;
    }
    inline bool ChartContext::IsEntireChart() const
    {
        return mIsEntireChart;
    }
    inline bool ChartContext::IsFontAntiAlias() const
    {
        return mIsFontAntiAlias;
    }
    inline void ChartContext::SetAdvancedChartTypeSupport(bool iAdvancedChartTypeSupport)
    {
        mAdvancedChartTypeSupport = iAdvancedChartTypeSupport;
    }
    inline bool ChartContext::HasAdvancedChartTypeSupport() const
    {
        return mAdvancedChartTypeSupport;
    }
#ifndef _VE_CE
    inline void ChartContext::SetLineJoin(EnumLineJoinType iLineJoinType)
    {
        mLineJoinType = iLineJoinType;
        switch (mLineJoinType) {
            case LJT_MITER:
                CGContextSetLineJoin(mpCGContext, kCGLineJoinMiter);
                break;
            case LJT_BEVEL:
                CGContextSetLineJoin(mpCGContext, kCGLineJoinBevel);
                break;
            case LJT_ROUND:
                CGContextSetLineJoin(mpCGContext, kCGLineJoinRound);
                break;
            default:
                _ASSERTE(false);
                break;
        }
    }
#endif
    inline EnumLineJoinType ChartContext::GetLineJoin()
    {
        return mLineJoinType;
    }
    inline void ChartContext::SetFontScale(double iRatio)
    {
        _ASSERTE(iRatio > 0);
        mFontScaleRatio = iRatio;
    }
    inline double ChartContext::GetFontScale() const
    {
        if (mAbsoluteFontLineSize)
            return mFontScaleRatio; //#468456
        else
            return 1.0;             //#476838
    }

    inline void ChartContext::SetHasCurvePolygon(bool iHasCurvePolygon)
    {
        mHasCurvePolygon= iHasCurvePolygon;
    }
    inline bool ChartContext::HasCurvePolygon() const
    {
        return mHasCurvePolygon;
    }

    inline void ChartContext::ResetHighlightObjectList(std::vector<TripleId>* ipInputList)
    {
        mHighLightedObjectList.clear();
        if (ipInputList)
        {
            mHighLightedObjectList = *ipInputList;
        }
    }
    inline void ChartContext::GetHighLightObjectList(std::vector<TripleId>& iorCurrentList)
    {
        iorCurrentList = mHighLightedObjectList;
    }

    inline void ChartContext::SetBackgroundOpaque(bool iBackgroundOpaque)
    {
        mIsBackgroundOpaque = iBackgroundOpaque;
    }
    inline bool ChartContext::IsBackgroundOpaque() const
    {
        return mIsBackgroundOpaque;
    }

    inline void ChartContext::HideAxisElements(bool iHide)
    {
        mShouldHideAxisElements = iHide;
    }
    inline bool ChartContext::IsHidingAxisElements() const
    {
        return mShouldHideAxisElements;
    }
    inline void ChartContext::SetApplyMetricFormatting(bool iApplyMetricFormatting)
    {
        mApplyMetricFormatting = iApplyMetricFormatting;
    }
    inline bool ChartContext::GetApplyMetricFormatting() const
    {
        return mApplyMetricFormatting;
    }
    inline bool ChartContext::IsAxesStateNULL() const
    {
        if (mpAxesState) {
            return false;
        }
        else
            return true;
    }
    inline void ChartContext::SetCanvas(ChartCanvas *ipCanvas)
    {
        if(mpCanvas != NULL)
        {
            delete mpCanvas;
            mpCanvas = NULL;
        }
        mpCanvas = ipCanvas;
    }
    inline ChartCanvas* ChartContext::GetCanvas()
    {
        return mpCanvas;
    }
}
#endif