Netron应用实战系列（2）——Netron基础类介绍 - yatasoft

Netron应用实战系列（2）——Netron基础类介绍

一次图形图像类库的开发！一次.net组件的开发！一次MVC的尝试！一次重构的旅途！

  在使用Netron之前，我们要先来了解一下Netron的三个关键类：Shape、Connection、Connector。您可以在 NetronGraphLibrary文件夹下发现他们。这三个类均继承自Entity类。下面我们简要介绍Entity类的基本模块，先看Entity 类的代码。

 

using System;
using System.Collections;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Printing;
using System.IO;
using System.Security;
using System.Security.Permissions;

using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Reflection;
using System.Threading;
using System.Windows.Forms;
using Netron.GraphLib.UI;
using Netron.GraphLib.Interfaces;
using Netron.GraphLib.Attributes;
using Netron.GraphLib.Configuration;
namespace Netron.GraphLib
{
    /// <summary>
    /// Abstract base class for everything that participates in the diagram/graph (connection, connector)    
    /// </summary>
    [Serializable] public abstract class Entity : IEntity, IDisposable, ISerializable
    {    

        #region Events

        /// <summary>
        /// Occurs when the mouse is pressed on this entity
        /// </summary>
        public event MouseEventHandler OnMouseDown;

        /// <summary>
        /// Occurs when the mouse is released while above this entity
        /// </summary>
        public event MouseEventHandler OnMouseUp;

        /// <summary>
        /// Occurs when the mouse is moved while above this entity
        /// </summary>
        public event MouseEventHandler OnMouseMove;
        #endregion

        #region Fields

        /// <summary>
        /// the layer to which the entity belongs,
        /// the default layer is a static unique layer defined in the GraphAbstract.        
        /// </summary>        
        private GraphLayer mLayer;
        /// <summary>
        /// volatile all-purpose tag
        /// </summary>
        [NonSerialized] private object mTag;
        /// <summary>
        /// whether to recalculate the shape size, speed up the rendering
        /// </summary>
        private bool mRecalculateSize ;
        /// <summary>
        /// the property bag
        /// </summary>
        [NonSerialized] private PropertyBag mBag;
        /// <summary>
        /// default blue mPen, speeds up rendering
        /// Note that the Pen is not serialzable!
        /// </summary>
        [NonSerialized] private Pen mBluePen;
        /// <summary>
        /// default black mPen, speeds up rendering
        /// </summary>
        [NonSerialized] private Pen mBlackPen;
        /// <summary>
        /// the mPen\'s width
        /// </summary>
        private float mPenWidth = 1F;
        /// <summary>
        /// default mPen
        /// </summary>
        [NonSerialized] private Pen mPen;
        /// <summary>
        /// whether the entity is reset
        /// </summary>
        private bool mIsGuiReset;
        /// <summary>
        /// the font family
        /// </summary>
        private string mFontFamily = "Verdana";
        /// <summary>
        /// whether the entity is selected
        /// </summary>
        private bool mIsSelected;
        /// <summary>
        /// whether this entity is being hovered
        /// </summary>
        private bool mIsHovered ;
        /// <summary>
        /// the unique identitfier
        /// </summary>
        private Guid mUID ;
        /// <summary>
        /// mText or label
        /// </summary>
        private string mText = "[Not set]";
        /// <summary>
        /// whether to show the mText label
        /// </summary>
        private bool mShowLabel = true;        
        /// <summary>
        /// the default mText color
        /// </summary>
        private Color mTextColor = Color.Black;
        /// <summary>
        /// the default font size in points
        /// </summary>
        private float mFontSize = 7.8F;
        /// <summary>
        /// the default font for entities
        /// </summary>
        private Font mFont;
        /// <summary>
        /// the mSite of the entity
        /// </summary>
        [NonSerialized] private IGraphSite mSite;
            

        #endregion

        #region Properties

        /// <summary>
        /// Gets or sets the pen-object to paint and draw
        /// </summary>
        public Pen Pen
        {
            get{return mPen;}
            set{mPen = value;}
        }

        /// <summary>
        /// Gets the property-bag
        /// </summary>
        /// <remarks>The bag acts as a proxy-object for the properties and his part of the propertybag mechanism.</remarks>
        protected PropertyBag Bag
        {
            get{return mBag;}
        }
        
        /// <summary>
        /// Gets or sets whether the next painting roun will have to recalculate the size of the entity
        /// </summary>
        protected bool RecalculateSize
        {
            get{return mRecalculateSize;}
            set{mRecalculateSize = value;}
        }
        /// <summary>
        /// Gets the default black mPen for drawing text and lines
        /// </summary>
        protected Pen BlackPen
        {
            get{return mBlackPen;}
        }

        /// <summary>
        /// Gets or sets the font-family used by derived class to draw and paint on the canvas
        /// </summary>
        protected virtual string FontFamily
        {
            get{return mFontFamily;}
            set{mFontFamily = value;}
        }

        /// <summary>
        /// Gets the layer ths shape is on. If null, the shape is in the default layer.
        /// </summary>
        /// <remarks>User the SetLayer() method to set or change the layer.
        /// </remarks>
        public  GraphLayer Layer
        {
            get
            {
                return mLayer;
            }            
        }
        

        /// <summary>
        /// Gets or sets a general purpose tag object
        /// </summary>
        public object Tag
        {
            get{return mTag;}
            set{mTag = value;}
        }
        /// <summary>
        /// Gets or sets the mPen width
        /// </summary>
        [GraphMLData]public float PenWidth
        {
            get{return mPenWidth;}
            set{mPenWidth = value;}
        }

        /// <summary>
        /// Gets or sets whether the shape label should be shown.
        /// </summary>
        [GraphMLData]public virtual bool ShowLabel
        {
            get
            {
                    
                return mShowLabel;
            }
            set
            {
                mShowLabel=value; this.Invalidate();
            }
        }
        /// <summary>
        /// Allows to view/change the properties of the shape, most probably on double-clicking it.
        /// </summary>            
        public virtual PropertyBag Properties
        {
            get{return mBag;}

        }

        /// <summary>
        /// Gets or sets the entity label
        /// </summary>
        [GraphMLData]public virtual string Text
        {

            get
            {

                return mText;
            }
            set
            {
                if (value!=null)    mText=value;

            }
        }

        /// <summary>
        /// Gets or sets the mSite of the entity
        /// </summary>
        public IGraphSite Site
        {
            get{return mSite;}
            set{mSite = value;}
        }
        /// <summary>
        /// Tells wether the entity (shape) is selected
        /// </summary>
        public virtual bool IsSelected
        {
            set { Invalidate(); mIsSelected = value; Invalidate(); }
            get { return mIsSelected; }
        }
        /// <summary>
        /// Gets or sets whether the entity\'s UID is reset
        /// </summary>
        /// <remarks>USed in the cotext of copy/paste</remarks>
        protected internal virtual bool IsGuiReset
        {
            get{return mIsGuiReset;}
            set{mIsGuiReset = value;}
        }
        /// <summary>
        /// Gives true if the mouse is hovering over this entity
        /// </summary>
        protected internal virtual bool IsHovered
        {
            set { Invalidate(); mIsHovered = value; Invalidate(); }
            get { return mIsHovered; }
        }

        /// <summary>
        /// Gets or sets the mText color
        /// </summary>
        public virtual Color TextColor
        {
            get
            {                    
                return mTextColor;
            }
            set
            {
                mTextColor=value;
            }
        }

        /// <summary>
        /// Gets or sets the font size of the mText
        /// </summary>
        protected virtual float FontSize
        {
            get
            {
                    
                return mFontSize;
            }
            set
            {
                mFontSize=value;
            }
        }
    

        
        /// <summary>
        /// Gets or sets the font to be used when drawing text-data
        /// </summary>
        protected Font Font
        {
            get{return this.mFont;}
            set
            {
                this.mFont = value;
                this.mFontFamily = value.FontFamily.ToString();
                this.mFontSize = value.Size;                
            }
        
        }

        /// <summary>
        /// Gets or sets the unique identifier for the shape.
        /// </summary>
        public Guid UID
        {
            get
            {
                return mUID;
            }
            set{mUID = value;}
        }

        /// <summary>
        /// Gets the Summary for this entity
        /// </summary>
        public Summary Summary
        {
            get
            {
                
                return this.Site.GetSummary(this);
            }
        }

        /// <summary>
        /// Gets the tracker of the entity
        /// </summary>
        public virtual Tracker Tracker
        {
            get{return null;}
            set{}
        }
        #endregion
        
        #region Constructors
        /// <summary>
        /// Constructor for the entity class, initializes a new GUID for the entity
        /// </summary>
        protected Entity()
        {
            InitEntity();
        }
        /// <summary>
        /// Creates a new entity, specifying the mSite 
        /// </summary>
        /// <param name="site"></param>
        protected Entity(IGraphSite site)
        {
            InitEntity();
            this.mSite = site;
            
        }
        /// <summary>
        /// Deserialization constructor
        /// </summary>
        /// <param name="info"></param>
        /// <param name="context"></param>
        protected Entity(SerializationInfo info, StreamingContext context)
        {
            InitEntity();
            //overwrite some members with the serialized data
            this.mUID = new Guid(info.GetString("mUID"));
            this.mText = info.GetString("mText");
            this.mShowLabel = info.GetBoolean("mShowLabel");
            this.mTextColor = (Color) info.GetValue("mTextColor",typeof(Color));
            try
            {
                this.mFont = (Font) info.GetValue("mFont", typeof(Font));
            }
            catch
            {
                //font is set by default in the member definition
            }
            //this.mIsSelected = info.GetBoolean("mIsSelected");
            
        }
        #endregion

        #region Methods
        /// <summary>
        /// IDispose implementation
        /// </summary>
        public void Dispose()
        {
            this.mFont.Dispose();
            this.mPen.Dispose();
            this.mBlackPen.Dispose();
            this.mBluePen.Dispose();
        }
        /// <summary>
        /// Sets the layer the entity belongs to
        /// </summary>
        /// <param name="layer"></param>
        protected virtual void SetLayer(GraphLayer layer)
        {
            mLayer = layer;
            return;            
        }

        /// <summary>
        /// Sets the shape in a layer.
        /// Use "default" to set the shape in the default layer.
        /// </summary>
        /// <param name="name"></param>
        public void SetLayer(string name)
        {
            if(name.CompareTo("Default")==0)
            {                
                SetLayer(GraphAbstract.DefaultLayer);
            }
            else
            {                
                SetLayer(Site.Abstract.Layers[name]);
            }
        }
        /// <summary>
        /// Sets the shape in a layer.
        /// Layer 0 is the default layer.
        /// </summary>
        /// <param name="index"></param>
        public void SetLayer(int index)
        {
            if(index==0)
            {
                SetLayer(GraphAbstract.DefaultLayer);
            }
            else
            {
                index--;//the collection starts at 0
                SetLayer(Site.Abstract.Layers[index]);                                
            }
        }


        /// <summary>
        /// Determines which properties are accessible via the property grid
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected virtual void GetPropertyBagValue(object sender, PropertySpecEventArgs e)
        {
            switch(e.Property.Name)
            {
                case "Text": e.Value=this.mText;break;
                case "ShowLabel": e.Value=this.ShowLabel; break;
            }
        }


        /// <summary>
        /// Sets the values passed by the property grid
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected virtual void SetPropertyBagValue(object sender, PropertySpecEventArgs e)
        {

            switch(e.Property.Name)
            {
                case "ShowLabel": this.ShowLabel=(bool) e.Value; break;
                case "Text": 
                    //use the logic and the constraint of the object that is being reflected
                    if(e.Value.ToString() != null)                    
                    {
                        this.mText=(string) e.Value;
                    }
                    else
                        MessageBox.Show("Not a valid label","Invalid label",MessageBoxButtons.OK,MessageBoxIcon.Warning);                    
                    
                    break;
            }
            this.Invalidate();
        }

        /// <summary>
        /// When overriden, allows user defined entities to get custom properties
        /// </summary>
        public virtual void AddProperties()
        {
            return;
        }
        /// <summary>
        /// Initializes the class. This method is necessary when deserializing since various elements like
        /// the Pen cannot be serialized to file and have to be, hence, set after deserialization.
        /// </summary>
        protected internal virtual void InitEntity()
        {
            
            mLayer = GraphAbstract.DefaultLayer;
            mBluePen= new Pen(Brushes.DarkSlateBlue,1F);
            mBlackPen = new Pen(Brushes.Black,1F);
            mUID = Guid.NewGuid();
            mRecalculateSize = false;
            mFont = new Font(mFontFamily,mFontSize,FontStyle.Regular,GraphicsUnit.Point);
            mPen=new Pen(Brushes.Black, mPenWidth);
            mLayer = GraphAbstract.DefaultLayer;//everything is initially in the default (static) layer
            mBag=new PropertyBag(this);
            try
            {                    
                mBag.GetValue+=new PropertySpecEventHandler(GetPropertyBagValue);
                mBag.SetValue+=new PropertySpecEventHandler(SetPropertyBagValue);
                mBag.Properties.Add(new PropertySpec("Text",typeof(string),"Appearance","The text attached to the entity","[Not set]"));
                mBag.Properties.Add(new PropertySpec("ShowLabel",typeof(bool),"Appearance","Gets or sets whether the label will be shown."));
                //                    PropertySpec spec=new PropertySpec("MDI children",typeof(string[]));
                //                    spec.Attributes=new Attribute[]{new System.ComponentModel.ReadOnlyAttribute(true)};
                //                    mBag.Properties.Add(spec);
                //AddProperties(); //add the user defined shape properties                    
                    
            }
            catch(Exception exc) //TODO: catch only those exceptions that you can handle gracefully
            {                
                Trace.WriteLine(exc.Message, "Entity.InitEntity");
            }
            catch
            {                
                Trace.WriteLine("Non-CLS compliant exception caught.", "Entity.InitEntity");
            }


        
        }

        /// <summary>
        /// creates the actual visual element on screen
        /// </summary>
        /// <param name="g"></param>
        public abstract void Paint(Graphics g);
        /// <summary>
        /// Gets the cursor for the current position of the mouse
        /// </summary>
        /// <param name="p"></param>
        /// <returns></returns>
        public abstract Cursor GetCursor(PointF p);

        /// <summary>
        /// GraphAbstract delete method; deletes the entity from the plex
        /// </summary>
        internal protected abstract void Delete();
        /// <summary>
        /// Says wether, for the given rectangle, the underlying shape is contained in it.
        /// </summary>
        /// <param name="r"></param>
        /// <returns></returns>
        public abstract bool Hit(RectangleF r);
        /// <summary>
        /// Invalidating refreshes part or all of a control
        /// </summary>
        public abstract void Invalidate();
        /// <summary>
        /// Allows to paints additional things like the clickable elements on shapes
        /// independently of the shape\'s design
        /// </summary>
        /// <param name="g"></param>
        public abstract void PaintAdornments(Graphics g);

        /// <summary>
        /// Paints the tracker of the entity
        /// </summary>
        /// <param name="g"></param>
        public void PaintTracker(Graphics g)
        {
            if(this.IsSelected) this.Tracker.Paint(g);
        }
        /// <summary>
        /// Regenerates a GUID for this entity
        /// </summary>
        public void GenerateNewUID()
        {
            mUID=Guid.NewGuid();
            mIsGuiReset=true;
        }


        /// <summary>
        /// Raises the mouse down event
        /// </summary>
        /// <param name="e"></param>
        internal virtual void RaiseMouseDown(MouseEventArgs e)
        {
            if(OnMouseDown != null) OnMouseDown(this, e);
        }

        /// <summary>
        /// Raises the mouse up event
        /// </summary>
        /// <param name="e"></param>
        internal void RaiseMouseUp(MouseEventArgs e)
        {
            if(OnMouseUp != null) OnMouseUp(this, e);
        }

        internal void RaiseMouseMove(MouseEventArgs e)
        {
            if(OnMouseMove!=null) OnMouseMove(this,e);
        }

        
        
        #endregion

        #region ISerializable Members

        /// <summary>
        /// ISerializable implementation
        /// </summary>
        /// <param name="info">the serialization info</param>
        /// <param name="context">the streaming context</param>
        [SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
        public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            info.AddValue("mUID",this.mUID.ToString());            

            info.AddValue("mTextColor",this.mTextColor,typeof(Color));            

            info.AddValue("mText",this.mText);            

            info.AddValue("mShowLabel",this.mShowLabel);
            
            info.AddValue("mFont", this.mFont, typeof(Font));

            //additional check in case we\'re making a deep copy of a bundle
            if(mLayer==null)
                info.AddValue("mLayer","Default");
            else
                info.AddValue("mLayer",this.mLayer.Name);
            

        }
        /// <summary>
        /// Post-deserialization actions
        /// </summary>
        public virtual void PostDeserialization()
        {
            //add the properties
            this.AddProperties();
        }

        #endregion
    }
}

   可以看到这个基本类多继承接口IEntity, IDisposable, ISerializable。类本身可以做的3个基本鼠标事件支持，以及实体大小等字段，还有序列化方法等等。

   下面给出一个三个类的实例图

 

    Shape即为图像所画出的实体，代码太多就不贴了不好意思哈。

字段介绍： 注意看这个字段mRectangle这个字段十分重要，大致作用是shape的本体宿主，你可以通过这个取得shape的坐标以及宽和高。

---

   方法介绍：这里不能不说Paint方法，这个方法是每种shape都要override的方法，其主要作用是绘制图像，不同图像的很大区别也在这个方法的内容不同。

      Connection即为图像的连线，代码太多就不贴了不好意思哈

 字段介绍 ：private Connector mFrom ;private Connector mTo;这两个是Connector(待会介绍这个类)引用，这是保存连线的开始节点和结束节点。private Color mLineColor 连线的颜色。private DashStyle mLineStyle连线的样式，可选值是枚举类型的,比如点，还是实心线等。ConnectionEnd mLineEnd，连线结束头的样子，可选值是枚举类型，例如可选小箭头型。private Tracker   mTracker; 这个Tracker类放到下一篇介绍

---

     方法介绍：Invalidate()，刷新自身的方法，另外一个重要的方法是Delete方法。其余方法读者自己可以去研究，我因没有多深入，在此不多说了。

     Connector即为图像身边的小灰色方块点，这些点的作用是连线的接头，注意Connection类中含有Connector mFrom 和Connector mTo两个字段。注意Connector仅仅存在于shape类内，自己不可独立存在。也即shape类组合Connector，这里关系类似骑车轮胎和 汽车的关系一样。

    Connector也仅仅一个类，如果读者愿意完全可以自己实现一个Connector替换之，下面是它的代码。

using System;
using System.Collections;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Printing;
using System.IO;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Reflection;
using System.Threading;
using System.Windows.Forms;
using Netron.GraphLib.Interfaces;
using System.Security;
using System.Security.Permissions;
namespace Netron.GraphLib
{
    /**//// <summary>
    /// A Connector aka \'connection point\' is the spot on a shape where a line (connection) will attach itself.
    /// Lits up when cursor is nearby and can contain in/outflow data that can propagate through the connections.
    /// </summary>
    /// <remarks>
    /// Things you can do:
    /// <br>- making the connector blink or flash when hit</br>
    /// <br>- show an extensive information box when hovered</br>
    /// <br>- attach a status message when hovered</br>
    /// <br>- differentiate different connector on their propagation type or their parnet/child relation</br>
    ///</remarks>
    
        
    [Serializable] public  class Connector : Entity, ISerializable
    {

        Fields#region Fields
        /**//// <summary>
        /// gives a little displacement between the connection and the connector
        /// </summary>
        private float mConnectionShift = 15F;
        /**//// <summary>
        /// determines the place of the connection shift
        /// </summary>
        private ConnectorLocation mConnectorLocation = ConnectorLocation.Unknown;
        /**//// <summary>
        /// the shift point
        /// </summary>
        private PointF mAdjacentPoint = PointF.Empty;
        /**//// <summary>
        /// only 1 connection allowed if false
        /// </summary>
        private bool mAllowMultipleConnections;          
        /**//// <summary>
        /// object this connector belongs to.
        /// </summary>
        private Shape mBelongsTo; 
        /**//// <summary>
        /// connections attached to this connector
        /// </summary>
        private ConnectionCollection mConnections; 
        /**//// <summary>
        /// collection of objects that the connector propagates
        /// </summary>
        private ArrayList mSendList;  
        /**//// <summary>
        /// collection of values/objects that the connector receives from other connectors
        /// </summary>
        private ArrayList mReceiveList; 
        /**//// <summary>
        /// name of the connector
        /// </summary>
        private string mName;
        /**//// <summary>
        /// allow new connections to be launched from this connector
        /// </summary>
        private bool mAllowNewConnectionsFrom = true;
        /**//// <summary>
        /// allow new connection to be attached to this connector
        /// </summary>
        private bool mAllowNewConnectionsTo = true;

        #endregion

        Properties#region Properties

        /**//// <summary>
        /// Gets or sets whether to allow new connections to be launched from this connector
        /// </summary>
        public bool AllowNewConnectionsFrom
        {
            get{return mAllowNewConnectionsFrom;}
            set{mAllowNewConnectionsFrom = value;}
        }

        /**//// <summary>
        /// Gets or sets whether to allow new connections to be attached to this connector
        /// </summary>
        public bool AllowNewConnectionsTo
        {
            get{return mAllowNewConnectionsTo;}
            set{mAllowNewConnectionsTo = value;}
        }
        /**//// <summary>
        /// Gets or sets the name of the connector.
        /// 
        /// </summary>
        /// <remarks>
        /// This property makes it possible to deserialize a connector, it\'s the only way to find back where a 
        /// serialized connector came from.
        /// </remarks>
        public string Name
        {
            get{return mName;}
            set{mName = value;}
        }

        /**//// <summary>
        /// Gets or sets the connection shift with respect to this connector.
        /// If the type is \'Omni\' it\'s an offset in the direction of the connection,
        /// otherwise it creates a little shift/break in the connection in the direction specified by the
        /// ConnectorLocation.
        /// </summary>
        public float ConnectionShift
        {
            get{return mConnectionShift;}
            set{mConnectionShift = value;}
        }

        /**//// <summary>
        /// The location of the connector
        /// </summary>
        public PointF Location
        {
            get{return mBelongsTo.ConnectionPoint(this);}
        }

        /**//// <summary>
        /// Gets or sets whether the connector can have multiple connection attached
        /// </summary>    
        public bool AllowMultipleConnections
        {
            get{return mAllowMultipleConnections;}
            [Browsable(false)] set{mAllowMultipleConnections = value;}
        }

        /**//// <summary>
        /// Gets the connections of a connector
        /// </summary>
        public ConnectionCollection Connections
        {
            get
            {
                return mConnections;
            }
        }

        /**//// <summary>
        /// The values/objects that the connector propagates
        /// </summary>
        public ArrayList Sends
        {
            get
            {
                return mSendList;
            }
//            [Browsable(false)] set
//            {
//                mSendList= value;
//            }
        }

        /**//// <summary>
        /// The values/objects that the connectors receives from other connectors
        /// </summary>
        public ArrayList Receives
        {
            get
            {
                return mReceiveList;
            }
//            [Browsable(false)]set
//            {
//                mReceiveList= value;
//            }
        }

        /**//// <summary>
        /// The get/Set the ShapeObjects this connector is attached to
        /// </summary>
        public Shape BelongsTo
        {
            get
            {
                return mBelongsTo;
            }
            [Browsable(false)] set
            {
                mBelongsTo = value;
            }
        }
        
        /**//// <summary>
        /// Gets or sets the adjacent point which allows to have a little distance between shapes and connections
        /// </summary>
        public PointF AdjacentPoint
        {
            get
            {
                
                PointF p = mBelongsTo.ConnectionPoint(this);
                switch(this.mConnectorLocation)
                {
                    case ConnectorLocation.North: this.mAdjacentPoint= new PointF(p.X,p.Y - mConnectionShift); break;
                    case ConnectorLocation.East: this.mAdjacentPoint= new PointF(p.X+mConnectionShift,p.Y); break;
                    case ConnectorLocation.South: this.mAdjacentPoint= new PointF(p.X,p.Y + mConnectionShift); break;
                    case ConnectorLocation.West: this.mAdjacentPoint= new PointF(p.X-mConnectionShift,p.Y); break;                    
                    case ConnectorLocation.Omni: case ConnectorLocation.Unknown: this.mAdjacentPoint= p; break;
                }

                
                return mAdjacentPoint;
            }
        }


        /**//// <summary>
        /// Gets or sets the location of the connector which will determine where the adjacent point will be
        /// </summary>
        public ConnectorLocation ConnectorLocation
        {
            get{return mConnectorLocation;}
            [Browsable(false)] set{mConnectorLocation = value;}
        }

        #endregion    
        
        Constructors#region Constructors
        /**//// <summary>
        /// Constructor of the connector clss
        /// </summary>
        /// <param name="o">the underlying shape to which the connector belongs</param>
        /// <param name="connectorName">the name of the connector</param>
        /// <param name="multipleConnections">whether the connector allows multiple connections to be added or connected to it</param>        
        public Connector(Shape o, string connectorName, bool multipleConnections) : base()
        {
            mBelongsTo = o;
            mName = Text = connectorName;
            mConnections = new ConnectionCollection();
            mSendList = new ArrayList();
            mReceiveList = new ArrayList();
            mAllowMultipleConnections = multipleConnections;                
        }

        /**//// <summary>
        /// Internal constructor, related to deserialization
        /// </summary>
        /// <param name="uid"></param>
        internal Connector(string uid) : base()
        {
            this.UID = new Guid(uid);
        }

        /**//// <summary>
        /// Deserialization constructor
        /// </summary>
        /// <param name="info"></param>
        /// <param name="context"></param>
        protected Connector(SerializationInfo info, StreamingContext context) : base(info, context)
        {
            this.mName = info.GetString("mName");

            this.mAllowMultipleConnections = info.GetBoolean("mAllowMultipleConnections");

            this.ConnectorLocation = (ConnectorLocation) info.GetValue("mConnectorLocation", typeof(ConnectorLocation));

            this.mConnectionShift = info.GetSingle("mConnectionShift");

            try
            {
                this.mAllowNewConnectionsFrom = info.GetBoolean("mAllowNewConnectionsFrom");
            }
            catch
            {
                this.mAllowNewConnectionsFrom = true;
            }
            try
            {
                this.mAllowNewConnectionsTo = info.GetBoolean("mAllowNewConnectionsTo");
            }
            catch
            {
                this.mAllowNewConnectionsTo = true;
            }

            mConnections = new ConnectionCollection();
            mSendList = new ArrayList();
            mReceiveList = new ArrayList();
        }
        #endregion

        Methods#region Methods

        /**//// <summary>
        /// Implements the abstract method of the Entity class
        /// </summary>
        /// <param name="g"></param>
        public override void PaintAdornments(Graphics g)
        {
            return;
        }

        /**//// <summary>
        /// Says wether the given RectangleF is contained inside this connector
        /// </summary>
        /// <param name="r">the RectangleF as a candidate, usually the mouse coordinates converted to a zero sized rectangle.</param>
        /// <returns>True/false</returns>
        public override bool Hit(RectangleF r)
        {
            if ((r.Width == 0) && (r.Height == 0))
                return ConnectionGrip().Contains(r.Location);

            return r.Contains(ConnectionGrip());
        }
        /**//// <summary>
        /// Overrides the Paint of the control and paint a little connection point or a highlighted connecting widget to 
        /// show the user that a connection is possible.
        /// </summary>
        /// <remarks>
        /// The parent\'s Hover boolean can be used to check if the mouse is currently hovering over this object. This enables a status message or a different shape.
        /// </remarks>
        /// <param name="g">The Graphics or canvas onto which to paint.</param>
        public override void Paint(Graphics g)
        {
            Rectangle r = Rectangle.Round(ConnectionGrip());
                
            Color Line = Color.White;
            if (IsHovered) Line = Color.Black;
      
            Color Fill = Color.FromArgb(49, 69, 107); // dark blue
            if (IsHovered)
            {
                
                if ((mAllowMultipleConnections) || (mConnections.Count < 1))
                    Fill = Color.FromArgb(0, 192, 0); // medium green
                else
                    Fill = Color.FromArgb(255, 0, 0); // red
            }

            g.FillRectangle(new SolidBrush(Fill), r);
            g.DrawRectangle(new Pen(Line, 1), r);

            /**//*This piece of code has been replaced by the tooltip
             * 
            if (IsHovered)
            {
                Font f = new Font("Tahoma", 8.25f);
                Size s = g.MeasureString(Text + " [" + this.Connections.Count + "]", f).ToSize();
                Rectangle a = new Rectangle(r.X - (s.Width / 2), r.Y + s.Height + 6, s.Width, s.Height + 1);
                Rectangle b = a;
                a.Inflate(+3, +2);
      
                g.FillRectangle(new SolidBrush(Color.FromArgb(255, 255, 231)), a);
                g.DrawRectangle(new Pen(Color.Black, 1), a);
                g.DrawString(Text + " [" + this.Connections.Count + "]", f, new SolidBrush(Color.Black), b.Location);
            }
            */

        }
        /**//// <summary>
        /// Necessary implementation of the abstract delete method defined in Entity
        /// </summary>
        protected internal override void Delete()
        {

        }

        /**//// <summary>
        /// Update/refresh the connector\'s appearance
        /// </summary>
        public override void Invalidate()
        {
            if (mBelongsTo == null) return;
            IGraphSite c = mBelongsTo.Site;//should return the underlying canvasobject
            if (c == null) return;
            RectangleF r = ConnectionGrip();//get the neighborhood of the connector
            if (IsHovered) r.Inflate(+100, +100); // make sure a sufficient piece of the neighborhood will be refreshed.
            c.Invalidate(Rectangle.Round(r)); //and refresh it by calling the control\'s invalidate method.
        }
        /**//// <summary>
        /// Returns the cursor for the current connector
        /// </summary>
        /// <param name="p">The cursor location</param>
        /// <returns>A grip cursor, looks like a focus/target</returns>
        public override Cursor GetCursor(PointF p)
        {
                
            return MouseCursors.Grip; 
        }
        /**//// <summary>
        /// Represents the spot around a connector that lits up and where the connections is attaching itself
        /// The color is determined by various things, can be red, grey or green. See the Hover conditions in the paint handler for this.
        /// </summary>
        /// <returns>A little rectangleF (3x3)</returns>
        public RectangleF ConnectionGrip()
        {
            PointF p = mBelongsTo.ConnectionPoint(this);
            RectangleF r = new RectangleF(p.X, p.Y, 0, 0);
            r.Inflate(+3, +3);
            return r;
        }


        
        #endregion

        ISerializable Members#region ISerializable Members

        /**//// <summary>
        /// ISerializable implementation
        /// </summary>
        /// <param name="info">the serialization info</param>
        /// <param name="context">the streaming context</param>
        [SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter=true)]
        public override void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            base.GetObjectData(info, context);

            info.AddValue("mName", this.mName);

            info.AddValue("mAllowMultipleConnections", this.mAllowMultipleConnections);

            info.AddValue("mConnectorLocation", this.mConnectorLocation,typeof(ConnectorLocation));

            info.AddValue("mConnectionShift", this.mConnectionShift, typeof(float));

            info.AddValue("mAllowNewConnectionsFrom", this.mAllowNewConnectionsFrom);

            info.AddValue("mAllowNewConnectionsTo", this.mAllowNewConnectionsTo);

        }

        #endregion
    }
}

 

     字段介绍：这里介绍有几个重要的字段：mBelongsTo 此字段作用是保存本点所属于那个shape,private  mConnections 此字段作用是保存本点所连接的所以connection,mAllowNewConnectionsFrom 此字段作用是确定本点是否允许新的线画出， mAllowNewConnectionsTo 此字段作用是是否允许新的线连入本点。

    方法暂不了解，有兴趣读者可以自己去看。