using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Xml;
using Newtonsoft.Json;
namespace Vision.Controls
{
#region 基础接口定义
public interface IDrawable
{
Rectangle Bounds { get; }
void Draw
(Graphics g
);
event EventHandler StyleChanged;
}
public interface IPlugin
{
string Name { get; }
VisualElement CreateElement
();
}
public interface ICommand
{
void Execute
();
void Undo
();
}
public interface ISerializer
{
string Format { get; }
string Serialize
(WorkflowCanvas canvas
);
void Deserialize
(WorkflowCanvas canvas, string data
);
}
#endregion
#region 核心实体类
public class Port
{
public string Name { get; set; }
public PortType Type { get; set; }
public Point Position { get; set; } // 相对于节点的偏移
public Port ConnectedPort { get; set; } // 连接的目标端口
public VisualElement Parent { get; set; } // 所属元素
public Point ScreenPosition
{
get
{
// 确保 Parent 已初始化，且 Bounds 有效
if
(Parent == null
) return Position;
return new Point
(
Parent.Bounds.X + Position.X, // 用 Bounds（逻辑坐标）替代 Location
Parent.Bounds.Y + Position.Y
);
}
}
}
public enum PortType { Input, Output }
public abstract class VisualElement : UserControl, IDrawable
{
public virtual Rectangle Bounds {
get
{
scale = WorkflowCanvas.Instance.Scale;
return new Rectangle
(
(int
)(LogicLocation.X * scale
),
(int
)(LogicLocation.Y * scale
),
(int
)(LogicSize.Width * scale
),
(int
)(LogicSize.Height * scale
)
);
}
}
public abstract void Draw
(Graphics g
);
public event EventHandler StyleChanged;
public virtual string Title { get; set; } = "DefaultTitle";
protected void OnStyleChanged
() => StyleChanged?.Invoke
(this, EventArgs.Empty
);
public bool IsSelected { get; set; } = false;
public Point LogicLocation { get; set; } = new Point
(0, 0
);
public Size LogicSize { get; set; } = new Size
(100, 50
);
public float scale {get; set; }
// 新增：Z轴层级（值越大越靠前）
public int ZIndex { get; set; } = 0;
[Browsable
(false
)]
public new Point Location
{
get => LogicLocation;
set => LogicLocation = value;
}
[Browsable
(false
)]
public new Size Size
{
get => LogicSize;
set => LogicSize = value;
}
}
public class Connection : IDrawable
{
public Port StartPort { get; set; }
public Port EndPort { get; set; }
public Point StartPosition { get; set; } // 临时连接起点
public Point EndPosition { get; set; } // 临时连接终点
public Rectangle Bounds
{
get
{
if
(StartPort != null && EndPort != null
)
{
var minX = Math.Min
(StartPort.ScreenPosition.X, EndPort.ScreenPosition.X
);
var maxX = Math.Max
(StartPort.ScreenPosition.X, EndPort.ScreenPosition.X
);
var minY = Math.Min
(StartPort.ScreenPosition.Y, EndPort.ScreenPosition.Y
);
var maxY = Math.Max
(StartPort.ScreenPosition.Y, EndPort.ScreenPosition.Y
);
return new Rectangle
(minX - 10, minY - 10, maxX - minX + 20, maxY - minY + 20
);
}
return new Rectangle
(StartPosition.X, StartPosition.Y,
EndPosition.X - StartPosition.X, EndPosition.Y - StartPosition.Y
);
}
}
public void Draw
(Graphics g
)
{
var scale = WorkflowCanvas.Instance.Scale;
g.ScaleTransform
(scale, scale
); // 应用画布缩放
Point start = StartPort?.ScreenPosition ?? StartPosition;
Point end = EndPort?.ScreenPosition ?? EndPosition;
g.DrawLine
(Pens.Black, start, end
);
// 绘制箭头（末端）
DrawArrow
(g, end, start
);
}
private void DrawArrow
(Graphics g, Point end, Point start
)
{
// 计算箭头方向（从 start 到 end 的向量）
float dx = end.X - start.X;
float dy = end.Y - start.Y;
float angle =
(float
)Math.Atan2
(dy, dx
);
int arrowSize =
(int
)(10 * WorkflowCanvas.Instance.Scale
); // 箭头大小适配缩放
// 计算箭头的两个侧点
Point arrowPoint1 = new Point
(
(int
)(end.X - arrowSize * Math.Cos
(angle - Math.PI / 6
)),
(int
)(end.Y - arrowSize * Math.Sin
(angle - Math.PI / 6
))
);
Point arrowPoint2 = new Point
(
(int
)(end.X - arrowSize * Math.Cos
(angle + Math.PI / 6
)),
(int
)(end.Y - arrowSize * Math.Sin
(angle + Math.PI / 6
))
);
// 绘制箭头（填充三角形）
g.FillPolygon
(Brushes.Black, new Point[] { end, arrowPoint1, arrowPoint2 }
);
}
public event EventHandler StyleChanged;
}
public partial class VisionNode : VisualElement
{
public string Title { get; set; } = "Node";
public List<Port> InputPorts { get; } = new List<Port>
();
public List<Port> OutputPorts { get; } = new List<Port>
();
public IDictionary<string, object> Parameters { get; set; } = new Dictionary<string, object>
();
public bool IsSelected { get; set; }
public override Rectangle Bounds => new Rectangle
(Location, Size
);
public VisionNode
()
{
DoubleBuffered = true;
Size = new Size
(100, 50
);
BackColor = Color.Transparent;
InputPorts.Add
(new Port { Name = "In1", Type = PortType.Input, Position = new Point
(Size.Width/2, this.Location.Y
), Parent = this }
);
OutputPorts.Add
(new Port { Name = "Out1", Type = PortType.Output, Position = new Point
(Size.Width / 2,this.Location.Y+ Size.Height
), Parent = this }
);
}
public override void Draw
(Graphics g
)
{
// 绘制节点框等其他内容（可再处理缩放）
var pen = StyleManager.Instance.NodeBorderPen;
g.DrawRectangle
(pen, Bounds
);
// 若有全局缩放，先重置变换（避免文字被缩放影响）
g.ResetTransform
();
// 保存原始 Graphics 状态
var state = g.Save
();
var font = StyleManager.Instance.NodeFont;
// 用物理坐标绘制文字（假设 _scale 是画布缩放因子）
SizeF textSize = g.MeasureString
(Title, font
);
var physicalX = Bounds.X +
(Bounds.Width - textSize.Width
) / 2;
var physicalY = Bounds.Y +
(Bounds.Height - textSize.Height
) / 2;
g.DrawString
(Title, font, Brushes.Black, new PointF
(physicalX, physicalY
));
g.Restore
(state
);
}
protected override void OnLocationChanged
(EventArgs e
)
{
base.OnLocationChanged
(e
);
OnStyleChanged
();
}
}
#endregion
#region 性能优化模块
public class QuadTree
{
private readonly Rectangle _bounds;
private List<IDrawable> _objects = new List<IDrawable>
();
private QuadTree[] _children;
private const int MAX_OBJECTS = 10;
private const int MIN_SIZE = 100;
public QuadTree
(Rectangle bounds
) => _bounds = bounds;
public Rectangle Bounds => _bounds;
public void Insert
(IDrawable obj
)
{
if
(_children != null
)
{
int index = GetChildIndex
(obj.Bounds
);
if
(index != -1
)
{
_children[index].Insert
(obj
);
return;
}
}
_objects.Add
(obj
);
if
(_objects.Count > MAX_OBJECTS && _bounds.Width > MIN_SIZE
)
{
Subdivide
();
var objs = new List<IDrawable>
(_objects
);
_objects.Clear
();
foreach
(var o in objs
)
{
int index = GetChildIndex
(o.Bounds
);
if
(index != -1
) _children[index].Insert
(o
);
else _objects.Add
(o
);
}
}
}
private void Subdivide
()
{
int x = _bounds.X, y = _bounds.Y;
int w = _bounds.Width / 2, h = _bounds.Height / 2;
_children = new QuadTree[4]
{
new QuadTree
(new Rectangle
(x, y, w, h
)),
new QuadTree
(new Rectangle
(x + w, y, w, h
)),
new QuadTree
(new Rectangle
(x, y + h, w, h
)),
new QuadTree
(new Rectangle
(x + w, y + h, w, h
))
};
}
private int GetChildIndex
(Rectangle bounds
)
{
if
(_children == null
) return -1;
int midX = _bounds.X + _bounds.Width / 2;
int midY = _bounds.Y + _bounds.Height / 2;
bool top = bounds.Y < midY;
bool bottom = bounds.Bottom > midY;
bool left = bounds.X < midX;
bool right = bounds.Right > midX;
if
(top && left
) return 0;
if
(top && right
) return 1;
if
(bottom && left
) return 2;
if
(bottom && right
) return 3;
return -1;
}
public void Clear
()
{
_objects.Clear
();
if
(_children != null
)
{
for
(int i = 0; i < _children.Length; i++
)
{
_children[i].Clear
();
_children[i] = null;
}
_children = null;
}
}
public List<IDrawable> Query
(Rectangle area
)
{
var result = new List<IDrawable>
();
if
(!_bounds.IntersectsWith
(area
)) return result;
result.AddRange
(_objects.Where
(o => o.Bounds.IntersectsWith
(area
)));
if
(_children != null
)
{
foreach
(var child in _children
)
result.AddRange
(child.Query
(area
));
}
return result;
}
public void Query
(List<IDrawable> result, Rectangle area
)
{
if
(!_bounds.IntersectsWith
(area
)) return;
result.AddRange
(_objects.Where
(o => o.Bounds.IntersectsWith
(area
)));
if
(_children != null
)
{
foreach
(var child in _children
)
{
child.Query
(result, area
);
}
}
}
}
// 增强 ForceDirectedLayout 类
public class ForceDirectedLayout
{
private const float Repulsion = 10000f; // 排斥力强度
private const float Attraction = 0.1f; // 吸引力强度
private const float Damping = 0.9f; // 阻尼系数
private const int MaxIterations = 50; // 最大迭代次数
// 存储节点速度
private Dictionary<VisualElement, PointF> _velocities = new Dictionary<VisualElement, PointF>
();
public void Layout
(IEnumerable<VisualElement> nodes, IEnumerable<Connection> connections
)
{
var nodeList = nodes.ToList
();
InitializeVelocities
(nodeList
);
// 迭代计算力和位置
for
(int i = 0; i < MaxIterations; i++
)
{
ApplyForces
(nodeList, connections
);
UpdatePositions
(nodeList
);
}
}
private void InitializeVelocities
(List<VisualElement> nodes
)
{
_velocities.Clear
();
foreach
(var node in nodes
)
{
_velocities[node] = new PointF
(0, 0
);
}
}
private void ApplyForces
(List<VisualElement> nodes, IEnumerable<Connection> connections
)
{
// 计算节点间排斥力
foreach
(var node in nodes
)
{
foreach
(var other in nodes.Where
(n => n != node
))
{
float dx = node.LogicLocation.X - other.LogicLocation.X;
float dy = node.LogicLocation.Y - other.LogicLocation.Y;
float distance =
(float
)Math.Sqrt
(dx * dx + dy * dy
);
if
(distance < 1
) distance = 1; // 避免除零
float force = Repulsion /
(distance * distance
);
// 更新速度
_velocities[node] = new PointF
(
_velocities[node].X + dx / distance * force,
_velocities[node].Y + dy / distance * force
);
}
}
// 计算连接间吸引力
foreach
(var conn in connections
)
{
var startNode = conn.StartPort?.Parent;
var endNode = conn.EndPort?.Parent;
if
(startNode != null && endNode != null
)
{
float dx = endNode.LogicLocation.X - startNode.LogicLocation.X;
float dy = endNode.LogicLocation.Y - startNode.LogicLocation.Y;
float distance =
(float
)Math.Sqrt
(dx * dx + dy * dy
);
float force = Attraction * distance;
// 更新速度（吸引力方向相反）
_velocities[startNode] = new PointF
(
_velocities[startNode].X + dx * force,
_velocities[startNode].Y + dy * force
);
_velocities[endNode] = new PointF
(
_velocities[endNode].X - dx * force,
_velocities[endNode].Y - dy * force
);
}
}
}
private void UpdatePositions
(List<VisualElement> nodes
)
{
foreach
(var node in nodes
)
{
// 应用阻尼
_velocities[node] = new PointF
(
_velocities[node].X * Damping,
_velocities[node].Y * Damping
);
// 更新位置
node.LogicLocation = new Point
(
(int
)(node.LogicLocation.X + _velocities[node].X
),
(int
)(node.LogicLocation.Y + _velocities[node].Y
)
);
}
}
}
#endregion
#region 样式与主题管理
public class StyleManager
{
public event EventHandler StyleChanged;
public static StyleManager Instance { get; } = new StyleManager
();
public Pen NodeBorderPen { get; private set; } = new Pen
(Color.Black, 2
);
public Font NodeFont { get; private set; } = new Font
("Segoe UI", 16
);
public float ZoomThreshold { get; set; } = 0.8f; // LOD阈值
private StyleManager
() { }
public void ApplyDarkTheme
()
{
NodeBorderPen.Color = Color.White;
NodeFont = new Font
("Segoe UI", 10, FontStyle.Bold
);
foreach
(var element in WorkflowCanvas.Instance.Elements
)
OnStyleChanged
();
}
public bool ShowPortsWhenZoomed
(float scale
) => scale > ZoomThreshold;
public virtual void OnStyleChanged
()
{
StyleChanged?.Invoke
(this, EventArgs.Empty
);
}
}
#endregion
#region 命令模式与撤销、重做
public partial class WorkflowCanvas : Panel
{
public List<VisualElement> Elements { get; } = new List<VisualElement>
();
public List<Connection> Connections { get; } = new List<Connection>
();
private QuadTree _quadTree;
private Rectangle _dirtyRegion = Rectangle.Empty;
private ForceDirectedLayout _layoutEngine = new ForceDirectedLayout
();
private Stack<ICommand> _undoStack = new Stack<ICommand>
();
private Stack<ICommand> _redoStack = new Stack<ICommand>
();
private float _scale = 1.0f;
private float _targetScale = 1.0f;
private VisualElement _draggingElement;
private Point _dragStart;
private Port _draggingPort;
private PointF _zoomCenter;
private PointF _panOffset = PointF.Empty;
private Connection _tempConnection;
private Rectangle _selectionRect;
private bool _isSelecting;
private System.Windows.Forms.Timer _zoomTimer;
public float Scale
{
get => _scale;
private set
{
_scale = Math.Max
(0.1f, Math.Min
(5.0f, value
)); // 限制范围
Invalidate
(); // 更新画布
}
}
// 添加公共方法来安全地修改缩放比例
public void SetScale
(float newScale
)
{
Scale = newScale;
}
public static WorkflowCanvas Instance { get; private set; }
public WorkflowCanvas
()
{
Instance = this;
DoubleBuffered = true;
MouseDown += OnMouseDown;
MouseMove += OnMouseMove;
MouseUp += OnMouseUp;
MouseWheel += OnMouseWheel;
_quadTree = new QuadTree
(new Rectangle
(0, 0, 10000, 10000
));
_zoomTimer = new System.Windows.Forms.Timer { Interval = 16 };
_zoomTimer.Tick +=
(sender, e
) => ZoomTick
();
}
// 执行自动布局
public void AutoLayout
()
{
_layoutEngine.Layout
(Elements, Connections
);
Invalidate
();
}
// 添加布局命令（可选）
public class LayoutCommand : ICommand
{
private readonly WorkflowCanvas _canvas;
private Dictionary<VisualElement, Point> _oldPositions = new Dictionary<VisualElement, Point>
();
public LayoutCommand
(WorkflowCanvas canvas
)
{
_canvas = canvas;
// 保存原始位置用于撤销
foreach
(var element in canvas.Elements
)
{
_oldPositions[element] = element.LogicLocation;
}
}
public void Execute
() => _canvas.AutoLayout
();
public void Undo
()
{
foreach
(var element in _canvas.Elements
)
{
if
(_oldPositions.TryGetValue
(element, out var pos
))
{
element.LogicLocation = pos;
}
}
_canvas.Invalidate
();
}
}
public void ZoomTo
(float newScale, Point? zoomCenter = null, bool animated = true
)
{
PointF oldCenter = _zoomCenter==null ? new PointF
(Width / 2f, Height / 2f
) : _zoomCenter;
PointF oldLogicalCenter = new PointF
(oldCenter.X / _scale, oldCenter.Y / _scale
);
_targetScale = Math.Max
(0.1f, Math.Min
(5.0f, newScale
));
if
(animated && Math.Abs
(_scale - _targetScale
) > 0.05f
)
{
_zoomCenter = oldLogicalCenter;
_zoomTimer.Start
();
}
else
{
_scale = _targetScale;
ApplyZoomWithFixedPoint
(oldLogicalCenter
);
Invalidate
();
}
}
private void ZoomTick
()
{
// 缓动算法：平滑过渡到目标缩放值
_scale +=
(_targetScale - _scale
) * 0.2f;
// 接近目标时停止动画
if
(Math.Abs
(_scale - _targetScale
) < 0.01f
)
{
_scale = _targetScale;
_zoomTimer.Stop
();
}
ApplyZoomWithFixedPoint
(_zoomCenter
);
Invalidate
();
}
private void ApplyZoomWithFixedPoint
(PointF logicalCenter
)
{
// 计算缩放后的偏移，保持逻辑中心点不变
float dx = logicalCenter.X *
(_scale - WorkflowCanvas.Instance.Scale
);
float dy = logicalCenter.Y *
(_scale - WorkflowCanvas.Instance.Scale
);
// 调整所有元素位置（需根据实际坐标系调整）
foreach
(var element in Elements
)
{
element.LogicLocation = new Point
(
(int
)(element.LogicLocation.X - dx
),
(int
)(element.LogicLocation.Y - dy
)
);
}
}
public void AddElement
(VisualElement element
)
{
var newBounds = _quadTree.Bounds;
// 确保元素位置在四叉树范围内，否则扩容
if
(element.Location.X < 0 || element.Location.Y < 0
|| element.Right > newBounds.Right
|| element.Bottom > newBounds.Bottom
)
{
ResizeQuadTreeBounds
(element
);
}
Elements.Add
(element
);
Controls.Add
(element
);
element.Visible = true; // 确保可见
_quadTree.Insert
(element
);
InvalidateRegion
(element.Bounds
);
}
public void AddConnection
(Connection conn
)
{
Connections.Add
(conn
);
_quadTree.Insert
(conn
); // 关键：插入四叉树，确保 OnPaint 能查询到
InvalidateRegion
(conn.Bounds
);
}
private void ResizeQuadTreeBounds
(VisualElement element
)
{
var newBounds = _quadTree.Bounds;
newBounds.X = Math.Min
(newBounds.X, element.Location.X
);
newBounds.Y = Math.Min
(newBounds.Y, element.Location.Y
);
newBounds.Width = Math.Max
(newBounds.Width, element.Right - newBounds.X
);
newBounds.Height = Math.Max
(newBounds.Height, element.Bottom - newBounds.Y
);
_quadTree = new QuadTree
(newBounds
); // 重建四叉树（简易方式，生产需迁移元素）
// 迁移已有元素到新四叉树...
}
public void RemoveElement
(VisualElement element
)
{
var connectionsToRemove = Connections.Where
(c => c.StartPort?.Parent == element || c.EndPort?.Parent == element
).ToList
();
foreach
(var conn in connectionsToRemove
) Connections.Remove
(conn
);
Elements.Remove
(element
);
Controls.Remove
(element
);
InvalidateRegion
(element.Bounds
);
}
public void InvalidateRegion
(Rectangle region
)
{
_dirtyRegion = Rectangle.Union
(_dirtyRegion, region
);
Invalidate
();
}
#region 交互处理
private void OnMouseDown
(object sender, MouseEventArgs e
)
{
var scaledPoint = new Point
((int
)(e.X / _scale
),
(int
)(e.Y / _scale
));
_draggingElement = Elements.FirstOrDefault
(n => n.Bounds.Contains
(scaledPoint
));
if
(_draggingElement != null
)
{
_dragStart = scaledPoint;
_draggingPort = null; // 拖动节点时不处理端口
_tempConnection = null;
}
else
{
_draggingPort = CheckPortClick
(_draggingElement, scaledPoint
);
if
(_draggingPort != null
)
{
_tempConnection = new Connection
{
StartPort = _draggingPort,
StartPosition = _draggingPort.ScreenPosition
};
}
else if
(e.Button == MouseButtons.Left
)
{
_isSelecting = true;
_selectionRect = new Rectangle
(scaledPoint, Size.Empty
);
}
}
}
private Port CheckPortClick
(VisualElement element, Point localPoint
)
{
if
(element is VisionNode node
)
{
foreach
(var port in node.InputPorts.Concat
(node.OutputPorts
))
{
var portCenter = new Point
(port.Position.X + 5, port.Position.Y + 5
);
if
(Math.Sqrt
(Math.Pow
(localPoint.X - portCenter.X, 2
) + Math.Pow
(localPoint.Y - portCenter.Y, 2
)) <= 5
)
return port;
}
}
return null;
}
private void OnMouseMove
(object sender, MouseEventArgs e
)
{
var scaledPoint = new Point
((int
)(e.X / _scale
),
(int
)(e.Y / _scale
));
if
(_draggingElement != null && _draggingPort == null
)
{
int dx = scaledPoint.X - _dragStart.X;
int dy = scaledPoint.Y - _dragStart.Y;
// 更新逻辑坐标（带边界限制）
int maxLogicX = 10000 - _draggingElement.LogicSize.Width;
int maxLogicY = 10000 - _draggingElement.LogicSize.Height;
_draggingElement.Location = new Point
(_draggingElement.Location.X + dx < 0 ? 0 :
_draggingElement.Location.X + dx > maxLogicX ? maxLogicX :
_draggingElement.Location.X + dx,
_draggingElement.Location.Y + dy < 0 ? 0 :
_draggingElement.LogicLocation.Y + dy > maxLogicY ? maxLogicY :
_draggingElement.LogicLocation.Y + dy
);
_dragStart = scaledPoint;
// 标记脏区域（旧位置 + 新位置）
var oldBounds = new Rectangle
(
_draggingElement.Bounds.X -
(int
)(dx * _scale
),
_draggingElement.Bounds.Y -
(int
)(dy * _scale
),
_draggingElement.Bounds.Width,
_draggingElement.Bounds.Height
);
InvalidateRegion
(_draggingElement.Bounds
);
}
else if
(_tempConnection != null
)
{
_tempConnection.EndPosition = scaledPoint;
InvalidateRegion
(_tempConnection.Bounds
);
}
else if
(_isSelecting
)
{
_selectionRect.Width = scaledPoint.X - _selectionRect.X;
_selectionRect.Height = scaledPoint.Y - _selectionRect.Y;
InvalidateRegion
(_selectionRect
);
}
}
private void OnMouseUp
(object sender, MouseEventArgs e
)
{
var scaledPoint = new Point
((int
)(e.X / _scale
),
(int
)(e.Y / _scale
));
if
(_tempConnection != null
)
{
var targetElement = Elements.FirstOrDefault
(n => n.Bounds.Contains
(scaledPoint
));
var targetPort = targetElement != null ? CheckPortClick
(targetElement, scaledPoint
) : null;
if
(targetPort != null && _tempConnection.StartPort.Type != targetPort.Type
)
{
_tempConnection.EndPort = targetPort;
AddConnection
(_tempConnection
); // 改用 AddConnection
_tempConnection.StartPort.ConnectedPort = targetPort;
targetPort.ConnectedPort = _tempConnection.StartPort;
InvalidateRegion
(_tempConnection.Bounds
);
}
_tempConnection = null;
_draggingPort = null;
}
else if
(_isSelecting
)
{
_isSelecting = false;
foreach
(var element in Elements
)
element.IsSelected = _selectionRect.IntersectsWith
(element.Bounds
);
InvalidateRegion
(_selectionRect
);
}
_draggingElement = null;
}
private void OnMouseWheel
(object sender, MouseEventArgs e
)
{
PointF mouseLogicPos = new PointF
(
(e.Location.X - _panOffset.X
) / _scale,
(e.Location.Y - _panOffset.Y
) / _scale
);
float oldScale = _scale;
_scale *= e.Delta > 0 ? 1.1f : 0.9f;
_scale = Math.Max
(0.1f, Math.Min
(5.0f, _scale
));
Invalidate
();
}
#endregion
#region 绘制逻辑（脏矩形+LOD+四叉树）
protected override void OnPaint
(PaintEventArgs e
)
{
base.OnPaint
(e
);
// 防止缩放因子过小导致除零或极小值
var safeScale = Math.Max
(0.01f, _scale
);
//
使用浮点计算避免精度丢失
var clip = e.ClipRectangle;
var scaledClip = new RectangleF
(
clip.X / safeScale,
clip.Y / safeScale,
clip.Width / safeScale,
clip.Height / safeScale
);
// 转换为整数矩形，确保尺寸至少为1x1
var intClip = new Rectangle
(
(int
)scaledClip.X,
(int
)scaledClip.Y,
Math.Max
(1,
(int
)scaledClip.Width
),
Math.Max
(1,
(int
)scaledClip.Height
)
);
var g = e.Graphics;
g.ScaleTransform
(safeScale, safeScale
);
// 线程安全访问（
使用副本避免并发修改）
List<IDrawable>
drawables;
lock
(_quadTree
)
{
drawables = _quadTree.Query
(intClip
).ToList
();
}
// 绘制节点
foreach
(var element in
drawables.OfType<VisualElement>
().OrderBy
(el => el.ZIndex
))
{
try
{
element.Draw
(g
);
}
catch
(Exception ex
)
{
Debug.WriteLine
($"绘制节点时出错: {ex.Message}"
);
// 可添加降级绘制逻辑
}
}
// 绘制连接
foreach
(var drawable in
drawables.OfType<Connection>
())
{
try
{
drawable.Draw
(g
);
}
catch
(Exception ex
)
{
Debug.WriteLine
($"绘制连接时出错: {ex.Message}"
);
}
}
// 绘制临时连接
if
(_tempConnection != null
)
{
_tempConnection.Draw
(g
);
}
_dirtyRegion = Rectangle.Empty;
}
public void BringToFront
(VisualElement element
)
{
var maxZIndex = Elements.Max
(el => el.ZIndex
);
element.ZIndex = maxZIndex + 1;
Invalidate
();
}
// 将元素置于底层
public void SendToBack
(VisualElement element
)
{
var minZIndex = Elements.Min
(el => el.ZIndex
);
element.ZIndex = minZIndex - 1;
Invalidate
();
}
// 提升
一层
public void MoveUp
(VisualElement element
)
{
var nextZIndex = Elements
.Where
(el => el.ZIndex > element.ZIndex
)
.Select
(el => el.ZIndex
)
.DefaultIfEmpty
(element.ZIndex + 1
)
.Min
();
element.ZIndex = nextZIndex;
Invalidate
();
}
// 降低
一层
public void MoveDown
(VisualElement element
)
{
var prevZIndex = Elements
.Where
(el => el.ZIndex < element.ZIndex
)
.Select
(el => el.ZIndex
)
.DefaultIfEmpty
(element.ZIndex - 1
)
.Max
();
element.ZIndex = prevZIndex;
Invalidate
();
}
#endregion
#region 命令模式
public void ExecuteCommand
(ICommand command
)
{
command.Execute
();
_undoStack.Push
(command
);
_redoStack.Clear
();
}
public void Undo
()
{
if
(_undoStack.Any
())
{
var cmd = _undoStack.Pop
();
cmd.Undo
();
_redoStack.Push
(cmd
);
Invalidate
();
}
}
public void Redo
()
{
if
(_redoStack.Any
())
{
var cmd = _redoStack.Pop
();
cmd.Execute
();
_undoStack.Push
(cmd
);
Invalidate
();
}
}
public class AddElementCommand : ICommand
{
private readonly WorkflowCanvas _canvas;
private readonly VisualElement _element;
public AddElementCommand
(WorkflowCanvas canvas, VisualElement element
)
{
_canvas = canvas;
_element = element;
}
public void Execute
() => _canvas.AddElement
(_element
);
public void Undo
() => _canvas.RemoveElement
(_element
);
}
}
#endregion
#endregion
#region 插件与序列化
public class PluginLoader
{
public static IEnumerable<IPlugin> Load
(string directory
)
{
var result = new List<IPlugin>
(); // 临时集合存储结果
foreach
(var file in Directory.GetFiles
(directory, "*.dll"
))
{
try
{
var assembly = Assembly.LoadFrom
(file
);
foreach
(var type in assembly.GetTypes
())
{
if
(typeof
(IPlugin
).IsAssignableFrom
(type
) && !type.IsAbstract
)
{
result.Add
((IPlugin
)Activator.CreateInstance
(type
)); // 收集结果
}
}
}
catch
(Exception ex
)
{
Debug.WriteLine
($"Plugin load failed: {ex}"
);
}
}
return result; // 统
一返回结果
}
}
public class JsonSerializer : ISerializer
{
public string Format => "json";
public string Serialize
(WorkflowCanvas canvas
)
{
var data = new
{
Elements = canvas.Elements.Select
(e => new
{
Type = e.GetType
().FullName,
Location = e.Location,
Size = e.Size,
Title =
(e as VisionNode
)?.Title,
Parameters =
(e as VisionNode
)?.Parameters
}
).ToList
(),
Connections = canvas.Connections.Select
(c => new
{
StartPort = c.StartPort != null ? new { c.StartPort.Parent.Title, c.StartPort.Name, c.StartPort.Type } : null,
EndPort = c.EndPort != null ? new { c.EndPort.Parent.Title, c.EndPort.Name, c.EndPort.Type } : null,
StartPosition = c.StartPosition,
EndPosition = c.EndPosition
}
).ToList
(),
Scale = canvas.Scale
};
return JsonConvert.SerializeObject
(data, Newtonsoft.Json.Formatting.Indented
);
}
public void Deserialize
(WorkflowCanvas canvas, string data
)
{
// 反序列化逻辑（需映射类型，此处简化）
var obj = JsonConvert.DeserializeAnonymousType
(data, new
{
Elements = new List<ElementDTO>
(),
Connections = new List<ConnectionDTO>
(),
Scale = 1.0f
}
);
canvas.Elements.Clear
();
canvas.Connections.Clear
();
canvas.Controls.Clear
();
canvas.SetScale
(obj.Scale
);
foreach
(var dto in obj.Elements
)
{
var type = Type.GetType
(dto.Type
);
if
(type == null || !typeof
(VisualElement
).IsAssignableFrom
(type
)) continue;
var element =
(VisualElement
)Activator.CreateInstance
(type
);
element.Location = dto.Location;
element.Size = dto.Size;
if
(element is VisionNode node
)
{
node.Title = dto.Title;
node.Parameters = dto.Parameters.ToDictionary
(k => k.Key, v => v.Value
);
}
canvas.AddElement
(element
);
}
// 重建连接...
}
private class ElementDTO
{
public string Type { get; set; }
public Point Location { get; set; }
public Size Size { get; set; }
public string Title { get; set; }
public Dictionary<string, object> Parameters { get; set; }
}
private class ConnectionDTO
{
public PortRef StartPort { get; set; }
public PortRef EndPort { get; set; }
public Point StartPosition { get; set; }
public Point EndPosition { get; set; }
}
private class PortRef
{
public string Title { get; set; }
public string Name { get; set; }
public PortType Type { get; set; }
}
}
#endregion
}
使用winform完善功能
本文深入介绍了Drawable中的着色、颜色提取与矢量图片技术，包括Tint的概念与实现，从图像中提取颜色的方法，以及矢量图片的应用。通过实例解析，展示了如何利用这些技术优化客户端资源，实现Material Design效果。
扫一扫
425
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
