GraphObject.h

Go to the documentation of this file.

//===========================================================================
//  Filename:       GraphObject.h
//  Date:           2008-05-19
//  Authors:        Bing Huang

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

#ifndef MsiChart_GraphObject_h
#define MsiChart_GraphObject_h

#include "Base/Defines/BasicTypes.h"
#include "Synch/Defines/SmartPtr.h"
#include "PDCHeader/PDCstring"

#include "../Common.h"
#include "ImageMap.h"
#include "ChartContext.h"
#include "FormatLine.h"

namespace MsiChart
{
    class GraphObjectManager;
    class GraphCollectionObject;
    typedef std::vector<Point2D> Polygon2D;
    
    typedef enum
    {
        GOU_NORMAL_HIGHLIGHT = 0,
        GOU_GM_HOVER = 1,
        GOU_GM_SELECTED = 2
    }EnumGraphObjectUsage;
    
    class GraphObject
    {
    public:
        //smart ptr
        typedef MSynch::SmartPtr<GraphObject> Ptr;
        
        //ctor & dtor
        GraphObject(const TripleId& irTripleId, GraphObjectManager* ipManager, GraphCollectionObject* ipParentObject, bool iHasLine = true);
        virtual ~GraphObject();
        
        void GetTripleId(TripleId& orTripleId) const;
        
        Int32 GetObjectId() const;
        
        Int32 GetSeriesId() const;
        virtual void Draw() const = 0;
        
        virtual void GenerateView();
        
        virtual bool ObjectInRectangle(const Rect2D& irRect) = 0;
        virtual void ObjectsInRectange(const Rect2D& irRect, std::vector<GraphObject::Ptr>& iorSelectedObjects);
        
        virtual void DrawOutLine();
        
        virtual bool PointInObject(const Point2D& irPoint);
        
        virtual Int32 DistanceToPoint(const Point2D& irPoint);
        
        virtual void GetOptions(Int32 iPropertyId, CComVariant* opValue) const;
        
        virtual void GenerateImageMap(ImageMap& iorImageMap);
        
        GraphCollectionObject* GetParentObject() const;
        
        void SetFormatLine(FormatLine::Ptr iFormatLinePtr);
        
        FormatLine::Ptr GetFormatLine() const;
        
        virtual void GetBoundingRect(Rect2D& orBoundingRect) const;
        
        virtual Point2D GetCenterPoint() const;
        
        Int32 GetChartAreaId() const;
        
        void SetDetectable(bool iIsDetectable);
        
        virtual Point2D GetDataPoint();
        
        virtual void GetClockwisePolygon(std::vector<Point2D>& orPolygon) const = 0;
        
        virtual void SetProgress(double iProgress);
        
        void SetAnimationEnable(bool iIsAnimationEnabled);
        bool IsAnimationEnabled();
        void SetNativeAnimationEnable(bool iIsNativeAnimationEnabled);
        bool IsNativeAnimationEnabled();
        
        virtual bool IsLayerObject() const;
        
        virtual float GetMemoryUsageEstimation() const;
        
        virtual void SetHover(bool iIsHovered);
        virtual bool GetHover() const;
        virtual bool IsVirtual() const;
        void GetGraphObjectManager(GraphObjectManager* &oprManager);
        void SetOutlineWidth() const;
        void SetOutlineWidth(Int32 iLineWidth) const;
#ifndef _VE_CE

        void DrawGlowEffectForRect(const Rect2D& irRect, CGGradientRef iGradient) const;
        
        void DrawGlowEffectForPolygon(const Polygon2D& irPolygon, CGGradientRef iGradient) const;
#endif
    protected:
        void SetLineWidth() const;
        
        void ApplyLineFormat() const;
        
        void ApplyOutlineFormat() const;
        
        void ApplyInnerOutlineFormat() const;
        
        void AppendRectangle2ImageMap(const Rect2D& irRect, ImageMap& iorImageMap) const;
        
        void AppendPolygon2ImageMap(const std::vector<Point2D>& irPolygon,ImageMap& iorImageMap) const;
        
        void GetAngularBisectorIntersectionPoint(const Point2D& irA, const Point2D& irB, const Point2D& irC, float irDepth, Point2D& orBisectorPoint) const;
        
        void MakePolygonClockwise(std::vector<Point2D>& iorPolygon) const;
        //bool mIsShown;
        //mutable bool mDeviceValid;
        GraphCollectionObject* mpParentObject;
        FormatLine::Ptr mFormatLinePtr;
        
        const TripleId mTripleId;
        ChartContext::Ptr mChartContextPtr;
        GraphObjectManager* mpManager;
        
        bool mIsDetectable;                 
        
        double mProgress;
        
        bool mIsAnimationEnabled;
        
        bool mIsNativeAnimationEnabled;
        
        bool mIsHovered;                    
    private:
        void hSetLineWidth(Int32 iLineWidth) const;
        
        void hSetParent(GraphCollectionObject* ipParentObject);
        
        virtual void hGetFormatFromParent();
        
        friend class GraphCollectionObject;
    };
    typedef GraphObject LineObject;
    
    inline Int32 GraphObject::GetObjectId() const
    {
        return mTripleId.mObjectId;
    }
    inline Int32 GraphObject::GetSeriesId() const
    {
        return mTripleId.mSeriesId;
    }
    
    inline GraphCollectionObject* GraphObject::GetParentObject() const
    {
        return mpParentObject;
    }
    
    inline FormatLine::Ptr GraphObject::GetFormatLine() const
    {
        return mFormatLinePtr;
    }
    
    inline void GraphObject::hSetParent(GraphCollectionObject* ipParentObject)
    {
        mpParentObject = ipParentObject;
    }
    
    inline void GraphObject::SetDetectable(bool iIsDetectable)
    {
        mIsDetectable = iIsDetectable;
    }
    
    inline void GraphObject::SetAnimationEnable(bool iIsAnimationEnabled)
    {
        mIsAnimationEnabled = iIsAnimationEnabled;
        SetProgress(0.1);
    }
    inline bool GraphObject::IsAnimationEnabled()
    {
        return mIsAnimationEnabled;
    }
    inline void GraphObject::SetNativeAnimationEnable(bool iIsNativeAnimationEnabled)
    {
        mIsNativeAnimationEnabled = iIsNativeAnimationEnabled;
        SetProgress(0.1);
    }
    inline bool GraphObject::IsNativeAnimationEnabled()
    {
        return mIsNativeAnimationEnabled;   
    }
    inline void GraphObject::SetProgress(double iProgress)
    {
        mProgress = iProgress;
    }   
    inline bool GraphObject::IsLayerObject() const
    {
        return false;
    }
    inline float GraphObject::GetMemoryUsageEstimation() const
    {
        return sizeof(*this);
    }
    inline void GraphObject::SetHover(bool iIsHovered)
    {
        mIsHovered = iIsHovered;
        mChartContextPtr->SetHover(mTripleId, iIsHovered);
    }       
    inline bool GraphObject::GetHover() const
    {
        return mIsHovered;
    }
    inline bool GraphObject::IsVirtual() const
    {
        return false;
    }
    inline void GraphObject::GetGraphObjectManager(GraphObjectManager* &oprManager)
    {
        oprManager = mpManager;
    }
}

#endif