| /* |
| * The Apache Software License, Version 1.1 |
| * |
| * |
| * Copyright (c) 1999 The Apache Software Foundation. All rights |
| * reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * 3. The end-user documentation included with the redistribution, |
| * if any, must include the following acknowledgment: |
| * "This product includes software developed by the |
| * Apache Software Foundation (http://www.apache.org/)." |
| * Alternately, this acknowledgment may appear in the software itself, |
| * if and wherever such third-party acknowledgments normally appear. |
| * |
| * 4. The names "Xerces" and "Apache Software Foundation" must |
| * not be used to endorse or promote products derived from this |
| * software without prior written permission. For written |
| * permission, please contact apache@apache.org. |
| * |
| * 5. Products derived from this software may not be called "Apache", |
| * nor may "Apache" appear in their name, without prior written |
| * permission of the Apache Software Foundation. |
| * |
| * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR |
| * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF |
| * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT |
| * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| * ==================================================================== |
| * |
| * This software consists of voluntary contributions made by many |
| * individuals on behalf of the Apache Software Foundation and was |
| * originally based on software copyright (c) 1999, International |
| * Business Machines, Inc., http://www.apache.org. For more |
| * information on the Apache Software Foundation, please see |
| * <http://www.apache.org/>. |
| */ |
| |
| package ui; |
| |
| |
| import java.awt.*; |
| import java.awt.event.*; |
| import java.util.*; |
| import java.io.*; |
| import javax.swing.*; |
| import javax.swing.tree.*; |
| import javax.swing.event.*; |
| import java.net.URL; |
| import java.net.MalformedURLException; |
| |
| import org.w3c.dom.Attr; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.NamedNodeMap; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Text; |
| import org.xml.sax.InputSource; |
| import org.xml.sax.ErrorHandler; |
| import org.xml.sax.Locator; |
| import org.xml.sax.SAXException; |
| import org.xml.sax.SAXParseException; |
| import org.apache.xerces.parsers.DOMParser; |
| import ui.DOMParserSaveEncoding; |
| |
| |
| |
| /** |
| * A sample DOM Tree Viewer. This sample program illustrates how to |
| * traverse a DOM tree and display it in a Swing JTree View. |
| * |
| * @version |
| */ |
| public class TreeView extends JFrame implements ActionListener, TextListener { |
| |
| // |
| // Constants |
| // |
| |
| static final boolean DEBUG = true; |
| |
| /** Default parser name. */ |
| static final String |
| DEFAULT_PARSER_NAME = "org.apache.xerces.parsers.DOMParser"; |
| static int WARNING = 0; |
| static int ERROR=1; |
| static int FATAL_ERROR=2; |
| |
| |
| static final String title = "TreeViewer"; |
| static final String openString = "Open"; |
| static final String quitString = "Quit"; |
| static final String reloadString = "Reload current XML file"; |
| static final String expandString = "Expand Tree"; |
| static final String collapseString = "Collapse Tree"; |
| |
| // |
| // Data |
| // |
| |
| ErrorStorer ef; |
| String fname; |
| DOMTree m_tree; |
| JTextArea sourceText, messageText; |
| Vector textLine; |
| FileNameInput fni; |
| DOMParserSaveEncoding parser; |
| Image openFolder; |
| Image closedFolder; |
| Image leafImage; |
| |
| /** |
| * Constructor |
| */ |
| public TreeView() { |
| this(null); |
| } |
| |
| /** |
| * Constructor |
| */ |
| public TreeView(String uri) { |
| super(uri); |
| openFolder = DefaultImages.createOpenFolderImage(); |
| closedFolder = DefaultImages.createClosedFolderImage(); |
| leafImage = DefaultImages.createLeafImage(); |
| parser = new DOMParserSaveEncoding(); |
| ef = new ErrorStorer(); |
| fname = uri; |
| JMenuBar jmb = new JMenuBar(); |
| JMenu fileMenu = new JMenu("File"); |
| JMenuItem item; |
| |
| item = new JMenuItem(openString); |
| fileMenu.add(item); |
| item.addActionListener(this); |
| |
| item = new JMenuItem(quitString); |
| fileMenu.add(item); |
| item.addActionListener(this); |
| |
| JMenu shortcutMenu = new JMenu("Shortcuts"); |
| |
| item = new JMenuItem(expandString); |
| shortcutMenu.add(item); |
| item.addActionListener(this); |
| |
| item = new JMenuItem(collapseString); |
| shortcutMenu.add(item); |
| item.addActionListener(this); |
| |
| item = new JMenuItem(reloadString); |
| shortcutMenu.add(item); |
| item.addActionListener(this); |
| |
| jmb.add(fileMenu); |
| jmb.add(shortcutMenu); |
| setJMenuBar(jmb); |
| |
| getContentPane().add(createUI(fname)); |
| |
| } |
| |
| /** create and return the entire UI from the root TreeNode |
| */ |
| JComponent createUI(String filename) { |
| if (DEBUG) System.out.println("START createUI:"+filename); |
| |
| // create the message panel first so we can send messages to it... |
| messageText = new JTextArea(3,40); |
| messageText.setFont(new Font("dialog", Font.PLAIN, 12)); |
| JPanel messagePanel = new JPanel(new BorderLayout()); |
| messagePanel.add(new JScrollPane(messageText) { |
| public Dimension getPreferredSize(){ |
| Dimension size = TreeView.this.getSize(); |
| return new Dimension(size.width, size.height / 4); |
| } |
| public Dimension getMinimumSize(){ |
| return new Dimension(100, 100); |
| } |
| }, |
| BorderLayout.CENTER); |
| messagePanel.setBorder(BorderFactory.createCompoundBorder( |
| BorderFactory.createTitledBorder("Messages"), |
| BorderFactory.createEmptyBorder(4, 4, 4, 4) |
| )); |
| |
| // create the TextArea for XML source |
| sourceText = new JTextArea(); |
| sourceText.setFont(new Font("monospaced", Font.PLAIN, 12)); |
| sourceText.setBackground(Color.white); |
| sourceText.setForeground(Color.black); |
| sourceText.setSelectedTextColor(Color.black); |
| sourceText.setSelectionColor(Color.red); |
| sourceText.setEditable(false); |
| JPanel sourcePanel = new JPanel(new BorderLayout()); |
| sourcePanel.add(new JScrollPane(sourceText){ |
| public Dimension getPreferredSize(){ |
| Dimension size = TreeView.this.getSize(); |
| return new Dimension(size.width / 2, size.height * 3 / 5); |
| } |
| public Dimension getMinimumSize(){ |
| return new Dimension(100, 100); |
| } |
| }, |
| BorderLayout.CENTER); |
| sourcePanel.setBorder(BorderFactory.createCompoundBorder( |
| BorderFactory.createTitledBorder("Source View"), |
| BorderFactory.createEmptyBorder(4, 4, 4, 4) |
| )); |
| |
| // create the JTree and scroll pane. |
| JPanel treePanel = new JPanel(new BorderLayout()); |
| m_tree = new DOMTree(); |
| m_tree.setCellRenderer(new XMLTreeCellRenderer()); |
| m_tree.getSelectionModel().setSelectionMode |
| (TreeSelectionModel.SINGLE_TREE_SELECTION); |
| |
| // Listen for when the selection changes, call nodeSelected(node) |
| m_tree.addTreeSelectionListener( |
| new TreeSelectionListener() { |
| public void valueChanged(TreeSelectionEvent e) { |
| TreeNode node = (TreeNode) |
| (e.getPath().getLastPathComponent()); |
| |
| nodeSelected(node); |
| } |
| } |
| ); |
| m_tree.setRowHeight(18); |
| m_tree.setFont(new Font("dialog", Font.PLAIN, 12)); |
| |
| treePanel.add(new JScrollPane(m_tree) { |
| public Dimension getPreferredSize(){ |
| Dimension size = TreeView.this.getSize(); |
| return new Dimension(size.width / 2, size.height * 3 / 5); |
| } |
| public Dimension getMinimumSize(){ |
| return new Dimension(100, 100); |
| } |
| }, |
| BorderLayout.CENTER); |
| |
| treePanel.setBorder(BorderFactory.createCompoundBorder( |
| BorderFactory.createTitledBorder("Tree View"), |
| BorderFactory.createEmptyBorder(4, 4, 4, 4) |
| )); |
| |
| // refreshUI loads everthything! |
| refreshUI(filename); |
| |
| // use the new JSplitPane to dynamically resize... |
| JComponent split = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, |
| true, treePanel, sourcePanel); |
| |
| JComponent mainSplitPane = |
| new JSplitPane(JSplitPane.VERTICAL_SPLIT, |
| true, split, messagePanel); |
| |
| if (DEBUG) System.out.println("END createUI:"+filename); |
| return mainSplitPane; |
| } |
| |
| /** refreshUI is called when we have a new filename to parse. |
| */ |
| void refreshUI(String filename) { |
| if (DEBUG) System.out.println("START refreshUI:"+filename); |
| |
| messageText.selectAll(); |
| messageText.cut(); |
| |
| if (filename == null || filename.equals("")) { |
| messageText.setForeground(Color.red); |
| messageText.append("No input XML filename specified:"+filename+"\n"); |
| return; |
| } |
| |
| fname = filename; |
| Document newRoot = getRoot(filename); |
| if (newRoot == null) { |
| messageText.setForeground(Color.red); |
| messageText.append("Unable to get new DOM Tree for:"+filename+"\n"); |
| return; |
| } |
| m_tree.setDocument(newRoot); |
| |
| // new Source |
| sourceText.selectAll(); |
| sourceText.cut(); |
| readXMLFile(fname, sourceText); |
| |
| setTitle(title+": "+filename); |
| |
| if (m_tree!= null) |
| expandTree(); |
| |
| |
| if (ef != null && ef.getErrorNodes()!=null |
| && ef.getErrorNodes().size() > 0 ) { |
| messageText.setForeground(Color.red); |
| messageText.append("XML source, "+fname+" has errors.\n"); |
| messageText.append("Please click on red Tree View items for details.\n"); |
| /***/ |
| Hashtable errors = ef.getErrorNodes(); |
| Enumeration keys = errors.keys(); |
| while (keys.hasMoreElements()) { |
| Node node = (Node)keys.nextElement(); |
| messageText.append("node="+node.getNodeName() |
| +", error="+((ParseError)errors.get(node)).getMsg()+"\n"); |
| } |
| } |
| if (DEBUG) System.out.println("END refreshUI:"+filename); |
| } |
| |
| /** |
| * Invoke the Parser on fname and return the root TreeNode. |
| */ |
| public Document getRoot(String filename) { |
| if (DEBUG) System.out.println("START getRoot:"+filename); |
| |
| if (filename == null || filename.equals("")) |
| return null; |
| |
| try { |
| // |
| // Reset the Error Storage and handling |
| // |
| |
| ef.resetErrors(); |
| parser.setErrorHandler(ef); |
| parser.setFeature("http://apache.org/xml/features/dom/defer-node-expansion", false); // otherwise parser.getCurrentNode() == null |
| parser.setFeature("http://apache.org/xml/features/continue-after-fatal-error", true); |
| parser.setFeature("http://apache.org/xml/features/allow-java-encodings", true); |
| parser.parse(filename); |
| Document document = parser.getDocument(); |
| /***/ |
| return document; |
| } catch (Exception e) { |
| System.err.println( "Error: Invalid XML document could not get ROOT" ); |
| System.exit( 1 ); |
| //e.printStackTrace(System.err); |
| } |
| return null; |
| } |
| |
| /** read the xml file from filename and append it to the JTextArea |
| */ |
| synchronized void readXMLFile(String filename, JTextArea ta) { |
| |
| if (DEBUG) System.out.println("START readXMLFile"+filename); |
| if (filename == null || filename.equals("")) |
| return; |
| InputStream fis = null; |
| BufferedReader dis = null; |
| try { |
| java.net.URL file = createURL(filename); |
| fis = file.openStream(); |
| |
| String javaEncoding = parser.getJavaEncoding(); // get saved java encoding |
| try |
| { |
| dis = new BufferedReader(new InputStreamReader(fis, javaEncoding )); |
| } |
| catch( UnsupportedEncodingException ex ) |
| { |
| dis = new BufferedReader(new InputStreamReader(fis )); |
| } |
| } catch (Exception ex) { |
| System.err.println("ERROR: Xerces.readXMLFile: "+ex); |
| return; |
| } |
| |
| String line; |
| int i = 0; |
| |
| int len = 0; |
| textLine = new Vector(); |
| String nl = "\n"; |
| int nllen = nl.length(); |
| StringBuffer sb = new StringBuffer(); |
| |
| try{ |
| readline: while ((line = dis.readLine()) != null) { |
| sb.append(line+nl); |
| textLine.addElement(new Integer(len)); |
| len += line.length()+nllen; |
| } |
| ta.append(sb.toString()); |
| } catch (IOException io) { |
| System.err.println(io); |
| return; |
| } |
| |
| // relayout because contents have changed |
| //ta.revalidate(); |
| |
| if (DEBUG) System.out.println("END readXMLFile"+filename); |
| return; |
| |
| } |
| |
| /** called when our JTree's nodes are selected. |
| */ |
| void nodeSelected(TreeNode treeNode) { |
| |
| Node node = m_tree.getNode(treeNode); |
| |
| if( node == null ) // It is possible to get a null node |
| return; |
| |
| StringBuffer sb = new StringBuffer(); |
| messageText.selectAll(); |
| messageText.cut(); |
| |
| |
| //fix |
| |
| //JTextArea sourceText = sourceText; |
| Object errorObject = ef == null ? null : ef.getError(node); |
| if (errorObject != null) { |
| // There *is* an error in this node. |
| messageText.setForeground(Color.red); |
| ParseError eip = (ParseError)errorObject; |
| sb.append("Error: "+eip.getMsg()+"\n"); |
| int lineNo = eip.getLineNo(); |
| int pos = 0; |
| int next = 0; |
| int sizeOfTextLine = textLine.size(); |
| |
| if( lineNo < sizeOfTextLine ) |
| { |
| pos = ((Integer)textLine.elementAt(lineNo-1)).intValue(); |
| next = (lineNo == sizeOfTextLine ) ? |
| pos : |
| (((Integer)textLine.elementAt(lineNo)).intValue()); |
| } |
| else |
| { |
| pos = (( Integer) textLine.elementAt( sizeOfTextLine - 1 )).intValue(); |
| next = pos + 2; |
| } |
| |
| sourceText.select(pos, next ); |
| //m_textScrollPane.repaint(); |
| } else { |
| messageText.setForeground(Color.black); |
| sourceText.select(0, 0 ); |
| } |
| |
| //fix |
| |
| |
| if (node.getNodeType() == Node.ELEMENT_NODE |
| || node.getNodeType() == Node.TEXT_NODE |
| || node.getNodeType() == Node.CDATA_SECTION_NODE ) |
| { |
| sb.append(node.toString()); |
| } |
| |
| messageText.append(sb.toString()); |
| } |
| |
| /** called when a the text value has changed in the FileNameInput. |
| * read in new XML file. |
| */ |
| public void textValueChanged(TextEvent e) { |
| try { |
| if (fni != null) |
| fni.setVisible(false); |
| fname = ((JTextField)e.getSource()).getText(); |
| if (DEBUG) System.out.println("textValueChanged:"+fname); |
| refreshUI(fname); |
| |
| } catch (Exception ex) { |
| System.err.println( "Error: while trying to refresh gui" ); |
| System.exit( 1 ); |
| // ex.printStackTrace(); |
| } |
| } |
| |
| /** called to handle menu actions. |
| */ |
| public void actionPerformed(java.awt.event.ActionEvent e) { |
| if (DEBUG) System.err.println("ACTION: "+e.getActionCommand()+", "+e.paramString()); |
| |
| if (e.getActionCommand().equals(quitString)) { |
| System.exit(0); |
| } |
| else if (e.getActionCommand().equals(openString)) { |
| |
| fni = new FileNameInput("Open File"); |
| fni.addTextListener(this); |
| fni.setVisible(true); |
| } |
| else if (e.getActionCommand().equals(expandString)) { |
| expandTree(); |
| } |
| else if (e.getActionCommand().equals(collapseString)) { |
| int rows = m_tree.getRowCount(); |
| for (int i = 0; i < rows; i++) { |
| m_tree.collapseRow(i); |
| } |
| } |
| else |
| //if (e.getActionCommand().equals(reloadString)) { |
| refreshUI(fname); |
| //} |
| } |
| |
| void expandTree() { |
| int rows = 0; |
| for (int levels=0; levels <= 4; levels++) { |
| rows=m_tree.getRowCount(); |
| for (int i = 0; i < rows; i++) { |
| m_tree.expandRow(i); |
| } |
| } |
| } |
| |
| /* |
| * The XMLTreeCellRenderer is an inner class which enables the |
| * highlighting of errors in the tree and shows the gender values |
| * as different icons. |
| */ |
| class XMLTreeCellRenderer extends DefaultTreeCellRenderer |
| { |
| |
| public Component getTreeCellRendererComponent(JTree tree, Object value, |
| boolean selected, boolean expanded, |
| boolean leaf, int row, |
| boolean hasFocus) |
| { |
| Node node = ((DOMTree)tree).getNode(value); |
| Component comp = super.getTreeCellRendererComponent(tree, value, |
| selected, expanded, leaf, row, hasFocus); |
| if (selected) { |
| comp.setBackground(Color.blue); |
| } |
| if (ef != null |
| && ef.getErrorNodes() != null |
| && value != null |
| && node != null |
| && ef.getErrorNodes().containsKey( node )) { |
| comp.setForeground(Color.red); |
| } |
| |
| if (node != null) { |
| if (leaf) { |
| setIcon(new ImageIcon(leafImage)); |
| } else if (expanded) { |
| setIcon(new ImageIcon(openFolder)); |
| } else { |
| setIcon(new ImageIcon(closedFolder)); |
| } |
| } |
| if (node != null && node instanceof Element) { |
| |
| Element txNode = (Element)node; |
| Attr txAtt = (Attr)txNode.getAttributeNode("gender"); |
| if (txAtt != null) { |
| if (txAtt.getValue().equals("male")) { |
| setIcon(new ImageIcon("male.gif")); |
| } else |
| if (txAtt.getValue().equals("female")) { |
| setIcon(new ImageIcon("female.gif")); |
| } |
| } |
| } |
| |
| return comp; |
| } |
| } |
| |
| /* |
| * The FileNameInput is an inner class which allows the user |
| * to enter a filename. It exists due to a Swing bug which |
| * has problems with the real file input panel. |
| */ |
| class FileNameInput extends JFrame implements ActionListener { |
| |
| |
| JLabel fileLabel; |
| JTextField textField; |
| JButton ok; |
| JButton cancel; |
| Vector textListeners; |
| |
| public FileNameInput() { |
| this(""); |
| } |
| |
| public FileNameInput(String title) { |
| |
| super(title); |
| |
| fileLabel = new JLabel("Enter XML file name:"); |
| textField = new JTextField(); |
| textField.addActionListener(this); |
| ok = new JButton("ok"); |
| cancel = new JButton("cancel"); |
| JPanel buttonPanel = new JPanel(); |
| buttonPanel.add(ok); |
| buttonPanel.add(cancel); |
| ok.addActionListener(this); |
| cancel.addActionListener(this); |
| getContentPane().add(fileLabel, BorderLayout.NORTH); |
| getContentPane().add(textField, BorderLayout.CENTER); |
| getContentPane().add(buttonPanel, BorderLayout.SOUTH); |
| setSize(400,100); |
| } |
| |
| public void actionPerformed(ActionEvent e) { |
| |
| if (e.getSource() == ok || e.getSource() == textField) { |
| System.out.println("FileNameInput: pressed OK"); |
| TextEvent event = new TextEvent(textField, TextEvent.TEXT_VALUE_CHANGED); |
| deliverEvent(event); |
| setVisible(false); |
| } else |
| if (e.getSource() == cancel) { |
| System.out.println("FileNameInput: pressed cancel"); |
| setVisible(false); |
| } |
| } |
| |
| /** |
| * Adds a TextListener event listener. |
| * |
| * @param listener The listener to add. |
| * |
| * @see #removeTextListener |
| */ |
| public void addTextListener(TextListener listener) { |
| |
| // is there anything to do? |
| if (listener == null) |
| return; |
| |
| if (textListeners == null) |
| textListeners = new Vector(); |
| |
| // add listener |
| textListeners.addElement(listener); |
| } |
| |
| /** |
| * Removes a TextListener event listener. |
| * |
| * @param listener The listener to remove. |
| * |
| * @see #addTextListener |
| */ |
| public void removeTextListener(TextListener listener) { |
| |
| // is there anything to do? |
| if (listener == null || textListeners == null) |
| return; |
| |
| // add listener |
| textListeners.removeElement(listener); |
| } |
| |
| |
| /** |
| * This function delivers TextListener events, when the ok |
| * button is clicked. |
| * |
| * @param evt The event to deliver. |
| */ |
| protected void deliverEvent(EventObject evt) { |
| |
| if (evt instanceof TextEvent) { |
| TextEvent event = (TextEvent)evt; |
| |
| Vector l; |
| synchronized (textListeners) { l = (Vector)textListeners.clone(); } |
| |
| int size = l.size(); |
| for (int i = 0; i < size; i++) |
| ((TextListener)l.elementAt(i)).textValueChanged(event); |
| } |
| } |
| } |
| |
| // |
| // Create a URL object from either a URL string or a plain file name. |
| // |
| static URL createURL(String name) throws Exception { |
| try { |
| URL u = new URL(name); |
| return u; |
| } catch (MalformedURLException ex) { |
| } |
| URL u = new URL("file:" + new File(name).getAbsolutePath()); |
| return u; |
| } |
| |
| /** |
| * The ErrorStorer maps Nodes to errors. It receives a reference |
| * to the ErrorTreeFactory in the Constructor. |
| * |
| * When error is called, it asks the |
| * ErrorTreeFactory for the current node, and uses this as the |
| * "key" of a Hashtable, with the error as a value. The error |
| * value is wrapped up nicely in an ParseError object. |
| * |
| * It is used in the XML Tutorial to illustrate how to implement |
| * the ErrorListener to provide error storage for later reference. |
| * |
| */ |
| class ErrorStorer |
| implements ErrorHandler |
| |
| { |
| |
| // |
| // Data |
| // |
| Hashtable errorNodes = null; |
| |
| /** |
| * Constructor |
| */ |
| public ErrorStorer() { |
| } |
| |
| /** |
| * The client is is allowed to get a reference to the Hashtable, |
| * and so could corrupt it, or add to it... |
| */ |
| public Hashtable getErrorNodes() { |
| return errorNodes; |
| } |
| |
| /** |
| * The ParseError object for the node key is returned. |
| * If the node doesn't have errors, null is returned. |
| */ |
| public Object getError(Node node) { |
| if (errorNodes == null) |
| return null; |
| return errorNodes.get(node); |
| } |
| |
| /** |
| * Reset the error storage. |
| */ |
| public void resetErrors() { |
| if (errorNodes != null) |
| errorNodes.clear(); |
| } |
| |
| /***/ |
| public void warning(SAXParseException ex) { |
| handleError(ex, WARNING); |
| } |
| |
| public void error(SAXParseException ex) { |
| handleError(ex, ERROR); |
| } |
| |
| public void fatalError(SAXParseException ex) throws SAXException { |
| handleError(ex, FATAL_ERROR); |
| } |
| |
| private void handleError(SAXParseException ex, int type) { |
| System.out.println("!!! handleError: "+ex.getMessage()); |
| |
| StringBuffer errorString = new StringBuffer(); |
| errorString.append("at line number, "); |
| errorString.append(ex.getLineNumber()); |
| errorString.append(": "); |
| errorString.append(ex.getMessage()); |
| |
| // Node current = parser.getCurrentNode(); |
| |
| Node current = null ; |
| |
| try |
| { |
| current = ( Node ) parser.getProperty( "http://apache.org/xml/properties/dom/current-element-node" ); |
| |
| } |
| catch( SAXException exception ) |
| { |
| ; |
| } |
| |
| if (current == null) { |
| System.err.println("Error in handleError. getCurrentNode()==null!"); |
| return; |
| } |
| |
| if (errorNodes == null) |
| errorNodes = new Hashtable(); |
| ParseError previous = (ParseError) errorNodes.get(current); |
| ParseError eip = null; |
| // if a Node already has an error, we accumulate the text here... |
| if (previous != null) { |
| eip = previous; |
| errorString = new StringBuffer(previous.getMsg()+"\n"+errorString.toString()); |
| eip.setMsg(errorString.toString()); |
| } else { |
| eip = new |
| ParseError( |
| ex.getSystemId(), |
| ex.getLineNumber(), |
| ex.getColumnNumber(), |
| "", |
| errorString.toString()); |
| } |
| |
| // put it in the Hashtable. |
| errorNodes.put(current, eip); |
| } |
| |
| } |
| |
| /** |
| * The ParseError class wraps up all the error info from |
| * the ErrorStorer's error method. |
| * |
| * @see ErrorStorer |
| */ |
| class ParseError extends Object { |
| |
| // |
| // Data |
| // |
| |
| String fileName; |
| int lineNo; |
| int charOffset; |
| Object key; |
| String msg; |
| |
| /** |
| * Constructor |
| */ |
| public ParseError(String fileName, int lineNo, int charOffset, |
| Object key, |
| String msg) |
| { |
| this. fileName=fileName; |
| this. lineNo=lineNo; |
| this. charOffset=charOffset; |
| this. key=key; |
| this. msg=msg; |
| } |
| |
| // |
| // Getters... |
| // |
| public String getFileName() { return fileName; } |
| public int getLineNo() { return lineNo; } |
| public int getCharOffset() { return charOffset;} |
| public Object getKey() { return key; } |
| public String getMsg() { return msg; } |
| public void setMsg(String s) { msg = s; } |
| } |
| |
| |
| // |
| // Main |
| // |
| |
| /** Main program entry point. */ |
| public static void main(String argv[]) { |
| |
| // vars |
| int parserNameIndex = -1; |
| String parserName = DEFAULT_PARSER_NAME; |
| |
| // check parameters |
| for (int i = 0; i < argv.length; i++) { |
| String arg = argv[i]; |
| |
| // options |
| if (arg.startsWith("-")) { |
| if (arg.equals("-p")) { |
| if (i == argv.length - 1) { |
| System.err.println("error: missing parser class"); |
| System.exit(1); |
| } |
| parserName = argv[++i]; |
| parserNameIndex = i; |
| continue; |
| } |
| |
| if (arg.equals("-h")) { |
| printUsage(); |
| System.exit(1); |
| } |
| } |
| |
| // print uri |
| System.err.println(arg+':'); |
| |
| JFrame frame = null; |
| if (parserNameIndex == argv.length-1) { |
| // null behaviour is blank screen - eg no JTree, or file dispalyed |
| frame = new TreeView(""); |
| } else { |
| frame = new TreeView(arg); |
| } |
| frame.addWindowListener(new java.awt.event.WindowAdapter() { |
| public void windowClosing(java.awt.event.WindowEvent e) { |
| System.exit(0); |
| } |
| }); |
| frame.setSize(790, 590); |
| frame.setVisible(true); |
| } |
| } // main(String[]) |
| |
| /** Prints the usage. */ |
| private static void printUsage() { |
| |
| System.err.println("usage: java ui.TreeViewer (options) uri ..."); |
| System.err.println(); |
| System.err.println("options:"); |
| System.err.println(" -p name Specify DOM parser class by name."); |
| System.err.println(" Default parser: "+DEFAULT_PARSER_NAME); |
| System.err.println(" -h This help screen."); |
| |
| } // printUsage() |
| |
| } // class TreeViewer |
