private static M可视树节点 <T, U, V> 递归生成可视节点(M树节点 <T> __节点, int __层数, List <M可视树节点 <T, U, V> > __可视终结点列表, Func <M树节点 <T>, U> __生成控件, Func <M树节点 <T>, V> __生成连线)
{
var __终结点 = new List <M树节点 <T> >();
递归过滤终结点(__节点, __终结点);
var __范围起始 = int.MaxValue;
var __范围结束 = 0;
__终结点.ForEach(q =>
{
var __匹配可视终结点 = __可视终结点列表.Find(k => k.标识 == q.标识);
__范围起始 = Math.Min(__范围起始, __匹配可视终结点.范围起始);
__范围结束 = Math.Max(__范围结束, __匹配可视终结点.范围结束);
});
var __可视节点 = new M可视树节点 <T, U, V>(__节点, __生成控件, __生成连线)
{
层数 = --__层数,
范围起始 = __范围起始,
范围结束 = __范围结束,
占位 = (float)((__范围起始 + __范围结束) / 2.0)
};
if (__节点.子节点 == null || __节点.子节点.Count == 0)
{
return(__可视节点);
}
foreach (var __树节点 in __节点.子节点)
{
var __可视子节点 = 递归生成可视节点(__树节点, __可视节点.层数, __可视终结点列表, __生成控件, __生成连线);
//__可视子节点.父可视节点 = __可视节点;
__可视节点.子可视节点.Add(__可视子节点);
}
return(__可视节点);
}
public static void 从上到下呈现(M可视树节点 <T, U, V> __可视树, Control __容器, int __节点宽度, int __节点高度, int __连线厚度, Padding __留白, bool __合并连线 = false)
{
var __容器长度 = __容器.Width;
var __容器高度 = __容器.Height;
var __连线X长度 = (__容器长度 - __留白.Left - __留白.Right - (__可视树.范围结束 - __可视树.范围起始 + 1) * __节点宽度) / (__可视树.范围结束 - __可视树.范围起始);
var __连线Y长度 = (__容器高度 - __留白.Top - __留白.Bottom - (__可视树.层数 + 1) * __节点高度) / __可视树.层数;
从上到下递归呈现(__可视树, __容器, __留白, __连线X长度, __连线Y长度, __可视树.层数, __连线厚度, __合并连线);
}
public static List <M可视树节点 <T, U, V> > 查询所有可视节点(M可视树节点 <T, U, V> __节点)
{
var __结果 = new List <M可视树节点 <T, U, V> > {
__节点
};
foreach (var __子节点 in __节点.子可视节点)
{
__结果.AddRange(查询所有可视节点(__子节点));
}
return(__结果);
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
this.Resize += FDemo逻辑图2_Resize;
var __根节点 = new M树节点 <M示例业务对象> {
业务对象 = new M示例业务对象 {
称 = "根节点"
}
};
for (int i = 0; i < 1; i++)
{
__根节点.子节点.Add(new M树节点 <M示例业务对象> {
业务对象 = new M示例业务对象 {
称 = "2层节点"
}, 父节点 = __根节点
});
var __2层节点 = __根节点.子节点[i];
for (int j = 0; j < 2; j++)
{
__2层节点.子节点.Add(new M树节点 <M示例业务对象> {
业务对象 = new M示例业务对象 {
称 = "1层节点"
}, 父节点 = __2层节点
});
var __1层节点 = __2层节点.子节点[j];
for (int k = 0; k < 3; k++)
{
__1层节点.子节点.Add(new M树节点 <M示例业务对象> {
业务对象 = new M示例业务对象 {
称 = "0层节点"
}, 父节点 = __1层节点
});
}
}
}
_根可视节点 = M可视树节点 <M示例业务对象, Button, Label> .生成可视树(__根节点, q => 生成节点(q.业务对象), q => 生成连线(q.业务对象));
//_根可视节点.从左到右呈现(this.out容器, _节点宽度, _节点高度, _连线厚度, _留白, true);
_根可视节点.从上到下呈现(this.out容器, _节点宽度, _节点高度, _连线厚度, _留白, true);
var __所有节点 = _根可视节点.查询所有节点();
var __所有可视节点 = _根可视节点.查询所有可视节点();
var __所有业务对象树节点映射 = ((M树节点 <M示例业务对象>)_根可视节点).查询业务对象映射();
var __所有业务对象可视节点映射 = _根可视节点.查询业务对象映射();
var __所有节点控件映射 = _根可视节点.查询节点控件映射();
var __所有连线控件映射 = _根可视节点.查询连线控件映射();
}
public static Dictionary <U, M可视树节点 <T, U, V> > 查询节点控件映射(M可视树节点 <T, U, V> __节点)
{
var __结果 = new Dictionary <U, M可视树节点 <T, U, V> >();
__结果[__节点.节点控件] = __节点;
foreach (var __子节点 in __节点.子可视节点)
{
var __temp = 查询节点控件映射(__子节点);
foreach (var kv in __temp)
{
__结果[kv.Key] = kv.Value;
}
}
return(__结果);
}
private static void 从上到下递归呈现(M可视树节点 <T, U, V> __节点, Control __容器, Padding __留白, int __连线X长度, int __连线Y长度, int __总层数, int __连线厚度, bool __合并连线 = false)
{
__节点.节点控件.Left = (int)(__留白.Left + (__节点.节点控件.Width + __连线X长度) * __节点.占位);
__节点.节点控件.Top = __留白.Top + (__节点.节点控件.Height + __连线Y长度) * (__总层数 - __节点.层数);
__容器.Controls.Add(__节点.节点控件);
var __子节点数量 = __节点.子节点.Count;
var __当前子节点索引 = 0;
foreach (var __子节点 in __节点.子可视节点)
{
从上到下递归呈现(__子节点, __容器, __留白, __连线X长度, __连线Y长度, __总层数, __连线厚度, __合并连线);
if (__子节点数量 == 1)
{
V __连线;
if (__子节点.连线控件.Count > 0)
{
__连线 = __子节点.连线控件[0];
}
else
{
__连线 = __节点.生成连线(__子节点);
__容器.Controls.Add(__连线);
__子节点.连线控件.Add(__连线);
}
__连线.Width = __连线厚度;
__连线.Height = __连线Y长度;
__连线.Left = __节点.节点控件.Left + __节点.节点控件.Width / 2;
__连线.Top = __节点.节点控件.Top + __节点.节点控件.Height;
}
else
{
//前横线
int __X重叠偏移 = 0;
var __Y重叠偏移 = 0;
if (!__合并连线)
{
__Y重叠偏移 = (__当前子节点索引 - __子节点数量 / 2) * (__连线厚度 + 1);
__X重叠偏移 = __Y重叠偏移;
if (__子节点数量 % 2 == 0 && __当前子节点索引 >= __子节点数量 / 2)
{
__Y重叠偏移 = (__当前子节点索引 + 1 - __子节点数量 / 2) * (__连线厚度 + 1);
}
}
V __前横线;
if (__子节点.连线控件.Count > 0)
{
__前横线 = __子节点.连线控件[0];
}
else
{
__前横线 = __节点.生成连线(__子节点);
__容器.Controls.Add(__前横线);
__子节点.连线控件.Add(__前横线);
}
__前横线.Width = __连线厚度;
__前横线.Height = __连线Y长度 / 2 - Math.Abs(__Y重叠偏移);
__前横线.Left = __节点.节点控件.Left + __节点.节点控件.Width / 2 + __X重叠偏移;
__前横线.Top = __节点.节点控件.Top + __节点.节点控件.Height;
//后横线
V __后横线;
if (__子节点.连线控件.Count > 1)
{
__后横线 = __子节点.连线控件[1];
}
else
{
__后横线 = __节点.生成连线(__子节点);
__容器.Controls.Add(__后横线);
__子节点.连线控件.Add(__后横线);
}
__后横线.Width = __连线厚度;
__后横线.Height = __子节点.节点控件.Top - __前横线.Top - __前横线.Height;
__后横线.Left = __子节点.节点控件.Left + __节点.节点控件.Width / 2;
__后横线.Top = __前横线.Top + __前横线.Height;
__容器.Controls.Add(__后横线);
//中竖线
V __中竖线;
if (__子节点.连线控件.Count > 2)
{
__中竖线 = __子节点.连线控件[2];
}
else
{
__中竖线 = __节点.生成连线(__子节点);
__容器.Controls.Add(__中竖线);
__子节点.连线控件.Add(__中竖线);
}
__中竖线.Width = Math.Abs(__后横线.Left - __前横线.Left) + __连线厚度;
__中竖线.Height = __连线厚度;
__中竖线.Left = Math.Min(__前横线.Left, __后横线.Left);
__中竖线.Top = __后横线.Top;
__当前子节点索引++;
}
}
}