LineSeriesRenderer.h

Go to the documentation of this file.

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

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

#ifndef MsiChart_LineSeriesRenderer_h
#define MsiChart_LineSeriesRenderer_h

#include "SeriesRenderer.h"
#include "DataLabelManager.h"
#ifdef _VE_CE
#include "GraphObjectAggregation.h"
#endif

namespace MsiChart
{
    struct LineSeriesOptions
    {
        typedef MSynch::SmartPtr<LineSeriesOptions> Ptr;

        LineSeriesOptions() : mShowMarkers(true),
            mMarkerShape(0), mShowStepLine(false), mMarkerSize(50)
        {}
        
        bool            mShowStepLine;
        bool            mShowMarkers;
        unsigned char   mMarkerShape;
        Int32           mMarkerSize;
    };

    class ABLPlot;
    struct ABLPlotContext;

    typedef std::pair<Point2D, Point2D> LinePair;

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

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

        //pure virtual functions from GraphObjectManager
        virtual void GenerateMapAndList();
        virtual void GetOptions(Int32 iSeriesId, Int32 iPropertyId, CComVariant* opValue) const;

        //pure virtual function from SeriesRenderer
        virtual void GenerateByValueAxis(EnumValueAxis iValueAxis, std::vector<GraphObject::Ptr>& iorGraphObjectList);
#ifndef _VE_CE
        virtual void GenerateInterpolationFrame(double iProgress, LayerObject* ipLayerObject);
#else
        virtual void GenerateInterpolationFrame(double iProgress);
#endif
        virtual bool GetToolTipData(Int32 iSeriesID, Int32 iGroupID, double& orValue, double& orPercentValue, Int32 iOffset = 0);
        
        //override from GraphObjectManager
        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 GenerateVirtualMarker();
        
        bool GetData(Int32 iInfoIndex, Int32 iGroupId, double& orValue, bool iPreValue = false, Int32 iDataGroup = 0) const;
        void AddObjectsToDataLabelManager(DataLabelManager::Ptr iDataLabelManagerPtr);
        void hCreateDataMarkerForDataLabel(bool iOnlyForDisplayedDataLable = true);
        
    protected:
        void LoadSeriesProperties(Int32 iInfoIndex);

        virtual void LoadStepLine(Int32 iInfoIndex);
                
        virtual void GenerateMapAndListForSeries(Int32 iInfoIndex);

        virtual void GenerateByValueAxisAndGroup(EnumValueAxis iValueAxisIndex, Int32 iGroupId);

        virtual void GetLinePointSet(Int32 iInfoIndex, std::vector<std::vector<Point2D> >& orPointSet) const;

        bool GetLinePoint(Int32 iInfoIndex, Int32 iGroupIndex, Point2D& orPoint) const;
        
        bool GetFinalLinePoint(Int32 iInfoIndex, Int32 iGroupIndex, Point2D& orLinePoint, bool iIsOldRenderer) const;

        virtual void GenerateDepthLine(Int32 iInfoIndex, Int32 iGroupId, LinePair& irLinePair);

        void GenerateLineCollections();
        
        void GenerateMarkerCollections();

        void CreateSeriesMarkers(Int32 iInfoIndex);

        void CreateAllSeriesLabels();
        
        void CreateMarker(Int32 iInfoIndex, Int32 iGroupId, GraphCollectionObject::Ptr iMarkerCollectionPtr, Point2D& irCenterPoint);
        
        //For Graph Matrix, we create virtual marker in method OnPointDetectionEx() when tooltip trigled.
        void CreateVirtualMarker(Int32 iInfoIndex, Int32 iGroupId, GraphCollectionObject::Ptr iMarkerCollectionPtr, Point2D& irCenterPoint);
        
        //void CreateTrendLines(Int32 iInfoIndex);

        bool GetMinMaxPoint(Int32 iInfoIndex, Int32 iGroupId, Point2D& orMinPoint, Point2D& orMaxPoint) const;

        virtual bool GetPointPair(Int32 iInfoIndex, Int32 iGroupId, Point2D& orStartPoint, Point2D& orEndPoint) const;

        void GenerateOrderedDepthLine(EnumValueAxis iValueAxisIndex, Int32 iGroupId, bool iIsStepLine);
                        
        virtual bool hGetParetoLinePoints(Int32 iInfoIndex, std::vector<std::vector<Point2D> >& orPointSet) const;
        
        //virtual bool hGetParetoLinePoints(Int32 iInfoIndex, std::vector<Point2D>& orPointSet) const;

        virtual bool hGetFinalParetoLinePoint(Int32 iInfoIndex,  Int32 iOffsetFromGroupOrder, Point2D& orPointSet) const;
        
        virtual bool hGetParetoLinePointWithOffset(Int32 iInfoIndex, Int32 iGroupId, Point2D& orPoint, bool iIsFinal) const;
        
        Int32 hGetOffsetFromGroupOrder(const std::vector<Int32>& irGroupOrder, Int32 iGroupId) const;
        
        double hGetCumulatedYValueForPareto(Int32 iGroupOffsetOrId, bool iIsUseOffset = true) const; 
        
        bool hGetParetoLineValues(Int32 iInfoIndex, std::vector<double>& orValues) const;

        void hCreateRiserLabelForPareto(GraphCollectionObject::Ptr iTextCollectionPtr);
        
        void hCreateLineSeriesTrendlinesForPareto();

        bool hGetParetoTrendLineCoordination(std::vector<double>& iorX, std::vector<double>& iorY) const;
        
        bool hIsLastFrame() const;
        
        bool hIsFirstFrame() const;
        
        bool hIsParetoPercent() const;

        void hDrawStandAlonePoint(Int32 iSeriesID);
        GraphObject::Ptr hGetLineObject(Int32 iInfoIndex, Int32 iGroupId, const std::vector<std::vector<Point2D> >& irLinePointSet, bool& iorAlreadyInMapAndList);

        GraphObject::Ptr hGetPolyGonObjectWithStepGradientFill(const TripleId& iLineId, const std::vector<std::vector<Point2D> >& irLinePointSet, bool& iorAlreadyInMapAndList, Int32 iDepthValue, bool iIsTrapezoid, Int32 iSeriesInfo = 0);
        
        void hCheckPolylineSizeAndColorMode(Int32& iorDepthValue, bool& iorIsLineWithFill, bool& iorIsTrapezoid, bool& iorIsUnified, Int32 iSeriesIndex = -3);
        
        GraphObject::Ptr hGetSingleShapeObject(Int32 iInfoIndex, Int32 iGroupId, const std::vector<std::vector<Point2D> >& irLinePointSet, bool& iorAlreadyInMapAndList);
        GraphObject::Ptr hGetSinglePointOrIsolatedPoint(Int32 iInfoIndex, Int32 iGroupId, const std::vector<std::vector<Point2D> >& irLinePointSet, bool& iorAlreadyInMapAndList);
        bool hIsSeriesAsSingleDataPointShapeType(Int32 iInfoIndex);
        
         void CreateVirtualMarkerForGMLineWithSizeby(const TripleId& irDataPointId, const Point2D &irBasePoint, Int32 iLineWidth, Rect2D &orPolygon);
        
        
        void hGetSectionFromBasePolygon(Int32 iSectionIndex, const std::vector<Point2D>& irBasePolyGon, std::vector<Point2D>& orPolygon);
        
        void hGetTrapezoidFromPoints(const TripleId& irLineId, std::vector<Point2D>& irPoints, Int32 iLineWidth, std::vector<Point2D>& orPolygon);

        void hGetAccompanyPoints(const Point2D& irBasePoint, double iMaxSize, double iSizeRatio, Point2D& orPoint1, Point2D& orPoint2);

        void hGetBoundPointsForLineWithFill(std::vector<Point2D>& irPolyLine, float iLineWidth, std::vector<Point2D>& orPolygon);
        
        

        //void CreateMarkerForEngeDataPoint(Int32 iInfoIndex, Int32 iGroupId, GraphCollectionObject::Ptr iMarkerCollectionPtr, Point2D& irCenterPoint)
        

        void CreateAllSeriesDataLabels();
        DataLabelManager::Ptr hInitDataLabelManager();
        bool hCalculateDLBasePointAndOffset(GMDataLabelInfo &iorDataLabel);
        void hPrepareDataLabelPositions();
       
        EnumDssGraphMatrixDataLabelHostMarkerShape hGetDataLabelHostMarkerShape(Int32 iInfoIndex);
        int hGetDLIndexInVec(Int32 iSeriesId, Int32 iGroupId);
        void hGetDLCenterOffset(Int32 iInfoIndex, Int32 iGroupIndex, Int32& iorXCenterOffset,Int32& iorYCenterOffset);
        Int32 hGetCorrectLineObjectGroupIdInSeriesPoints(Int32 iInfoIndex, Int32 irGroupId);
        //void CreateMarkerForDataLabel(Int32 iInfoIndex, Int32 iGroupId, GraphCollectionObject::Ptr iMarkerCollectionPtr, Point2D& irCenterPoint);
        
        
        std::vector<GraphCollectionObject::Ptr> mLineCollections;
        
        std::vector<GraphCollectionObject::Ptr> mMarkerCollections;
        
        mutable std::vector<std::vector<Point2D> > mVecSeriesPoints; 

        std::vector<LineSeriesOptions::Ptr> mLineSeriesOptions;
        bool mIsShowDataMarkerForEdgePoint;
        Int32 mDepth;
        bool mInitialized;
        bool mIsByValueAxis;
        bool mSupportDiscretePoints;                                
        std::vector<std::vector<bool> > mIsVirtualMarkerCreated;
        
        bool mIsVirtualMarkerAllCreated;
        
        // Li en : GM Combination Graph, we need to draw tick in lineseriesrender
        void hCalTickWidth();
        double hGetTickThickness(Int32 iInfoIndex, Int32 iGroupId);
        double hGetTickRiserWidth(Int32 iInfoIndex, Int32 iGroupId);
        bool hPrepareTickRect(Rect2D &iorRect, const Point2D& iCenter, Int32 iInfoIndex, Int32 iGroupId);
        GraphObject::Ptr hDrawSingleTickObject(Int32 iInfoIndex, Int32 iGroupId, Point2D iCenter);
        Int32 mTickGapWidth;
        Int32 mTickWidth;
        Int32 mSpaceBetweenGroup;
        
    private:
#ifndef _VE_CE
        virtual void GenerateFrameInOnePlot(LayerObject* ipLayerObject);
#else
        virtual void GenerateFrameInOnePlot(GraphObjectAggregation* ioGraphObjectAggregation, bool iForStartFrame);
#endif
        
        std::vector<std::map<Int32, Int32> >mVecGroupIdMapPerSeries; //<in one specific series, there could be null point, each section of contineous points will make one map.
        void hPopulateGroupIdMapAtSeries(Int32 iInfoIndex);
        void hGetGroupIdMapAt(Int32 iInfoIndex);
        void hCreateLineMarkers();
        
        GMDataLabelVecs mDataLabels;
        std::vector<GraphObject::Ptr > mSinglePointObjects;
        std::vector<GraphObject::Ptr > mPolygonObjects;
        std::vector<GraphObject::Ptr > mPolyLineObjects;
        
        // DE36136, get groupIDMap for one series, and don't modify current series's groupIDMap in mVecGroupIdMapPerSeries.
        std::vector<std::map<Int32, Int32> > hGetGroupIdMapAtSeries(Int32 iInfoIndex);
    };
}

#endif