PieSliceObject.h

Go to the documentation of this file.

//=====================================================================================
//  Filename:       Kernel/SourceCode/ChartEngine/PrivateSource/PieSliceObject.h
//  Date:           2008-05-22
//  Authors:        Bing Huang

//  Copyright (C) 1997-2008 MicroStrategy Incorporated
//  All rights reserved
//=====================================================================================

#ifndef MsiChart_PieSliceObject_h
#define MsiChart_PieSliceObject_h

#include "ShapeObject.h"

namespace MsiChart
{
    //related structs and enums
    typedef enum
    {
        BRT_TOP,
        BRT_BOTTOM,
        BRT_CYLINDER,
        BRT_RING_CYLINDER,
        BRT_START_RECT,
        BRT_END_RECT,
    }BoundingRectType;
    
    typedef enum
    {
        RA_START,
        RA_END
    }RectangleAngle;

    struct Angle
    {
        Angle(Int32 iStartAngle = 0, Int32 iEndAngle = 0)
            : mStartAngle(iStartAngle), mEndAngle(iEndAngle)
        {}

        Int32 mStartAngle;
        Int32 mEndAngle;
    };

    struct SliceInfo
    {
        float   mStartAngle;
        float   mEndAngle;
        float   mRingPieFactor;
        bool    mIsRingPie;
        bool    mIs2DCircular;
        double  mScale;

        Point2D mCenter;
        float   mRadius;
        Int32   mMaxRadius;//no proportional
        Int32   mDepth;

        SliceInfo(float iStartAngle, float iEndAngle, float iRingPieFactor, 
            bool iIsRingPie, bool iIs2DCircular, double iScale, const Point2D& irCenter,
            float iRadius, Int32 iMaxRadius, Int32 iDepth, double iPercentContribution = 0)
            : mStartAngle(iStartAngle),
            mEndAngle(iEndAngle),
            mRingPieFactor(iRingPieFactor),
            mIsRingPie(iIsRingPie),
            mIs2DCircular(iIs2DCircular),
            mScale(iScale),
            mCenter(irCenter), 
            mRadius(iRadius),
            mMaxRadius(iMaxRadius),
            mDepth(iDepth)
        {}
    };

    class PieSliceObject : public ShapeObject
    {
    public:
        typedef MSynch::SmartPtr<PieSliceObject> Ptr;

        PieSliceObject(const TripleId& irTripleId, GraphObjectManager* ipManager, 
            Int32 iExplode, float iStartAngle, float iEndAngle, float iRingPieFactor, 
            bool iIsRingPie, bool iIs2DCircular, double iScale, const Point2D& irCenter,
            float iRadius, Int32 iMaxRadius, Int32 iDepth, bool iOneSeries,
            GraphCollectionObject* ipParentObject = NULL, bool iIsShown = true);
        
        //Constructor method 2 for new pie chart.
        PieSliceObject(const TripleId& irTripleId, Int32 iAngleIndex, Int32 iSliceId, GraphObjectManager* ipManager,
                       Int32 iExplode, Int32 iStartAngle, Int32 iEndAngle, float iRingPieFactor, 
                       bool iIsRingPie, bool iIs2DCircular, double iScale, const Point2D& irCenter,
                       float iRadius, Int32 iMaxRadius, Int32 iDepth, bool iOneSeries,
                       GraphCollectionObject* ipParentObject = NULL, bool iIsShown = true);
                
        

        //virtual functions from GraphObject
        virtual void Draw() const;
        virtual void DrawInnerOutLine();
        virtual void DrawOutLine();
        virtual bool PointInObject(const Point2D& irPoint);
        virtual bool ObjectInRectangle(const Rect2D& irRect);
        virtual void GenerateImageMap(ImageMap& iorImageMap);
        virtual void GetOptions(Int32 iPropertyId, CComVariant* opValue) const;
        virtual void GetBoundingRect(Rect2D& orBoundingRect) const;

        const SliceInfo* GetSliceInfo() const;

        void SetBoundingRectType(BoundingRectType iBoundingRectType) const;

        void SetCylinderStart(Int32 iCylinderStart) const;

        void SetCylinderEnd(Int32 iCylinderEnd) const;

        void SetDrawOutline(bool iIsOutline);
        
        void SetWhitenOuterBorder(bool iIsWhiten);
        
        void SetOutLineInfo(bool iIsConsectiveOutline, bool iIsHighLightStartAngelEdge, bool iIsHighLightEndAngleEdge);

        void SetIsNeedInnerStrokeForConsectiveSlcie(bool iStroke);
        
        float GetStartAngelRadian();
        float GetEndAngelRadian();
        
        void ConvertAngle(Angle& iorAngle) const;

        bool GetIntersectionConvertedAngles(const Angle& irAngle1, const Angle& irAngle2, Angle& orAngle) const;

        bool GetIntersectionAngle(const Angle& irAngle1, const Angle& irAngle2) const;

        bool GetIntersectionAngle(const Angle& irAngle1, const Angle& irAngle2, Angle& orAngle) const;

        void ElementDrawRingPieTop();

        void ElementDrawNormalPieTop();

        void ElementFillSide();

        void GetLeaderLineStartPoint(Point2D& orPoint) const;

        void GetSectorImageMap(const Point2D& irCenter, const Int32 iRadius, const Int32 iStartAngle, const Int32 iEndAngle, ImageMap& iorImageMap) const;

        void GetSideRectangleImageMap(const Point2D& irCenter, const Int32 iRadius, const Int32 iDepth, const Int32 iAngle, ImageMap& iorImageMap) const;

        void GetCylinderImageMap(const Point2D& irCenter, const Int32 iRadius, const Int32 iDepth, const Int32 iStartAngle, const Int32 iEndAngle, ImageMap& iorImageMap) const;

        void UpdateRadius(Int32 iRadius, Int32 iMaxRadius);

        Point2D GetPointByRatio(double iRadiusRatio, bool iSmartLabels = false) const;

        Int32 GetMiddleAngleQuadrant() const;

        Int32 GetMiddleAngle() const;
        
        Int32 GetAngleIndex() const;
        
        Int32 GetSliceIndex() const;

        float GetMiddleAngleRadian() const;

    protected:
        //pure virtual functions from ShapeObject
        virtual void GetClockwisePolygon(std::vector<Point2D>& orPolygon) const; 
        virtual void FillBevel() const;
        virtual bool IsCircularShape() const;
        
        friend class PieSliceElementObject;

    private:    
        void hDrawGlowEffect() const;
            
        void hApplyFillAndLine() const;

        void hFillSide() const;

        void hDrawRingPieSlice() const;

        void hDrawRingPieInnerStroke() const;
        
        void hDrawRingPieOneSeriesTop() const;

        void hDrawRingPieOneSeriesBottom() const;

        void hDrawRingPieMiddle() const;

        void hDrawRingPieTop() const;

        void hDrawRingPieBottom() const;

        void hDrawRingPieMiddleRectangle(RectangleAngle iRectangleAngle) const;

        void hDrawRingPieMiddleCylinder() const;

        void hDrawCylinder(bool iIsRing, Int32 iStartAngle, Int32 iEndAngle) const;

        void hDrawNormalPieSlice() const;

        void hDrawNormalPieInnerStroke() const;
        
        void hDrawNormalPieOneSeriesTop() const;

        void hDrawNormalPieOneSeriesBottom() const;

        void hDrawNormalPieMiddle() const;

        void hDrawNormalPieTop() const;

        void hDrawNormalPieBottom() const;

        void hDrawNormalPieMiddleRectangle(RectangleAngle iRectangleAngle) const;

        void hDrawNormalPieMiddleCylinder() const;

        bool hPointInRingPieSlice(const Point2D& irPoint) const;

        bool hPointInNormalPieSlice(const Point2D& irPoint) const;

        bool hGetIntersectionConvertedAngleToSliceAngle(const Angle& irAngle) const;

        void hGetTopBottomBoundingRect(Rect2D& orBoundingRect) const;

        void hGetCylinderBoundingRect(Rect2D& orBoundingRect) const;

        void hGetRectangleBoundingRect(Rect2D& orBoundingRect) const;

        void hWhitenOuterBorder() const;
        
        //SliceInfo mSliceInfo;
        SliceInfo mSliceInfo;       
        
        //used by "GetBoudingRect()"
        mutable BoundingRectType mBoundingRectType;
        mutable Int32 mCylinderStart;
        mutable Int32 mCylinderEnd;
        //deal with the case that there is only one series
        bool mOneSeries;
        mutable bool mIsOutline;

        Point2D mOriginalCenter;
        float mStartAngleRadian;
        float mEndAngleRadian;
        float mMiddleAngleRadian;

        Int32 mMiddleAngle;
        Int32 mMiddleAngleQuadrant;
        
        Int32 mAngleIndex;
        Int32 mSliceIndex;

        bool mIsShown;
        bool mIsWhitenOuterBorder;
        
        // Enhacement of Highline, for multiple slice connected, highlight the outer border as a group as web did.
        bool mIsConsecutiveHighLihgt;
        bool mIsConsecutiveSlcieNeedInnerStroke;
        bool mIsHighLightStartAngleEdge;
        bool mIsHighLightEndAngleEdge;
    };

    inline void PieSliceObject::SetCylinderStart(Int32 iCylinderStart) const
    {
        mCylinderStart = iCylinderStart;
    }

    inline void PieSliceObject::SetCylinderEnd(Int32 iCylinderEnd) const
    {
        mCylinderEnd = iCylinderEnd;
    }
    
    inline void PieSliceObject::SetBoundingRectType(BoundingRectType iBoundingRectType) const
    {
        mBoundingRectType = iBoundingRectType;
    }

    inline void PieSliceObject::SetDrawOutline(bool iIsOutline)
    {
        mIsOutline = iIsOutline;
    }

    inline const SliceInfo* PieSliceObject::GetSliceInfo() const
    {
        return &mSliceInfo;
    }

    inline Int32 PieSliceObject::GetMiddleAngleQuadrant() const
    {
        return mMiddleAngleQuadrant;
    }

    inline Int32 PieSliceObject::GetMiddleAngle() const
    {
        return mMiddleAngle;
    }

    inline float PieSliceObject::GetMiddleAngleRadian() const
    {
        return mMiddleAngleRadian;
    }
    
    inline Int32 PieSliceObject::GetAngleIndex() const
    {
        return mAngleIndex;
    }
    
    inline Int32 PieSliceObject::GetSliceIndex() const
    {
        return mSliceIndex;
    }
    
    inline void PieSliceObject::SetIsNeedInnerStrokeForConsectiveSlcie(bool iStroke)
    {
        mIsConsecutiveSlcieNeedInnerStroke = iStroke;
    }
    
    inline float PieSliceObject::GetStartAngelRadian()
    {
        return mStartAngleRadian;
    }
    
    inline float PieSliceObject::GetEndAngelRadian()
    {
        return mEndAngleRadian;
    }
    
    inline void PieSliceObject::SetOutLineInfo(bool iIsConsectiveOutline, bool iIsHighLightStartAngelEdge, bool iIsHighLightEndAngleEdge)
    {
        mIsConsecutiveHighLihgt = iIsConsectiveOutline;
        mIsHighLightStartAngleEdge = iIsHighLightStartAngelEdge;
        mIsHighLightEndAngleEdge = iIsHighLightEndAngleEdge;
    }
    
    inline void PieSliceObject::SetWhitenOuterBorder(bool iIsWhiten)
    {
        mIsWhitenOuterBorder = iIsWhiten;
    }

}

#endif