using System;
|
using System.Collections.Generic;
|
using System.ComponentModel;
|
using System.Drawing;
|
using System.Drawing.Drawing2D;
|
using System.Linq;
|
using System.Text;
|
using System.Threading.Tasks;
|
using System.Windows.Forms;
|
|
namespace DPumpHydr.WinFrmUI.WenSkin.Controls;
|
|
public class NestBox : Control
|
{
|
private PoiList pois;
|
|
public NestBox()
|
{
|
base.SetStyle(
|
ControlStyles.UserPaint |
|
ControlStyles.DoubleBuffer |
|
ControlStyles.OptimizedDoubleBuffer |
|
ControlStyles.AllPaintingInWmPaint |
|
ControlStyles.ResizeRedraw |
|
ControlStyles.SupportsTransparentBackColor, true);
|
base.UpdateStyles();
|
this.BackColor = Color.Transparent;
|
}
|
|
|
[Category("文"), Description("限制移动只允许内部区域"), DefaultValue(false)]
|
public bool IsLimitRec { get; set; } = true;
|
|
|
public float L { get; set; } = 2400;
|
public float W { get; set; } = 1200;
|
public float H { get; set; } = 18;
|
|
private float Sc => this.Width / this.L;
|
|
|
|
public Poi SelectedPoi { get; set; }
|
|
|
protected override void OnSizeChanged(EventArgs e)
|
{
|
base.OnSizeChanged(e);
|
this.Width = (int)(this.Height * (L / W));
|
}
|
|
|
protected override void OnPaint(PaintEventArgs e)
|
{
|
base.OnPaint(e);
|
|
|
Graphics g = e.Graphics.SetGDIHigh();
|
|
|
//画底层框
|
using Pen p = new Pen(Color.Gray, 3);
|
//画底层框
|
using Pen px = new Pen(Color.Gray, 1)
|
{
|
DashStyle = DashStyle.Dot,
|
};
|
g.DrawRectangle(p, 0, 0, this.Width - 1, this.Height - 1);
|
|
for (int i = 0; i < this.W; i += 100)
|
{
|
g.DrawLine(px, 0, i * Sc, this.Width, i * Sc);
|
}
|
for (int i = 0; i < this.L; i += 100)
|
{
|
g.DrawLine(px, i * Sc, 0, i * Sc, this.Height);
|
}
|
|
DrawPoi(g);
|
}
|
|
|
private void DrawPoi(Graphics g)
|
{
|
if (this.Pois.Count <= 0)
|
{
|
return;
|
}
|
|
|
foreach (var poi in Pois)
|
{
|
g.FillPath(Brushes.Black, poi.GetGraphicsPath(this.Sc));
|
if (poi == SelectedPoi)
|
{
|
using var p = new Pen(Color.Red, 3)
|
{
|
Alignment = PenAlignment.Inset,
|
DashStyle = DashStyle.Dot,
|
};
|
g.DrawPath(p, poi.GetGraphicsPath(this.Sc));
|
|
g.FillRectangle(Brushes.Aqua, new RectangleF((poi.BasicPoint.X) * this.Sc, (poi.BasicPoint.Y) * this.Sc, 8, 8));
|
}
|
}
|
}
|
|
|
|
#region 鼠标操作
|
|
private bool isMouseDown = false;
|
private PointF mouseDownPoint = new PointF(0, 0);
|
|
//鼠标进入控件
|
protected override void OnMouseMove(MouseEventArgs e)
|
{
|
base.OnMouseMove(e);
|
|
var p = new PointF(e.X / Sc, e.Y / Sc);
|
|
if (this.Pois.IsVisible(p))
|
{
|
Cursor = Cursors.SizeAll;
|
}
|
else
|
{
|
Cursor = Cursors.Default;
|
}
|
|
|
|
var x = e.X - mouseDownPoint.X;
|
var y = e.Y - mouseDownPoint.Y;
|
|
if (this.SelectedPoi != null && isMouseDown)
|
{
|
var mx = (int)(x / Sc);
|
var my = (int)(y / Sc);
|
|
if (this.SelectedPoi.IsOffsetBasicPointIsVisible(mx, my, new RectangleF(0, 0, L, W)))
|
{
|
this.SelectedPoi.OffsetBasicPoint(mx, my);
|
|
var po = this.SelectedPoi.BasicPoint;
|
|
//判断基点是否考进指定点
|
|
//获取最小值
|
var mmx = this.NoSelectedPointFs.OrderBy(p => Math.Abs(p.X - po.X)).First();
|
var mmy = this.NoSelectedPointFs.OrderBy(p => Math.Abs(p.Y - po.Y)).First();
|
|
|
|
//判断当前坐标是否接近整数
|
var px = Math.Abs((po.X + mx) % 100);
|
var py = Math.Abs((po.Y + my) % 100);
|
|
var nx = Math.Abs(mmx.X - po.X) <= 10 ? mmx.X : px <= 5 ? po.X - px : px >= 95 ? po.X - px + 100 : po.X;
|
var ny = Math.Abs(mmy.Y - po.Y) <= 10 ? mmy.Y : py <= 5 ? po.Y - py : py >= 95 ? po.Y - py + 100 : po.Y;
|
|
//Console.WriteLine(mmx);
|
//Console.WriteLine(mmy);
|
//Console.WriteLine(po);
|
//Console.WriteLine();
|
this.SelectedPoi.BasicPoint = new PointF(nx, ny);
|
}
|
|
this.Invalidate();
|
mouseDownPoint = e.Location;
|
}
|
}
|
|
protected override void OnMouseDown(MouseEventArgs e)
|
{
|
base.OnMouseDown(e);
|
var p = new PointF(e.X / Sc, e.Y / Sc);
|
|
this.isMouseDown = true;
|
this.mouseDownPoint = e.Location;
|
|
this.SelectedPoi = this.Pois.GetMousePoi(p);
|
if(this.SelectedPoi!=null)
|
{
|
NoSelectedPointFs = GetNoSelectedPoiPs();
|
}
|
this.Invalidate(true);
|
}
|
|
protected override void OnMouseUp(MouseEventArgs e)
|
{
|
base.OnMouseUp(e);
|
this.isMouseDown = false;
|
}
|
|
|
|
|
#endregion
|
|
|
|
private List<PointF> NoSelectedPointFs { get; set; } = new List<PointF>();
|
|
private List<PointF> GetNoSelectedPoiPs()
|
{
|
var ps = new List<PointF>();
|
foreach (var p in this.Pois.FindAll(x => x != this.SelectedPoi).ToList())
|
{
|
ps.AddRange(p.GetPointFs());
|
}
|
return ps;
|
}
|
|
|
|
//检查是否重叠
|
public void Rrr()
|
{
|
var ls = new List<Poi>();
|
|
for (int i = 0; i < this.Pois.Count; i++)
|
{
|
var gp = this.Pois[i].GetGraphicsPath();
|
|
for (int j = i + 1; j < this.Pois.Count; j++)
|
{
|
var ps = this.Pois[j].GetPointFs();
|
foreach (var p in ps)
|
{
|
if (gp.IsVisible(p))
|
{
|
ls.Add(this.pois[j]);
|
ls.Add(this.pois[i]);
|
break;
|
}
|
}
|
}
|
}
|
var xs = ls.Distinct();
|
}
|
|
|
public PoiList Pois => this.pois ??= new PoiList(this);
|
|
|
public class PoiList : List<Poi>
|
{
|
private NestBox owner;
|
|
public PoiList(NestBox owner)
|
{
|
this.owner = owner;
|
}
|
|
public bool IsVisible(PointF p)
|
{
|
foreach (var poi in Enumerable.Reverse(this))
|
{
|
if (poi.GetGraphicsPath().IsVisible(p))
|
return true;
|
}
|
return false;
|
}
|
|
public Poi GetMousePoi(PointF p)
|
{
|
foreach (var poi in Enumerable.Reverse(this))
|
{
|
if (poi.GetGraphicsPath().IsVisible(p))
|
return poi;
|
}
|
return null;
|
}
|
|
public new void Add(Poi poi)
|
{
|
base.Add(poi);
|
owner.Invalidate();
|
}
|
}
|
|
public class Poi
|
{
|
|
private List<PointF> points;
|
public List<PointF> Points => points ??= new List<PointF>();
|
|
public PointF BasicPoint { get; set; } = new PointF(0, 0);
|
|
|
public int Rotate { get; set; } = 0;
|
|
public PointF[] GetPointFs(float sc = 1)
|
{
|
return Points.Select(x => new PointF((x.X + this.BasicPoint.X) * sc, (x.Y + this.BasicPoint.Y) * sc)).ToArray();
|
}
|
|
|
|
public GraphicsPath GetGraphicsPath(float sc = 1)
|
{
|
var gp = new GraphicsPath();
|
gp.AddLines(GetPointFs(sc));
|
gp.CloseAllFigures();
|
|
var rec = gp.GetBounds();
|
var matrix = new Matrix();
|
matrix.RotateAt(this.Rotate, new PointF(rec.X + rec.Width / 2, rec.Y + rec.Height / 2));
|
gp.Transform(matrix);
|
return gp;
|
}
|
|
public void SetBasicPoint(PointF p)
|
{
|
this.BasicPoint = p;
|
}
|
|
public void OffsetBasicPoint(float x, float y)
|
{
|
this.BasicPoint = new PointF(this.BasicPoint.X + x, this.BasicPoint.Y + y);
|
}
|
|
|
public bool IsOffsetBasicPointIsVisible(float x, float y, RectangleF inrec)
|
{
|
var pos = Points.Select(it => new PointF(it.X + this.BasicPoint.X + x, it.Y + this.BasicPoint.Y + y)).ToArray();
|
var gp = new GraphicsPath();
|
gp.AddLines(pos);
|
gp.CloseAllFigures();
|
|
var rec = gp.GetBounds();
|
var matrix = new Matrix();
|
matrix.RotateAt(this.Rotate, new PointF(rec.X + rec.Width / 2, rec.Y + rec.Height / 2));
|
gp.Transform(matrix);
|
|
return inrec.Contains(gp.GetBounds());
|
}
|
}
|
}
|
