public NodeMovedEventArgs(stringNode MovedNode, stringNode inOldParent, stringNode inNewParent, int index)
{
Node = MovedNode;
OldParent = inOldParent;
NewParent = inNewParent;
Index = index;
}
private void Set(stringNode inNode, TreeNode parentNode)
{
foreach (stringNode node in inNode.Nodes)
{
TreeNode categNode = null;
if (!nodesDic.ContainsKey(node.Name))
{
categNode = new TreeNode(node.Name);
parentNode.Nodes.Add(categNode);
nodesDic.Add(node.Name, categNode);
}
else
{
categNode = nodesDic[node.Name];
}
categNode.ImageIndex = 2;
categNode.SelectedImageIndex = 2;
SetNodeDisplay(categNode, node);
categNode.ToolTipText = node.Description;
categNode.Tag = node;
Set(node, categNode);
}
}
private void SetNodeDisplay(TreeNode inTreeNode, stringNode inStringNode)
{
if (inStringNode.IconIndex != -1)
{
inTreeNode.ImageIndex = inStringNode.IconIndex;
inTreeNode.SelectedImageIndex = inStringNode.IconIndex;
}
if (inStringNode.BackColor.A != 0)
{
inTreeNode.BackColor = inStringNode.BackColor;
}
if (inStringNode.ForeColor.A != 0)
{
inTreeNode.ForeColor = inStringNode.ForeColor;
}
if (!inStringNode.Active)
{
int meanBackColor = (int)((inTreeNode.BackColor.R + inTreeNode.BackColor.R + inTreeNode.BackColor.B) / 3.0);
int meanForeColor = (int)((inTreeNode.ForeColor.R + inTreeNode.ForeColor.R + inTreeNode.ForeColor.B) / 3.0);
int delta = (int)((meanBackColor - meanForeColor) / 5.0);
meanBackColor = Math.Max(0, meanBackColor - 50 + delta);
meanForeColor = Math.Max(0, meanForeColor - 50 - delta);
inTreeNode.BackColor = Color.FromArgb(inTreeNode.BackColor.A, meanBackColor, meanBackColor, meanBackColor);
inTreeNode.ForeColor = Color.FromArgb(inTreeNode.ForeColor.A, meanForeColor, meanForeColor, meanForeColor);
}
}
private void AddNewNode(string inName, stringNode parent)
{
if (!nodesDic.ContainsKey(inName))
{
stringNode newNode = new stringNode(inName);
parent.AddNode(newNode);
Reset();
OnNodeAdded(new NodeAddedEventArgs(newNode, parent));
}
else
{
MessageBox.Show("Node " + inName + " already exist !");
}
}
private void mainPanelAreaMapControl_Load(object sender, EventArgs e)
{
List <string> values = Handler.GetStoredValues();
foreach (string value in values)
{
setsLB.Items.Add(value);
}
stringNode root = new stringNode("Sets :");
foreach (string value in values)
{
root.AddPath(value);
}
setsSNTV.Set(root, false);
}
void DeleteNode(object sender, EventArgs e)
{
MenuItem item = sender as MenuItem;
if (item != null)
{
TreeNode node = item.Tag as TreeNode;
if (node != null)
{
stringNode realRemoved = node.Tag as stringNode;
//Reparent children
stringNode realRoot = null;
TreeNode parent = node.Parent;
if (parent != null)
{
realRoot = parent.Tag as stringNode;
}
else
{
realRoot = StringNodeRoot;
}
foreach (TreeNode subNode in node.Nodes)
{
stringNode realNode = subNode.Tag as stringNode;
realRoot.AddNode(realNode);
}
realRoot.Nodes.Remove(node.Tag as stringNode);
Reset();
OnNodeRemoved(new NodeRemovedEventArgs(realRemoved, realRoot));
}
}
}
void mNameBox_KeyUp(object sender, KeyEventArgs e)
{
if (e.KeyData == Keys.Enter)
{
TreeNode node = mNameBox.Tag as TreeNode;
if (node != null)
{
if (!nodesDic.ContainsKey(mNameBox.Text))
{
stringNode realNode = node.Tag as stringNode;
if (!IsAdding)
{
NodeRenamedEventArgs args = new NodeRenamedEventArgs(realNode, node.Text);
realNode.Name = mNameBox.Text;
node.Name = mNameBox.Text;
node.Text = mNameBox.Text;
OnNodeRenamed(args);
}
else
{
AddNewNode(mNameBox.Text, realNode);
}
}
else
{
MessageBox.Show("Node " + mNameBox.Text + " already exist !");
}
}
IsAdding = false;
mNameBox.Visible = false;
}
}
public NodeRemovedEventArgs(stringNode RemovedNode, stringNode inParent)
{
Node = RemovedNode;
Parent = inParent;
}
public NodeAddedEventArgs(stringNode AddedNode, stringNode inParent)
{
Node = AddedNode;
Parent = inParent;
}
public NodeRenamedEventArgs(stringNode RenamedNode, string oldName)
{
Node = RenamedNode;
OldName = oldName;
}
public void Set(stringNode Root, bool createRoot)
{
//Folded nodes / Selected nodes
List <string> foldedNodes = new List <string>();
List <string> selectedNodes = new List <string>();
foreach (string nodeName in nodesDic.Keys)
{
if (!nodesDic[nodeName].IsExpanded)
{
foldedNodes.Add(nodeName);
}
if (nodesDic[nodeName].IsSelected)
{
selectedNodes.Add(nodeName);
}
}
//Scroll
Point scroll = GetTreeViewScrollPos();
Nodes.Clear();
nodesDic.Clear();
StringNodeRoot = Root;
CreateRoot = createRoot;
if (createRoot)
{
TreeNode root = new TreeNode(Root.Name);
Nodes.Add(root);
nodesDic.Add(Root.Name, root);
root.SelectedImageIndex = 2;
root.ImageIndex = 2;
SetNodeDisplay(root, Root);
root.Tag = Root;
Set(Root, root);
}
else
{
foreach (stringNode node in Root.Nodes)
{
TreeNode categNode = new TreeNode(node.Name);
Nodes.Add(categNode);
nodesDic.Add(node.Name, categNode);
categNode.ImageIndex = 2;
categNode.SelectedImageIndex = 2;
SetNodeDisplay(categNode, node);
categNode.ToolTipText = node.Description;
categNode.Tag = node;
Set(node, categNode);
}
}
ExpandAll();
//Folded nodes
foreach (string nodeName in foldedNodes)
{
if (nodesDic.ContainsKey(nodeName))
{
nodesDic[nodeName].Collapse(true);
}
}
//Selected nodes ??
if (selectedNodes.Count > 0 && nodesDic.ContainsKey(selectedNodes[0]))
{
SelectedNode = nodesDic[selectedNodes[0]];
}
//Scroll
SetTreeViewScrollPos(scroll);
}
void stringNodesTreeView_DragDrop(object sender, DragEventArgs e)
{
if (IsAdding)
{
if (e.Data.GetDataPresent(typeof(string)))
{
AddNewNode((string)e.Data.GetData(typeof(string)), RefNode.Tag as stringNode);
}
}
else
{
if (e.Data.GetDataPresent(typeof(TreeNode)))
{
TreeNode Dropped = (TreeNode)e.Data.GetData(typeof(TreeNode));
stringNode realParent = null;
stringNode refParent = null;
stringNode realDropped = null;
stringNode realRef = null;
int index = 0;
if (Dropped != null && RefNode != null)
{
realDropped = Dropped.Tag as stringNode;
realRef = RefNode.Tag as stringNode;
if (!realRef.IsChildOf(realDropped))
{
switch (DropMode)
{
case DropLocation.Top:
if (Dropped.Parent != null)
{
realParent = Dropped.Parent.Tag as stringNode;
}
else
{
realParent = StringNodeRoot;
}
if (RefNode.Parent != null)
{
refParent = RefNode.Parent.Tag as stringNode;
}
else
{
refParent = StringNodeRoot;
}
realParent.Nodes.Remove(realDropped);
index = 0;
foreach (stringNode child in refParent.Nodes)
{
if (child == realRef)
{
break;
}
index++;
}
refParent.Nodes.Insert(index, realDropped);
realDropped.Parent = refParent;
Reset();
OnNodeMoved(new NodeMovedEventArgs(realDropped, realParent, refParent, index));
break;
case DropLocation.Bottom:
if (Dropped.Parent != null)
{
realParent = Dropped.Parent.Tag as stringNode;
}
else
{
realParent = StringNodeRoot;
}
if (RefNode.Parent != null)
{
refParent = RefNode.Parent.Tag as stringNode;
}
else
{
refParent = StringNodeRoot;
}
realParent.Nodes.Remove(realDropped);
index = 0;
foreach (stringNode child in refParent.Nodes)
{
if (child == realRef)
{
index++;
break;
}
index++;
}
refParent.Nodes.Insert(index, realDropped);
realDropped.Parent = refParent;
Reset();
OnNodeMoved(new NodeMovedEventArgs(realDropped, realParent, refParent, index));
break;
default:
if (Dropped != RefNode)
{
if (Dropped.Parent != null)
{
realParent = Dropped.Parent.Tag as stringNode;
}
else
{
realParent = StringNodeRoot;
}
realRef.AddNode(realDropped);
Reset();
OnNodeMoved(new NodeMovedEventArgs(realDropped, realParent, realRef, realRef.Nodes.Count - 1));
}
break;
}
}
}
}
}
Invalidate();
RefNode = null;
IsAdding = false;
}
void stringNodesTreeView_DragOver(object sender, DragEventArgs e)
{
e.Effect = DragDropEffects.Copy;
Point clientHit = PointToClient(new Point(e.X, e.Y));
TreeNode destination = HitTest(clientHit).Node;
TreeNode Dropped = null;
if (destination == null)
{
stringNode last = StringNodeRoot.Nodes[StringNodeRoot.Nodes.Count - 1];
if (nodesDic.ContainsKey(last.Name))
{
destination = nodesDic[last.Name];
}
}
if (e.Data.GetDataPresent(typeof(TreeNode)))
{
Dropped = (TreeNode)e.Data.GetData(typeof(TreeNode));
}
else
{
if (e.Data.GetDataPresent(typeof(string)))
{
string droppedStr = (string)e.Data.GetData(typeof(string));
if (!string.IsNullOrEmpty(droppedStr))
{
Dropped = new TreeNode(droppedStr);
IsAdding = true;
}
}
}
bool allowDrop = false;
DropLocation newDrop = DropLocation.On;
if (Dropped != null && destination != null)
{
int deadZone = destination.Bounds.Height / 4;
if ((clientHit.Y - destination.Bounds.Y) < deadZone)
{
newDrop = DropLocation.Top;
}
else
{
if ((clientHit.Y - destination.Bounds.Y) > (3 * deadZone))
{
newDrop = DropLocation.Bottom;
}
else
{
newDrop = DropLocation.On;
}
}
allowDrop = true;
}
if (allowDrop && canDrop(newDrop, Dropped, destination))
{
RefNode = destination;
DropMode = newDrop;
Invalidate();
}
else
{
e.Effect = DragDropEffects.None;
RefNode = null;
IsAdding = false;
}
}
