Getting Even Further with Spring RCP (1)

Replacing the Table with a Tree

In the previous part, we displayed our data in a table, using the Spring RCP "AbstractObjectTable" class. This time, instead, we'll display our data in a tree:

 

1. Start by simply pasting the following into the existing CustomerView class:

   private void createTree() {
       DefaultMutableTreeNode rootNode = 
               new DefaultMutableTreeNode("Customers");
       Object[] cutomers = customerDataStore.getAllCustomers();
       for (int i = 0; i < cutomers.length; i++) {
           Customer customer = (Customer) cutomers[i];
           DefaultMutableTreeNode customerNode = 
                   new DefaultMutableTreeNode(customer);
           customerNode.add(new DefaultMutableTreeNode(
                   customer.getAddress().getAddress1()));
           customerNode.add(new DefaultMutableTreeNode(
                   customer.getAddress().getCity()));
           customerNode.add(new DefaultMutableTreeNode(
                   customer.getAddress().getState()));
           rootNode.add(customerNode);
       }
       treeModel = new DefaultTreeModel(rootNode);
       tree = new JTree(treeModel);
       tree.setShowsRootHandles(true);
       tree.setCellRenderer(getTreeCellRenderer());
       tree.setRootVisible(true);
   }
   
   public TreeCellRenderer getTreeCellRenderer() {
       return treeCellRenderer;
   }
   
   private DefaultTreeCellRenderer treeCellRenderer = 
           new FocusableTreeCellRenderer() {
       @Override
       public Component getTreeCellRendererComponent(
               JTree tree, Object value, boolean sel, 
               boolean expanded, boolean leaf, int row, 
               boolean hasFocus) {
           super.getTreeCellRendererComponent(
                   tree, value, sel, expanded, leaf, row, hasFocus);
           DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;
           if (node.isRoot()) {
               this.setIcon(getIconSource().getIcon("folder.icon"));
           } else {
               Object userObject = node.getUserObject();
               if (userObject instanceof Customer) {
                   Customer o = (Customer) userObject;
                   this.setText(o.getFirstName() + " " + o.getLastName());
                   this.setIcon(getIconSource().getIcon("icon1"));
               } else {
                   this.setIcon(getIconSource().getIcon("icon2"));
               }
           }
           return this;
       }
   };

 

2. Next, change the "CustomerView.createControl" as follows:

   @Override
   protected JComponent createControl() {
       //No need to create the customer table anymore:
       //customerTable = new customerTableFactory().createCustomerTable();
       //Create the tree instead:
       createTree();
       JPanel view = new JPanel(new BorderLayout());
       //No need to add the JTable to the JScrollPane anymore:
       //JScrollPane sp = getComponentFactory().createScrollPane(customerTable.getControl());
       //Add the tree to the JScrollPane instead:
       JScrollPane sp = getComponentFactory().createScrollPane(tree);
       view.add(sp, BorderLayout.CENTER);
       return view;
   }

Notice something interesting—or, in fact, boring—we've done a lot of coding to replace our AbstractObjectTable with a JTree. And none of what we've done is specific to Spring RCP—we've only used a standard Swing JTree, after all. However, we're displaying the same data as before. When we were dealing with the Spring RCP forms, how much coding did we need to do to replace one dialog with another? Just one line. We replaced the instantiation of the "TabbedDialogPage" with the instantiation of the "TreeCompositeDialogPage". Wouldn't it be cool if we could do the same thing for our data... and not just for our forms? That's what the next section is all about.