Exemple #1
0
        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 !");
            }
        }
Exemple #2
0
        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));
                }
            }
        }
Exemple #3
0
        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;
        }