Annotation.h

#pragma once

using namespace System;
using namespace System::Xml;
using namespace System::Text;
using namespace System::Drawing;
using namespace System::Drawing::Drawing2D;
using namespace System::Collections::Generic;
using namespace System::ComponentModel;


namespace MST
{
namespace Imaging
{
namespace Annotations
{
    public enum class Type
    {
        Line,
        Rectangle,
        Hilite,
        Arrow,
        Ruler,
        CrossProduct,
        Ellipse,
        Pencil,
        Polyline,
        PolyRuler,
        Curve,
        Cloud,
        ScratchOut,
        Angle,
        Point,
        TextNote,
        Stamp
     };

    ref class MSTAnnotationPage;
    [DefaultPropertyAttribute("Name")]
    public ref class MSTAnnotation abstract
    {
    public:
        MSTAnnotation(Pen^ pen,MSTAnnotationPage^ page);
        
        [CategoryAttribute("General"), DescriptionAttribute("Type of annotation.")]
        property Type AnnotationType
        {
            virtual Type get()=0;
        }
        [CategoryAttribute("General"), DescriptionAttribute("Border color of annotation. [Format: RGB/ARGB]")]
        property Color BorderColor
        {
            Color get() 
            {
                return m_pen->Color;  
            }
            void set(Color clr)
            {
                m_pen->Color = clr; 
            }
        }
        
        [CategoryAttribute("General"), DescriptionAttribute("Border width of annotation. [Range: 1-10]")]
        property Int32 BorderWidth
        {
            Int32 get()
            {
                return (Int32)m_pen->Width;
            }
            void set(Int32 Value)
            {
                if(Value<1)Value=1;
                if(Value>10)Value=10;
                m_pen->Width=Value;
            }
        }

        [BrowsableAttribute(false)]
        property bool Selected
        {
            bool get(){return m_bSelected;}
            void set(bool value){m_bSelected=value;}
        }

        [BrowsableAttribute(false)]
        property array<PointF>^ Points
        {
            virtual array<PointF>^ get(){return m_ptArr;}
        }

        [BrowsableAttribute(false)]
        property PointF Points[Int16]
        {
            virtual PointF get(Int16 iIndex)
            {
                if(iIndex < 0 || iIndex >= m_ptArr->Length) throw gcnew System::ArgumentException("Index out of range.");
                return m_ptArr[iIndex];
            }
            virtual void set(Int16 iIndex,PointF Value)
            {
                if(iIndex < 0 || iIndex >= m_ptArr->Length) throw gcnew System::ArgumentException("Index out of range.");
                m_ptArr[iIndex] = Value;
            }
        }

        [BrowsableAttribute(false)]
        property System::Drawing::Drawing2D::GraphicsPath^ graphicsPath
        {
            GraphicsPath^ get()
            {
                GraphicsPath^ path = gcnew GraphicsPath();
                Draw(path,m_ptArr);
                return path;
            }
        }

        [BrowsableAttribute(false)]
        property array<RectangleF>^ PointRect
        {
            virtual array<RectangleF>^ get()
            {
                array<PointF>^ pts = Points;
                array<RectangleF>^ rectArr = gcnew array<RectangleF>(pts->Length);
                for(int i=0;i<pts->Length;i++)
                {
                    rectArr[i] = RectangleF(pts[i].X-4,pts[i].Y-4,8,8);
                }
                return rectArr;
            }
        }

        [BrowsableAttribute(false)]
        property Int16 PointsCount
        {
            virtual Int16 get(){return m_ptArr->Length;}
        }

        void DrawPoints(Graphics ^g);

        array<PointF>^ GetNormalPoints();
        virtual void Save(XmlDocument^ writer,XmlElement^ element);
        virtual void Load(XmlElement^ element);

        void FlipGraphicsPath(GraphicsPath^ gp,float Width,float Height,bool bHorz,bool bVert);

        void DrawString(Graphics^ g, String^ text ,Point location)
        {
            System::Drawing::SolidBrush^ brush = gcnew System::Drawing::SolidBrush(Color::FromArgb(150,0,0,0)); 
            StringFormat ^ Centre = gcnew StringFormat();  
            Centre->Alignment = StringAlignment::Center; 
            Font^ font = gcnew Font("Calibri",12);
            System::Drawing::Rectangle rect = System::Drawing::Rectangle(location.X,location.Y,g->MeasureString(text,font).Width+5 ,g->MeasureString(text,font).Height); 
            g->FillRectangle(brush,rect); 
            g->DrawString(text, font,Brushes::Wheat,rect,Centre);
            delete brush;
            delete Centre;
            delete font;
        }
        void DrawScale(GraphicsPath^ g,PointF pt1,PointF pt2,float distance);

        virtual void Move(int cx,int cy);

        virtual bool HitTest(PointF pt);

        virtual bool IntersectsRect(System::Drawing::Rectangle rect);

        virtual void ApplyMatrix(Matrix^ matrix);

        virtual Int16 GetPointIndex(PointF pt);

        virtual void Draw(Graphics^ g,array<PointF>^ ptArr,bool bShowSelection); 
        virtual void Draw(GraphicsPath^ gp,array<PointF>^ ptArr);
        void Burn(Graphics^ g);
    protected:
        static bool IsLineIntersectsRect(array<PointF>^ pts,System::Drawing::Rectangle rect);
        static double getdistance(PointF start, PointF end,float fPixelWidth,float fPixelHeight);
    protected:
        Pen^ m_pen;
        array<PointF>^          m_ptArr;
        MSTAnnotationPage^      m_pPage; 
        bool                    m_bSelected;
    };
}
}
}