c# - Drag and Drop from one Treeview to another - WinForms - c#

I have the DragAndDrop Event such as below for both my treeviews (treeV and treeV_IgnoreD):
private void treeV_IgnoredDragDropEvent(object sender, DragEventArgs e)
{
// Retrieve the client coordinates of the drop location.
Point targetPoint = treeV_Ignored.PointToClient(new Point(e.X, e.Y));
// Retrieve the node at the drop location.
TreeNode targetNode = treeV.GetNodeAt(targetPoint);
// Retrieve the node that was dragged.
TreeNode draggedNode = (TreeNode)e.Data.GetData(typeof(TreeNode));
// Confirm that the node at the drop location is not
// the dragged node and that target node isn't null
// (for example if you drag outside the control)
if (!draggedNode.Equals(targetNode) && targetNode != null)
{
// Remove the node from its current
// location and add it to the node at the drop location.
draggedNode.Remove();
targetNode.Nodes.Add(draggedNode);
// Expand the node at the location
// to show the dropped node.
targetNode.Expand();
}
}
private void treeV_Ignored_ItemDrag(object sender, ItemDragEventArgs e)
{
DoDragDrop(e.Item, DragDropEffects.Move);
MessageBox.Show("ola");
}
private void treeV_Ignored_DragEnter(object sender, DragEventArgs e)
{
e.Effect = DragDropEffects.Move;
}
These treeviews are populated from a Oracle dataset, and represent the same data.
I want to be able to drag an item from "treeV", and drop it within "treeV_Ignored".
How can I achieve that behaviour?


your requirement is full fill with this link
kindly look into.
Further more , you have to understand first, here SplitContainer is used for drag and drop purpose thorough which we can add our treeview to this control, so we easily drag any node to another tree. If you have any issue let me know

Related

C# Word VSTO addin - Drag and drop from treeView to word document

I am building a word addin using visual studio (c#)
Can someone help to implement the drag and drop event from a TreeView node in a user control to the body of the word document and in the chosen position by the user?
Thanks in advance.

I found the answer.
Let me share it with you.
If you need to drag and drop an item from a Treeview control to a word document you need to implement two event handlers: MouseDown and MouseMove
private bool MouseIsDown;
private void treeView1_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
{
MouseIsDown = true;
TreeView tree = (TreeView)sender;
TreeNode node = tree.GetNodeAt(e.X, e.Y);
tree.SelectedNode = node;
}
private void treeView1_MouseMove(object sender, System.Windows.Forms.MouseEventArgs e)
{
if (MouseIsDown)
{
this.treeView1.DoDragDrop(this.treeView1.SelectedNode.Text, DragDropEffects.Copy);
}
MouseIsDown = false;
}
Please note that this is different than implementing the drag and drop within the TreeView itself.

how to check a check box in tree-view when a tree-view node is selected / clicked in c#

in c# windows application i have a tree view with different nodes associated with Check Box for each node(this is for multiple Node Selection). how to change the Check Box property to checked when we click on respective node?

private void treeView1_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
{
TreeNode node = e.Node;
node.Checked = true;
}
Try this event ...

Winforms: Determine if tree view background clicked

I am making a winforms app where the user can add nodes to a tree view by right clicking on a node or the background. If the user clicks a node, the new node should become the child of that node, otherwise it will be added to the root of the tree view.
My problem is that there is no function to check if the background is clicked. Below is what I have so far. Unfortunately, if a node is clicked right now then the child will be added to both the root and the parent node.
private void treeView_MouseClick(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Right) addChild(null);
}
private void treeView_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
{
if (e.Button == MouseButtons.Right) addChild(e.Node);
}
private void addChild(TreeNode parent)
{
TreeNode node = new TreeNode("new node");
// If didn't click on a node, add to root, otherwise add to parent
if (parent == null) treeView.Nodes.Add(node);
else parent.Nodes.Add(node)
node.Parent.Expand();
}

move your code from MouseClick to MouseUp (when user releases mouse button). Then check by mouse coordinates is there node on that location.
Take a look at this code:
private void treeView1_MouseUp(object sender, MouseEventArgs e)
{
var clickedNode = treeView1.GetNodeAt(e.X, e.Y);
if (clickedNode == null)
{
//clicked on background
addChild(null);
}
else
{
//clicked on node
addChild(clickedNode);
}
}

Treeview.selectednode gives wrong value

I have a treeview which have several childs and many of them have ancestors.
I also have a datagridview along side the treeview. Based on treeview selected node, I bind data in Datagridview.
I use treeView1.SelectedNode to get the node value
My problem is that this expression give the previously selected node.
private void treeView1_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
{
node = e.node;
}
this give me correct node (selected node).
but
node = treeview1.selectednode give the node which I selected earlier.
I want to get the selected node outside the click event (_nodemouseclick).
How can I get It.
I dont want to save node in global variable then use it.
Hope I am clear to explain my question.
Thanks in anticipation.

TreeNode yourGlobalTreeNode;
void treeView1_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
{
yourGlobalTreeNode = e.Node;
otherFunction();
anOtherFunction(e.Node);
}
void otherFunction()
{
MessageBox.Show(yourGlobalTreeNode.Text);
}
void anOtherFunction(TreeNode tn)
{
MessageBox.Show(tn.Text);
}
Other Function means you can use this tree_node anywhere using above two methods.

It is because MouseClick event is raised before selectedNode is changed. Try to use SelectedItemChanged event instead
private void TreeView1_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs<object> e)
{
}

Find node clicked under context menu

How can I find out which node in a tree list the context menu has been activated? For instance right-clicking a node and selecting an option from the menu.
I can't use the TreeViews' SelectedNode property because the node is only been right-clicked and not selected.

You can add a mouse click event to the TreeView, then select the correct node using GetNodeAt given the mouse coordinates provided by the MouseEventArgs.
void treeView1MouseUp(object sender, MouseEventArgs e)
{
if(e.Button == MouseButtons.Right)
{
// Select the clicked node
treeView1.SelectedNode = treeView1.GetNodeAt(e.X, e.Y);
if(treeView1.SelectedNode != null)
{
myContextMenuStrip.Show(treeView1, e.Location);
}
}
}

Here is my solution. Put this line into NodeMouseClick event of the TreeView:
((TreeView)sender).SelectedNode = e.Node;

I find the standard windows treeview behavior selection behavior to be quite annoying. For example, if you are using Explorer and right click on a node and hit Properties, it highlights the node and shows the properties dialog for the node you clicked on. But when you return from the dialog, the highlighted node was the node previously selected/highlighted before you did the right-click. I find this causes usability problems because I am forever being confused on whether I acted on the right node.
So in many of our GUIs, we change the selected tree node on a right-click so that there is no confusion. This may not be the same as a standard iwndos app like Explorer (and I tend to strongly model our GUI behavior after standard window apps for usabiltiy reasons), I believe that this one exception case results in far more usable trees.
Here is some code that changes the selection during the right click:
private void tree_MouseUp(object sender, System.Windows.Forms.MouseEventArgs e)
{
// only need to change selected note during right-click - otherwise tree does
// fine by itself
if ( e.Button == MouseButtons.Right )
{
Point pt = new Point( e.X, e.Y );
tree.PointToClient( pt );
TreeNode Node = tree.GetNodeAt( pt );
if ( Node != null )
{
if ( Node.Bounds.Contains( pt ) )
{
tree.SelectedNode = Node;
ResetContextMenu();
contextMenuTree.Show( tree, pt );
}
}
}
}

Reviving this question because I find this to be a much better solution.
I use the NodeMouseClick event instead.
void treeview_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
{
if( e.Button == MouseButtons.Right )
{
tree.SelectedNode = e.Node;
}
}

This is a very old question, but I still found it useful. I am using a combination of some of the answers above, because I don't want the right-clicked node to become the selectedNode. If I have the root node selected and want to delete one of it's children, I don't want the child selected when I delete it (I am also doing some work on the selectedNode that I don't want to happen on a right-click). Here is my contribution:
// Global Private Variable to hold right-clicked Node
private TreeNode _currentNode = new TreeNode();
// Set Global Variable to the Node that was right-clicked
private void treeView_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
{
if (e.Button == System.Windows.Forms.MouseButtons.Right)
_currentNode = e.Node;
}
// Do something when the Menu Item is clicked using the _currentNode
private void toolStripMenuItem_Clicked(object sender, EventArgs e)
{
if (_currentNode != null)
MessageBox.Show(_currentNode.Text);
}

Similar to Marcus' answer, this was the solution I found worked for me:
private void treeView_MouseClick(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Right)
{
treeView.SelectedNode = treeView.GetNodeAt(e.Location);
}
}
You need not show the context menu yourself if you set it to each individual node like so:
TreeNode node = new TreeNode();
node.ContextMenuStrip = contextMenu;
Then inside the ContextMenu's Opening event, the TreeView.SelectedNode property will reflect the correct node.

If you want the context menu to be dependent on the selected item you're best move I think is to use Jonesinator's code to select the clicked item. Your context menu content can then be dependent on the selected item.
Selecting the item first as opposed to just using it for the context menu gives a few advantages. The first is that the user has a visual indication as to which he clicked and thus which item the menu is associated with. The second is that this way it's a hell of a lot easier to keep compatible with other methods of invoking the context menu (e.g. keyboard shortcuts).

Here is how I do it.
private void treeView_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
{
if (e.Button == System.Windows.Forms.MouseButtons.Right)
e.Node.TreeView.SelectedNode = e.Node;
}

Another option you could run with is to have a global variable that has the selected node. You would just need to use the TreeNodeMouseClickEventArgs.
public void treeNode_Click(object sender, TreeNodeMouseClickEventArgs e)
{
_globalVariable = e.Node;
}
Now you have access to that node and it's properties.

I would like to propose an alternative to using the click events, using the context menu's Opened event:
private void Handle_ContextMenu_Opened(object sender, EventArgs e)
{
TreeViewHitTestInfo info = treeview.HitTest(treeview.PointToClient(Cursor.Position));
TreeNode contextNode;
// was there a node where the context menu was opened?
if (info != null && info.Node != null)
{
contextNode = info.Node;
}
// Set the enabled states of the context menu elements
menuEdit.Enabled = contextNode != null;
menuDelete.Enabled = contextNode != null;
}
This has the following advantages that I can see:
It does not change the selected node
No separate event handler needed to store the target node instance
Can disable menu items if the user right-clicks empty space in the TreeView
Note: if you worry that the user may have already moved the mouse by the time the menu is opened, it is possible to use the Opening event instead.

Categories

Resources