{

private const UInt32 WM_MOUSEHWHEEL = 0x020E;

protected static readonly Type m_type_node = typeof(STNode);

#region protected enum,struct --------------------------------------------------------------------------------------

protected enum CanvasAction //当前鼠标移动操作表示进行下列哪一个行为

{

None, //无

MoveNode, //正在移动 Node

ConnectOption, //正在连接 Option

SelectRectangle, //正在选择矩形区域

DrawMarkDetails //正在绘制标记信息详情

}

protected struct MagnetInfo

{

public bool XMatched; //X轴是否有磁铁匹配上

public bool YMatched;

public int X; //与X轴那个数字匹配上

public int Y;

public int OffsetX; //当前节点X位置与匹配上的X的相对偏移

public int OffsetY;

}

#endregion

#region Properties ------------------------------------------------------------------------------------------------------

private float _CanvasOffsetX;

/// <summary>

/// 获取画布原点相对于控件 X 方向上的偏移位置

/// </summary>

[Browsable(false)]

public float CanvasOffsetX {

get { return _CanvasOffsetX; }

}

private float _CanvasOffsetY;

/// <summary>

/// 获取画布原点相对于控件 Y 方向上的偏移位置

/// </summary>

[Browsable(false)]

public float CanvasOffsetY {

get { return _CanvasOffsetY; }

}

private PointF _CanvasOffset;

/// <summary>

/// 获取画布原点相对于控件偏移位置

/// </summary>

[Browsable(false)]

public PointF CanvasOffset {

get {

_CanvasOffset.X = _CanvasOffsetX;

_CanvasOffset.Y = _CanvasOffsetY;

return _CanvasOffset;

}

}

private Rectangle _CanvasValidBounds;

/// <summary>

/// 获取画布中的有被用到的有效区域

/// </summary>

[Browsable(false)]

public Rectangle CanvasValidBounds {

get { return _CanvasValidBounds; }

}

private float _CanvasScale = 1;

/// <summary>

/// 获取画布的缩放比例

/// </summary>

[Browsable(false)]

public float CanvasScale {

get { return _CanvasScale; }

}

private float _Curvature = 0.3F;

/// <summary>

/// 获取或设置 Option 之间连线的曲度

/// </summary>

[Browsable(false)]

public float Curvature {

get { return _Curvature; }

set {

if (value < 0) value = 0;

if (value > 1) value = 1;

_Curvature = value;

if (m_dic_gp_info.Count != 0) this.BuildLinePath();

}

}

private bool _ShowMagnet = true;

/// <summary>

/// 获取或设置移动画布中 Node 时候 是否启用磁铁效果

/// </summary>

[Description("获取或设置移动画布中 Node 时候 是否启用磁铁效果"), DefaultValue(true)]

public bool ShowMagnet {

get { return _ShowMagnet; }

set { _ShowMagnet = value; }

}

private bool _ShowBorder = true;

/// <summary>

/// 获取或设置 移动画布中是否显示 Node 边框

/// </summary>

[Description("获取或设置 移动画布中是否显示 Node 边框"), DefaultValue(true)]

public bool ShowBorder {

get { return _ShowBorder; }

set {

_ShowBorder = value;

this.Invalidate();

}

}

private bool _ShowGrid = true;

/// <summary>

/// 获取或设置画布中是否绘制背景网格线条

/// </summary>

[Description("获取或设置画布中是否绘制背景网格线条"), DefaultValue(true)]

public bool ShowGrid {

get { return _ShowGrid; }

set {

_ShowGrid = value;

this.Invalidate();

}

}

private bool _ShowLocation = true;

/// <summary>

/// 获取或设置是否在画布边缘显示超出视角的 Node 位置信息

/// </summary>

[Description("获取或设置是否在画布边缘显示超出视角的 Node 位置信息"), DefaultValue(true)]

public bool ShowLocation {

get { return _ShowLocation; }

set {

_ShowLocation = value;

this.Invalidate();

}

}

private STNodeCollection _Nodes;

/// <summary>

/// 获取画布中 Node 集合

/// </summary>

[Browsable(false)]

public STNodeCollection Nodes {

get {

return _Nodes;

}

}

private STNode _ActiveNode;

/// <summary>

/// 获取当前画布中被选中的活动 Node

/// </summary>

[Browsable(false)]

public STNode ActiveNode {

get { return _ActiveNode; }

//set {

// if (value == _ActiveSelectedNode) return;

// if (_ActiveSelectedNode != null) _ActiveSelectedNode.OnLostFocus(EventArgs.Empty);

// _ActiveSelectedNode = value;

// _ActiveSelectedNode.IsActive = true;

// this.Invalidate();

// this.OnSelectedChanged(EventArgs.Empty);

//}

}

private STNode _HoverNode;

/// <summary>

/// 获取当前画布中鼠标悬停的 Node

/// </summary>

[Browsable(false)]

public STNode HoverNode {

get { return _HoverNode; }

}

//========================================color================================

private Color _GridColor = Color.Black;

/// <summary>

/// 获取或设置绘制画布背景时 网格线条颜色

/// </summary>

[Description("获取或设置绘制画布背景时 网格线条颜色"), DefaultValue(typeof(Color), "Black")]

public Color GridColor {

get { return _GridColor; }

set {

_GridColor = value;

this.Invalidate();

}

}

private Color _BorderColor = Color.Black;

/// <summary>

/// 获取或设置画布中 Node 边框颜色

/// </summary>

[Description("获取或设置画布中 Node 边框颜色"), DefaultValue(typeof(Color), "Black")]

public Color BorderColor {

get { return _BorderColor; }

set {

_BorderColor = value;

if (m_img_border != null) m_img_border.Dispose();

m_img_border = this.CreateBorderImage(value);

this.Invalidate();

}

}

private Color _BorderHoverColor = Color.Gray;

/// <summary>

/// 获取或设置画布中悬停 Node 边框颜色

/// </summary>

[Description("获取或设置画布中悬停 Node 边框颜色"), DefaultValue(typeof(Color), "Gray")]

public Color BorderHoverColor {

get { return _BorderHoverColor; }

set {

_BorderHoverColor = value;

if (m_img_border_hover != null) m_img_border_hover.Dispose();

m_img_border_hover = this.CreateBorderImage(value);

this.Invalidate();

}

}

private Color _BorderSelectedColor = Color.Orange;

/// <summary>

/// 获取或设置画布中选中 Node 边框颜色

/// </summary>

[Description("获取或设置画布中选中 Node 边框颜色"), DefaultValue(typeof(Color), "Orange")]

public Color BorderSelectedColor {

get { return _BorderSelectedColor; }

set {

_BorderSelectedColor = value;

if (m_img_border_selected != null) m_img_border_selected.Dispose();

m_img_border_selected = this.CreateBorderImage(value);

this.Invalidate();

}

}

private Color _BorderActiveColor = Color.OrangeRed;

/// <summary>

/// 获取或设置画布中活动 Node 边框颜色

/// </summary>

[Description("获取或设置画布中活动 Node 边框颜色"), DefaultValue(typeof(Color), "OrangeRed")]

public Color BorderActiveColor {

get { return _BorderActiveColor; }

set {

_BorderActiveColor = value;

if (m_img_border_active != null) m_img_border_active.Dispose();

m_img_border_active = this.CreateBorderImage(value);

this.Invalidate();

}

}

private Color _MarkForeColor = Color.White;

/// <summary>

/// 获取或设置画布绘制 Node 标记详情采用的前景色

/// </summary>

[Description("获取或设置画布绘制 Node 标记详情采用的前景色"), DefaultValue(typeof(Color), "White")]

public Color MarkForeColor {

get { return _MarkBackColor; }

set {

_MarkBackColor = value;

this.Invalidate();

}

}

private Color _MarkBackColor = Color.FromArgb(180, Color.Black);

/// <summary>

/// 获取或设置画布绘制 Node 标记详情采用的背景色

/// </summary>

[Description("获取或设置画布绘制 Node 标记详情采用的背景色")]

public Color MarkBackColor {

get { return _MarkBackColor; }

set {

_MarkBackColor = value;

this.Invalidate();

}

}

private Color _MagnetColor = Color.Lime;

/// <summary>

/// 获取或设置画布中移动 Node 时候 磁铁标记颜色

/// </summary>

[Description("获取或设置画布中移动 Node 时候 磁铁标记颜色"), DefaultValue(typeof(Color), "Lime")]

public Color MagnetColor {

get { return _MagnetColor; }

set { _MagnetColor = value; }

}

private Color _SelectedRectangleColor = Color.DodgerBlue;

/// <summary>

/// 获取或设置画布中选择矩形区域的颜色

/// </summary>

[Description("获取或设置画布中选择矩形区域的颜色"), DefaultValue(typeof(Color), "DodgerBlue")]

public Color SelectedRectangleColor {

get { return _SelectedRectangleColor; }

set { _SelectedRectangleColor = value; }

}

private Color _HighLineColor = Color.Cyan;

/// <summary>

/// 获取或设置画布中高亮连线的颜色

/// </summary>

[Description("获取或设置画布中高亮连线的颜色"), DefaultValue(typeof(Color), "Cyan")]

public Color HighLineColor {

get { return _HighLineColor; }

set { _HighLineColor = value; }

}

private Color _LocationForeColor = Color.Red;

/// <summary>

/// 获取或设置画布中边缘位置提示区域前景色

/// </summary>

[Description("获取或设置画布中边缘位置提示区域前景色"), DefaultValue(typeof(Color), "Red")]

public Color LocationForeColor {

get { return _LocationForeColor; }

set {

_LocationForeColor = value;

this.Invalidate();

}

}

private Color _LocationBackColor = Color.FromArgb(120, Color.Black);

/// <summary>

/// 获取或设置画布中边缘位置提示区域背景色

/// </summary>

[Description("获取或设置画布中边缘位置提示区域背景色")]

public Color LocationBackColor {

get { return _LocationBackColor; }

set {

_LocationBackColor = value;

this.Invalidate();

}

}

private Color _UnknownTypeColor = Color.Gray;

/// <summary>

/// 获取或设置画布中当 Node 中 Option 数据类型无法确定时应当使用的颜色

/// </summary>

[Description("获取或设置画布中当 Node 中 Option 数据类型无法确定时应当使用的颜色"), DefaultValue(typeof(Color), "Gray")]

public Color UnknownTypeColor {

get { return _UnknownTypeColor; }

set {

_UnknownTypeColor = value;

this.Invalidate();

}

}

private Dictionary<Type, Color> _TypeColor = new Dictionary<Type, Color>();

/// <summary>

/// 获取或设置画布中 Node 中 Option 数据类型预设颜色

/// </summary>

[Browsable(false)]

public Dictionary<Type, Color> TypeColor {

get { return _TypeColor; }

}

#endregion

#region protected properties ----------------------------------------------------------------------------------------

/// <summary>

/// 当前鼠标在控件中的实时位置

/// </summary>

protected Point m_pt_in_control;

/// <summary>

/// 当前鼠标在画布中的实时位置

/// </summary>

protected PointF m_pt_in_canvas;

/// <summary>

/// 鼠标点击时在控件上的位置

/// </summary>

protected Point m_pt_down_in_control;

/// <summary>

/// 鼠标点击时在画布中的位置

/// </summary>

protected PointF m_pt_down_in_canvas;

/// <summary>

/// 用于鼠标点击移动画布时候 鼠标点下时候的画布坐标位置

/// </summary>

protected PointF m_pt_canvas_old;

/// <summary>

/// 用于保存连线过程中保存点下 Option 的起点坐标

/// </summary>

protected Point m_pt_dot_down;

/// <summary>

/// 用于保存连线过程中鼠标点下的起点Option 当MouseUP时候 确定是否连接此节点

/// </summary>

protected STNodeOption m_option_down;

/// <summary>

/// 当前鼠标点下的 STNode

/// </summary>

protected STNode m_node_down;

/// <summary>

/// 当前鼠标是否位于控件中

/// </summary>

protected bool m_mouse_in_control;

#endregion

public STNodeEditor() {

this.SetStyle(ControlStyles.UserPaint, true);

this.SetStyle(ControlStyles.ResizeRedraw, true);

this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);

this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);

this.SetStyle(ControlStyles.SupportsTransparentBackColor, true);

this._Nodes = new STNodeCollection(this);

this.BackColor = Color.FromArgb(255, 34, 34, 34);

this.MinimumSize = new Size(100, 100);

this.Size = new Size(200, 200);

this.AllowDrop = true;

m_real_canvas_x = this._CanvasOffsetX = 10;

m_real_canvas_y = this._CanvasOffsetY = 10;

}

#region private fields --------------------------------------------------------------------------------------

private DrawingTools m_drawing_tools;

private NodeFindInfo m_find = new NodeFindInfo();

private MagnetInfo m_mi = new MagnetInfo();

private RectangleF m_rect_select = new RectangleF();

//节点边框预设图案

private Image m_img_border;

private Image m_img_border_hover;

private Image m_img_border_selected;

private Image m_img_border_active;

//用于鼠标滚动或者触摸板移动画布时候的动画效果 该值为需要移动到的真实坐标地址 查看->MoveCanvasThread()

private float m_real_canvas_x;

private float m_real_canvas_y;

//用于移动节点时候 保存鼠标点下时候选中的节点初始坐标

private Dictionary<STNode, Point> m_dic_pt_selected = new Dictionary<STNode, Point>();

//用于磁铁效果 移动节点时候 非选择节点的统计出来的需要参与磁铁效果的坐标 查看->BuildMagnetLocation()

private List<int> m_lst_magnet_x = new List<int>();

private List<int> m_lst_magnet_y = new List<int>();

//用于磁铁效果 移动节点时候 活动选择节点统计出来需要参与磁铁效果的坐标 查看->CheckMagnet()

private List<int> m_lst_magnet_mx = new List<int>();

private List<int> m_lst_magnet_my = new List<int>();

//用于鼠标滚动中计算时间触发间隔 根据间隔不同 画布产生的位移不同 查看->OnMouseWheel(),OnMouseHWheel()

private DateTime m_dt_vw = DateTime.Now;

private DateTime m_dt_hw = DateTime.Now;

//移动鼠标过程中的当前行为

private CanvasAction m_ca;

//保存已选中的节点

private HashSet<STNode> m_hs_node_selected = new HashSet<STNode>();

private bool m_is_process_mouse_event = true; //是否向下(Node or NodeControls)传递鼠标相关事件 如断开连接相关操作不应向下传递

private bool m_is_buildpath; //用于重绘过程中 判断该次是否要重新建立缓存连线的路径

private Pen m_p_line = new Pen(Color.Cyan, 2f); //用于绘制已经连接的线条

private Pen m_p_line_hover = new Pen(Color.Cyan, 4f); //用于绘制鼠标悬停时候的线条

private GraphicsPath m_gp_hover; //当前鼠标悬停的连线路径

private StringFormat m_sf = new StringFormat(); //文本格式 用于Mark绘制时候 设置文本格式

//保存每个连接线条与之对应的节点关系

private Dictionary<GraphicsPath, ConnectionInfo> m_dic_gp_info = new Dictionary<GraphicsPath, ConnectionInfo>();

//保存超出视觉区域的 Node 的位置

private List<Point> m_lst_node_out = new List<Point>();

//当前编辑器已加载的 Node 类型 用于从文件或者数据中加载节点使用

private Dictionary<string, Type> m_dic_type = new Dictionary<string, Type>();

private int m_time_alert;

private int m_alpha_alert;

private string m_str_alert;

private Color m_forecolor_alert;

private Color m_backcolor_alert;

private DateTime m_dt_alert;

private Rectangle m_rect_alert;

private AlertLocation m_al;

#endregion

#region event ----------------------------------------------------------------------------------------------------

/// <summary>

/// 活动的节点发生变化时候发生

/// </summary>

[Description("活动的节点发生变化时候发生")]

public event EventHandler ActiveChanged;

/// <summary>

/// 选择的节点发生变化时候发生

/// </summary>

[Description("选择的节点发生变化时候发生")]

public event EventHandler SelectedChanged;

/// <summary>

/// 悬停的节点发生变化时候发生

/// </summary>

[Description("悬停的节点发生变化时候发生")]

public event EventHandler HoverChanged;

/// <summary>

/// 当节点被添加时候发生

/// </summary>

[Description("当节点被添加时候发生")]

public event STNodeEditorEventHandler NodeAdded;

/// <summary>

/// 当节点被移除时候发生

/// </summary>

[Description("当节点被移除时候发生")]

public event STNodeEditorEventHandler NodeRemoved;

/// <summary>

/// 移动画布原点时候发生

/// </summary>

[Description("移动画布原点时候发生")]

public event EventHandler CanvasMoved;

/// <summary>

/// 缩放画布时候发生

/// </summary>

[Description("缩放画布时候发生")]

public event EventHandler CanvasScaled;

/// <summary>

/// 连接节点选项时候发生

/// </summary>

[Description("连接节点选项时候发生")]

public event STNodeEditorOptionEventHandler OptionConnected;

/// <summary>

/// 正在连接节点选项时候发生

/// </summary>

[Description("正在连接节点选项时候发生")]

public event STNodeEditorOptionEventHandler OptionConnecting;

/// <summary>

/// 断开节点选项时候发生

/// </summary>

[Description("断开节点选项时候发生")]

public event STNodeEditorOptionEventHandler OptionDisConnected;

/// <summary>

/// 正在断开节点选项时候发生

/// </summary>

[Description("正在断开节点选项时候发生")]

public event STNodeEditorOptionEventHandler OptionDisConnecting;

protected virtual internal void OnSelectedChanged(EventArgs e) {

if (this.SelectedChanged != null) this.SelectedChanged(this, e);

}

protected virtual void OnActiveChanged(EventArgs e) {

if (this.ActiveChanged != null) this.ActiveChanged(this, e);

}

protected virtual void OnHoverChanged(EventArgs e) {

if (this.HoverChanged != null) this.HoverChanged(this, e);

}

protected internal virtual void OnNodeAdded(STNodeEditorEventArgs e) {

if (this.NodeAdded != null) this.NodeAdded(this, e);

}

protected internal virtual void OnNodeRemoved(STNodeEditorEventArgs e) {

if (this.NodeRemoved != null) this.NodeRemoved(this, e);

}

protected virtual void OnCanvasMoved(EventArgs e) {

if (this.CanvasMoved != null) this.CanvasMoved(this, e);

}

protected virtual void OnCanvasScaled(EventArgs e) {

if (this.CanvasScaled != null) this.CanvasScaled(this, e);

}

protected internal virtual void OnOptionConnected(STNodeEditorOptionEventArgs e) {

if (this.OptionConnected != null) this.OptionConnected(this, e);

}

protected internal virtual void OnOptionDisConnected(STNodeEditorOptionEventArgs e) {

if (this.OptionDisConnected != null) this.OptionDisConnected(this, e);

}

protected internal virtual void OnOptionConnecting(STNodeEditorOptionEventArgs e) {

if (this.OptionConnecting != null) this.OptionConnecting(this, e);

}

protected internal virtual void OnOptionDisConnecting(STNodeEditorOptionEventArgs e) {

if (this.OptionDisConnecting != null) this.OptionDisConnecting(this, e);

}

#endregion event

#region override -----------------------------------------------------------------------------------------------------

protected override void OnCreateControl() {

m_drawing_tools = new DrawingTools() {

Pen = new Pen(Color.Black, 1),

SolidBrush = new SolidBrush(Color.Black)

};

m_img_border = this.CreateBorderImage(this._BorderColor);

m_img_border_active = this.CreateBorderImage(this._BorderActiveColor);

m_img_border_hover = this.CreateBorderImage(this._BorderHoverColor);

m_img_border_selected = this.CreateBorderImage(this._BorderSelectedColor);

base.OnCreateControl();

new Thread(this.MoveCanvasThread) { IsBackground = true }.Start();

new Thread(this.ShowAlertThread) { IsBackground = true }.Start();

m_sf = new StringFormat();

m_sf.Alignment = StringAlignment.Near;

m_sf.FormatFlags = StringFormatFlags.NoWrap;

m_sf.SetTabStops(0, new float[] { 40 });

}

protected override void WndProc(ref Message m) {

base.WndProc(ref m);

try {

Point pt = new Point(((int)m.LParam) >> 16, (ushort)m.LParam);

pt = this.PointToClient(pt);

if (m.Msg == WM_MOUSEHWHEEL) { //获取水平滚动消息

MouseButtons mb = MouseButtons.None;

int n = (ushort)m.WParam;

if ((n & 0x0001) == 0x0001) mb |= MouseButtons.Left;

if ((n & 0x0010) == 0x0010) mb |= MouseButtons.Middle;

if ((n & 0x0002) == 0x0002) mb |= MouseButtons.Right;

if ((n & 0x0020) == 0x0020) mb |= MouseButtons.XButton1;

if ((n & 0x0040) == 0x0040) mb |= MouseButtons.XButton2;

this.OnMouseHWheel(new MouseEventArgs(mb, 0, pt.X, pt.Y, ((int)m.WParam) >> 16));

}

} catch { /*add code*/ }

}

protected override void OnPaint(PaintEventArgs e) {

base.OnPaint(e);

Graphics g = e.Graphics;

g.Clear(this.BackColor);

g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.ClearTypeGridFit;

m_drawing_tools.Graphics = g;

SolidBrush brush = m_drawing_tools.SolidBrush;

if (this._ShowGrid) this.OnDrawGrid(m_drawing_tools, this.Width, this.Height);

g.TranslateTransform(this._CanvasOffsetX, this._CanvasOffsetY); //移动坐标系

g.ScaleTransform(this._CanvasScale, this._CanvasScale); //缩放绘图表面

this.OnDrawConnectedLine(m_drawing_tools);

this.OnDrawNode(m_drawing_tools, this.ControlToCanvas(this.ClientRectangle));

if (m_ca == CanvasAction.ConnectOption) { //如果正在连线

m_drawing_tools.Pen.Color = this._HighLineColor;

g.SmoothingMode = SmoothingMode.HighQuality;

if (m_option_down.IsInput)

this.DrawBezier(g, m_drawing_tools.Pen, m_pt_in_canvas, m_pt_dot_down, this._Curvature);

else

this.DrawBezier(g, m_drawing_tools.Pen, m_pt_dot_down, m_pt_in_canvas, this._Curvature);

}

//重置绘图坐标 我认为除了节点以外的其它 修饰相关的绘制不应该在Canvas坐标系中绘制 而应该使用控件的坐标进行绘制 不然会受到缩放比影响

g.ResetTransform();

switch (m_ca) {

case CanvasAction.MoveNode: //移动过程中 绘制对齐参考线

if (this._ShowMagnet && this._ActiveNode != null) this.OnDrawMagnet(m_drawing_tools, m_mi);

break;

case CanvasAction.SelectRectangle: //绘制矩形选取

this.OnDrawSelectedRectangle(m_drawing_tools, this.CanvasToControl(m_rect_select));

break;

case CanvasAction.DrawMarkDetails: //绘制标记信息详情

if (!string.IsNullOrEmpty(m_find.Mark)) this.OnDrawMark(m_drawing_tools);

break;

}

if (this._ShowLocation) this.OnDrawNodeOutLocation(m_drawing_tools, this.Size, m_lst_node_out);

this.OnDrawAlert(g);

}

protected override void OnMouseDown(MouseEventArgs e) {

base.OnMouseDown(e);

this.Focus();

m_ca = CanvasAction.None;

m_mi.XMatched = m_mi.YMatched = false;

m_pt_down_in_control = e.Location;

m_pt_down_in_canvas.X = ((e.X - this._CanvasOffsetX) / this._CanvasScale);

m_pt_down_in_canvas.Y = ((e.Y - this._CanvasOffsetY) / this._CanvasScale);

m_pt_canvas_old.X = this._CanvasOffsetX;

m_pt_canvas_old.Y = this._CanvasOffsetY;

if (m_gp_hover != null && e.Button == MouseButtons.Right) { //断开连接

this.DisConnectionHover();

m_is_process_mouse_event = false; //终止MouseClick与MouseUp向下传递

return;

}

NodeFindInfo nfi = this.FindNodeFromPoint(m_pt_down_in_canvas);

if (!string.IsNullOrEmpty(nfi.Mark)) { //如果点下的是标记信息

m_ca = CanvasAction.DrawMarkDetails;

this.Invalidate();

return;

}

if (nfi.NodeOption != null) { //如果点下的Option的连接点

this.StartConnect(nfi.NodeOption);

return;

}

if (nfi.Node != null) {

nfi.Node.OnMouseDown(new MouseEventArgs(e.Button, e.Clicks, (int)m_pt_down_in_canvas.X - nfi.Node.Left, (int)m_pt_down_in_canvas.Y - nfi.Node.Top, e.Delta));

bool bCtrlDown = (Control.ModifierKeys & Keys.Control) == Keys.Control;

if (bCtrlDown) {

if (nfi.Node.IsSelected) {

if (nfi.Node == this._ActiveNode) {

this.SetActiveNode(null);

}

} else {

nfi.Node.SetSelected(true, true);

}

return;

} else if (!nfi.Node.IsSelected) {

foreach (var n in m_hs_node_selected.ToArray()) n.SetSelected(false, false);

}

nfi.Node.SetSelected(true, false); //添加到已选择节点

this.SetActiveNode(nfi.Node);

if (this.PointInRectangle(nfi.Node.TitleRectangle, m_pt_down_in_canvas.X, m_pt_down_in_canvas.Y)) {

if (e.Button == MouseButtons.Right) {

if (nfi.Node.ContextMenuStrip != null) {

nfi.Node.ContextMenuStrip.Show(this.PointToScreen(e.Location));

}

} else {

m_dic_pt_selected.Clear();

lock (m_hs_node_selected) {

foreach (STNode n in m_hs_node_selected) //记录已选择节点位置 如果需要移动已选中节点时候 将会有用

m_dic_pt_selected.Add(n, n.Location);

}

m_ca = CanvasAction.MoveNode; //如果点下的是节点的标题 则可以移动该节点

if (this._ShowMagnet && this._ActiveNode != null) this.BuildMagnetLocation(); //建立磁铁需要的坐标 如果需要移动已选中节点时候 将会有用

}

} else

m_node_down = nfi.Node;

} else {

this.SetActiveNode(null);

foreach (var n in m_hs_node_selected.ToArray()) n.SetSelected(false, false);//没有点下任何东西 清空已经选择节点

m_ca = CanvasAction.SelectRectangle; //进入矩形区域选择模式

m_rect_select.Width = m_rect_select.Height = 0;

m_node_down = null;

}

//this.SetActiveNode(nfi.Node);

}

protected override void OnMouseMove(MouseEventArgs e) {

base.OnMouseMove(e);

m_pt_in_control = e.Location;

m_pt_in_canvas.X = ((e.X - this._CanvasOffsetX) / this._CanvasScale);

m_pt_in_canvas.Y = ((e.Y - this._CanvasOffsetY) / this._CanvasScale);

if (m_node_down != null) {

m_node_down.OnMouseMove(new MouseEventArgs(e.Button, e.Clicks,

(int)m_pt_in_canvas.X - m_node_down.Left,

(int)m_pt_in_canvas.Y - m_node_down.Top, e.Delta));

return;

}

if (e.Button == MouseButtons.Middle) { //鼠标中键移动画布

this._CanvasOffsetX = m_real_canvas_x = m_pt_canvas_old.X + (e.X - m_pt_down_in_control.X);

this._CanvasOffsetY = m_real_canvas_y = m_pt_canvas_old.Y + (e.Y - m_pt_down_in_control.Y);

this.Invalidate();

return;

}

if (e.Button == MouseButtons.Left) { //如果鼠标左键点下 判断行为

m_gp_hover = null;

switch (m_ca) {

case CanvasAction.MoveNode: this.MoveNode(e.Location); return; //当前移动节点

case CanvasAction.ConnectOption: this.Invalidate(); return; //当前正在连线

case CanvasAction.SelectRectangle: //当前正在选取

m_rect_select.X = m_pt_down_in_canvas.X < m_pt_in_canvas.X ? m_pt_down_in_canvas.X : m_pt_in_canvas.X;

m_rect_select.Y = m_pt_down_in_canvas.Y < m_pt_in_canvas.Y ? m_pt_down_in_canvas.Y : m_pt_in_canvas.Y;

m_rect_select.Width = Math.Abs(m_pt_in_canvas.X - m_pt_down_in_canvas.X);

m_rect_select.Height = Math.Abs(m_pt_in_canvas.Y - m_pt_down_in_canvas.Y);

foreach (STNode n in this._Nodes) {

n.SetSelected(m_rect_select.IntersectsWith(n.Rectangle), false);

}

this.Invalidate();

return;

}

}

//若不存在行为 则判断鼠标下方是否存在其他对象

NodeFindInfo nfi = this.FindNodeFromPoint(m_pt_in_canvas);

bool bRedraw = false;

if (this._HoverNode != nfi.Node) { //鼠标悬停到Node上

if (nfi.Node != null) nfi.Node.OnMouseEnter(EventArgs.Empty);

if (this._HoverNode != null)

this._HoverNode.OnMouseLeave(new MouseEventArgs(e.Button, e.Clicks,

(int)m_pt_in_canvas.X - this._HoverNode.Left,

(int)m_pt_in_canvas.Y - this._HoverNode.Top, e.Delta));

this._HoverNode = nfi.Node;

this.OnHoverChanged(EventArgs.Empty);

bRedraw = true;

}

if (this._HoverNode != null) {

this._HoverNode.OnMouseMove(new MouseEventArgs(e.Button, e.Clicks,

(int)m_pt_in_canvas.X - this._HoverNode.Left,

(int)m_pt_in_canvas.Y - this._HoverNode.Top, e.Delta));

m_gp_hover = null;

} else {