Mover nodo en árbol hacia arriba o hacia abajo

Question

¿Cuál es la forma más precisa de mover un nodo hacia arriba y hacia abajo en una vista de árbol? Obtuve un menú contextual en cada nodo y el nodo seleccionado debe moverse con todos sus subnodos.

estoy usando C# .NET 3.5 Windows Forms

Answer 1

Puede usar las siguientes extensiones:

public static class Extensions 
{ 
    public static void MoveUp(this TreeNode node) 
    { 
     TreeNode parent = node.Parent; 
     TreeView view = node.TreeView; 
     if (parent != null) 
     { 
      int index = parent.Nodes.IndexOf(node); 
      if (index > 0) 
      { 
       parent.Nodes.RemoveAt(index); 
       parent.Nodes.Insert(index - 1, node); 
      } 
     } 
     else if (node.TreeView.Nodes.Contains(node)) //root node 
     { 
      int index = view.Nodes.IndexOf(node); 
      if (index > 0) 
      { 
       view.Nodes.RemoveAt(index); 
       view.Nodes.Insert(index - 1, node); 
      } 
     } 
    } 

    public static void MoveDown(this TreeNode node) 
    { 
     TreeNode parent = node.Parent; 
     TreeView view = node.TreeView; 
     if (parent != null) 
     { 
      int index = parent.Nodes.IndexOf(node); 
      if (index < parent.Nodes.Count -1) 
      { 
       parent.Nodes.RemoveAt(index); 
       parent.Nodes.Insert(index + 1, node); 
      } 
     } 
     else if (view != null && view.Nodes.Contains(node)) //root node 
     { 
      int index = view.Nodes.IndexOf(node); 
      if (index < view.Nodes.Count - 1) 
      { 
       view.Nodes.RemoveAt(index); 
       view.Nodes.Insert(index + 1, node); 
      } 
     } 
    } 
} 

nodos hijos seguirán sus padres.

EDITAR: Caso agregado que el nodo para mover es una raíz en el TreeView.

Answer 2

Si bien creo que escribir este código es una pérdida de tiempo, dada la falta de respuesta a los comentarios del OP, lo menos que puedo hacer es mostrar cómo el código del ejemplo de Le-Savard se puede reparar para que varios clics de la opción hacia arriba o hacia abajo en el menú contextual ... suponiendo que el menú contextual no se cierra automáticamente cada vez y el usuario se ve obligado a seleccionar el mismo nodo una y otra vez ... hará lo correcto con el nodo seleccionado de manera correcta , y no crear efectos secundarios de la ONU-previsto:

public static class Extensions 
{ 
    public static void MoveUp(this TreeNode node) 
    { 
     TreeNode parent = node.Parent; 
     if (parent != null) 
     { 
      int index = parent.Nodes.IndexOf(node); 
      if (index > 0) 
      { 
       parent.Nodes.RemoveAt(index); 
       parent.Nodes.Insert(index - 1, node); 

       // bw : add this line to restore the originally selected node as selected 
       node.TreeView.SelectedNode = node; 
      } 
     } 
    } 

    public static void MoveDown(this TreeNode node) 
    { 
     TreeNode parent = node.Parent; 
     if (parent != null) 
     { 
      int index = parent.Nodes.IndexOf(node); 
      if (index < parent.Nodes.Count - 1) 
      { 
       parent.Nodes.RemoveAt(index); 
       parent.Nodes.Insert(index + 1, node); 

       // bw : add this line to restore the originally selected node as selected 
       node.TreeView.SelectedNode = node; 
      } 
     } 
    } 
} 

por supuesto esta revisión, aún no aborda el hecho de que en el código de ejemplo que múltiples nodos raíz no se pueden mover (ya que son 'sin padres): eso es easiliy fijable.

Tampoco aborda el caso más interesante en el que mover un nodo secundario superior significa hacer una interpretación de dónde debería ir ese código secundario "promocionado": exactamente la misma "elección estratégica" involucra "mover hacia abajo" "el último nodo hijo de un nodo padre y, por lo tanto, se requiere que decida dónde debe ir. En el código de Dynami Le-Savard: estos casos simplemente se ignoran.

Sin embargo, es un diseño-elección para restringir nodo hijo de solamente ser movido dentro de sus nodos padre Nodos colección: una opción de diseño que puede ser perfectamente adecuado para una solución.

Del mismo modo, se trata de una elección diseño puede obligar al usuario a seleccionar un nodo y hacer un clic contextual para obtener un menú contextual que permite una elección de moverse hacia arriba o hacia abajo cada vez que quieren moverlo : esa no es una opción de diseño que yo haría: usaría arrastrar y soltar aquí o botones que permitan la reubicación rápida repetida de cualquier nodo seleccionado en cualquier parte del árbol.

Por cierto, me gusta el uso de extensiones de Dynami Le-Savard aquí.

Answer 3

Aquí hay una solución que le permite arrastrar & colocar nodos donde desee. Para mover un nodo al mismo nivel que otro nodo, solo mantenga presionada la tecla shift cuando deje caer el nodo. Esta es una manera realmente fácil de seguir en comparación con las alternativas y sus posibles problemas. El ejemplo fue escrito con una versión más reciente de .Net (4.5).

Nota: Asegúrese de que AllowDrop = true en el control TreeView, de lo contrario, no podrá colocar nodos.

/// <summary> 
/// Handle user dragging nodes in treeview 
/// </summary> 
private void treeView1_ItemDrag(object sender, ItemDragEventArgs e) 
{ 
    DoDragDrop(e.Item, DragDropEffects.Move); 
} 

/// <summary> 
/// Handle user dragging node into another node 
/// </summary> 
private void treeView1_DragEnter(object sender, DragEventArgs e) 
{ 
    e.Effect = DragDropEffects.Move; 
} 

/// <summary> 
/// Handle user dropping a dragged node onto another node 
/// </summary> 
private void treeView1_DragDrop(object sender, DragEventArgs e) 
{ 
    // Retrieve the client coordinates of the drop location. 
    Point targetPoint = treeView1.PointToClient(new Point(e.X, e.Y)); 

    // Retrieve the node that was dragged. 
    TreeNode draggedNode = e.Data.GetData(typeof(TreeNode)); 

    // Sanity check 
    if (draggedNode == null) 
    { 
     return; 
    } 

    // Retrieve the node at the drop location. 
    TreeNode targetNode = treeView1.GetNodeAt(targetPoint); 

    // Did the user drop the node 
    if (targetNode == null) 
    { 
     draggedNode.Remove(); 
     treeView1.Nodes.Add(draggedNode); 
     draggedNode.Expand(); 
    } 
    else 
    { 
     TreeNode parentNode = targetNode; 

     // 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) 
     { 
      bool canDrop = true; 
      while (canDrop && (parentNode != null)) 
      { 
       canDrop = !Object.ReferenceEquals(draggedNode, parentNode); 
       parentNode = parentNode.Parent; 
      } 

      if (canDrop) 
      { 
       // Have to remove nodes before you can move them. 
       draggedNode.Remove(); 

       // Is the user holding down shift? 
       if (e.KeyState == 4) 
       { 
        // Is the targets parent node null? 
        if (targetNode.Parent == null) 
        { 
         // The target node has no parent. That means 
         // the target node is at the root level. We'll 
         // insert the node at the root level below the 
         // target node. 
         treeView1.Nodes.Insert(targetNode.Index + 1, draggedNode); 
        } 
        else 
        { 
         // The target node has a valid parent so we'll 
         // drop the node into it's index. 
         targetNode.Parent.Nodes.Insert(targetNode.Index + 1, draggedNode); 
        } 
       } 
       else 
       { 
        targetNode.Nodes.Add(draggedNode); 
       } 

       targetNode.Expand(); 
      } 
     } 
    } 

    // Optional: The following lines are an example of how you might 
    // provide a better experience by highlighting and displaying the 
    // content of the dropped node. 
    // treeView1.SelectedNode = draggedNode; 
    // NavigateToNodeContent(draggedNode.Tag); 
}