/// <summary>
/// 给标签节点添加信息节点关联，当用户在树中删除标签节点时，标签节点及其关联的“信息节点关联关系”会删除，但不会删除信息节点本身。
private void AddInfoNodeToLabel()
{
//var dataObj = labeltree.SelectedItem.NodeData.DataItem as LabelNodeDataInfo; 如此获得的数据对象不是数据库信息选项卡中的标签节点的数据对象
//var accessObj = labeltree.SelectedItem.NodeData.AccessObject as LabelNodeAccess;
string labelnodePath = labeltree.SelectedItem.NodeData.DataItem.Path;
//查找节点
TreeViewIconsItem nodeNeedToAddInfoNode = curDbInfoTab.LabelViewObj.SuperTree.Nodes.FirstOrDefault(n => n.Path == labelnodePath);
var dataObj = nodeNeedToAddInfoNode.NodeData.DataItem as LabelNodeDataInfo;
var accessObj = nodeNeedToAddInfoNode.NodeData.AccessObject as LabelNodeAccess;
DBInfoNodeInfo infoNodeInfo = new DBInfoNodeInfo()
{
ModifyTime = DateTime.Now,
//Path= curDbInfoTab.CurrentTreeView.SelectedItem.NodeData.DataItem.Path
Path = InfoNodeDataInfoObj.Path
};
//不加入重复的信息节点
if (dataObj.AttachInfoNodeInfos.IndexOf(infoNodeInfo) == -1)
{
//创建连接字符串
String EFConnectionString = DALConfig.getEFConnectionString(curDbInfoTab.dbInfoObject.DatabaseFilePath);
InfoNodeRepository repository = new InfoNodeRepository(EFConnectionString);
//InfoNodeDataInfo obj = SelectedInfoNodeDataObj.DataItem as InfoNodeDataInfo;
InfoNodeDB dbobj = repository.GetInfoNodeDBWithoutFileInfosByPath(InfoNodeDataInfoObj.Path);
//给标签节点添加标签节点与信息节点的关联
accessObj.AddInfoNodeAssociation(dataObj.Path, infoNodeInfo, dbobj);
dataObj.AttachInfoNodeInfos.Add(infoNodeInfo);
}
}
private void OnTreeViewSelectedItemChanged(object sender, RoutedPropertyChangedEventArgs <object> e)
{
TreeViewIconsItem newSelectedNode = e.NewValue as TreeViewIconsItem;
if (treeView1.IsInEditMode)
{
if (newSelectedNode != null)
{
newSelectedNode.IsSelected = false;
}
return;
}
//更换节点图标
ChangedSelectedNodeIconWhenClick(sender, e);
if (newSelectedNode != null)
{
LoadDataAndShowInUI(newSelectedNode);
}
else
{
//没有选中任何节点，则显示空白的窗体
NodeUIContainer.Content = null;
}
if (visitedNodesManager != null && e.OldValue != null)
{
visitedNodesManager.AddHistoryRecord((e.OldValue as TreeViewIconsItem).Path);
}
}
private void CutNode(object sender, ExecutedRoutedEventArgs e)
{
if (curDbInfoTab.CurrentTreeView.IsInEditMode)
{
curDbInfoTab.CurrentTreeView.SelectedItem.EndEdit();
}
//如果己经有被剪切的节点，则取消它的下划线状态
if (cutNode != null && cutNode != curDbInfoTab.CurrentTreeView.SelectedItem)
{
cutNode.Strikethrough = false;
}
cutNode = curDbInfoTab.CurrentTreeView.SelectedItem as TreeViewIconsItem;
cutNode.Strikethrough = true;
cutNodeSourceTab = curDbInfoTab;
String info = "";
if (cutNode.HeaderText.Length > 30)
{
info = "节点：\"" + cutNode.HeaderText.Substring(0, 30) + "\"己被剪切";
}
else
{
info = "节点：\"" + cutNode.HeaderText + "\"己被剪切";
}
ShowInfo(info);
}
private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
if (findNodesWindow != null)
{
findNodesWindow.ShouldExit = true;
findNodesWindow.Close();
}
//用户没有打开任何数据库文件
if (curDbInfoTab == null)
{
return;
}
if (curDbInfoTab.treeView1.IsInEditMode)
{
curDbInfoTab.treeView1.SelectedItem.EndEdit();
}
SaveDbTabDataToDB(curDbInfoTab);
//更新配置文件内容
DatabaseInfo info = null;
TreeViewIconsItem selectedItem = null;
SystemConfig.configArgus.DbInfos.Clear();
foreach (var item in DBtabContainer.Items)
{
selectedItem = ((item as TabItem).Content as DBInfoTab).treeView1.SelectedItem;
info = ((item as TabItem).Content as DBInfoTab).dbInfoObject;
SystemConfig.configArgus.DbInfos.Add(info);
}
SystemConfig.configArgus.ActiveDBIndex = DBtabContainer.SelectedIndex;
DeepSerializer.BinarySerialize(SystemConfig.configArgus, SystemConfig.ConfigFileName);
}
private void btnGo_Click(object sender, RoutedEventArgs e)
{
if (dgNodes.SelectedItem != null)
{
//先保存原有的节点数据
if (_tree.SelectedItem != null)
{
_tree.SelectedItem.NodeData.DataItem.RefreshMe();
//当前节点如果是OnlyText时，其AccessObj==null，此时不应该更新底层存储
if (_tree.SelectedItem.NodeData.AccessObject != null)
{
try
{
_tree.SelectedItem.NodeData.AccessObject.UpdateDataInfoObject(_tree.SelectedItem.NodeData.DataItem);
}
catch (Exception ex)
{
Dispatcher.Invoke(new Action(() => { MessageBox.Show(ex.ToString()); }));
}
}
}
//显示新数据
TreeViewIconsItem node = dgNodes.SelectedItem as TreeViewIconsItem;
_tree.ShowNode(node.Path);
//如果当前节点不可视，则滚动显示它！
node.BringIntoView();
}
}
private void ChangeNodeIcon(TreeViewIconsItem node, ImageSource newIcon)
{
if (node == null || newIcon == null)
{
return;
}
node.Icon = newIcon;
}
private void ChangeNodeIcon(TreeViewIconsItem node, ImageSource newIcon)
{
if (node == null || newIcon == null)
{
return;
}
node.Icon = newIcon;
}
public void Handle(LoadInfoNodeControlEvent e)
{
//查找节点，显示其内容
if (OutLineViewObj.SuperTree.IsNodeExisted(e.Path))
{
TreeViewIconsItem nodeNeedToLoad = OutLineViewObj.SuperTree.Nodes.FirstOrDefault(n => n.Path == e.Path);
LoadDataAndShowInLabelNodeUI(nodeNeedToLoad);
}
}
private void UpdateDataAcessObject(TreeViewIconsItem root, String EFConnectionString)
{
if (root == null)
{
return;
}
root.NodeData.AccessObject = NodeFactory.CreateNodeAccessObject(root.NodeData.DataItem.NodeType, EFConnectionString);
foreach (var node in root.Items)
{
UpdateDataAcessObject(node as TreeViewIconsItem, EFConnectionString);
}
}
private void RenameNode(object sender, ExecutedRoutedEventArgs e)
{
if (curDbInfoTab.CurrentTreeView.IsInEditMode)
{
curDbInfoTab.CurrentTreeView.SelectedItem.EndEdit();
}
TreeViewIconsItem selectedNode = curDbInfoTab.CurrentTreeView.SelectedItem as TreeViewIconsItem;
if (selectedNode != null)
{
selectedNode.BeginEdit();
}
}
/// <summary>
/// 再标签节点中显示信息节点内容
/// </summary>
/// <param name="newSelectedNode"></param>
private void LoadDataAndShowInLabelNodeUI(TreeViewIconsItem newSelectedNode)
{
NodeDataObject dataInfoObject = newSelectedNode.NodeData;
//正确地设置可视化界面所关联的数据存取对象
dataInfoObject.DataItem.SetRootControlDataAccessObj(dataInfoObject.AccessObject);
//检查一下数据是否己被装入
if (!dataInfoObject.DataItem.HasBeenLoadFromStorage)
{
//装入数据
IDataInfo dataObj = dataInfoObject.AccessObject.GetDataInfoObjectByPath(newSelectedNode.Path);
if (dataObj != null)
{
//给将己装入数据的对象添加对主窗体的引用
if (NodeFactory._mainWindow != null)
{
dataObj.MainWindow = NodeFactory._mainWindow;
}
//把节点数据对象挂到节点上
newSelectedNode.NodeData.DataItem = dataObj;
}
}
if (dataInfoObject.DataItem.ShouldEmbedInHostWorkingBench)
{
if (dataInfoObject.DataItem.RootControl.Parent != null)
{
(dataInfoObject.DataItem.RootControl.Parent as ContentControl).Content = null;
}
(NodeUIContainer.Content as LabelNodeControl).InnerContainer.Content = dataInfoObject.DataItem.RootControl;
if (dataInfoObject.DataItem.RootControl is InfoNodeControl)
{
(dataInfoObject.DataItem.RootControl as InfoNodeControl).InnerSuperRichTextBox.EditorTool = EditorTool;
}
//根节点不显示内容
if (newSelectedNode.Parent is TreeView)
{
NodeUIContainer.Content = null;
}
}
//显示最新的数据
dataInfoObject.DataItem.BindToRootControl();
dataInfoObject.DataItem.RefreshDisplay();
}
/// <summary>
/// 当用户在TreeView上右击鼠标时，设置当前选中的节点
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void treeView1_PreviewMouseRightButtonDown(object sender, MouseButtonEventArgs e)
{
IInputElement currentElement = treeView1.InputHitTest(e.GetPosition(treeView1));
TreeViewIconsItem node = GetNodeUnderMouseCursor(currentElement as DependencyObject);
if (node != null)
{
node.IsSelected = true;
}
else
{
e.Handled = true;
}
}
private void CreateAssociation()
{
//创建连接字符串
String EFConnectionString = DALConfig.getEFConnectionString(curDbInfoTab.dbInfoObject.DatabaseFilePath);
string labelnodePath = labeltree.SelectedItem.NodeData.DataItem.Path;
string infoNodePath = InfoNodeDataInfoObj.Path;
//创建多对多关联时，对信息节点与标签节点在数据库中均存在的，不能直接修改数据库表或实体类，而应该修改关联关系
using (MyDBEntities context = new MyDBEntities(EFConnectionString))
{
var infoNode = context.InfoNodeDBs.FirstOrDefault(p => p.Path == infoNodePath);
var labelNode = context.LabelNodeDBs.FirstOrDefault(p => p.Path == labelnodePath);
if (infoNode != null && labelNode != null)
{
infoNode.LabelNodeDBs.Add(labelNode);
labelNode.InfoNodeDBs.Add(infoNode);
//context.LabelNodeDBs.Add(labelNode);//不能再添加了否则数据库中会多出一个ID不同的labelNode
// context.InfoNodeDBs.Add(infoNode);//不能再添加了否则数据库中会多出一个ID不同的infoNode
int r = context.SaveChanges();
//给标签添加信息绑定
DBInfoNodeInfo infoNodeInfo = new DBInfoNodeInfo()
{
ID = infoNode.ID,
ModifyTime = DateTime.Now,
Path = InfoNodeDataInfoObj.Path
};
//查找节点
TreeViewIconsItem nodeNeedToAddInfoNode = curDbInfoTab.LabelViewObj.SuperTree.Nodes.FirstOrDefault(n => n.Path == labelnodePath);
var dataObj = nodeNeedToAddInfoNode.NodeData.DataItem as LabelNodeDataInfo;
//不加入重复的信息节点
if (dataObj.AttachInfoNodeInfos.IndexOf(infoNodeInfo) == -1)
{
dataObj.AttachInfoNodeInfos.Add(infoNodeInfo);
}
//给信息添加标签绑定
DBLabelInfo labelInfo = new DBLabelInfo()
{
ID = labelNode.ID,
ModifyTime = DateTime.Now,
Path = labelnodePath,
// Label = selectedlabel
};
if (InfoNodeDataInfoObj.AttachLabels.IndexOf(labelInfo) == -1)
{
InfoNodeDataInfoObj.AttachLabels.Add(labelInfo);
}
}
}
}
private void DeleteNode(object sender, ExecutedRoutedEventArgs e)
{
if (curDbInfoTab.CurrentTreeView.IsInEditMode)
{
curDbInfoTab.CurrentTreeView.SelectedItem.EndEdit();
}
//删除多级节点时询问用户
TreeViewIconsItem selectedNode = curDbInfoTab.CurrentTreeView.SelectedItem as TreeViewIconsItem;
if (selectedNode != null && curDbInfoTab.CurrentTreeView.GetChildren(selectedNode).Count > 0)
{
MessageBoxResult result = MessageBox.Show("您将要删除一个包含有下级信息的节点，删除操作不可恢复，真的进行吗？", "删除节点", MessageBoxButton.OKCancel);
if (result == MessageBoxResult.Cancel)
{
return;
}
}
curDbInfoTab.CurrentTreeView.DeleteNode(selectedNode);
//保存树结构
curDbInfoTab.SaveTreeToDB();
//此时可能出现一个WPF中的bug，当删除树窗口中最后一个节点时，会导致树窗口内部卡死，添加的节点实际存在但无法显示在树窗口中，于是在此处重新添加视图，以避开此bug
if (curDbInfoTab.CurrentTreeView.Nodes.Count == 0)
{
//findNodesWindow.ShouldExit = true;
//Close();
//Process.Start(Assembly.GetEntryAssembly().Location);
if (curDbInfoTab.CurrentTreeView.TreeNodeType == "InfoNode")
{
curDbInfoTab.OutLineViewObj = new OutLineView(curDbInfoTab);
curDbInfoTab.OutLineViewObj.SuperTree.EFConnectionString = DALConfig.getEFConnectionString(curDbInfoTab.dbInfoObject.DatabaseFilePath);
curDbInfoTab.InnerTabControl.SelectedIndex = 1;
curDbInfoTab.InnerTabControl.SelectedIndex = 0;
}
if (curDbInfoTab.CurrentTreeView.TreeNodeType == "LabelNode")
{
curDbInfoTab.LabelViewObj = new LabelView(curDbInfoTab);
curDbInfoTab.LabelViewObj.SuperTree.EFConnectionString = DALConfig.getEFConnectionString(curDbInfoTab.dbInfoObject.DatabaseFilePath);
curDbInfoTab.InnerTabControl.SelectedIndex = 0;
curDbInfoTab.InnerTabControl.SelectedIndex = 1;
}
}
}
/// <summary>
/// 删除节点时，在节点集合中删除它及所有子节点
/// </summary>
/// <param name="node"></param>
public void DeleteNode(TreeViewIconsItem node)
{
if (node == null)
{
return;
}
var query = from n in nodes
where n.Path.StartsWith(node.Path)
select n;
List<TreeViewIconsItem> nodesToBeDeletes = query.ToList() ;
foreach (var n in nodesToBeDeletes)
{
nodes.Remove(n);
}
}
/// <summary>
/// 当用户点击树节点时，切换节点图标
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void ChangedSelectedNodeIconWhenClick(object sender, RoutedPropertyChangedEventArgs <object> e)
{
//将老节点的图标改为默认的文件夹图标
TreeViewIconsItem oldNode = e.OldValue as TreeViewIconsItem;
if (oldNode != null)
{
ChangeNodeIcon(oldNode, oldNode.NodeData.DataItem.NormalIcon);
}
//设置新节点图标
TreeViewIconsItem selectedNode = e.NewValue as TreeViewIconsItem;
if (selectedNode != null)
{
ChangeNodeIcon(selectedNode, selectedNode.NodeData.DataItem.SelectedIcon);
}
}
/// <summary>
/// 用于代表当前节点移动的类型
/// </summary>
// private NodeMoveType curNodeMove=NodeMoveType.NodeNotMove ;
public void OnNodeMove(NodeMoveType moveType)
{
// curNodeMove = moveType;
if (treeView1.IsInEditMode)
{
treeView1.SelectedItem.EndEdit();
}
TreeViewIconsItem selectedNode = treeView1.SelectedItem;
//还原默认节点图标
ChangeNodeIcon(treeView1.SelectedItem, treeView1.SelectedItem.NodeData.DataItem.NormalIcon);
switch (moveType)
{
case NodeMoveType.NodeMoveUp:
treeView1.MoveUp(selectedNode);
break;
case NodeMoveType.NodeMoveDown:
treeView1.MoveDown(selectedNode);
break;
case NodeMoveType.NodeMoveLeft:
treeView1.MoveLeft(selectedNode);
break;
case NodeMoveType.NodeMoveRight:
treeView1.MoveRight(selectedNode);
break;
case NodeMoveType.NodePaste:
//todo:paste!
break;
default:
break;
}
SaveTreeToDB();
//更新节点图标
ChangeNodeIcon(treeView1.SelectedItem, treeView1.SelectedItem.NodeData.DataItem.SelectedIcon);
//SaveTreeToFile();
}
/// <summary>
/// 为新节点提取数据并显示
/// </summary>
/// <param name="newSelectedNode"></param>
private void LoadDataAndShowInUI(TreeViewIconsItem newSelectedNode)
{
if (newSelectedNode.NodeData.DataItem.NodeType == "OnlyText")
{
NodeUIContainer.Content = null;
newSelectedNode.NodeData.DataItem.RefreshDisplay();
return;
}
NodeDataObject dataInfoObject = newSelectedNode.NodeData;
//正确地设置可视化界面所关联的数据存取对象
dataInfoObject.DataItem.SetRootControlDataAccessObj(dataInfoObject.AccessObject);
//检查一下数据是否己被装入
if (!dataInfoObject.DataItem.HasBeenLoadFromStorage)
{
//装入数据
IDataInfo dataObj = dataInfoObject.AccessObject.GetDataInfoObjectByPath(newSelectedNode.Path);
if (dataObj != null)
{
//给将己装入数据的对象添加对主窗体的引用
if (NodeFactory._mainWindow != null)
{
dataObj.MainWindow = NodeFactory._mainWindow;
}
//把节点数据对象挂到节点上
newSelectedNode.NodeData.DataItem = dataObj;
}
}
if (dataInfoObject.DataItem.ShouldEmbedInHostWorkingBench)
{
if (dataInfoObject.DataItem.RootControl.Parent != null)
{
(dataInfoObject.DataItem.RootControl.Parent as ContentControl).Content = null;
}
NodeUIContainer.Content = dataInfoObject.DataItem.RootControl;
}
//显示最新的数据
dataInfoObject.DataItem.BindToRootControl();
dataInfoObject.DataItem.RefreshDisplay();
}
public void Handle(FileCountChangedEvent e)
{
TreeViewIconsItem node = OutLineViewObj.SuperTree.Nodes.FirstOrDefault(n => n.Path == e.DataInfo.Path);
if (node != null)
{
if (e.IsHaveFile)
{
ChangeNodeIcon(node, node.NodeData.DataItem.NewIcon);
node.NodeData.DataItem.IconType = "FileIcon";
SaveTreeToDB(OutLineViewObj.SuperTree);
}
else
{
ChangeNodeIcon(node, node.NodeData.DataItem.NormalIcon);
node.NodeData.DataItem.IconType = "InfoNode";
SaveTreeToDB(OutLineViewObj.SuperTree);
}
}
}
private void DeleteNode(object sender, ExecutedRoutedEventArgs e)
{
if (curDbInfoTab.treeView1.IsInEditMode)
{
curDbInfoTab.treeView1.SelectedItem.EndEdit();
}
//删除多级节点时询问用户
TreeViewIconsItem selectedNode = curDbInfoTab.treeView1.SelectedItem as TreeViewIconsItem;
if (selectedNode != null && curDbInfoTab.treeView1.GetChildren(selectedNode).Count > 0)
{
MessageBoxResult result = MessageBox.Show("您将要删除一个包含有下级信息的节点，删除操作不可恢复，真的进行吗？", "删除节点", MessageBoxButton.OKCancel);
if (result == MessageBoxResult.Cancel)
{
return;
}
}
curDbInfoTab.treeView1.DeleteNode(selectedNode);
//保存树结构
curDbInfoTab.SaveTreeToDB();
}
/// <summary>
/// 将指定选项卡的数据保存到数据库中
/// </summary>
/// <param name="infoTab"></param>
private void SaveDbTabDataToDB(DBInfoTab infoTab)
{
TreeViewIconsItem selectedItem = infoTab.CurrentTreeView.SelectedItem;
DatabaseInfo info = infoTab.dbInfoObject;
if (selectedItem != null)
{
if (infoTab.CurrentTreeView == infoTab.OutLineViewObj.SuperTree || infoTab.CurrentTreeView == infoTab.LabelViewObj.SuperTree)
{
info.LastVisitNodePath = selectedItem.Path;
if (infoTab.CurrentTreeView == infoTab.OutLineViewObj.SuperTree)
{
infoTab.dbInfoObject.LastTabViewIndex = 0;
}
if (infoTab.CurrentTreeView == infoTab.LabelViewObj.SuperTree)
{
infoTab.dbInfoObject.LastTabViewIndex = 1;
}
}
IDataAccess accessobj = selectedItem.NodeData.AccessObject;
IDataInfo infoObj = selectedItem.NodeData.DataItem;
if (accessobj != null)
{
try
{
infoObj.RefreshMe();
accessobj.UpdateDataInfoObject(infoObj);
}
catch (Exception ex)
{
Dispatcher.Invoke(new Action(() => { MessageBox.ShowInformation(ex.ToString()); }));
}
}
}
}
/// <summary>
/// 将指定选项卡的数据保存到数据库中
/// </summary>
/// <param name="infoTab"></param>
private void SaveDbTabDataToDB(DBInfoTab infoTab)
{
TreeViewIconsItem selectedItem = infoTab.treeView1.SelectedItem;
DatabaseInfo info = infoTab.dbInfoObject;
if (selectedItem != null)
{
info.LastVisitNodePath = selectedItem.Path;
IDataAccess accessobj = selectedItem.NodeData.AccessObject;
IDataInfo infoObj = selectedItem.NodeData.DataItem;
if (accessobj != null)
{
try
{
infoObj.RefreshMe();
accessobj.UpdateDataInfoObject(infoObj);
}
catch (Exception ex)
{
Dispatcher.Invoke(new Action(() => { MessageBox.Show(ex.ToString()); }));
}
}
}
}
void DBtabContainer_TabPageClosed(object sender, TabPageClosedEventArgs e)
{
//保存被关闭的选项卡的数据
DBInfoTab closedTab = e.ClosedTabItem.Content as DBInfoTab;
//如果被关闭的是包容有被剪切节点的选项卡，则设置相关的变量为null
if (cutNodeSourceTab != null && cutNodeSourceTab == closedTab)
{
cutNodeSourceTab = null;
cutNode = null;
}
//从参数中移除本选项卡所对应的DbInfo对象
int index = SystemConfig.configArgus.DbInfos.IndexOf(closedTab.dbInfoObject);
if (index != -1)
{
SystemConfig.configArgus.DbInfos.RemoveAt(index);
}
SaveDbTabDataToDB(closedTab);
}
private void PasteNode(object sender, ExecutedRoutedEventArgs e)
{
if (curDbInfoTab.CurrentTreeView.IsInEditMode)
{
curDbInfoTab.CurrentTreeView.SelectedItem.EndEdit();
}
if (cutNode == null || cutNodeSourceTab == null)
{
return;
}
TreeViewIconsItem selectedNode = curDbInfoTab.CurrentTreeView.SelectedItem as TreeViewIconsItem;
if (selectedNode == cutNode)
{
return;
}
String newPath = "";
if (selectedNode == null)//如果目标选项卡中没有选中任何节点，则默认添加到根节点
{
newPath = "/" + cutNode.HeaderText + "/";
}
else
{
newPath = selectedNode.Path + cutNode.HeaderText + "/";
}
if (curDbInfoTab.CurrentTreeView.IsNodeExisted(newPath))
{
MessageBox.ShowInformation("在此处粘贴将导致两个节点拥有相同的路径，因此，请在其他地方粘贴");
return;
}
//在同一数据库中粘贴
if (curDbInfoTab == cutNodeSourceTab)
{
//先移除被剪切的子树
curDbInfoTab.CurrentTreeView.CutNode(cutNode);
curDbInfoTab.CurrentTreeView.PasteNode(cutNode, selectedNode);
curDbInfoTab.OnNodeMove(NodeMoveType.NodePaste);
}
else
{
//在不同的数据库中粘贴
String sourcePath = cutNode.Path;
String targetPath = "";
if (selectedNode != null)
{
targetPath = selectedNode.Path;
}
else
{
targetPath = "/";
}
//先移除源树中被剪切的子树
cutNodeSourceTab.CurrentTreeView.CutNode(cutNode);
//将剪切的节点子树追加到当前节点
curDbInfoTab.CurrentTreeView.PasteNodeCrossDB(cutNode, selectedNode);
//保存目标树结构
curDbInfoTab.CurrentTreeView.SaveToDB();
//将源树保存到数据库中
cutNodeSourceTab.CurrentTreeView.SaveToDB();
//更新所有粘贴节点的数据存取对象
String EFConnectionString = DALConfig.getEFConnectionString(curDbInfoTab.dbInfoObject.DatabaseFilePath);
if (selectedNode != null)
{
UpdateDataAcessObject(selectedNode, EFConnectionString);
}
else
{
UpdateDataAcessObject(cutNode, EFConnectionString);
}
//更新数据库中内容
NodeMoveBetweenDBManager nodeMoveManager = new NodeMoveBetweenDBManager(cutNodeSourceTab.dbInfoObject.DatabaseFilePath, curDbInfoTab.dbInfoObject.DatabaseFilePath);
nodeMoveManager.MoveNodeBetweenDB(sourcePath, targetPath);
}
//取消删除线显示
cutNode.Strikethrough = false;
cutNode = null;
cutNodeSourceTab = null;
if (curDbInfoTab.CurrentTreeView.SelectedItem != null)
{
curDbInfoTab.CurrentTreeView.SelectedItem.IsExpanded = true;
}
}
/// <summary>
/// 左移（即升级）
/// 1.已是顶级节点则不动
/// 2.成为父节点的兄弟
/// </summary>
/// <param name="node"></param>
public void MoveLeft(TreeViewIconsItem node)
{
if (node == null)
{
return;
}
//己经是顶级节点
if (IsFirstLevelNode(node))
{
return;
}
//记录下当前路径
String oldPath = node.Path;
//查找父节点
TreeViewIconsItem parent = GetParent(node) as TreeViewIconsItem;
int parentIndex = GetNodeIndex(parent);
//查找爷爷节点
ItemsControl grandfather = GetParent(parent);
String newPath="";
//获取新路径
if (grandfather == tree)
{
newPath = "/" + node.HeaderText + "/";
}
else
{
newPath = (grandfather as TreeViewIconsItem).Path + node.HeaderText + "/";
}
if (IsNodeExisted(newPath))
{
MessageBox.Show("己经存在相同路径的节点，不允许升级");
return;
}
tree.BeginInit();
//先移除自己
parent.Items.Remove(node);
//插入成为父亲的兄弟节点
grandfather.Items.Insert(parentIndex + 1, node);
node.Path=newPath;
node.NodeData.DataItem.Path = newPath;
//更新所有内存相关子节点集合的路径
nodesManager.UpdateNodePath(oldPath, newPath);
//更新数据库中相关子节点的路径
NodePathManager.UpdateNodePath(oldPath, newPath);
node.IsSelected = true;
tree.EndInit();
//激发事件
if (NodeMove != null)
{
NodeMoveEventArgs e = new NodeMoveEventArgs
{
MoveType = NodeMoveType.NodeMoveLeft,
Node = node,
PrevPath=oldPath
};
NodeMove(node, e);
}
}
/// <summary>
/// 粘贴节点并自动更新相关的内存及数据库中的记录
/// 要求被剪切的节点必须是“独立”的（其Parent属性==null)
/// </summary>
/// <param name="nodeToBeCut">被剪切的节点</param>
/// <param name="attachToNode">将接收被剪切节点的那个节点</param>
public void PasteNode(TreeViewIconsItem nodeToBeCut, TreeViewIconsItem attachToNode)
{
PasteNode(nodeToBeCut, attachToNode, false);
}
private void AddNode(AddNodeCategory category)
{
string treeNodeType = labeltree.TreeNodeType;
//为新节点生成默认文本
String NodeText = MainWin.getDefaultNodeText(treeNodeType) + (labeltree.NodeCount + 1);
//尝试从剪贴板中提取文本
String textFromClipboard = StringUtils.getFirstLineOfString(Clipboard.GetText());
if (String.IsNullOrEmpty(textFromClipboard) == false && textFromClipboard != LastPasteNodeText && textFromClipboard.IndexOf("/") == -1)
{
//检测一下从剪贴板中获取的文本是否有效（即不会导致重名的节点出现）
String newNodeText = textFromClipboard;
bool nodeExisted = labeltree.IsNodeExisted(MainWin.getNewNodePath(category, newNodeText));
//如果不存在同名的路径
if (nodeExisted == false)
{
NodeText = newNodeText;
LastPasteNodeText = NodeText;
}
}
//如果还有重复路径的，则循环使用随机数，务必保证路径不会相同
while (labeltree.IsNodeExisted(MainWin.getNewNodePath(category, NodeText)))
{
NodeText = MainWin.getDefaultNodeText(treeNodeType) + new Random().Next() as string;
}
//创建默认的节点数据对象
NodeDataObject dataobject = NodeFactory.CreateDataInfoNode(treeNodeType, DALConfig.getEFConnectionString(curDbInfoTab.dbInfoObject.DatabaseFilePath));
TreeViewIconsItem newNode = null;
//在树中添加节点
switch (category)
{
case AddNodeCategory.AddRoot:
newNode = labeltree.AddRoot(NodeText, dataobject);
curDbInfoTab.LabelViewObj.SuperTree.AddRoot(NodeText, dataobject);
break;
case AddNodeCategory.AddChild:
newNode = labeltree.AddChild(NodeText, dataobject);
curDbInfoTab.LabelViewObj.SuperTree.AddChild(NodeText, dataobject);
break;
case AddNodeCategory.AddSibling:
newNode = labeltree.AddSibling(NodeText, dataobject);
curDbInfoTab.LabelViewObj.SuperTree.AddSibling(NodeText, dataobject);
break;
default:
break;
}
if (newNode == null)
{
return;
}
//新节点，默认不是粗体的
newNode.FontWeight = FontWeights.Normal;
//在数据库中创建记录
if (dataobject.AccessObject != null)
{
dataobject.AccessObject.Create(dataobject.DataItem);
}
//保存树结构
curDbInfoTab.SaveTreeToDB(labeltree);
//自动进入编辑状态
newNode.BeginEdit();
}
/// <summary>
/// 获取指定节点的所有孩子
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public List<TreeViewIconsItem> GetChildren(TreeViewIconsItem node)
{
if (node == null)
{
return null;
}
List<TreeViewIconsItem> children = new List<TreeViewIconsItem>();
TreeViewIconsItem tempNode = null;
foreach (var item in node.Items)
{
tempNode = item as TreeViewIconsItem;
if (tempNode != null)
children.Add(tempNode);
}
return children;
}
/// <summary>
/// 剪切一个节点
/// </summary>
/// <param name="nodeToBeCut"></param>
public TreeViewIconsItem CutNode(TreeViewIconsItem nodeToBeCut)
{
if (nodeToBeCut == null)
{
return null;
}
ItemsControl parent = GetParent(nodeToBeCut);
parent.Items.Remove(nodeToBeCut);
return nodeToBeCut;
}
// <summary>
/// 从XElement中创建TreeViewIconsItem对象，不理会其子节点
/// </summary>
/// <param name="element"></param>
/// <returns></returns>
private TreeViewIconsItem CreateTreeViewNodeFromXElement(XElement element)
{
if (element == null)
{
return null;
}
NodeDataObject nodeDataObject = NodeFactory.CreateDataInfoNode(element.Attribute("NodeType").Value);
TreeViewIconsItem node = new TreeViewIconsItem(this, nodeDataObject);
node.HeaderText = element.Attribute("Title").Value;
if (element.Attribute("Foreground") != null)
{
String color = element.Attribute("Foreground").Value;
//if (color == "#FFFFFFFF")
//{
// Console.WriteLine("White!");
//}
node.MyForeground = new SolidColorBrush((Color)ColorConverter.ConvertFromString(color));
}
else
{
//默认为黑色
node.Foreground = Brushes.Black;
}
if (element.Attribute("FontWeight")!=null)
{
String FontWeight = element.Attribute("FontWeight").Value;
if (FontWeight != "Normal")
{
node.FontWeight = FontWeights.ExtraBold;
}
else
{
node.FontWeight = FontWeights.Normal;
}
}
node.Icon = nodeDataObject.DataItem.NormalIcon;
return node;
}
private XElement CreateXElementFromTreeViewIconsItem(TreeViewIconsItem node)
{
XElement element = new XElement("TreeNode");
element.SetAttributeValue("Title",node.HeaderText);
element.SetAttributeValue("NodeType", node.NodeData.DataItem.NodeType);
element.SetAttributeValue("FontWeight", node.FontWeight);
if (node.Foreground != Brushes.White)
{
element.SetAttributeValue("Foreground", node.MyForeground);
}
//else
//{
// Console.WriteLine("White!");
//}
return element;
}
/// <summary>
/// 添加节点
/// 成功返回新节点，不成功，返回null
/// 新节点自动展开且选中
/// </summary>
/// <param name="parent"></param>
/// <param name="nodeText"></param>
/// <param name="nodeIcon"></param>
/// <returns></returns>
private TreeViewIconsItem addNode(AddNodeCategory addType, TreeViewIconsItem selectedNode, String nodeText, NodeDataObject nodeDataObject)
{
if (selectedNode != null)
{
selectedNode.IsExpanded = true;
}
TreeViewIconsItem treeNode = new TreeViewIconsItem(this, nodeDataObject);
treeNode.HeaderText = nodeText;
treeNode.Icon = nodeDataObject.DataItem.NormalIcon;
//自动展开
treeNode.IsExpanded = true;
switch (addType)
{
case AddNodeCategory.AddRoot:
treeNode.Path = "/" + nodeText + "/";
nodeDataObject.DataItem.Path = treeNode.Path;
tree.Items.Add(treeNode);
nodesManager.nodes.Add(treeNode);
break;
case AddNodeCategory.AddChild:
if (selectedNode != null)
{
treeNode.Path = selectedNode.Path + nodeText + "/";
nodeDataObject.DataItem.Path = treeNode.Path;
selectedNode.Items.Add(treeNode);
nodesManager.nodes.Add(treeNode);
}
else
{
return null;
}
break;
case AddNodeCategory.AddSibling:
if (selectedNode != null && selectedNode.Parent != null)
{
//如果选中节点是顶层节点
if (selectedNode.Parent == tree)
{
treeNode.Path = "/" + nodeText + "/";
nodeDataObject.DataItem.Path = treeNode.Path;
tree.Items.Add(treeNode);
}
else
{
//不是顶层节点
TreeViewIconsItem parent = selectedNode.Parent as TreeViewIconsItem;
treeNode.Path = parent.Path + nodeText + "/";
nodeDataObject.DataItem.Path = treeNode.Path;
parent.Items.Add(treeNode);
}
nodesManager.nodes.Add(treeNode);
}
else //当前没有选中节点或选中节点没有父亲
{
return null;
}
break;
default:
break;
}
if (_autoSelectNewNode)
{
treeNode.IsSelected = true;
}
//更新树的存储
String treeXml = saveToXmlString();
MainTreeRepository.SaveTree(treeXml);
return treeNode;
}
/// <summary>
/// 将element的所有子节点添加为rootNode的子节点，递归进行
/// </summary>
/// <param name="element"></param>
/// <param name="rootNode"></param>
/// <param name="nodeIcon"></param>
private void AddXmlNodeToTree(XElement element, TreeViewIconsItem rootNode)
{
if (element == null)
{
return;
}
TreeViewIconsItem tempNode = null;
foreach (var item in element.Elements())
{
tempNode = CreateTreeViewNodeFromXElement(item);
tempNode.Path = rootNode.Path + tempNode.HeaderText + "/";
tempNode.NodeData.DataItem.Path = tempNode.Path;
rootNode.Items.Add(tempNode);
nodesManager.nodes.Add(tempNode);
//递归处理树节点
AddXmlNodeToTree(item, tempNode);
}
}
/// <summary>
/// 查找选中节点在本层节点集合中的索引，找不到返回-1
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public int GetNodeIndex(TreeViewIconsItem node)
{
int index = -1;
TreeViewIconsItem tempNode = null;
ItemCollection nodes = null;
if (node.Parent != null)
{
if (node.Parent == tree)
{
//是一级节点，在TreeView的子节点集合中查找
nodes = tree.Items;
}
else
{
//在父节点的子节点集合中查找
nodes = (node.Parent as TreeViewItem).Items;
}
//开始查找
for (int i = 0; i < nodes.Count; i++)
{
tempNode = nodes[i] as TreeViewIconsItem;
if (tempNode.CompareTo(node) == 0)
{
index = i;
break;
}
}
}
return index;
}
/// <summary>
/// 获取前一个兄弟节点
/// 如果己经是第一个了，返回null
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public TreeViewIconsItem GetPrevNode(TreeViewIconsItem node)
{
if (node == null)
{
return null;
}
int index = GetNodeIndex(node);
if (index == 0)
{
return null;
}
if (IsFirstLevelNode(node))
{
return tree.Items[index - 1] as TreeViewIconsItem;
}
else
{
return (node.Parent as TreeViewIconsItem).Items[index - 1] as TreeViewIconsItem;
}
}
/// <summary>
/// 右移（即降级）
/// 1.无兄弟节点则不动
/// 2.如有兄弟节点,则成为上一个兄弟节点的子节点
/// 3.如果本身是所有兄弟节点中的第一个,则成为下一个兄弟的子节点
/// </summary>
/// <param name="node"></param>
public void MoveRight(TreeViewIconsItem node)
{
if (node == null)
{
return;
}
//记录下当前路径
String oldPath = node.Path;
ItemsControl parent = GetParent(node);
//查找兄弟节点
TreeViewIconsItem prevBrother = GetPrevNode(node);
TreeViewIconsItem nextBrother = GetNextNode(node);
//是独子
if (prevBrother == null && nextBrother == null)
{
return;
}
//获取新路径
String newPath = "";
if (prevBrother != null)
{
newPath = prevBrother.Path + node.HeaderText + "/";
}
else
{
newPath = nextBrother.Path + node.HeaderText + "/";
}
if (IsNodeExisted(newPath))
{
MessageBox.Show("已经存在相同路径的节点，不允许降级。");
return;
}
tree.BeginInit();
//删除自己
parent.Items.Remove(node);
//插入
if (prevBrother != null)
{
prevBrother.Items.Add(node);
node.Path = newPath;
node.NodeData.DataItem.Path = newPath;
prevBrother.IsExpanded = true;
}
else
{
nextBrother.Items.Add(node);
node.Path = newPath;
node.NodeData.DataItem.Path = newPath;
nextBrother.IsExpanded = true;
}
//更新所有内存相关子节点集合的路径
nodesManager.UpdateNodePath(oldPath, newPath);
//更新数据库中相关子节点的路径
NodePathManager.UpdateNodePath(oldPath, newPath);
node.IsSelected = true;
tree.EndInit();
//激发事件
if (NodeMove != null)
{
NodeMoveEventArgs e = new NodeMoveEventArgs
{
MoveType = NodeMoveType.NodeMoveRight,
Node = node,
PrevPath = oldPath
};
NodeMove(node, e);
}
}
private void PasteNode(object sender, ExecutedRoutedEventArgs e)
{
if (curDbInfoTab.treeView1.IsInEditMode)
{
curDbInfoTab.treeView1.SelectedItem.EndEdit();
}
if (cutNode == null || cutNodeSourceTab == null)
{
return;
}
TreeViewIconsItem selectedNode = curDbInfoTab.treeView1.SelectedItem as TreeViewIconsItem;
if (selectedNode == cutNode)
{
return;
}
String newPath = "";
if (selectedNode == null)//如果目标选项卡中没有选中任何节点，则默认添加到根节点
{
newPath = "/" + cutNode.HeaderText + "/";
}
else
{
newPath = selectedNode.Path + cutNode.HeaderText + "/";
}
if (curDbInfoTab.treeView1.IsNodeExisted(newPath))
{
MessageBox.Show("在此处粘贴将导致两个节点拥有相同的路径，因此，请在其他地方粘贴");
return;
}
//在同一数据库中粘贴
if (curDbInfoTab == cutNodeSourceTab)
{
//先移除被剪切的子树
curDbInfoTab.treeView1.CutNode(cutNode);
curDbInfoTab.treeView1.PasteNode(cutNode, selectedNode);
curDbInfoTab.OnNodeMove(NodeMoveType.NodePaste);
}
else
{
//在不同的数据库中粘贴
String sourcePath = cutNode.Path;
String targetPath = "";
if (selectedNode != null)
{
targetPath = selectedNode.Path;
}
else
{
targetPath = "/";
}
//先移除源树中被剪切的子树
cutNodeSourceTab.treeView1.CutNode(cutNode);
//将剪切的节点子树追加到当前节点
curDbInfoTab.treeView1.PasteNodeCrossDB(cutNode, selectedNode);
//保存目标树结构
curDbInfoTab.treeView1.SaveToDB();
//将源树保存到数据库中
cutNodeSourceTab.treeView1.SaveToDB();
//更新所有粘贴节点的数据存取对象
String EFConnectionString = DALConfig.getEFConnectionString(curDbInfoTab.dbInfoObject.DatabaseFilePath);
if (selectedNode != null)
{
UpdateDataAcessObject(selectedNode, EFConnectionString);
}
else
{
UpdateDataAcessObject(cutNode, EFConnectionString);
}
//更新数据库中内容
NodeMoveBetweenDBManager nodeMoveManager = new NodeMoveBetweenDBManager(cutNodeSourceTab.dbInfoObject.DatabaseFilePath, curDbInfoTab.dbInfoObject.DatabaseFilePath);
nodeMoveManager.MoveNodeBetweenDB(sourcePath, targetPath);
}
//取消删除线显示
cutNode.Strikethrough = false;
cutNode = null;
cutNodeSourceTab = null;
if (curDbInfoTab.treeView1.SelectedItem != null)
{
curDbInfoTab.treeView1.SelectedItem.IsExpanded = true;
}
}
private void CreateXmlTreeFromTreeViewIconsItem(TreeViewIconsItem rootNode,XElement element)
{
XElement tempElement=null;
foreach (var item in rootNode.Items)
{
//加入所有子节点
tempElement=CreateXElementFromTreeViewIconsItem(item as TreeViewIconsItem);
element.Add(tempElement);
CreateXmlTreeFromTreeViewIconsItem(item as TreeViewIconsItem, tempElement);
}
}
private void UpdateDataAcessObject(TreeViewIconsItem root, String EFConnectionString)
{
if (root == null)
{
return;
}
root.NodeData.AccessObject = NodeFactory.CreateNodeAccessObject(root.NodeData.DataItem.NodeType, EFConnectionString);
foreach (var node in root.Items)
{
UpdateDataAcessObject(node as TreeViewIconsItem, EFConnectionString);
}
}
private void CutNode(object sender, ExecutedRoutedEventArgs e)
{
if (treeView1.IsInEditMode)
{
treeView1.SelectedItem.EndEdit();
}
cutNode = treeView1.SelectedItem as TreeViewIconsItem;
treeView1.CutNode(cutNode);
}
/// <summary>
/// 删除指定的节点,同时更新内存中的节点数据及数据库中的记录
/// </summary>
/// <param name="selectedNode"></param>
public void DeleteNode(TreeViewIconsItem selectedNode)
{
if (selectedNode == null || selectedNode.Parent == null)
{
return;
}
if (selectedNode.Parent == tree)
{
tree.Items.Remove(selectedNode);
}
else
{
(selectedNode.Parent as TreeViewIconsItem).Items.Remove(selectedNode);
}
//更新内存中的节点集合
nodesManager.DeleteNode(selectedNode);
//更新数据库
NodePathManager.DeleteDataInfoObjectOfNodeAndItsChildren(selectedNode.Path);
}
/// <summary>
/// 为新节点提取数据并显示
/// </summary>
/// <param name="newSelectedNode"></param>
private void LoadDataAndShowInUI(TreeViewIconsItem newSelectedNode)
{
if (newSelectedNode.NodeData.DataItem.NodeType == "OnlyText")
{
NodeUIContainer.Content = null;
return;
}
NodeDataObject dataInfoObject = newSelectedNode.NodeData;
//检查一下数据是否己被装入
if (!dataInfoObject.DataItem.HasBeenLoadFromStorage)
{
//装入数据
IDataInfo dataObj = dataInfoObject.AccessObject.GetDataInfoObjectByPath(newSelectedNode.Path);
if (dataObj != null)
{
//将己装入数据的对象挂到节点上
newSelectedNode.NodeData.DataItem = dataObj;
}
}
if (dataInfoObject.DataItem.ShouldEmbedInHostWorkingBench)
{
NodeUIContainer.Content = dataInfoObject.DataItem.RootControl;
}
//显示最新的数据
dataInfoObject.DataItem.BindToRootControl();
dataInfoObject.DataItem.RefreshDisplay();
}
/// <summary>
/// 粘贴节点并自动更新相关的节点内存记录,但不更新底层数据库
/// </summary>
/// <param name="nodeToBeCut"></param>
/// <param name="attachToNode"></param>
public void PasteNodeCrossDB(TreeViewIconsItem nodeToBeCut, TreeViewIconsItem attachToNode)
{
PasteNode(nodeToBeCut, attachToNode, true);
}
private void PasteNode(object sender, ExecutedRoutedEventArgs e)
{
if (treeView1.IsInEditMode)
{
treeView1.SelectedItem.EndEdit();
}
if (cutNode == null)
{
return;
}
TreeViewIconsItem selectedNode = treeView1.SelectedItem as TreeViewIconsItem;
String newPath = selectedNode.Path + cutNode.HeaderText + "/";
if (treeView1.IsNodeExisted(newPath))
{
MessageBox.Show("在此处粘贴将导致两个节点拥有相同的路径，因此，请在其他地方粘贴");
return;
}
treeView1.PasteNode(cutNode, selectedNode);
OnNodeMove(NodeMoveType.NodePaste);
cutNode = null;
treeView1.SelectedItem.IsExpanded = true;
}
/// <summary>
/// 删除指定的节点,同时更新内存中的节点数据及数据库中的记录
/// </summary>
/// <param name="selectedNode"></param>
public void DeleteNode(TreeViewIconsItem selectedNode)
{
if (selectedNode == null || selectedNode.Parent == null)
{
return;
}
ShouldRaiseSelectedItemChangedEvent = true;
if (selectedNode.Parent == tree)
{
tree.Items.Remove(selectedNode);
}
else
{
(selectedNode.Parent as TreeViewIconsItem).Items.Remove(selectedNode);
}
//更新内存中的节点集合
nodesManager.DeleteNode(selectedNode);
//更新数据库
if (_nodePathManager != null)
{
_nodePathManager.DeleteDataInfoObjectOfNodeAndItsChildren(selectedNode.Path);
}
}
/// <summary>
/// 获取后一个兄弟节点
/// 如果己经是最后一个了，返回null
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public TreeViewIconsItem GetNextNode(TreeViewIconsItem node)
{
if (node == null)
{
return null;
}
int nodeCount = GetParent(node).Items.Count;
int index = GetNodeIndex(node);
if (index == nodeCount - 1)
{
return null;
}
if (IsFirstLevelNode(node))
{
return tree.Items[index + 1] as TreeViewIconsItem;
}
else
{
return (node.Parent as TreeViewIconsItem).Items[index + 1] as TreeViewIconsItem;
}
}
/// <summary>
/// 剪切一个节点
/// </summary>
/// <param name="nodeToBeCut"></param>
public TreeViewIconsItem CutNode(TreeViewIconsItem nodeToBeCut)
{
if (nodeToBeCut == null)
{
return null;
}
ShouldRaiseSelectedItemChangedEvent = true;
ItemsControl parent = GetParent(nodeToBeCut);
parent.Items.Remove(nodeToBeCut);
return nodeToBeCut;
}
private void CutNode(object sender, ExecutedRoutedEventArgs e)
{
if (curDbInfoTab.treeView1.IsInEditMode)
{
curDbInfoTab.treeView1.SelectedItem.EndEdit();
}
//如果己经有被剪切的节点，则取消它的下划线状态
if (cutNode != null && cutNode != curDbInfoTab.treeView1.SelectedItem)
{
cutNode.Strikethrough = false;
}
cutNode = curDbInfoTab.treeView1.SelectedItem as TreeViewIconsItem;
cutNode.Strikethrough = true;
cutNodeSourceTab = curDbInfoTab;
String info = "";
if (cutNode.HeaderText.Length > 30)
{
info = "节点：\"" + cutNode.HeaderText.Substring(0, 30) + "\"己被剪切";
}
else
{
info = "节点：\"" + cutNode.HeaderText + "\"己被剪切";
}
ShowInfo(info);
}
/// <summary>
/// 上移
/// </summary>
/// <param name="node"></param>
public void MoveUp(TreeViewIconsItem node)
{
if (node == null)
{
return;
}
int index = GetNodeIndex(node);
//最前一个无法上移
if (index == 0)
{
return;
}
//先删除自己，再在新位置重新插入
tree.BeginInit();
ItemsControl parent = GetParent(node);
parent.Items.RemoveAt(index);
parent.Items.Insert(index - 1, node);
node.IsSelected = true;
tree.EndInit();
}
/// <summary>
/// 下移
/// </summary>
/// <param name="node"></param>
public void MoveDown(TreeViewIconsItem node)
{
if (node == null)
{
return;
}
//共有多少个兄弟节点
ItemsControl parent = GetParent(node);
int nodeCount = parent.Items.Count;
//获取我的索引
int index = GetNodeIndex(node);
//最后一个无法下移
if (index == nodeCount - 1)
{
return;
}
//先删除自己，再在新位置重新插入
tree.BeginInit();
parent.Items.RemoveAt(index);
parent.Items.Insert(index + 1, node);
node.IsSelected = true;
tree.EndInit();
}
/// <summary>
/// 为新节点提取数据并显示
/// </summary>
/// <param name="newSelectedNode"></param>
private void LoadDataAndShowInUI(TreeViewIconsItem newSelectedNode)
{
if (newSelectedNode.NodeData.DataItem.NodeType == "OnlyText")
{
NodeUIContainer.Content = null;
newSelectedNode.NodeData.DataItem.RefreshDisplay();
return;
}
NodeDataObject dataInfoObject = newSelectedNode.NodeData;
//正确地设置可视化界面所关联的数据存取对象
dataInfoObject.DataItem.SetRootControlDataAccessObj(dataInfoObject.AccessObject);
//检查一下数据是否己被装入
if (!dataInfoObject.DataItem.HasBeenLoadFromStorage)
{
//装入数据
IDataInfo dataObj = dataInfoObject.AccessObject.GetDataInfoObjectByPath(newSelectedNode.Path);
if (dataObj != null)
{
//给将己装入数据的对象添加对主窗体的引用
if (NodeFactory._mainWindow != null)
{
dataObj.MainWindow = NodeFactory._mainWindow;
}
//把节点数据对象挂到节点上
newSelectedNode.NodeData.DataItem = dataObj;
}
}
if (dataInfoObject.DataItem.ShouldEmbedInHostWorkingBench)
{
if (dataInfoObject.DataItem.RootControl.Parent != null)
{
(dataInfoObject.DataItem.RootControl.Parent as ContentControl).Content=null;
}
NodeUIContainer.Content = dataInfoObject.DataItem.RootControl;
}
//显示最新的数据
dataInfoObject.DataItem.BindToRootControl();
dataInfoObject.DataItem.RefreshDisplay();
}
/// <summary>
/// 粘贴节点并自动更新相关的内存及数据库中的记录
/// 要求被剪切的节点必须是“独立”的（其Parent属性==null)
/// </summary>
/// <param name="nodeToBeCut">被剪切的节点</param>
/// <param name="attachToNode">将接收被剪切节点的那个节点</param>
public void PasteNode(TreeViewIconsItem nodeToBeCut, TreeViewIconsItem attachToNode)
{
if (nodeToBeCut == null || attachToNode == null || nodeToBeCut.Parent != null)
{
return;
}
String oldPath = nodeToBeCut.Path;
String newPath = attachToNode.Path + nodeToBeCut.HeaderText + "/";
tree.BeginInit();
attachToNode.Items.Add(nodeToBeCut);
//更新所有内存相关子节点集合的路径
nodesManager.UpdateNodePath(oldPath, newPath);
//更新数据库中相关子节点的路径
NodePathManager.UpdateNodePath(oldPath, newPath);
tree.EndInit();
//激发事件
if (NodeMove != null)
{
NodeMoveEventArgs e = new NodeMoveEventArgs
{
MoveType = NodeMoveType.NodePaste,
Node = nodeToBeCut,
PrevPath = oldPath
};
NodeMove(nodeToBeCut, e);
}
}
