TextObject.h

Go to the documentation of this file.

//==============================================================================================
//  FILENAME    :   TextObject.h
//  AUTHOR      :   Fangyao Ma
//  CREATION    :   2008-06-06
//  Copyright (C) MicroStrategy Incorporated 2008
//  All Rights Reserved
//==============================================================================================

#ifndef MsiChart_TextObject_h
#define MsiChart_TextObject_h 1

#include "RectangleObject.h"
#include "FormatFont.h"

namespace MsiChart
{
    const Int32 XOffset = 2;    
    const Int32 YOffset = 2;    

    enum EnumVerticalAlign
    {
        VERTICAL_TOP,
        VERTICAL_MIDDLE,
        VERTICAL_BOTTOM,
        VERTICAL_NONE,
    };

    enum EnumAnchorPoint
    {
        TOP_LEFT,
        TOP_MIDDLE,
        TOP_RIGHT,
        LEFT_MIDDLE,
        CENTER,
        RIGHT_MIDDLE,
        BOTTOM_LEFT,
        BOTTOM_MIDDLE,
        BOTTOM_RIGHT,
    };
    
    typedef enum EnumTextBorderStyle
    {
        TBS_NONE = 0,
        TBS_SOLID,
        TBS_DASH,
        TBS_DOT,
        TBS_DOUBLE,
    }EnumTextBorderStyle;

    struct TextExtent
    {
        /*TextExtent(const cairo_text_extents_t& iCairoTextExtent)
            : width(iCairoTextExtent.width)
            , x_bearing(iCairoTextExtent.x_bearing)
            , x_advance(iCairoTextExtent.x_advance)
        {}*/
        TextExtent(float iWidth)
        : width(iWidth)     
        , x_bearing(0)
        , x_advance(iWidth)
        {}
        TextExtent()
            : width(0.0)
            , x_bearing(0.0)
            , x_advance(0.0)
        {}

        double width;
        double x_bearing;
        double x_advance;
    };
    
    class SubTextHolder
    {
    public:
        friend class TextObject;
        void Clear();

        void ParseText(const MBase::String& irText, const wchar_t iSeparator, Int32 iWordLengthLimit = -1);

        void UpdateText(ChartContext::Ptr iChartContextPtr,FormatFont* ipDeviceFont);

        void PartitionBy(Int32 iDestWidth, bool iIsStrigent = true);

        void GetPartitionRange(std::vector<Int32>& orVecIndex) const;

        Int32 GetMaxWidth() const;

        Int32 GetLineCount() const;

        void SetLineCount(Int32 iLineCount);
        double GetOneLineWidth(Int32 iLineIndex) const;

        double GetOneLineXBearing(Int32 iLineIndex) const;

        MBase::ReturnWString GetOneLineString(Int32 iLineIndex) const;

        MBase::ReturnWString TruncateWord(const MBase::String& irString, Int32 iWordLengthLimit) const;

        Int32 GetSpaceWidth() const;
    private:
        std::vector<MBase::String> mVecStr;     
        std::vector<Int32>  mInitVecPartition;  
        std::vector<Int32>  mVecPartition;      
        std::vector<TextExtent> mVecSize;           
        double mSpaceWidth;
        MBase::String mText;
        double mMaxWordWidth;
    };

    class TextObject: public ShapeObject
    {
    public:
        typedef MSynch::SmartPtr<TextObject> Ptr;

        TextObject(const TripleId& irTripleId,      
                        GraphObjectManager* ipManager,                                          
                        Rect2D iRect,
                        GraphCollectionObject* ipParentObject = NULL, 
                        bool iClientDrag = false);
        
        TextObject(const TripleId& irTripleId,
                        GraphObjectManager* ipManager,
                        GraphCollectionObject* ipParentObject = NULL);
        
        virtual ~TextObject();

        //  virtual functions from GraphObject
        virtual void DrawOutLine();
        virtual bool PointInObject(const Point2D& irPoint);     
        virtual bool ObjectInRectangle(const Rect2D& irRect);
        virtual void Draw() const;
        virtual void GetOptions(Int32 iPropertyId, CComVariant* opValue) const;
        virtual void GenerateImageMap(ImageMap& iorImageMap);

        //  pure virtual function from ShapeObject
        virtual void GetBoundingRect(Rect2D& orBoundingRect) const;     

        //  Public method
        void GetBoundingRectNoRotation(Rect2D& orBoundingRect) const;

        void SetText(const MBase::String& irText, Int32 iWordLengthLimit = -1);

        void GetText(MBase::String& orText, bool iIsOriginalText = false);

        void SetRect(const Rect2D& irRect);
        
        void GetRect(Rect2D& orRect) const;

    //  void GetRect(Rect2D& orRect);

        FormatFont::Ptr GetFormatFont();

        void MoveTo(Int32 iDestX, Int32 iDestY, Int32 iAnchor = TOP_LEFT);  

        void MoveToCenter(float iDestX, float iDestY);

        void SetTextWidthLimit(Int32 iWidthLimit, bool iIsStringent = true);

        void SetIsShown(bool iIsShown);

        bool GetIsShown();

        void CalculateDeviceRect() const;

        TextObject::Ptr Clone() const;

        void GetTransformedRect(Rect2D& orRect) const;
        bool HasOverlapForSameRotation(TextObject* ipTextObject, Int32 iLabelSpan = 0, REC_EXP_DIRECTION iSpanDirection = REC_EXP_INVALID) const;

        Int32 GetLineCount() const;

        Int32 GetOneLineHeight() const;

        void RestoreWidthAndHeight();

        void SetLineCount(Int32 iLineCount);
        
        Int32 GetStringLength() const;
        
        void SetBorderStyleAndColor(EnumTextBorderStyle iStyle, Int32 iColor, Int32 iDirection);
        
        void EnableLargerTruncationLimit(bool iUseLargerTruncationLimit);
    
        bool IsTruncated() const;
        
        bool MaybeTruncated() const;
        
        bool IsTooCloseTo(TextObject* ipTextObject, double iDistance, Int32 iAnchorStyle);
        void SetLineCountEnforced(bool iIsEnforeced = false);
        
        Int32 GetWidthHeightMargin(bool iIsWidth);
        

    protected:  
        virtual void GetClockwisePolygon(std::vector<Point2D>& orPolygon) const;
        
        void ApplyUnderlineorStrikeThroughFormat() const;

        void hFillTextFrame(const Rect2D& irTextFrameRect) const;

        void hFormatSingleLineText(Point2D& irStartPoint, Int32 iLineIndex) const;

        void hGetDevicePolygon(std::vector<Point2D>& orDevicePolygon) const;

        void hGetDevicePolygon(const Rect2D irRect, std::vector<Point2D>& orDevicePolygon) const;
        
        double hGetRadian() const;  

        void hTruncate(Int32 iLineIndex, MBase::String& orStr, double& orTextWidth, double& orTextXBearing) const;

        void hCalculateParas(); 

        FormatFont::Ptr     mFormatFontPtr; 
        MBase::String       mText;          
        MBase::String       mFullText;      
        
        mutable Rect2D      mRect;          
        mutable SubTextHolder   mSubTextHolder; 
        bool mClientDrag;
        bool mIsShown;

        Int32   mWidthEdgeMargin;
        Int32   mHeightEdgeMargin;
        Int32   mTextLineSpace;
        Int32   mDoubleLineMargin;      
        Int32   mFontHeight;
        mutable bool    mIsRectCalculated;
        Int32   mTextWidthLimit;
        bool    mIsStringent;
        bool    mUseLargerTruncationLimit;  
        Int32   mLineCount;
        bool    mIsLineCountEnforced;       
        mutable bool    mIsTruncated;               
        EnumTextBorderStyle mBorderStyle[4];//left right top bottom
        int mBorderColor[4];//left right top bottom
        


    //  EnumVerticalAlign   mVerticalAlign; ///< Vertical Alignment

    private:        
        virtual void hGetFormatFromParent();

        void hAdjustRect() const;
        
        void hInitFormat();
        
    };

    
    inline void TextObject::SetIsShown(bool iIsShown)
    {
        mIsShown = iIsShown;
    }

    inline bool TextObject::GetIsShown()
    {
        return mIsShown;
    }

    inline void TextObject::MoveToCenter(float iDestX, float iDestY)
    {   
        mRect.x = static_cast<Int32>(iDestX - mRect.width / 2.0f + 0.5f);
        mRect.y = static_cast<Int32>(iDestY - mRect.height / 2.0f + 0.5f);      
    }
    
    inline Int32 TextObject::GetStringLength() const
    {
        return (Int32)mText.length();
    }
    
    inline void TextObject::GetRect(Rect2D& orRect) const
    {
        orRect = mRect;
    }
    
    inline void TextObject::SetBorderStyleAndColor(EnumTextBorderStyle iStyle, Int32 iColor, Int32 iDirection)
    {
        _ASSERT(iDirection < 4);
        mBorderStyle[iDirection] = iStyle;
        mBorderColor[iDirection] = iColor;
    }
    
    inline void TextObject::EnableLargerTruncationLimit(bool iUseLargerTruncationLimit)
    {
        mUseLargerTruncationLimit = iUseLargerTruncationLimit;
    }

    inline bool TextObject::IsTruncated() const
    {
        return mIsTruncated;
    }

    inline Int32 TextObject::GetWidthHeightMargin(bool iIsWidth)
    {
        return iIsWidth ? mWidthEdgeMargin : mHeightEdgeMargin;
    }
    
}

#endif