JTree cut and paste multiple child and ancestor nodes not function correct

Question

Hello i'm creating a filebrowser for multimedia files (SDK 1.22) such as .jpg .gif .au .wav. (using Swing, JTree, DefaultMutableTreeNode)
The problem is I want to cut and paste single and multiple nodes (from current node til the last child "top-down") which partly functions:
single nodes and multiple nodes with only one folder per hierarchy level;
Not function:
- multiple folders in the same level -> the former order gets lost
- if there is a file (MMed. document) between folders (or after them) in the same level this file is put inside one of those
I tried much easier functions to cope with this problem but every time I solve one the "steps" the next problem appears...
The thing I don't want to do, is something like a LinkedList, Hashtable (to store the nodes)... because the MMed. filebrowser would need to much resources while browsing through a media library with (e.g.) thousands of files!
If someone has any idea to solve this problem I would be very pleased!
Thank you anyway by reading this ;)
// part of the code, if you want more detailed info
// @mail: [email protected]
import java.util.Enumeration;
import javax.swing.*;
import javax.swing.tree.*;
// var declaration
static Enumeration en;
static DefaultMutableTreeNode jTreeModel, lastCopiedNode, dmt, insert, insertParent, insertSameFolder;
static String varCut;
static int index= 0;
static int counter = 0;
/* cut function */
if (actionCommand.equals ("cut"))
     // get the selected node (DefaultMutableTreeNode)
     lastCopiedNode = (DefaultMutableTreeNode)  selPath.getLastPathComponent ();
     // get the nodes in an Enumeration array (in top- down order)
     en = dmt.preorderEnumeration();
     // the way to make sure if it is a cut or a copied node
     varCut = "cut";
/* paste function */
if (actionCommand.equals ("paste"))
// node is cut
if (varCut == "cut")
// is necessary for first time same folder case
insertParent = dmt;
// getting the nodes out of the array
while(en.hasMoreElements())
     // cast the Object to DefaultMutableTreeNode
     // and get stored (next) node
     insert = (DefaultMutableTreeNode) en.nextElement();
// check if the node is a catalogue when getRepresentation()
// is a function of my node creating class (to know if it is
// a folder or a file)
if (insert.getRepresentation().equals("catalogue"))
     // check if a "folder" node is inserted
     if (index == 1)
          counter = 0;
          index = 0;
     System.out.println ("***index and counter reset***");
     // the node is in the same folder
     // check if the folder is in the same hierarchy level
     // -> in this case the insertParent has to remain
     if (insert.getLevel() == insertParent.getLevel())
          // this is necessary to get right parent folder
          insertSameFolder = (Knoten) insert.getParent();
          jTreeModel.insertNodeInto (insert, insertSameFolder, index);
System.out.println (">>>sameFolderCASE- insert"+counter+"> " + String.valueOf(insert) +
          "\ninsertTest -> " + String.valueOf(insertTest)
          // set insertParent folder to the new createded one
          insertParent = insert;
          index ++;
     else // the node is a subfolder
          // insertNode
          jTreeModel.insertNodeInto (insert, insertParent, index);
          // set insertParent folder to the new createded one
          insertParent = insert;
System.out.println (">>>subFolderCASE- insertParent"+counter+"> " + String.valueOf(insertParent) +
          "\ninsertParent -> " + String.valueOf(insertParent)
          index ++;
else // the node is a file
     // insertNode
     jTreeModel.insertNodeInto (insert, insertParent, counter);
     System.out.println (">>>fileCASE insert "+counter+"> " + String.valueOf(insert) +
     "\ninsertParent -> " + String.valueOf(insertParent)
counter ++;
// reset index and counter for the next loop
index = 0;
counter = 0;
// reset cut var
varCut = null;
// remove the node (automatically deletes subfolders and files)
dmt.removeNodeFromParent (lastCopiedNode);
// if node is a copied one
if varCut == null)
     // insert copied node the same way as for cut one's
     // to make it possible to copy more than one node
}

Answer 1

You need to use a recursive copy method to do this. Here's a simple example of the copy. To do a cut you need to do a copy and then delete the source.
import java.io.*;
import javax.swing.*;
import javax.swing.tree.*;
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.event.*;
import java.util.*;
public class CopyTree extends JFrame
     Container cp;
     JTree cTree;
     JScrollPane spTree;
     DefaultTreeModel cModel;
     CNode cRoot;
     JMenuBar menuBar = new JMenuBar();
     JMenu editMenu = new JMenu("Edit");
     JMenuItem copyItem = new JMenuItem("Copy");
     JMenuItem pasteItem = new JMenuItem("Paste");
     TreePath [] sourcePaths;
     TreePath [] destPaths;
     // =====================================================================
     // constructors and public methods
     CopyTree()
          super("Copy Tree Example");
          addWindowListener(new WindowAdapter()
          {public void windowClosing(WindowEvent evt){System.exit(0);}});
          // edit menu
          copyItem.addActionListener(new ActionListener()
          {public void actionPerformed(ActionEvent e){mnuCopy();}});
          editMenu.add(copyItem);
          pasteItem.addActionListener(new ActionListener()
          {public void actionPerformed(ActionEvent e){mnuPaste();}});
          editMenu.add(pasteItem);
          menuBar.add(editMenu);
          setJMenuBar(menuBar);
          buildModel();
          cp = getContentPane();
          cTree = new JTree(cModel);
          spTree = new JScrollPane(cTree);
          cp.add(spTree, BorderLayout.CENTER);
          pack();
     static public void main(String [] args)
          new CopyTree().show();
     // =====================================================================
     // private methods - User Interface
     private void mnuCopy()
          sourcePaths = cTree.getSelectionPaths();
     private void mnuPaste()
          TreePath sp, dp;
          CNode sn,dn;
          int i;
          destPaths = cTree.getSelectionPaths();
          if(1 == destPaths.length)
               dp = destPaths[0];
               for(i=0; i< sourcePaths.length;i++)
                    sp = sourcePaths;
                    if(sp.isDescendant(dp) || dp.isDescendant(sp))
                         JOptionPane.showMessageDialog
                              (null, "source and destinations overlap","Paste", JOptionPane.ERROR_MESSAGE);
                         return;
               dn = (CNode)dp.getLastPathComponent(); // the node we will append our source to
               for(i=0; i< sourcePaths.length;i++)
                    sn = (CNode)sourcePaths[i].getLastPathComponent();
                    copyNode(sn,dn);
          else
               JOptionPane.showMessageDialog
                    (null, "multiple destinations not allowed","Paste", JOptionPane.ERROR_MESSAGE);
     // recursive copy method
     private void copyNode(CNode sn, CNode dn)
          int i;
          CNode scn = new CNode(sn);      // make a copy of the node
          // insert it into the model
          cModel.insertNodeInto(scn,dn,dn.getChildCount());
          // copy its children
          for(i = 0; i<sn.getChildCount();i++)
               copyNode((CNode)sn.getChildAt(i),scn);
     // ===================================================================
     // private methods - just a sample tree
     private void buildModel()
          int k = 0;
          cRoot = new CNode("root");
          cModel = new DefaultTreeModel(cRoot);
          CNode n1a = new CNode("n1a");
          cModel.insertNodeInto(n1a,cRoot,k++);
          CNode n1b = new CNode("n1b");
          cModel.insertNodeInto(n1b,cRoot,k++);
          CNode n1c = new CNode("n1c");
          cModel.insertNodeInto(n1c,cRoot,k++);
          CNode n1d = new CNode("n1d");
          cModel.insertNodeInto(n1d,cRoot,k++);
          k = 0;
          CNode n1a1 = new CNode("n1a1");
          cModel.insertNodeInto(n1a1,n1a,k++);
          CNode n1a2 = new CNode("n1a2");
          cModel.insertNodeInto(n1a2,n1a,k++);
          CNode n1a3 = new CNode("n1a3");
          cModel.insertNodeInto(n1a3,n1a,k++);
          CNode n1a4 = new CNode("n1a4");
          cModel.insertNodeInto(n1a4,n1a,k++);
          k = 0;
          CNode n1c1 = new CNode("n1c1");
          cModel.insertNodeInto(n1c1,n1c,k++);
          CNode n1c2 = new CNode("n1c2");
          cModel.insertNodeInto(n1c2,n1c,k++);
     // simple tree node with copy constructor
     class CNode extends DefaultMutableTreeNode
          private String name = "";
          // default constructor
          CNode(){this("");}
          // new constructor
          CNode(String n){super(n);}
          // copy constructor
          CNode(CNode c)
               super(c.getName());
          public String getName(){return (String)getUserObject();}
          public String toString(){return  getName();}