Changeset 164

Timestamp:

08/16/11 18:29:34 (13 years ago)

Author:

jhall

Message:

Implemented a new way to build the tree view - work in progress

File:

• trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/swing/DlgInsert.java (modified) (6 diffs)

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/swing/DlgInsert.java

@@ -3 +3 @@
 import java.awt.BorderLayout;
 import java.util.ArrayList;
+import java.util.Enumeration;
 import java.util.List;
 
@@ -33 +34 @@
 import javax.swing.tree.DefaultTreeModel;
 import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.TreePath;
+import javax.swing.event.TreeSelectionListener;
+import javax.swing.event.TreeSelectionEvent;
 
 public class DlgInsert extends JDialog {
@@ -81 +85 @@
                 final JComboBox comboBoxTestcase = new JComboBox();
                 final JPanel panelTextEquals = new JPanel();
-                panelTextEquals.setBorder(new EtchedBorder(EtchedBorder.LOWERED, null, null));
+                panelTextEquals.setBorder(new EtchedBorder(EtchedBorder.LOWERED, null,
+                                null));
                 final JPanel panelFileEquals = new JPanel();
-                panelFileEquals.setBorder(new EtchedBorder(EtchedBorder.LOWERED, null, null));
+                panelFileEquals.setBorder(new EtchedBorder(EtchedBorder.LOWERED, null,
+                                null));
 
                 // JComboBox: comboBoxTestcase
@@ -140 +146 @@
                 panelTextEquals.add(scrollPane);
 
-                final JList listTargets = new JList(modelListTargets);          
+                final JList listTargets = new JList(modelListTargets);
                 scrollPane.setViewportView(listTargets);
-                
+
                 JScrollPane scrollPane_1 = new JScrollPane();
                 scrollPane_1.setBounds(10, 63, 474, 276);
                 panelTextEquals.add(scrollPane_1);
-                
-                //JTree to hold the targets
-                JTree tree = new JTree();
-                tree.setModel(new DefaultTreeModel(
-                        new DefaultMutableTreeNode("Targets") {
-                                {
-                                        List<DefaultMutableTreeNode> nodes = new ArrayList<DefaultMutableTreeNode>();
-                                        List<String> listTargets = new ArrayList<String>();
-                                        List<String> sortedTargets = new ArrayList<String>();
-
-                                        try {
-                                                listTargets = (List<String>) GlobalDataContainer.getInstance().getData("ListTargets");
-                                        }
-                                        catch (ClassCastException e) {
-                                                Console.println("Not able to cast data in GlobalDataContainer to List of Strings");
-                                        }
-                
-                                        int parts = 1;
-                                        while(sortedTargets.size() < listTargets.size()) {
-                                                for(int i=0; i<listTargets.size(); i++) {
-                                                        String splitted[] = listTargets.get(i).split("/>");
-                                                        if(splitted.length == parts) {
-                                                                sortedTargets.add(listTargets.get(i));
-                                                                modelListTargets.addElement(listTargets.get(i));
-                                                                
-                                                                //insert in tree
-                                                                boolean inserted = false;
-                                                                for(int j=parts-2; j>=0 && !inserted; j--) {
-                                                                        splitted[j] = splitted[j] + "/>";
-                                                                        for(int k=0; k<nodes.size(); k++) {
-                                                                                if(nodes.get(k).toString().compareTo(splitted[j]) == 0) {
-                                                                                        DefaultMutableTreeNode newNode = new DefaultMutableTreeNode(splitted[j+1]);
-                                                                                        nodes.add(newNode);
-                                                                                        nodes.get(k).add(newNode);
-                                                                                        inserted = true;
-                                                                                        break;
-                                                                                }
-                                                                        }
-                                                                }
-                                                                
-                                                                if(!inserted) {
-                                                                        DefaultMutableTreeNode newNode = new DefaultMutableTreeNode(listTargets.get(i).toString());
-                                                                        nodes.add(newNode);
-                                                                        add(newNode);
-                                                                }
+
+                // JTree to hold the targets
+                final JTree tree = new JTree();
+                tree.addTreeSelectionListener(new TreeSelectionListener() {
+                        public void valueChanged(TreeSelectionEvent arg0) {
+                                TreePath path = tree.getSelectionPath();
+                                textFieldExpectedValue.setText(path.toString());
+                        }
+                });
+                DefaultTreeModel treeModel = new DefaultTreeModel(null);
+                DefaultMutableTreeNode root = new DefaultMutableTreeNode("Targets");
+                treeModel.setRoot(root);
+                tree.setModel(treeModel);
+
+                // List<DefaultMutableTreeNode> nodes = new
+                // ArrayList<DefaultMutableTreeNode>();
+                List<String> listTargets1 = new ArrayList<String>(); // targets out of
+                                                                                                                                // GlobalDataContainer
+                List<String> sortedTargets = new ArrayList<String>(); // targets will be
+                                                                                                                                // sorted by
+                                                                                                                                // number of
+                                                                                                                                // parts,
+                                                                                                                                // splitted at
+                                                                                                                                // "/>"
+
+                try {
+                        listTargets1 = (List<String>) GlobalDataContainer.getInstance()
+                                        .getData("ListTargets");
+                } catch (ClassCastException e) {
+                        Console.println("Not able to cast data in GlobalDataContainer to List of Strings");
+                }
+
+                int parts = 1;
+                while (sortedTargets.size() < listTargets1.size()) {
+                        for (int i = 0; i < listTargets1.size(); i++) {
+                                String splitted[] = listTargets1.get(i).split("/>");
+
+                                // sort targets by number of parts
+                                if (splitted.length != parts)
+                                        continue;
+
+                                sortedTargets.add(listTargets1.get(i));
+
+                                // insert in tree
+                                DefaultMutableTreeNode node = compareTargetWithNode(root,
+                                                listTargets1.get(i));
+
+                                if (node == null) {
+                                        DefaultMutableTreeNode newNode[] = new DefaultMutableTreeNode[splitted.length];
+
+                                        for (int j = 0; j < splitted.length; j++) {
+                                                newNode[j] = new DefaultMutableTreeNode(splitted[j]
+                                                                + "/>");
+
+                                                if (j == 0) {
+                                                        root.add(newNode[0]);
+                                                } else {
+                                                        newNode[j - 1].add(newNode[j]);
+                                                }
+                                        }
+                                } else {
+                                        for (int j = 0; j < splitted.length; j++) {
+                                                if (node.toString().compareTo(splitted[j] + "/>") != 0)
+                                                        continue;
+
+                                                DefaultMutableTreeNode newNode[] = new DefaultMutableTreeNode[splitted.length
+                                                                - j - 1];
+                                                for (int k = 0; k < newNode.length; k++) {
+                                                        newNode[k] = new DefaultMutableTreeNode(splitted[j
+                                                                        + k + 1]
+                                                                        + "/>");
+
+                                                        if (k == 0) {
+                                                                node.add(newNode[0]);
+                                                        } else {
+                                                                newNode[k - 1].add(newNode[k]);
                                                         }
                                                 }
-                                                
-                                                parts++;
                                         }
                                 }
                         }
-                ));
+                        parts++;
+                }
                 scrollPane_1.setViewportView(tree);
-                
 
                 if (listTargets.getComponentCount() > 0)
@@ -242 +277 @@
                 {
                         JPanel buttonPane = new JPanel();
-                        buttonPane.setBorder(new EtchedBorder(EtchedBorder.LOWERED, null, null));
+                        buttonPane.setBorder(new EtchedBorder(EtchedBorder.LOWERED, null,
+                                        null));
                         buttonPane.setBounds(12, 531, 494, 51);
                         contentPanel.add(buttonPane);
@@ -355 +391 @@
                 // ***
         }
+
+        DefaultMutableTreeNode compareTargetWithNode(DefaultMutableTreeNode node,
+                        String target) {
+
+                if (node.isLeaf()) {
+                        if (target.contains(node.toString()))
+                                return node;
+                        else
+                                return null;
+                } else {
+                        for (@SuppressWarnings("unchecked")
+                        Enumeration<DefaultMutableTreeNode> e = node.children(); e
+                                        .hasMoreElements();) {
+                                DefaultMutableTreeNode nodeReturn = compareTargetWithNode(
+                                                e.nextElement(), target);
+                                if (nodeReturn == null) {
+                                        if (target.contains(node.toString()))
+                                                return node;
+                                } else
+                                        return nodeReturn;
+                        }
+                }
+
+                return null;
+        }
 }