BarSeriesRenderer.h

Go to the documentation of this file.

//=======================================================================
//  Filename:       BarSeriesRenderer.h
//  Date:           2008-10-06
//  Authors:        Bing Huang

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

#ifndef MsiChart_BarSeriesRenderer_h
#define MsiChart_BarSeriesRenderer_h

#include "SeriesRenderer.h"
#include "GraphCollectionObject.h"
#include "DataLabelManager.h"

namespace MsiChart
{
    /*struct BarDataLabelInfo
    {
        bool mIsDisPlayed;  //<Whether this label is already been located
        bool mIsValid;      //Is Host marker valid ?
        
        Int32 mSeriesId;
        Int32 mGroupId;
        
        Int32 mSeriesInfo;

        Rect2D mHostMarkerBound;
        
        TextObject::Ptr mLabelPtr;
        
        BarDataLabelInfo(): mSeriesId(0),mGroupId(0), mIsDisPlayed(false), mIsValid(false)
        {}
        
        Rect2D ToRectangle()
        {
            Rect2D lRect;
            mLabelPtr->GetBoundingRect(lRect);
            return lRect;
        }
    };
    
    typedef std::vector<BarDataLabelInfo> DataLables;*/
    
    struct BarOptions
    {
        BarOptions(): mOverlap(0),mGapWidth(40),
            mRiserShape(0),mShowErrorBar(false),mHasMiddleValue(false),
            mMiddleValueSize(50), mShowSeriesLines(false),
            mColorBySeries(true){}
        Int32           mOverlap;   
        Int32           mGapWidth;  
        unsigned char   mRiserShape;    
        bool            mShowErrorBar;  
        bool            mHasMiddleValue;    
        Int32           mMiddleValueSize;   
        bool            mShowSeriesLines;   
        bool            mColorBySeries;     
    };

    struct RiserInfo
    {
        RiserInfo(Int32 iGroupID,Int32 iSeriesInfoID)
            : mGroupID(iGroupID),mSeriesInfoID(iSeriesInfoID)
        {}
        Int32   mGroupID;
        Int32   mSeriesInfoID;

        virtual Int32 GetGroupIndex();
    };

    inline Int32 RiserInfo::GetGroupIndex() {return mGroupID;}
    
    struct RiserInfoWithIndex : public RiserInfo //used by Pareto chart...
    {
            
        RiserInfoWithIndex(Int32 iGroupID,Int32 iSeriesInfoID) : 
        RiserInfo(iGroupID, iSeriesInfoID)  
        {
            mGroupIndex = iGroupID;
        }   
        

        RiserInfoWithIndex(Int32 iGroupID, Int32 iSeriesInfoID, Int32 iGroupIndex) : 
        RiserInfo(iGroupID, iSeriesInfoID)  
        {
            mGroupIndex = iGroupIndex;
        }   
    

        Int32 mGroupIndex;

        virtual Int32 GetGroupIndex();
    };

    inline Int32 RiserInfoWithIndex::GetGroupIndex(){return mGroupIndex;}

    
    enum SERIES_LINEINFO_CLEARTYPE
    {
        SLC_FRONT = 0,
        SLC_BACK,
        SLC_BOTH
    };
    
    struct SeriesLineInfo
    {
        struct PointInfo
        {
            PointInfo():mpFront(NULL), mpBack(NULL){}
 
            ~PointInfo()
            {
                Clear(SLC_BOTH);
            }
            
            void Clear(SERIES_LINEINFO_CLEARTYPE iType)
            {
                if (iType == SLC_FRONT || iType == SLC_BOTH)
                { 
                    if (mpFront)
                    {
                        delete mpFront; mpFront = NULL;
                    }
                }
                
                if (iType == SLC_BACK || iType == SLC_BOTH)
                {    
                    if (mpBack)
                    {
                        delete mpBack; mpBack = NULL;
                    }
                }   
            }

            Point2D* mpFront;
            Point2D* mpBack;
        };
    
        SeriesLineInfo(Int32 iGroupCount, Int32 iSeriesCount):
            mGroupCount(iGroupCount),mSeriesCount(iSeriesCount)
        {
            
            if (iGroupCount > 0 && iSeriesCount > 0)
                mpPointInfo = new PointInfo[iSeriesCount * iGroupCount];
        }
        ~SeriesLineInfo()
        {
            delete [] mpPointInfo;
        }

        void SetPoint(Int32 iGroupID, Int32 iSeriesID, const Point2D& irPoint, bool iFront)
        {
            if (iFront)
            {    
                mpPointInfo[iGroupID + iSeriesID * mGroupCount].Clear(SLC_FRONT);
                mpPointInfo[iGroupID + iSeriesID * mGroupCount].mpFront = new Point2D(irPoint);
            } 
            else
            {
                mpPointInfo[iGroupID + iSeriesID * mGroupCount].Clear(SLC_BACK);
                mpPointInfo[iGroupID + iSeriesID * mGroupCount].mpBack = new Point2D(irPoint);
            }
        }

        bool GetPoint(Int32 iGroupID, Int32 iSeriesID, Point2D& orPoint, bool iFront)
        {
            if (iFront)
            {
                if(mpPointInfo[iGroupID + iSeriesID * mGroupCount].mpFront)
                {
                    orPoint = (*mpPointInfo[iGroupID + iSeriesID * mGroupCount].mpFront);
                    return true;
                }
            }
            else
            {
                if(mpPointInfo[iGroupID + iSeriesID * mGroupCount].mpBack)
                {
                    orPoint = (*mpPointInfo[iGroupID + iSeriesID * mGroupCount].mpBack);
                    return true;
                }
            }
            
            return false;
        }
    
        PointInfo* mpPointInfo;

        Int32 mGroupCount;
        Int32 mSeriesCount;
    };

    enum EnumBarRenderType
    {
        BAR_ABSOLUTE,
        BAR_CLUSTER,
        BAR_STACKED,
        BAR_PERCENT,
    };

    class BarSeriesRenderer : public SeriesRenderer
    {
    public:
        typedef MSynch::SmartPtr<BarSeriesRenderer> Ptr;

        BarSeriesRenderer(const TripleId& irTripleId, GraphObjectManager* ipManager,
                            Dataset::Ptr iDatasetPtr, Legend::Ptr iLegendPtr);

        virtual ~BarSeriesRenderer()
        {
            if (mpSeriesLineInfo)
            {
                delete mpSeriesLineInfo;    mpSeriesLineInfo = NULL;
            }
        }

        virtual void GenerateMapAndList();

        virtual void GenerateByValueAxis(EnumValueAxis iValueAxis, std::vector<GraphObject::Ptr>& iorGraphObjectList);


        void SetDeviceDataArea(const Rect2D& irDeviceDataArea);

        virtual void GetOptions(Int32 iSeriesId, Int32 iPropertyId, CComVariant* opValue) const;

        virtual void AddTextToMapAndList(std::map<TripleId, GraphObject::Ptr>& irGraphObjectMap, std::vector<GraphObject::Ptr>& irGraphObjectList);

        void hGenerateTrendLine();
        
        virtual bool GetDataPoint(Int32 iSeriesId, Int32 iGroupId, Point2D& orDataPoint);
        
        void ReserveAreaForDataLabels(Rect2D& iorRect);
        
        //----Data Label for Graph Matrix---//
        bool ShouldRotateDataLabel();
        void AddObjectsToDataLabelManager(DataLabelManager::Ptr iDataLabelManagerPtr);
        void AddObjectsToDLManagerForAxisOrigin(DataLabelManager::Ptr iDataLabelManagerPtr);
    protected:
        virtual void LoadProperties();

        virtual void hRenderItems(EnumValueAxis iVA, BOOL iIsOnlyForDataLabels);

        void hGenerateByValueAxis(EnumValueAxis iValueAxis, BOOL iIsOnlyForDataLabels);
        
    //private:

        bool hShouldRotateDataLabel();
        Int32 hGetDataLabelNumber(bool iIsRotated);
        void hCreateDataLabels(std::vector<Rect2D> &iorBarsRect, std::vector<Rect2D> &iorDLRect, bool iIsRotated, bool iIsOnlyForRect = false);
        void hCreateOneDataLabelItem(const RiserInfo& irRiserInfo, std::vector<Rect2D> &iorBarsRect, std::vector<Rect2D> &iorDLRect, bool iIsRoteated, bool iIsOnlyForRect = true);
        bool hIsFitPaddingToBorder(const Rect2D &irDLRect, const Int32 &irPadding);
        bool hIsTwoRectFitPadding(const Rect2D &irDLRect, const Rect2D &irRect, const Int32 &irPadding);
        void hPutOneDataLabel(const Rect2D &irBarRect, TextObject::Ptr irDLText, double irValue, bool iIsForJudgeRotate = false, bool iIsRotated = false); // used for both verticla and horizontal bar, cal the data label's position
        void hPutOneDataLabel(const Rect2D &irHostRect, TextObject::Ptr irLDText, EnumDssGraphMatrixDataLabelPosition irLocation, bool iIsRotated);
        //TextObject::Ptr hCreateDataLabelForGraphMatrix(const double &irValue, GraphCollectionObject *ipCollection);
        void hRenderDataLabels();  //detect overlap, show data labels
        GMDataLabelVecs mDataLabes;
        
        
        void hGetRenderingType();
        
        void hCalSeriesOrderForOneGroup(Int32 iGroupIndex, std::vector<Int32>& orSeries, EnumValueAxis iVA); 

        
        GraphCollectionObject* hFindRiserCollectionOrInsert(const RiserInfo& irInfo);

        Int32 hGetNumberOfVA() const;

        void hGetVAOrder(EnumValueAxis& orFirst, EnumValueAxis& orSecond);

        void hGetSeriesByVA(std::vector<Int32>& irSeries,EnumValueAxis iVA);

        void hGetSeriesOrderByType(Int32 iGroupIndex, std::vector<Int32>& orSerie, EnumValueAxis iVA);

        virtual void hGetRiserStartPosAndSize(const RiserInfo& irRiserInfo, Int32& orStart, Int32& orSize);

        void hGetLogicalMiddlePosition(Int32 iSeriesIndex, Int32 iGroupId, double& orPosition) const;
    
        virtual Int32 hGetIndexInColumn(const RiserInfo& irRiserInfo);

        Int32 hGetGroupIndex(const RiserInfo& irRiserInfo);
        
        virtual void hCalBarWidth();
        
        //lizhang, 2016-06-21, US55868, Calculate how many series clusters in combo chart when subtype is Absolue(Cluster)
        void hCalClusterNum();
        
        //  Calculate the drawing order for 3 different kinds of render
        //  Need to consider 3 factors
        //  1. Depth direction  2. Plot Orientation  3. ValueAxis.IsReverseOrder 4. Data
        
        void hAdjustSeriesOrderForNegativeValue(Int32 iGroupIndex, std::vector<Int32> &iorVecSeries);
    
        void hRenderOneItem(const RiserInfo& irRiserInfo, std::vector<std::pair<Int32, TextObject::Ptr> >& orTextForGroup, BOOL iIsForReserveArea);
        bool hIsSeperateMetricForClusterBar();

        //The followings are helper functions called by hRenderOneItem
        bool hPrepareData(const RiserInfo& irRiserInfo, double& orValue);
        Rect2D hPrepareRect(const RiserInfo& irRiserInfo, double iDataValue, bool& orAboveZero);
        GraphObject::Ptr hPrepareRectangleObject(const RiserInfo& irRiserInfo, const Rect2D& irRectBar, bool iAboveZero);
        //lizhang, 2016-06-20, US55868, new shapes in combo
        void hGetSingleShapeCenter(Point2D& iCenter, const Rect2D& iRectBar, bool iAboveZero);
        GraphObject::Ptr hprepareSingleShape(const TripleId& irTripleId, const Point2D& irPoint, bool iIsLineAsDots);
        void hGetSingleShapeSize(Int32& iMarkersize, const TripleId& irTripleId, bool iIsLineAsDots);
        
        void hPrepareAnimationForOneBar(const RiserInfo& irRiserInfo, const Rect2D& irRectBar, GraphObject::Ptr iObjectPtr);
        void hPostProcessOneBar(const RiserInfo& irRiserInfo, GraphObject::Ptr iObjectPtr);
        void hPrepareErrorBar(const RiserInfo& irRiserInfo, const Rect2D& irRectBar);
        void hPrepareGMRiserLabel(const TripleId& ID, const RiserInfo& irRiserInfo, const Rect2D& irRectBar, const Rect2D& irOldRectBar, double iDataValue);
        bool hCheckBarRect(const Int32 iSeriesIndex, const Rect2D& irRect);
        
        bool hIsTickShapeForGMObject(const TripleId& iID);
        
        bool hGetOneBarRect(const RiserInfo& irRiserInfo, Rect2D& iorRect, bool iIsOnlyForDataLabels = true);
        
        TextObject::Ptr hCreateRiserLabel(const RiserInfo& irRiserInfo, const Rect2D& irRefRect, GraphCollectionObject::Ptr iColPtr);

        void hCheckLabelForClipping(const RiserInfo& irRiserInfo, TextObject::Ptr iTextObjectPtr, const Point2D& irMax, const Point2D& irMin);

        bool hGetSamplePoint(const RiserInfo& irRiserInfo, Point<double>& orSample);

        void hGetSeriesLinePoint(const RiserInfo& irRiserInfo, const Rect2D& irRefRect, Point2D& orFront, Point2D& orBack);

        void hGenerateSeriesLine(EnumValueAxis iValueAxis);

        void hSmartLabelForCluster(EnumValueAxis iVA, std::vector<TextObject::Ptr>& irTextForGroup);

        bool hIsLegendMarkerAddedToCollection(Int32 iSeriesID);
        
        bool hUpdateBarRectSize(const RiserInfo& irRiserInfo, Rect2D& iorRect, bool iIsDataPointAboveZero, double iDataValue);
        bool hUpdateBarRectSizeToTickMode(const RiserInfo& irRiserInfo, Rect2D& iorRect, bool iIsDataPointAboveZero, double iDataValue);
        
        double hGetBarRiserWidth(const RiserInfo& irRiserInfo);
        double hGetBarThickness(const RiserInfo& irRiserInfo);
        bool hUpdateSpecificColor(const TripleId& irId, GraphObject::Ptr lPtr);
        void hPrepareForAnimation();
        //lizhang, de38822, 20160727, reform case in combo
        bool multipleShapes();
        
        bool hReserveAreaForDataLabel(Rect2D &iorRect, TextObject* ipTextObject);
        virtual void hReserveAreaForDataLabel(Rect2D &iorRect); //used by subclass.
        virtual void hClearUp();
        virtual bool hIsLabelShown();
        
        std::map<Int32, GraphCollectionObject::Ptr> mSGMapLabel;
        std::map<Int32, std::vector<Point<double> > > mSGMapTrend;
        SeriesLineInfo* mpSeriesLineInfo;   

        std::map<Int32, Rect2D> mMapTotalRect[2];   

        EnumBarRenderType mBarRenderType;   
        double mBarWidth;       
        double mGroupSize;
        double mSpaceBetweenRiser;
        double mSpaceBetweenGroup;
        Int32 mBarColumns;      
        //lizhang, 2016-06-21, US55868, how many series clusters in combo chart when subtype is Absolue(Cluster)
        Int32 mBarClusters; 
        BarOptions mBarOptions;     

        std::map<Int32, bool> mAddedLegendMarkerSet;    
        Int32 mLastSeenWidth;                           
        std::map<Int32, Int32> mBarSeriesInfoToIndex;
        bool mReformedCombo;//lizhang, 20160728, de38822, indicate whether data is reformed in combo
        
    };
}

#endif