/// <summary>
/// 判断是否可执行元素替换
/// </summary>
/// <param name="beforeConferenceTreeItem"></param>
/// <param name="nowConferenceTreeItem"></param>
/// <returns></returns>
public bool CheckCanInsteadElement(ConferenceTreeItem beforeConferenceTreeItem, ConferenceTreeItem nowConferenceTreeItem)
{
bool result = true;
try
{
if (beforeConferenceTreeItem != null && nowConferenceTreeItem != null)
{
//查找拖动目标的子集（不允许父级拖到子级的动作）
List <ConferenceTreeItem> beforeItemList = WPFElementManage.FindVisualChildren <ConferenceTreeItem>(beforeConferenceTreeItem).ToList <ConferenceTreeItem>();
//不允许父级拖到子级的动作（返回）
if (beforeItemList != null && beforeItemList.Contains(nowConferenceTreeItem))
{
result = false;
}
//不为父子级关系
if (beforeConferenceTreeItem.ACA_Parent == null || beforeConferenceTreeItem.ACA_Parent.Equals(nowConferenceTreeItem))
{
result = false;
}
}
}
catch (Exception ex)
{
LogManage.WriteLog(this.GetType(), ex);
}
return(result);
}
/// <summary>
/// 使用递归的方式填充会议纪要的内容
/// </summary>
/// <param name="treeParent"></param>
/// <param name="number"></param>
/// <param name="builder"></param>
void SetNextLineAboutMeetSummary(ConferenceTreeItem treeParent, string number, ref StringBuilder builder)
{
try
{
if (treeParent.ACA_ChildList.Count > 0)
{
int count = 0;
foreach (var item in treeParent.ACA_ChildList)
{
count++;
if (treeParent.ACA_Parent == null)
{
displayNumber = Convert.ToString(count);
}
else
{
displayNumber = number + "." + count;
}
this.SetLineValue(item, ref builder);
this.SetNextLineAboutMeetSummary(item, displayNumber, ref builder);
}
}
}
catch (Exception ex)
{
LogManage.WriteLog(this.GetType(), ex);
}
}
/// <summary>
/// 更改标题
/// </summary>
/// <param name="academicReviewItemTransferEntity"></param>
public static void UpdateItemTittle(ConferenceTreeItemTransferEntity academicReviewItemTransferEntity)
{
try
{
//遍历记录所有知识树的记录
foreach (var item in ConferenceTreeItem.AcademicReviewItemList)
{
//指定与服务器传过来的协议实体GUID相同的知识树节点
if (item.ACA_Guid.Equals(academicReviewItemTransferEntity.Guid))
{
//避免重复设置（标题）
if (item.ACA_Tittle != academicReviewItemTransferEntity.Title && !item.IsTittleEditNow)
{
//指定节点的标题设置
item.ACA_Tittle = academicReviewItemTransferEntity.Title;
//指定节点的协议实体的标题设置
item.AcademicReviewItemTransferEntity.Title = item.ACA_Tittle;
//指定节点的选择起始位置设置为文本的长度
item.txtTittle.SelectionStart = item.txtTittle.Text.Length;
//显示操作提示
ConferenceTreeItem.ShowOperationTip(item, academicReviewItemTransferEntity.Operationer);
}
break;
}
}
}
catch (Exception ex)
{
LogManage.WriteLog(typeof(ConferenceTreeItem), ex);
}
finally
{
}
}
/// <summary>
/// 元素替换法（服务器同步使用）
/// </summary>
public void InsteadElement(int beforeConferenceTreeItemGuid, int nowConferenceTreeItemGuid)
{
try
{
///获取相对应的元素
ConferenceTreeItem beforeConferenceTreeItem = null;
ConferenceTreeItem nowConferenceTreeItem = null;
//通过遍历获取相对应的子节点（判断GUID）
foreach (var item in ConferenceTreeItem.AcademicReviewItemList)
{
if (beforeConferenceTreeItem != null && nowConferenceTreeItem != null)
{
break;
}
else if (item.ACA_Guid.Equals(beforeConferenceTreeItemGuid))
{
beforeConferenceTreeItem = item;
}
else if (item.ACA_Guid.Equals(nowConferenceTreeItemGuid))
{
nowConferenceTreeItem = item;
}
}
this.InsteadElement(beforeConferenceTreeItem, nowConferenceTreeItem);
}
catch (Exception ex)
{
LogManage.WriteLog(this.GetType(), ex);
}
}
/// <summary>
/// 更改评论
/// </summary>
/// <param name="academicReviewItemTransferEntity"></param>
public static void UpdateItemComment(ConferenceTreeItemTransferEntity academicReviewItemTransferEntity)
{
try
{
//遍历记录所有知识树的记录
foreach (var item in ConferenceTreeItem.AcademicReviewItemList)
{
//指定与服务器传过来的协议实体GUID相同的知识树节点
if (item.ACA_Guid.Equals(academicReviewItemTransferEntity.Guid))
{
//避免重复设置（评论）
if (item.ACA_Comment != academicReviewItemTransferEntity.Comment && !item.IsCommentEditNow)
{
//指定节点的评论设置
item.ACA_Comment = academicReviewItemTransferEntity.Comment;
//指定节点的协议实体的评论设置
item.AcademicReviewItemTransferEntity.Comment = item.ACA_Comment;
item.CommentCommandVisibility = Visibility.Visible;
//显示操作提示
ConferenceTreeItem.ShowOperationTip(item, academicReviewItemTransferEntity.Operationer);
}
break;
}
}
}
catch (Exception ex)
{
LogManage.WriteLog(typeof(ConferenceTreeItem), ex);
}
finally
{
}
}
/// <summary>
/// 计算赞成票与反对票显示长度的对比
/// </summary>
/// <param name="YesVoteCount"></param>
/// <param name="NoVoteCount"></param>
public void CalculateVoteDisplay(ConferenceTreeItem item, int YesVoteCount, int NoVoteCount)
{
try
{
//赞成票的对比度显示值设置
//item.YesVoteLength = ((double)YesVoteCount / ((double)YesVoteCount + (double)NoVoteCount)) * item.VoteAllLength;
////反对票的对比度显示值设置
//item.NoVoteLength = ((double)NoVoteCount / ((double)YesVoteCount + (double)NoVoteCount)) * item.VoteAllLength;
}
catch (Exception ex)
{
LogManage.WriteLog(this.GetType(), ex);
}
}
/// <summary>
/// 子项相应鼠标移动
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ConferenceTreeView_PreviewMouseMove(object sender, MouseEventArgs e)
{
try
{
// 拖动终止位置
Point EndPoint;
if (Mouse.LeftButton != MouseButtonState.Pressed)
{
return;
}
ConferenceTreeItem item = ConferenceTreeItem.currentConferenceTreeItem;
if (item != null && item.isDrag)
{
EndPoint = e.GetPosition(this.borDiscussTheme);
//计算X、Y轴起始点与终止点之间的相对偏移量
double y = EndPoint.Y - item.StartPoint.Y;
double x = EndPoint.X - item.StartPoint.X;
//if (x > 10 || y > 10 || x < -10 || y < -10)
//{
Thickness margin = this.conferenceTreeItemVisual.Margin;
//计算新的Margin
Thickness newMargin = new Thickness()
{
Left = margin.Left + x,
Top = margin.Top + y,
Bottom = margin.Bottom,
Right = margin.Right
};
if (this.conferenceTreeItemVisual.Visibility != System.Windows.Visibility.Visible)
{
//显示虚拟拖拽节点
this.conferenceTreeItemVisual.Visibility = System.Windows.Visibility.Visible;
}
//设置移动效果
this.conferenceTreeItemVisual.Margin = newMargin;
//开始位置变为最终的位置
item.StartPoint = EndPoint;
//}
}
}
catch (Exception ex)
{
LogManage.WriteLog(this.GetType(), ex);
}
}
/// <summary>
/// 服务器同步添加节点
/// </summary>
/// <param name="academicReviewItemTransferEntity"></param>
public static void Add_Item(ConferenceTreeItemTransferEntity academicReviewItemTransferEntity)
{
try
{
lock (AddItem_Object)
{
//映射集合GUID
if (ConferenceTreeItem.retunList.Count > 0 && !ConferenceTreeItem.retunList.Contains(academicReviewItemTransferEntity.Guid))
{
//添加GUID
ConferenceTreeItem.retunList.Add(academicReviewItemTransferEntity.Guid);
//声明一个新的知识树节点
ConferenceTreeItem academicReviewItem = null;
//指定父节点，通过关联记录所有知识树的记录中获取（根据服务器传过来的知识树协议实体的父节点的GUID来判断）
foreach (var item in ConferenceTreeItem.AcademicReviewItemList)
{
if (item.ACA_Guid.Equals(academicReviewItemTransferEntity.ParentGuid))
{
//生成知识树节点（关联）（该节点的GUID为服务器传过来的知识树协议实体的GUID）
academicReviewItem = new ConferenceTreeItem(false)
{
VerticalLineVisibility = System.Windows.Visibility.Collapsed, ExpanderVisibility = System.Windows.Visibility.Collapsed, ACA_Parent = item, ParentGuid = academicReviewItemTransferEntity.ParentGuid, ACA_Guid = academicReviewItemTransferEntity.Guid
};
//父节点容器将新生成的知识节点添加
item.StackPanel.Children.Add(academicReviewItem);
//父节点的子项集合添加该节点
item.ACA_ChildList.Add(academicReviewItem);
//该节点的协议实体绑定服务器传过来的知识树协议实体
academicReviewItem.AcademicReviewItemTransferEntity = academicReviewItemTransferEntity;
//根目录自增1
ConferenceTreeItem.RootCount++;
break;
}
}
if (academicReviewItem != null)
{
//记录所有知识树的记录添加节点
ConferenceTreeItem.AcademicReviewItemList.Add(academicReviewItem);
}
}
}
}
catch (Exception ex)
{
LogManage.WriteLog(typeof(ConferenceTreeItem), ex);
}
}
/// <summary>
/// 選擇事件回調
/// </summary>
public void SelectedItemCallEvent()
{
try
{
//子项选择回调（携带标题）
if (ConferenceTreeItem.SelectedItemCallBack != null && currentConferenceTreeItem != null)
{
ConferenceTreeItem.SelectedItemCallBack(currentConferenceTreeItem.ACA_Tittle);
}
}
catch (Exception ex)
{
LogManage.WriteLog(this.GetType(), ex);
}
finally
{
}
}
/// <summary>
/// 填充一行内容
/// </summary>
/// <param name="item"></param>
/// <param name="builder"></param>
void SetLineValue(ConferenceTreeItem item, ref StringBuilder builder)
{
try
{
string pNormal = @"<p class=MsoNormal align=left style='text-align:left'><b><span lang=EN-US
style='font-size:12pt'>" + (displayNumber) + "、" + item.ACA_Tittle + "</span></span></b></p>";
builder.Append(pNormal);
if (!string.IsNullOrEmpty(item.ACA_Comment))
{
string pNormal2 = @"<p align=left style='text-align:left'><b><span lang=EN-US
style='font-size:12pt'>" + " 备注：" + item.ACA_Comment + "</span></span></b></p>";
builder.Append(pNormal2);
}
}
catch (Exception ex)
{
LogManage.WriteLog(this.GetType(), ex);
}
}
/// <summary>
/// 清空附加数据
/// </summary>
/// <param name="academicReviewChild"></param>
public static void ClearAddData(ConferenceTreeItem academicReviewChild)
{
try
{
#region 清空附加数据
//树节点集合
List <ConferenceTreeItem> treeItemList = ConferenceTreeItem.AcademicReviewItemList;
//若包含则清除
if (treeItemList.Contains(academicReviewChild))
{
treeItemList.Remove(academicReviewChild);
}
List <int> intlist = ConferenceTreeItem.retunList;
if (intlist.Contains(academicReviewChild.ACA_Guid))
{
intlist.Remove(academicReviewChild.ACA_Guid);
}
//若为当前选择的子节点则清空
if (currentConferenceTreeItem != null && currentConferenceTreeItem.Equals(academicReviewChild))
{
currentConferenceTreeItem = null;
}
////清空计时器
//if (academicReviewChild.CommentEditControlTimer != null)
//{
// academicReviewChild.CommentEditControlTimer.Stop();
//}
//if (academicReviewChild.TittleEditControlTimer != null)
//{
// academicReviewChild.TittleEditControlTimer.Stop();
//}
#endregion
}
catch (Exception ex)
{
LogManage.WriteLog(typeof(ConferenceTreeItem), ex);
}
}
/// <summary>
/// 元素替换法
/// </summary>
public void InsteadElement(ConferenceTreeItem beforeConferenceTreeItem, ConferenceTreeItem nowConferenceTreeItem)
{
try
{
if (beforeConferenceTreeItem != null && nowConferenceTreeItem != null)
{
bool result = this.CheckCanInsteadElement(beforeConferenceTreeItem, nowConferenceTreeItem);
if (result)
{
//获取目标节点的父节点
ConferenceTreeItem beforeConferenceTreeItemParent = beforeConferenceTreeItem.ACA_Parent;
if (beforeConferenceTreeItemParent.ACA_ChildList.Contains(beforeConferenceTreeItem))
{
//移除该子节点
beforeConferenceTreeItemParent.ACA_ChildList.Remove(beforeConferenceTreeItem);
}
if (beforeConferenceTreeItemParent.StackPanel.Children.Contains(beforeConferenceTreeItem))
{
//UI显示
beforeConferenceTreeItemParent.StackPanel.Children.Remove(beforeConferenceTreeItem);
}
if (!nowConferenceTreeItem.ACA_ChildList.Contains(beforeConferenceTreeItem))
{
//拖拽到选中子节点添加节点
nowConferenceTreeItem.ACA_ChildList.Add(beforeConferenceTreeItem);
}
if (!nowConferenceTreeItem.StackPanel.Children.Contains(beforeConferenceTreeItem))
{
//UI显示
nowConferenceTreeItem.StackPanel.Children.Add(beforeConferenceTreeItem);
}
//父级更替
beforeConferenceTreeItem.ACA_Parent = nowConferenceTreeItem;
}
}
}
catch (Exception ex)
{
LogManage.WriteLog(this.GetType(), ex);
}
}
/// <summary>
/// 初始化(权限、)
/// </summary>
public void ParametersInit()
{
try
{
if (goIntoReflesh)
{
goIntoReflesh = false;
//同步协议对象（根节点）
this.AcademicReviewItemTransferEntity = new ConferenceTreeItemTransferEntity()
{
};
//根目录为0，说明刚启动
if (ConferenceTreeItem.RootCount == 0)
{
retunList.Add(0);
//获取服务器里缓存的知识树并刷新本地知识树（到达初始化同步）
ModelManage.ConferenceTree.GetAll(TreeCodeEnterEntity.ConferenceName, new Action <ConferenceTreeInitRefleshEntity>((result) =>
{
if (result != null)
{
//刷新知识树
this.Reflesh(result);
//更新整棵研讨树完成事件
if (ConferenceTreeItem.RefleshCompleateEvent != null)
{
ConferenceTreeItem.RefleshCompleateEvent();
}
goIntoReflesh = true;
}
}));
ConferenceTreeItem.AcademicReviewItemList.Add(this);
}
}
}
catch (Exception ex)
{
LogManage.WriteLog(typeof(ConferenceTreeItem), ex);
}
}
/// <summary>
/// 使用递归方式删除子节点
/// </summary>
/// <param name="parentGuid"></param>
public static void ItemDeleteRecursion(int parentGuid)
{
try
{
#region 相对应的子节点也得删除
//遍历记录所有知识树的记录
for (int i = ConferenceTreeItem.AcademicReviewItemList.Count - 1; i > -1; i--)
{
var item = ConferenceTreeItem.AcademicReviewItemList[i];
//若该节点的GUID为当前遍历所指定的子节点的父节点GUID,则证明了该节点为遍历所之指定的节点的父节点，父几点删除，子节点一样得进行删除
if (item.ParentGuid.Equals(parentGuid))
{
//清空附加数据
ConferenceTreeItem.ClearAddData(item);
//使用递归的方式以同样是方式操作子节点
if (item != null)
{
ItemDeleteRecursion(item.ACA_Guid);
}
else
{
return;
}
}
}
#endregion
}
catch (Exception ex)
{
LogManage.WriteLog(typeof(ConferenceTreeItem), ex);
}
finally
{
}
}
/// <summary>
/// 节点选择
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void ConferenceTreeItem_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
try
{
//释放选择
if (currentConferenceTreeItem != null)
{
currentConferenceTreeItem.SelectedVisibility = vy.Collapsed;
}
//绑定节点
currentConferenceTreeItem = this;
//显示选择
currentConferenceTreeItem.SelectedVisibility = vy.Visible;
//選擇事件回調
this.SelectedItemCallEvent();
}
catch (Exception ex)
{
LogManage.WriteLog(this.GetType(), ex);
}
finally
{
}
}
/// <summary>
/// 记住如果重新进入一个会议室,该实例弃用,把描述静态的实例释放
/// </summary>
public static void SessionClear()
{
try
{
//清除所有节点附加数据
for (int i = ConferenceTreeItem.AcademicReviewItemList.Count - 1; i > -1; i--)
{
ConferenceTreeItem.ClearAddData(ConferenceTreeItem.AcademicReviewItemList[i]);
}
ConferenceTreeItem.goIntoReflesh = true;
//记录所有知识树的记录清空
ConferenceTreeItem.AcademicReviewItemList.Clear();
//GUID集合清除
ConferenceTreeItem.retunList.Clear();
//根记录恢复为默认值
ConferenceTreeItem.RootCount = 0;
//评论关联的子节点恢复为默认值
ConferenceTreeItem.currentConferenceTreeItem = null;
}
catch (Exception ex)
{
LogManage.WriteLog(typeof(ConferenceTreeItem), ex);
}
}
/// <summary>
/// 子项拖动完成（鼠标点击弹起事件）
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ConferenceTreeView_PreviewMouseRightButtonUp(object sender, MouseButtonEventArgs e)
{
try
{
if (this.conferenceTreeItemVisual.Visibility == System.Windows.Visibility.Visible)
{
ConferenceTreeItem currentItem = ConferenceTreeItem.currentConferenceTreeItem;
if (currentItem != null)
{
//鼠标点击释放了，不可再拖动
currentItem.isDrag = false;
Point pos = e.GetPosition(this.borDiscussTheme);
HitTestResult result = VisualTreeHelper.HitTest(this.borDiscussTheme, pos);
if (result == null)
{
//显示虚拟拖拽节点
ConferenceTreeView.conferenceTreeView.conferenceTreeItemVisual.Visibility = System.Windows.Visibility.Collapsed;
return;
}
else
{
//显示虚拟拖拽节点
ConferenceTreeView.conferenceTreeView.conferenceTreeItemVisual.Visibility = System.Windows.Visibility.Collapsed;
}
ConferenceTreeItem conferenceTreeItem = WPFElementManage.FindVisualParent <ConferenceTreeItem>(result.VisualHit); // Find your actual visual you want to drag
if (conferenceTreeItem == null)
{
return;
}
if (conferenceTreeItem == currentItem)
{
return;
}
#region old solution
//ConferenceTreeItemTransferEntity beforeTransferItem = currentItem.AcademicReviewItemTransferEntity;
//ConferenceTreeItemTransferEntity nowTransferItem = conferenceTreeItem.AcademicReviewItemTransferEntity;
////存储选择协议实体和目标协议实体标题
//string title1 = beforeTransferItem.Title;
//string title2 = nowTransferItem.Title;
////存储选择协议实体和目标协议实体评论
//string coment1 = beforeTransferItem.Comment;
//string coment2 = nowTransferItem.Comment;
////存储选择协议实体和目标协议实体链接
//List<string> list1 = beforeTransferItem.LinkList.ToList<string>();
//List<string> list2 = nowTransferItem.LinkList.ToList<string>();
//beforeTransferItem.Title = title2;
//nowTransferItem.Title = title1;
//beforeTransferItem.Comment = coment2;
//nowTransferItem.Comment = coment1;
//beforeTransferItem.LinkList = list2;
//nowTransferItem.LinkList = list1;
#endregion
if (CheckCanInsteadElement(currentItem, conferenceTreeItem))
{
//conferenceTreeItem.ContentVisibility = System.Windows.Visibility.Visible;
ModelManage.ConferenceTree.InsteadElement(TreeCodeEnterEntity.ConferenceName, currentItem.ACA_Guid, conferenceTreeItem.ACA_Guid, new Action <bool>((successed) =>
{
}));
}
}
}
}
catch (Exception ex)
{
LogManage.WriteLog(this.GetType(), ex);
}
finally
{
}
}
/// <summary>
/// 显示操作提示
/// </summary>
/// <param name="item"></param>
public static void ShowOperationTip(ConferenceTreeItem item, string operater)
{
try
{
if (!operater.Equals(TreeCodeEnterEntity.SelfName))
{
#region 显示操作提示
if (!string.IsNullOrEmpty(item.TitleOperationer) && item.TitleOperationer.Equals(operater))
{
if (item.OperationVisibilityTimer != null)
{
item.CanSettingEditCollpased = false;
item.OperationVisibilityTimer.Stop();
item.OperationVisibilityTimer = null;
TimerJob.StartRun(new Action(() =>
{
item.OperationVisibility = Visibility.Collapsed;
item.IsLocked = true;
item.CanSettingEditCollpased = true;
if (item.OperationVisibilityTimer != null)
{
item.OperationVisibilityTimer.Stop();
item.OperationVisibilityTimer = null;
}
}), 3000, out item.OperationVisibilityTimer);
}
else
{
TimerJob.StartRun(new Action(() =>
{
if (item.CanSettingEditCollpased)
{
item.OperationVisibility = Visibility.Collapsed;
item.IsLocked = true;
if (item.OperationVisibilityTimer != null)
{
item.OperationVisibilityTimer.Stop();
}
}
}), 3000, out item.OperationVisibilityTimer);
}
}
else
{
TimerJob.StartRun(new Action(() =>
{
if (item.CanSettingEditCollpased)
{
item.OperationVisibility = Visibility.Collapsed;
item.IsLocked = true;
if (item.OperationVisibilityTimer != null)
{
item.OperationVisibilityTimer.Stop();
}
}
}), 3000, out item.OperationVisibilityTimer);
}
item.OperationVisibility = Visibility.Visible;
//操作人
item.TitleOperationer = operater;
//只读
item.IsLocked = false;
//item.txtHelper.Focus();
#endregion
}
}
catch (Exception ex)
{
LogManage.WriteLog(typeof(ConferenceTreeItem), ex);
}
}
/// <summary>
/// 服务器同步删除节点
/// </summary>
public static void Delete_Item(ConferenceTreeItemTransferEntity academicReviewItemTransferEntity)
{
try
{
//声明一个知识树节点
ConferenceTreeItem academicReviewChild = null;
//指定父节点，通过关联记录所有知识树的记录中获取（根据服务器传过来的知识树协议实体的父节点的GUID来判断）
if (academicReviewItemTransferEntity.Guid != 0)
{
for (int i = 0; i < ConferenceTreeItem.AcademicReviewItemList.Count; i++)
{
//记录所有知识树的记录里获取同协议实体相同GUID的子节点
academicReviewChild = ConferenceTreeItem.AcademicReviewItemList[i];
//对应协议实体的GUID
if (academicReviewChild.ACA_Guid.Equals(academicReviewItemTransferEntity.Guid))
{
//父节点容器删除该子节点
academicReviewChild.ACA_Parent.StackPanel.Children.Remove(academicReviewChild);
//父节点的子项集合删除该节点
academicReviewChild.ACA_Parent.ACA_ChildList.Remove(academicReviewChild);
//清空附加数据
ConferenceTreeItem.ClearAddData(academicReviewChild);
#region 相对应的子节点也得删除
//使用递归方式删除子节点
ConferenceTreeItem.ItemDeleteRecursion(academicReviewItemTransferEntity.Guid);
#endregion
break;
}
}
}
//该为根节点
else
{
for (int i = 0; i < ConferenceTreeItem.AcademicReviewItemList.Count; i++)
{
//记录所有知识树的记录里获取同协议实体相同GUID的子节点
academicReviewChild = ConferenceTreeItem.AcademicReviewItemList[i];
//对应协议实体的GUID
if (academicReviewChild.ACA_Guid.Equals(academicReviewItemTransferEntity.Guid))
{
//父节点容器删除所有子节点
academicReviewChild.StackPanel.Children.Clear();
//父节点的子项集合删除所有节点
academicReviewChild.ACA_ChildList.Clear();
//通过遍历去清空所有子节点
for (int j = ConferenceTreeItem.AcademicReviewItemList.Count - 1; j > -1; j--)
{
ConferenceTreeItem item = ConferenceTreeItem.AcademicReviewItemList[j];
//根节点没有父类
if (item.ACA_Parent != null)
{
//记录所有知识树的记录删除该节点
ConferenceTreeItem.AcademicReviewItemList.RemoveAt(j);
//清空附加数据
ConferenceTreeItem.ClearAddData(item);
}
}
break;
}
}
}
}
catch (Exception ex)
{
LogManage.WriteLog(typeof(ConferenceTreeItem), ex);
}
}
/// <summary>
/// 知识树子节点点对点进行同步
/// </summary>
/// <param name="result"></param>
public static void Information_Sync(ConferenceTreeItemTransferEntity result)
{
try
{
//树视图启动
ConferenceTreeView.conferenceTreeView.IsStart = true;
switch (result.Operation)
{
//添加节点
case ConferenceTreeOperationType.AddType:
Add_Item(result);
ShowSummerUpdateView();
break;
//删除节点
case ConferenceTreeOperationType.DeleteType:
Delete_Item(result);
ShowSummerUpdateView();
break;
//更新节点
case ConferenceTreeOperationType.UpdateType:
UpdateItem(result);
ShowSummerUpdateView();
break;
//刷新
case ConferenceTreeOperationType.RefleshAllType:
ConferenceTreeItem.SessionClear();
//重新加载一个新实例
ConferenceTreeView.conferenceTreeView.ConferenceTreeItem.ParametersInit();
break;
case ConferenceTreeOperationType.FocusType1:
//剔除标题焦点
RemoveTittleFocus(result);
break;
case ConferenceTreeOperationType.FocusType2:
//剔除评论焦点
RemoveCommentFocus(result);
break;
case ConferenceTreeOperationType.LinkAdd:
UpdateItemLink(result);
ShowSummerUpdateView();
break;
case ConferenceTreeOperationType.UpdateComment:
UpdateItemComment(result);
ShowSummerUpdateView();
break;
case ConferenceTreeOperationType.UpdateTittle:
UpdateItemTittle(result);
ShowSummerUpdateView();
break;
default:
break;
}
}
catch (Exception ex)
{
LogManage.WriteLog(typeof(ConferenceTreeItem), ex);
}
}
/// <summary>
/// 刷新知识树
/// </summary>
/// <param name="result"></param>
void Reflesh(ConferenceTreeInitRefleshEntity result)
{
try
{
//根记录同步
ConferenceTreeItem.RootCount = result.RootCount;
//rootParent(只有根节点是没有的，所有可以判断该节点为根节点)
if (result != null && result.RootParent_AcademicReviewItemTransferEntity != null)
{
//绑定根节点的协议实体
this.AcademicReviewItemTransferEntity = result.RootParent_AcademicReviewItemTransferEntity;
//设置根节点的标题
this.ACA_Tittle = this.AcademicReviewItemTransferEntity.Title;
//设置根节点的评论
this.ACA_Comment = this.AcademicReviewItemTransferEntity.Comment;
//有备注内容
if (!string.IsNullOrEmpty(this.AcademicReviewItemTransferEntity.Comment))
{
//显示备注弹出按钮
this.CommentCommandVisibility = System.Windows.Visibility.Visible;
}
//有附件列表
if (this.AcademicReviewItemTransferEntity.LinkList != null && this.AcademicReviewItemTransferEntity.LinkList.Count > 0)
{
//显示附件列表弹出按钮
this.LinkCommandVisibility = System.Windows.Visibility.Visible;
}
foreach (var link in AcademicReviewItemTransferEntity.LinkList)
{
string fileName = System.IO.Path.GetFileName(link);
this.LinkListItemAdd(fileName, link);
}
}
//根节点的衍生子节点
if (result.AcademicReviewItemTransferEntity_ObserList != null && result.AcademicReviewItemTransferEntity_ObserList.Count() > 0)
{
//进行后续的关联
for (int i = 0; i < ConferenceTreeItem.AcademicReviewItemList.Count; i++)
{
//记录所有知识树的记录
ConferenceTreeItem entityItem = ConferenceTreeItem.AcademicReviewItemList[i];
foreach (var transferItem in result.AcademicReviewItemTransferEntity_ObserList)
{
//映射集合GUID
if (!ConferenceTreeItem.retunList.Contains(transferItem.Guid))
{
//添加GUID
ConferenceTreeItem.retunList.Add(transferItem.Guid);
}
//父节点加载子节点
if (transferItem.ParentGuid.Equals(entityItem.ACA_Guid))
{
//生成子节点
ConferenceTreeItem academicReviewItem = new ConferenceTreeItem(false)
{
ACA_Parent = entityItem, ParentGuid = entityItem.ACA_Guid, ACA_Guid = transferItem.Guid
};
//节点标题
academicReviewItem.ACA_Tittle = transferItem.Title;
if (!string.IsNullOrEmpty(transferItem.Comment))
{
academicReviewItem.CommentCommandVisibility = System.Windows.Visibility.Visible;
}
if (transferItem.LinkList != null && transferItem.LinkList.Count > 0)
{
academicReviewItem.LinkCommandVisibility = System.Windows.Visibility.Visible;
}
foreach (var link in transferItem.LinkList)
{
string fileName = System.IO.Path.GetFileName(link);
academicReviewItem.LinkListItemAdd(fileName, link);
}
//评论
academicReviewItem.ACA_Comment = transferItem.Comment;
//简介
entityItem.StackPanel.Children.Add(academicReviewItem);
//父节点子节点集合添加该子项
entityItem.ACA_ChildList.Add(academicReviewItem);
//子节点协议实体绑定
academicReviewItem.AcademicReviewItemTransferEntity = transferItem;
//记录所有知识树的记录添加子节点
ConferenceTreeItem.AcademicReviewItemList.Add(academicReviewItem);
}
}
}
}
ConferenceTreeView.ExpanderMethod();
}
catch (Exception ex)
{
LogManage.WriteLog(typeof(ConferenceTreeItem), ex);
}
}
