comparisonstree.java

The ElectricTM VLSI Design System is an open-source Electronic Design Automation (EDA) system that c

     * @param lpRes  results of Local Partitioning 
     * @param isHashChecked  true is hashcodes were checked
     */
    private void addPartClasses(TreeNode compTreeNode, int compNdx, 
                                DefaultMutableTreeNode inode, 
                                EquivRecReport[] mismEqRecs,
                                boolean isHashChecked) {
        DefaultMutableTreeNode parts, eclass;
        // add parts entry title
        TreeNode partsNode = new TreeNode(compTreeNode, "Parts ", 
                                          compNdx, -1, TreeNode.TITLE);
        parts = new DefaultMutableTreeNode(partsNode);
        inode.add(parts);

        // add part equivalence classes
        int type = TreeNode.PART;
        int count=0;
        boolean truncated = false;
        for (int i=0; i<mismEqRecs.length; i++) {
            if (!mismEqRecs[i].hasParts()) continue;
                
            count++;
            // limit output size
            if (count > MAX_CLASSES) { truncated = true; continue;}
            
            List<String> reasons = mismEqRecs[i].getReasons();
            StringBuffer nodeName = new StringBuffer("#"+ count + " [");
            int size = mismEqRecs[i].maxSize();

            if (size > MAX_LIST_ELEMENTS)
                nodeName.append("first " + MAX_LIST_ELEMENTS + " of ");
            nodeName.append(size + "]");
            
            Iterator<String> it = null;
            String reas = null;            
            if (! isHashChecked) {  // don't process reasons for hash code classes
                it = reasons.iterator();
                if (it.hasNext()) {
                    reas = it.next();
                    // fetch part type if it's available
                    int ind = reas.indexOf("type is ");
                    if (ind >= 0) {
                        nodeName.append(": " + reas.substring(ind + 8));
                        reas = null;
                    }
                } 
                if (it.hasNext() || reas != null) {
                    if (reas == null) {
                        reas = it.next();
                        nodeName.append(", ");
                    } else
                        nodeName.append(": ");
                    // fetch number of wires attached if it's available                    
                    if (reas.endsWith("different Wires attached")) {
                        int a = reas.indexOf("has ") + 4;
                        int b = reas.indexOf(" different");
                        nodeName.append(reas.substring(a,b) + " Wires attached");
                        reas = null;
                    }
                }
            }
            
            TreeNode partTreeNode = new TreeNode(compTreeNode, nodeName.toString(), 
                                                 compNdx, i, type);
            partTreeNode.setShortName("Part Class #"+ count);
            eclass = new DefaultMutableTreeNode(partTreeNode);
            parts.add(eclass);
            
            if (! isHashChecked) {  // don't process reasons for hash code classes
                if (reasons.size() == 0) {
                    eclass.add(new DefaultMutableTreeNode(
                               new TreeNode(partTreeNode, "all Parts are indistinguishable", 
                                            compNdx, i, TreeNode.PARTLEAF)));
                } else {
                    if (reas != null)
                        eclass.add(new DefaultMutableTreeNode(
                                new TreeNode(partTreeNode, reas, compNdx, i, TreeNode.PARTLEAF)));
                    while (it.hasNext())
                        eclass.add(new DefaultMutableTreeNode(
                                   new TreeNode(partTreeNode, it.next(), 
                                                compNdx, i, TreeNode.PARTLEAF)));
                }
            }
        }
        if (count == 0)
            inode.remove(parts);  // remove "Parts" node if no Part classes exist
        else {
            StringBuffer buf = new StringBuffer("Parts ");
            if (isHashChecked) buf.append("(hash code) ");
            buf.append("[");
            if (truncated) buf.append("first " + MAX_CLASSES + " of ");
            buf.append((count) + "]");
            partsNode.setFullName(buf.toString());
        }
    }
    
    /**
     * Add Wire equiv. classes nodes
     * @param compTreeNode  top-level comparison node
     * @param compNdx  comparison index
     * @param inode  tree node to add to
     * @param mismEqRecs  equiv. classes
     * @param lpRes  results of Local Partitioning 
     * @param isHashChecked  true is hashcodes were checked
     */    
    private void addWireClasses(TreeNode compTreeNode, int compNdx, 
                                DefaultMutableTreeNode inode, 
                                EquivRecReport[] mismEqRecs,
                                boolean isHashChecked) {
        DefaultMutableTreeNode wires, eclass, node;
        // add wires entry title
        TreeNode wiresNode = new TreeNode(compTreeNode, "Wires ", 
                                          compNdx, -1, TreeNode.TITLE);
        wires = new DefaultMutableTreeNode(wiresNode);
        inode.add(wires);
        
        // add wire equivalence classes
        TreeNode wireTreeNode;
        int type = TreeNode.WIRE;
        int count = 0;
        boolean truncated = false;

        int i=0;
        for (; i<mismEqRecs.length; i++) {
            if (mismEqRecs[i].hasParts()) continue;
            
            count++;
            // limit output size
            if (count > MAX_CLASSES) { truncated = true; continue;}            
            
            wireTreeNode = new TreeNode(compTreeNode, "Wire Class #" + count, 
                                        compNdx, i, type);
            wireTreeNode.setShortName("Wire Class #" + count);
            wireTreeNode.setWireClassNum(count-1);
            
            eclass = new DefaultMutableTreeNode(wireTreeNode);
            wires.add(eclass);
            if (!isHashChecked) {
                String reasons[] = 
                    mismEqRecs[i].getReasons().toArray(new String[0]);
                int j = 0;
                if (reasons.length == 0) {
                    eclass.add(new DefaultMutableTreeNode(
                            new TreeNode(wireTreeNode, "all Wires are indistinguishable", 
                                         compNdx, i, TreeNode.WIRELEAF)));
                } else if (reasons.length > 1 
                        && reasons[0].startsWith("0") && reasons[1].startsWith("0")) {
                    node = new DefaultMutableTreeNode(
                           new TreeNode(wireTreeNode, "0's", compNdx, i, TreeNode.WIRELEAF));
                    eclass.add(node);
                    for (; j<reasons.length && reasons[j].startsWith("0"); j++) {
                        if (j >= MAX_ZEROS) continue; // limit number of zeros displayed
                        int start = reasons[j].indexOf(" of ");
                        String reason;
                        if (start >= 0)
                            reason = reasons[j].substring(start + 4);
                        else
                            reason = reasons[j];
                        node.add(new DefaultMutableTreeNode(
                                 new TreeNode(wireTreeNode, reason, compNdx, i, TreeNode.WIRELEAF)));
                    }
                }
                for (; j<reasons.length; j++)
                    eclass.add(new DefaultMutableTreeNode(
                               new TreeNode(wireTreeNode, reasons[j], compNdx, i, TreeNode.WIRELEAF)));
            }
        }
        if (count == 0)
            inode.remove(wires);
        else {
            StringBuffer buf = new StringBuffer("Wires ");
            if (isHashChecked) buf.append("(hash code) ");
            buf.append("[");
            if (truncated) buf.append("first " + MAX_CLASSES + " of ");
            buf.append((count) + "]");
            wiresNode.setFullName(buf.toString());
            wireClassNodes[compNdx] = new WireClassNode[count];
        }
    } 
    
    /* (non-Javadoc)
     * ActionListener interface (for popup menus)
     */
    public void actionPerformed(ActionEvent e) {
        Clipboard cb = Toolkit.getDefaultToolkit().getSystemClipboard();
        // copy text prepared during popup to clipboard
        StringSelection ss = new StringSelection(clipboard);
        cb.setContents(ss,ss);                    
    }

    /* (non-Javadoc)
     * TreeSelectionListener interface
     */
    public void valueChanged(TreeSelectionEvent e) {
        TreePath[] paths = e.getPaths();
        boolean doAdded = false;
        // one pass for removed, one - for added nodes
        for (int i=0; i<2; i++) {  
            // loop over all nodes whose state has changed
            for (int j=0; j<paths.length; j++) {  
                if (e.isAddedPath(j) != doAdded) continue;
                if (paths[j] == null) {
                    parentPane.treeSelectionChanged(null, doAdded);
                    continue;
                }
                DefaultMutableTreeNode node = (DefaultMutableTreeNode)paths[j].getLastPathComponent();
                // notify Comparison Pane about the change                
                parentPane.treeSelectionChanged((TreeNode)node.getUserObject(), doAdded);
            }
            doAdded = true;
        }
        // update Comparison Pane
        parentPane.updateRightPane();
    }

    private class MyRenderer extends DefaultTreeCellRenderer {
        /* (non-Javadoc)
         * TreeCellRenderer interface
         */
        public Component getTreeCellRendererComponent(JTree tree, Object value,
                boolean selected, boolean expanded, boolean leaf,
                int row, boolean hasFocus) {
            DefaultMutableTreeNode node = (DefaultMutableTreeNode)value;
            TreeNode data = (TreeNode)node.getUserObject();
            int compNdx = data.compNdx;
            int wclass = data.getWireClassNum();
            if (data.type == TreeNode.WIRE && !updateInProgress
                    && compNdx < wireClassNodes.length && wireClassNodes[compNdx] != null
                    && wclass < wireClassNodes[compNdx].length) {
                // wclass is a special index of Wire classes in each comparison
                // Needed because Wire and part classes are mixed together
                if (wireClassNodes[compNdx][wclass] == null)
                    createWireClassNodes(data, node.isLeaf());
                if (selected)
                    wireClassNodes[compNdx][wclass].select();
                else
                    wireClassNodes[compNdx][wclass].deselect();
                if (!node.isLeaf())
                    if (expanded)
                        wireClassNodes[compNdx][wclass].expand();
                    else
                        wireClassNodes[compNdx][wclass].collapse();
                return wireClassNodes[compNdx][wclass].getPanel();
            }
            
            return super.getTreeCellRendererComponent(tree, value, selected, expanded,
                    leaf, row, hasFocus);
        }
    }
    
    /**
     * Create Wire class nodes for the comparison represented by the supplied node 
     * @param data  comparison top-level tree node
     * @param areLeaves  true if Wire class nodes are leaves
     */
    private void createWireClassNodes(TreeNode data, boolean areLeaves) {
        int compNdx = data.compNdx;
        EquivRecReport[] mismEqRecs = parentPane.getMismatchEquivRecs(compNdx);
        int count = 0, len = wireClassNodes[compNdx].length;
        // max width of the first 3 columns in node names, height of a name 
        int maxWidth0 = 0, maxWidth1 = 0, maxWidth2 = 0, height = 0;
        Font font = getFont();
        boolean isHashPrinted = mismatches[compNdx].isHashFailuresPrinted();
        
        int i;
        if (isHashPrinted) 
            i = 0;
        else // in LP wire mismatches are grouped at the end of mismEqRecs
            i = mismatches[compNdx].getPartRecReports().size();
        // for each equiv. class        
        for (; i<mismEqRecs.length; i++) {