Axis.h

Go to the documentation of this file.

//==============================================================================================
//  FILENAME    :   Axis.h
//  AUTHOR      :   Liang Liu
//  CREATION    :   2008-05-15
//  Copyright (C) MicroStrategy Incorporated 2008
//  All Rights Reserved
//==============================================================================================
#ifndef MsiChart_Axis_h
#define MsiChart_Axis_h

#include "GraphObjectManager.h"
#include "TextObject.h"

namespace MsiChart
{
    //---------Axis Related enumerations-----------------------------------
    enum EnumAxisLabelsLocation
    {
        ALL_LEFT, 
        ALL_RIGHT, 
        ALL_LEFT_RIGHT,
        ALL_BOTTOM,
        ALL_TOP,
        ALL_BOTTOM_TOP
    }; 
    
    enum EnumAxisDirection  
    { 
        AD_X,   
        AD_Y,   
        AD_Z    
    };  

    enum EnumAxisIndex
    {
        AI_O1,
        AI_O2,
        AI_X1,
        AI_Y1,
        AI_Y2,
        AI_Y3,
        AI_Y4,
        AI_Z
    }; 
    
    enum EnumGraphObjectType
    {
        GOT_AXIS_TITLE,
        GOT_AXIS_LABEL,
        GOT_AXIS_LINE,      
        GOT_MAJOR_GRID,
        GOT_MINOR_GRID,
        GOT_INTERLACED_GRID
    };

    //---------Axis Related structures----------------------------------
    struct GraphAxisGeneral
    {  
        GraphAxisGeneral(unsigned char mAxisLabelsLocation, unsigned char iAxisDirection);
        unsigned char mAxisLabelsLocation;  
        bool mAxisDrawInReverse;
        bool mShowAxisLine;
        bool mShowAxisLabels; 
        bool mShowAxisTitle;
        unsigned char mAxisDirection;
        bool mUseInterlacedGrids;
        
        bool mIsValid;
    }; 

    struct GraphAxisGrid
    {
        GraphAxisGrid(bool iShowGridLines, unsigned char iGridStyle);
        bool mShowGridLines;
        unsigned char mGridStyle; 
        bool mUseManualGrid;
        double mGridInterval;
    };  

    struct AxisObject
    {   
        Int32 mLabelId;     
        Int32 mMajorId;     
        Int32 mMinorId;     
        Int32 mTitleId;     
        Int32 mCustomLineId;
    };

    extern const AxisObject gAxisObjects[];
    const Int32 gLabelMargin = 4;
    const Int32 gMaxLabelLength = 42;

    class Axis: public GraphObjectManager
    {
    public:
        typedef MSynch::SmartPtr<Axis> Ptr;
        Axis(const TripleId& irTripleId, GraphObjectManager* ipManager, unsigned char iAxisLabelsLocation, 
            unsigned char iAxisDirection); 
        virtual ~Axis();

        void SetDeviceDataArea(const Rect2D& irDeviceDataArea);     
        
        void GetDeviceDataArea(Rect2D& orDeviceDataArea);   
        

        //---------Override functions-------------------------------------
        virtual void GetOptions(Int32 iSeriesId, Int32 iPropertyId, CComVariant* opValue) const;    
        virtual GraphObject::Ptr OnPointDetection(const Point2D& irCursor) const; 

        bool IsReverseOrder();
        void SetDepthAndDirection(Int32 iDepth, Int32 iDepthDirection); 
        
        void GenerateAxisLine(std::vector<GraphObject::Ptr>& iorGraphObjectList);
        void GenerateGridLines(const Rect2D& irDataArea, Int32 iAreaId, std::vector<GraphObject::Ptr>& iorGraphObjectList);
        void GenerateGridLines();                               //This is used by ipad Graph matrix to generate ticks.

        void GenerateInterlacedGrids(const Rect2D& irDataArea, Int32 iAreaId, std::vector<GraphObject::Ptr>& iorGraphObjectList);   
        virtual void GetInterlacedPositions(std::vector<double>& orPositions);

        virtual double GetLogicalCoord(Int32 iAbsoluteCoord) = 0;
        
        virtual float GetAbsoluteCoord(double iLogicalCoord) = 0;   

        virtual void GetMinMaxLogicalCoord(double& orMin, double& orMax) const = 0;

        virtual double GetSlopeFactor(double iLogicalCoord) const = 0;

        virtual bool IsLogarithmic() const;


        virtual double GetPositionAtTick(double iTickValue) = 0;

        bool IsMajorGridShown() const;
        bool IsInterlacedShown() const;
        bool IsLabelsShown() const;
        bool IsTitleShown() const;

        void ReserveTitleArea(Rect2D& iorTitleArea); 

        void SetAxisInfoFor3D(Int32 iAxisLength, Int32 iAxisMargin);
        Int32 GetAxisLengthFor3D() const;
        
        double ValueToPositionFor3D(double iLogicalCoord) const;
        
        virtual void GenerateLabelsFor3D(const std::vector<Point2D>& irGridPoints, const DVector2D& irUnitOffsetDirection,
                                         GraphCollectionObject* ipLabelCollectioin, std::vector<GraphObject::Ptr>& iorGraphObjectList) = 0;
        
        void GenerateTitleFor3D(Int32 iObjectId, Point2D& irRefPoint, const DVector2D& irUnitOffsetDirection, std::vector<GraphObject::Ptr>& iorGraphObjectList);
        
        virtual void GetGridLinePositionsFor3D(std::vector<double>& orGridLinePositions, EnumGraphObjectType iGraphObjectType) const = 0;       




        virtual void TrimAxisPadding(Rect2D& iorRect, bool iUseFixedMargin = true);

        Int32 GetAxisTitleLocationId(Int32 iAxisTitleId) const; 

        Int32 GetInterlacedGridId() const;

        void InitObjectSet(const TripleId& irTripleId, EnumGraphObjectType iGraphObjectType);

        GraphCollectionObject* GetObjectSet(EnumGraphObjectType iGraphObjectType) const;    
        
        virtual void OnZooming(Int32 iOldStart, Int32 iOldEnd, Int32 iNewStart, Int32 iNewEnd) = 0; 
        
        void DrawTitleAndLabels();
        
        void SetIsAxisForRangeLegend(bool iIsForRangeLegend);

        double GetIntervalSpace();
        
        virtual Int32 LayoutAxis(bool iIsRotated, Int32& orMaxLabelSpace) = 0;  

        //return the axis label rotation information.
        Int32 GetLabelRotation();
        
        virtual Int32 GetUniformAxisExtraPadding();
        
        bool IsUniformAxis() const;
        void SetAsUniformAxis(bool iUniformAxis);
    protected:      
        virtual void CreateAxisLine();
        Int32 GetIndex() const;         
        
        void ReserveTitle(Rect2D& iorTitleArea, bool iIsReversed);
        void UpdateTitleLocation(const Rect2D& irTitleArea);        

        void ReserveDepthAxisLine(Rect2D& iorDeviceDataArea, bool iIsReversed = false, bool iBothDirections = false) const;

        void GetLabelOffset(Int32 iLabelLocation, Point2D& orOffset) const;

        bool HasLabelsOnBothSides() const;      
        bool HasDepthAxisLine(Int32 iLabelLocation) const;
        bool IsVerticalAxis() const;

        void GetOneGridLine(Int32 iLocation, Int32 iGridStyle, Int32 iTickLength, 
            const Point2D& irLeftOrBottom, const Point2D& irRightOrTop, std::vector<Point2D>& orPolyLine);  
        void GenerateOneLineObject(const TripleId& irTripleId, const std::vector<Point2D>& irPolyLine, GraphCollectionObject* ipGridLineSet);

        bool IsRightDirection() const;
        bool IsLeftDirection() const;
        bool IsUpDirection() const;
        bool IsDownDirection() const;
        bool HasOuterTicks(Int32 iGridStyle) const; 
        bool HasTwoGridLineParts(Int32 iGridStyle) const;

        void TrimMarginsForDepthAxis(Int32& iorLowMargin, Int32& iorHighMargin) const;
        void GetDepthMargin(Int32& orLowMargin, Int32& orHighMargin) const;
        void MoveLabel(TextObject* ipLabel, const Point2D& irGridPoint, const DVector2D& irUnitOffsetDirection, Int32 iLabelMargin = gLabelMargin) const;
        void MoveTitleForManual(TextObject* ipAxisTitle) const;
        void MoveGraphObjectList(std::vector<GraphObject::Ptr>& iorGraphObjectList);    
        
        void LoadProperties();      
        
        
        
        //---------Data members----------------------------------
        GraphAxisGeneral mAxisInfo; 
        GraphAxisGrid mMajorGrid;   
        GraphAxisGrid mMinorGrid;   
        Rect2D mDeviceDataArea; 
        Int32 mTickLength;  

        bool mUseDepth;     
        Int32 mDepth;       
        Int32 mDepthDirection;  
        Point2D mDepthOffset;   
        MBase::String mAxisTitle;   
        double mLowTrim;
        double mHighTrim;

        std::vector<GraphObject::Ptr> mManagerGraphObjectList;      

        bool mIsAxisFor3D;
        Int32 mAxisLengthFor3D;
        Int32 mAxisMarginFor3D;
        
        GraphCollectionObject* mpMajorGridSet;
        GraphCollectionObject* mpMinorGridSet;
        GraphCollectionObject* mpInterlacedGridSet;
        GraphCollectionObject* mpAxisTitleSet;
        GraphCollectionObject* mpAxisLabelSet;
        GraphCollectionObject* mpAxisLineSet;   

        bool mIsForRangeLegend;        
        bool mIsUniformAxis;
    private:
        void hGenerateGrids(const Rect2D& irDataArea, std::vector<GraphObject::Ptr>& iorGraphObjectList, bool iIsGridLine); 
        virtual void hGenerateGridsByArea(bool iIsGridLine) = 0;
        
        void hMapGridOptions(GraphAxisGrid& iorGrid);
        void hGenerateOneAxisLine(Int32 iLabelLocation);
        void hGenerateDepthAxisLine();      
        void hGetAxisLine(Int32 iLabelLocation, Point2D& orStart, Point2D& orEnd) const;    

        void hGetOneDepthGridLine(Int32 iLocation, Int32 iGridStyle, Int32 iTickLength, 
            const Point2D& irLeftOrBottom, const Point2D& irRightOrTop, std::vector<Point2D>& orPolyLine);
        void hUseInnerDataArea();       
    };

    inline void Axis::SetDeviceDataArea(const Rect2D& irDeviceDataArea)
    {
        mDeviceDataArea = irDeviceDataArea;
    }   
    
    inline void Axis::GetDeviceDataArea(Rect2D& orDeviceDataArea)
    {
        orDeviceDataArea = mDeviceDataArea;
    }

    inline bool Axis::IsReverseOrder()
    {
        return mAxisInfo.mAxisDrawInReverse;
    }   

    inline bool Axis::HasLabelsOnBothSides() const
    {
        return (mAxisInfo.mAxisLabelsLocation == ALL_BOTTOM_TOP || mAxisInfo.mAxisLabelsLocation == ALL_LEFT_RIGHT) && !(mChartContextPtr->IsTimeSeriesChart());
    }   

    inline bool Axis::IsVerticalAxis() const
    {
        return mAxisInfo.mAxisDirection == AD_Y;
    }

    inline bool Axis::IsRightDirection() const
    {
        return mDepthDirection < 90 || mDepthDirection > 270;
    }
    inline bool Axis::IsLeftDirection() const
    {
        return mDepthDirection > 90 && mDepthDirection < 270;
    }
    inline bool Axis::IsUpDirection() const
    {
        return mDepthDirection < 180;
    }
    inline bool Axis::IsDownDirection() const
    {
        return mDepthDirection > 180;
    }
    inline bool Axis::HasOuterTicks(Int32 iGridStyle) const
    {
        return iGridStyle == DssGraphGridOuterTicks || 
            iGridStyle == DssGraphGridBoth ||
            iGridStyle == DssGraphGridSpanningTicks;
    }
    inline bool Axis::HasTwoGridLineParts(Int32 iGridStyle) const
    {
        return HasLabelsOnBothSides() && (iGridStyle == DssGraphGridInnerTicks || 
            iGridStyle == DssGraphGridOuterTicks || iGridStyle == DssGraphGridSpanningTicks);
    }
    inline bool Axis::IsLogarithmic() const
    {
        return false;
    }
    inline bool Axis::IsMajorGridShown() const
    {
        return mMajorGrid.mShowGridLines;
    }
    inline bool Axis::IsInterlacedShown() const
    {
        return mAxisInfo.mUseInterlacedGrids;
    }
    inline bool Axis::IsLabelsShown() const
    {
        return mAxisInfo.mShowAxisLabels;
    }   
    inline bool Axis::IsTitleShown() const
    {
        return mAxisInfo.mShowAxisTitle;
    }
    inline void Axis::SetAxisInfoFor3D(Int32 iAxisLength, Int32 iAxisMargin)
    {
        mAxisLengthFor3D = iAxisLength;
        mAxisMarginFor3D = iAxisMargin;
    }
    inline Int32 Axis::GetAxisLengthFor3D() const
    {
        return mAxisLengthFor3D;
    }   
    inline bool Axis::IsUniformAxis() const
    {
        _ASSERTE(mChartContextPtr->IsGraphMatrix());
        return mIsUniformAxis;
    }
    inline void Axis::SetAsUniformAxis(bool iUniformAxis)
    {
        mIsUniformAxis = iUniformAxis;
    }
}
#endif