ट्री अप या डाउन

Question

नोड को ट्रीव्यू में ऊपर और नीचे ले जाने का सबसे सटीक तरीका क्या है। मुझे प्रत्येक नोड पर एक संदर्भ मेनू मिला और चयनित नोड को इसके सभी उपन्यासों के साथ स्थानांतरित किया जाना चाहिए।

मैं उपयोग कर रहा हूँ सी # नेट 3.5 WinForms

Answer 1

आप नीचे दिए गए एक्सटेंशन का उपयोग कर सकते हैं:

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); 
      } 
     } 
    } 
} 

बाल नोड्स अपने माता पिता का पालन करेंगे।

संपादित करें: जोड़ा गया मामला जो नोड को स्थानांतरित करने के लिए TreeView में एक रूट है।

Answer 2

जबकि मुझे लगता है कि यह कोड लिखने का समय है, ओपी द्वारा टिप्पणियों के जवाब की कमी के कारण, कम से कम मैं यह कर सकता हूं कि ले-सावार्ड द्वारा कोड उदाहरण कैसे तय किया जा सकता है ताकि बहु क्लिक संदर्भ मेनू पर ऊपर या नीचे विकल्प ... मानते हैं कि संदर्भ मेनू प्रत्येक बार स्वत: बंद नहीं होता है और उपयोगकर्ता को एक ही नोड को बार-बार चुनने के लिए मजबूर किया जाता है ... ऑरगिनली चयनित नोड के साथ सही काम करेगा यह सुधार

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; 
      } 
     } 
    } 
} 

बेशक

, अभी भी तथ्य यह है कि उदाहरण के कोड में जो एक से अधिक जड़ नोड्स हटाया नहीं जा सकता को संबोधित नहीं करता (क्योंकि वे 'parentless हैं)::, और नहीं अन-इरादा दुष्प्रभाव बनाने कि easiliy है सुधारी जा सकने वाली।

न ही यह एक और अधिक दिलचस्प मामला संबोधित करता है जहां एक शीर्ष बाल-नोड को स्थानांतरित करना है, इसका मतलब है कि आप "प्रचारित" बाल कोड कहां जाना चाहिए: बिल्कुल वही "रणनीतिक पसंद" शामिल है जहां आप "नीचे उतरते हैं" "माता-पिता नोड का अंतिम बच्चा नोड और इस प्रकार यह तय करना आवश्यक है कि इसे कहां जाना चाहिए। डायनेमी ले-सावार्ड के कोड में: इन मामलों को अभी अनदेखा कर दिया गया है। एक डिजाइन पसंद है कि एक समाधान के लिए पूरी तरह से उपयुक्त हो सकता है:

हालांकि, यह से केवल अपने मूल नोड्स के भीतर ले जाया जा रहा एक डिजाइन पसंद चाइल्ड नोड प्रतिबंधित करने के लिए है संग्रह नोड्स।

इसी तरह, यह एक डिजाइन पसंद एक नोड और चुनने के लिए उपयोगकर्ता के लिए मजबूर करने के लिए है एक संदर्भ मेनू कि नीचे हर बार ऊपर जा रहा है या के एक विकल्प है कि वे इसे ले जाना चाहते हैं अनुमति देता है प्राप्त करने के लिए संदर्भ-क्लिक करें : यह एक डिज़ाइन विकल्प नहीं है जो मैं करूँगा: मैं यहां ड्रैग-एंड-ड्रॉप का उपयोग कर रहा हूं या बटन जो पेड़ में कहीं भी किसी भी चयनित नोड के दोबारा तेजी से आग स्थानांतरण की अनुमति देता है।

जिस तरह से मुझे डायनेमी ले-सावार्ड के एक्सटेंशन का उपयोग पसंद है।

Answer 3

यहां एक समाधान है जो आपको जहां भी चाहें & ड्रॉप नोड खींचने की अनुमति देता है। एक नोड को एक और नोड के समान स्तर पर ले जाने के लिए, नोड को छोड़ते समय बस शिफ्ट दबाएं। विकल्प और उनकी संभावित समस्याओं की तुलना में यह वास्तव में आसान तरीका है। उदाहरण .Net (4.5) के एक नवीनतम संस्करण के साथ लिखा गया था।

नोट: सुनिश्चित करें और ट्रीव्यू नियंत्रण पर TrueDrop = true अन्यथा आप नोड्स को नहीं छोड़ सकते हैं।

/// <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); 
}