errorloggertree.java

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

            children[l] = errorTree.getChildAt(oldIndex);
            l++;
        }
        if (index >= 0) {
            childIndex[l] = index;
            children[l] = errorTree.getChildAt(index);
            l++;
        }
        if (oldIndex >= 0 && oldIndex > index) {
            childIndex[l] = oldIndex;
            children[l] = errorTree.getChildAt(oldIndex);
            l++;
        }
        ExplorerTreeModel.fireTreeNodesChanged(errorTree, errorPath, childIndex, children);
    }

    /** Delete this logger */
//    private static void delete(ErrorLoggerTreeNode node) {
//        int index = indexOf(node);
//        if (index < 0) return;
//        removeLogger(index);
//        if (currentLogger != null && ((ErrorLoggerTreeNode)currentLogger.getUserObject()) == node) {
//            if (errorTree.getChildCount() != 0)
//                currentLogger = (DefaultMutableTreeNode)errorTree.getChildAt(0);
//            else
//                currentLogger = null;
//        }
//    }

    private static int indexOf(ErrorLoggerTreeNode tn) {
        for (int i = 0, numLoggers = errorTree.getChildCount(); i < numLoggers; i++)
            if (((DefaultMutableTreeNode)errorTree.getChildAt(i)).getUserObject() == tn) return i;
        return -1;
    }

    private static int indexOf(ErrorLogger logger) {
        for (int i = 0, numLoggers = errorTree.getChildCount(); i < numLoggers; i++) {
            DefaultMutableTreeNode defaultMutableTreeNode = (DefaultMutableTreeNode)errorTree.getChildAt(i);
            ErrorLoggerTreeNode errorLoggerTreeNode = (ErrorLoggerTreeNode)defaultMutableTreeNode.getUserObject();
            if (errorLoggerTreeNode.logger == logger) return i;
        }
        return -1;
    }

    public static void importLogger()
    {
        String fileName = OpenFile.chooseInputFile(FileType.XML, "Read ErrorLogger");
        if (fileName == null) return; // nothing to load

        try {
            ErrorLogger.XMLParser parser = new ErrorLogger.XMLParser();
            ErrorLogger logger = parser.process(TextUtils.makeURLToFile(fileName), true);
            if (logger != null)
                addLogger(logger, false, true);
        } catch (Exception e)
		{
			System.out.println("Error loading " + fileName);
			return;
		}
    }

    public static class ErrorLoggerDefaultMutableTreeNode extends DefaultMutableTreeNode {
        ErrorLoggerDefaultMutableTreeNode(ErrorLoggerTreeNode tn) { super(tn); }
        public boolean isLeaf() { return false; }
    }

    public static class ErrorLoggerGroupNode
    {
    	private String name;
    	private int sortKey;
    	private ErrorLoggerTreeNode parent;

    	ErrorLoggerGroupNode(String s, int k, ErrorLoggerTreeNode p)
    	{
    		name = s;
    		sortKey = k;
    		parent = p;
    	}

    	public int getSortKey() { return sortKey; }

    	public ErrorLoggerTreeNode getParentNode() { return parent; }

    	public boolean equals(Object x)
    	{
    		if (x instanceof ErrorLoggerGroupNode)
    		{
    			ErrorLoggerGroupNode elgn = (ErrorLoggerGroupNode)x;
    			if (elgn.name.equals(name) && elgn.parent == parent) return true;
    		}
    		return false;
    	}

    	public String toString() { return name; }
    }

    public static class ErrorLoggerTreeNode implements DatabaseChangeListener //, ActionListener
    {
        private ErrorLogger logger;
        private int currentLogNumber;

        ErrorLoggerTreeNode(ErrorLogger log)
        {
            this.logger = log;
        }

        public void setLogNumber(int number) { currentLogNumber = number;}

        public ErrorLogger getLogger() { return logger; }

        public String toString() { return "ErrorLogger Information: " +  logger.getInfo();}

        public String reportNextMessage_(boolean showHigh) {
            if (currentLogNumber < logger.getNumLogs()-1) {
                currentLogNumber++;
            } else {
                if (logger.getNumLogs() <= 0) return "No "+logger.getSystem()+" errors";
                currentLogNumber = 0;
            }
            return reportLog(currentLogNumber, showHigh);
        }

        public String reportPrevMessage_() {
            if (currentLogNumber > 0) {
                currentLogNumber--;
            } else {
                if (logger.getNumLogs() <= 0) return "No "+logger.getSystem()+" errors";
                currentLogNumber = logger.getNumLogs() - 1;
            }
            return reportLog(currentLogNumber, true);
        }

        /**
         * Report an error
         */
        private String reportLog(int logNumber, boolean showHigh) {

            if (logNumber < 0 || (logNumber >= logger.getNumLogs())) {
                return logger.getSystem() + ": no such error or warning "+(logNumber+1)+", only "+logger.getNumLogs()+" errors.";
            }

            ErrorLogger.MessageLog el = logger.getLog(logNumber);
            String extraMsg = null;
            if (logNumber < logger.getNumErrors()) {
                extraMsg = " error " + (logNumber+1) + " of " + logger.getNumErrors();
            } else {
                extraMsg = " warning " + (logNumber+1-logger.getNumErrors()) + " of " + logger.getNumWarnings();
            }
            String message = Job.getUserInterface().reportLog(el, showHigh, null);
            return (logger.getSystem() + extraMsg + ": " + message);
        }

        public void databaseChanged(DatabaseChangeEvent e) {
            // check if any errors need to be deleted
            boolean changed = false;
            for (int i = logger.getNumLogs() - 1; i >= 0; i--) {
                MessageLog err = logger.getLog(i);
                if (!err.isValid(EDatabase.clientDatabase())) {
                    logger.deleteLog(i);
                    if (i < currentLogNumber)
                        currentLogNumber--;
                    else if (i == currentLogNumber)
                        currentLogNumber = 0;
                    changed = true;
                }
            }
            if (!changed) return;
            int index = indexOf(this);
            if (index < 0) return;
            if (logger.getNumLogs() == 0)
                removeLogger(index);
            else
            {
        		// remember the state of the tree
            	WindowFrame wf = WindowFrame.getCurrentWindowFrame();
            	if (wf != null)
            	{
	            	ExplorerTree tree = wf.getExplorerTab();
	            	ExplorerTreeModel etm = tree.model();
	            	ExplorerTree.KeepTreeExpansion kte = new ExplorerTree.KeepTreeExpansion(tree, etm.getRoot(), etm, errorPath);
	                updateTree((DefaultMutableTreeNode)errorTree.getChildAt(index));
	                kte.restore();
            	}
            }
        }

//        public void actionPerformed(ActionEvent e)
//        {
//            int index = indexOf(this);
//            if (e.getSource() instanceof JMenuItem)
//            {
//                JMenuItem m = (JMenuItem)e.getSource();
//                if (m.getText().equals("Delete"))
//                {
//                	boolean removedStuff = false;
//                	WindowFrame wf = WindowFrame.getCurrentWindowFrame();
//                	if (wf != null)
//                	{
//	                	ExplorerTree ex = wf.getExplorerTab();
//	                	TreePath [] paths = ex.getSelectionPaths();
//	                	for(int i=0; i<paths.length; i++)
//	                	{
//	    	                Object obj = paths[i].getLastPathComponent();
//	    	                if (obj instanceof DefaultMutableTreeNode)
//	    	                {
//	    	                	Object clickedObject = ((DefaultMutableTreeNode)obj).getUserObject();
//	    	                	if (clickedObject instanceof ErrorLoggerTreeNode)
//	    	                	{
//	    	                		index = indexOf((ErrorLoggerTreeNode)clickedObject);
//	    	                    	removeLogger(index);
//	    	                    	removedStuff = true;
//	    	                	}
//	    	                }
//	                	}
//                	}
//                	if (!removedStuff)
//                		removeLogger(index);
//                } else if (m.getText().equals("Export"))
//                {
//                    String filePath = null;
//                    try
//                    {
//                        filePath = OpenFile.chooseOutputFile(FileType.XML, null, "ErrorLoggerSave.xml");
//                        if (filePath == null) return; // cancel operation
//                        logger.exportErrorLogger(filePath);
//                    } catch (Exception se)
//                    {
//                        System.out.println("Error creating " + filePath);
//                    }
//                } else if (m.getText().equals("Show All"))
//                {
//                	WindowFrame wf = WindowFrame.getCurrentWindowFrame();
//                	if (wf == null) return;
//                	Job.getUserInterface().getCurrentEditWindow_().clearHighlighting();
//                	ExplorerTree ex = wf.getExplorerTab();
//                	TreePath [] paths = ex.getSelectionPaths();
//                	for(int i=0; i<paths.length; i++)
//                	{
//    	                Object obj = paths[i].getLastPathComponent();
//    	                if (obj instanceof DefaultMutableTreeNode)
//    	                {
//    	                	Object clickedObject = ((DefaultMutableTreeNode)obj).getUserObject();
//    	                	if (clickedObject instanceof ErrorLoggerTreeNode)
//    	                	{
//    	                		index = indexOf((ErrorLoggerTreeNode)clickedObject);
//    	                		highlightLogger(index);
//    	                	}
//    	                }
//                	}
//                	Job.getUserInterface().getCurrentEditWindow_().finishedHighlighting();
//                } else if (m.getText().equals("Get Info"))
//                {
//                    System.out.println("ErrorLogger Information: " +  logger.getInfo());
//                } else if (m.getText().equals("Set Current"))
//                {
//                    setCurrent(index);
//                }
//            }
//        }
    }

    public static void deleteAllLoggers() {
        for (int i = errorTree.getChildCount() - 1; i >= 0; i--)
            removeLogger(i);
    }

    public static void deleteLogger(ExplorerTree ex)
    {                                             
        TreePath [] paths = ex.getSelectionPaths();
        for(int i=0; i<paths.length; i++)
        {
            Object obj = paths[i].getLastPathComponent();
            if (obj instanceof DefaultMutableTreeNode)
            {
                Object clickedObject = ((DefaultMutableTreeNode)obj).getUserObject();
                if (clickedObject instanceof ErrorLoggerTreeNode)
                {
                    int index = indexOf((ErrorLoggerTreeNode)clickedObject);
                    removeLogger(index);
                }
            }
        }
    }

    public static void exportLogger(ErrorLoggerTreeNode node)
    {
        ErrorLogger logger = node.getLogger();
        String filePath = null;
        try
        {
            filePath = OpenFile.chooseOutputFile(FileType.XML, null, "ErrorLoggerSave.xml");
            if (filePath == null) return; // cancel operation
            logger.exportErrorLogger(filePath);
        } catch (Exception se)
        {
            System.out.println("Error creating " + filePath);
        }
    }
    
    public static void showAllLogger(ExplorerTree ex)
    {  	
        Job.getUserInterface().getCurrentEditWindow_().clearHighlighting();
        TreePath [] paths = ex.getSelectionPaths();
        for(int i=0; i<paths.length; i++)
        {
            Object obj = paths[i].getLastPathComponent();
            if (obj instanceof DefaultMutableTreeNode)
            {
                Object clickedObject = ((DefaultMutableTreeNode)obj).getUserObject();
                if (clickedObject instanceof ErrorLoggerTreeNode)
                {
                    int index = indexOf((ErrorLoggerTreeNode)clickedObject);
                    highlightLogger(index, -1);
                } else if (clickedObject instanceof ErrorLoggerGroupNode)
                {
                	ErrorLoggerGroupNode egn = (ErrorLoggerGroupNode)clickedObject;
                	int sortKey = egn.getSortKey();
                    int index = indexOf(egn.getParentNode());
                    highlightLogger(index, sortKey);
                } else if (clickedObject instanceof ErrorLogger.MessageLog)
                {
                	ErrorLogger.MessageLog ml = (ErrorLogger.MessageLog)clickedObject;
                	EditWindow ew = EditWindow.getCurrent();
                	if (ew == null) return;
                	Highlighter h = ew.getHighlighter();
                    EDatabase database = EDatabase.clientDatabase();
                    for(Iterator<ErrorHighlight> it = ml.getHighlights(); it.hasNext(); )
                	{
                		ErrorHighlight eh = it.next();
                		eh.addToHighlighter(h, database);
                	}
                }
            }
        }
        Job.getUserInterface().getCurrentEditWindow_().finishedHighlighting();
    }

    public static void setCurrentLogger(ErrorLoggerTreeNode node)
    {
        int index = indexOf(node);
        setCurrent(index);
    }
}