/// <summary>
            /// Gets called when a dragged item leaves the control.
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private void _DragLeave(object sender, EventArgs e)
            {
                var treeView = sender as TreeView;

                if (treeView == null || treeView != this._treeView)
                {
                    return;
                }

                // remove drag/drop image
                DragHelper.ImageList_DragLeave(treeView.Handle);

                // Disable timer for scrolling dragged item
                this._dragScrollTimer.Enabled = false;
            }
Ejemplo n.º 2
0
        protected override void OnDragLeave(EventArgs e)
        {
            try
            {
                this.dragging = false;
                DragHelper.ImageList_DragLeave(this.Handle);

                // Disable timer for scrolling dragged item
                this.timer.Enabled = false;
            }
            catch (Exception ex)
            {
                ACSLog.InsertLog(MessageBoxIcon.Error, ex);
            }
        }
Ejemplo n.º 3
0
        private void suiteTreeView_DragDrop(object sender, DragEventArgs e)
        {
            DragHelper.ImageList_DragLeave(this.suiteTreeView.Handle);
            TreeNode dropNode = this.suiteTreeView.GetNodeAt(this.suiteTreeView.PointToClient(new Point(e.X, e.Y)));

            if (this.dragNode != dropNode && dropNode.Tag is TestSuite)
            {
                if (this.dragNode.Parent == null)
                {
                    this.suiteTreeView.Nodes.Remove(this.dragNode);
                }
                else
                {
                    this.dragNode.Parent.Nodes.Remove(this.dragNode);
                }

                dropNode.Nodes.Add(this.dragNode);
                dropNode.ExpandAll();

                this.dragNode      = null;
                this.timer.Enabled = false;
            }
        }
Ejemplo n.º 4
0
        private void BetterTreeView_DragDrop(object sender, DragEventArgs e)
        {
            // Unlock updates
            DragHelper.ImageList_DragLeave(Handle);

            // Get drop node
            TreeNode dropNode = GetNodeAt(PointToClient(new Point(e.X, e.Y)));

            // Manually move the nodes if we are handling that internally.
            if (MoveNodesOnDragDrop)
            {
                if (dragNode != dropNode)
                {
                    // Remove drag node from parent
                    if (dragNode.Parent == null)
                    {
                        Nodes.Remove(dragNode);
                    }
                    else
                    {
                        dragNode.Parent.Nodes.Remove(dragNode);
                    }

                    // Add drag node to drop node
                    dropNode.Nodes.Add(dragNode);
                    dropNode.ExpandAll();
                }
            }

            if (NodeDropped != null)
            {
                NodeDropped(this, new NodeDroppedEventArgs(dragNode, dropNode));
            }

            dragNode = null;
        }
Ejemplo n.º 5
0
 private void TemplateTree_DragLeave(object sender, System.EventArgs e)
 {
     DragHelper.ImageList_DragLeave(TemplateTree.Handle);
 }
Ejemplo n.º 6
0
        private void suiteTreeView_DragLeave(object sender, System.EventArgs e)
        {
            DragHelper.ImageList_DragLeave(this.suiteTreeView.Handle);

            this.timer.Enabled = false;
        }
Ejemplo n.º 7
0
 private void BetterTreeView_DragLeave(object sender, EventArgs e)
 {
     DragHelper.ImageList_DragLeave(Handle);
 }
Ejemplo n.º 8
0
        protected override void OnDragDrop(DragEventArgs drgevent)
        {
            try
            {
                this.dragging = false;

                // Unlock updates
                DragHelper.ImageList_DragLeave(this.Handle);

                // Get drop node
                TreeNode dropNode = this.GetNodeAt(this.PointToClient(new Point(drgevent.X, drgevent.Y)));

                if (dropNode == null && this.dragNode.Parent != null)
                {
                    dropNode = NewDocument();
                }

                var IndexAdd = -1;

                if (dropNode != null)
                {
                    if (dropNode.Parent != null)
                    {
                        IndexAdd = dropNode.Index;
                        dropNode = dropNode.Parent;
                    }

                    if (this.dragNode.Parent == null && dropNode.Parent == null)
                    {
                        this.Nodes.Remove(this.dragNode);
                        this.Nodes.Insert(dropNode.Index + 1, this.dragNode);

                        foreach (TreeNode Node in this.Nodes)
                        {
                            var Index = Node.Index + 1;
                            Node.Text = this.MaskDocumentName + Index.ToString();
                        }
                        // Disable scroll timer
                        this.timer.Enabled = false;

                        return;
                    }
                }

                // If drop node isn't equal to drag node, add drag node as child of drop node
                if (this.dragNode != dropNode)
                {
                    // Remove drag node from parent
                    if (this.dragNode.Parent == null)
                    {
                        this.Nodes.Remove(this.dragNode);
                    }
                    else
                    {
                        var ParentNode = this.dragNode.Parent;
                        ParentNode.Nodes.Remove(this.dragNode);

                        if (ParentNode.Nodes.Count == 0)
                        {
                            if (ParentNode.Parent == null)
                            {
                                this.Nodes.Remove(ParentNode);
                            }
                            else
                            {
                                ParentNode.Parent.Nodes.Remove(ParentNode);
                            }
                        }
                    }

                    // Add drag node to drop node
                    if (dropNode != null)
                    {
                        if (IndexAdd == -1)
                        {
                            dropNode.Nodes.Add(this.dragNode);
                        }
                        else
                        {
                            dropNode.Nodes.Insert(IndexAdd, this.dragNode);
                        }

                        dropNode.ExpandAll();

                        foreach (TreeNode Node in dropNode.Nodes)
                        {
                            var Index = Node.Index + 1;
                            Node.Text = Index.ToString(this.MaskPageName);
                        }

                        // Set drag node to null
                        this.dragNode = null;
                    }
                    else
                    {
                        this.Nodes.Add(this.dragNode);
                    }
                }

                if (AfterOnDragDrop != null)
                {
                    AfterOnDragDrop(this.dragNode == null ? (TreeNodeCustom)dropNode : (TreeNodeCustom)this.dragNode);
                }

                // Disable scroll timer
                this.timer.Enabled = false;
            }
            catch (Exception e)
            {
                ACSLog.InsertLog(MessageBoxIcon.Error, e);
            }
        }