AreaSeriesRenderer.h

Go to the documentation of this file.

//=======================================================================
//  Filename:       Kernel/SourceCode/IPhoneChart/PrivateSource/AreaSeriesRenderer.h
//  Date:           2008-10-06
//  Authors:        Liang Liu, Bing Huang

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

#ifndef MsiChart_AreaSeriesRenderer_h
#define MsiChart_AreaSeriesRenderer_h

#include "SeriesRenderer.h"
#include "Vector2D.h"
#include "DataLabelManager.h"

namespace MsiChart
{
#ifdef _VE_CE
    class GraphObjectAggregation;
#endif
    struct ABLPlotContext;
    class AreaSeriesRenderer : public SeriesRenderer
    {
    public:
        typedef MSynch::SmartPtr<AreaSeriesRenderer> Ptr;

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

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

#ifdef _VE_CE
        virtual void GenerateInterpolationFrame(double iProgress, GraphObjectAggregation* ipLayerObject);
#else
        virtual void GenerateInterpolationFrame(double iProgress, LayerObject* ipLayerObject);
#endif
        //override function.
        virtual GraphObject::Ptr OnPointDetectionEx(const Point2D& irCursor,
                                                    const std::vector<Int32>& irObjectIds, Int32& iorDistance, Int32 iRadius,
                                                    std::vector<GraphObject::Ptr>& iorGraphObjectsAround, EnumGraphObjectUsage iUsage = GOU_NORMAL_HIGHLIGHT);
        virtual void AddObjectsToDataLabelManager(DataLabelManager::Ptr iDataLabelManagerPtr);
        void hCreateDataMarkerForDataLabel(bool iOnlyForDisplayedDataLable = true);
    private:
        void hGenerateAreaCollections(EnumValueAxis iValueAxisIndex);
        void hGenerateDataLabels();
        void hGenerateLabelsForSeries(Int32 iSeriesIndex);
        void hGenerateNaiveSideFaces(Int32 iSeriesIndex, const Polygon2D& irPolygon, Int32 iGroupId);
        void hGenerateRisers(EnumValueAxis iValueAxisIndex);
        void hGenerateSideFaces(EnumValueAxis iValueAxisIndex, Int32 iGroupId);
        void hGenerateTrickySideFaces(EnumValueAxis iValueAxisIndex, Int32 iGroupId);
        void hGenerateTotalLabelsByAxis(EnumValueAxis iValueAxisIndex, GraphCollectionObject::Ptr iTotalCollectionPtr);
        void hGenerateRisersForSeries(Int32 iSeriesIndex, bool iUseDepth);
        void hGenerateOnePolygon(Int32 iSeriesIndex, const Polygon2D& irPolygon, bool iUseDepth);
        bool hGetSeriesPolygon(Int32 iSeriesIndex, Polygon2D& orPolygon);

        void hAddVirtualMarkersToImageMap(EnumValueAxis iValueAxisIndex, ImageMap& iorImageMap);

        void hAddSeriesVirtualMarkersToImageMap(Int32 iSeriesIndex, ImageMap& iorImageMap);

        void hInitSeriesPolygons();

        void hParsePolygon(const Polygon2D& irPolygon, std::vector<std::vector<Point2D> >& orPolygonUnits, std::vector<std::vector<Point2D> >& orSeriesPolygonBounder, int iSeriesIndex) const;

        bool hGetPolygonUnit(Int32 iSeriesIndex, Int32 iGroupId, Polygon2D& orPolygonUnit) const;

        void hGenerateVirtualMarkers(EnumValueAxis iValueAxisIndex);
        void hGenerateVirtualMarkersBySeries(Int32 iSeriesIndex);
        void GetAreaPointByProgress(int iSeriesIndex, int iPointIndex, double iProgress, Point2D& orAreaPoint);

        //GraphMatrix Stuff
        void hGenerateOneRiser(Int32 iSeriesIndex, Int32 iGroupIndex, const Polygon2D& irPolygon, bool iUseDepth);
        GraphObject::Ptr hGenerateOnePolygon(const TripleId& irAreaId, const Polygon2D& irPolygon, bool iUseDepth, GraphCollectionObject* ipSet);
        void hSplitPolygon(const Polygon2D& irPolyGon, std::vector<Polygon2D>& orSplitPolyGonSet, Int32 iSplitSpan) const;

        void hPrepareAnimation();

        Int32 hGetSeriesPolygonIndex(Int32 iSeriesIndex);
        //End of GM
        std::vector<GraphCollectionObject::Ptr> mAreaCollection;

        std::vector<std::vector<Point2D> > mSeriesPolygons; 

        std::vector<std::vector<Point2D> > mFinalSeriesPolygons;

        std::vector<Int32> mSeriesDrawingOrder;     
        std::set<Int32> mTransitionalSet;           

        bool mIsAbsolute;   
        mutable bool mIsPolygonSplit; 
        bool mSupportAnimation; 

        std::vector<std::vector<EnumValueAxis> > mAxisGenInfo;

        mutable std::vector<std::pair<Int32, Int32> > mGroupRangeList;
        void hPopulateGroupRangeListPerSeries(const std::vector<std::vector<Point2D> >& irPolygonUnits) const;
        void hPopulateGroupIdMapPerSeries(const std::vector<Point2D>& irPolygonUnit) const;

        void hSplitGroupRangeListPerSeries(Int32 iSplitSpan) const;
        Int32 hGetStartGroupIndexForPolygonAt(Int32 iPolygonIndex, Int32 iCanidate);
        bool hIsAtHighSideToBase(bool iIsVertical, Int32 iBasePosition, bool iIsStringent, const Point2D& irPoint) const;
        void hUpdatePolygonSize(Int32& iBasePosition, Int32& iValuePosition, double iValue, double iBaseValue);
        void hPushDownBaseSide(Polygon2D& iorPolygon, bool iIsVertical) const;
        // Move the entire polygon by iOffset pixels. if iOffset is :
        // Positive : Move Up(Vertical), Move Right(Horizontal)
        // Negative : Move Down(Vertical), Move Left(Horizontal)
        void hMovePolygon(Polygon2D& iorPolygon, Int32 iOffset, bool iIsVertical) const;
        bool hUpdateBaseSide(Polygon2D& iorPolygon, ValueAxis* iValueAxisPtr, bool iIsVertical);

        //Generate one polygonline object, to draw as the stroke of the areas
        void hGenerateOnePolylineBounderForDataLabel(Int32 iSeriesIndex, Int32 iGroupIndex, const Polygon2D& irPolygon, bool iUseDepth);
        void hGenerateStorkeBounderForOneRiser(Int32 iSeriesIndex, Int32 iGroupIndex, const Polygon2D& irPolygon, bool iUseDepth);
        GraphObject::Ptr hGenerateOnePolygonBounder(const TripleId& irAreaId, const Polygon2D& irPolygon, Int32 iSeriesIndex);

        TripleId hGetBelowMarkerObjectID(const TripleId& lMarkerId, const Point2D& irCursor);

        //-------------Data Label for GM------------//
        GMDataLabelVecs mDataLabelsVec;
        std::vector<GraphObject::Ptr> mAreaBoundForDL;
        std::vector<GraphObject::Ptr > mSinglePointObjects;
        void CreateAllDataLabels();
        DataLabelManager::Ptr hInitDataLabelManager();
        
        bool hCalculateDLBasePointAndOffset(GMDataLabelInfo &iorDataLabel);
        void hPrepareDataLabelPositions();
        int hGetDLIndexInVec(Int32 iSeriesId, Int32 iGroupId);
        void hCreateAreaMarkers();
        //Int32 hGetCorrectLineObjectGroupIdInSeriesPoints(Int32 iInfoIndex, Int32 irGroupId);
    };

}

#endif