ValueAxis.h

Go to the documentation of this file.

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

#include "Axis.h"
#include "NumberObject.h"

namespace MsiChart
{

    struct ValueAxisInfo
    {
        TripleId mId;
        unsigned char mAxisLabelsLocation; 
        unsigned char mAxisDirection;   
        
        ValueAxisInfo()
        {
            mId = TripleId(DssGraphY1Body, 0, -3);
            mAxisDirection = AD_Y;
            mAxisLabelsLocation = ALL_LEFT;
        }
        
        void ToX(bool iIsLabelAoveAxis)
        {
            mId = TripleId(DssGraphX1Body, 0, -3);
            mAxisDirection = AD_X;
            mAxisLabelsLocation = iIsLabelAoveAxis ? ALL_TOP : ALL_BOTTOM;
        }
        
        void ToY1(bool iIsSeriesAxis = false)
        {
            mId = TripleId(DssGraphY1Body, 0, -3); //maybe some other ID?
            mAxisDirection = AD_Y;
            mAxisLabelsLocation = ALL_LEFT;
        }

        void ToY2(bool iIsSeriesAxis = false)
        {
            mId = TripleId(DssGraphY2Body, 0, -3); //maybe some other ID?
            mAxisDirection = AD_Y;
            mAxisLabelsLocation = ALL_RIGHT;
        }

    };




    struct ValueAxisOptions
    {
        ValueAxisOptions();         
        bool mUseLogarithmicScale;
        bool mAlwaysIncludeZero;
        bool mDrawFromZero;
        bool mUseMinValue;
        bool mUseMaxValue;
        bool mShowMinLabel;
        bool mShowMaxLabel;
        bool mDrawCustomLine; 
        bool mDrawSecondCustomLine;
        bool mUseSmartScaleBreak;
        bool mUseCustomMinMax;
        bool mDisableFractionalGrids;   
        bool   mCondenseLabel;
        bool   mHasCustomAxisOrigin;
        unsigned char mOffScaleType;
        double mAxisMinValue; 
        double mAxisMaxValue;
        double mAxisCustomValue; 
        double mAxisSecondCustomValue;
        double mCustomAxisOriginValue;
    }; 

    class ValueAxis: public Axis
    {
    public:
        typedef MSynch::SmartPtr<ValueAxis> Ptr;
        
        ValueAxis(const TripleId& irTripleId, 
            GraphObjectManager* ipManager, 
            double iMin, 
            double iMax,        
            bool iLargerGridInterval = false,            
            bool iIsPercent = false,
            unsigned char iAxisDirection = AD_Y,
            bool iIsShown = true,
            Int32 iPrimaryMetricIndex = -1); 
        virtual ~ValueAxis();
            
        // Override methods
        virtual void GenerateMapAndList();
        virtual void GetOptions(Int32 iSeriesId, Int32 iPropertyId, CComVariant* opValue) const;
        
        void AdjustDeviceDataArea(Rect2D& iorDeviceDataArea, bool iIsReversed = false);             
        Int32 ValueToPosition(double iValue, bool iTruncate = true) const; 
        bool GetPositionByValue(double iValue, Int32& orPosition) const; 
        bool GetFloatPositionByValue(double iValue, float& orPosition) const;
    
        bool Get3DPositionByValue(double iValue, double& orPosition) const;
        
        float ValueToFloatPosition(double iValue) const; 
        Int32 ValueToBubbleSize(Int32 iDialogSize, double iValue) const;            
        Int32 GetBasePosition();
        double GetBasePositionFor3D();
        double GetMinTick();        
        double GetMaxTick();    
        double GetBaseValue(); 
        bool IsBaseAtZero();
        void GenerateCustomLine(const Rect2D& irDataArea, std::vector<GraphObject::Ptr>& iorGraphObjectList);
        void GenerateOneCustomLine(double iValue, Int32 iLineObjectId, const Rect2D& irDataArea, std::vector<GraphObject::Ptr>& iorGraphObjectList);
        
        void ReserveTitleAndLabels(Rect2D& iorArea, Int32 iLowMargin = 1000, Int32 iHighMargin = 1000);
        virtual void UpdateTitleAndLabelArea(Rect2D& iorArea);  

        double GetStep() const;

        void GetNumberFormat(ChartAdvFormat& orFormat);

        virtual double GetLogicalCoord(Int32 iAbsoluteCoord);
        virtual float GetAbsoluteCoord(double iLogicalCoord);   
        virtual void GetMinMaxLogicalCoord(double& orMin, double& orMax) const;
        virtual double GetSlopeFactor(double iLogicalCoord) const;

        virtual void GetTicks(std::vector<double>& orTicks) const;

        virtual bool IsLogarithmic() const;
        
        virtual void OnZooming(Int32 iOldStart, Int32 iOldEnd, Int32 iNewStart, Int32 iNewEnd);
        
        void OnZoomRestore();
        
        Int32 GetOuterTickLength() const;

        virtual void GenerateLabelsFor3D(const std::vector<Point2D>& irGridPoints, const DVector2D& irUnitOffsetDirection,   
                                         GraphCollectionObject* ipLabelCollectioin, std::vector<GraphObject::Ptr>& iorGraphObjectList);
        
        virtual void GetGridLinePositionsFor3D(std::vector<double>& orGridLinePositions, EnumGraphObjectType iGraphObjectType) const;
        
        virtual double GetPositionAtTick(double iTickValue);
        virtual double GetIntervalSpace();
        virtual void TrimAxisPadding(Rect2D& iorRect, bool iUseFixedMargin = true);


        bool IsZeroBaseLineQualified(); 
        void SetTrimWithPadding(bool iIsTrimmed);
        bool GetTrimWithPadding();
        virtual Int32 LayoutAxis(bool iIsRotated, Int32& orMaxLabelSpace);  
        virtual Int32 GetUniformAxisExtraPadding();
        void GetMaxMinDataInput(double &orMaximum, double &orMinimum);
        
        int GetPrimaryMetricIndex() const;
        
        bool IsCustomMinMax() const;
        bool IsTickExist(double iValue);
        bool HasCustomAxisOrigin();
        double GetCustomAxisOriginValue() const;
        Int32 GetLabelObjectId()const;
    protected:
        void LoadProperties();  
        virtual void CreateAxisLine();

        float ValueToPosition(double iValue, float iStartPosition, float iStopPosition) const;  

        bool ValueToPosition(double iValue, float iStartPosition, float iStopPosition, float& orPosition) const;
            
        void GenerateTickLabels();
        void hCreateTickLabels();
        virtual void hCreateOneTickLabel(const TripleId& irTripleId, double iTickValue);
        void hUpdateLabelLocation();
        void hUpdateOneLabelLocation(Int32 iGraphObjectIndex, Int32 iLabelLocation, double iTickValue);
        void hComputeTicks();
        virtual double hComputeStep(double iMaximum, double iMinimum, bool iIncludeZero);       
        void hReserveLabelOrTickArea(Rect2D& iorArea, bool iIsLabel, bool iIsReversed);
        
        Int32 hGetMaxLabelWidthOrHeight(bool iIsWidth) const;       
        void hGenerateInterlacedGrids();
        void hGenerateGridSectionByValue(const TripleId& irTripleId, double iValue1, double iValue2, GraphCollectionObject* ipGridSet);
        void hGenerateMajorGrid();  
        void hGenerateMinorGrid();      
        void hGenerateGridByValue(const TripleId& irTripleId, double iValue, GraphCollectionObject* ipGridLineSet, bool iIsMajor);  

        void hGenerateOneCustomLine(std::vector<GraphObject::Ptr>& iorGraphObjectList, 
                                    double iCustomValue, Int32 iCustomLineId);
        void hGetLineByValue(double iValue, Point2D& orLowEnd, Point2D& orHighEnd) const;
        bool hHasAxisLine() const;  
        bool hIsDualAxisWithoutSplit() const;
        void hComputeTicksForPercent();
        void hComputeTicksForHistogramX();
        void hComputeTicksForLogScale();
        // Four combinations of mUseMaxValue and mUseMinValue.
        void hComputeTicksForFlexMinMax();
        void hComputeTicksForFixMax();
        void hComputeTicksForFixMin();
        void hComputeTicksForFixMinMax();           
        void HideOverlappedLabels(Int32 iStartIndex, Int32 iEndIndex);
        
        
        Int32 hComputeLabelSkipStepForCustomPercentLabels(Int32 iStartIndex, Int32 iEndIndex);
        void HideOverlappedLabelsForCustomPercentLabels(Int32 iStartIndex, Int32 iEndIndex);
        bool hHasTooManyTicks() const;
        bool hIsHistogramX() const;

        bool hIsPolarXOrHistogramX() const;

        bool hCheckValue(double& iorValue, double& orMin, double& orMax) const;
        
        
        double hLengthToValue(double iLength);              //< Map a length to a value.
        void hAdjustAxisRangeForGM();                       //< Enlarge the axis range so all the element/markers would be included in graph area
        void hAdjustTickForGM();                            //< Decide flex min/max or fix min/max will be used by checking the tick values
        //double hGetMaxOffsetSpaceForGMMarker();               //< Get max offset space according to graph type and radius computation forum.
        bool hGetNumberFormatFromMetric();                  //< Get NumberFormat From Primary Metric
        TextObject* hGetAxisLabelByTickValue(double iValue); //< Get the corresponding label to one tick value. 
        void hGetOneTickToLabel(bool iIsOnHighSide, double iValue, TextObject* ipObject);//< Build the label from tick value to label object
        void hBuildTickToLabelMap(bool iIsOnHighSide, Int32 iStartIndexInset);//< Build the label from tick value to label object
        bool IsAxisLabelAbbreviated(const TripleId& irTripleId);              //< Scan all the labels and check if any abbreviation happens for the labels under this axis.
        void hSetAxisLabelStyle();                          //< Notify chart context if abbreviation of the labels should be used.
        void hUpdateShownTicksToGMContext();                //< Notify GM context which labels will be shown.
        void hSetAxisOrigin();
        Int32 hPickStartLabelIndex(Int32 iStartIndex, Int32 iEndIndex, bool& iorIsPaddingPossible);                     

        Int32 hComputeLabelSkipStep(bool iSkipFromHighEnd, bool iNeedDistanceCheck, Int32 iStartIndex, Int32 iEndIndex, Int32 iRefLabelIndex, Int32 iAnchorStyle, TextObject* ipRefLabel, REC_EXP_DIRECTION iExpDirection);

        void hHideLabelsWithStep(bool iSkipFromHighEnd, Int32 iStartIndex, Int32 iEndIndex, Int32 iReflabeIndex, Int32 iLabelStep);
        
        Int32 hHideLabelsFromHighEnd(Int32 iLastIndex, bool iIsFromHigh);                       
        bool hIsLabelFitWithPadding(TextObject* ipTextLable, Int32 iPadding); 
        Int32 hGetEvenSpacedPadding(bool iIsHighSide, double iBaseLength);
        void hFilterRepeatedLabels();
        double hScaleStep(double iStep);
        
        int hGetMaxScreenPixels() const;
    
        void hInitLargerGridInterval();
        bool hIsPercentChart();
        
        //---------Data members----------------------------------
        ValueAxisOptions mOptions;  
        bool mIsShown;
        bool mLargerGridInterval; 
        bool mIsPercent;        
        double mMinimum;    
        double mMaximum;    
        double mMaxTick;    
        double mMinTick;    
        double mStep;       
        Int32 mLabelStartIndex;     
        std::vector<double> mTicks; 
        
        bool mIsStagger;            
        ChartAdvFormat mNumberFormat;   
        Rect2D mLabelArea;
        Int32 mGraphMajorType;          
        Int32 mLabelObjectId;
        bool mIsTrimmedWithPadding;     
        mutable bool mIsMaxZoom;
        std::vector<Int32> mMetricList; 
        Int32 mPrimaryMetricIndex;      
        Int32 mLabelSpan;               
        std::map<double, TextObject*> mLowTicksToLabel; 
        std::map<double, TextObject*> mHighTicksToLabel;    
        /*
           since we may ajust the mMinmum and mMaxmum, we use those two values to
           store the origin value pass in ctor
        */
        double mOriginMinimum;   
        double mOriginMaxmum;   
        double mStepScale;
          
    private:
        virtual void hGenerateGridsByArea(bool iIsGridLine);
        bool hIsAutoXAxis() const;
        void hApplyAutoXAxisLayout();
        bool hIsManualMinShown() const;
        void hGetLabelMargins(Int32& orLowMargin, Int32& orHighMargin);
        void hAdjustAxisInputScale();
        
        bool hReserveAreaAtTop(Int32 iReservedHeight);
    };  

    inline bool ValueAxis::IsBaseAtZero()
    {
        return mOptions.mDrawFromZero && (!mOptions.mUseLogarithmicScale);
    }

    inline bool ValueAxis::hHasTooManyTicks() const
    {
        return mMajorGrid.mUseManualGrid && mMajorGrid.mGridInterval < (mMaxTick - mMinTick) / 30;
    }

    inline bool ValueAxis::hIsHistogramX() const
    {
        return mGraphMajorType == GMT_HISTOGRAM && mTripleId.mObjectId == DssGraphX1Body;
    }

    inline bool ValueAxis::hIsPolarXOrHistogramX() const
    {
        return (mGraphMajorType == GMT_HISTOGRAM || mGraphMajorType == GMT_POLAR) && mTripleId.mObjectId == DssGraphX1Body;
    }

    inline double ValueAxis::GetStep() const
    {
        return mStep;
    }
    inline bool ValueAxis::IsLogarithmic() const
    {
        return mOptions.mUseLogarithmicScale;
    }

    inline bool ValueAxis::hIsManualMinShown() const
    {
        return mOptions.mUseMinValue && mOptions.mShowMinLabel;
    }
    inline bool ValueAxis::IsZeroBaseLineQualified()
    {
        // Dual axis support, just a work round, we need to generate invalid valueaxis to complete the workflow, so here we need to judge the invalidation
        if (!mAxisInfo.mIsValid) {
            return false;
        }
        
        //[2013/2/19] if custom min/max enabled in Graph matrix
        return mMaxTick * mMinTick < 0;
        //return mMaximum * mMinimum < 0;
    }
    inline void ValueAxis::SetTrimWithPadding(bool iIsTrimmed)
    {
        mIsTrimmedWithPadding = iIsTrimmed;
    }       

    inline bool ValueAxis::GetTrimWithPadding()
    {
        return mIsTrimmedWithPadding;
    }
    
    inline int ValueAxis::GetPrimaryMetricIndex() const
    {
        return mPrimaryMetricIndex;
    }
    
    inline bool ValueAxis::IsCustomMinMax() const
    {
        return mOptions.mUseCustomMinMax;
    }
    inline Int32 ValueAxis::GetLabelObjectId() const
    {
        return mLabelObjectId;
    }
}
#endif