public static M可视树节点 <T, U, V> 生成可视树(M树节点 <T> __根节点, Func <M树节点 <T>, U> __生成控件, Func <M树节点 <T>, V> __生成连线)
{
int __总层数 = 0;
var __终结点列表 = new List <M树节点 <T> >();
递归过滤终结点(__根节点, __终结点列表);
__终结点列表.ForEach(q =>
{
int __层数 = 0;
迭代计算总层数(q, ref __层数);
if (__层数 > __总层数)
{
__总层数 = __层数;
}
});
var __可视终结点列表 = new List <M可视树节点 <T, U, V> >();
for (int i = 0; i < __终结点列表.Count; i++)
{
__可视终结点列表.Add(new M可视树节点 <T, U, V>(__终结点列表[i], __生成控件, __生成连线)
{
占位 = i, 范围起始 = i, 范围结束 = i, 层数 = 0
});
}
return(递归生成可视节点(__根节点, __总层数, __可视终结点列表, __生成控件, __生成连线));
}
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(__可视节点);
}
private static void 迭代计算总层数(M树节点 <T> __节点, ref int __层数)
{
__层数++;
if (__节点.父节点 == null)
{
return;
}
迭代计算总层数(__节点.父节点, ref __层数);
}
private static void 递归过滤终结点(M树节点 <T> __节点, List <M树节点 <T> > __终结点)
{
if (__节点.子节点 == null || __节点.子节点.Count == 0)
{
__终结点.Add(__节点);
return;
}
foreach (var __树节点 in __节点.子节点)
{
递归过滤终结点(__树节点, __终结点);
}
}
public M可视树节点(M树节点 <T> __树节点, Func <M树节点 <T>, U> __生成控件, Func <M树节点 <T>, V> __生成连线)
{
this.子可视节点 = new List <M可视树节点 <T, U, V> >();
this.连线控件 = new List <V>();
this.节点控件 = __生成控件(__树节点);
this.生成连线 = __生成连线;
this.父节点 = __树节点.父节点;
this.标识 = __树节点.标识;
this.子节点 = __树节点.子节点;
this.业务对象 = __树节点.业务对象;
}
public static List <M树节点 <T> > 查询所有节点(M树节点 <T> __节点)
{
var __结果 = new List <M树节点 <T> > {
__节点
};
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 <T, M树节点 <T> > 查询业务对象映射(M树节点 <T> __节点)
{
var __结果 = new Dictionary <T, M树节点 <T> >();
__结果[__节点.业务对象] = __节点;
foreach (var __子节点 in __节点.子节点)
{
var __temp = 查询业务对象映射(__子节点);
foreach (var kv in __temp)
{
__结果[kv.Key] = kv.Value;
}
}
return(__结果);
}
