public bool NodeMoved(IServerTreeNode destinationNode, IServerTreeNode movingDataNode)
{
if (!CanMove(destinationNode, movingDataNode))
{
return(false);
}
if (movingDataNode.IsServer)
{
_serverTree.CurrentNode = movingDataNode;
_serverTree.DeleteServer();
((IServerTreeGroup)destinationNode).AddChild(movingDataNode);
SetSelection(movingDataNode);
}
else if (movingDataNode.IsServerGroup)
{
var movingGroup = (IServerTreeGroup)movingDataNode;
_serverTree.CurrentNode = movingGroup;
_serverTree.DeleteGroup();
_serverTree.Save();
((IServerTreeGroup)destinationNode).AddChild(movingGroup);
SetSelection(movingGroup);
}
_serverTree.Save();
return(true);
}
public static List <IDicomServiceNode> ToDicomServiceNodes(this IServerTreeNode serverTreeNode)
{
Platform.CheckForNullReference(serverTreeNode, "serverTreeNode");
if (serverTreeNode.IsLocalServer)
{
return new List <IDicomServiceNode> {
ServerDirectory.GetLocalServer()
}
}
;
if (serverTreeNode.IsServer)
{
return new List <IDicomServiceNode> {
((IServerTreeDicomServer)serverTreeNode).ToDicomServiceNode()
}
}
;
var group = (IServerTreeGroup)serverTreeNode;
var childServers = new List <IDicomServiceNode>();
childServers.AddRange(group.ChildGroups.SelectMany(g => g.ToDicomServiceNodes()));
childServers.AddRange(group.Servers.Cast <IServerTreeDicomServer>().Select(g => g.ToDicomServiceNode()));
return(childServers);
}
private void TreeViewDragOver(object sender, DragEventArgs e)
{
// precondition
TreeNode underPointerNode = _aeTreeView.GetNodeAt(_aeTreeView.PointToClient(new Point(e.X, e.Y)));
if (null == underPointerNode)
{
return;
}
IServerTreeNode underPointerDataNode = underPointerNode.Tag as IServerTreeNode;
IServerTreeNode lastClickedDataNode = _lastClickedNode.Tag as IServerTreeNode;
// _lastMouseOverNode was the node that I highlighted last
// but its highlight must be turned off
if ((_lastMouseOverNode != null) && (_lastMouseOverNode != underPointerNode))
{
_lastMouseOverNode.BackColor = Color.White;
_lastMouseOverNode.ForeColor = Color.Black;
}
// highlight node only if the target node is a potential place
// for us to drop a node for moving
if (_component.CanMove(underPointerDataNode, lastClickedDataNode))
{
underPointerNode.BackColor = Color.DarkBlue;
underPointerNode.ForeColor = Color.White;
_lastMouseOverNode = underPointerNode;
}
}
private static void SelectPriorsServers(ServerTreeComponent serverTreeComponent)
{
ServerTree serverTree = serverTreeComponent.ServerTree;
var priorsServers = ServerDirectory.GetPriorsServers(false);
CheckPriorsServers(serverTree, priorsServers);
IServerTreeNode initialSelection = GetFirstPriorsServerOrGroup(serverTree.RootServerGroup);
UncheckAllServers(serverTree);
if (initialSelection == null)
{
if (serverTreeComponent.ShowLocalServerNode)
{
initialSelection = serverTreeComponent.ServerTree.LocalServer;
}
else
{
initialSelection = serverTreeComponent.ServerTree.RootServerGroup;
}
}
serverTreeComponent.SetSelection(initialSelection);
}
private void TreeViewNodeMouseDoubleClick(object sender, TreeNodeMouseClickEventArgs e)
{
SelectNode(e.Node);
IServerTreeNode dataNode = _lastClickedNode.Tag as IServerTreeNode;
_component.SetSelection(dataNode);
_component.NodeDoubleClick();
}
public bool CanMove(IServerTreeNode destinationNode, IServerTreeNode movingDataNode)
{
if (IsReadOnly)
{
return(false);
}
return(_serverTree.CanMove(destinationNode, movingDataNode));
}
private void SelectServerTreeNode(IServerTreeNode serverTreeNode)
{
TreeNode foundNode = FindNode(serverTreeNode, _aeTreeView.Nodes);
if (foundNode != null)
{
SelectNode(foundNode);
}
}
public void SetSelection(IServerTreeNode serverTreeNode)
{
_selectedServers = new DicomServiceNodeList(serverTreeNode.ToDicomServiceNodes())
{
Name = serverTreeNode.DisplayName,
Id = serverTreeNode.Path
};
_serverTree.CurrentNode = serverTreeNode;
FireSelectedServerChangedEvent();
}
private void TreeViewDragDrop(object sender, System.Windows.Forms.DragEventArgs e)
{
if (e.Data.GetDataPresent("System.Windows.Forms.TreeNode", false))
{
Point pt = ((TreeView)sender).PointToClient(new Point(e.X, e.Y));
TreeNode destinationNode = ((TreeView)sender).GetNodeAt(pt);
TreeNode draggingNode = (TreeNode)e.Data.GetData("System.Windows.Forms.TreeNode");
IServerTreeNode draggingDataNode = draggingNode.Tag as IServerTreeNode;
IServerTreeNode destinationDataNode = destinationNode.Tag as IServerTreeNode;
if (draggingDataNode == null || destinationDataNode == null)
{
return;
}
// turn off the white-on-blue highlight of a destination node
destinationNode.BackColor = Color.White;
destinationNode.ForeColor = Color.Black;
_lastMouseOverNode.BackColor = Color.White;
_lastMouseOverNode.ForeColor = Color.Black;
// detecting if a node is being moved to the same/current parent, then do nothing
// or if we're not dragging into a server group, do nothing
// or if you're dragging over a child group
//if (destinationDataNode.Path == draggingDataNode.Path ||
// !destinationDataNode.IsServerGroup ||
// draggingDataNode.Path.IndexOf(destinationDataNode.Path) == -1) // don't allow dropping a node into one of its own children
if (!_component.CanMove(destinationDataNode, draggingDataNode))
{
return;
}
if (!_component.NodeMoved(destinationDataNode, draggingDataNode))
{
return;
}
SelectNode(destinationNode);
draggingNode.Remove();
// build up the destination
destinationNode.Nodes.Clear();
BuildNextTreeLevel(_lastClickedNode);
destinationNode.Expand();
_component.SetSelection(_lastClickedNode.Tag as IServerTreeNode);
UpdateServerGroups();
}
}
public void AddChild(IServerTreeNode child)
{
if (child.IsServer)
{
var childServer = (ServerTreeDicomServer)child;
Servers.Add(childServer);
childServer.ChangeParentPath(_path);
}
else if (child.IsServerGroup)
{
var groups = (ServerTreeGroup)child;
ChildGroups.Add(groups);
groups.ChangeParentPath(_path);
}
}
private TreeNode AddTreeNode(TreeNode treeNode, IServerTreeNode dataChild)
{
TreeNode treeChild = new TreeNode(dataChild.DisplayName);
SetIcon(dataChild, treeChild);
treeChild.Tag = dataChild;
treeChild.ToolTipText = dataChild.ToString();
if (treeChild.Tag is IServerTreeDicomServer)
{
SetServerCheck(treeChild);
}
treeNode.Nodes.Add(treeChild);
return(treeChild);
}
public bool CanMove(IServerTreeNode destinationNode, IServerTreeNode addMoveNode)
{
if (destinationNode == addMoveNode || !destinationNode.IsServerGroup)
{
return(false);
}
if (addMoveNode == RootServerGroup || addMoveNode == LocalServer)
{
return(false);
}
if (addMoveNode.IsServer)
{
var server = (ServerTreeDicomServer)addMoveNode;
string conflictingPath;
if (IsConflictingServerInGroup((ServerTreeGroup)destinationNode, false, server.AETitle, server.HostName, server.Port, out conflictingPath))
{
return(false);
}
}
else if (addMoveNode is ServerTreeGroup)
{
string conflictingPath;
if (IsConflictingServerTreeGroupInGroup((ServerTreeGroup)destinationNode, addMoveNode.Name, false, out conflictingPath))
{
return(false);
}
if (addMoveNode.ParentPath == destinationNode.Path)
{
return(false);
}
// if the node that's being added is actually a direct parent of
// the destination node, then it's not possible for it to be added as a child
// direct parent:
// destination - ./a/b/c/destination
// direct parents - ./a/b/c; ./a/b; ./a
// non-d parents - ./a/b/d; ./a/b/c/e
// thus, if the proposed node's path is NOT wholly contained in the destination node's
// path, then it's okay to add the proposed node
return(destinationNode.Path.IndexOf(addMoveNode.Path) == -1);
}
return(true);
}
private TreeNode FindNode(IServerTreeNode findNode, TreeNodeCollection treeNodes)
{
foreach (TreeNode treeNode in treeNodes)
{
if (treeNode.Tag == findNode)
{
return(treeNode);
}
else
{
TreeNode foundTreeNode = FindNode(findNode, treeNode.Nodes);
if (foundTreeNode != null)
{
return(foundTreeNode);
}
}
}
return(null);
}
public IServerTreeNode FindServer(IServerTreeGroup group, string path)
{
foreach (IServerTreeNode server in group.Servers)
{
if (server.Path == path)
{
return(server);
}
}
foreach (IServerTreeGroup childGroup in group.ChildGroups)
{
IServerTreeNode server = FindServer(childGroup, path);
if (server != null)
{
return(server);
}
}
return(null);
}
private void SetIcon(IServerTreeNode browserNode, TreeNode treeNode)
{
if (browserNode == null)
{
return;
}
if (browserNode.IsLocalServer)
{
treeNode.ImageIndex = 0;
treeNode.SelectedImageIndex = 0;
}
else if (browserNode.IsServer)
{
treeNode.ImageIndex = 1;
treeNode.SelectedImageIndex = 1;
}
else
{
treeNode.ImageIndex = 2;
treeNode.SelectedImageIndex = 2;
}
}
public bool CanMove(IServerTreeNode destinationNode, IServerTreeNode addMoveNode)
{
if (destinationNode == addMoveNode || !destinationNode.IsServerGroup)
return false;
if (addMoveNode == RootServerGroup || addMoveNode == LocalServer)
return false;
if (addMoveNode.IsServer)
{
var server = (ServerTreeDicomServer)addMoveNode;
string conflictingPath;
if (IsConflictingServerInGroup((ServerTreeGroup)destinationNode, false, server.AETitle, server.HostName, server.Port, out conflictingPath))
return false;
}
else if (addMoveNode is ServerTreeGroup)
{
string conflictingPath;
if (IsConflictingServerTreeGroupInGroup((ServerTreeGroup)destinationNode, addMoveNode.Name, false, out conflictingPath))
return false;
if (addMoveNode.ParentPath == destinationNode.Path)
return false;
// if the node that's being added is actually a direct parent of
// the destination node, then it's not possible for it to be added as a child
// direct parent:
// destination - ./a/b/c/destination
// direct parents - ./a/b/c; ./a/b; ./a
// non-d parents - ./a/b/d; ./a/b/c/e
// thus, if the proposed node's path is NOT wholly contained in the destination node's
// path, then it's okay to add the proposed node
return (destinationNode.Path.IndexOf(addMoveNode.Path) == -1);
}
return true;
}
private void OnServerTreeUpdated(object sender, EventArgs e)
{
if (_lastClickedNode == null)
{
return;
}
if (_component.UpdateType == 0)
{
return;
}
if (_component.UpdateType == (int)ServerUpdateType.Add)
{
IServerTreeNode dataChild = _component.ServerTree.CurrentNode;
AddTreeNode(_lastClickedNode, dataChild);
_lastClickedNode.Expand();
}
else if (_component.UpdateType == (int)ServerUpdateType.Delete)
{
TreeNode removeNode = _lastClickedNode;
SelectNode(_lastClickedNode.Parent);
removeNode.Remove();
}
else if (_component.UpdateType == (int)ServerUpdateType.Edit)
{
IServerTreeNode dataNode = _component.ServerTree.CurrentNode;
_lastClickedNode.Text = dataNode.DisplayName;
_lastClickedNode.Tag = dataNode;
SynchronizeTooltips(_lastClickedNode);
}
_component.SetSelection(_lastClickedNode.Tag as IServerTreeNode);
UpdateServerGroups();
}
private static IServerTreeNode GetFirstPriorsServerOrGroup(IServerTreeGroup serverGroup)
{
if (serverGroup.IsEntireGroupChecked())
{
return(serverGroup);
}
//consider groups and servers at this level
foreach (IServerTreeGroup group in serverGroup.ChildGroups)
{
if (group.IsEntireGroupChecked())
{
return(group);
}
}
foreach (IServerTreeDicomServer server in serverGroup.Servers)
{
if (server.IsChecked)
{
return(server);
}
}
//repeat for children of the groups at this level
foreach (IServerTreeGroup group in serverGroup.ChildGroups)
{
IServerTreeNode priorsServerOrGroup = GetFirstPriorsServerOrGroup(group);
if (priorsServerOrGroup != null)
{
return(priorsServerOrGroup);
}
}
return(null);
}
private IServerTreeGroup FindParentGroup(IServerTreeNode node)
{
return FindServerTreeGroup(RootServerGroup, node.ParentPath);
}
private void SelectServerTreeNode(IServerTreeNode serverTreeNode)
{
TreeNode foundNode = FindNode(serverTreeNode, _aeTreeView.Nodes);
if (foundNode != null)
SelectNode(foundNode);
}
private TreeNode FindNode(IServerTreeNode findNode, TreeNodeCollection treeNodes)
{
foreach (TreeNode treeNode in treeNodes)
{
if (treeNode.Tag == findNode)
{
return treeNode;
}
else
{
TreeNode foundTreeNode = FindNode(findNode, treeNode.Nodes);
if (foundTreeNode != null)
return foundTreeNode;
}
}
return null;
}
private TreeNode AddTreeNode(TreeNode treeNode, IServerTreeNode dataChild)
{
TreeNode treeChild = new TreeNode(dataChild.DisplayName);
SetIcon(dataChild, treeChild);
treeChild.Tag = dataChild;
treeChild.ToolTipText = dataChild.ToString();
if (treeChild.Tag is IServerTreeDicomServer)
SetServerCheck(treeChild);
treeNode.Nodes.Add(treeChild);
return treeChild;
}
public void AddChild(IServerTreeNode child)
{
if (child.IsServer)
{
var childServer = (ServerTreeDicomServer)child;
Servers.Add(childServer);
childServer.ChangeParentPath(_path);
}
else if (child.IsServerGroup)
{
var groups = (ServerTreeGroup)child;
ChildGroups.Add(groups);
groups.ChangeParentPath(_path);
}
}
private void SetIcon(IServerTreeNode browserNode, TreeNode treeNode)
{
if (browserNode == null)
return;
if (browserNode.IsLocalServer)
{
treeNode.ImageIndex = 0;
treeNode.SelectedImageIndex = 0;
}
else if (browserNode.IsServer)
{
treeNode.ImageIndex = 1;
treeNode.SelectedImageIndex = 1;
}
else
{
treeNode.ImageIndex = 2;
treeNode.SelectedImageIndex = 2;
}
}
private IServerTreeGroup FindParentGroup(IServerTreeNode node)
{
return(FindServerTreeGroup(RootServerGroup, node.ParentPath));
}
