Attachment #20518 for bug #42741

View | Details | Raw Unified | Return to bug 42741
Collapse All | Expand All

Lines 137-142 Link Here

(-)sources/org/apache/batik/dom/AbstractDocument.java (+24 lines)
137	protected transient WeakHashMap elementsByTagNamesNS;	137	protected transient WeakHashMap elementsByTagNamesNS;
138		138
139	/**	139	/**
		140	* The Imported Nodes lists.
		141	*/
		142	protected transient WeakHashMap importedNodes;
		143
		144	/**
140	* Input encoding of this document.	145	* Input encoding of this document.
141	*/	146	*/
142	protected String inputEncoding;	147	protected String inputEncoding;
Lines 414-419 Link Here
414	result.appendChild(importNode(n, true));	419	result.appendChild(importNode(n, true));
415	}	420	}
416	}	421	}
		422
		423	// Store in importedNodes hashmap so that the original
		424	// node is available
		425	putImportedNode(result, importedNode);
		426
417	return result;	427	return result;
418	}	428	}
419		429
Lines 675-680 Link Here
675	}	685	}
676	t.put(ns, ln, l);	686	t.put(ns, ln, l);
677	}	687	}
		688
		689	public Node getImportedNode(Node clone) {
		690	if (importedNodes == null) {
		691	return null;
		692	}
		693	return (Node)importedNodes.get(clone);
		694	}
		695
		696	public void putImportedNode(Node clone, Node importedNode) {
		697	if (importedNodes == null) {
		698	importedNodes = new WeakHashMap();
		699	}
		700	importedNodes.put(clone, importedNode);
		701	}
678		702
679	// DocumentEvent /////////////////////////////////////////////////////////	703	// DocumentEvent /////////////////////////////////////////////////////////
680		704

Lines 94-97 Link Here

(-)sources/org/apache/batik/dom/svg/SVGContext.java (+5 lines)
94	* Returns the font-size on the associated element.	94	* Returns the font-size on the associated element.
95	*/	95	*/
96	float getFontSize();	96	float getFontSize();
		97
		98	/**
		99	* Whether parsing should be strict (throw exception on error) or not
		100	*/
		101	boolean strictParsing = false;
97	}	102	}

Lines 18-27 Link Here

(-)sources/org/apache/batik/dom/util/DocumentDescriptor.java (-3 / +3 lines)
18	*/	18	*/
19	package org.apache.batik.dom.util;	19	package org.apache.batik.dom.util;
20		20
		21	import org.apache.batik.dom.AbstractDocument;
		22	import org.apache.batik.util.CleanerThread;
21	import org.w3c.dom.Element;	23	import org.w3c.dom.Element;
22		24
23	import org.apache.batik.util.CleanerThread;
24
25	/**	25	/**
26	* This class contains informations about a document.	26	* This class contains informations about a document.
27	*	27	*
Lines 87-93 Link Here
87	*/	87	*/
88	public int getLocationColumn(Element elt) {	88	public int getLocationColumn(Element elt) {
89	synchronized (this) {	89	synchronized (this) {
90	int hash = elt.hashCode() & 0x7FFFFFFF;	90	int hash = elt.hashCode() & 0x7FFFFFFF;
91	int index = hash % table.length;	91	int index = hash % table.length;
92		92
93	for (Entry e = table[index]; e != null; e = e.next) {	93	for (Entry e = table[index]; e != null; e = e.next) {




/*

 Licensed to the Apache Software Foundation (ASF) under one or more
 contributor license agreements.  See the NOTICE file distributed with
 this work for additional information regarding copyright ownership.
 The ASF licenses this file to You under the Apache License, Version 2.0
 (the "License"); you may not use this file except in compliance with
 the License.  You may obtain a copy of the License at

 http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.

 */
package org.apache.batik.dom.util;

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.apache.batik.dom.svg.SVGOMRectElement;
import org.apache.batik.util.HaltingThread;
import org.apache.batik.util.XMLConstants;


import org.w3c.dom.Node;

/**
 * This class contains methods for creating Document instances from an URI using
 * SAX2.
 * 
 * @author <a href="mailto:stephane@hillion.org">Stephane Hillion</a>
 * @version $Id$
 */
public class SAXDocumentFactory extends DefaultHandler implements
		LexicalHandler, DocumentFactory {
    implements LexicalHandler,
               DocumentFactory {

	/**
	 * The DOM implementation used to create the document.
	 */
	protected DOMImplementation implementation;

	/**
	 * The SAX2 parser classname.
	 */
	protected String parserClassName;

	/**
	 * The SAX2 parser object.
	 */
	protected XMLReader parser;

	/**
	 * The created document.
	 */
	protected Document document;

	/**
	 * The created document descriptor.
	 */
	protected DocumentDescriptor documentDescriptor;

	/**
	 * Whether a document descriptor must be generated.
	 */
	protected boolean createDocumentDescriptor;

	/**
	 * The current node.
	 */
	protected Node currentNode;

	/**
	 * The locator.
	 */
	protected Locator locator;

	/**
	 * Contains collected string data. May be Text, CDATA or Comment.
	 */
	protected StringBuffer stringBuffer = new StringBuffer();
    /**
     * Indicates if stringBuffer has content, needed in case of
     * zero sized "text" content.
     */
    protected boolean stringContent;

	/**
	 * Indicates if stringBuffer has content, needed in case of zero sized
	 * "text" content.
	 */
	protected boolean stringContent;

	/**
	 * True if the parser is currently parsing a DTD.
	 */
	protected boolean inDTD;

	/**
	 * True if the parser is currently parsing a CDATA section.
	 */
	protected boolean inCDATA;
    protected boolean inProlog;

	/**
	 * Whether the parser still hasn't read the document element's opening tag.
	 */
	protected boolean inProlog;

	/**
	 * Whether the parser is in validating mode.
	 */
	protected boolean isValidating;

	/**
	 * Whether the document just parsed was standalone.
	 */
	protected boolean isStandalone;

	/**
	 * XML version of the document just parsed.
	 */
	protected String xmlVersion;

	/**
	 * The stack used to store the namespace URIs.
	 */
	protected HashTableStack namespaces;

	/**
	 * The error handler.
	 */
	protected ErrorHandler errorHandler;

	protected interface PreInfo {
		Node createNode(Document doc);
	}
            this.target = target;
            this.data = data;
        }
        public Node createNode(Document doc) {
            return doc.createProcessingInstruction(target, data);
        }
    }

	static class ProcessingInstructionInfo implements PreInfo {
		public String target, data;
        public CommentInfo(String comment) {
            this.comment = comment;
        }
        public Node createNode(Document doc) {
            return doc.createComment(comment);
        }
    }

		public ProcessingInstructionInfo(String target, String data) {
			this.target = target;
			this.data = data;
		}
        }
        public Node createNode(Document doc) {
            return doc.createCDATASection(cdata);
        }
    }

		public Node createNode(Document doc) {
			return doc.createProcessingInstruction(target, data);
		}
	}
        }
        public Node createNode(Document doc) {
            return doc.createTextNode(text);
        }
    }

	static class CommentInfo implements PreInfo {
		public String comment;
     * List of PreInfo objects.
     */
    protected List preInfo;

		public CommentInfo(String comment) {
			this.comment = comment;
		}
     * @param impl The DOM implementation to use for building the DOM tree.
     * @param parser The SAX2 parser classname.
     */
    public SAXDocumentFactory(DOMImplementation impl,
                              String parser) {
        implementation           = impl;
        parserClassName          = parser;
    }

		public Node createNode(Document doc) {
			return doc.createComment(comment);
		}
	}
     * @param dd Whether a document descriptor must be generated.
     */
    public SAXDocumentFactory(DOMImplementation impl,
                              String parser,
                              boolean dd) {
        implementation           = impl;
        parserClassName          = parser;
        createDocumentDescriptor = dd;
    }

	static class CDataInfo implements PreInfo {
		public String cdata;
     * @param ns The namespace URI of the root element of the document.
     * @param root The name of the root element of the document.
     * @param uri The document URI.
     * @exception IOException if an error occured while reading the document.
     */
    public Document createDocument(String ns, String root, String uri)
        throws IOException {
        return createDocument(ns, root, uri, new InputSource(uri));
    }

		public CDataInfo(String cdata) {
			this.cdata = cdata;
		}
     * @exception IOException if an error occured while reading the document.
     */
    public Document createDocument(String uri)
        throws IOException {
        return createDocument(new InputSource(uri));
    }

		public Node createNode(Document doc) {
			return doc.createCDATASection(cdata);
		}
	}
     * @param uri The document URI.
     * @param is The document input stream.
     * @exception IOException if an error occured while reading the document.
     */
    public Document createDocument(String ns, String root, String uri,
                                   InputStream is) throws IOException {
        InputSource inp = new InputSource(is);
        inp.setSystemId(uri);
        return createDocument(ns, root, uri, inp);
    }

	static class TextInfo implements PreInfo {
		public String text;
     * @param uri The document URI.
     * @param is The document input stream.
     * @exception IOException if an error occured while reading the document.
     */
    public Document createDocument(String uri, InputStream is)
        throws IOException {
        InputSource inp = new InputSource(is);
        inp.setSystemId(uri);
        return createDocument(inp);
    }

		public TextInfo(String text) {
			this.text = text;
		}
     * @param root The name of the root element of the document.
     * @param uri The document URI.
     * @param r The document reader.
     * @exception IOException if an error occured while reading the document.
     */
    public Document createDocument(String ns, String root, String uri,
                                   Reader r) throws IOException {
        InputSource inp = new InputSource(r);
        inp.setSystemId(uri);
        return createDocument(ns, root, uri, inp);
    }

		public Node createNode(Document doc) {
			return doc.createTextNode(text);
		}
	}
     * @param uri The document URI.
     * @param r an XMLReaderInstance
     * @exception IOException if an error occured while reading the document.
     */
    public Document createDocument(String ns, String root, String uri,
                                   XMLReader r) throws IOException {
        r.setContentHandler(this);
        r.setDTDHandler(this);
        r.setEntityResolver(this);
        try {
            r.parse(uri);
        } catch (SAXException e) {
            Exception ex = e.getException();
            if (ex != null && ex instanceof InterruptedIOException) {
                throw (InterruptedIOException) ex;
            }
            throw new SAXIOException(e);
        }
        currentNode = null;
        Document ret = document;
        document = null;
        return ret;
    }

	/**
	 * Various elements encountered prior to real document root element. List of
	 * PreInfo objects.
	 */
	protected List preInfo;
     */
    public Document createDocument(String uri, Reader r) throws IOException {
        InputSource inp = new InputSource(r);
        inp.setSystemId(uri);
        return createDocument(inp);
    }

	/**
	 * Creates a new SAXDocumentFactory object. No document descriptor will be
	 * created while generating a document.
	 * 
	 * @param impl
	 *            The DOM implementation to use for building the DOM tree.
	 * @param parser
	 *            The SAX2 parser classname.
	 */
	public SAXDocumentFactory(DOMImplementation impl, String parser) {
		implementation = impl;
		parserClassName = parser;
	}

	/**
	 * Creates a new SAXDocumentFactory object.
	 * 
	 * @param impl
	 *            The DOM implementation to use for building the DOM tree.
	 * @param parser
	 *            The SAX2 parser classname.
	 * @param dd
	 *            Whether a document descriptor must be generated.
	 */
	public SAXDocumentFactory(DOMImplementation impl, String parser, boolean dd) {
		implementation = impl;
		parserClassName = parser;
		createDocumentDescriptor = dd;
	}

	/**
	 * Creates a Document instance.
	 * 
	 * @param ns
	 *            The namespace URI of the root element of the document.
	 * @param root
	 *            The name of the root element of the document.
	 * @param uri
	 *            The document URI.
	 * @exception IOException
	 *                if an error occured while reading the document.
	 */
	public Document createDocument(String ns, String root, String uri)
			throws IOException {
		return createDocument(ns, root, uri, new InputSource(uri));
	}

	/**
	 * Creates a Document instance.
	 * 
	 * @param uri
	 *            The document URI.
	 * @exception IOException
	 *                if an error occured while reading the document.
	 */
	public Document createDocument(String uri) throws IOException {
		return createDocument(new InputSource(uri));
	}

	/**
	 * Creates a Document instance.
	 * 
	 * @param ns
	 *            The namespace URI of the root element of the document.
	 * @param root
	 *            The name of the root element of the document.
	 * @param uri
	 *            The document URI.
	 * @param is
	 *            The document input stream.
	 * @exception IOException
	 *                if an error occured while reading the document.
	 */
	public Document createDocument(String ns, String root, String uri,
			InputStream is) throws IOException {
		InputSource inp = new InputSource(is);
		inp.setSystemId(uri);
		return createDocument(ns, root, uri, inp);
	}

	/**
	 * Creates a Document instance.
	 * 
	 * @param uri
	 *            The document URI.
	 * @param is
	 *            The document input stream.
	 * @exception IOException
	 *                if an error occured while reading the document.
	 */
	public Document createDocument(String uri, InputStream is)
			throws IOException {
		InputSource inp = new InputSource(is);
		inp.setSystemId(uri);
		return createDocument(inp);
	}

	/**
	 * Creates a Document instance.
	 * 
	 * @param ns
	 *            The namespace URI of the root element of the document.
	 * @param root
	 *            The name of the root element of the document.
	 * @param uri
	 *            The document URI.
	 * @param r
	 *            The document reader.
	 * @exception IOException
	 *                if an error occured while reading the document.
	 */
	public Document createDocument(String ns, String root, String uri, Reader r)
			throws IOException {
		InputSource inp = new InputSource(r);
		inp.setSystemId(uri);
		return createDocument(ns, root, uri, inp);
	}

	/**
	 * Creates a Document instance.
	 * 
	 * @param ns
	 *            The namespace URI of the root element of the document.
	 * @param root
	 *            The name of the root element of the document.
	 * @param uri
	 *            The document URI.
	 * @param r
	 *            an XMLReaderInstance
	 * @exception IOException
	 *                if an error occured while reading the document.
	 */
	public Document createDocument(String ns, String root, String uri,
			XMLReader r) throws IOException {
		r.setContentHandler(this);
		r.setDTDHandler(this);
		r.setEntityResolver(this);
		try {
			r.parse(uri);
		} catch (SAXException e) {
			Exception ex = e.getException();
			if (ex != null && ex instanceof InterruptedIOException) {
				throw (InterruptedIOException) ex;
			}
			throw new SAXIOException(e);
		}
		currentNode = null;
		Document ret = document;
		document = null;
		return ret;
	}

	/**
	 * Creates a Document instance.
	 * 
	 * @param uri
	 *            The document URI.
	 * @param r
	 *            The document reader.
	 * @exception IOException
	 *                if an error occured while reading the document.
	 */
	public Document createDocument(String uri, Reader r) throws IOException {
		InputSource inp = new InputSource(r);
		inp.setSystemId(uri);
		return createDocument(inp);
	}

	/**
	 * Creates a Document.
	 * 
	 * @param ns
	 *            The namespace URI of the root element.
	 * @param root
	 *            The name of the root element.
	 * @param uri
	 *            The document URI.
	 * @param is
	 *            The document input source.
	 * @exception IOException
	 *                if an error occured while reading the document.
	 */
	protected Document createDocument(String ns, String root, String uri,
			InputSource is) throws IOException {
		Document ret = createDocument(is);
		Element docElem = ret.getDocumentElement();

		String lname = root;
		String nsURI = ns;
		if (ns == null) {
			int idx = lname.indexOf(':');
			String nsp = (idx == -1 || idx == lname.length() - 1) ? "" : lname
					.substring(0, idx);
			nsURI = namespaces.get(nsp);
			if (idx != -1 && idx != lname.length() - 1) {
				lname = lname.substring(idx + 1);
			}
		}

		String docElemNS = docElem.getNamespaceURI();
		if ((docElemNS != nsURI)
				&& ((docElemNS == null) || (!docElemNS.equals(nsURI))))
			throw new IOException(
					"Root element namespace does not match that requested:\n"
							+ "Requested: " + nsURI + "\n" + "Found: "
							+ docElemNS);
    }

		if (docElemNS != null) {
			if (!docElem.getLocalName().equals(lname))
				throw new IOException(
						"Root element does not match that requested:\n"
								+ "Requested: " + lname + "\n" + "Found: "
								+ docElem.getLocalName());
		} else {
			if (!docElem.getNodeName().equals(lname))
				throw new IOException(
						"Root element does not match that requested:\n"
								+ "Requested: " + lname + "\n" + "Found: "
								+ docElem.getNodeName());
		}

		return ret;
	}
     * depending on the specified parameter.
     *
     * @param isValidating indicates that the XML parser will validate the XML
     * document
     */
    public void setValidating(boolean isValidating) {
        this.isValidating = isValidating;
    }

	static SAXParserFactory saxFactory;
	static {
		saxFactory = SAXParserFactory.newInstance();
	}
    public boolean isValidating() {
        return isValidating;
    }

	/**
	 * Creates a Document.
	 * 
	 * @param is
	 *            The document input source.
	 * @exception IOException
	 *                if an error occured while reading the document.
	 */
	protected Document createDocument(InputSource is) throws IOException {
		try {
			if (parserClassName != null) {
				parser = XMLReaderFactory.createXMLReader(parserClassName);
			} else {
				SAXParser saxParser;
				try {
					saxParser = saxFactory.newSAXParser();
				} catch (ParserConfigurationException pce) {
					throw new IOException("Could not create SAXParser: "
							+ pce.getMessage());
				}
				parser = saxParser.getXMLReader();
			}

			parser.setContentHandler(this);
			parser.setDTDHandler(this);
			parser.setEntityResolver(this);
			parser
					.setErrorHandler((errorHandler == null) ? this
							: errorHandler);

			parser.setFeature("http://xml.org/sax/features/namespaces", true);
			parser.setFeature("http://xml.org/sax/features/namespace-prefixes",
					true);
			parser.setFeature("http://xml.org/sax/features/validation",
					isValidating);
			parser.setProperty("http://xml.org/sax/properties/lexical-handler",
					this);
			parser.parse(is);
		} catch (SAXException e) {
			Exception ex = e.getException();
			if (ex != null && ex instanceof InterruptedIOException) {
				throw (InterruptedIOException) ex;
			}
			throw new SAXIOException(e);
		}

		currentNode = null;
		Document ret = document;
		document = null;
		locator = null;
		parser = null;
		return ret;
	}

	/**
	 * Returns the document descriptor associated with the latest created
	 * document.
	 * 
	 * @return null if no document or descriptor was previously generated.
	 */
	public DocumentDescriptor getDocumentDescriptor() {
		return documentDescriptor;
	}

	/**
	 * <b>SAX</b>: Implements {@link
	 * org.xml.sax.ContentHandler#setDocumentLocator(Locator)}.
	 */
	public void setDocumentLocator(Locator l) {
		locator = l;
	}
        namespaces.put("xml", XMLSupport.XML_NAMESPACE_URI);
        namespaces.put("xmlns", XMLSupport.XMLNS_NAMESPACE_URI);
        namespaces.put("", null);

	/**
	 * Sets whether or not the XML parser will validate the XML document
	 * depending on the specified parameter.
	 * 
	 * @param isValidating
	 *            indicates that the XML parser will validate the XML document
	 */
	public void setValidating(boolean isValidating) {
		this.isValidating = isValidating;
	}

	/**
	 * Returns true if the XML parser validates the XML stream, false otherwise.
	 */
	public boolean isValidating() {
		return isValidating;
	}

	/**
	 * Sets a custom error handler.
	 */
	public void setErrorHandler(ErrorHandler eh) {
		errorHandler = eh;
	}

	public DOMImplementation getDOMImplementation(String ver) {
		return implementation;
	}
     */
    public void startElement(String     uri,
                             String     localName,
                             String     rawName,
                             Attributes attributes) throws SAXException {
        // Check If we should halt early.
        if (HaltingThread.hasBeenHalted()) {
            throw new SAXException(new InterruptedIOException());
        }

	/**
	 * <b>SAX</b>: Implements {@link
	 * org.xml.sax.ErrorHandler#fatalError(SAXParseException)}.
	 */
	public void fatalError(SAXParseException ex) throws SAXException {
		throw ex;
	}
            try {
                xmlVersion = (String) parser.getProperty
                    ("http://xml.org/sax/properties/document-xml-version");
            } catch (SAXNotRecognizedException ex) {
            }
        }

	/**
	 * <b>SAX</b>: Implements {@link
	 * org.xml.sax.ErrorHandler#error(SAXParseException)}.
	 */
	public void error(SAXParseException ex) throws SAXException {
		throw ex;
	}
            if (slen < 5)
                continue;
            if (aname.equals("version")) {
                version = attributes.getValue(i);
                continue;
            }
            if (!aname.startsWith("xmlns"))
                continue;
            if (slen == 5) {
                String ns = attributes.getValue(i);
                if (ns.length() == 0)
                    ns = null;
                namespaces.put("", ns);
            } else if (aname.charAt(5) == ':') {
                String ns = attributes.getValue(i);
                if (ns.length() == 0) {
                    ns = null;
                }
                namespaces.put(aname.substring(6), ns);
            }
        }

	/**
	 * <b>SAX</b>: Implements {@link
	 * org.xml.sax.ErrorHandler#warning(SAXParseException)}.
	 */
	public void warning(SAXParseException ex) throws SAXException {
	}

	/**
	 * <b>SAX</b>: Implements {@link
	 * org.xml.sax.ContentHandler#startDocument()}.
	 */
	public void startDocument() throws SAXException {
		preInfo = new LinkedList();
		namespaces = new HashTableStack();
		namespaces.put("xml", XMLSupport.XML_NAMESPACE_URI);
		namespaces.put("xmlns", XMLSupport.XMLNS_NAMESPACE_URI);
		namespaces.put("", null);
            Iterator i = preInfo.iterator();
            currentNode = e = document.getDocumentElement();
            while (i.hasNext()) {
                PreInfo pi = (PreInfo)i.next();
                Node n = pi.createNode(document);
                document.insertBefore(n, e);
            }
            preInfo = null;
        } else {
            e = document.createElementNS(nsURI, rawName);
            currentNode.appendChild(e);
            currentNode = e;
        }

		inDTD = false;
		inCDATA = false;
		inProlog = true;
		currentNode = null;
		document = null;
		isStandalone = false;
		xmlVersion = XMLConstants.XML_VERSION_10;

		stringBuffer = new StringBuffer();
		stringContent = false;
            String aname = attributes.getQName(i);
            if (aname.equals("xmlns")) {
                e.setAttributeNS(XMLSupport.XMLNS_NAMESPACE_URI,
                                 aname,
                                 attributes.getValue(i));
            } else {
                idx = aname.indexOf(':');
                nsURI = (idx == -1)
                    ? null
                    : namespaces.get(aname.substring(0, idx));
                e.setAttributeNS(nsURI, aname, attributes.getValue(i));
            }
        }
    }

		if (createDocumentDescriptor) {
			documentDescriptor = new DocumentDescriptor();
		} else {
			documentDescriptor = null;
		}
	}
        appendStringData(); // add string data if any.

	/**
	 * <b>SAX</b>: Implements {@link
	 * org.xml.sax.ContentHandler#startElement(String,String,String,Attributes)}.
	 */
	public void startElement(String uri, String localName, String rawName,
			Attributes attributes) throws SAXException {
		// Check If we should halt early.
		if (HaltingThread.hasBeenHalted()) {
			throw new SAXException(new InterruptedIOException());
		}

		if (inProlog) {
			inProlog = false;
			try {
				isStandalone = parser
						.getFeature("http://xml.org/sax/features/is-standalone");
			} catch (SAXNotRecognizedException ex) {
			}
			try {
				xmlVersion = (String) parser
						.getProperty("http://xml.org/sax/properties/document-xml-version");
			} catch (SAXNotRecognizedException ex) {
			}
		}

		// Namespaces resolution
		int len = attributes.getLength();
		namespaces.push();
		String version = null;
		for (int i = 0; i < len; i++) {
			String aname = attributes.getQName(i);
			int slen = aname.length();
			if (slen < 5)
				continue;
			if (aname.equals("version")) {
				version = attributes.getValue(i);
				continue;
			}
			if (!aname.startsWith("xmlns"))
				continue;
			if (slen == 5) {
				String ns = attributes.getValue(i);
				if (ns.length() == 0)
					ns = null;
				namespaces.put("", ns);
			} else if (aname.charAt(5) == ':') {
				String ns = attributes.getValue(i);
				if (ns.length() == 0) {
					ns = null;
				}
				namespaces.put(aname.substring(6), ns);
			}
		}

		// Add any collected String Data before element.
		appendStringData();
     * org.xml.sax.ContentHandler#characters(char[],int,int)}.
     */
    public void characters(char[] ch, int start, int length)
        throws SAXException {
        stringBuffer.append(ch, start, length);
        stringContent = true;
    }

		// Element creation
		Element e;
		int idx = rawName.indexOf(':');
		String nsp = (idx == -1 || idx == rawName.length() - 1) ? "" : rawName
				.substring(0, idx);
		String nsURI = namespaces.get(nsp);
		if (currentNode == null) {
			implementation = getDOMImplementation(version);
			document = implementation.createDocument(nsURI, rawName, null);
			Iterator i = preInfo.iterator();
			currentNode = e = document.getDocumentElement();
			while (i.hasNext()) {
				PreInfo pi = (PreInfo) i.next();
				Node n = pi.createNode(document);
				document.insertBefore(n, e);
			}
			preInfo = null;
		} else {
			e = document.createElementNS(nsURI, rawName);
			currentNode.appendChild(e);
			currentNode = e;
		}

		// Storage of the line number.
		if (createDocumentDescriptor && locator != null) {
			documentDescriptor.setLocation(e, locator.getLineNumber(), locator
					.getColumnNumber());
		}
                                    int start,
                                    int length)
        throws SAXException {
        stringBuffer.append(ch, start, length);
        stringContent = true;
    }

		// Attributes creation
		for (int i = 0; i < len; i++) {
			String aname = attributes.getQName(i);
			if (aname.equals("xmlns")) {
				e.setAttributeNS(XMLSupport.XMLNS_NAMESPACE_URI, aname,
						attributes.getValue(i));
			} else {
				idx = aname.indexOf(':');
				nsURI = (idx == -1) ? null : namespaces.get(aname.substring(0,
						idx));
				e.setAttributeNS(nsURI, aname, attributes.getValue(i));
			}
		}
	}

	/**
	 * <b>SAX</b>: Implements {@link
	 * org.xml.sax.ContentHandler#endElement(String,String,String)}.
	 */
	public void endElement(String uri, String localName, String rawName)
			throws SAXException {
		appendStringData(); // add string data if any.

		if (currentNode != null)
			currentNode = currentNode.getParentNode();
		namespaces.pop();
	}
                (document.createProcessingInstruction(target, data));
    }

	public void appendStringData() {
		if (!stringContent)
			return;

		String str = stringBuffer.toString();
		stringBuffer.setLength(0); // reuse buffer.
		stringContent = false;
		if (currentNode == null) {
			if (inCDATA)
				preInfo.add(new CDataInfo(str));
			else
				preInfo.add(new TextInfo(str));
		} else {
			Node n;
			if (inCDATA)
				n = document.createCDATASection(str);
			else
				n = document.createTextNode(str);
			currentNode.appendChild(n);
		}
	}

	/**
	 * <b>SAX</b>: Implements {@link
	 * org.xml.sax.ContentHandler#characters(char[],int,int)}.
	 */
	public void characters(char[] ch, int start, int length)
			throws SAXException {
		stringBuffer.append(ch, start, length);
		stringContent = true;
	}

	/**
	 * <b>SAX</b>: Implements {@link
	 * org.xml.sax.ContentHandler#ignorableWhitespace(char[],int,int)}.
	 */
	public void ignorableWhitespace(char[] ch, int start, int length)
			throws SAXException {
		stringBuffer.append(ch, start, length);
		stringContent = true;
	}

	/**
	 * <b>SAX</b>: Implements {@link
	 * org.xml.sax.ContentHandler#processingInstruction(String,String)}.
	 */
	public void processingInstruction(String target, String data)
			throws SAXException {
		if (inDTD)
			return;

		appendStringData(); // Add any collected String Data before PI
     * <b>SAX</b>: Implements {@link
     * org.xml.sax.ext.LexicalHandler#startCDATA()}.
     */
    public void startCDATA() throws SAXException {
        appendStringData(); // Add any collected String Data before CData
        inCDATA       = true;
        stringContent = true; // always create CDATA even if empty.
    }

		if (currentNode == null)
			preInfo.add(new ProcessingInstructionInfo(target, data));
		else
			currentNode.appendChild(document.createProcessingInstruction(
					target, data));
	}
        inCDATA = false;
    }

	// LexicalHandler /////////////////////////////////////////////////////////
     * <b>SAX</b>: Implements
     * {@link org.xml.sax.ext.LexicalHandler#comment(char[],int,int)}.
     */
    public void comment(char[] ch, int start, int length) throws SAXException {
        if (inDTD) return;
        appendStringData();

	/**
	 * <b>SAX</b>: Implements {@link
	 * org.xml.sax.ext.LexicalHandler#startDTD(String,String,String)}.
	 */
	public void startDTD(String name, String publicId, String systemId)
			throws SAXException {
		appendStringData(); // Add collected string data before entering DTD
		inDTD = true;
	}

	/**
	 * <b>SAX</b>: Implements {@link org.xml.sax.ext.LexicalHandler#endDTD()}.
	 */
	public void endDTD() throws SAXException {
		inDTD = false;
	}

	/**
	 * <b>SAX</b>: Implements
	 * {@link org.xml.sax.ext.LexicalHandler#startEntity(String)}.
	 */
	public void startEntity(String name) throws SAXException {
	}

	/**
	 * <b>SAX</b>: Implements
	 * {@link org.xml.sax.ext.LexicalHandler#endEntity(String)}.
	 */
	public void endEntity(String name) throws SAXException {
	}

	/**
	 * <b>SAX</b>: Implements {@link
	 * org.xml.sax.ext.LexicalHandler#startCDATA()}.
	 */
	public void startCDATA() throws SAXException {
		appendStringData(); // Add any collected String Data before CData
		inCDATA = true;
		stringContent = true; // always create CDATA even if empty.
	}

	/**
	 * <b>SAX</b>: Implements {@link
	 * org.xml.sax.ext.LexicalHandler#endCDATA()}.
	 */
	public void endCDATA() throws SAXException {
		appendStringData(); // Add the CDATA section
		inCDATA = false;
	}

	/**
	 * <b>SAX</b>: Implements
	 * {@link org.xml.sax.ext.LexicalHandler#comment(char[],int,int)}.
	 */
	public void comment(char[] ch, int start, int length) throws SAXException {
		if (inDTD)
			return;
		appendStringData();

		String str = new String(ch, start, length);
		if (currentNode == null) {
			preInfo.add(new CommentInfo(str));
		} else {
			currentNode.appendChild(document.createComment(str));
		}
	}
}

Lines 22-28 Link Here

(-)sources/org/apache/batik/swing/svg/SVGUserAgentGUIAdapter.java (-4 / +10 lines)
22	import java.awt.Component;	22	import java.awt.Component;
23	import javax.swing.JDialog;	23	import javax.swing.JDialog;
24	import javax.swing.JOptionPane;	24	import javax.swing.JOptionPane;
		25
		26	import org.apache.batik.swing.JSVGCanvas;
		27	import org.apache.batik.util.gui.ErrorConsole;
25	import org.apache.batik.util.gui.JErrorPane;	28	import org.apache.batik.util.gui.JErrorPane;
		29	import org.apache.batik.util.gui.ErrorConsole.ErrorInfo;
26		30
27	/**	31	/**
28	* One line Class Desc	32	* One line Class Desc
Lines 53-62 Link Here
53	* Displays an error resulting from the specified Exception.	57	* Displays an error resulting from the specified Exception.
54	*/	58	*/
55	public void displayError(Exception ex) {	59	public void displayError(Exception ex) {
56	JErrorPane pane = new JErrorPane(ex, JOptionPane.ERROR_MESSAGE);	60	// JErrorPane pane = new JErrorPane(ex, JOptionPane.ERROR_MESSAGE);
57	JDialog dialog = pane.createDialog(parentComponent, "ERROR");	61	ErrorConsole console = ErrorConsole.getInstance();
58	dialog.setModal(false);	62	// <!FIX ME> Document is null for now, how to get access to it??
59	dialog.setVisible(true);	63	ErrorInfo info = new ErrorInfo(ex, "Not available", ErrorConsole.ERROR);
		64	console.add(info);
		65	ErrorConsole.showDialog(parentComponent);
60	}	66	}
61		67
62	/**	68	/**

Lines 73-79 Link Here

(-)sources/org/apache/batik/swing/svg/SVGDocumentLoader.java (-2 / +2 lines)
73	*/	73	*/
74	public void run() {	74	public void run() {
75	SVGDocumentLoaderEvent evt;	75	SVGDocumentLoaderEvent evt;
76	evt = new SVGDocumentLoaderEvent(this, null);	76	evt = new SVGDocumentLoaderEvent(this, null, null);
77	try {	77	try {
78	fireEvent(startedDispatcher, evt);	78	fireEvent(startedDispatcher, evt);
79	if (isHalted()) {	79	if (isHalted()) {
Lines 88-94 Link Here
88	return;	88	return;
89	}	89	}
90		90
91	evt = new SVGDocumentLoaderEvent(this, svgDocument);	91	evt = new SVGDocumentLoaderEvent(this, svgDocument, loader.getDocumentDescriptor(svgDocument));
92	fireEvent(completedDispatcher, evt);	92	fireEvent(completedDispatcher, evt);
93	} catch (InterruptedIOException e) {	93	} catch (InterruptedIOException e) {
94	fireEvent(cancelledDispatcher, evt);	94	fireEvent(cancelledDispatcher, evt);





import java.util.EventObject;

import org.apache.batik.dom.util.DocumentDescriptor;
import org.w3c.dom.svg.SVGDocument;

/**

    protected SVGDocument svgDocument;

    /**
     * The document descriptor describing the document
     */
    protected DocumentDescriptor docDescriptor;
    
    /**
     * Creates a new SVGDocumentLoaderEvent.
     * @param source the object that originated the event, ie. the
     *               SVGDocumentLoader.
     * @param doc The associated document.
     */
    public SVGDocumentLoaderEvent(Object source, SVGDocument doc, DocumentDescriptor desc) {
        super(source);
        svgDocument = doc;
        docDescriptor = desc;
    }

    /**

    public SVGDocument getSVGDocument() {
        return svgDocument;
    }
    
    /**
     * Returns the document descriptor for this document, or null
     * if the document wasn't completely loaded
     */
    public DocumentDescriptor getDocumentDescriptor() {
    	return docDescriptor;
    }
}




/*

 Licensed to the Apache Software Foundation (ASF) under one or more
 contributor license agreements.  See the NOTICE file distributed with
 this work for additional information regarding copyright ownership.
 The ASF licenses this file to You under the Apache License, Version 2.0
 (the "License"); you may not use this file except in compliance with
 the License.  You may obtain a copy of the License at

 http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.

 */
package org.apache.batik.swing;

import org.apache.batik.swing.svg.SVGUserAgent;
import org.apache.batik.util.SVGConstants;
import org.apache.batik.util.XMLConstants;
import org.apache.batik.util.gui.ErrorConsole;
import org.apache.batik.util.gui.ErrorConsole.ErrorInfo;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.events.Event;


/**
 * This class represents a general-purpose swing SVG component. The
 * <tt>JSVGCanvas</tt> does not provided additional functionalities compared
 * to the <tt>JSVGComponent</tt> but simply provides an API conformed to the
 * JavaBean specification. The only major change between the
 * <tt>JSVGComponent</tt> and this component is that interactors and text
 * selection are activated by default.
 * 
 * @author <a href="mailto:tkormann@apache.org">Thierry Kormann</a>
 * @author <a href="mailto:stephane@hillion.org">Stephane Hillion</a>
 * @version $Id$
 */
public class JSVGCanvas extends JSVGComponent {

	/**
	 * The key for the Action to scroll right.
	 */
	public static final String SCROLL_RIGHT_ACTION = "ScrollRight";

	/**
	 * The key for the Action to scroll left.
	 */
	public static final String SCROLL_LEFT_ACTION = "ScrollLeft";

	/**
	 * The key for the Action to scroll up.
	 */
	public static final String SCROLL_UP_ACTION = "ScrollUp";

	/**
	 * The key for the Action to scroll down.
	 */
	public static final String SCROLL_DOWN_ACTION = "ScrollDown";

	/**
	 * The key for the Action to quickly scroll right.
	 */
	public static final String FAST_SCROLL_RIGHT_ACTION = "FastScrollRight";

	/**
	 * The key for the Action to quickly scroll left.
	 */
	public static final String FAST_SCROLL_LEFT_ACTION = "FastScrollLeft";

	/**
	 * The key for the Action to quickly scroll up.
	 */
	public static final String FAST_SCROLL_UP_ACTION = "FastScrollUp";

	/**
	 * The key for the Action to quickly scroll down.
	 */
	public static final String FAST_SCROLL_DOWN_ACTION = "FastScrollDown";

	/**
	 * The key for the Action to zoom in.
	 */
	public static final String ZOOM_IN_ACTION = "ZoomIn";

	/**
	 * The key for the Action to zoom out.
	 */
	public static final String ZOOM_OUT_ACTION = "ZoomOut";

	/**
	 * The key for the Action to reset the transform.
	 */
	public static final String RESET_TRANSFORM_ACTION = "ResetTransform";

	/**
	 * This flag bit indicates whether or not the zoom interactor is enabled.
	 * True means the zoom interactor is functional.
	 */
	private boolean isZoomInteractorEnabled = true;

	/**
	 * This flag bit indicates whether or not the image zoom interactor is
	 * enabled. True means the image zoom interactor is functional.
	 */
	private boolean isImageZoomInteractorEnabled = true;

	/**
	 * This flag bit indicates whether or not the pan interactor is enabled.
	 * True means the pan interactor is functional.
	 */
	private boolean isPanInteractorEnabled = true;

	/**
	 * This flag bit indicates whether or not the rotate interactor is enabled.
	 * True means the rotate interactor is functional.
	 */
	private boolean isRotateInteractorEnabled = true;

	/**
	 * This flag bit indicates whether or not the reset transform interactor is
	 * enabled. True means the reset transform interactor is functional.
	 */
	private boolean isResetTransformInteractorEnabled = true;

	/**
	 * The <tt>PropertyChangeSupport</tt> used to fire
	 * <tt>PropertyChangeEvent</tt>.
	 */
	protected PropertyChangeSupport pcs = new PropertyChangeSupport(this);

	/**
	 * The URI of the current document being displayed.
	 */
	protected String uri;

	/**
	 * Keeps track of the last known mouse position over the canvas. This is
	 * used for displaying tooltips at the right location.
	 */
	protected LocationListener locationListener = new LocationListener();

	/**
	 * Mapping of elements to listeners so they can be removed, if the tooltip
	 * is removed.
	 */
	protected Map toolTipMap = null;
    protected EventListener toolTipListener = new ToolTipModifier();
    protected EventTarget   lastTarget = null;
    protected Map toolTipDocs = null;
    /**
     * This is used as the value in the toolTipDocs WeakHashMap.
     * This way we can tell if a document has already been added.
     */
    protected static final Object MAP_TOKEN = new Object();
    /**
     * The time of the last tool tip event.
     */
    protected long lastToolTipEventTimeStamp;

	protected EventListener toolTipListener = new ToolTipModifier();
     * The target for which the last tool tip event was fired.
     */
    protected EventTarget lastToolTipEventTarget;

	protected EventTarget lastTarget = null;

	protected Map toolTipDocs = null;

	/**
	 * This is used as the value in the toolTipDocs WeakHashMap. This way we can
	 * tell if a document has already been added.
	 */
	protected static final Object MAP_TOKEN = new Object();
        addMouseMotionListener(locationListener);
    }

	/**
	 * The time of the last tool tip event.
	 */
	protected long lastToolTipEventTimeStamp;
     * @param eventsEnabled Whether the GVT tree should be reactive to mouse
     *                      and key events.
     * @param selectableText Whether the text should be selectable.
     */
    public JSVGCanvas(SVGUserAgent ua,
                      boolean eventsEnabled,
                      boolean selectableText) {

	/**
	 * The target for which the last tool tip event was fired.
	 */
	protected EventTarget lastToolTipEventTarget;

	/**
	 * Creates a new JSVGCanvas.
	 */
	public JSVGCanvas() {
		this(null, true, true);
		addMouseMotionListener(locationListener);
	}

	/**
	 * Creates a new JSVGCanvas.
	 * 
	 * @param ua
	 *            a SVGUserAgent instance or null.
	 * @param eventsEnabled
	 *            Whether the GVT tree should be reactive to mouse and key
	 *            events.
	 * @param selectableText
	 *            Whether the text should be selectable.
	 */
	public JSVGCanvas(SVGUserAgent ua, boolean eventsEnabled,
			boolean selectableText) {

		super(ua, eventsEnabled, selectableText);

		setPreferredSize(new Dimension(200, 200));
		setMinimumSize(new Dimension(100, 100));
                public void mousePressed(MouseEvent evt) {
                    requestFocus();
                }
            });

		List intl = getInteractors();
		intl.add(zoomInteractor);
		intl.add(imageZoomInteractor);
		intl.add(panInteractor);
		intl.add(rotateInteractor);
		intl.add(resetTransformInteractor);

		installActions();
     * Builds the ActionMap of this canvas with a set of predefined
     * <tt>Action</tt>s.
     */
    protected void installActions() {
        ActionMap actionMap = getActionMap();

		if (eventsEnabled) {
			addMouseListener(new MouseAdapter() {
				public void mousePressed(MouseEvent evt) {
					requestFocus();
				}
			});

			installKeyboardActions();
		}
		addMouseMotionListener(locationListener);
	}

	/**
	 * Builds the ActionMap of this canvas with a set of predefined
	 * <tt>Action</tt>s.
	 */
	protected void installActions() {
		ActionMap actionMap = getActionMap();

		actionMap.put(SCROLL_RIGHT_ACTION, new ScrollRightAction(10));
		actionMap.put(SCROLL_LEFT_ACTION, new ScrollLeftAction(10));
		actionMap.put(SCROLL_UP_ACTION, new ScrollUpAction(10));
		actionMap.put(SCROLL_DOWN_ACTION, new ScrollDownAction(10));

		actionMap.put(FAST_SCROLL_RIGHT_ACTION, new ScrollRightAction(30));
		actionMap.put(FAST_SCROLL_LEFT_ACTION, new ScrollLeftAction(30));
		actionMap.put(FAST_SCROLL_UP_ACTION, new ScrollUpAction(30));
		actionMap.put(FAST_SCROLL_DOWN_ACTION, new ScrollDownAction(30));

		actionMap.put(ZOOM_IN_ACTION, new ZoomInAction());
		actionMap.put(ZOOM_OUT_ACTION, new ZoomOutAction());
        actionMap.get(SCROLL_UP_ACTION)        .setEnabled(!b);
        actionMap.get(SCROLL_DOWN_ACTION)      .setEnabled(!b);

		actionMap.put(RESET_TRANSFORM_ACTION, new ResetTransformAction());
	}
        actionMap.get(FAST_SCROLL_UP_ACTION)   .setEnabled(!b);
        actionMap.get(FAST_SCROLL_DOWN_ACTION) .setEnabled(!b);

	public void setDisableInteractions(boolean b) {
		super.setDisableInteractions(b);
		ActionMap actionMap = getActionMap();
    }

		actionMap.get(SCROLL_RIGHT_ACTION).setEnabled(!b);
		actionMap.get(SCROLL_LEFT_ACTION).setEnabled(!b);
		actionMap.get(SCROLL_UP_ACTION).setEnabled(!b);
		actionMap.get(SCROLL_DOWN_ACTION).setEnabled(!b);

		actionMap.get(FAST_SCROLL_RIGHT_ACTION).setEnabled(!b);
		actionMap.get(FAST_SCROLL_LEFT_ACTION).setEnabled(!b);
		actionMap.get(FAST_SCROLL_UP_ACTION).setEnabled(!b);
		actionMap.get(FAST_SCROLL_DOWN_ACTION).setEnabled(!b);
    protected void installKeyboardActions() {

		actionMap.get(ZOOM_IN_ACTION).setEnabled(!b);
		actionMap.get(ZOOM_OUT_ACTION).setEnabled(!b);
		actionMap.get(RESET_TRANSFORM_ACTION).setEnabled(!b);
	}

	/**
	 * Builds the InputMap of this canvas with a set of predefined
	 * <tt>Action</tt>s.
	 */
	protected void installKeyboardActions() {

		InputMap inputMap = getInputMap(JComponent.WHEN_FOCUSED);
		KeyStroke key;

		key = KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, 0);
		inputMap.put(key, SCROLL_RIGHT_ACTION);

		key = KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, 0);
		inputMap.put(key, SCROLL_LEFT_ACTION);

		key = KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0);
		inputMap.put(key, SCROLL_UP_ACTION);

		key = KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0);
		inputMap.put(key, SCROLL_DOWN_ACTION);

		key = KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, KeyEvent.SHIFT_MASK);
		inputMap.put(key, FAST_SCROLL_RIGHT_ACTION);

		key = KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, KeyEvent.SHIFT_MASK);
		inputMap.put(key, FAST_SCROLL_LEFT_ACTION);

		key = KeyStroke.getKeyStroke(KeyEvent.VK_UP, KeyEvent.SHIFT_MASK);
		inputMap.put(key, FAST_SCROLL_UP_ACTION);

		key = KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, KeyEvent.SHIFT_MASK);
		inputMap.put(key, FAST_SCROLL_DOWN_ACTION);

		key = KeyStroke.getKeyStroke(KeyEvent.VK_I, KeyEvent.CTRL_MASK);
		inputMap.put(key, ZOOM_IN_ACTION);
    }

		key = KeyStroke.getKeyStroke(KeyEvent.VK_O, KeyEvent.CTRL_MASK);
		inputMap.put(key, ZOOM_OUT_ACTION);
     *
     * @param pcl the property change listener to add
     */
    public void addPropertyChangeListener(PropertyChangeListener pcl) {
        pcs.addPropertyChangeListener(pcl);
    }

		key = KeyStroke.getKeyStroke(KeyEvent.VK_T, KeyEvent.CTRL_MASK);
		inputMap.put(key, RESET_TRANSFORM_ACTION);
	}
     * @param pcl the property change listener to remove
     */
    public void removePropertyChangeListener(PropertyChangeListener pcl) {
        pcs.removePropertyChangeListener(pcl);
    }

	/**
	 * Adds the specified <tt>PropertyChangeListener</tt>.
	 * 
	 * @param pcl
	 *            the property change listener to add
	 */
	public void addPropertyChangeListener(PropertyChangeListener pcl) {
		pcs.addPropertyChangeListener(pcl);
	}
        pcs.addPropertyChangeListener(propertyName, pcl);
    }

	/**
	 * Removes the specified <tt>PropertyChangeListener</tt>.
	 * 
	 * @param pcl
	 *            the property change listener to remove
	 */
	public void removePropertyChangeListener(PropertyChangeListener pcl) {
		pcs.removePropertyChangeListener(pcl);
	}
        pcs.removePropertyChangeListener(propertyName, pcl);
    }

	/**
	 * Adds the specified <tt>PropertyChangeListener</tt> for the specified
	 * property.
	 * 
	 * @param propertyName
	 *            the name of the property to listen on
	 * @param pcl
	 *            the property change listener to add
	 */
	public void addPropertyChangeListener(String propertyName,
			PropertyChangeListener pcl) {
		pcs.addPropertyChangeListener(propertyName, pcl);
	}
        }
    }

	/**
	 * Removes the specified <tt>PropertyChangeListener</tt> for the specified
	 * property.
	 * 
	 * @param propertyName
	 *            the name of the property that was listened on
	 * @param pcl
	 *            the property change listener to remove
	 */
	public void removePropertyChangeListener(String propertyName,
			PropertyChangeListener pcl) {
		pcs.removePropertyChangeListener(propertyName, pcl);
	}

	/**
	 * Determines whether the zoom interactor is enabled or not.
	 */
	public void setEnableZoomInteractor(boolean b) {
		if (isZoomInteractorEnabled != b) {
			boolean oldValue = isZoomInteractorEnabled;
			isZoomInteractorEnabled = b;
			if (isZoomInteractorEnabled) {
				getInteractors().add(zoomInteractor);
			} else {
				getInteractors().remove(zoomInteractor);
			}
			pcs.firePropertyChange("enableZoomInteractor", oldValue, b);
		}
	}

	/**
	 * Returns true if the zoom interactor is enabled, false otherwise.
	 */
	public boolean getEnableZoomInteractor() {
		return isZoomInteractorEnabled;
	}

	/**
	 * Determines whether the image zoom interactor is enabled or not.
	 */
	public void setEnableImageZoomInteractor(boolean b) {
		if (isImageZoomInteractorEnabled != b) {
			boolean oldValue = isImageZoomInteractorEnabled;
			isImageZoomInteractorEnabled = b;
			if (isImageZoomInteractorEnabled) {
				getInteractors().add(imageZoomInteractor);
			} else {
				getInteractors().remove(imageZoomInteractor);
			}
			pcs.firePropertyChange("enableImageZoomInteractor", oldValue, b);
		}
	}

	/**
	 * Returns true if the image zoom interactor is enabled, false otherwise.
	 */
	public boolean getEnableImageZoomInteractor() {
		return isImageZoomInteractorEnabled;
	}

	/**
	 * Determines whether the pan interactor is enabled or not.
	 */
	public void setEnablePanInteractor(boolean b) {
		if (isPanInteractorEnabled != b) {
			boolean oldValue = isPanInteractorEnabled;
			isPanInteractorEnabled = b;
			if (isPanInteractorEnabled) {
				getInteractors().add(panInteractor);
			} else {
				getInteractors().remove(panInteractor);
			}
			pcs.firePropertyChange("enablePanInteractor", oldValue, b);
		}
	}

	/**
	 * Returns true if the pan interactor is enabled, false otherwise.
	 */
	public boolean getEnablePanInteractor() {
		return isPanInteractorEnabled;
	}

	/**
	 * Determines whether the rotate interactor is enabled or not.
	 */
	public void setEnableRotateInteractor(boolean b) {
		if (isRotateInteractorEnabled != b) {
			boolean oldValue = isRotateInteractorEnabled;
			isRotateInteractorEnabled = b;
			if (isRotateInteractorEnabled) {
				getInteractors().add(rotateInteractor);
			} else {
				getInteractors().remove(rotateInteractor);
			}
			pcs.firePropertyChange("enableRotateInteractor", oldValue, b);
		}
	}
        }
    }

	/**
	 * Returns true if the rotate interactor is enabled, false otherwise.
	 */
	public boolean getEnableRotateInteractor() {
		return isRotateInteractorEnabled;
	}
    }

	/**
	 * Determines whether the reset transform interactor is enabled or not.
	 */
	public void setEnableResetTransformInteractor(boolean b) {
		if (isResetTransformInteractorEnabled != b) {
			boolean oldValue = isResetTransformInteractorEnabled;
			isResetTransformInteractorEnabled = b;
			if (isResetTransformInteractorEnabled) {
				getInteractors().add(resetTransformInteractor);
			} else {
				getInteractors().remove(resetTransformInteractor);
			}
			pcs.firePropertyChange("enableResetTransformInteractor", oldValue,
					b);
		}
	}

	/**
	 * Returns true if the reset transform interactor is enabled, false
	 * otherwise.
	 */
	public boolean getEnableResetTransformInteractor() {
		return isResetTransformInteractorEnabled;
	}
    public void setURI(String newURI) {
        String oldValue = uri;
        this.uri = newURI;
        if (uri != null) {
            loadSVGDocument(uri);
        } else {
            setSVGDocument(null);
        }

	/**
	 * Returns the URI of the current document.
	 */
	public String getURI() {
		return uri;
	}

	/**
	 * Sets the URI to the specified uri. If the input 'newURI' string is null,
	 * then the canvas will display an empty document.
	 * 
	 * @param newURI
	 *            the new uri of the document to display
	 */
	public void setURI(String newURI) {
		String oldValue = uri;
		this.uri = newURI;
		if (uri != null) {
			loadSVGDocument(uri);
		} else {
			setSVGDocument(null);
		}

		pcs.firePropertyChange("URI", oldValue, uri);
	}
     */
    protected Listener createListener() {
        return new CanvasSVGListener();
    }

	/**
	 * Creates a UserAgent.
	 */
	protected UserAgent createUserAgent() {
		return new CanvasUserAgent();
	}

	/**
	 * Creates an instance of Listener.
	 */
	protected Listener createListener() {
		return new CanvasSVGListener();
	}
        }

	/**
	 * To hide the listener methods. This class just reset the tooltip.
	 */
	protected class CanvasSVGListener extends ExtendedSVGListener {

		/**
		 * Called when the loading of a document was started.
		 */
		public void documentLoadingStarted(SVGDocumentLoaderEvent e) {
			super.documentLoadingStarted(e);
			JSVGCanvas.this.setToolTipText(null);
		}

	}
                root = (NodeEventTarget)ttdoc.getRootElement();
                if (root == null) continue;
                root.removeEventListenerNS
                    (XMLConstants.XML_EVENTS_NAMESPACE_URI,
                     SVGConstants.SVG_EVENT_MOUSEOVER,
                     toolTipListener, false);
                root.removeEventListenerNS
                    (XMLConstants.XML_EVENTS_NAMESPACE_URI,
                     SVGConstants.SVG_EVENT_MOUSEOUT,
                     toolTipListener, false);
            }
            toolTipDocs = null;
        }
        lastTarget = null;

	protected void installSVGDocument(SVGDocument doc) {
		if (toolTipDocs != null) {
			Iterator i = toolTipDocs.keySet().iterator();
			while (i.hasNext()) {
				SVGDocument ttdoc;
				ttdoc = (SVGDocument) i.next();
				if (ttdoc == null)
					continue;

				NodeEventTarget root;
				root = (NodeEventTarget) ttdoc.getRootElement();
				if (root == null)
					continue;
				root.removeEventListenerNS(
						XMLConstants.XML_EVENTS_NAMESPACE_URI,
						SVGConstants.SVG_EVENT_MOUSEOVER, toolTipListener,
						false);
				root
						.removeEventListenerNS(
								XMLConstants.XML_EVENTS_NAMESPACE_URI,
								SVGConstants.SVG_EVENT_MOUSEOUT,
								toolTipListener, false);
			}
			toolTipDocs = null;
		}
		lastTarget = null;

		if (toolTipMap != null) {
			toolTipMap.clear();
		}

		super.installSVGDocument(doc);
	}
     */
    public class ResetTransformAction extends AbstractAction {
        public void actionPerformed(ActionEvent evt) {
            fragmentIdentifier = null;
            resetRenderingTransform();
        }
    }

	// ----------------------------------------------------------------------
	// Actions
	// ----------------------------------------------------------------------
     * applied the method translates the center of the display to
     * 0,0 so scale and rotate occur around the middle of
     * the display.
     */
    public class AffineAction extends AbstractAction {
        AffineTransform at;
        public AffineAction(AffineTransform at) {
            this.at = at;
        }

	/**
	 * A swing action to reset the rendering transform of the canvas.
	 */
	public class ResetTransformAction extends AbstractAction {
		public void actionPerformed(ActionEvent evt) {
			fragmentIdentifier = null;
			resetRenderingTransform();
		}
	}
                AffineTransform t = AffineTransform.getTranslateInstance(x, y);
                t.concatenate(at);
                t.translate(-x, -y);
                t.concatenate(rat);
                setRenderingTransform(t);
            }
        }
    }

	/**
	 * A swing action to append an affine transform to the current rendering
	 * transform. Before the rendering transform is applied the method
	 * translates the center of the display to 0,0 so scale and rotate occur
	 * around the middle of the display.
	 */
	public class AffineAction extends AbstractAction {
		AffineTransform at;
        public ZoomAction(double scaleX, double scaleY) {
            super(AffineTransform.getScaleInstance(scaleX, scaleY));
        }
    }

		public AffineAction(AffineTransform at) {
			this.at = at;
		}
    public class ZoomInAction extends ZoomAction {
        ZoomInAction() { super(2); }
    }

		public void actionPerformed(ActionEvent evt) {
			if (gvtRoot == null) {
				return;
			}
			AffineTransform rat = getRenderingTransform();
			if (at != null) {
				Dimension dim = getSize();
				int x = dim.width / 2;
				int y = dim.height / 2;
				AffineTransform t = AffineTransform.getTranslateInstance(x, y);
				t.concatenate(at);
				t.translate(-x, -y);
				t.concatenate(rat);
				setRenderingTransform(t);
			}
		}
	}

	/**
	 * A swing action to apply a zoom factor to the canvas. This can be used to
	 * zoom in (scale > 1) and out (scale <1).
	 */
	public class ZoomAction extends AffineAction {
		public ZoomAction(double scale) {
			super(AffineTransform.getScaleInstance(scale, scale));
		}

		public ZoomAction(double scaleX, double scaleY) {
			super(AffineTransform.getScaleInstance(scaleX, scaleY));
		}
	}
        public ScrollAction(double tx, double ty) {
            super(AffineTransform.getTranslateInstance(tx, ty));
        }
    }

	/**
	 * A swing action to zoom in the canvas.
	 */
	public class ZoomInAction extends ZoomAction {
		ZoomInAction() {
			super(2);
		}
	}
    }

	/**
	 * A swing action to zoom out the canvas.
	 */
	public class ZoomOutAction extends ZoomAction {
		ZoomOutAction() {
			super(.5);
		}
	}
    }

	/**
	 * A swing action to Rotate the canvas.
	 */
	public class RotateAction extends AffineAction {
		public RotateAction(double theta) {
			super(AffineTransform.getRotateInstance(theta));
		}
	}
    }

	/**
	 * A swing action to Pan/scroll the canvas.
	 */
	public class ScrollAction extends AffineAction {
		public ScrollAction(double tx, double ty) {
			super(AffineTransform.getTranslateInstance(tx, ty));
		}
	}
    }

	/**
	 * A swing action to scroll the canvas to the right, by a fixed amount
	 */
	public class ScrollRightAction extends ScrollAction {
		public ScrollRightAction(int inc) {
			super(-inc, 0);
		}
	}

	/**
	 * A swing action to scroll the canvas to the left, by a fixed amount
	 */
	public class ScrollLeftAction extends ScrollAction {
		public ScrollLeftAction(int inc) {
			super(inc, 0);
		}
	}
                ie.getID() == MouseEvent.MOUSE_PRESSED &&
                (mods & InputEvent.BUTTON1_MASK) != 0 &&
                (mods & InputEvent.CTRL_MASK) != 0;
        }
    };

	/**
	 * A swing action to scroll the canvas up, by a fixed amount
	 */
	public class ScrollUpAction extends ScrollAction {
		public ScrollUpAction(int inc) {
			super(0, inc);
		}
	}
            return
                ie.getID() == MouseEvent.MOUSE_PRESSED &&
                (mods & InputEvent.BUTTON3_MASK) != 0 &&
                (mods & InputEvent.SHIFT_MASK) != 0;
        }
    };

	/**
	 * A swing action to scroll the canvas down, by a fixed amount
	 */
	public class ScrollDownAction extends ScrollAction {
		public ScrollDownAction(int inc) {
			super(0, -inc);
		}
	}
                ie.getID() == MouseEvent.MOUSE_PRESSED &&
                (mods & InputEvent.BUTTON1_MASK) != 0 &&
                (mods & InputEvent.SHIFT_MASK) != 0;
        }
    };

	// ----------------------------------------------------------------------
	// Interactors
	// ----------------------------------------------------------------------
     */
    protected Interactor rotateInteractor = new AbstractRotateInteractor() {
        public boolean startInteraction(InputEvent ie) {
            int mods = ie.getModifiers();
            return
                ie.getID() == MouseEvent.MOUSE_PRESSED &&
                (mods & InputEvent.BUTTON3_MASK) != 0 &&
                (mods & InputEvent.CTRL_MASK) != 0;
        }
    };

	/**
	 * An interactor to perform a zoom.
	 * <p>
	 * Binding: BUTTON1 + CTRL Key
	 * </p>
	 */
	protected Interactor zoomInteractor = new AbstractZoomInteractor() {
		public boolean startInteraction(InputEvent ie) {
			int mods = ie.getModifiers();
			return ie.getID() == MouseEvent.MOUSE_PRESSED
					&& (mods & InputEvent.BUTTON1_MASK) != 0
					&& (mods & InputEvent.CTRL_MASK) != 0;
		}
	};
    };

	/**
	 * An interactor to perform a realtime zoom.
	 * <p>
	 * Binding: BUTTON3 + SHIFT Key
	 * </p>
	 */
	protected Interactor imageZoomInteractor = new AbstractImageZoomInteractor() {
		public boolean startInteraction(InputEvent ie) {
			int mods = ie.getModifiers();
			return ie.getID() == MouseEvent.MOUSE_PRESSED
					&& (mods & InputEvent.BUTTON3_MASK) != 0
					&& (mods & InputEvent.SHIFT_MASK) != 0;
		}
	};

	/**
	 * An interactor to perform a translation.
	 * <p>
	 * Binding: BUTTON1 + SHIFT Key
	 * </p>
	 */
	protected Interactor panInteractor = new AbstractPanInteractor() {
		public boolean startInteraction(InputEvent ie) {
			int mods = ie.getModifiers();
			return ie.getID() == MouseEvent.MOUSE_PRESSED
					&& (mods & InputEvent.BUTTON1_MASK) != 0
					&& (mods & InputEvent.SHIFT_MASK) != 0;
		}
	};

	/**
	 * An interactor to perform a rotation.
	 * <p>
	 * Binding: BUTTON3 + CTRL Key
	 * </p>
	 */
	protected Interactor rotateInteractor = new AbstractRotateInteractor() {
		public boolean startInteraction(InputEvent ie) {
			int mods = ie.getModifiers();
			return ie.getID() == MouseEvent.MOUSE_PRESSED
					&& (mods & InputEvent.BUTTON3_MASK) != 0
					&& (mods & InputEvent.CTRL_MASK) != 0;
		}
	};

	/**
	 * An interactor to reset the rendering transform.
	 * <p>
	 * Binding: CTRL+SHIFT+BUTTON3
	 * </p>
	 */
	protected Interactor resetTransformInteractor = new AbstractResetTransformInteractor() {
		public boolean startInteraction(InputEvent ie) {
			int mods = ie.getModifiers();
			return ie.getID() == MouseEvent.MOUSE_CLICKED
					&& (mods & InputEvent.BUTTON3_MASK) != 0
					&& (mods & InputEvent.SHIFT_MASK) != 0
					&& (mods & InputEvent.CTRL_MASK) != 0;
		}
	};

	// ----------------------------------------------------------------------
	// User agent implementation
	// ----------------------------------------------------------------------
         * element or both. <br/>
         * Because these elements can appear in any order, here
         * is the algorithm used to build the tool tip:<br />
         * <ul>
         * <li>If a &lt;title&gt; is passed to <tt>handleElement</tt>
         *     the method checks if there is a &gt;desc&gt; peer. If
         *     there is one, nothing is done (because the desc will do
         *     it). If there in none, the tool tip is set to the value
         *     of the &lt;title&gt; element content.</li>
         * <li>If a &lt;desc&gt; is passed to <tt>handleElement</tt>
         *     the method checks if there is a &lt;title&gt; peer. If there
         *     is one, the content of that peer is pre-pended to the
         *     content of the &lt;desc&gt; element.</li>
         * </ul>
         */
        public void handleElement(Element elt, Object data){
            super.handleElement(elt, data);

	/**
	 * The <tt>CanvasUserAgent</tt> only adds tooltips to the behavior of the
	 * default <tt>BridgeUserAgent</tt>. A tooltip will be displayed wheneven
	 * the mouse lingers over an element which has a &lt;title&gt; or a
	 * &lt;desc&gt; child element.
	 */
	protected class CanvasUserAgent extends BridgeUserAgent

	implements XMLConstants {
                return;

		final String TOOLTIP_TITLE_ONLY = "JSVGCanvas.CanvasUserAgent.ToolTip.titleOnly";
            if (elt.getParentNode() ==
                elt.getOwnerDocument().getDocumentElement()) {
                return;
            }

		final String TOOLTIP_DESC_ONLY = "JSVGCanvas.CanvasUserAgent.ToolTip.descOnly";
            // When node is removed data is old parent node
            // since we can't get it otherwise.
            if (data instanceof Element) parent = (Element)data;
            else                         parent = (Element)elt.getParentNode();

		final String TOOLTIP_TITLE_AND_TEXT = "JSVGCanvas.CanvasUserAgent.ToolTip.titleAndDesc";
            Element titlePeer = null;
            if (elt.getLocalName().equals(SVGConstants.SVG_TITLE_TAG)) {
                if (data == Boolean.TRUE)
                    titlePeer = elt;
                descPeer = getPeerWithTag(parent,
                                           SVGConstants.SVG_NAMESPACE_URI,
                                           SVGConstants.SVG_DESC_TAG);
            } else if (elt.getLocalName().equals(SVGConstants.SVG_DESC_TAG)) {
                if (data == Boolean.TRUE)
                    descPeer = elt;
                titlePeer = getPeerWithTag(parent,
                                           SVGConstants.SVG_NAMESPACE_URI,
                                           SVGConstants.SVG_TITLE_TAG);
            }

		/**
		 * The handleElement method builds a tool tip from the content of a
		 * &lt;title&gt; element, a &lt;desc&gt; element or both. <br/> Because
		 * these elements can appear in any order, here is the algorithm used to
		 * build the tool tip:<br />
		 * <ul>
		 * <li>If a &lt;title&gt; is passed to <tt>handleElement</tt> the
		 * method checks if there is a &gt;desc&gt; peer. If there is one,
		 * nothing is done (because the desc will do it). If there in none, the
		 * tool tip is set to the value of the &lt;title&gt; element content.</li>
		 * <li>If a &lt;desc&gt; is passed to <tt>handleElement</tt> the
		 * method checks if there is a &lt;title&gt; peer. If there is one, the
		 * content of that peer is pre-pended to the content of the &lt;desc&gt;
		 * element.</li>
		 * </ul>
		 */
		public void handleElement(Element elt, Object data) {
			super.handleElement(elt, data);

			// Don't handle tool tips unless we are interactive.
			if (!isInteractive())
				return;
                if (descPeer.getFirstChild() != null)
                    descTip = descPeer.getFirstChild().getNodeValue();
            }

			if (!SVGConstants.SVG_NAMESPACE_URI.equals(elt.getNamespaceURI()))
				return;
                if ((descTip != null) && (descTip.length() != 0)) {
                    toolTip = Messages.formatMessage
                        (TOOLTIP_TITLE_AND_TEXT,
                         new Object[] { toFormattedHTML(titleTip),
                                        toFormattedHTML(descTip)});
                } else {
                    toolTip = Messages.formatMessage
                        (TOOLTIP_TITLE_ONLY,
                         new Object[]{toFormattedHTML(titleTip)});
                }
            } else {
                if ((descTip != null) && (descTip.length() != 0)) {
                    toolTip = Messages.formatMessage
                        (TOOLTIP_DESC_ONLY,
                         new Object[]{toFormattedHTML(descTip)});
                } else {
                    toolTip = null;
                }
            }

			// Don't handle tool tips for the root SVG element.
			if (elt.getParentNode() == elt.getOwnerDocument()
					.getDocumentElement()) {
				return;
			}

			Element parent;
			// When node is removed data is old parent node
			// since we can't get it otherwise.
			if (data instanceof Element)
				parent = (Element) data;
			else
				parent = (Element) elt.getParentNode();
                    toolTipMap.put(parent, toolTip);
                }

			Element descPeer = null;
			Element titlePeer = null;
			if (elt.getLocalName().equals(SVGConstants.SVG_TITLE_TAG)) {
				if (data == Boolean.TRUE)
					titlePeer = elt;
				descPeer = getPeerWithTag(parent,
						SVGConstants.SVG_NAMESPACE_URI,
						SVGConstants.SVG_DESC_TAG);
			} else if (elt.getLocalName().equals(SVGConstants.SVG_DESC_TAG)) {
				if (data == Boolean.TRUE)
					descPeer = elt;
				titlePeer = getPeerWithTag(parent,
						SVGConstants.SVG_NAMESPACE_URI,
						SVGConstants.SVG_TITLE_TAG);
			}
                            }
                        });
                } else {
                    EventQueue.invokeLater(new ToolTipRunnable(toolTip));
                }
            }
        }

			String titleTip = null;
			if (titlePeer != null) {
				titlePeer.normalize();
				if (titlePeer.getFirstChild() != null)
					titleTip = titlePeer.getFirstChild().getNodeValue();
			}
            replace(sb, XML_CHAR_AMP, XML_ENTITY_AMP);  // Must go first!
            replace(sb, XML_CHAR_LT, XML_ENTITY_LT);
            replace(sb, XML_CHAR_GT, XML_ENTITY_GT);
            replace(sb, XML_CHAR_QUOT, XML_ENTITY_QUOT);
            // Dont' quote "'" apostrphe since the display doesn't
            // seem to understand it.
            // replace(sb, XML_CHAR_APOS, XML_ENTITY_APOS);
            replace(sb, '\n', "<br>");
            return sb.toString();
        }

			String descTip = null;
			if (descPeer != null) {
				descPeer.normalize();
				if (descPeer.getFirstChild() != null)
					descTip = descPeer.getFirstChild().getNodeValue();
			}

			final String toolTip;
			if ((titleTip != null) && (titleTip.length() != 0)) {
				if ((descTip != null) && (descTip.length() != 0)) {
					toolTip = Messages.formatMessage(TOOLTIP_TITLE_AND_TEXT,
							new Object[] { toFormattedHTML(titleTip),
									toFormattedHTML(descTip) });
				} else {
					toolTip = Messages.formatMessage(TOOLTIP_TITLE_ONLY,
							new Object[] { toFormattedHTML(titleTip) });
				}
			} else {
				if ((descTip != null) && (descTip.length() != 0)) {
					toolTip = Messages.formatMessage(TOOLTIP_DESC_ONLY,
							new Object[] { toFormattedHTML(descTip) });
				} else {
					toolTip = null;
				}
			}

			if (toolTip == null) {
				removeToolTip(parent);
				return;
			}
        public Element getPeerWithTag(Element parent,
                                      String nameSpaceURI,
                                      String localName) {

			if (lastTarget != parent) {
				setToolTip(parent, toolTip);
			} else {
				// Already has focus check if it already has tip text.
				Object o = null;
				if (toolTipMap != null) {
					o = toolTipMap.get(parent);
					toolTipMap.put(parent, toolTip);
				}

				if (o != null) {
					// Update components tooltip text now.
					EventQueue.invokeLater(new Runnable() {
						public void run() {
							setToolTipText(toolTip);
							MouseEvent e = new MouseEvent(JSVGCanvas.this,
									MouseEvent.MOUSE_MOVED, System
											.currentTimeMillis(), 0,
									locationListener.getLastX(),
									locationListener.getLastY(), 0, false);
							ToolTipManager.sharedInstance().mouseMoved(e);
						}
					});
				} else {
					EventQueue.invokeLater(new ToolTipRunnable(toolTip));
				}
			}
		}

		/**
		 * Converts line breaks to HTML breaks and encodes special entities.
		 * Poor way of replacing '<', '>' and '&' in content.
		 */
		public String toFormattedHTML(String str) {
			StringBuffer sb = new StringBuffer(str);
			replace(sb, XML_CHAR_AMP, XML_ENTITY_AMP); // Must go first!
			replace(sb, XML_CHAR_LT, XML_ENTITY_LT);
			replace(sb, XML_CHAR_GT, XML_ENTITY_GT);
			replace(sb, XML_CHAR_QUOT, XML_ENTITY_QUOT);
			// Dont' quote "'" apostrphe since the display doesn't
			// seem to understand it.
			// replace(sb, XML_CHAR_APOS, XML_ENTITY_APOS);
			replace(sb, '\n', "<br>");
			return sb.toString();
		}

		protected void replace(StringBuffer sb, char c, String r) {
			String v = sb.toString();
			int i = v.length();

			while ((i = v.lastIndexOf(c, i - 1)) != -1) {
				sb.deleteCharAt(i);
				sb.insert(i, r);
			}
		}
                toolTipMap = new WeakHashMap();
            }
            if (toolTipDocs == null) {
                toolTipDocs = new WeakHashMap();
            }
            SVGDocument doc = (SVGDocument)elt.getOwnerDocument();
            if (toolTipDocs.put(doc, MAP_TOKEN) == null) {
                NodeEventTarget root;
                root = (NodeEventTarget)doc.getRootElement();
                // On mouseover, it sets the tooltip to the given value
                root.addEventListenerNS(XMLConstants.XML_EVENTS_NAMESPACE_URI,
                                        SVGConstants.SVG_EVENT_MOUSEOVER,
                                        toolTipListener,
                                        false, null);
                // On mouseout, it removes the tooltip
                root.addEventListenerNS(XMLConstants.XML_EVENTS_NAMESPACE_URI,
                                        SVGConstants.SVG_EVENT_MOUSEOUT,
                                        toolTipListener,
                                        false, null);
            }

		/**
		 * Checks if there is a peer element of a given type. This returns the
		 * first occurence of the given type or null if none is found.
		 */
		public Element getPeerWithTag(Element parent, String nameSpaceURI,
				String localName) {

			Element p = parent;
			if (p == null) {
				return null;
			}

			for (Node n = p.getFirstChild(); n != null; n = n.getNextSibling()) {
				if (!nameSpaceURI.equals(n.getNamespaceURI())) {
					continue;
				}
				if (!localName.equals(n.getLocalName())) {
					continue;
				}
				if (n.getNodeType() == Node.ELEMENT_NODE) {
					return (Element) n;
				}
			}
			return null;
		}

		/**
		 * Returns a boolean defining whether or not there is a peer of
		 * <tt>elt</tt> with the given qualified tag.
		 */
		public boolean hasPeerWithTag(Element elt, String nameSpaceURI,
				String localName) {
            } else {
                JOptionPane pane =
                    new JOptionPane(message, JOptionPane.ERROR_MESSAGE);
                JDialog dialog =
                    pane.createDialog(JSVGCanvas.this, "ERROR");
                dialog.setModal(false);
                dialog.setVisible(true); // Safe to be called from any thread
            }
        }

			return !(getPeerWithTag(elt, nameSpaceURI, localName) == null);
		}
         */
        public void displayError(Exception ex) {
            if (svgUserAgent != null) {
                super.displayError(ex);
            } else {
                JErrorPane pane =
                    new JErrorPane(ex, JOptionPane.ERROR_MESSAGE);
                JDialog dialog = pane.createDialog(JSVGCanvas.this, "ERROR");
                dialog.setModal(false);
                dialog.setVisible(true); // Safe to be called from any thread
            }
        }
    }

		/**
		 * Sets the tool tip on the input element.
		 */
		public void setToolTip(Element elt, String toolTip) {
			if (toolTipMap == null) {
				toolTipMap = new WeakHashMap();
			}
			if (toolTipDocs == null) {
				toolTipDocs = new WeakHashMap();
			}
			SVGDocument doc = (SVGDocument) elt.getOwnerDocument();
			if (toolTipDocs.put(doc, MAP_TOKEN) == null) {
				NodeEventTarget root;
				root = (NodeEventTarget) doc.getRootElement();
				// On mouseover, it sets the tooltip to the given value
				root.addEventListenerNS(XMLConstants.XML_EVENTS_NAMESPACE_URI,
						SVGConstants.SVG_EVENT_MOUSEOVER, toolTipListener,
						false, null);
				// On mouseout, it removes the tooltip
				root.addEventListenerNS(XMLConstants.XML_EVENTS_NAMESPACE_URI,
						SVGConstants.SVG_EVENT_MOUSEOUT, toolTipListener,
						false, null);
			}

			toolTipMap.put(elt, toolTip);
     * Sets the time and element of the last tool tip event handled.
     */
    public void setLastToolTipEvent(long t, EventTarget et) {
        lastToolTipEventTimeStamp = t;
        lastToolTipEventTarget = et;
    }

			if (elt == lastTarget)
				EventQueue.invokeLater(new ToolTipRunnable(toolTip));
		}
     */
    public boolean matchLastToolTipEvent(long t, EventTarget et) {
        return lastToolTipEventTimeStamp == t
            && lastToolTipEventTarget == et;
    }

		public void removeToolTip(Element elt) {
			if (toolTipMap != null)
				toolTipMap.remove(elt);
			if (lastTarget == elt) { // clear ToolTip.
				EventQueue.invokeLater(new ToolTipRunnable(null));
			}
		}

		/**
		 * Displays an error message in the User Agent interface.
		 */
		public void displayError(String message) {
			if (svgUserAgent != null) {
				super.displayError(message);
			} else {
				JOptionPane pane = new JOptionPane(message,
						JOptionPane.ERROR_MESSAGE);
				JDialog dialog = pane.createDialog(JSVGCanvas.this, "ERROR");
				dialog.setModal(false);
				dialog.setVisible(true); // Safe to be called from any thread
			}
		}

		/**
		 * Displays an error resulting from the specified Exception.
		 */
		public void displayError(Exception ex) {
			if (svgUserAgent != null) {
				super.displayError(ex);
			} else {
				// JErrorPane pane =
				// new JErrorPane(ex, JOptionPane.ERROR_MESSAGE);
				ErrorConsole console = ErrorConsole.getInstance();
				ErrorInfo info = new ErrorInfo(ex, getURI(),
						ErrorConsole.ERROR);
				console.add(info);
				ErrorConsole.showDialog(JSVGCanvas.this);
			}
		}
	}

	// ----------------------------------------------------------------------
	// Tooltip
	// ----------------------------------------------------------------------
        }

	/**
	 * Sets the time and element of the last tool tip event handled.
	 */
	public void setLastToolTipEvent(long t, EventTarget et) {
		lastToolTipEventTimeStamp = t;
		lastToolTipEventTarget = et;
	}

	/**
	 * Checks if the specified event time and element are the same as the last
	 * tool tip event.
	 */
	public boolean matchLastToolTipEvent(long t, EventTarget et) {
		return lastToolTipEventTimeStamp == t && lastToolTipEventTarget == et;
	}

	/**
	 * Helper class. Simply keeps track of the last known mouse position over
	 * the canvas.
	 */
	protected class LocationListener extends MouseMotionAdapter {
     * Because we are on a single <tt>JComponent</tt> we trigger an artificial
     * <tt>MouseEvent</tt> when the toolTip is set to a non-null value, so as
     * to make sure it will show after the <tt>ToolTipManager</tt>'s default
     * delay.
     */
    protected class ToolTipModifier implements EventListener {
        /**
         * The CanvasUserAgent used to track the last tool tip event.
         */
        protected CanvasUserAgent canvasUserAgent;

		protected int lastX, lastY;
         * Creates a new ToolTipModifier object.
         */
        public ToolTipModifier() {
        }

		public LocationListener() {
			lastX = 0;
			lastY = 0;
		}
            if (matchLastToolTipEvent(evt.getTimeStamp(), evt.getTarget())) {
                return;
            }
            setLastToolTipEvent(evt.getTimeStamp(), evt.getTarget());
            EventTarget prevLastTarget = lastTarget;
            if (SVGConstants.SVG_EVENT_MOUSEOVER.equals(evt.getType())) {
                lastTarget = evt.getTarget();
            } else if (SVGConstants.SVG_EVENT_MOUSEOUT.equals(evt.getType())) {
                // related target is one it is entering or null.
                org.w3c.dom.events.MouseEvent mouseEvt;
                mouseEvt = ((org.w3c.dom.events.MouseEvent)evt);
                lastTarget = mouseEvt.getRelatedTarget();
            }

		public void mouseMoved(MouseEvent evt) {
			lastX = evt.getX();
			lastY = evt.getY();
		}
                    // Search the parents of the current node for ToolTips.
                    o = toolTipMap.get(e);
                    if (o != null) {
                        break;
                    }
                    e = CSSEngine.getParentCSSStylableElement(e);
                }
                final String theToolTip = (String)o;
                if (prevLastTarget != lastTarget)
                    EventQueue.invokeLater(new ToolTipRunnable(theToolTip));
            }
        }
    }

		public int getLastX() {
			return lastX;
		}
            this.theToolTip = toolTip;
        }

		public int getLastY() {
			return lastY;
		}
	}

	/**
	 * Sets a specific tooltip on the JSVGCanvas when a given event occurs. This
	 * listener is used in the handleElement method to set, remove or modify the
	 * JSVGCanvas tooltip on mouseover and on mouseout.<br/>
	 * 
	 * Because we are on a single <tt>JComponent</tt> we trigger an artificial
	 * <tt>MouseEvent</tt> when the toolTip is set to a non-null value, so as
	 * to make sure it will show after the <tt>ToolTipManager</tt>'s default
	 * delay.
	 */
	protected class ToolTipModifier implements EventListener {
		/**
		 * The CanvasUserAgent used to track the last tool tip event.
		 */
		protected CanvasUserAgent canvasUserAgent;

		/**
		 * Creates a new ToolTipModifier object.
		 */
		public ToolTipModifier() {
		}

		public void handleEvent(Event evt) {
			// Don't set the tool tip if another ToolTipModifier
			// has already handled this event (as it will have been
			// a higher priority tool tip).
			if (matchLastToolTipEvent(evt.getTimeStamp(), evt.getTarget())) {
				return;
			}
			setLastToolTipEvent(evt.getTimeStamp(), evt.getTarget());
			EventTarget prevLastTarget = lastTarget;
			if (SVGConstants.SVG_EVENT_MOUSEOVER.equals(evt.getType())) {
				lastTarget = evt.getTarget();
			} else if (SVGConstants.SVG_EVENT_MOUSEOUT.equals(evt.getType())) {
				// related target is one it is entering or null.
				org.w3c.dom.events.MouseEvent mouseEvt;
				mouseEvt = ((org.w3c.dom.events.MouseEvent) evt);
				lastTarget = mouseEvt.getRelatedTarget();
			}

			if (toolTipMap != null) {
				Element e = (Element) lastTarget;
				Object o = null;
				while (e != null) {
					// Search the parents of the current node for ToolTips.
					o = toolTipMap.get(e);
					if (o != null) {
						break;
					}
					e = CSSEngine.getParentCSSStylableElement(e);
				}
				final String theToolTip = (String) o;
				if (prevLastTarget != lastTarget)
					EventQueue.invokeLater(new ToolTipRunnable(theToolTip));
			}
		}
	}

	protected class ToolTipRunnable implements Runnable {
		String theToolTip;

		public ToolTipRunnable(String toolTip) {
			this.theToolTip = toolTip;
		}

		public void run() {
			setToolTipText(theToolTip);

			MouseEvent e;
			if (theToolTip != null) {
				e = new MouseEvent(JSVGCanvas.this, MouseEvent.MOUSE_ENTERED,
						System.currentTimeMillis(), 0, locationListener
								.getLastX(), locationListener.getLastY(), 0,
						false);
				ToolTipManager.sharedInstance().mouseEntered(e);
				e = new MouseEvent(JSVGCanvas.this, MouseEvent.MOUSE_MOVED,
						System.currentTimeMillis(), 0, locationListener
								.getLastX(), locationListener.getLastY(), 0,
						false);
				ToolTipManager.sharedInstance().mouseMoved(e);
			} else {
				e = new MouseEvent(JSVGCanvas.this, MouseEvent.MOUSE_MOVED,
						System.currentTimeMillis(), 0, locationListener
								.getLastX(), locationListener.getLastY(), 0,
						false);
				ToolTipManager.sharedInstance().mouseMoved(e);
			}
		}
	}
}

Lines 19-24 Link Here

(-)sources/org/apache/batik/bridge/SVGShapeElementBridge.java (+7 lines)
19	package org.apache.batik.bridge;	19	package org.apache.batik.bridge;
20		20
21	import java.awt.RenderingHints;	21	import java.awt.RenderingHints;
		22	import java.awt.Shape;
		23	import java.awt.geom.Area;
22		24
23	import org.apache.batik.css.engine.CSSEngineEvent;	25	import org.apache.batik.css.engine.CSSEngineEvent;
24	import org.apache.batik.css.engine.SVGCSSEngine;	26	import org.apache.batik.css.engine.SVGCSSEngine;
Lines 35-40 Link Here
35	*/	37	*/
36	public abstract class SVGShapeElementBridge extends AbstractGraphicsNodeBridge {	38	public abstract class SVGShapeElementBridge extends AbstractGraphicsNodeBridge {
37		39
		40	/**
		41	*
		42	*/
		43	protected static Shape nullShape = new Area();
		44
38	/**	45	/**
39	* Constructs a new bridge for SVG shapes.	46	* Constructs a new bridge for SVG shapes.
40	*/	47	*/




 */
package org.apache.batik.bridge;

import java.io.IOException;
import java.io.InputStream;
import java.io.IOException;
import java.util.HashMap;

import org.apache.batik.dom.svg.SAXSVGDocumentFactory;
import org.apache.batik.dom.svg.SVGDocumentFactory;
import org.apache.batik.dom.util.DocumentDescriptor;
import org.apache.batik.util.CleanerThread;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.svg.SVGDocument;

            return ret;

        SVGDocument document = documentFactory.createSVGDocument(uri);

        DocumentDescriptor desc = documentFactory.getDocumentDescriptor();
        DocumentState state = new DocumentState(uri, document, desc);
        synchronized (cacheMap) {

    }

    /**
     * Returns the document descriptor of the last loaded document
     *
     * @return the document descriptor of the last loaded document, or
     * null if no document has been loaded.
     */
    public DocumentDescriptor getDocumentDescriptor(SVGDocument doc) {
        String uri = doc.getURL();
        DocumentState state;
        synchronized (cacheMap) {
            state = (DocumentState)cacheMap.get(uri);
        }
        if (state == null) {
            return null;
        } else {
            return state.desc;
        }
    }

    /**
     * A simple class that contains a Document and its number of nodes.
     */
    private class DocumentState extends CleanerThread.SoftReferenceCleared {

Lines 90-96 Link Here

(-)sources/org/apache/batik/bridge/SVGCircleElementBridge.java (-1 / +6 lines)
90	float w = r * 2;	90	float w = r * 2;
91	shapeNode.setShape(new Ellipse2D.Float(x, y, w, w));	91	shapeNode.setShape(new Ellipse2D.Float(x, y, w, w));
92	} catch (LiveAttributeException ex) {	92	} catch (LiveAttributeException ex) {
93	throw new BridgeException(ctx, ex);	93	if (strictParsing) {
		94	throw new BridgeException(ctx, ex);
		95	} else {
		96	ctx.userAgent.displayError(ex);
		97	shapeNode.setShape(nullShape);
		98	}
94	}	99	}
95	}	100	}
96		101

Lines 20-25 Link Here

(-)sources/org/apache/batik/bridge/SVGPolygonElementBridge.java (-1 / +7 lines)
20		20
21	import java.awt.Shape;	21	import java.awt.Shape;
22	import java.awt.geom.GeneralPath;	22	import java.awt.geom.GeneralPath;
		23	import java.awt.geom.Rectangle2D;
23		24
24	import org.apache.batik.css.engine.SVGCSSEngine;	25	import org.apache.batik.css.engine.SVGCSSEngine;
25	import org.apache.batik.dom.svg.AnimatedLiveAttributeValue;	26	import org.apache.batik.dom.svg.AnimatedLiveAttributeValue;
Lines 98-104 Link Here
98	shapeNode.setShape(app.getShape());	99	shapeNode.setShape(app.getShape());
99	}	100	}
100	} catch (LiveAttributeException ex) {	101	} catch (LiveAttributeException ex) {
101	throw new BridgeException(ctx, ex);	102	if (strictParsing) {
		103	throw new BridgeException(ctx, ex);
		104	} else {
		105	ctx.userAgent.displayError(ex);
		106	shapeNode.setShape(nullShape);
		107	}
102	}	108	}
103	}	109	}
104		110

Lines 93-99 Link Here

(-)sources/org/apache/batik/bridge/SVGEllipseElementBridge.java (-1 / +6 lines)
93	shapeNode.setShape(new Ellipse2D.Float(cx - rx, cy - ry,	93	shapeNode.setShape(new Ellipse2D.Float(cx - rx, cy - ry,
94	rx * 2, ry * 2));	94	rx * 2, ry * 2));
95	} catch (LiveAttributeException ex) {	95	} catch (LiveAttributeException ex) {
96	throw new BridgeException(ctx, ex);	96	if (strictParsing) {
		97	throw new BridgeException(ctx, ex);
		98	} else {
		99	ctx.userAgent.displayError(ex);
		100	shapeNode.setShape(nullShape);
		101	}
97	}	102	}
98	}	103	}
99		104




import org.apache.batik.dom.svg.SVGOMRectElement;
import org.apache.batik.gvt.ShapeNode;
import org.apache.batik.gvt.ShapePainter;

import org.w3c.dom.Element;

/**

            }
            shapeNode.setShape(shape);
        } catch (LiveAttributeException ex) {
        	if (strictParsing) {
	            throw new BridgeException(ctx, ex);
        	} else {
        		ctx.userAgent.displayError(ex);
        		shapeNode.setShape(nullShape);
        	}
        }
    }





/*
 * TextAreaPainter.java - Paints the text area
 * Copyright (C) 1999 Slava Pestov
 *
 * You may use and modify this package for any purpose. Redistribution is
 * permitted, in both source and binary form, provided that this notice
 * remains intact in all source distributions of this package.
 */
package org.apache.batik.apps.svgbrowser.srcview;

import javax.swing.ToolTipManager;
import javax.swing.text.*;
import javax.swing.JComponent;
import java.awt.event.MouseEvent;
import java.awt.*;

/**
 * The text area repaint manager. It performs double buffering and paints
 * lines of text.
 * @author Slava Pestov
 * @version $Id: TextAreaPainter.java,v 1.24 1999/12/13 03:40:30 sp Exp $
 */
public class TextAreaPainter extends JComponent implements TabExpander
{
	/**
	 * Creates a new repaint manager. This should be not be called
	 * directly.
	 */
	public TextAreaPainter(JEditTextArea textArea, TextAreaDefaults defaults)
	{
		this.textArea = textArea;

		setAutoscrolls(true);
		setDoubleBuffered(true);
		setOpaque(true);

		ToolTipManager.sharedInstance().registerComponent(this);

		currentLine = new Segment();
		currentLineIndex = -1;

		setCursor(Cursor.getPredefinedCursor(Cursor.TEXT_CURSOR));

		setFont(new Font("Monospaced",Font.PLAIN,14));
		setForeground(Color.black);
		setBackground(Color.white);

		blockCaret = defaults.blockCaret;
		styles = defaults.styles;
		cols = defaults.cols;
		rows = defaults.rows;
		caretColor = defaults.caretColor;
		selectionColor = defaults.selectionColor;
		lineHighlightColor = defaults.lineHighlightColor;
		lineHighlight = defaults.lineHighlight;
		bracketHighlightColor = defaults.bracketHighlightColor;
		bracketHighlight = defaults.bracketHighlight;
		paintInvalid = defaults.paintInvalid;
		eolMarkerColor = defaults.eolMarkerColor;
		eolMarkers = defaults.eolMarkers;
	}

	/**
	 * Returns if this component can be traversed by pressing the
	 * Tab key. This returns false.
	 */
	public final boolean isManagingFocus()
	{
		return false;
	}

	/**
	 * Returns the syntax styles used to paint colorized text. Entry <i>n</i>
	 * will be used to paint tokens with id = <i>n</i>.
	 * @see org.gjt.sp.jedit.syntax.Token
	 */
	public final SyntaxStyle[] getStyles()
	{
		return styles;
	}

	/**
	 * Sets the syntax styles used to paint colorized text. Entry <i>n</i>
	 * will be used to paint tokens with id = <i>n</i>.
	 * @param styles The syntax styles
	 * @see org.gjt.sp.jedit.syntax.Token
	 */
	public final void setStyles(SyntaxStyle[] styles)
	{
		this.styles = styles;
		repaint();
	}

	/**
	 * Returns the caret color.
	 */
	public final Color getCaretColor()
	{
		return caretColor;
	}

	/**
	 * Sets the caret color.
	 * @param caretColor The caret color
	 */
	public final void setCaretColor(Color caretColor)
	{
		this.caretColor = caretColor;
		invalidateSelectedLines();
	}

	/**
	 * Returns the selection color.
	 */
	public final Color getSelectionColor()
	{
		return selectionColor;
	}

	/**
	 * Sets the selection color.
	 * @param selectionColor The selection color
	 */
	public final void setSelectionColor(Color selectionColor)
	{
		this.selectionColor = selectionColor;
		invalidateSelectedLines();
	}

	/**
	 * Returns the line highlight color.
	 */
	public final Color getLineHighlightColor()
	{
		return lineHighlightColor;
	}

	/**
	 * Sets the line highlight color.
	 * @param lineHighlightColor The line highlight color
	 */
	public final void setLineHighlightColor(Color lineHighlightColor)
	{
		this.lineHighlightColor = lineHighlightColor;
		invalidateSelectedLines();
	}

	/**
	 * Returns true if line highlight is enabled, false otherwise.
	 */
	public final boolean isLineHighlightEnabled()
	{
		return lineHighlight;
	}

	/**
	 * Enables or disables current line highlighting.
	 * @param lineHighlight True if current line highlight should be enabled,
	 * false otherwise
	 */
	public final void setLineHighlightEnabled(boolean lineHighlight)
	{
		this.lineHighlight = lineHighlight;
		invalidateSelectedLines();
	}

	/**
	 * Returns the bracket highlight color.
	 */
	public final Color getBracketHighlightColor()
	{
		return bracketHighlightColor;
	}

	/**
	 * Sets the bracket highlight color.
	 * @param bracketHighlightColor The bracket highlight color
	 */
	public final void setBracketHighlightColor(Color bracketHighlightColor)
	{
		this.bracketHighlightColor = bracketHighlightColor;
		invalidateLine(textArea.getBracketLine());
	}

	/**
	 * Returns true if bracket highlighting is enabled, false otherwise.
	 * When bracket highlighting is enabled, the bracket matching the
	 * one before the caret (if any) is highlighted.
	 */
	public final boolean isBracketHighlightEnabled()
	{
		return bracketHighlight;
	}

	/**
	 * Enables or disables bracket highlighting.
	 * When bracket highlighting is enabled, the bracket matching the
	 * one before the caret (if any) is highlighted.
	 * @param bracketHighlight True if bracket highlighting should be
	 * enabled, false otherwise
	 */
	public final void setBracketHighlightEnabled(boolean bracketHighlight)
	{
		this.bracketHighlight = bracketHighlight;
		invalidateLine(textArea.getBracketLine());
	}

	/**
	 * Returns true if the caret should be drawn as a block, false otherwise.
	 */
	public final boolean isBlockCaretEnabled()
	{
		return blockCaret;
	}

	/**
	 * Sets if the caret should be drawn as a block, false otherwise.
	 * @param blockCaret True if the caret should be drawn as a block,
	 * false otherwise.
	 */
	public final void setBlockCaretEnabled(boolean blockCaret)
	{
		this.blockCaret = blockCaret;
		invalidateSelectedLines();
	}

	/**
	 * Returns the EOL marker color.
	 */
	public final Color getEOLMarkerColor()
	{
		return eolMarkerColor;
	}

	/**
	 * Sets the EOL marker color.
	 * @param eolMarkerColor The EOL marker color
	 */
	public final void setEOLMarkerColor(Color eolMarkerColor)
	{
		this.eolMarkerColor = eolMarkerColor;
		repaint();
	}

	/**
	 * Returns true if EOL markers are drawn, false otherwise.
	 */
	public final boolean getEOLMarkersPainted()
	{
		return eolMarkers;
	}

	/**
	 * Sets if EOL markers are to be drawn.
	 * @param eolMarkers True if EOL markers should be drawn, false otherwise
	 */
	public final void setEOLMarkersPainted(boolean eolMarkers)
	{
		this.eolMarkers = eolMarkers;
		repaint();
	}

	/**
	 * Returns true if invalid lines are painted as red tildes (~),
	 * false otherwise.
	 */
	public boolean getInvalidLinesPainted()
	{
		return paintInvalid;
	}

	/**
	 * Sets if invalid lines are to be painted as red tildes.
	 * @param paintInvalid True if invalid lines should be drawn, false otherwise
	 */
	public void setInvalidLinesPainted(boolean paintInvalid)
	{
		this.paintInvalid = paintInvalid;
	}

	/**
	 * Adds a custom highlight painter.
	 * @param highlight The highlight
	 */
	public void addCustomHighlight(Highlight highlight)
	{
		highlight.init(textArea,highlights);
		highlights = highlight;
	}

	/**
	 * Highlight interface.
	 */
	public interface Highlight
	{
		/**
		 * Called after the highlight painter has been added.
		 * @param textArea The text area
		 * @param next The painter this one should delegate to
		 */
		void init(JEditTextArea textArea, Highlight next);

		/**
		 * This should paint the highlight and delgate to the
		 * next highlight painter.
		 * @param gfx The graphics context
		 * @param line The line number
		 * @param y The y co-ordinate of the line
		 */
		void paintHighlight(Graphics gfx, int line, int y);

		/**
		 * Returns the tool tip to display at the specified
		 * location. If this highlighter doesn't know what to
		 * display, it should delegate to the next highlight
		 * painter.
		 * @param evt The mouse event
		 */
		String getToolTipText(MouseEvent evt);
	}

	/**
	 * Returns the tool tip to display at the specified location.
	 * @param evt The mouse event
	 */
	public String getToolTipText(MouseEvent evt)
	{
		if(highlights != null)
			return highlights.getToolTipText(evt);
		else
			return null;
	}

	/**
	 * Returns the font metrics used by this component.
	 */
	public FontMetrics getFontMetrics()
	{
		return fm;
	}

	/**
	 * Sets the font for this component. This is overridden to update the
	 * cached font metrics and to recalculate which lines are visible.
	 * @param font The font
	 */
	public void setFont(Font font)
	{
		super.setFont(font);
		fm = Toolkit.getDefaultToolkit().getFontMetrics(font);
		textArea.recalculateVisibleLines();
	}

	/**
	 * Repaints the text.
	 * @param g The graphics context
	 */
	public void paint(Graphics gfx)
	{
		tabSize = fm.charWidth(' ') * ((Integer)textArea
			.getDocument().getProperty(
			PlainDocument.tabSizeAttribute)).intValue();

		Rectangle clipRect = gfx.getClipBounds();

		gfx.setColor(getBackground());
		gfx.fillRect(clipRect.x,clipRect.y,clipRect.width,clipRect.height);

		// We don't use yToLine() here because that method doesn't
		// return lines past the end of the document
		int height = fm.getHeight();
		int firstLine = textArea.getFirstLine();
		int firstInvalid = firstLine + clipRect.y / height;
		// Because the clipRect's height is usually an even multiple
		// of the font height, we subtract 1 from it, otherwise one
		// too many lines will always be painted.
		int lastInvalid = firstLine + (clipRect.y + clipRect.height - 1) / height;

		try
		{
			TokenMarker tokenMarker = textArea.getDocument()
				.getTokenMarker();
			int x = textArea.getHorizontalOffset();

			for(int line = firstInvalid; line <= lastInvalid; line++)
			{
				paintLine(gfx,tokenMarker,line,x);
			}

			if(tokenMarker != null && tokenMarker.isNextLineRequested())
			{
				int h = clipRect.y + clipRect.height;
				repaint(0,h,getWidth(),getHeight() - h);
			}
		}
		catch(Exception e)
		{
			System.err.println("Error repainting line"
				+ " range {" + firstInvalid + ","
				+ lastInvalid + "}:");
			e.printStackTrace();
		}
	}

	/**
	 * Marks a line as needing a repaint.
	 * @param line The line to invalidate
	 */
	public final void invalidateLine(int line)
	{
		repaint(0,textArea.lineToY(line) + fm.getMaxDescent() + fm.getLeading(),
			getWidth(),fm.getHeight());
	}

	/**
	 * Marks a range of lines as needing a repaint.
	 * @param firstLine The first line to invalidate
	 * @param lastLine The last line to invalidate
	 */
	public final void invalidateLineRange(int firstLine, int lastLine)
	{
		repaint(0,textArea.lineToY(firstLine) + fm.getMaxDescent() + fm.getLeading(),
			getWidth(),(lastLine - firstLine + 1) * fm.getHeight());
	}

	/**
	 * Repaints the lines containing the selection.
	 */
	public final void invalidateSelectedLines()
	{
		invalidateLineRange(textArea.getSelectionStartLine(),
			textArea.getSelectionEndLine());
	}

	/**
	 * Implementation of TabExpander interface. Returns next tab stop after
	 * a specified point.
	 * @param x The x co-ordinate
	 * @param tabOffset Ignored
	 * @return The next tab stop after <i>x</i>
	 */
	public float nextTabStop(float x, int tabOffset)
	{
		int offset = textArea.getHorizontalOffset();
		int ntabs = ((int)x - offset) / tabSize;
		return (ntabs + 1) * tabSize + offset;
	}

	/**
	 * Returns the painter's preferred size.
	 */
	public Dimension getPreferredSize()
	{
		Dimension dim = new Dimension();
		dim.width = fm.charWidth('w') * cols;
		dim.height = fm.getHeight() * rows;
		return dim;
	}


	/**
	 * Returns the painter's minimum size.
	 */
	public Dimension getMinimumSize()
	{
		return getPreferredSize();
	}

	// package-private members
	int currentLineIndex;
	Token currentLineTokens;
	Segment currentLine;

	// protected members
	protected JEditTextArea textArea;
	
	protected SyntaxStyle[] styles;
	protected Color caretColor;
	protected Color selectionColor;
	protected Color lineHighlightColor;
	protected Color bracketHighlightColor;
	protected Color eolMarkerColor;

	protected boolean blockCaret;
	protected boolean lineHighlight;
	protected boolean bracketHighlight;
	protected boolean paintInvalid;
	protected boolean eolMarkers;
	protected int cols;
	protected int rows;
	
	protected int tabSize;
	protected FontMetrics fm;

	protected Highlight highlights;

	protected void paintLine(Graphics gfx, TokenMarker tokenMarker,
		int line, int x)
	{
		Font defaultFont = getFont();
		Color defaultColor = getForeground();

		currentLineIndex = line;
		int y = textArea.lineToY(line);

		if(line < 0 || line >= textArea.getLineCount())
		{
			if(paintInvalid)
			{
				paintHighlight(gfx,line,y);
				styles[Token.INVALID].setGraphicsFlags(gfx,defaultFont);
				gfx.drawString("~",0,y + fm.getHeight());
			}
		}
		else if(tokenMarker == null)
		{
			paintPlainLine(gfx,line,defaultFont,defaultColor,x,y);
		}
		else
		{
			paintSyntaxLine(gfx,tokenMarker,line,defaultFont,
				defaultColor,x,y);
		}
	}

	protected void paintPlainLine(Graphics gfx, int line, Font defaultFont,
		Color defaultColor, int x, int y)
	{
		paintHighlight(gfx,line,y);
		textArea.getLineText(line,currentLine);

		gfx.setFont(defaultFont);
		gfx.setColor(defaultColor);

		y += fm.getHeight();
		x = Utilities.drawTabbedText(currentLine,x,y,gfx,this,0);

		if(eolMarkers)
		{
			gfx.setColor(eolMarkerColor);
			gfx.drawString(".",x,y);
		}
	}

	protected void paintSyntaxLine(Graphics gfx, TokenMarker tokenMarker,
		int line, Font defaultFont, Color defaultColor, int x, int y)
	{
		textArea.getLineText(currentLineIndex,currentLine);
		currentLineTokens = tokenMarker.markTokens(currentLine,
			currentLineIndex);

		paintHighlight(gfx,line,y);

		gfx.setFont(defaultFont);
		gfx.setColor(defaultColor);
		y += fm.getHeight();
		x = SyntaxUtilities.paintSyntaxLine(currentLine,
			currentLineTokens,styles,this,gfx,x,y);

		if(eolMarkers)
		{
			gfx.setColor(eolMarkerColor);
			gfx.drawString(".",x,y);
		}
	}

	protected void paintHighlight(Graphics gfx, int line, int y)
	{
		if(line >= textArea.getSelectionStartLine()
			&& line <= textArea.getSelectionEndLine())
			paintLineHighlight(gfx,line,y);

		if(highlights != null)
			highlights.paintHighlight(gfx,line,y);

		if(bracketHighlight && line == textArea.getBracketLine())
			paintBracketHighlight(gfx,line,y);

		if(line == textArea.getCaretLine())
			paintCaret(gfx,line,y);
	}

	protected void paintLineHighlight(Graphics gfx, int line, int y)
	{
		int height = fm.getHeight();
		y += fm.getLeading() + fm.getMaxDescent();

		int selectionStart = textArea.getSelectionStart();
		int selectionEnd = textArea.getSelectionEnd();

		if(selectionStart == selectionEnd)
		{
			if(lineHighlight)
			{
				gfx.setColor(lineHighlightColor);
				gfx.fillRect(0,y,getWidth(),height);
			}
		}
		else
		{
			gfx.setColor(selectionColor);

			int selectionStartLine = textArea.getSelectionStartLine();
			int selectionEndLine = textArea.getSelectionEndLine();
			int lineStart = textArea.getLineStartOffset(line);

			int x1, x2;
			if(textArea.isSelectionRectangular())
			{
				int lineLen = textArea.getLineLength(line);
				x1 = textArea._offsetToX(line,Math.min(lineLen,
					selectionStart - textArea.getLineStartOffset(
					selectionStartLine)));
				x2 = textArea._offsetToX(line,Math.min(lineLen,
					selectionEnd - textArea.getLineStartOffset(
					selectionEndLine)));
				if(x1 == x2)
					x2++;
			}
			else if(selectionStartLine == selectionEndLine)
			{
				x1 = textArea._offsetToX(line,
					selectionStart - lineStart);
				x2 = textArea._offsetToX(line,
					selectionEnd - lineStart);
			}
			else if(line == selectionStartLine)
			{
				x1 = textArea._offsetToX(line,
					selectionStart - lineStart);
				x2 = getWidth();
			}
			else if(line == selectionEndLine)
			{
				x1 = 0;
				x2 = textArea._offsetToX(line,
					selectionEnd - lineStart);
			}
			else
			{
				x1 = 0;
				x2 = getWidth();
			}

			// "inlined" min/max()
			gfx.fillRect(x1 > x2 ? x2 : x1,y,x1 > x2 ?
				(x1 - x2) : (x2 - x1),height);
		}

	}

	protected void paintBracketHighlight(Graphics gfx, int line, int y)
	{
		int position = textArea.getBracketPosition();
		if(position == -1)
			return;
		y += fm.getLeading() + fm.getMaxDescent();
		int x = textArea._offsetToX(line,position);
		gfx.setColor(bracketHighlightColor);
		// Hack!!! Since there is no fast way to get the character
		// from the bracket matching routine, we use ( since all
		// brackets probably have the same width anyway
		gfx.drawRect(x,y,fm.charWidth('(') - 1,
			fm.getHeight() - 1);
	}

	protected void paintCaret(Graphics gfx, int line, int y)
	{
		if(textArea.isCaretVisible())
		{
			int offset = textArea.getCaretPosition() 
				- textArea.getLineStartOffset(line);
			int caretX = textArea._offsetToX(line,offset);
			int caretWidth = ((blockCaret ||
				textArea.isOverwriteEnabled()) ?
				fm.charWidth('w') : 1);
			y += fm.getLeading() + fm.getMaxDescent();
			int height = fm.getHeight();
			
			gfx.setColor(caretColor);

			if(textArea.isOverwriteEnabled())
			{
				gfx.fillRect(caretX,y + height - 1,
					caretWidth,1);
			}
			else
			{
				gfx.drawRect(caretX,y,caretWidth - 1,height - 1);
			}
		}
	}
}




/*
 * DefaultInputHandler.java - Default implementation of an input handler
 * Copyright (C) 1999 Slava Pestov
 *
 * You may use and modify this package for any purpose. Redistribution is
 * permitted, in both source and binary form, provided that this notice
 * remains intact in all source distributions of this package.
 */
package org.apache.batik.apps.svgbrowser.srcview;

import javax.swing.KeyStroke;
import java.awt.event.*;
import java.awt.Toolkit;
import java.util.Hashtable;
import java.util.StringTokenizer;

/**
 * The default input handler. It maps sequences of keystrokes into actions
 * and inserts key typed events into the text area.
 * @author Slava Pestov
 * @version $Id: DefaultInputHandler.java,v 1.18 1999/12/13 03:40:30 sp Exp $
 */
public class DefaultInputHandler extends InputHandler
{
	/**
	 * Creates a new input handler with no key bindings defined.
	 */
	public DefaultInputHandler()
	{
		bindings = currentBindings = new Hashtable();
	}

	/**
	 * Sets up the default key bindings.
	 */
	public void addDefaultKeyBindings()
	{
		addKeyBinding("BACK_SPACE",BACKSPACE);
		addKeyBinding("C+BACK_SPACE",BACKSPACE_WORD);
		addKeyBinding("DELETE",DELETE);
		addKeyBinding("C+DELETE",DELETE_WORD);

		addKeyBinding("ENTER",INSERT_BREAK);
		addKeyBinding("TAB",INSERT_TAB);

		addKeyBinding("INSERT",OVERWRITE);
		addKeyBinding("C+\\",TOGGLE_RECT);

		addKeyBinding("HOME",HOME);
		addKeyBinding("END",END);
		addKeyBinding("S+HOME",SELECT_HOME);
		addKeyBinding("S+END",SELECT_END);
		addKeyBinding("C+HOME",DOCUMENT_HOME);
		addKeyBinding("C+END",DOCUMENT_END);
		addKeyBinding("CS+HOME",SELECT_DOC_HOME);
		addKeyBinding("CS+END",SELECT_DOC_END);

		addKeyBinding("PAGE_UP",PREV_PAGE);
		addKeyBinding("PAGE_DOWN",NEXT_PAGE);
		addKeyBinding("S+PAGE_UP",SELECT_PREV_PAGE);
		addKeyBinding("S+PAGE_DOWN",SELECT_NEXT_PAGE);

		addKeyBinding("LEFT",PREV_CHAR);
		addKeyBinding("S+LEFT",SELECT_PREV_CHAR);
		addKeyBinding("C+LEFT",PREV_WORD);
		addKeyBinding("CS+LEFT",SELECT_PREV_WORD);
		addKeyBinding("RIGHT",NEXT_CHAR);
		addKeyBinding("S+RIGHT",SELECT_NEXT_CHAR);
		addKeyBinding("C+RIGHT",NEXT_WORD);
		addKeyBinding("CS+RIGHT",SELECT_NEXT_WORD);
		addKeyBinding("UP",PREV_LINE);
		addKeyBinding("S+UP",SELECT_PREV_LINE);
		addKeyBinding("DOWN",NEXT_LINE);
		addKeyBinding("S+DOWN",SELECT_NEXT_LINE);

		addKeyBinding("C+ENTER",REPEAT);
	}

	/**
	 * Adds a key binding to this input handler. The key binding is
	 * a list of white space separated key strokes of the form
	 * <i>[modifiers+]key</i> where modifier is C for Control, A for Alt,
	 * or S for Shift, and key is either a character (a-z) or a field
	 * name in the KeyEvent class prefixed with VK_ (e.g., BACK_SPACE)
	 * @param keyBinding The key binding
	 * @param action The action
	 */
	public void addKeyBinding(String keyBinding, ActionListener action)
	{
	        Hashtable current = bindings;

		StringTokenizer st = new StringTokenizer(keyBinding);
		while(st.hasMoreTokens())
		{
			KeyStroke keyStroke = parseKeyStroke(st.nextToken());
			if(keyStroke == null)
				return;

			if(st.hasMoreTokens())
			{
				Object o = current.get(keyStroke);
				if(o instanceof Hashtable)
					current = (Hashtable)o;
				else
				{
					o = new Hashtable();
					current.put(keyStroke,o);
					current = (Hashtable)o;
				}
			}
			else
				current.put(keyStroke,action);
		}
	}

	/**
	 * Removes a key binding from this input handler. This is not yet
	 * implemented.
	 * @param keyBinding The key binding
	 */
	public void removeKeyBinding(String keyBinding)
	{
		throw new InternalError("Not yet implemented");
	}

	/**
	 * Removes all key bindings from this input handler.
	 */
	public void removeAllKeyBindings()
	{
		bindings.clear();
	}

	/**
	 * Returns a copy of this input handler that shares the same
	 * key bindings. Setting key bindings in the copy will also
	 * set them in the original.
	 */
	public InputHandler copy()
	{
		return new DefaultInputHandler(this);
	}

	/**
	 * Handle a key pressed event. This will look up the binding for
	 * the key stroke and execute it.
	 */
	public void keyPressed(KeyEvent evt)
	{
		int keyCode = evt.getKeyCode();
		int modifiers = evt.getModifiers();

		if(keyCode == KeyEvent.VK_CONTROL ||
			keyCode == KeyEvent.VK_SHIFT ||
			keyCode == KeyEvent.VK_ALT ||
			keyCode == KeyEvent.VK_META)
			return;

		if((modifiers & ~KeyEvent.SHIFT_MASK) != 0
			|| evt.isActionKey()
			|| keyCode == KeyEvent.VK_BACK_SPACE
			|| keyCode == KeyEvent.VK_DELETE
			|| keyCode == KeyEvent.VK_ENTER
			|| keyCode == KeyEvent.VK_TAB
			|| keyCode == KeyEvent.VK_ESCAPE)
		{
			if(grabAction != null)
			{
				handleGrabAction(evt);
				return;
			}

			KeyStroke keyStroke = KeyStroke.getKeyStroke(keyCode,
				modifiers);
			Object o = currentBindings.get(keyStroke);
			if(o == null)
			{
				// Don't beep if the user presses some
				// key we don't know about unless a
				// prefix is active. Otherwise it will
				// beep when caps lock is pressed, etc.
				if(currentBindings != bindings)
				{
					Toolkit.getDefaultToolkit().beep();
					// F10 should be passed on, but C+e F10
					// shouldn't
					repeatCount = 0;
					repeat = false;
					evt.consume();
				}
				currentBindings = bindings;
				return;
			}
			else if(o instanceof ActionListener)
			{
				currentBindings = bindings;

				executeAction(((ActionListener)o),
					evt.getSource(),null);

				evt.consume();
				return;
			}
			else if(o instanceof Hashtable)
			{
				currentBindings = (Hashtable)o;
				evt.consume();
				return;
			}
		}
	}

	/**
	 * Handle a key typed event. This inserts the key into the text area.
	 */
	public void keyTyped(KeyEvent evt)
	{
		int modifiers = evt.getModifiers();
		char c = evt.getKeyChar();
		if(c != KeyEvent.CHAR_UNDEFINED &&
			(modifiers & KeyEvent.ALT_MASK) == 0)
		{
			if(c >= 0x20 && c != 0x7f)
			{
				KeyStroke keyStroke = KeyStroke.getKeyStroke(
					Character.toUpperCase(c));
				Object o = currentBindings.get(keyStroke);

				if(o instanceof Hashtable)
				{
					currentBindings = (Hashtable)o;
					return;
				}
				else if(o instanceof ActionListener)
				{
					currentBindings = bindings;
					executeAction((ActionListener)o,
						evt.getSource(),
						String.valueOf(c));
					return;
				}

				currentBindings = bindings;

				if(grabAction != null)
				{
					handleGrabAction(evt);
					return;
				}

				// 0-9 adds another 'digit' to the repeat number
				if(repeat && Character.isDigit(c))
				{
					repeatCount *= 10;
					repeatCount += (c - '0');
					return;
				}

				executeAction(INSERT_CHAR,evt.getSource(),
					String.valueOf(evt.getKeyChar()));

				repeatCount = 0;
				repeat = false;
			}
		}
	}

	/**
	 * Converts a string to a keystroke. The string should be of the
	 * form <i>modifiers</i>+<i>shortcut</i> where <i>modifiers</i>
	 * is any combination of A for Alt, C for Control, S for Shift
	 * or M for Meta, and <i>shortcut</i> is either a single character,
	 * or a keycode name from the <code>KeyEvent</code> class, without
	 * the <code>VK_</code> prefix.
	 * @param keyStroke A string description of the key stroke
	 */
	public static KeyStroke parseKeyStroke(String keyStroke)
	{
		if(keyStroke == null)
			return null;
		int modifiers = 0;
		int index = keyStroke.indexOf('+');
		if(index != -1)
		{
			for(int i = 0; i < index; i++)
			{
				switch(Character.toUpperCase(keyStroke
					.charAt(i)))
				{
				case 'A':
					modifiers |= InputEvent.ALT_MASK;
					break;
				case 'C':
					modifiers |= InputEvent.CTRL_MASK;
					break;
				case 'M':
					modifiers |= InputEvent.META_MASK;
					break;
				case 'S':
					modifiers |= InputEvent.SHIFT_MASK;
					break;
				}
			}
		}
		String key = keyStroke.substring(index + 1);
		if(key.length() == 1)
		{
			char ch = Character.toUpperCase(key.charAt(0));
			if(modifiers == 0)
				return KeyStroke.getKeyStroke(ch);
			else
				return KeyStroke.getKeyStroke(ch,modifiers);
		}
		else if(key.length() == 0)
		{
			System.err.println("Invalid key stroke: " + keyStroke);
			return null;
		}
		else
		{
			int ch;

			try
			{
				ch = KeyEvent.class.getField("VK_".concat(key))
					.getInt(null);
			}
			catch(Exception e)
			{
				System.err.println("Invalid key stroke: "
					+ keyStroke);
				return null;
			}

			return KeyStroke.getKeyStroke(ch,modifiers);
		}
	}

	// private members
	private Hashtable bindings;
	private Hashtable currentBindings;

	private DefaultInputHandler(DefaultInputHandler copy)
	{
		bindings = currentBindings = copy.bindings;
	}
}




/*
 * XMLTokenMarker.java - XML token marker
 * Copyright (C) 1998, 1999 Slava Pestov
 * Copyright (C) 2001 Tom Bradford
 *
 * You may use and modify this package for any purpose. Redistribution is
 * permitted, in both source and binary form, provided that this notice
 * remains intact in all source distributions of this package.
 */
package org.apache.batik.apps.svgbrowser.srcview;

import javax.swing.text.Segment;

/**
 * XML Token Marker Rewrite
 *
 * @author Tom Bradford
 * @version $Id: XMLTokenMarker.java,v 1.5 2001/07/29 20:45:43 tom Exp $
 */
public class XMLTokenMarker extends TokenMarker {
   public XMLTokenMarker() {
   }
   
   public byte markTokensImpl(byte token, Segment line, int lineIndex) {
      char[] array = line.array;
      int offset = line.offset;
      int lastOffset = offset;
      int length = line.count + offset;
      
      // Ugly hack to handle multi-line tags
      boolean sk1 = token == Token.KEYWORD1;
      
      for ( int i = offset; i < length; i++ ) {
         int ip1 = i+1;
         char c = array[i];
         switch ( token ) {
            case Token.NULL: // text
               switch ( c ) {
                  case '<':
                     addToken(i-lastOffset, token);
                     lastOffset = i;
                     if ( SyntaxUtilities.regionMatches(false, line, ip1, "!--") ) {
                        i += 3;
                        token = Token.COMMENT1;
                     }
                     else if ( array[ip1] == '!' ) {
                        i += 1;
                        token = Token.COMMENT2;
                     }
                     else if ( array[ip1] == '?' ) {
                        i += 1;
                        token = Token.KEYWORD3;
                     }
                     else
                        token = Token.KEYWORD1;
                     break;
                     
                  case '&':
                     addToken(i - lastOffset, token);
                     lastOffset = i;
                     token = Token.LABEL;
                     break;
               }
               break;
               
            case Token.KEYWORD1: // tag
               switch ( c ) {
                  case '>':
                     addToken(ip1-lastOffset, token);
                     lastOffset = ip1;
                     token = Token.NULL;
                     sk1 = false;
                     break;
                     
                  case ' ':
                  case '\t':
                     addToken(i-lastOffset, token);
                     lastOffset = i;
                     token = Token.KEYWORD2;
                     sk1 = false;
                     break;
                     
                  default:
                     if ( sk1 ) {
                        token = Token.KEYWORD2;
                        sk1 = false;
                     }
                     break;
               }
               break;

            case Token.KEYWORD2: // attribute
               switch ( c ) {
                   case '>':
                     addToken(ip1-lastOffset, token);
                     lastOffset = ip1;
                     token = Token.NULL;
                     break;
                    
                  case '/':
                     addToken(i-lastOffset, token);
                     lastOffset = i;
                     token = Token.KEYWORD1;
                     break;
                     
                  case '=':
                     addToken(i-lastOffset, token);
                     lastOffset = i;
                     token = Token.OPERATOR;
               }
               break;
               
            case Token.OPERATOR: // equal for attribute
               switch ( c ) {
                  case '\"':
                  case '\'':
                     addToken(i-lastOffset, token);
                     lastOffset = i;
                     if ( c == '\"' )
                        token = Token.LITERAL1;
                     else
                        token = Token.LITERAL2;
                     break;
               }
               break;
               
            case Token.LITERAL1:
            case Token.LITERAL2: // strings
               if ( ( token == Token.LITERAL1 && c == '\"' )
                 || ( token == Token.LITERAL2 && c == '\'' ) ) {
                  addToken(ip1-lastOffset, token);
                  lastOffset = ip1;
                  token = Token.KEYWORD1;
               }
               break;
            
            case Token.LABEL: // entity
               if ( c == ';' ) {
                  addToken(ip1-lastOffset, token);
                  lastOffset = ip1;
                  token = Token.NULL;
                  break;
               }
               break;
               
            case Token.COMMENT1: // Inside a comment
               if ( SyntaxUtilities.regionMatches(false, line, i, "-->") ) {
                  addToken((i+3)-lastOffset, token);
                  lastOffset = i+3;
                  token = Token.NULL;
               }
               break;

            case Token.COMMENT2: // Inside a declaration
               if ( SyntaxUtilities.regionMatches(false, line, i, ">") ) {
                  addToken(ip1-lastOffset, token);
                  lastOffset = ip1;
                  token = Token.NULL;
               }
               break;

            case Token.KEYWORD3: // Inside a processor instruction
               if ( SyntaxUtilities.regionMatches(false, line, i, "?>") ) {
                  addToken((i+2)-lastOffset, token);
                  lastOffset = i+2;
                  token = Token.NULL;
               }
               break;
               
            default:
               throw new InternalError("Invalid state: " + token);
         }
      }
      
      switch ( token ) {
         case Token.LABEL:
            addToken(length-lastOffset, Token.INVALID);
            token = Token.NULL;
            break;
            
         default:
            addToken(length-lastOffset, token);
            break;
      }
      
      return token;
   }
}






/*
 * TextAreaDefaults.java - Encapsulates default values for various settings
 * Copyright (C) 1999 Slava Pestov
 *
 * You may use and modify this package for any purpose. Redistribution is
 * permitted, in both source and binary form, provided that this notice
 * remains intact in all source distributions of this package.
 */
package org.apache.batik.apps.svgbrowser.srcview;

import javax.swing.JPopupMenu;
import java.awt.Color;

/**
 * Encapsulates default settings for a text area. This can be passed
 * to the constructor once the necessary fields have been filled out.
 * The advantage of doing this over calling lots of set() methods after
 * creating the text area is that this method is faster.
 */
public class TextAreaDefaults
{
	private static TextAreaDefaults DEFAULTS;

	public InputHandler inputHandler;
	public SyntaxDocument document;
	public boolean editable;

	public boolean caretVisible;
	public boolean caretBlinks;
	public boolean blockCaret;
	public int electricScroll;

	public int cols;
	public int rows;
	public SyntaxStyle[] styles;
	public Color caretColor;
	public Color selectionColor;
	public Color lineHighlightColor;
	public boolean lineHighlight;
	public Color bracketHighlightColor;
	public boolean bracketHighlight;
	public Color eolMarkerColor;
	public boolean eolMarkers;
	public boolean paintInvalid;

	public JPopupMenu popup;

	/**
	 * Returns a new TextAreaDefaults object with the default values filled
	 * in.
	 */
	public static TextAreaDefaults getDefaults()
	{
		if(DEFAULTS == null)
		{
			DEFAULTS = new TextAreaDefaults();

			DEFAULTS.inputHandler = new DefaultInputHandler();
			DEFAULTS.inputHandler.addDefaultKeyBindings();
			DEFAULTS.document = new SyntaxDocument();
			DEFAULTS.editable = true;

			DEFAULTS.caretVisible = true;
			DEFAULTS.caretBlinks = true;
			DEFAULTS.electricScroll = 3;

			DEFAULTS.cols = 80;
			DEFAULTS.rows = 25;
			DEFAULTS.styles = SyntaxUtilities.getDefaultSyntaxStyles();
			DEFAULTS.caretColor = Color.red;
			DEFAULTS.selectionColor = new Color(0xccccff);
			DEFAULTS.lineHighlightColor = new Color(0xe0e0e0);
			DEFAULTS.lineHighlight = true;
			DEFAULTS.bracketHighlightColor = Color.black;
			DEFAULTS.bracketHighlight = true;
			DEFAULTS.eolMarkerColor = new Color(0x009999);
			DEFAULTS.eolMarkers = true;
			DEFAULTS.paintInvalid = true;
		}

		return DEFAULTS;
	}
}




package org.apache.batik.apps.svgbrowser.srcview;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.DefaultFocusTraversalPolicy;
import java.awt.Dimension;
import java.awt.FocusTraversalPolicy;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.ResourceBundle;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JDialog;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenuBar;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.JToggleButton;
import javax.swing.JToolBar;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.event.CaretEvent;
import javax.swing.event.CaretListener;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.filechooser.FileFilter;

import org.apache.batik.apps.svgbrowser.AboutDialog;
import org.apache.batik.apps.svgbrowser.Application;
import org.apache.batik.swing.svg.SVGUserAgent;
import org.apache.batik.util.gui.ErrorConsole;
import org.apache.batik.util.gui.resource.ActionMap;
import org.apache.batik.util.gui.resource.ButtonFactory;
import org.apache.batik.util.gui.resource.MenuFactory;
import org.apache.batik.util.gui.resource.MissingListenerException;
import org.apache.batik.util.gui.resource.ResourceManager;

public class SourceViewFrame extends JFrame implements ActionMap {

	public static final String RESOURCES = "org.apache.batik.apps.svgbrowser.srcview.resources.SourceViewFrame";

	// The action names
	public static final String SAVE_AS_ACTION = "SaveAsAction";

	public static final String CLOSE_ACTION = "CloseAction";

	public static final String UNDO_ACTION = "UndoAction";

	public static final String REDO_ACTION = "RedoAction";

	public static final String CUT_ACTION = "CutAction";

	public static final String COPY_ACTION = "CopyAction";

	public static final String PASTE_ACTION = "PasteAction";

	public static final String DELETE_ACTION = "DeleteAction";

	public static final String SELECT_ALL_ACTION = "SelectAllAction";

	public static final String FIND_ACTION = "FindAction";

	public static final String FIND_CLOSE_ACTION = "FindCloseAction";

	public static final String FIND_AGAIN_ACTION = "FindAgainAction";

	public static final String FIND_PREVIOUS_ACTION = "FindPreviousAction";

	public static final String HIGHLIGHT_ALL_ACTION = "HighlightAllAction";

	public static final String GOTO_LINE_ACTION = "GotoLineAction";

	public static final String TEXT_SIZE_INCREASE_ACTION = "TextSizeIncreaseAction";

	public static final String TEXT_SIZE_DECREASE_ACTION = "TextSizeDecreaseAction";

	public static final String TEXT_SIZE_NORMAL_ACTION = "TextSizeNormalAction";

	public static final String SYNTAX_HIGHLIGHTING_ACTION = "SyntaxHighlightingAction";

	public static final String ABOUT_ACTION = "AboutAction";

	protected static final float[] FONT_SIZES = { 6, 8, 10, 11, 12, 14, 18, 28,
			36, 72 };

	/**
	 * The resource bundle
	 */
	protected static ResourceBundle bundle;

	/**
	 * The resource manager
	 */
	protected static ResourceManager resources;
	static {
		bundle = ResourceBundle.getBundle(RESOURCES, Locale.getDefault());
		resources = new ResourceManager(bundle);
	}

	/**
	 * The SVG user agent.
	 */
	protected SVGUserAgent userAgent;

	/**
	 * The current application.
	 */
	protected Application application;

	/**
	 * The syntax highlighted text area
	 */
	protected JEditTextArea textArea;

	/**
	 * TokenMarker used by syntax highlighted text area to tokenize text
	 */
	protected TokenMarker tokenMarker;

	/**
	 * The current save path.
	 */
	protected File currentSavePath = new File("");

	/**
	 * The find bar.
	 */
	protected JToolBar findbar;

	/**
	 * Label to display status messages in the find bar
	 */
	protected FindBarMessage findbarMessage;

	/**
	 * The status bar.
	 */
	protected StatusBar statusBar;

	/**
	 * The current font size index (into the array FONT_SIZES)
	 */
	protected int fontSizeIndex;

	/**
	 * The default font size index (into the array FONT_SIZES)
	 */
	protected final int defaultFontSizeIndex = 4;

	/**
	 * Creates a new source viewer frame.
	 */
	public SourceViewFrame(Application app, SVGUserAgent agt)
			throws MissingResourceException {
		application = app;
		userAgent = agt;

		listeners.put(SAVE_AS_ACTION, new SaveAsAction());
		listeners.put(CLOSE_ACTION, new CloseAction());
		listeners.put(UNDO_ACTION, new UndoAction());
		listeners.put(REDO_ACTION, new RedoAction());
		listeners.put(CUT_ACTION, new CutAction());
		listeners.put(COPY_ACTION, new CopyAction());
		listeners.put(PASTE_ACTION, new PasteAction());
		listeners.put(DELETE_ACTION, new DeleteAction());
		listeners.put(SELECT_ALL_ACTION, new SelectAllAction());
		listeners.put(FIND_ACTION, new FindAction());
		listeners.put(FIND_CLOSE_ACTION, new FindCloseAction());
		listeners.put(FIND_AGAIN_ACTION, new FindAgainAction());
		listeners.put(FIND_PREVIOUS_ACTION, new FindPreviousAction());
		listeners.put(HIGHLIGHT_ALL_ACTION, new HighlightAllAction());
		listeners.put(GOTO_LINE_ACTION, new GotoLineAction());
		listeners.put(TEXT_SIZE_INCREASE_ACTION, new TextSizeIncreaseAction());
		listeners.put(TEXT_SIZE_DECREASE_ACTION, new TextSizeDecreaseAction());
		listeners.put(TEXT_SIZE_NORMAL_ACTION, new TextSizeNormalAction());
		listeners.put(SYNTAX_HIGHLIGHTING_ACTION,
				new SyntaxHighlightingAction());
		listeners.put(ABOUT_ACTION, new AboutAction());

		// Create the menu
		MenuFactory mf = new MenuFactory(bundle, this);

		// TODO:Remove this and use specialized version (commented out below)
		JMenuBar mb = mf.createJMenuBar("MenuBar");
		// JMenuBar mb = mf.createJMenuBar("MenuBar", application
		// .getUISpecialization());
		setJMenuBar(mb);

		// Create the central panel
		JPanel center = new JPanel(new BorderLayout());
		getContentPane().add(center, BorderLayout.CENTER);

		// Create syntax-highlighted text area
		textArea = new JEditTextArea();
		tokenMarker = new XMLTokenMarker();
		textArea.setTokenMarker(tokenMarker);
		fontSizeIndex = defaultFontSizeIndex;
		TextAreaPainter painter = textArea.getPainter();
		painter.setFont(new Font("Monospaced", Font.PLAIN,
				(int) (FONT_SIZES[fontSizeIndex])));
		textArea.addCaretListener(new CaretListener() {
			public void caretUpdate(CaretEvent e) {
				JEditTextArea a = (JEditTextArea) e.getSource();
				int row = a.getCaretLine() + 1;
				int col = a.getCaretPosition() - a.getLineStartOffset(row - 1)
						+ 1;
				statusBar.setPosition(row, col);
			}
		});
		center.add(textArea);

		// Create find bar (initially invisible)
		ButtonFactory bf = new ButtonFactory(bundle, this);
		findbar = new JToolBar();
		findbar.setVisible(false);
		findbar.setFloatable(false);
		findbar.add(bf.createJToolbarButton("FindBarClose"));
		findbar
				.add(new JLabel(resources.getString("FindBar.label.find")
						+ ": "));
		final JTextField findText = new JTextField(20);
		JPanel p = new JPanel();
		p.setOpaque(false);
		p.add(findText);
		p.setMinimumSize(p.getPreferredSize());
		p.setMaximumSize(p.getPreferredSize());
		findbar.add(p);
		final JButton next = bf.createJToolbarButton("FindBarNext");
		next.setEnabled(false);
		findbar.add(next);
		final JButton previous = bf.createJToolbarButton("FindBarPrevious");
		previous.setEnabled(false);
		findbar.add(previous);
		final JToggleButton highlightAll = bf
				.createJToolbarToggleButton("FindBarHighlightAll");
		highlightAll.setEnabled(false);
		findbar.add(highlightAll);
		JCheckBox matchCase = bf.createJCheckBox("FindBarMatchCase");
		matchCase.setOpaque(false);
		findbar.add(matchCase);
		findbarMessage = new FindBarMessage();
		findbar.add(findbarMessage);
		findText.getDocument().addDocumentListener(new DocumentListener() {
			private final Color NOT_FOUND_BACKGROUND = new Color(255, 128, 128);

			private final Color DEFAULT_BACKGROUND = findText.getBackground();

			public void changedUpdate(DocumentEvent e) {
				update();
			}

			public void insertUpdate(DocumentEvent e) {
				update();
			}

			public void removeUpdate(DocumentEvent e) {
				update();
			}

			private void update() {
				String str = findText.getText();
				boolean enabled = !str.equals("");
				next.setEnabled(enabled);
				previous.setEnabled(enabled);
				highlightAll.setEnabled(enabled);
				if (enabled) {
					if (find(str, DIRECTION_DOWN, false)) {
						findText.setBackground(DEFAULT_BACKGROUND);
					} else {
						findText.setBackground(NOT_FOUND_BACKGROUND);
					}
				} else {
					findbarMessage.setMessage(FindBarMessage.NONE);
					findText.setBackground(UIManager
							.getColor("TextField.background"));
				}
			}
		});
		center.add(findbar, BorderLayout.SOUTH);

		// Create status bar
		statusBar = new StatusBar();
		getContentPane().add(statusBar, BorderLayout.SOUTH);
	}

	public void setVisible(boolean visible) {
		super.setVisible(visible);

		if (visible) {
			// Set focus on the text area
			textArea.requestFocus();
		}
	}

	public void setText(String text) {
		textArea.setText(text);
	}

	public String getText() {
		return textArea.getText();
	}

	public void select(int start, int end) {
		textArea.select(start, end);
	}

	protected static ImageIcon notFoundIcon, continueFromTopIcon, continueFromBottomIcon;

	protected static String notFoundStr, continueFromTopStr, continueFromBottomStr;

	static {
		notFoundStr = resources.getString("FindBarNotFound.text");
		notFoundIcon = new ImageIcon(SourceViewFrame.class
				.getResource(resources.getString("FindBarNotFound.icon")));
		continueFromTopStr = resources.getString("FindBarContinueFromTop.text");
		continueFromTopIcon = new ImageIcon(
				SourceViewFrame.class.getResource(resources
						.getString("FindBarContinueFromTop.icon")));
		continueFromBottomStr = resources.getString("FindBarContinueFromBottom.text");
		continueFromBottomIcon = new ImageIcon(
				SourceViewFrame.class.getResource(resources
						.getString("FindBarContinueFromBottom.icon")));
	}

	protected class FindBarMessage extends JLabel {
		public static final int NONE = 0, NOT_FOUND = 1, CONTINUE_FROM_TOP = 2,
				CONTINUE_FROM_BOTTOM = 3;

		public void setMessage(int type) {
			switch (type) {
			case NOT_FOUND:
				setIcon(notFoundIcon);
				setText(notFoundStr);
				break;
			case CONTINUE_FROM_TOP:
				setIcon(continueFromTopIcon);
				setText(continueFromTopStr);
				break;
			case NONE:
			default:
				setIcon(null);
				setText("");
				break;
			}
		}
	}

	/**
	 * Save the document as a different file
	 */
	public class SaveAsAction extends AbstractAction {
		public void actionPerformed(ActionEvent e) {
			JFileChooser fileChooser;
			fileChooser = new JFileChooser(
					currentSavePath.isAbsolute() ? currentSavePath
							: currentSavePath.getAbsoluteFile());
			fileChooser.setDialogTitle(resources.getString("SaveAs.title"));
			fileChooser.setFileHidingEnabled(false);
			fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
			fileChooser.addChoosableFileFilter(new FileFilter() {
				public boolean accept(File f) {
					if (f == null) {
						return false;
					}
					if (f.isDirectory()) {
						return true;
					}
					String fileName = f.getName().toLowerCase();
					return fileName.endsWith(".svg");
				}

				public String getDescription() {
					return "SVG Document";
				}
			});

			int choice = fileChooser.showSaveDialog(SourceViewFrame.this);
			if (choice != JFileChooser.APPROVE_OPTION)
				return;

			final File f = fileChooser.getSelectedFile();

			statusBar.setMessage(resources.getString("Message.saveAs"));
			currentSavePath = f;
			OutputStreamWriter w = null;
			try {
				OutputStream tos = null;
				tos = new FileOutputStream(f);
				tos = new BufferedOutputStream(tos);
				w = new OutputStreamWriter(tos, "utf-8");
			} catch (Exception ex) {
				userAgent.displayError(ex);
				return;
			}

			final OutputStreamWriter writer = w;

			final Runnable doneRun = new Runnable() {
				public void run() {
					String doneStr = resources.getString("Message.done");
					statusBar.setMessage(doneStr);
				}
			};

			try {
				writer.write(textArea.getText());
				writer.close();

				SwingUtilities.invokeLater(doneRun);
			} catch (Exception ex) {
				userAgent.displayError(ex);
			}
		}
	}

	/**
	 * Closes the source viewer
	 */
	public class CloseAction extends AbstractAction {
		public void actionPerformed(ActionEvent e) {
			dispose();
		}
	}

	/**
	 * Undo last action
	 */
	public class UndoAction extends AbstractAction {
		public void actionPerformed(ActionEvent e) {

		}
	}

	/**
	 * Redo last undone action
	 */
	public class RedoAction extends AbstractAction {
		public void actionPerformed(ActionEvent e) {

		}
	}

	/**
	 * Cut selected text
	 */
	public class CutAction extends AbstractAction {
		public void actionPerformed(ActionEvent e) {
			textArea.cut();
		}
	}

	/**
	 * Copy selected text
	 */
	public class CopyAction extends AbstractAction {
		public void actionPerformed(ActionEvent e) {
			textArea.copy();
		}
	}

	/**
	 * Paste copied text
	 */
	public class PasteAction extends AbstractAction {
		public void actionPerformed(ActionEvent e) {
			textArea.paste();
		}
	}

	/**
	 * Delete selected text
	 */
	public class DeleteAction extends AbstractAction {
		public void actionPerformed(ActionEvent e) {
		}
	}

	/**
	 * Select all text
	 */
	public class SelectAllAction extends AbstractAction {
		public void actionPerformed(ActionEvent e) {
			textArea.selectAll();
		}
	}

	/**
	 * Displays the find bar if not already visible
	 */
	public class FindAction extends AbstractAction {
		public void actionPerformed(ActionEvent e) {
			if (!findbar.isVisible()) {
				findbar.setVisible(true);
			}
		}
	}

	/**
	 * Closes the find bar if visible
	 */
	public class FindCloseAction extends AbstractAction {
		public void actionPerformed(ActionEvent e) {
			if (findbar.isVisible()) {
				findbar.setVisible(false);
			}
		}
	}

	/**
	 * Find the string in the text specified using the Find action
	 */
	public class FindAgainAction extends AbstractAction {
		public void actionPerformed(ActionEvent e) {
			if (!findbar.isVisible()) {
				findbar.setVisible(true);
			} else {
				find(currentPhrase, DIRECTION_DOWN, true);
			}
		}
	}

	/**
	 * Find the string in the text specified using the Find action
	 */
	public class FindPreviousAction extends AbstractAction {
		public void actionPerformed(ActionEvent e) {
			if (!findbar.isVisible()) {
				findbar.setVisible(true);
			} else {
				find(currentPhrase, DIRECTION_UP, true);
			}
		}
	}

	/**
	 * Highlight all occurrences of the search phrase in the text
	 */
	public class HighlightAllAction extends AbstractAction {
		public void actionPerformed(ActionEvent e) {
		}
	}

	private String currentPhrase;

	private int currentOffset = -1;

	private static final int DIRECTION_UP = -1, DIRECTION_DOWN = 1;

	/**
	 * Helper function to search for a phrase in the text
	 * 
	 * @param currentPhrase
	 *            search string
	 * @param direction
	 *            whether to search downward or upward
	 * @return true is search string found, false otherwise
	 */
	private boolean find(String phrase, int direction, boolean next) {
		currentPhrase = phrase;
		boolean found = false;
		boolean wrap = false;

		String text = textArea.getText();

		int offset;
		switch (direction) {
		case DIRECTION_UP:
			offset = text.lastIndexOf(currentPhrase, currentOffset
					- (next ? 1 : 0));
			break;
		case DIRECTION_DOWN:
		default:
			offset = text
					.indexOf(currentPhrase, currentOffset + (next ? 1 : 0));
			break;
		}
		if (offset < 0) { // Not found, wrap around and search again
			wrap = true;
			switch (direction) {
			case DIRECTION_UP:
				offset = text.lastIndexOf(currentPhrase, text.length());
				break;
			case DIRECTION_DOWN:
			default:
				offset = text.indexOf(currentPhrase, 0);
				break;
			}
		}
		found = offset >= 0;

		if (found) {
			currentOffset = offset;
			textArea.select(currentOffset, currentOffset
					+ currentPhrase.length());
		}

		if (!found) {
			findbarMessage.setMessage(FindBarMessage.NOT_FOUND);
		} else if (wrap) {
			switch (direction) {
			case DIRECTION_UP:
				findbarMessage.setMessage(FindBarMessage.CONTINUE_FROM_BOTTOM);
				break;
			case DIRECTION_DOWN:
			default:
				findbarMessage.setMessage(FindBarMessage.CONTINUE_FROM_TOP);
				break;
			}
		} else {
			findbarMessage.setMessage(FindBarMessage.NONE);
		}
		return found;
	}

	/**
	 * Goto a particular line
	 */
	public class GotoLineAction extends AbstractAction {
		public void actionPerformed(ActionEvent e) {
			SwingUtilities.invokeLater(new Runnable() {
				public void run() {
					GotoLineDialog gld = new GotoLineDialog(
							SourceViewFrame.this, textArea.getLineCount());
					gld.setVisible(true);
					int n = gld.getLineNumber();
					if (n > 0) {
						gotoLine(n);
					}
				}
			});
		}
	}

	/**
	 * Helper function to adjust caret position and scroll viewport
	 * 
	 * @param n
	 *            line number of the new caret position
	 */
	private void gotoLine(int n) {
		textArea.setCaretPosition(textArea.getLineStartOffset(n - 1));
		textArea.scrollToCaret();
	}

	/**
	 * Increase text size
	 */
	public class TextSizeIncreaseAction extends AbstractAction {
		public void actionPerformed(ActionEvent e) {
			if (fontSizeIndex < FONT_SIZES.length - 1) {
				TextAreaPainter painter = textArea.getPainter();
				painter.setFont(painter.getFont().deriveFont(
						FONT_SIZES[++fontSizeIndex]));
			}
		}
	}

	/**
	 * Decrease text size
	 */
	public class TextSizeDecreaseAction extends AbstractAction {
		public void actionPerformed(ActionEvent e) {
			if (fontSizeIndex > 0) {
				TextAreaPainter painter = textArea.getPainter();
				painter.setFont(painter.getFont().deriveFont(
						FONT_SIZES[--fontSizeIndex]));
			}
		}
	}

	/**
	 * Set text size to default value
	 */
	public class TextSizeNormalAction extends AbstractAction {
		public void actionPerformed(ActionEvent e) {
			TextAreaPainter painter = textArea.getPainter();
			painter.setFont(painter.getFont().deriveFont(
					FONT_SIZES[fontSizeIndex = defaultFontSizeIndex]));
		}
	}

	/**
	 * Toggle syntax highlighting
	 */
	public class SyntaxHighlightingAction extends AbstractAction {
		public void actionPerformed(ActionEvent e) {
			textArea
					.setTokenMarker(textArea.getTokenMarker() == null ? tokenMarker
							: null);
			textArea.repaint();
		}
	}

	/**
	 * To show the about dialog
	 */
	public class AboutAction extends AbstractAction {
		public void actionPerformed(ActionEvent e) {
			AboutDialog dlg = new AboutDialog(SourceViewFrame.this);
			// Work around pack() bug on some platforms
			dlg.setSize(dlg.getPreferredSize());
			dlg.setLocationRelativeTo(SourceViewFrame.this);
			dlg.setVisible(true);
			dlg.toFront();
		}
	}

	/**
	 * The map that contains the action listeners
	 */
	protected Map listeners = new HashMap();

	/**
	 * Returns the action associated with the given string or null on error
	 * 
	 * @param key
	 *            the key mapped with the action to get
	 * @throws MissingListenerException
	 *             if the action is not found
	 */
	public Action getAction(String key) throws MissingListenerException {
		Action result = (Action) listeners.get(key);
		if (result == null) {
			throw new MissingListenerException("Can't find action.", RESOURCES,
					key);
		}
		return result;
	}

	private class GotoLineDialog extends JDialog implements ActionListener,
			DocumentListener {

		private JTextField textField;

		private JButton okButton, cancelButton;

		private JLabel errorMessage;

		private int totalLines;

		private int lineNumber = -1;

		public GotoLineDialog(JFrame owner, int totalLines) {
			super(owner, resources.getString("GotoLine.title"), true);
			this.totalLines = totalLines;

			JPanel content = new JPanel(new BorderLayout());
			content.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
			content.setPreferredSize(new Dimension(300, 120));
			getContentPane().add(content);

			Box input = new Box(BoxLayout.Y_AXIS);
			content.add(input, BorderLayout.NORTH);

			String str = resources.getString("GotoLine.label.enterLineNumber");
			str = str.replace("{0}", "" + totalLines);
			JLabel label = new JLabel(str);
			input.add(label);

			textField = new JTextField(120);
			textField.getDocument().addDocumentListener(this);
			input.add(textField);

			errorMessage = new JLabel();
			input.add(errorMessage);

			Box buttons = new Box(BoxLayout.X_AXIS);
			content.add(buttons, BorderLayout.SOUTH);

			buttons.add(Box.createHorizontalGlue());

			okButton = new JButton(resources.getString("GotoLine.button.ok"));
			okButton.setEnabled(false);
			okButton.addActionListener(this);
			buttons.add(okButton);

			buttons.add(Box.createHorizontalStrut(5));

			cancelButton = new JButton(resources
					.getString("GotoLine.button.cancel"));
			cancelButton.addActionListener(this);
			buttons.add(cancelButton);

			pack();
			setLocationRelativeTo(getParent());
		}

		public int getLineNumber() {
			return lineNumber;
		}

		public void actionPerformed(ActionEvent e) {
			if (e.getSource() == okButton) {
				lineNumber = Integer.parseInt(textField.getText());
				dispose();
			} else if (e.getSource() == cancelButton) {
				dispose();
			}
		}

		public void changedUpdate(DocumentEvent e) {
			check();
		}

		public void insertUpdate(DocumentEvent e) {
			check();
		}

		public void removeUpdate(DocumentEvent e) {
			check();
		}

		private void check() {
			boolean disabled = false;
			String error = "";
			try {
				String text = textField.getText();
				if (text == null || text.trim().equals("")) {
					disabled = true;
				} else {
					int n = Integer.parseInt(text);
					if (n < 1 || n > totalLines) {
						disabled = true;
						error = "Number out of range";
					}
				}
			} catch (NumberFormatException e) {
				disabled = true;
				error = "Not a number";
			}
			okButton.setEnabled(!disabled);
			errorMessage.setText(error);
		}
	}

	public static void main(String[] args) {
		// try {
		// UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
		// } catch (Exception e) {
		// e.printStackTrace();
		// }

		SourceViewFrame svf = new SourceViewFrame(null, null);
		svf.setSize(700, 500);
		svf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		svf.setVisible(true);
	}
}




/*
 * SyntaxStyle.java - A simple text style class
 * Copyright (C) 1999 Slava Pestov
 *
 * You may use and modify this package for any purpose. Redistribution is
 * permitted, in both source and binary form, provided that this notice
 * remains intact in all source distributions of this package.
 */
package org.apache.batik.apps.svgbrowser.srcview;

import java.awt.*;
import java.util.StringTokenizer;

/**
 * A simple text style class. It can specify the color, italic flag,
 * and bold flag of a run of text.
 * @author Slava Pestov
 * @version $Id: SyntaxStyle.java,v 1.6 1999/12/13 03:40:30 sp Exp $
 */
public class SyntaxStyle
{
	/**
	 * Creates a new SyntaxStyle.
	 * @param color The text color
	 * @param italic True if the text should be italics
	 * @param bold True if the text should be bold
	 */
	public SyntaxStyle(Color color, boolean italic, boolean bold)
	{
		this.color = color;
		this.italic = italic;
		this.bold = bold;
	}

	/**
	 * Returns the color specified in this style.
	 */
	public Color getColor()
	{
		return color;
	}

	/**
	 * Returns true if no font styles are enabled.
	 */
	public boolean isPlain()
	{
		return !(bold || italic);
	}

	/**
	 * Returns true if italics is enabled for this style.
	 */
	public boolean isItalic()
	{
		return italic;
	}

	/**
	 * Returns true if boldface is enabled for this style.
	 */
	public boolean isBold()
	{
		return bold;
	}

	/**
	 * Returns the specified font, but with the style's bold and
	 * italic flags applied.
	 */
	public Font getStyledFont(Font font)
	{
		if(font == null)
			throw new NullPointerException("font param must not"
				+ " be null");
		if(font.equals(lastFont))
			return lastStyledFont;
		lastFont = font;
		lastStyledFont = new Font(font.getFamily(),
			(bold ? Font.BOLD : 0)
			| (italic ? Font.ITALIC : 0),
			font.getSize());
		return lastStyledFont;
	}

	/**
	 * Returns the font metrics for the styled font.
	 */
	public FontMetrics getFontMetrics(Font font)
	{
		if(font == null)
			throw new NullPointerException("font param must not"
				+ " be null");
		if(font.equals(lastFont) && fontMetrics != null)
			return fontMetrics;
		lastFont = font;
		lastStyledFont = new Font(font.getFamily(),
			(bold ? Font.BOLD : 0)
			| (italic ? Font.ITALIC : 0),
			font.getSize());
		fontMetrics = Toolkit.getDefaultToolkit().getFontMetrics(
			lastStyledFont);
		return fontMetrics;
	}

	/**
	 * Sets the foreground color and font of the specified graphics
	 * context to that specified in this style.
	 * @param gfx The graphics context
	 * @param font The font to add the styles to
	 */
	public void setGraphicsFlags(Graphics gfx, Font font)
	{
		Font _font = getStyledFont(font);
		gfx.setFont(_font);
		gfx.setColor(color);
	}

	/**
	 * Returns a string representation of this object.
	 */
	public String toString()
	{
		return getClass().getName() + "[color=" + color +
			(italic ? ",italic" : "") +
			(bold ? ",bold" : "") + "]";
	}

	// private members
	private Color color;
	private boolean italic;
	private boolean bold;
	private Font lastFont;
	private Font lastStyledFont;
	private FontMetrics fontMetrics;
}




/*

   Licensed to the Apache Software Foundation (ASF) under one or more
   contributor license agreements.  See the NOTICE file distributed with
   this work for additional information regarding copyright ownership.
   The ASF licenses this file to You under the Apache License, Version 2.0
   (the "License"); you may not use this file except in compliance with
   the License.  You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.

 */
package org.apache.batik.apps.svgbrowser.srcview;

import java.awt.Dimension;
import java.util.Locale;
import java.util.MissingResourceException;
import java.util.ResourceBundle;

import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.border.BevelBorder;

import org.apache.batik.util.gui.resource.ResourceManager;

/**
 * This class represents a viewer status bar.
 *
 */
public class StatusBar extends JPanel {

    /**
     * The gui resources file name
     */
    protected static final String RESOURCES =
        "org.apache.batik.apps.svgbrowser.srcview.resources.StatusBarMessages";

    /**
     * The resource bundle
     */
    protected static ResourceBundle bundle;

    /**
     * The resource manager
     */
    protected static ResourceManager rManager;

    /**
     * The string to be used for "Row"
     */
    private static String rowStr;
    
    /**
     * The string to be used for "Column"
     */
    private static String colStr;
    
    static {
        bundle = ResourceBundle.getBundle(RESOURCES, Locale.getDefault());
        rManager = new ResourceManager(bundle);
    	rowStr = rManager.getString("Position.row");
    	colStr = rManager.getString("Position.column");
    }

    /**
     * The row value
     */
    protected int row;
    
    /**
     * The column value
     */
    protected int column;
    
    /**
     * The position label.
     */
    protected JLabel position;

    /**
     * The message label
     */
    protected JLabel message;

    /**
     * Creates a new status bar.
     */
    public StatusBar() throws MissingResourceException {
        setLayout(new BoxLayout(this, BoxLayout.X_AXIS));
        setBorder(BorderFactory.createBevelBorder(BevelBorder.LOWERED));

    	position = new JLabel();
        position.setPreferredSize(new Dimension(110, 16));
        add(position);

        message = new JLabel();
        add(message);
        
        add(Box.createHorizontalGlue());
    }

    /**
     * Sets the row.
     */
    public void setRow(int row) {
    	this.row = row;
    	updatePosition();
    }

    /**
     * Sets the column.
     */
    public void setColumn(int column) {
    	this.column = column;
    	updatePosition();
    }
    
    /**
     * Sets the row and column together
     */
    public void setPosition(int row, int column) {
    	this.row = row;
    	this.column = column;
    	updatePosition();
    }
    
    private void updatePosition() {
    	position.setText(rowStr + " " + row + ", " + colStr + " " + column);
    }

    /**
     * Sets the message
     * @param s the message
     */
    public void setMessage(String s) {
        message.setText(s);
    }
}




/*
 * Token.java - Generic token
 * Copyright (C) 1998, 1999 Slava Pestov
 *
 * You may use and modify this package for any purpose. Redistribution is
 * permitted, in both source and binary form, provided that this notice
 * remains intact in all source distributions of this package.
 */

package org.apache.batik.apps.svgbrowser.srcview;

/**
 * A linked list of tokens. Each token has three fields - a token
 * identifier, which is a byte value that can be looked up in the
 * array returned by <code>SyntaxDocument.getColors()</code>
 * to get a color value, a length value which is the length of the
 * token in the text, and a pointer to the next token in the list.
 *
 * @author Slava Pestov
 * @version $Id: Token.java,v 1.12 1999/12/13 03:40:30 sp Exp $
 */
public class Token
{
	/**
	 * Normal text token id. This should be used to mark
	 * normal text.
	 */
	public static final byte NULL = 0;

	/**
	 * Comment 1 token id. This can be used to mark a comment.
	 */
	public static final byte COMMENT1 = 1;

	/**
	 * Comment 2 token id. This can be used to mark a comment.
	 */
	public static final byte COMMENT2 = 2;

	
	/**
	 * Literal 1 token id. This can be used to mark a string
	 * literal (eg, C mode uses this to mark "..." literals)
	 */
	public static final byte LITERAL1 = 3;

	/**
	 * Literal 2 token id. This can be used to mark an object
	 * literal (eg, Java mode uses this to mark true, false, etc)
	 */
	public static final byte LITERAL2 = 4;

	/**
	 * Label token id. This can be used to mark labels
	 * (eg, C mode uses this to mark ...: sequences)
	 */
	public static final byte LABEL = 5;

	/**
	 * Keyword 1 token id. This can be used to mark a
	 * keyword. This should be used for general language
	 * constructs.
	 */
	public static final byte KEYWORD1 = 6;

	/**
	 * Keyword 2 token id. This can be used to mark a
	 * keyword. This should be used for preprocessor
	 * commands, or variables.
	 */
	public static final byte KEYWORD2 = 7;

	/**
	 * Keyword 3 token id. This can be used to mark a
	 * keyword. This should be used for data types.
	 */
	public static final byte KEYWORD3 = 8;

	/**
	 * Operator token id. This can be used to mark an
	 * operator. (eg, SQL mode marks +, -, etc with this
	 * token type)
	 */
	public static final byte OPERATOR = 9;

	/**
	 * Invalid token id. This can be used to mark invalid
	 * or incomplete tokens, so the user can easily spot
	 * syntax errors.
	 */
	public static final byte INVALID = 10;

	/**
	 * The total number of defined token ids.
	 */
	public static final byte ID_COUNT = 11;

	/**
	 * The first id that can be used for internal state
	 * in a token marker.
	 */
	public static final byte INTERNAL_FIRST = 100;

	/**
	 * The last id that can be used for internal state
	 * in a token marker.
	 */
	public static final byte INTERNAL_LAST = 126;

	/**
	 * The token type, that along with a length of 0
	 * marks the end of the token list.
	 */
	public static final byte END = 127;

	/**
	 * The length of this token.
	 */
	public int length;

	/**
	 * The id of this token.
	 */
	public byte id;

	/**
	 * The next token in the linked list.
	 */
	public Token next;

	/**
	 * Creates a new token.
	 * @param length The length of the token
	 * @param id The id of the token
	 */
	public Token(int length, byte id)
	{
		this.length = length;
		this.id = id;
	}

	/**
	 * Returns a string representation of this token.
	 */
	public String toString()
	{
		return "[id=" + id + ",length=" + length + "]";
	}
}




/*
 * TextUtilities.java - Utility functions used by the text area classes
 * Copyright (C) 1999 Slava Pestov
 *
 * You may use and modify this package for any purpose. Redistribution is
 * permitted, in both source and binary form, provided that this notice
 * remains intact in all source distributions of this package.
 */
package org.apache.batik.apps.svgbrowser.srcview;

import javax.swing.text.*;

/**
 * Class with several utility functions used by the text area component.
 * @author Slava Pestov
 * @version $Id: TextUtilities.java,v 1.4 1999/12/13 03:40:30 sp Exp $
 */
public class TextUtilities
{
	/**
	 * Returns the offset of the bracket matching the one at the
	 * specified offset of the document, or -1 if the bracket is
	 * unmatched (or if the character is not a bracket).
	 * @param doc The document
	 * @param offset The offset
	 * @exception BadLocationException If an out-of-bounds access
	 * was attempted on the document text
	 */
	public static int findMatchingBracket(Document doc, int offset)
		throws BadLocationException
	{
		if(doc.getLength() == 0)
			return -1;
		char c = doc.getText(offset,1).charAt(0);
		char cprime; // c` - corresponding character
		boolean direction; // true = back, false = forward

		switch(c)
		{
		case '(': cprime = ')'; direction = false; break;
		case ')': cprime = '('; direction = true; break;
		case '[': cprime = ']'; direction = false; break;
		case ']': cprime = '['; direction = true; break;
		case '{': cprime = '}'; direction = false; break;
		case '}': cprime = '{'; direction = true; break;
		default: return -1;
		}

		int count;

		// How to merge these two cases is left as an exercise
		// for the reader.

		// Go back or forward
		if(direction)
		{
			// Count is 1 initially because we have already
			// `found' one closing bracket
			count = 1;

			// Get text[0,offset-1];
			String text = doc.getText(0,offset);

			// Scan backwards
			for(int i = offset - 1; i >= 0; i--)
			{
				// If text[i] == c, we have found another
				// closing bracket, therefore we will need
				// two opening brackets to complete the
				// match.
				char x = text.charAt(i);
				if(x == c)
					count++;

				// If text[i] == cprime, we have found a
				// opening bracket, so we return i if
				// --count == 0
				else if(x == cprime)
				{
					if(--count == 0)
						return i;
				}
			}
		}
		else
		{
			// Count is 1 initially because we have already
			// `found' one opening bracket
			count = 1;

			// So we don't have to + 1 in every loop
			offset++;

			// Number of characters to check
			int len = doc.getLength() - offset;

			// Get text[offset+1,len];
			String text = doc.getText(offset,len);

			// Scan forwards
			for(int i = 0; i < len; i++)
			{
				// If text[i] == c, we have found another
				// opening bracket, therefore we will need
				// two closing brackets to complete the
				// match.
				char x = text.charAt(i);

				if(x == c)
					count++;

				// If text[i] == cprime, we have found an
				// closing bracket, so we return i if
				// --count == 0
				else if(x == cprime)
				{
					if(--count == 0)
						return i + offset;
				}
			}
		}

		// Nothing found
		return -1;
	}

	/**
	 * Locates the start of the word at the specified position.
	 * @param line The text
	 * @param pos The position
	 */
	public static int findWordStart(String line, int pos, String noWordSep)
	{
		char ch = line.charAt(pos - 1);

		if(noWordSep == null)
			noWordSep = "";
		boolean selectNoLetter = (!Character.isLetterOrDigit(ch)
			&& noWordSep.indexOf(ch) == -1);

		int wordStart = 0;
		for(int i = pos - 1; i >= 0; i--)
		{
			ch = line.charAt(i);
			if(selectNoLetter ^ (!Character.isLetterOrDigit(ch) &&
				noWordSep.indexOf(ch) == -1))
			{
				wordStart = i + 1;
				break;
			}
		}

		return wordStart;
	}

	/**
	 * Locates the end of the word at the specified position.
	 * @param line The text
	 * @param pos The position
	 */
	public static int findWordEnd(String line, int pos, String noWordSep)
	{
		char ch = line.charAt(pos);

		if(noWordSep == null)
			noWordSep = "";
		boolean selectNoLetter = (!Character.isLetterOrDigit(ch)
			&& noWordSep.indexOf(ch) == -1);

		int wordEnd = line.length();
		for(int i = pos; i < line.length(); i++)
		{
			ch = line.charAt(i);
			if(selectNoLetter ^ (!Character.isLetterOrDigit(ch) &&
				noWordSep.indexOf(ch) == -1))
			{
				wordEnd = i;
				break;
			}
		}
		return wordEnd;
	}
}




/*
 * KeywordMap.java - Fast keyword->id map
 * Copyright (C) 1998, 1999 Slava Pestov
 * Copyright (C) 1999 Mike Dillon
 *
 * You may use and modify this package for any purpose. Redistribution is
 * permitted, in both source and binary form, provided that this notice
 * remains intact in all source distributions of this package.
 */
package org.apache.batik.apps.svgbrowser.srcview;

import javax.swing.text.Segment;

/**
 * A <code>KeywordMap</code> is similar to a hashtable in that it maps keys
 * to values. However, the `keys' are Swing segments. This allows lookups of
 * text substrings without the overhead of creating a new string object.
 * <p>
 * This class is used by <code>CTokenMarker</code> to map keywords to ids.
 *
 * @author Slava Pestov, Mike Dillon
 * @version $Id: KeywordMap.java,v 1.16 1999/12/13 03:40:30 sp Exp $
 */
public class KeywordMap
{
	/**
	 * Creates a new <code>KeywordMap</code>.
	 * @param ignoreCase True if keys are case insensitive
	 */
	public KeywordMap(boolean ignoreCase)
	{
		this(ignoreCase, 52);
		this.ignoreCase = ignoreCase;
	}

	/**
	 * Creates a new <code>KeywordMap</code>.
	 * @param ignoreCase True if the keys are case insensitive
	 * @param mapLength The number of `buckets' to create.
	 * A value of 52 will give good performance for most maps.
	 */
	public KeywordMap(boolean ignoreCase, int mapLength)
	{
		this.mapLength = mapLength;
		this.ignoreCase = ignoreCase;
		map = new Keyword[mapLength];
	}

	/**
	 * Looks up a key.
	 * @param text The text segment
	 * @param offset The offset of the substring within the text segment
	 * @param length The length of the substring
	 */
	public byte lookup(Segment text, int offset, int length)
	{
		if(length == 0)
			return Token.NULL;
		Keyword k = map[getSegmentMapKey(text, offset, length)];
		while(k != null)
		{
			if(length != k.keyword.length)
			{
				k = k.next;
				continue;
			}
			if(SyntaxUtilities.regionMatches(ignoreCase,text,offset,
				k.keyword))
				return k.id;
			k = k.next;
		}
		return Token.NULL;
	}

	/**
	 * Adds a key-value mapping.
	 * @param keyword The key
	 * @Param id The value
	 */
	public void add(String keyword, byte id)
	{
		int key = getStringMapKey(keyword);
		map[key] = new Keyword(keyword.toCharArray(),id,map[key]);
	}

	/**
	 * Returns true if the keyword map is set to be case insensitive,
	 * false otherwise.
	 */
	public boolean getIgnoreCase()
	{
		return ignoreCase;
	}

	/**
	 * Sets if the keyword map should be case insensitive.
	 * @param ignoreCase True if the keyword map should be case
	 * insensitive, false otherwise
	 */
	public void setIgnoreCase(boolean ignoreCase)
	{
		this.ignoreCase = ignoreCase;
	}

	// protected members
	protected int mapLength;

	protected int getStringMapKey(String s)
	{
		return (Character.toUpperCase(s.charAt(0)) +
				Character.toUpperCase(s.charAt(s.length()-1)))
				% mapLength;
	}

	protected int getSegmentMapKey(Segment s, int off, int len)
	{
		return (Character.toUpperCase(s.array[off]) +
				Character.toUpperCase(s.array[off + len - 1]))
				% mapLength;
	}

	// private members
	class Keyword
	{
		public Keyword(char[] keyword, byte id, Keyword next)
		{
			this.keyword = keyword;
			this.id = id;
			this.next = next;
		}

		public char[] keyword;
		public byte id;
		public Keyword next;
	}

	private Keyword[] map;
	private boolean ignoreCase;
}




/*
 * SyntaxUtilities.java - Utility functions used by syntax colorizing
 * Copyright (C) 1999 Slava Pestov
 *
 * You may use and modify this package for any purpose. Redistribution is
 * permitted, in both source and binary form, provided that this notice
 * remains intact in all source distributions of this package.
 */
package org.apache.batik.apps.svgbrowser.srcview;

import javax.swing.text.*;
import java.awt.*;

/**
 * Class with several utility functions used by jEdit's syntax colorizing
 * subsystem.
 *
 * @author Slava Pestov
 * @version $Id: SyntaxUtilities.java,v 1.9 1999/12/13 03:40:30 sp Exp $
 */
public class SyntaxUtilities
{
	/**
	 * Checks if a subregion of a <code>Segment</code> is equal to a
	 * string.
	 * @param ignoreCase True if case should be ignored, false otherwise
	 * @param text The segment
	 * @param offset The offset into the segment
	 * @param match The string to match
	 */
	public static boolean regionMatches(boolean ignoreCase, Segment text,
					    int offset, String match)
	{
		int length = offset + match.length();
		char[] textArray = text.array;
		if(length > text.offset + text.count)
			return false;
		for(int i = offset, j = 0; i < length; i++, j++)
		{
			char c1 = textArray[i];
			char c2 = match.charAt(j);
			if(ignoreCase)
			{
				c1 = Character.toUpperCase(c1);
				c2 = Character.toUpperCase(c2);
			}
			if(c1 != c2)
				return false;
		}
		return true;
	}
	
	/**
	 * Checks if a subregion of a <code>Segment</code> is equal to a
	 * character array.
	 * @param ignoreCase True if case should be ignored, false otherwise
	 * @param text The segment
	 * @param offset The offset into the segment
	 * @param match The character array to match
	 */
	public static boolean regionMatches(boolean ignoreCase, Segment text,
					    int offset, char[] match)
	{
		int length = offset + match.length;
		char[] textArray = text.array;
		if(length > text.offset + text.count)
			return false;
		for(int i = offset, j = 0; i < length; i++, j++)
		{
			char c1 = textArray[i];
			char c2 = match[j];
			if(ignoreCase)
			{
				c1 = Character.toUpperCase(c1);
				c2 = Character.toUpperCase(c2);
			}
			if(c1 != c2)
				return false;
		}
		return true;
	}

	/**
	 * Returns the default style table. This can be passed to the
	 * <code>setStyles()</code> method of <code>SyntaxDocument</code>
	 * to use the default syntax styles.
	 */
	public static SyntaxStyle[] getDefaultSyntaxStyles()
	{
		SyntaxStyle[] styles = new SyntaxStyle[Token.ID_COUNT];

		styles[Token.COMMENT1] = new SyntaxStyle(Color.black,true,true);
		styles[Token.COMMENT2] = new SyntaxStyle(new Color(0x990033),true,true);
		styles[Token.KEYWORD1] = new SyntaxStyle(Color.black,false,true);
		styles[Token.KEYWORD2] = new SyntaxStyle(Color.magenta,false,true);
		styles[Token.KEYWORD3] = new SyntaxStyle(new Color(0x009600),false,false);
		styles[Token.LITERAL1] = new SyntaxStyle(new Color(0x650099),false,false);
		styles[Token.LITERAL2] = new SyntaxStyle(new Color(0x650099),false,true);
		styles[Token.LABEL] = new SyntaxStyle(new Color(0x990033),false,true);
		styles[Token.OPERATOR] = new SyntaxStyle(Color.black,false,true);
		styles[Token.INVALID] = new SyntaxStyle(Color.red,false,true);

		return styles;
	}

	/**
	 * Paints the specified line onto the graphics context. Note that this
	 * method munges the offset and count values of the segment.
	 * @param line The line segment
	 * @param tokens The token list for the line
	 * @param styles The syntax style list
	 * @param expander The tab expander used to determine tab stops. May
	 * be null
	 * @param gfx The graphics context
	 * @param x The x co-ordinate
	 * @param y The y co-ordinate
	 * @return The x co-ordinate, plus the width of the painted string
	 */
	public static int paintSyntaxLine(Segment line, Token tokens,
		SyntaxStyle[] styles, TabExpander expander, Graphics gfx,
		int x, int y)
	{
		Font defaultFont = gfx.getFont();
		Color defaultColor = gfx.getColor();

		int offset = 0;
		for(;;)
		{
			byte id = tokens.id;
			if(id == Token.END)
				break;

			int length = tokens.length;
			if(id == Token.NULL)
			{
				if(!defaultColor.equals(gfx.getColor()))
					gfx.setColor(defaultColor);
				if(!defaultFont.equals(gfx.getFont()))
					gfx.setFont(defaultFont);
			}
			else
				styles[id].setGraphicsFlags(gfx,defaultFont);

			line.count = length;
			x = Utilities.drawTabbedText(line,x,y,gfx,expander,0);
			line.offset += length;
			offset += length;

			tokens = tokens.next;
		}

		return x;
	}

	// private members
	private SyntaxUtilities() {}
}




/*
 * TokenMarker.java - Generic token marker
 * Copyright (C) 1998, 1999 Slava Pestov
 *
 * You may use and modify this package for any purpose. Redistribution is
 * permitted, in both source and binary form, provided that this notice
 * remains intact in all source distributions of this package.
 */
package org.apache.batik.apps.svgbrowser.srcview;

import javax.swing.text.Segment;
import java.util.*;

/**
 * A token marker that splits lines of text into tokens. Each token carries
 * a length field and an indentification tag that can be mapped to a color
 * for painting that token.<p>
 *
 * For performance reasons, the linked list of tokens is reused after each
 * line is tokenized. Therefore, the return value of <code>markTokens</code>
 * should only be used for immediate painting. Notably, it cannot be
 * cached.
 *
 * @author Slava Pestov
 * @version $Id: TokenMarker.java,v 1.32 1999/12/13 03:40:30 sp Exp $
 *
 * @see org.gjt.sp.jedit.syntax.Token
 */
public abstract class TokenMarker
{
	/**
	 * A wrapper for the lower-level <code>markTokensImpl</code> method
	 * that is called to split a line up into tokens.
	 * @param line The line
	 * @param lineIndex The line number
	 */
	public Token markTokens(Segment line, int lineIndex)
	{
		if(lineIndex >= length)
		{
			throw new IllegalArgumentException("Tokenizing invalid line: "
				+ lineIndex);
		}

		lastToken = null;

		LineInfo info = lineInfo[lineIndex];
		LineInfo prev;
		if(lineIndex == 0)
			prev = null;
		else
			prev = lineInfo[lineIndex - 1];

		byte oldToken = info.token;
		byte token = markTokensImpl(prev == null ?
			Token.NULL : prev.token,line,lineIndex);

		info.token = token;

		/*
		 * This is a foul hack. It stops nextLineRequested
		 * from being cleared if the same line is marked twice.
		 *
		 * Why is this necessary? It's all JEditTextArea's fault.
		 * When something is inserted into the text, firing a
		 * document event, the insertUpdate() method shifts the
		 * caret (if necessary) by the amount inserted.
		 *
		 * All caret movement is handled by the select() method,
		 * which eventually pipes the new position to scrollTo()
		 * and calls repaint().
		 *
		 * Note that at this point in time, the new line hasn't
		 * yet been painted; the caret is moved first.
		 *
		 * scrollTo() calls offsetToX(), which tokenizes the line
		 * unless it is being called on the last line painted
		 * (in which case it uses the text area's painter cached
		 * token list). What scrollTo() does next is irrelevant.
		 *
		 * After scrollTo() has done it's job, repaint() is
		 * called, and eventually we end up in paintLine(), whose
		 * job is to paint the changed line. It, too, calls
		 * markTokens().
		 *
		 * The problem was that if the line started a multiline
		 * token, the first markTokens() (done in offsetToX())
		 * would set nextLineRequested (because the line end
		 * token had changed) but the second would clear it
		 * (because the line was the same that time) and therefore
		 * paintLine() would never know that it needed to repaint
		 * subsequent lines.
		 *
		 * This bug took me ages to track down, that's why I wrote
		 * all the relevant info down so that others wouldn't
		 * duplicate it.
		 */
		 if(!(lastLine == lineIndex && nextLineRequested))
			nextLineRequested = (oldToken != token);

		lastLine = lineIndex;

		addToken(0,Token.END);

		return firstToken;
	}

	/**
	 * An abstract method that splits a line up into tokens. It
	 * should parse the line, and call <code>addToken()</code> to
	 * add syntax tokens to the token list. Then, it should return
	 * the initial token type for the next line.<p>
	 *
	 * For example if the current line contains the start of a 
	 * multiline comment that doesn't end on that line, this method
	 * should return the comment token type so that it continues on
	 * the next line.
	 *
	 * @param token The initial token type for this line
	 * @param line The line to be tokenized
	 * @param lineIndex The index of the line in the document,
	 * starting at 0
	 * @return The initial token type for the next line
	 */
	protected abstract byte markTokensImpl(byte token, Segment line,
		int lineIndex);

	/**
	 * Returns if the token marker supports tokens that span multiple
	 * lines. If this is true, the object using this token marker is
	 * required to pass all lines in the document to the
	 * <code>markTokens()</code> method (in turn).<p>
	 *
	 * The default implementation returns true; it should be overridden
	 * to return false on simpler token markers for increased speed.
	 */
	public boolean supportsMultilineTokens()
	{
		return true;
	}

	/**
	 * Informs the token marker that lines have been inserted into
	 * the document. This inserts a gap in the <code>lineInfo</code>
	 * array.
	 * @param index The first line number
	 * @param lines The number of lines 
	 */
	public void insertLines(int index, int lines)
	{
		if(lines <= 0)
			return;
		length += lines;
		ensureCapacity(length);
		int len = index + lines;
		System.arraycopy(lineInfo,index,lineInfo,len,
			lineInfo.length - len);

		for(int i = index + lines - 1; i >= index; i--)
		{
			lineInfo[i] = new LineInfo();
		}
	}
	
	/**
	 * Informs the token marker that line have been deleted from
	 * the document. This removes the lines in question from the
	 * <code>lineInfo</code> array.
	 * @param index The first line number
	 * @param lines The number of lines
	 */
	public void deleteLines(int index, int lines)
	{
		if (lines <= 0)
			return;
		int len = index + lines;
		length -= lines;
		System.arraycopy(lineInfo,len,lineInfo,
			index,lineInfo.length - len);
	}

	/**
	 * Returns the number of lines in this token marker.
	 */
	public int getLineCount()
	{
		return length;
	}

	/**
	 * Returns true if the next line should be repainted. This
	 * will return true after a line has been tokenized that starts
	 * a multiline token that continues onto the next line.
	 */
	public boolean isNextLineRequested()
	{
		return nextLineRequested;
	}

	// protected members

	/**
	 * The first token in the list. This should be used as the return
	 * value from <code>markTokens()</code>.
	 */
	protected Token firstToken;

	/**
	 * The last token in the list. New tokens are added here.
	 * This should be set to null before a new line is to be tokenized.
	 */
	protected Token lastToken;

	/**
	 * An array for storing information about lines. It is enlarged and
	 * shrunk automatically by the <code>insertLines()</code> and
	 * <code>deleteLines()</code> methods.
	 */
	protected LineInfo[] lineInfo;

	/**
	 * The number of lines in the model being tokenized. This can be
	 * less than the length of the <code>lineInfo</code> array.
	 */
	protected int length;

	/**
	 * The last tokenized line.
	 */
	protected int lastLine;

	/**
	 * True if the next line should be painted.
	 */
	protected boolean nextLineRequested;

	/**
	 * Creates a new <code>TokenMarker</code>. This DOES NOT create
	 * a lineInfo array; an initial call to <code>insertLines()</code>
	 * does that.
	 */
	protected TokenMarker()
	{
		lastLine = -1;
	}

	/**
	 * Ensures that the <code>lineInfo</code> array can contain the
	 * specified index. This enlarges it if necessary. No action is
	 * taken if the array is large enough already.<p>
	 *
	 * It should be unnecessary to call this under normal
	 * circumstances; <code>insertLine()</code> should take care of
	 * enlarging the line info array automatically.
	 *
	 * @param index The array index
	 */
	protected void ensureCapacity(int index)
	{
		if(lineInfo == null)
			lineInfo = new LineInfo[index + 1];
		else if(lineInfo.length <= index)
		{
			LineInfo[] lineInfoN = new LineInfo[(index + 1) * 2];
			System.arraycopy(lineInfo,0,lineInfoN,0,
					 lineInfo.length);
			lineInfo = lineInfoN;
		}
	}

	/**
	 * Adds a token to the token list.
	 * @param length The length of the token
	 * @param id The id of the token
	 */
	protected void addToken(int length, byte id)
	{
		if(id >= Token.INTERNAL_FIRST && id <= Token.INTERNAL_LAST)
			throw new InternalError("Invalid id: " + id);

		if(length == 0 && id != Token.END)
			return;

		if(firstToken == null)
		{
			firstToken = new Token(length,id);
			lastToken = firstToken;
		}
		else if(lastToken == null)
		{
			lastToken = firstToken;
			firstToken.length = length;
			firstToken.id = id;
		}
		else if(lastToken.next == null)
		{
			lastToken.next = new Token(length,id);
			lastToken = lastToken.next;
		}
		else
		{
			lastToken = lastToken.next;
			lastToken.length = length;
			lastToken.id = id;
		}
	}

	/**
	 * Inner class for storing information about tokenized lines.
	 */
	public class LineInfo
	{
		/**
		 * Creates a new LineInfo object with token = Token.NULL
		 * and obj = null.
		 */
		public LineInfo()
		{
		}

		/**
		 * Creates a new LineInfo object with the specified
		 * parameters.
		 */
		public LineInfo(byte token, Object obj)
		{
			this.token = token;
			this.obj = obj;
		}

		/**
		 * The id of the last token of the line.
		 */
		public byte token;

		/**
		 * This is for use by the token marker implementations
		 * themselves. It can be used to store anything that
		 * is an object and that needs to exist on a per-line
		 * basis.
		 */
		public Object obj;
	}
}




/*
 * SyntaxDocument.java - Document that can be tokenized
 * Copyright (C) 1999 Slava Pestov
 *
 * You may use and modify this package for any purpose. Redistribution is
 * permitted, in both source and binary form, provided that this notice
 * remains intact in all source distributions of this package.
 */
package org.apache.batik.apps.svgbrowser.srcview;

import javax.swing.event.*;
import javax.swing.text.*;
import javax.swing.undo.UndoableEdit;

/**
 * A document implementation that can be tokenized by the syntax highlighting
 * system.
 *
 * @author Slava Pestov
 * @version $Id: SyntaxDocument.java,v 1.14 1999/12/13 03:40:30 sp Exp $
 */
public class SyntaxDocument extends PlainDocument
{
	/**
	 * Returns the token marker that is to be used to split lines
	 * of this document up into tokens. May return null if this
	 * document is not to be colorized.
	 */
	public TokenMarker getTokenMarker()
	{
		return tokenMarker;
	}

	/**
	 * Sets the token marker that is to be used to split lines of
	 * this document up into tokens. May throw an exception if
	 * this is not supported for this type of document.
	 * @param tm The new token marker
	 */
	public void setTokenMarker(TokenMarker tm)
	{
		tokenMarker = tm;
		if(tm == null)
			return;
		tokenMarker.insertLines(0,getDefaultRootElement()
			.getElementCount());
		tokenizeLines();
	}

	/**
	 * Reparses the document, by passing all lines to the token
	 * marker. This should be called after the document is first
	 * loaded.
	 */
	public void tokenizeLines()
	{
		tokenizeLines(0,getDefaultRootElement().getElementCount());
	}

	/**
	 * Reparses the document, by passing the specified lines to the
	 * token marker. This should be called after a large quantity of
	 * text is first inserted.
	 * @param start The first line to parse
	 * @param len The number of lines, after the first one to parse
	 */
	public void tokenizeLines(int start, int len)
	{
		if(tokenMarker == null || !tokenMarker.supportsMultilineTokens())
			return;

		Segment lineSegment = new Segment();
		Element map = getDefaultRootElement();

		len += start;

		try
		{
			for(int i = start; i < len; i++)
			{
				Element lineElement = map.getElement(i);
				int lineStart = lineElement.getStartOffset();
				getText(lineStart,lineElement.getEndOffset()
					- lineStart - 1,lineSegment);
				tokenMarker.markTokens(lineSegment,i);
			}
		}
		catch(BadLocationException bl)
		{
			bl.printStackTrace();
		}
	}

	/**
	 * Starts a compound edit that can be undone in one operation.
	 * Subclasses that implement undo should override this method;
	 * this class has no undo functionality so this method is
	 * empty.
	 */
	public void beginCompoundEdit() {}

	/**
	 * Ends a compound edit that can be undone in one operation.
	 * Subclasses that implement undo should override this method;
	 * this class has no undo functionality so this method is
	 * empty.
	 */
	public void endCompoundEdit() {}

	/**
	 * Adds an undoable edit to this document's undo list. The edit
	 * should be ignored if something is currently being undone.
	 * @param edit The undoable edit
	 *
	 * @since jEdit 2.2pre1
	 */
	public void addUndoableEdit(UndoableEdit edit) {}

	// protected members
	protected TokenMarker tokenMarker;

	/**
	 * We overwrite this method to update the token marker
	 * state immediately so that any event listeners get a
	 * consistent token marker.
	 */
	protected void fireInsertUpdate(DocumentEvent evt)
	{
		if(tokenMarker != null)
		{
			DocumentEvent.ElementChange ch = evt.getChange(
				getDefaultRootElement());
			if(ch != null)
			{
				tokenMarker.insertLines(ch.getIndex() + 1,
					ch.getChildrenAdded().length -
					ch.getChildrenRemoved().length);
			}
		}

		super.fireInsertUpdate(evt);
	}
	
	/**
	 * We overwrite this method to update the token marker
	 * state immediately so that any event listeners get a
	 * consistent token marker.
	 */
	protected void fireRemoveUpdate(DocumentEvent evt)
	{
		if(tokenMarker != null)
		{
			DocumentEvent.ElementChange ch = evt.getChange(
				getDefaultRootElement());
			if(ch != null)
			{
				tokenMarker.deleteLines(ch.getIndex() + 1,
					ch.getChildrenRemoved().length -
					ch.getChildrenAdded().length);
			}
		}

		super.fireRemoveUpdate(evt);
	}
}




/*
 * JEditTextArea.java - jEdit's text component
 * Copyright (C) 1999 Slava Pestov
 *
 * You may use and modify this package for any purpose. Redistribution is
 * permitted, in both source and binary form, provided that this notice
 * remains intact in all source distributions of this package.
 */
package org.apache.batik.apps.svgbrowser.srcview;

import javax.swing.event.*;
import javax.swing.text.*;
import javax.swing.undo.*;
import javax.swing.*;
import java.awt.datatransfer.*;
import java.awt.event.*;
import java.awt.*;
import java.util.Enumeration;
import java.util.Vector;

/**
 * jEdit's text area component. It is more suited for editing program
 * source code than JEditorPane, because it drops the unnecessary features
 * (images, variable-width lines, and so on) and adds a whole bunch of
 * useful goodies such as:
 * <ul>
 * <li>More flexible key binding scheme
 * <li>Supports macro recorders
 * <li>Rectangular selection
 * <li>Bracket highlighting
 * <li>Syntax highlighting
 * <li>Command repetition
 * <li>Block caret can be enabled
 * </ul>
 * It is also faster and doesn't have as many problems. It can be used
 * in other applications; the only other part of jEdit it depends on is
 * the syntax package.<p>
 *
 * To use it in your app, treat it like any other component, for example:
 * <pre>JEditTextArea ta = new JEditTextArea();
 * ta.setTokenMarker(new JavaTokenMarker());
 * ta.setText("public class Test {\n"
 *     + "    public static void main(String[] args) {\n"
 *     + "        System.out.println(\"Hello World\");\n"
 *     + "    }\n"
 *     + "}");</pre>
 *
 * @author Slava Pestov
 * @version $Id: JEditTextArea.java,v 1.36 1999/12/13 03:40:30 sp Exp $
 */
public class JEditTextArea extends JComponent
{
	/**
	 * Adding components with this name to the text area will place
	 * them left of the horizontal scroll bar. In jEdit, the status
	 * bar is added this way.
	 */
	public static String LEFT_OF_SCROLLBAR = "los";

	/**
	 * Creates a new JEditTextArea with the default settings.
	 */
	public JEditTextArea()
	{
		this(TextAreaDefaults.getDefaults());
	}

	/**
	 * Creates a new JEditTextArea with the specified settings.
	 * @param defaults The default settings
	 */
	public JEditTextArea(TextAreaDefaults defaults)
	{
		// Enable the necessary events
		enableEvents(AWTEvent.KEY_EVENT_MASK);

		// Initialize some misc. stuff
		painter = new TextAreaPainter(this,defaults);
		documentHandler = new DocumentHandler();
		listenerList = new EventListenerList();
		caretEvent = new MutableCaretEvent();
		lineSegment = new Segment();
		bracketLine = bracketPosition = -1;
		blink = true;

		// Initialize the GUI
		setLayout(new ScrollLayout());
		add(CENTER,painter);
		add(RIGHT,vertical = new JScrollBar(JScrollBar.VERTICAL));
		add(BOTTOM,horizontal = new JScrollBar(JScrollBar.HORIZONTAL));

		// Add some event listeners
		vertical.addAdjustmentListener(new AdjustHandler());
		horizontal.addAdjustmentListener(new AdjustHandler());
		painter.addComponentListener(new ComponentHandler());
		painter.addMouseListener(new MouseHandler());
		painter.addMouseMotionListener(new DragHandler());
		addFocusListener(new FocusHandler());

		// Load the defaults
		setInputHandler(defaults.inputHandler);
		setDocument(defaults.document);
		editable = defaults.editable;
		caretVisible = defaults.caretVisible;
		caretBlinks = defaults.caretBlinks;
		electricScroll = defaults.electricScroll;

		popup = defaults.popup;

		// We don't seem to get the initial focus event?
		focusedComponent = this;
	}

	/**
	 * Returns if this component can be traversed by pressing
	 * the Tab key. This returns false.
	 */
	public final boolean isManagingFocus()
	{
		return true;
	}

	/**
	 * Returns the object responsible for painting this text area.
	 */
	public final TextAreaPainter getPainter()
	{
		return painter;
	}

	/**
	 * Returns the input handler.
	 */
	public final InputHandler getInputHandler()
	{
		return inputHandler;
	}

	/**
	 * Sets the input handler.
	 * @param inputHandler The new input handler
	 */
	public void setInputHandler(InputHandler inputHandler)
	{
		this.inputHandler = inputHandler;
	}

	/**
	 * Returns true if the caret is blinking, false otherwise.
	 */
	public final boolean isCaretBlinkEnabled()
	{
		return caretBlinks;
	}

	/**
	 * Toggles caret blinking.
	 * @param caretBlinks True if the caret should blink, false otherwise
	 */
	public void setCaretBlinkEnabled(boolean caretBlinks)
	{
		this.caretBlinks = caretBlinks;
		if(!caretBlinks)
			blink = false;

		painter.invalidateSelectedLines();
	}

	/**
	 * Returns true if the caret is visible, false otherwise.
	 */
	public final boolean isCaretVisible()
	{
		return (!caretBlinks || blink) && caretVisible;
	}

	/**
	 * Sets if the caret should be visible.
	 * @param caretVisible True if the caret should be visible, false
	 * otherwise
	 */
	public void setCaretVisible(boolean caretVisible)
	{
		this.caretVisible = caretVisible;
		blink = true;

		painter.invalidateSelectedLines();
	}

	/**
	 * Blinks the caret.
	 */
	public final void blinkCaret()
	{
		if(caretBlinks)
		{
			blink = !blink;
			painter.invalidateSelectedLines();
		}
		else
			blink = true;
	}

	/**
	 * Returns the number of lines from the top and button of the
	 * text area that are always visible.
	 */
	public final int getElectricScroll()
	{
		return electricScroll;
	}

	/**
	 * Sets the number of lines from the top and bottom of the text
	 * area that are always visible
	 * @param electricScroll The number of lines always visible from
	 * the top or bottom
	 */
	public final void setElectricScroll(int electricScroll)
	{
		this.electricScroll = electricScroll;
	}

	/**
	 * Updates the state of the scroll bars. This should be called
	 * if the number of lines in the document changes, or when the
	 * size of the text are changes.
	 */
	public void updateScrollBars()
	{
		if(vertical != null && visibleLines != 0)
		{
			vertical.setValues(firstLine,visibleLines,0,getLineCount());
			vertical.setUnitIncrement(2);
			vertical.setBlockIncrement(visibleLines);
		}

		int width = painter.getWidth();
		if(horizontal != null && width != 0)
		{
			horizontal.setValues(-horizontalOffset,width,0,width * 5);
			horizontal.setUnitIncrement(painter.getFontMetrics()
				.charWidth('w'));
			horizontal.setBlockIncrement(width / 2);
		}
	}

	/**
	 * Returns the line displayed at the text area's origin.
	 */
	public final int getFirstLine()
	{
		return firstLine;
	}

	/**
	 * Sets the line displayed at the text area's origin without
	 * updating the scroll bars.
	 */
	public void setFirstLine(int firstLine)
	{
		if(firstLine == this.firstLine)
			return;
		int oldFirstLine = this.firstLine;
		this.firstLine = firstLine;
		if(firstLine != vertical.getValue())
			updateScrollBars();
		painter.repaint();
	}

	/**
	 * Returns the number of lines visible in this text area.
	 */
	public final int getVisibleLines()
	{
		return visibleLines;
	}

	/**
	 * Recalculates the number of visible lines. This should not
	 * be called directly.
	 */
	public final void recalculateVisibleLines()
	{
		if(painter == null)
			return;
		int height = painter.getHeight();
		int lineHeight = painter.getFontMetrics().getHeight();
		int oldVisibleLines = visibleLines;
		visibleLines = height / lineHeight;
		updateScrollBars();
	}

	/**
	 * Returns the horizontal offset of drawn lines.
	 */
	public final int getHorizontalOffset()
	{
		return horizontalOffset;
	}

	/**
	 * Sets the horizontal offset of drawn lines. This can be used to
	 * implement horizontal scrolling.
	 * @param horizontalOffset offset The new horizontal offset
	 */
	public void setHorizontalOffset(int horizontalOffset)
	{
		if(horizontalOffset == this.horizontalOffset)
			return;
		this.horizontalOffset = horizontalOffset;
		if(horizontalOffset != horizontal.getValue())
			updateScrollBars();
		painter.repaint();
	}

	/**
	 * A fast way of changing both the first line and horizontal
	 * offset.
	 * @param firstLine The new first line
	 * @param horizontalOffset The new horizontal offset
	 * @return True if any of the values were changed, false otherwise
	 */
	public boolean setOrigin(int firstLine, int horizontalOffset)
	{
		boolean changed = false;
		int oldFirstLine = this.firstLine;

		if(horizontalOffset != this.horizontalOffset)
		{
			this.horizontalOffset = horizontalOffset;
			changed = true;
		}

		if(firstLine != this.firstLine)
		{
			this.firstLine = firstLine;
			changed = true;
		}

		if(changed)
		{
			updateScrollBars();
			painter.repaint();
		}

		return changed;
	}

	/**
	 * Ensures that the caret is visible by scrolling the text area if
	 * necessary.
	 * @return True if scrolling was actually performed, false if the
	 * caret was already visible
	 */
	public boolean scrollToCaret()
	{
		int line = getCaretLine();
		int lineStart = getLineStartOffset(line);
		int offset = Math.max(0,Math.min(getLineLength(line) - 1,
			getCaretPosition() - lineStart));

		return scrollTo(line,offset);
	}

	/**
	 * Ensures that the specified line and offset is visible by scrolling
	 * the text area if necessary.
	 * @param line The line to scroll to
	 * @param offset The offset in the line to scroll to
	 * @return True if scrolling was actually performed, false if the
	 * line and offset was already visible
	 */
	public boolean scrollTo(int line, int offset)
	{
		// visibleLines == 0 before the component is realized
		// we can't do any proper scrolling then, so we have
		// this hack...
		if(visibleLines == 0)
		{
			setFirstLine(Math.max(0,line - electricScroll));
			return true;
		}

		int newFirstLine = firstLine;
		int newHorizontalOffset = horizontalOffset;

		if(line < firstLine + electricScroll)
		{
			newFirstLine = Math.max(0,line - electricScroll);
		}
		else if(line + electricScroll >= firstLine + visibleLines)
		{
			newFirstLine = (line - visibleLines) + electricScroll + 1;
			if(newFirstLine + visibleLines >= getLineCount())
				newFirstLine = getLineCount() - visibleLines;
			if(newFirstLine < 0)
				newFirstLine = 0;
		}

		int x = _offsetToX(line,offset);
		int width = painter.getFontMetrics().charWidth('w');

		if(x < 0)
		{
			newHorizontalOffset = Math.min(0,horizontalOffset
				- x + width + 5);
		}
		else if(x + width >= painter.getWidth())
		{
			newHorizontalOffset = horizontalOffset +
				(painter.getWidth() - x) - width - 5;
		}

		return setOrigin(newFirstLine,newHorizontalOffset);
	}

	/**
	 * Converts a line index to a y co-ordinate.
	 * @param line The line
	 */
	public int lineToY(int line)
	{
		FontMetrics fm = painter.getFontMetrics();
		return (line - firstLine) * fm.getHeight()
			- (fm.getLeading() + fm.getMaxDescent());
	}

	/**
	 * Converts a y co-ordinate to a line index.
	 * @param y The y co-ordinate
	 */
	public int yToLine(int y)
	{
		FontMetrics fm = painter.getFontMetrics();
		int height = fm.getHeight();
		return Math.max(0,Math.min(getLineCount() - 1,
			y / height + firstLine));
	}

	/**
	 * Converts an offset in a line into an x co-ordinate. This is a
	 * slow version that can be used any time.
	 * @param line The line
	 * @param offset The offset, from the start of the line
	 */
	public final int offsetToX(int line, int offset)
	{
		// don't use cached tokens
		painter.currentLineTokens = null;
		return _offsetToX(line,offset);
	}

	/**
	 * Converts an offset in a line into an x co-ordinate. This is a
	 * fast version that should only be used if no changes were made
	 * to the text since the last repaint.
	 * @param line The line
	 * @param offset The offset, from the start of the line
	 */
	public int _offsetToX(int line, int offset)
	{
		TokenMarker tokenMarker = getTokenMarker();

		/* Use painter's cached info for speed */
		FontMetrics fm = painter.getFontMetrics();

		getLineText(line,lineSegment);

		int segmentOffset = lineSegment.offset;
		int x = horizontalOffset;

		/* If syntax coloring is disabled, do simple translation */
		if(tokenMarker == null)
		{
			lineSegment.count = offset;
			return x + Utilities.getTabbedTextWidth(lineSegment,
				fm,x,painter,0);
		}
		/* If syntax coloring is enabled, we have to do this because
		 * tokens can vary in width */
		else
		{
			Token tokens;
			if(painter.currentLineIndex == line
				&& painter.currentLineTokens != null)
				tokens = painter.currentLineTokens;
			else
			{
				painter.currentLineIndex = line;
				tokens = painter.currentLineTokens
					= tokenMarker.markTokens(lineSegment,line);
			}

			Toolkit toolkit = painter.getToolkit();
			Font defaultFont = painter.getFont();
			SyntaxStyle[] styles = painter.getStyles();

			for(;;)
			{
				byte id = tokens.id;
				if(id == Token.END)
				{
					return x;
				}

				if(id == Token.NULL)
					fm = painter.getFontMetrics();
				else
					fm = styles[id].getFontMetrics(defaultFont);

				int length = tokens.length;

				if(offset + segmentOffset < lineSegment.offset + length)
				{
					lineSegment.count = offset - (lineSegment.offset - segmentOffset);
					return x + Utilities.getTabbedTextWidth(
						lineSegment,fm,x,painter,0);
				}
				else
				{
					lineSegment.count = length;
					x += Utilities.getTabbedTextWidth(
						lineSegment,fm,x,painter,0);
					lineSegment.offset += length;
				}
				tokens = tokens.next;
			}
		}
	}

	/**
	 * Converts an x co-ordinate to an offset within a line.
	 * @param line The line
	 * @param x The x co-ordinate
	 */
	public int xToOffset(int line, int x)
	{
		TokenMarker tokenMarker = getTokenMarker();

		/* Use painter's cached info for speed */
		FontMetrics fm = painter.getFontMetrics();

		getLineText(line,lineSegment);

		char[] segmentArray = lineSegment.array;
		int segmentOffset = lineSegment.offset;
		int segmentCount = lineSegment.count;

		int width = horizontalOffset;

		if(tokenMarker == null)
		{
			for(int i = 0; i < segmentCount; i++)
			{
				char c = segmentArray[i + segmentOffset];
				int charWidth;
				if(c == '\t')
					charWidth = (int)painter.nextTabStop(width,i)
						- width;
				else
					charWidth = fm.charWidth(c);

				if(painter.isBlockCaretEnabled())
				{
					if(x - charWidth <= width)
						return i;
				}
				else
				{
					if(x - charWidth / 2 <= width)
						return i;
				}

				width += charWidth;
			}

			return segmentCount;
		}
		else
		{
			Token tokens;
			if(painter.currentLineIndex == line && painter
				.currentLineTokens != null)
				tokens = painter.currentLineTokens;
			else
			{
				painter.currentLineIndex = line;
				tokens = painter.currentLineTokens
					= tokenMarker.markTokens(lineSegment,line);
			}

			int offset = 0;
			Toolkit toolkit = painter.getToolkit();
			Font defaultFont = painter.getFont();
			SyntaxStyle[] styles = painter.getStyles();

			for(;;)
			{
				byte id = tokens.id;
				if(id == Token.END)
					return offset;

				if(id == Token.NULL)
					fm = painter.getFontMetrics();
				else
					fm = styles[id].getFontMetrics(defaultFont);

				int length = tokens.length;

				for(int i = 0; i < length; i++)
				{
					char c = segmentArray[segmentOffset + offset + i];
					int charWidth;
					if(c == '\t')
						charWidth = (int)painter.nextTabStop(width,offset + i)
							- width;
					else
						charWidth = fm.charWidth(c);

					if(painter.isBlockCaretEnabled())
					{
						if(x - charWidth <= width)
							return offset + i;
					}
					else
					{
						if(x - charWidth / 2 <= width)
							return offset + i;
					}

					width += charWidth;
				}

				offset += length;
				tokens = tokens.next;
			}
		}
	}

	/**
	 * Converts a point to an offset, from the start of the text.
	 * @param x The x co-ordinate of the point
	 * @param y The y co-ordinate of the point
	 */
	public int xyToOffset(int x, int y)
	{
		int line = yToLine(y);
		int start = getLineStartOffset(line);
		return start + xToOffset(line,x);
	}

	/**
	 * Returns the document this text area is editing.
	 */
	public final SyntaxDocument getDocument()
	{
		return document;
	}

	/**
	 * Sets the document this text area is editing.
	 * @param document The document
	 */
	public void setDocument(SyntaxDocument document)
	{
		if(this.document == document)
			return;
		if(this.document != null)
			this.document.removeDocumentListener(documentHandler);
		this.document = document;

		document.addDocumentListener(documentHandler);

		select(0,0);
		updateScrollBars();
		painter.repaint();
	}

	/**
	 * Returns the document's token marker. Equivalent to calling
	 * <code>getDocument().getTokenMarker()</code>.
	 */
	public final TokenMarker getTokenMarker()
	{
		return document.getTokenMarker();
	}

	/**
	 * Sets the document's token marker. Equivalent to caling
	 * <code>getDocument().setTokenMarker()</code>.
	 * @param tokenMarker The token marker
	 */
	public final void setTokenMarker(TokenMarker tokenMarker)
	{
		document.setTokenMarker(tokenMarker);
	}

	/**
	 * Returns the length of the document. Equivalent to calling
	 * <code>getDocument().getLength()</code>.
	 */
	public final int getDocumentLength()
	{
		return document.getLength();
	}

	/**
	 * Returns the number of lines in the document.
	 */
	public final int getLineCount()
	{
		return document.getDefaultRootElement().getElementCount();
	}

	/**
	 * Returns the line containing the specified offset.
	 * @param offset The offset
	 */
	public final int getLineOfOffset(int offset)
	{
		return document.getDefaultRootElement().getElementIndex(offset);
	}

	/**
	 * Returns the start offset of the specified line.
	 * @param line The line
	 * @return The start offset of the specified line, or -1 if the line is
	 * invalid
	 */
	public int getLineStartOffset(int line)
	{
		Element lineElement = document.getDefaultRootElement()
			.getElement(line);
		if(lineElement == null)
			return -1;
		else
			return lineElement.getStartOffset();
	}

	/**
	 * Returns the end offset of the specified line.
	 * @param line The line
	 * @return The end offset of the specified line, or -1 if the line is
	 * invalid.
	 */
	public int getLineEndOffset(int line)
	{
		Element lineElement = document.getDefaultRootElement()
			.getElement(line);
		if(lineElement == null)
			return -1;
		else
			return lineElement.getEndOffset();
	}

	/**
	 * Returns the length of the specified line.
	 * @param line The line
	 */
	public int getLineLength(int line)
	{
		Element lineElement = document.getDefaultRootElement()
			.getElement(line);
		if(lineElement == null)
			return -1;
		else
			return lineElement.getEndOffset()
				- lineElement.getStartOffset() - 1;
	}

	/**
	 * Returns the entire text of this text area.
	 */
	public String getText()
	{
		try
		{
			return document.getText(0,document.getLength());
		}
		catch(BadLocationException bl)
		{
			bl.printStackTrace();
			return null;
		}
	}

	/**
	 * Sets the entire text of this text area.
	 */
	public void setText(String text)
	{
		try
		{
			document.beginCompoundEdit();
			document.remove(0,document.getLength());
			document.insertString(0,text,null);
		}
		catch(BadLocationException bl)
		{
			bl.printStackTrace();
		}
		finally
		{
			document.endCompoundEdit();
		}
	}

	/**
	 * Returns the specified substring of the document.
	 * @param start The start offset
	 * @param len The length of the substring
	 * @return The substring, or null if the offsets are invalid
	 */
	public final String getText(int start, int len)
	{
		try
		{
			return document.getText(start,len);
		}
		catch(BadLocationException bl)
		{
			bl.printStackTrace();
			return null;
		}
	}

	/**
	 * Copies the specified substring of the document into a segment.
	 * If the offsets are invalid, the segment will contain a null string.
	 * @param start The start offset
	 * @param len The length of the substring
	 * @param segment The segment
	 */
	public final void getText(int start, int len, Segment segment)
	{
		try
		{
			document.getText(start,len,segment);
		}
		catch(BadLocationException bl)
		{
			bl.printStackTrace();
			segment.offset = segment.count = 0;
		}
	}

	/**
	 * Returns the text on the specified line.
	 * @param lineIndex The line
	 * @return The text, or null if the line is invalid
	 */
	public final String getLineText(int lineIndex)
	{
		int start = getLineStartOffset(lineIndex);
		return getText(start,getLineEndOffset(lineIndex) - start - 1);
	}

	/**
	 * Copies the text on the specified line into a segment. If the line
	 * is invalid, the segment will contain a null string.
	 * @param lineIndex The line
	 */
	public final void getLineText(int lineIndex, Segment segment)
	{
		int start = getLineStartOffset(lineIndex);
		getText(start,getLineEndOffset(lineIndex) - start - 1,segment);
	}

	/**
	 * Returns the selection start offset.
	 */
	public final int getSelectionStart()
	{
		return selectionStart;
	}

	/**
	 * Returns the offset where the selection starts on the specified
	 * line.
	 */
	public int getSelectionStart(int line)
	{
		if(line == selectionStartLine)
			return selectionStart;
		else if(rectSelect)
		{
			Element map = document.getDefaultRootElement();
			int start = selectionStart - map.getElement(selectionStartLine)
				.getStartOffset();

			Element lineElement = map.getElement(line);
			int lineStart = lineElement.getStartOffset();
			int lineEnd = lineElement.getEndOffset() - 1;
			return Math.min(lineEnd,lineStart + start);
		}
		else
			return getLineStartOffset(line);
	}

	/**
	 * Returns the selection start line.
	 */
	public final int getSelectionStartLine()
	{
		return selectionStartLine;
	}

	/**
	 * Sets the selection start. The new selection will be the new
	 * selection start and the old selection end.
	 * @param selectionStart The selection start
	 * @see #select(int,int)
	 */
	public final void setSelectionStart(int selectionStart)
	{
		select(selectionStart,selectionEnd);
	}

	/**
	 * Returns the selection end offset.
	 */
	public final int getSelectionEnd()
	{
		return selectionEnd;
	}

	/**
	 * Returns the offset where the selection ends on the specified
	 * line.
	 */
	public int getSelectionEnd(int line)
	{
		if(line == selectionEndLine)
			return selectionEnd;
		else if(rectSelect)
		{
			Element map = document.getDefaultRootElement();
			int end = selectionEnd - map.getElement(selectionEndLine)
				.getStartOffset();

			Element lineElement = map.getElement(line);
			int lineStart = lineElement.getStartOffset();
			int lineEnd = lineElement.getEndOffset() - 1;
			return Math.min(lineEnd,lineStart + end);
		}
		else
			return getLineEndOffset(line) - 1;
	}

	/**
	 * Returns the selection end line.
	 */
	public final int getSelectionEndLine()
	{
		return selectionEndLine;
	}

	/**
	 * Sets the selection end. The new selection will be the old
	 * selection start and the bew selection end.
	 * @param selectionEnd The selection end
	 * @see #select(int,int)
	 */
	public final void setSelectionEnd(int selectionEnd)
	{
		select(selectionStart,selectionEnd);
	}

	/**
	 * Returns the caret position. This will either be the selection
	 * start or the selection end, depending on which direction the
	 * selection was made in.
	 */
	public final int getCaretPosition()
	{
		return (biasLeft ? selectionStart : selectionEnd);
	}

	/**
	 * Returns the caret line.
	 */
	public final int getCaretLine()
	{
		return (biasLeft ? selectionStartLine : selectionEndLine);
	}

	/**
	 * Returns the mark position. This will be the opposite selection
	 * bound to the caret position.
	 * @see #getCaretPosition()
	 */
	public final int getMarkPosition()
	{
		return (biasLeft ? selectionEnd : selectionStart);
	}

	/**
	 * Returns the mark line.
	 */
	public final int getMarkLine()
	{
		return (biasLeft ? selectionEndLine : selectionStartLine);
	}

	/**
	 * Sets the caret position. The new selection will consist of the
	 * caret position only (hence no text will be selected)
	 * @param caret The caret position
	 * @see #select(int,int)
	 */
	public final void setCaretPosition(int caret)
	{
		select(caret,caret);
	}

	/**
	 * Selects all text in the document.
	 */
	public final void selectAll()
	{
		select(0,getDocumentLength());
	}

	/**
	 * Moves the mark to the caret position.
	 */
	public final void selectNone()
	{
		select(getCaretPosition(),getCaretPosition());
	}

	/**
	 * Selects from the start offset to the end offset. This is the
	 * general selection method used by all other selecting methods.
	 * The caret position will be start if start &lt; end, and end
	 * if end &gt; start.
	 * @param start The start offset
	 * @param end The end offset
	 */
	public void select(int start, int end)
	{
		int newStart, newEnd;
		boolean newBias;
		if(start <= end)
		{
			newStart = start;
			newEnd = end;
			newBias = false;
		}
		else
		{
			newStart = end;
			newEnd = start;
			newBias = true;
		}

		if(newStart < 0 || newEnd > getDocumentLength())
		{
			throw new IllegalArgumentException("Bounds out of"
				+ " range: " + newStart + "," +
				newEnd);
		}

		// If the new position is the same as the old, we don't
		// do all this crap, however we still do the stuff at
		// the end (clearing magic position, scrolling)
		if(newStart != selectionStart || newEnd != selectionEnd
			|| newBias != biasLeft)
		{
			int newStartLine = getLineOfOffset(newStart);
			int newEndLine = getLineOfOffset(newEnd);

			if(painter.isBracketHighlightEnabled())
			{
				if(bracketLine != -1)
					painter.invalidateLine(bracketLine);
				updateBracketHighlight(end);
				if(bracketLine != -1)
					painter.invalidateLine(bracketLine);
			}

			painter.invalidateLineRange(selectionStartLine,selectionEndLine);
			painter.invalidateLineRange(newStartLine,newEndLine);

			document.addUndoableEdit(new CaretUndo(
				selectionStart,selectionEnd));

			selectionStart = newStart;
			selectionEnd = newEnd;
			selectionStartLine = newStartLine;
			selectionEndLine = newEndLine;
			biasLeft = newBias;

			fireCaretEvent();
		}

		// When the user is typing, etc, we don't want the caret
		// to blink
		blink = true;
		caretTimer.restart();

		// Disable rectangle select if selection start = selection end
		if(selectionStart == selectionEnd)
			rectSelect = false;

		// Clear the `magic' caret position used by up/down
		magicCaret = -1;

		scrollToCaret();
	}

	/**
	 * Returns the selected text, or null if no selection is active.
	 */
	public final String getSelectedText()
	{
		if(selectionStart == selectionEnd)
			return null;

		if(rectSelect)
		{
			// Return each row of the selection on a new line

			Element map = document.getDefaultRootElement();

			int start = selectionStart - map.getElement(selectionStartLine)
				.getStartOffset();
			int end = selectionEnd - map.getElement(selectionEndLine)
				.getStartOffset();

			// Certain rectangles satisfy this condition...
			if(end < start)
			{
				int tmp = end;
				end = start;
				start = tmp;
			}

			StringBuffer buf = new StringBuffer();
			Segment seg = new Segment();

			for(int i = selectionStartLine; i <= selectionEndLine; i++)
			{
				Element lineElement = map.getElement(i);
				int lineStart = lineElement.getStartOffset();
				int lineEnd = lineElement.getEndOffset() - 1;
				int lineLen = lineEnd - lineStart;

				lineStart = Math.min(lineStart + start,lineEnd);
				lineLen = Math.min(end - start,lineEnd - lineStart);

				getText(lineStart,lineLen,seg);
				buf.append(seg.array,seg.offset,seg.count);

				if(i != selectionEndLine)
					buf.append('\n');
			}

			return buf.toString();
		}
		else
		{
			return getText(selectionStart,
				selectionEnd - selectionStart);
		}
	}

	/**
	 * Replaces the selection with the specified text.
	 * @param selectedText The replacement text for the selection
	 */
	public void setSelectedText(String selectedText)
	{
		if(!editable)
		{
			throw new InternalError("Text component"
				+ " read only");
		}

		document.beginCompoundEdit();

		try
		{
			if(rectSelect)
			{
				Element map = document.getDefaultRootElement();

				int start = selectionStart - map.getElement(selectionStartLine)
					.getStartOffset();
				int end = selectionEnd - map.getElement(selectionEndLine)
					.getStartOffset();

				// Certain rectangles satisfy this condition...
				if(end < start)
				{
					int tmp = end;
					end = start;
					start = tmp;
				}

				int lastNewline = 0;
				int currNewline = 0;

				for(int i = selectionStartLine; i <= selectionEndLine; i++)
				{
					Element lineElement = map.getElement(i);
					int lineStart = lineElement.getStartOffset();
					int lineEnd = lineElement.getEndOffset() - 1;
					int rectStart = Math.min(lineEnd,lineStart + start);

					document.remove(rectStart,Math.min(lineEnd - rectStart,
						end - start));

					if(selectedText == null)
						continue;

					currNewline = selectedText.indexOf('\n',lastNewline);
					if(currNewline == -1)
						currNewline = selectedText.length();

					document.insertString(rectStart,selectedText
						.substring(lastNewline,currNewline),null);

					lastNewline = Math.min(selectedText.length(),
						currNewline + 1);
				}

				if(selectedText != null &&
					currNewline != selectedText.length())
				{
					int offset = map.getElement(selectionEndLine)
						.getEndOffset() - 1;
					document.insertString(offset,"\n",null);
					document.insertString(offset + 1,selectedText
						.substring(currNewline + 1),null);
				}
			}
			else
			{
				document.remove(selectionStart,
					selectionEnd - selectionStart);
				if(selectedText != null)
				{
					document.insertString(selectionStart,
						selectedText,null);
				}
			}
		}
		catch(BadLocationException bl)
		{
			bl.printStackTrace();
			throw new InternalError("Cannot replace"
				+ " selection");
		}
		// No matter what happends... stops us from leaving document
		// in a bad state
		finally
		{
			document.endCompoundEdit();
		}

		setCaretPosition(selectionEnd);
	}

	/**
	 * Returns true if this text area is editable, false otherwise.
	 */
	public final boolean isEditable()
	{
		return editable;
	}

	/**
	 * Sets if this component is editable.
	 * @param editable True if this text area should be editable,
	 * false otherwise
	 */
	public final void setEditable(boolean editable)
	{
		this.editable = editable;
	}

	/**
	 * Returns the right click popup menu.
	 */
	public final JPopupMenu getRightClickPopup()
	{
		return popup;
	}

	/**
	 * Sets the right click popup menu.
	 * @param popup The popup
	 */
	public final void setRightClickPopup(JPopupMenu popup)
	{
		this.popup = popup;
	}

	/**
	 * Returns the `magic' caret position. This can be used to preserve
	 * the column position when moving up and down lines.
	 */
	public final int getMagicCaretPosition()
	{
		return magicCaret;
	}

	/**
	 * Sets the `magic' caret position. This can be used to preserve
	 * the column position when moving up and down lines.
	 * @param magicCaret The magic caret position
	 */
	public final void setMagicCaretPosition(int magicCaret)
	{
		this.magicCaret = magicCaret;
	}

	/**
	 * Similar to <code>setSelectedText()</code>, but overstrikes the
	 * appropriate number of characters if overwrite mode is enabled.
	 * @param str The string
	 * @see #setSelectedText(String)
	 * @see #isOverwriteEnabled()
	 */
	public void overwriteSetSelectedText(String str)
	{
		// Don't overstrike if there is a selection
		if(!overwrite || selectionStart != selectionEnd)
		{
			setSelectedText(str);
			return;
		}

		// Don't overstrike if we're on the end of
		// the line
		int caret = getCaretPosition();
		int caretLineEnd = getLineEndOffset(getCaretLine());
		if(caretLineEnd - caret <= str.length())
		{
			setSelectedText(str);
			return;
		}

		document.beginCompoundEdit();

		try
		{
			document.remove(caret,str.length());
			document.insertString(caret,str,null);
		}
		catch(BadLocationException bl)
		{
			bl.printStackTrace();
		}
		finally
		{
			document.endCompoundEdit();
		}
	}

	/**
	 * Returns true if overwrite mode is enabled, false otherwise.
	 */
	public final boolean isOverwriteEnabled()
	{
		return overwrite;
	}

	/**
	 * Sets if overwrite mode should be enabled.
	 * @param overwrite True if overwrite mode should be enabled,
	 * false otherwise.
	 */
	public final void setOverwriteEnabled(boolean overwrite)
	{
		this.overwrite = overwrite;
		painter.invalidateSelectedLines();
	}

	/**
	 * Returns true if the selection is rectangular, false otherwise.
	 */
	public final boolean isSelectionRectangular()
	{
		return rectSelect;
	}

	/**
	 * Sets if the selection should be rectangular.
	 * @param overwrite True if the selection should be rectangular,
	 * false otherwise.
	 */
	public final void setSelectionRectangular(boolean rectSelect)
	{
		this.rectSelect = rectSelect;
		painter.invalidateSelectedLines();
	}

	/**
	 * Returns the position of the highlighted bracket (the bracket
	 * matching the one before the caret)
	 */
	public final int getBracketPosition()
	{
		return bracketPosition;
	}

	/**
	 * Returns the line of the highlighted bracket (the bracket
	 * matching the one before the caret)
	 */
	public final int getBracketLine()
	{
		return bracketLine;
	}

	/**
	 * Adds a caret change listener to this text area.
	 * @param listener The listener
	 */
	public final void addCaretListener(CaretListener listener)
	{
		listenerList.add(CaretListener.class,listener);
	}

	/**
	 * Removes a caret change listener from this text area.
	 * @param listener The listener
	 */
	public final void removeCaretListener(CaretListener listener)
	{
		listenerList.remove(CaretListener.class,listener);
	}

	/**
	 * Deletes the selected text from the text area and places it
	 * into the clipboard.
	 */
	public void cut()
	{
		if(editable)
		{
			copy();
			setSelectedText("");
		}
	}

	/**
	 * Places the selected text into the clipboard.
	 */
	public void copy()
	{
		if(selectionStart != selectionEnd)
		{
			Clipboard clipboard = getToolkit().getSystemClipboard();

			String selection = getSelectedText();

			int repeatCount = inputHandler.getRepeatCount();
			StringBuffer buf = new StringBuffer();
			for(int i = 0; i < repeatCount; i++)
				buf.append(selection);

			clipboard.setContents(new StringSelection(buf.toString()),null);
		}
	}

	/**
	 * Inserts the clipboard contents into the text.
	 */
	public void paste()
	{
		if(editable)
		{
			Clipboard clipboard = getToolkit().getSystemClipboard();
			try
			{
				// The MacOS MRJ doesn't convert \r to \n,
				// so do it here
				String selection = ((String)clipboard
					.getContents(this).getTransferData(
					DataFlavor.stringFlavor))
					.replace('\r','\n');

				int repeatCount = inputHandler.getRepeatCount();
				StringBuffer buf = new StringBuffer();
				for(int i = 0; i < repeatCount; i++)
					buf.append(selection);
				selection = buf.toString();
				setSelectedText(selection);
			}
			catch(Exception e)
			{
				getToolkit().beep();
				System.err.println("Clipboard does not"
					+ " contain a string");
			}
		}
	}

	/**
	 * Called by the AWT when this component is removed from it's parent.
	 * This stops clears the currently focused component.
	 */
	public void removeNotify()
	{
		super.removeNotify();
		if(focusedComponent == this)
			focusedComponent = null;
	}

	/**
	 * Forwards key events directly to the input handler.
	 * This is slightly faster than using a KeyListener
	 * because some Swing overhead is avoided.
	 */
	public void processKeyEvent(KeyEvent evt)
	{
		if(inputHandler == null)
			return;
		switch(evt.getID())
		{
		case KeyEvent.KEY_TYPED:
			inputHandler.keyTyped(evt);
			break;
		case KeyEvent.KEY_PRESSED:
			inputHandler.keyPressed(evt);
			break;
		case KeyEvent.KEY_RELEASED:
			inputHandler.keyReleased(evt);
			break;
		}
	}

	// protected members
	protected static String CENTER = "center";
	protected static String RIGHT = "right";
	protected static String BOTTOM = "bottom";

	protected static JEditTextArea focusedComponent;
	protected static Timer caretTimer;
	
	protected TextAreaPainter painter;

	protected JPopupMenu popup;

	protected EventListenerList listenerList;
	protected MutableCaretEvent caretEvent;

	protected boolean caretBlinks;
	protected boolean caretVisible;
	protected boolean blink;

	protected boolean editable;

	protected int firstLine;
	protected int visibleLines;
	protected int electricScroll;

	protected int horizontalOffset;
	
	protected JScrollBar vertical;
	protected JScrollBar horizontal;
	protected boolean scrollBarsInitialized;

	protected InputHandler inputHandler;
	protected SyntaxDocument document;
	protected DocumentHandler documentHandler;

	protected Segment lineSegment;

	protected int selectionStart;
	protected int selectionStartLine;
	protected int selectionEnd;
	protected int selectionEndLine;
	protected boolean biasLeft;

	protected int bracketPosition;
	protected int bracketLine;

	protected int magicCaret;
	protected boolean overwrite;
	protected boolean rectSelect;

	protected void fireCaretEvent()
	{
		Object[] listeners = listenerList.getListenerList();
		for(int i = listeners.length - 2; i >= 0; i--)
		{
			if(listeners[i] == CaretListener.class)
			{
				((CaretListener)listeners[i+1]).caretUpdate(caretEvent);
			}
		}
	}

	protected void updateBracketHighlight(int newCaretPosition)
	{
		if(newCaretPosition == 0)
		{
			bracketPosition = bracketLine = -1;
			return;
		}

		try
		{
			int offset = TextUtilities.findMatchingBracket(
				document,newCaretPosition - 1);
			if(offset != -1)
			{
				bracketLine = getLineOfOffset(offset);
				bracketPosition = offset - getLineStartOffset(bracketLine);
				return;
			}
		}
		catch(BadLocationException bl)
		{
			bl.printStackTrace();
		}

		bracketLine = bracketPosition = -1;
	}

	protected void documentChanged(DocumentEvent evt)
	{
		DocumentEvent.ElementChange ch = evt.getChange(
			document.getDefaultRootElement());

		int count;
		if(ch == null)
			count = 0;
		else
			count = ch.getChildrenAdded().length -
				ch.getChildrenRemoved().length;

		int line = getLineOfOffset(evt.getOffset());
		if(count == 0)
		{
			painter.invalidateLine(line);
		}
		// do magic stuff
		else if(line < firstLine)
		{
			setFirstLine(firstLine + count);
		}
		// end of magic stuff
		else
		{
			painter.invalidateLineRange(line,firstLine + visibleLines);
			updateScrollBars();
		}
	}

	class ScrollLayout implements LayoutManager
	{
		public void addLayoutComponent(String name, Component comp)
		{
			if(name.equals(CENTER))
				center = comp;
			else if(name.equals(RIGHT))
				right = comp;
			else if(name.equals(BOTTOM))
				bottom = comp;
			else if(name.equals(LEFT_OF_SCROLLBAR))
				leftOfScrollBar.addElement(comp);
		}

		public void removeLayoutComponent(Component comp)
		{
			if(center == comp)
				center = null;
			if(right == comp)
				right = null;
			if(bottom == comp)
				bottom = null;
			else
				leftOfScrollBar.removeElement(comp);
		}

		public Dimension preferredLayoutSize(Container parent)
		{
			Dimension dim = new Dimension();
			Insets insets = getInsets();
			dim.width = insets.left + insets.right;
			dim.height = insets.top + insets.bottom;

			Dimension centerPref = center.getPreferredSize();
			dim.width += centerPref.width;
			dim.height += centerPref.height;
			Dimension rightPref = right.getPreferredSize();
			dim.width += rightPref.width;
			Dimension bottomPref = bottom.getPreferredSize();
			dim.height += bottomPref.height;

			return dim;
		}

		public Dimension minimumLayoutSize(Container parent)
		{
			Dimension dim = new Dimension();
			Insets insets = getInsets();
			dim.width = insets.left + insets.right;
			dim.height = insets.top + insets.bottom;

			Dimension centerPref = center.getMinimumSize();
			dim.width += centerPref.width; 
			dim.height += centerPref.height;
			Dimension rightPref = right.getMinimumSize();
			dim.width += rightPref.width;
			Dimension bottomPref = bottom.getMinimumSize();
			dim.height += bottomPref.height;

			return dim;
		}

		public void layoutContainer(Container parent)
		{
			Dimension size = parent.getSize();
			Insets insets = parent.getInsets();
			int itop = insets.top;
			int ileft = insets.left;
			int ibottom = insets.bottom;
			int iright = insets.right;

			int rightWidth = right.getPreferredSize().width;
			int bottomHeight = bottom.getPreferredSize().height;
			int centerWidth = size.width - rightWidth - ileft - iright;
			int centerHeight = size.height - bottomHeight - itop - ibottom;

			center.setBounds(
				ileft,
				itop,
				centerWidth,
				centerHeight);

			right.setBounds(
				ileft + centerWidth,
				itop,
				rightWidth,
				centerHeight);

			// Lay out all status components, in order
			Enumeration status = leftOfScrollBar.elements();
			while(status.hasMoreElements())
			{
				Component comp = (Component)status.nextElement();
				Dimension dim = comp.getPreferredSize();
				comp.setBounds(ileft,
					itop + centerHeight,
					dim.width,
					bottomHeight);
				ileft += dim.width;
			}

			bottom.setBounds(
				ileft,
				itop + centerHeight,
				size.width - rightWidth - ileft - iright,
				bottomHeight);
		}

		// private members
		private Component center;
		private Component right;
		private Component bottom;
		private Vector leftOfScrollBar = new Vector();
	}

	static class CaretBlinker implements ActionListener
	{
		public void actionPerformed(ActionEvent evt)
		{
			if(focusedComponent != null
				&& focusedComponent.hasFocus())
				focusedComponent.blinkCaret();
		}
	}

	class MutableCaretEvent extends CaretEvent
	{
		MutableCaretEvent()
		{
			super(JEditTextArea.this);
		}

		public int getDot()
		{
			return getCaretPosition();
		}

		public int getMark()
		{
			return getMarkPosition();
		}
	}

	class AdjustHandler implements AdjustmentListener
	{
		public void adjustmentValueChanged(final AdjustmentEvent evt)
		{
			if(!scrollBarsInitialized)
				return;

			// If this is not done, mousePressed events accumilate
			// and the result is that scrolling doesn't stop after
			// the mouse is released
			SwingUtilities.invokeLater(new Runnable() {
				public void run()
				{
					if(evt.getAdjustable() == vertical)
						setFirstLine(vertical.getValue());
					else
						setHorizontalOffset(-horizontal.getValue());
				}
			});
		}
	}

	class ComponentHandler extends ComponentAdapter
	{
		public void componentResized(ComponentEvent evt)
		{
			recalculateVisibleLines();
			scrollBarsInitialized = true;
		}
	}

	class DocumentHandler implements DocumentListener
	{
		public void insertUpdate(DocumentEvent evt)
		{
			documentChanged(evt);

			int offset = evt.getOffset();
			int length = evt.getLength();

			int newStart;
			int newEnd;

			if(selectionStart > offset || (selectionStart 
				== selectionEnd && selectionStart == offset))
				newStart = selectionStart + length;
			else
				newStart = selectionStart;

			if(selectionEnd >= offset)
				newEnd = selectionEnd + length;
			else
				newEnd = selectionEnd;

			select(newStart,newEnd);
		}
	
		public void removeUpdate(DocumentEvent evt)
		{
			documentChanged(evt);

			int offset = evt.getOffset();
			int length = evt.getLength();

			int newStart;
			int newEnd;

			if(selectionStart > offset)
			{
				if(selectionStart > offset + length)
					newStart = selectionStart - length;
				else
					newStart = offset;
			}
			else
				newStart = selectionStart;

			if(selectionEnd > offset)
			{
				if(selectionEnd > offset + length)
					newEnd = selectionEnd - length;
				else
					newEnd = offset;
			}
			else
				newEnd = selectionEnd;

			select(newStart,newEnd);
		}

		public void changedUpdate(DocumentEvent evt)
		{
		}
	}

	class DragHandler implements MouseMotionListener
	{
		public void mouseDragged(MouseEvent evt)
		{
			if(popup != null && popup.isVisible())
				return;

			setSelectionRectangular((evt.getModifiers()
				& InputEvent.CTRL_MASK) != 0);
			select(getMarkPosition(),xyToOffset(evt.getX(),evt.getY()));
		}

		public void mouseMoved(MouseEvent evt) {}
	}

	class FocusHandler implements FocusListener
	{
		public void focusGained(FocusEvent evt)
		{
			setCaretVisible(true);
			focusedComponent = JEditTextArea.this;
		}

		public void focusLost(FocusEvent evt)
		{
			setCaretVisible(false);
			focusedComponent = null;
		}
	}

	class MouseHandler extends MouseAdapter
	{
		public void mousePressed(MouseEvent evt)
		{
			requestFocus();

			// Focus events not fired sometimes?
			setCaretVisible(true);
			focusedComponent = JEditTextArea.this;

			if((evt.getModifiers() & InputEvent.BUTTON3_MASK) != 0
				&& popup != null)
			{
				popup.show(painter,evt.getX(),evt.getY());
				return;
			}

			int line = yToLine(evt.getY());
			int offset = xToOffset(line,evt.getX());
			int dot = getLineStartOffset(line) + offset;

			switch(evt.getClickCount())
			{
			case 1:
				doSingleClick(evt,line,offset,dot);
				break;
			case 2:
				// It uses the bracket matching stuff, so
				// it can throw a BLE
				try
				{
					doDoubleClick(evt,line,offset,dot);
				}
				catch(BadLocationException bl)
				{
					bl.printStackTrace();
				}
				break;
			case 3:
				doTripleClick(evt,line,offset,dot);
				break;
			}
		}

		private void doSingleClick(MouseEvent evt, int line, 
			int offset, int dot)
		{
			if((evt.getModifiers() & InputEvent.SHIFT_MASK) != 0)
			{
				rectSelect = (evt.getModifiers() & InputEvent.CTRL_MASK) != 0;
				select(getMarkPosition(),dot);
			}
			else
				setCaretPosition(dot);
		}

		private void doDoubleClick(MouseEvent evt, int line,
			int offset, int dot) throws BadLocationException
		{
			// Ignore empty lines
			if(getLineLength(line) == 0)
				return;

			try
			{
				int bracket = TextUtilities.findMatchingBracket(
					document,Math.max(0,dot - 1));
				if(bracket != -1)
				{
					int mark = getMarkPosition();
					// Hack
					if(bracket > mark)
					{
						bracket++;
						mark--;
					}
					select(mark,bracket);
					return;
				}
			}
			catch(BadLocationException bl)
			{
				bl.printStackTrace();
			}

			// Ok, it's not a bracket... select the word
			String lineText = getLineText(line);
			char ch = lineText.charAt(Math.max(0,offset - 1));

			String noWordSep = (String)document.getProperty("noWordSep");
			if(noWordSep == null)
				noWordSep = "";

			// If the user clicked on a non-letter char,
			// we select the surrounding non-letters
			boolean selectNoLetter = (!Character
				.isLetterOrDigit(ch)
				&& noWordSep.indexOf(ch) == -1);

			int wordStart = 0;

			for(int i = offset - 1; i >= 0; i--)
			{
				ch = lineText.charAt(i);
				if(selectNoLetter ^ (!Character
					.isLetterOrDigit(ch) &&
					noWordSep.indexOf(ch) == -1))
				{
					wordStart = i + 1;
					break;
				}
			}

			int wordEnd = lineText.length();
			for(int i = offset; i < lineText.length(); i++)
			{
				ch = lineText.charAt(i);
				if(selectNoLetter ^ (!Character
					.isLetterOrDigit(ch) &&
					noWordSep.indexOf(ch) == -1))
				{
					wordEnd = i;
					break;
				}
			}

			int lineStart = getLineStartOffset(line);
			select(lineStart + wordStart,lineStart + wordEnd);

			/*
			String lineText = getLineText(line);
			String noWordSep = (String)document.getProperty("noWordSep");
			int wordStart = TextUtilities.findWordStart(lineText,offset,noWordSep);
			int wordEnd = TextUtilities.findWordEnd(lineText,offset,noWordSep);

			int lineStart = getLineStartOffset(line);
			select(lineStart + wordStart,lineStart + wordEnd);
			*/
		}

		private void doTripleClick(MouseEvent evt, int line,
			int offset, int dot)
		{
			select(getLineStartOffset(line),getLineEndOffset(line)-1);
		}
	}

	class CaretUndo extends AbstractUndoableEdit
	{
		private int start;
		private int end;

		CaretUndo(int start, int end)
		{
			this.start = start;
			this.end = end;
		}

		public boolean isSignificant()
		{
			return false;
		}

		public String getPresentationName()
		{
			return "caret move";
		}

		public void undo() throws CannotUndoException
		{
			super.undo();

			select(start,end);
		}

		public void redo() throws CannotRedoException
		{
			super.redo();

			select(start,end);
		}

		public boolean addEdit(UndoableEdit edit)
		{
			if(edit instanceof CaretUndo)
			{
				CaretUndo cedit = (CaretUndo)edit;
				start = cedit.start;
				end = cedit.end;
				cedit.die();

				return true;
			}
			else
				return false;
		}
	}

	static
	{
		caretTimer = new Timer(500,new CaretBlinker());
		caretTimer.setInitialDelay(500);
		caretTimer.start();
	}
}




/*
 * InputHandler.java - Manages key bindings and executes actions
 * Copyright (C) 1999 Slava Pestov
 *
 * You may use and modify this package for any purpose. Redistribution is
 * permitted, in both source and binary form, provided that this notice
 * remains intact in all source distributions of this package.
 */
package org.apache.batik.apps.svgbrowser.srcview;

import javax.swing.text.*;
import javax.swing.JPopupMenu;
import java.awt.event.*;
import java.awt.Component;
import java.util.*;

/**
 * An input handler converts the user's key strokes into concrete actions.
 * It also takes care of macro recording and action repetition.<p>
 *
 * This class provides all the necessary support code for an input
 * handler, but doesn't actually do any key binding logic. It is up
 * to the implementations of this class to do so.
 *
 * @author Slava Pestov
 * @version $Id: InputHandler.java,v 1.14 1999/12/13 03:40:30 sp Exp $
 * @see org.gjt.sp.jedit.textarea.DefaultInputHandler
 */
public abstract class InputHandler extends KeyAdapter
{
	/**
	 * If this client property is set to Boolean.TRUE on the text area,
	 * the home/end keys will support 'smart' BRIEF-like behaviour
	 * (one press = start/end of line, two presses = start/end of
	 * viewscreen, three presses = start/end of document). By default,
	 * this property is not set.
	 */
	public static final String SMART_HOME_END_PROPERTY = "InputHandler.homeEnd";

	public static final ActionListener BACKSPACE = new backspace();
	public static final ActionListener BACKSPACE_WORD = new backspace_word();
	public static final ActionListener DELETE = new delete();
	public static final ActionListener DELETE_WORD = new delete_word();
	public static final ActionListener END = new end(false);
	public static final ActionListener DOCUMENT_END = new document_end(false);
	public static final ActionListener SELECT_END = new end(true);
	public static final ActionListener SELECT_DOC_END = new document_end(true);
	public static final ActionListener INSERT_BREAK = new insert_break();
	public static final ActionListener INSERT_TAB = new insert_tab();
	public static final ActionListener HOME = new home(false);
	public static final ActionListener DOCUMENT_HOME = new document_home(false);
	public static final ActionListener SELECT_HOME = new home(true);
	public static final ActionListener SELECT_DOC_HOME = new document_home(true);
	public static final ActionListener NEXT_CHAR = new next_char(false);
	public static final ActionListener NEXT_LINE = new next_line(false);
	public static final ActionListener NEXT_PAGE = new next_page(false);
	public static final ActionListener NEXT_WORD = new next_word(false);
	public static final ActionListener SELECT_NEXT_CHAR = new next_char(true);
	public static final ActionListener SELECT_NEXT_LINE = new next_line(true);
	public static final ActionListener SELECT_NEXT_PAGE = new next_page(true);
	public static final ActionListener SELECT_NEXT_WORD = new next_word(true);
	public static final ActionListener OVERWRITE = new overwrite();
	public static final ActionListener PREV_CHAR = new prev_char(false);
	public static final ActionListener PREV_LINE = new prev_line(false);
	public static final ActionListener PREV_PAGE = new prev_page(false);
	public static final ActionListener PREV_WORD = new prev_word(false);
	public static final ActionListener SELECT_PREV_CHAR = new prev_char(true);
	public static final ActionListener SELECT_PREV_LINE = new prev_line(true);
	public static final ActionListener SELECT_PREV_PAGE = new prev_page(true);
	public static final ActionListener SELECT_PREV_WORD = new prev_word(true);
	public static final ActionListener REPEAT = new repeat();
	public static final ActionListener TOGGLE_RECT = new toggle_rect();

	// Default action
	public static final ActionListener INSERT_CHAR = new insert_char();

	private static Hashtable actions;

	static
	{
		actions = new Hashtable();
		actions.put("backspace",BACKSPACE);
		actions.put("backspace-word",BACKSPACE_WORD);
		actions.put("delete",DELETE);
		actions.put("delete-word",DELETE_WORD);
		actions.put("end",END);
		actions.put("select-end",SELECT_END);
		actions.put("document-end",DOCUMENT_END);
		actions.put("select-doc-end",SELECT_DOC_END);
		actions.put("insert-break",INSERT_BREAK);
		actions.put("insert-tab",INSERT_TAB);
		actions.put("home",HOME);
		actions.put("select-home",SELECT_HOME);
		actions.put("document-home",DOCUMENT_HOME);
		actions.put("select-doc-home",SELECT_DOC_HOME);
		actions.put("next-char",NEXT_CHAR);
		actions.put("next-line",NEXT_LINE);
		actions.put("next-page",NEXT_PAGE);
		actions.put("next-word",NEXT_WORD);
		actions.put("select-next-char",SELECT_NEXT_CHAR);
		actions.put("select-next-line",SELECT_NEXT_LINE);
		actions.put("select-next-page",SELECT_NEXT_PAGE);
		actions.put("select-next-word",SELECT_NEXT_WORD);
		actions.put("overwrite",OVERWRITE);
		actions.put("prev-char",PREV_CHAR);
		actions.put("prev-line",PREV_LINE);
		actions.put("prev-page",PREV_PAGE);
		actions.put("prev-word",PREV_WORD);
		actions.put("select-prev-char",SELECT_PREV_CHAR);
		actions.put("select-prev-line",SELECT_PREV_LINE);
		actions.put("select-prev-page",SELECT_PREV_PAGE);
		actions.put("select-prev-word",SELECT_PREV_WORD);
		actions.put("repeat",REPEAT);
		actions.put("toggle-rect",TOGGLE_RECT);
		actions.put("insert-char",INSERT_CHAR);
	}

	/**
	 * Returns a named text area action.
	 * @param name The action name
	 */
	public static ActionListener getAction(String name)
	{
		return (ActionListener)actions.get(name);
	}

	/**
	 * Returns the name of the specified text area action.
	 * @param listener The action
	 */
	public static String getActionName(ActionListener listener)
	{
		Enumeration e = getActions();
		while(e.hasMoreElements())
		{
			String name = (String)e.nextElement();
			ActionListener _listener = getAction(name);
			if(_listener == listener)
				return name;
		}
		return null;
	}

	/**
	 * Returns an enumeration of all available actions.
	 */
	public static Enumeration getActions()
	{
		return actions.keys();
	}

	/**
	 * Adds the default key bindings to this input handler.
	 * This should not be called in the constructor of this
	 * input handler, because applications might load the
	 * key bindings from a file, etc.
	 */
	public abstract void addDefaultKeyBindings();

	/**
	 * Adds a key binding to this input handler.
	 * @param keyBinding The key binding (the format of this is
	 * input-handler specific)
	 * @param action The action
	 */
	public abstract void addKeyBinding(String keyBinding, ActionListener action);

	/**
	 * Removes a key binding from this input handler.
	 * @param keyBinding The key binding
	 */
	public abstract void removeKeyBinding(String keyBinding);

	/**
	 * Removes all key bindings from this input handler.
	 */
	public abstract void removeAllKeyBindings();

	/**
	 * Grabs the next key typed event and invokes the specified
	 * action with the key as a the action command.
	 * @param action The action
	 */
	public void grabNextKeyStroke(ActionListener listener)
	{
		grabAction = listener;
	}

	/**
	 * Returns if repeating is enabled. When repeating is enabled,
	 * actions will be executed multiple times. This is usually
	 * invoked with a special key stroke in the input handler.
	 */
	public boolean isRepeatEnabled()
	{
		return repeat;
	}

	/**
	 * Enables repeating. When repeating is enabled, actions will be
	 * executed multiple times. Once repeating is enabled, the input
	 * handler should read a number from the keyboard.
	 */
	public void setRepeatEnabled(boolean repeat)
	{
		this.repeat = repeat;
	}

	/**
	 * Returns the number of times the next action will be repeated.
	 */
	public int getRepeatCount()
	{
		return (repeat ? Math.max(1,repeatCount) : 1);
	}

	/**
	 * Sets the number of times the next action will be repeated.
	 * @param repeatCount The repeat count
	 */
	public void setRepeatCount(int repeatCount)
	{
		this.repeatCount = repeatCount;
	}

	/**
	 * Returns the macro recorder. If this is non-null, all executed
	 * actions should be forwarded to the recorder.
	 */
	public InputHandler.MacroRecorder getMacroRecorder()
	{
		return recorder;
	}

	/**
	 * Sets the macro recorder. If this is non-null, all executed
	 * actions should be forwarded to the recorder.
	 * @param recorder The macro recorder
	 */
	public void setMacroRecorder(InputHandler.MacroRecorder recorder)
	{
		this.recorder = recorder;
	}

	/**
	 * Returns a copy of this input handler that shares the same
	 * key bindings. Setting key bindings in the copy will also
	 * set them in the original.
	 */
	public abstract InputHandler copy();

	/**
	 * Executes the specified action, repeating and recording it as
	 * necessary.
	 * @param listener The action listener
	 * @param source The event source
	 * @param actionCommand The action command
	 */
	public void executeAction(ActionListener listener, Object source,
		String actionCommand)
	{
		// create event
		ActionEvent evt = new ActionEvent(source,
			ActionEvent.ACTION_PERFORMED,
			actionCommand);

		// don't do anything if the action is a wrapper
		// (like EditAction.Wrapper)
		if(listener instanceof Wrapper)
		{
			listener.actionPerformed(evt);
			return;
		}

		// remember old values, in case action changes them
		boolean _repeat = repeat;
		int _repeatCount = getRepeatCount();

		// execute the action
		if(listener instanceof InputHandler.NonRepeatable)
			listener.actionPerformed(evt);
		else
		{
			for(int i = 0; i < Math.max(1,repeatCount); i++)
				listener.actionPerformed(evt);
		}

		// do recording. Notice that we do no recording whatsoever
		// for actions that grab keys
		if(grabAction == null)
		{
			if(recorder != null)
			{
				if(!(listener instanceof InputHandler.NonRecordable))
				{
					if(_repeatCount != 1)
						recorder.actionPerformed(REPEAT,String.valueOf(_repeatCount));

					recorder.actionPerformed(listener,actionCommand);
				}
			}

			// If repeat was true originally, clear it
			// Otherwise it might have been set by the action, etc
			if(_repeat)
			{
				repeat = false;
				repeatCount = 0;
			}
		}
	}

	/**
	 * Returns the text area that fired the specified event.
	 * @param evt The event
	 */
	public static JEditTextArea getTextArea(EventObject evt)
	{
		if(evt != null)
		{
			Object o = evt.getSource();
			if(o instanceof Component)
			{
				// find the parent text area
				Component c = (Component)o;
				for(;;)
				{
					if(c instanceof JEditTextArea)
						return (JEditTextArea)c;
					else if(c == null)
						break;
					if(c instanceof JPopupMenu)
						c = ((JPopupMenu)c)
							.getInvoker();
					else
						c = c.getParent();
				}
			}
		}

		// this shouldn't happen
		System.err.println("BUG: getTextArea() returning null");
		System.err.println("Report this to Slava Pestov <sp@gjt.org>");
		return null;
	}

	// protected members

	/**
	 * If a key is being grabbed, this method should be called with
	 * the appropriate key event. It executes the grab action with
	 * the typed character as the parameter.
	 */
	protected void handleGrabAction(KeyEvent evt)
	{
		// Clear it *before* it is executed so that executeAction()
		// resets the repeat count
		ActionListener _grabAction = grabAction;
		grabAction = null;
		executeAction(_grabAction,evt.getSource(),
			String.valueOf(evt.getKeyChar()));
	}

	// protected members
	protected ActionListener grabAction;
	protected boolean repeat;
	protected int repeatCount;
	protected InputHandler.MacroRecorder recorder;

	/**
	 * If an action implements this interface, it should not be repeated.
	 * Instead, it will handle the repetition itself.
	 */
	public interface NonRepeatable {}

	/**
	 * If an action implements this interface, it should not be recorded
	 * by the macro recorder. Instead, it will do its own recording.
	 */
	public interface NonRecordable {}

	/**
	 * For use by EditAction.Wrapper only.
	 * @since jEdit 2.2final
	 */
	public interface Wrapper {}

	/**
	 * Macro recorder.
	 */
	public interface MacroRecorder
	{
		void actionPerformed(ActionListener listener,
			String actionCommand);
	}

	public static class backspace implements ActionListener
	{
		public void actionPerformed(ActionEvent evt)
		{
			JEditTextArea textArea = getTextArea(evt);

			if(!textArea.isEditable())
			{
				textArea.getToolkit().beep();
				return;
			}

			if(textArea.getSelectionStart()
			   != textArea.getSelectionEnd())
			{
				textArea.setSelectedText("");
			}
			else
			{
				int caret = textArea.getCaretPosition();
				if(caret == 0)
				{
					textArea.getToolkit().beep();
					return;
				}
				try
				{
					textArea.getDocument().remove(caret - 1,1);
				}
				catch(BadLocationException bl)
				{
					bl.printStackTrace();
				}
			}
		}
	}

	public static class backspace_word implements ActionListener
	{
		public void actionPerformed(ActionEvent evt)
		{
			JEditTextArea textArea = getTextArea(evt);
			int start = textArea.getSelectionStart();
			if(start != textArea.getSelectionEnd())
			{
				textArea.setSelectedText("");
			}

			int line = textArea.getCaretLine();
			int lineStart = textArea.getLineStartOffset(line);
			int caret = start - lineStart;

			String lineText = textArea.getLineText(textArea
				.getCaretLine());

			if(caret == 0)
			{
				if(lineStart == 0)
				{
					textArea.getToolkit().beep();
					return;
				}
				caret--;
			}
			else
			{
				String noWordSep = (String)textArea.getDocument().getProperty("noWordSep");
				caret = TextUtilities.findWordStart(lineText,caret,noWordSep);
			}

			try
			{
				textArea.getDocument().remove(
						caret + lineStart,
						start - (caret + lineStart));
			}
			catch(BadLocationException bl)
			{
				bl.printStackTrace();
			}
		}
	}

	public static class delete implements ActionListener
	{
		public void actionPerformed(ActionEvent evt)
		{
			JEditTextArea textArea = getTextArea(evt);

			if(!textArea.isEditable())
			{
				textArea.getToolkit().beep();
				return;
			}

			if(textArea.getSelectionStart()
			   != textArea.getSelectionEnd())
			{
				textArea.setSelectedText("");
			}
			else
			{
				int caret = textArea.getCaretPosition();
				if(caret == textArea.getDocumentLength())
				{
					textArea.getToolkit().beep();
					return;
				}
				try
				{
					textArea.getDocument().remove(caret,1);
				}
				catch(BadLocationException bl)
				{
					bl.printStackTrace();
				}
			}
		}
	}

	public static class delete_word implements ActionListener
	{
		public void actionPerformed(ActionEvent evt)
		{
			JEditTextArea textArea = getTextArea(evt);
			int start = textArea.getSelectionStart();
			if(start != textArea.getSelectionEnd())
			{
				textArea.setSelectedText("");
			}

			int line = textArea.getCaretLine();
			int lineStart = textArea.getLineStartOffset(line);
			int caret = start - lineStart;

			String lineText = textArea.getLineText(textArea
				.getCaretLine());

			if(caret == lineText.length())
			{
				if(lineStart + caret == textArea.getDocumentLength())
				{
					textArea.getToolkit().beep();
					return;
				}
				caret++;
			}
			else
			{
				String noWordSep = (String)textArea.getDocument().getProperty("noWordSep");
				caret = TextUtilities.findWordEnd(lineText,caret,noWordSep);
			}

			try
			{
				textArea.getDocument().remove(start,
					(caret + lineStart) - start);
			}
			catch(BadLocationException bl)
			{
				bl.printStackTrace();
			}
		}
	}

	public static class end implements ActionListener
	{
		private boolean select;

		public end(boolean select)
		{
			this.select = select;
		}

		public void actionPerformed(ActionEvent evt)
		{
			JEditTextArea textArea = getTextArea(evt);

			int caret = textArea.getCaretPosition();

			int lastOfLine = textArea.getLineEndOffset(
				textArea.getCaretLine()) - 1;
			int lastVisibleLine = textArea.getFirstLine()
				+ textArea.getVisibleLines();
			if(lastVisibleLine >= textArea.getLineCount())
			{
				lastVisibleLine = Math.min(textArea.getLineCount() - 1,
					lastVisibleLine);
			}
			else
				lastVisibleLine -= (textArea.getElectricScroll() + 1);

			int lastVisible = textArea.getLineEndOffset(lastVisibleLine) - 1;
			int lastDocument = textArea.getDocumentLength();

			if(caret == lastDocument)
			{
				textArea.getToolkit().beep();
				return;
			}
			else if(!Boolean.TRUE.equals(textArea.getClientProperty(
				SMART_HOME_END_PROPERTY)))
				caret = lastOfLine;
			else if(caret == lastVisible)
				caret = lastDocument;
			else if(caret == lastOfLine)
				caret = lastVisible;
			else
				caret = lastOfLine;

			if(select)
				textArea.select(textArea.getMarkPosition(),caret);
			else
				textArea.setCaretPosition(caret);
		}
	}

	public static class document_end implements ActionListener
	{
		private boolean select;

		public document_end(boolean select)
		{
			this.select = select;
		}

		public void actionPerformed(ActionEvent evt)
		{
			JEditTextArea textArea = getTextArea(evt);
			if(select)
				textArea.select(textArea.getMarkPosition(),
					textArea.getDocumentLength());
			else
				textArea.setCaretPosition(textArea
					.getDocumentLength());
		}
	}

	public static class home implements ActionListener
	{
		private boolean select;

		public home(boolean select)
		{
			this.select = select;
		}

		public void actionPerformed(ActionEvent evt)
		{
			JEditTextArea textArea = getTextArea(evt);

			int caret = textArea.getCaretPosition();

			int firstLine = textArea.getFirstLine();

			int firstOfLine = textArea.getLineStartOffset(
				textArea.getCaretLine());
			int firstVisibleLine = (firstLine == 0 ? 0 :
				firstLine + textArea.getElectricScroll());
			int firstVisible = textArea.getLineStartOffset(
				firstVisibleLine);

			if(caret == 0)
			{
				textArea.getToolkit().beep();
				return;
			}
			else if(!Boolean.TRUE.equals(textArea.getClientProperty(
				SMART_HOME_END_PROPERTY)))
				caret = firstOfLine;
			else if(caret == firstVisible)
				caret = 0;
			else if(caret == firstOfLine)
				caret = firstVisible;
			else
				caret = firstOfLine;

			if(select)
				textArea.select(textArea.getMarkPosition(),caret);
			else
				textArea.setCaretPosition(caret);
		}
	}

	public static class document_home implements ActionListener
	{
		private boolean select;

		public document_home(boolean select)
		{
			this.select = select;
		}

		public void actionPerformed(ActionEvent evt)
		{
			JEditTextArea textArea = getTextArea(evt);
			if(select)
				textArea.select(textArea.getMarkPosition(),0);
			else
				textArea.setCaretPosition(0);
		}
	}

	public static class insert_break implements ActionListener
	{
		public void actionPerformed(ActionEvent evt)
		{
			JEditTextArea textArea = getTextArea(evt);

			if(!textArea.isEditable())
			{
				textArea.getToolkit().beep();
				return;
			}

			textArea.setSelectedText("\n");
		}
	}

	public static class insert_tab implements ActionListener
	{
		public void actionPerformed(ActionEvent evt)
		{
			JEditTextArea textArea = getTextArea(evt);

			if(!textArea.isEditable())
			{
				textArea.getToolkit().beep();
				return;
			}

			textArea.overwriteSetSelectedText("\t");
		}
	}

	public static class next_char implements ActionListener
	{
		private boolean select;

		public next_char(boolean select)
		{
			this.select = select;
		}

		public void actionPerformed(ActionEvent evt)
		{
			JEditTextArea textArea = getTextArea(evt);
			int caret = textArea.getCaretPosition();
			if(caret == textArea.getDocumentLength())
			{
				textArea.getToolkit().beep();
				return;
			}

			if(select)
				textArea.select(textArea.getMarkPosition(),
					caret + 1);
			else
				textArea.setCaretPosition(caret + 1);
		}
	}

	public static class next_line implements ActionListener
	{
		private boolean select;

		public next_line(boolean select)
		{
			this.select = select;
		}

		public void actionPerformed(ActionEvent evt)
		{
			JEditTextArea textArea = getTextArea(evt);
			int caret = textArea.getCaretPosition();
			int line = textArea.getCaretLine();

			if(line == textArea.getLineCount() - 1)
			{
				textArea.getToolkit().beep();
				return;
			}

			int magic = textArea.getMagicCaretPosition();
			if(magic == -1)
			{
				magic = textArea.offsetToX(line,
					caret - textArea.getLineStartOffset(line));
			}

			caret = textArea.getLineStartOffset(line + 1)
				+ textArea.xToOffset(line + 1,magic);
			if(select)
				textArea.select(textArea.getMarkPosition(),caret);
			else
				textArea.setCaretPosition(caret);
			textArea.setMagicCaretPosition(magic);
		}
	}

	public static class next_page implements ActionListener
	{
		private boolean select;

		public next_page(boolean select)
		{
			this.select = select;
		}

		public void actionPerformed(ActionEvent evt)
		{
			JEditTextArea textArea = getTextArea(evt);
			int lineCount = textArea.getLineCount();
			int firstLine = textArea.getFirstLine();
			int visibleLines = textArea.getVisibleLines();
			int line = textArea.getCaretLine();

			firstLine += visibleLines;

			if(firstLine + visibleLines >= lineCount - 1)
				firstLine = lineCount - visibleLines;

			textArea.setFirstLine(firstLine);

			int caret = textArea.getLineStartOffset(
				Math.min(textArea.getLineCount() - 1,
				line + visibleLines));
			if(select)
				textArea.select(textArea.getMarkPosition(),caret);
			else
				textArea.setCaretPosition(caret);
		}
	}

	public static class next_word implements ActionListener
	{
		private boolean select;

		public next_word(boolean select)
		{
			this.select = select;
		}

		public void actionPerformed(ActionEvent evt)
		{
			JEditTextArea textArea = getTextArea(evt);
			int caret = textArea.getCaretPosition();
			int line = textArea.getCaretLine();
			int lineStart = textArea.getLineStartOffset(line);
			caret -= lineStart;

			String lineText = textArea.getLineText(textArea
				.getCaretLine());

			if(caret == lineText.length())
			{
				if(lineStart + caret == textArea.getDocumentLength())
				{
					textArea.getToolkit().beep();
					return;
				}
				caret++;
			}
			else
			{
				String noWordSep = (String)textArea.getDocument().getProperty("noWordSep");
				caret = TextUtilities.findWordEnd(lineText,caret,noWordSep);
			}

			if(select)
				textArea.select(textArea.getMarkPosition(),
					lineStart + caret);
			else
				textArea.setCaretPosition(lineStart + caret);
		}
	}

	public static class overwrite implements ActionListener
	{
		public void actionPerformed(ActionEvent evt)
		{
			JEditTextArea textArea = getTextArea(evt);
			textArea.setOverwriteEnabled(
				!textArea.isOverwriteEnabled());
		}
	}

	public static class prev_char implements ActionListener
	{
		private boolean select;

		public prev_char(boolean select)
		{
			this.select = select;
		}

		public void actionPerformed(ActionEvent evt)
		{
			JEditTextArea textArea = getTextArea(evt);
			int caret = textArea.getCaretPosition();
			if(caret == 0)
			{
				textArea.getToolkit().beep();
				return;
			}

			if(select)
				textArea.select(textArea.getMarkPosition(),
					caret - 1);
			else
				textArea.setCaretPosition(caret - 1);
		}
	}

	public static class prev_line implements ActionListener
	{
		private boolean select;

		public prev_line(boolean select)
		{
			this.select = select;
		}

		public void actionPerformed(ActionEvent evt)
		{
			JEditTextArea textArea = getTextArea(evt);
			int caret = textArea.getCaretPosition();
			int line = textArea.getCaretLine();

			if(line == 0)
			{
				textArea.getToolkit().beep();
				return;
			}

			int magic = textArea.getMagicCaretPosition();
			if(magic == -1)
			{
				magic = textArea.offsetToX(line,
					caret - textArea.getLineStartOffset(line));
			}

			caret = textArea.getLineStartOffset(line - 1)
				+ textArea.xToOffset(line - 1,magic);
			if(select)
				textArea.select(textArea.getMarkPosition(),caret);
			else
				textArea.setCaretPosition(caret);
			textArea.setMagicCaretPosition(magic);
		}
	}

	public static class prev_page implements ActionListener
	{
		private boolean select;

		public prev_page(boolean select)
		{
			this.select = select;
		}

		public void actionPerformed(ActionEvent evt)
		{
			JEditTextArea textArea = getTextArea(evt);
			int firstLine = textArea.getFirstLine();
			int visibleLines = textArea.getVisibleLines();
			int line = textArea.getCaretLine();

			if(firstLine < visibleLines)
				firstLine = visibleLines;

			textArea.setFirstLine(firstLine - visibleLines);

			int caret = textArea.getLineStartOffset(
				Math.max(0,line - visibleLines));
			if(select)
				textArea.select(textArea.getMarkPosition(),caret);
			else
				textArea.setCaretPosition(caret);
		}
	}

	public static class prev_word implements ActionListener
	{
		private boolean select;

		public prev_word(boolean select)
		{
			this.select = select;
		}

		public void actionPerformed(ActionEvent evt)
		{
			JEditTextArea textArea = getTextArea(evt);
			int caret = textArea.getCaretPosition();
			int line = textArea.getCaretLine();
			int lineStart = textArea.getLineStartOffset(line);
			caret -= lineStart;

			String lineText = textArea.getLineText(textArea
				.getCaretLine());

			if(caret == 0)
			{
				if(lineStart == 0)
				{
					textArea.getToolkit().beep();
					return;
				}
				caret--;
			}
			else
			{
				String noWordSep = (String)textArea.getDocument().getProperty("noWordSep");
				caret = TextUtilities.findWordStart(lineText,caret,noWordSep);
			}

			if(select)
				textArea.select(textArea.getMarkPosition(),
					lineStart + caret);
			else
				textArea.setCaretPosition(lineStart + caret);
		}
	}

	public static class repeat implements ActionListener,
		InputHandler.NonRecordable
	{
		public void actionPerformed(ActionEvent evt)
		{
			JEditTextArea textArea = getTextArea(evt);
			textArea.getInputHandler().setRepeatEnabled(true);
			String actionCommand = evt.getActionCommand();
			if(actionCommand != null)
			{
				textArea.getInputHandler().setRepeatCount(
					Integer.parseInt(actionCommand));
			}
		}
	}

	public static class toggle_rect implements ActionListener
	{
		public void actionPerformed(ActionEvent evt)
		{
			JEditTextArea textArea = getTextArea(evt);
			textArea.setSelectionRectangular(
				!textArea.isSelectionRectangular());
		}
	}

	public static class insert_char implements ActionListener,
		InputHandler.NonRepeatable
	{
		public void actionPerformed(ActionEvent evt)
		{
			JEditTextArea textArea = getTextArea(evt);
			String str = evt.getActionCommand();
			int repeatCount = textArea.getInputHandler().getRepeatCount();

			if(textArea.isEditable())
			{
				StringBuffer buf = new StringBuffer();
				for(int i = 0; i < repeatCount; i++)
					buf.append(str);
				textArea.overwriteSetSelectedText(buf.toString());
			}
			else
			{
				textArea.getToolkit().beep();
			}
		}
	}
}




/*

 Licensed to the Apache Software Foundation (ASF) under one or more
 contributor license agreements.  See the NOTICE file distributed with
 this work for additional information regarding copyright ownership.
 The ASF licenses this file to You under the Apache License, Version 2.0
 (the "License"); you may not use this file except in compliance with
 the License.  You may obtain a copy of the License at

 http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.

 */
package org.apache.batik.apps.svgbrowser;

import java.awt.Event;
import java.awt.EventQueue;
import java.awt.FileDialog;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.Toolkit;

import java.awt.image.BufferedImage;
import java.awt.print.PrinterException;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;

import javax.swing.Action;
import javax.swing.BorderFactory;
import javax.swing.ButtonGroup;
import javax.swing.ImageIcon;
import javax.swing.JComponent;
import javax.swing.JDialog;
import javax.swing.JFileChooser;

import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JRadioButtonMenuItem;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JToolBar;
import javax.swing.JWindow;
import javax.swing.KeyStroke;
import javax.swing.filechooser.FileFilter;
import javax.swing.text.Document;
import javax.swing.text.PlainDocument;

import org.apache.batik.apps.svgbrowser.srcview.SourceViewFrame;
import org.apache.batik.bridge.DefaultExternalResourceSecurity;
import org.apache.batik.bridge.DefaultScriptSecurity;
import org.apache.batik.bridge.EmbededExternalResourceSecurity;

import org.apache.batik.bridge.UpdateManagerEvent;
import org.apache.batik.bridge.UpdateManagerListener;
import org.apache.batik.dom.StyleSheetProcessingInstruction;
import org.apache.batik.dom.svg.LiveAttributeException;
import org.apache.batik.dom.svg.SVGOMDocument;
import org.apache.batik.dom.util.DOMUtilities;
import org.apache.batik.dom.util.DocumentDescriptor;
import org.apache.batik.dom.util.HashTable;
import org.apache.batik.dom.util.DOMUtilities;
import org.apache.batik.ext.swing.JAffineTransformChooser;
import org.apache.batik.swing.JSVGCanvas;
import org.apache.batik.swing.gvt.GVTTreeRendererEvent;

import org.apache.batik.transcoder.svg2svg.SVGTranscoder;
import org.apache.batik.util.ParsedURL;
import org.apache.batik.util.Platform;
import org.apache.batik.util.SVGConstants;
import org.apache.batik.util.Service;
import org.apache.batik.util.SVGConstants;
import org.apache.batik.util.XMLConstants;
import org.apache.batik.util.gui.DOMViewer;
import org.apache.batik.util.gui.ErrorConsole;
import org.apache.batik.util.gui.LocationBar;
import org.apache.batik.util.gui.MemoryMonitor;
import org.apache.batik.util.gui.TimelineViewer;
import org.apache.batik.util.gui.URIChooser;
import org.apache.batik.util.gui.ErrorConsole.ErrorInfo;
import org.apache.batik.util.gui.ErrorConsole.AttributeErrorInfo;
import org.apache.batik.util.gui.resource.ActionMap;
import org.apache.batik.util.gui.resource.JComponentModifier;
import org.apache.batik.util.gui.resource.MenuFactory;


/**
 * This class represents a SVG viewer swing frame.
 * 
 * @author <a href="mailto:stephane@hillion.org">Stephane Hillion</a>
 * @version $Id$
 */
public class JSVGViewerFrame extends JFrame implements ActionMap,
		SVGDocumentLoaderListener, GVTTreeBuilderListener,
		SVGLoadEventDispatcherListener, GVTTreeRendererListener,
		LinkActivationListener, UpdateManagerListener {
               GVTTreeBuilderListener,
               SVGLoadEventDispatcherListener,
               GVTTreeRendererListener,
               LinkActivationListener,
               UpdateManagerListener {

	private static String EOL;
	static {
		try {
			EOL = System.getProperty("line.separator", "\n");
		} catch (SecurityException e) {
			EOL = "\n";
		}
	}

	/**
	 * Kind of ugly, but we need to know if we are running before or after
	 * 1.4...
	 */
	protected static boolean priorJDK1_4 = true;

	/**
	 * If the following class can be found (it appeared in JDK 1.4), then we
	 * know we are post JDK 1.4.
	 */
	protected static final String JDK_1_4_PRESENCE_TEST_CLASS = "java.util.logging.LoggingPermission";
        = "java.util.logging.LoggingPermission";

	static {
		try {
			Class.forName(JDK_1_4_PRESENCE_TEST_CLASS);
			priorJDK1_4 = false;
		} catch (ClassNotFoundException e) {
		}
	}

	/**
	 * The gui resources file name
	 */
	public static final String RESOURCES = "org.apache.batik.apps.svgbrowser.resources.GUI";
        "org.apache.batik.apps.svgbrowser.resources.GUI";

	// The actions names.
	public static final String ABOUT_ACTION = "AboutAction";
    public static final String OPEN_ACTION = "OpenAction";
    public static final String OPEN_LOCATION_ACTION = "OpenLocationAction";
    public static final String NEW_WINDOW_ACTION = "NewWindowAction";
    public static final String RELOAD_ACTION = "ReloadAction";
    public static final String SAVE_AS_ACTION = "SaveAsAction";
    public static final String BACK_ACTION = "BackAction";
    public static final String FORWARD_ACTION = "ForwardAction";
    public static final String FULL_SCREEN_ACTION = "FullScreenAction";
    public static final String PRINT_ACTION = "PrintAction";
    public static final String EXPORT_AS_JPG_ACTION = "ExportAsJPGAction";
    public static final String EXPORT_AS_PNG_ACTION = "ExportAsPNGAction";
    public static final String EXPORT_AS_TIFF_ACTION = "ExportAsTIFFAction";
    public static final String PREFERENCES_ACTION = "PreferencesAction";
    public static final String CLOSE_ACTION = "CloseAction";
    public static final String VIEW_SOURCE_ACTION = "ViewSourceAction";
    public static final String EXIT_ACTION = "ExitAction";
    public static final String RESET_TRANSFORM_ACTION = "ResetTransformAction";
    public static final String ZOOM_IN_ACTION = "ZoomInAction";
    public static final String ZOOM_OUT_ACTION = "ZoomOutAction";
    public static final String PREVIOUS_TRANSFORM_ACTION = "PreviousTransformAction";
    public static final String NEXT_TRANSFORM_ACTION = "NextTransformAction";
    public static final String USE_STYLESHEET_ACTION = "UseStylesheetAction";
    public static final String PLAY_ACTION = "PlayAction";
    public static final String PAUSE_ACTION = "PauseAction";
    public static final String STOP_ACTION = "StopAction";
    public static final String MONITOR_ACTION = "MonitorAction";
    public static final String DOM_VIEWER_ACTION = "DOMViewerAction";
    public static final String SET_TRANSFORM_ACTION = "SetTransformAction";
    public static final String FIND_DIALOG_ACTION = "FindDialogAction";
    public static final String THUMBNAIL_DIALOG_ACTION = "ThumbnailDialogAction";
    public static final String FLUSH_ACTION = "FlushAction";
    public static final String TOGGLE_DEBUGGER_ACTION = "ToggleDebuggerAction";

	public static final String OPEN_ACTION = "OpenAction";
     * The cursor indicating that an operation is pending.
     */
    public static final Cursor WAIT_CURSOR =
        new Cursor(Cursor.WAIT_CURSOR);

	public static final String OPEN_LOCATION_ACTION = "OpenLocationAction";
     * The default cursor.
     */
    public static final Cursor DEFAULT_CURSOR =
        new Cursor(Cursor.DEFAULT_CURSOR);

	public static final String NEW_WINDOW_ACTION = "NewWindowAction";
     * Name for the os-name property
     */
    public static final String PROPERTY_OS_NAME
        = Resources.getString("JSVGViewerFrame.property.os.name");

	public static final String RELOAD_ACTION = "ReloadAction";
     * Name for the os.name default
     */
    public static final String PROPERTY_OS_NAME_DEFAULT
        = Resources.getString("JSVGViewerFrame.property.os.name.default");

	public static final String SAVE_AS_ACTION = "SaveAsAction";
     * Name for the os.name property prefix we are looking
     * for in OpenAction to work around JFileChooser bug
     */
    public static final String PROPERTY_OS_WINDOWS_PREFIX
        = Resources.getString("JSVGViewerFrame.property.os.windows.prefix");

	public static final String BACK_ACTION = "BackAction";
     * Resource string name for the Open dialog.
     */
    protected static final String OPEN_TITLE = "Open.title";

	public static final String FORWARD_ACTION = "ForwardAction";
     * The input handlers
     */
    protected static Vector handlers;

	public static final String FULL_SCREEN_ACTION = "FullScreenAction";
     * The default input handler
     */
    protected static SquiggleInputHandler defaultHandler = new SVGInputHandler();

	public static final String PRINT_ACTION = "PrintAction";
     * The resource bundle
     */
    protected static ResourceBundle bundle;

	public static final String EXPORT_AS_JPG_ACTION = "ExportAsJPGAction";
     * The resource manager
     */
    protected static ResourceManager resources;
    static {
        bundle = ResourceBundle.getBundle(RESOURCES, Locale.getDefault());
        resources = new ResourceManager(bundle);
    }

	public static final String EXPORT_AS_PNG_ACTION = "ExportAsPNGAction";
     * The current application.
     */
    protected Application application;

	public static final String EXPORT_AS_TIFF_ACTION = "ExportAsTIFFAction";
     * The JSVGCanvas.
     */
    protected Canvas svgCanvas;

	public static final String PREFERENCES_ACTION = "PreferencesAction";
     * An extension of JSVGCanvas that exposes the Rhino interpreter.
     */
    protected static class Canvas extends JSVGCanvas {

	public static final String CLOSE_ACTION = "CloseAction";
         * Creates a new Canvas.
         */
        public Canvas(SVGUserAgent ua, boolean eventsEnabled,
                      boolean selectableText) {
            super(ua, eventsEnabled, selectableText);
        }

	public static final String VIEW_SOURCE_ACTION = "ViewSourceAction";
         * Returns the Rhino interpreter for this canvas.
         */
        public Object getRhinoInterpreter() {
            if (bridgeContext == null) {
                return null;
            }
            return bridgeContext.getInterpreter("text/ecmascript");
        }
    }

	public static final String EXIT_ACTION = "ExitAction";
     * The panel where the svgCanvas is displayed
     */
    protected JPanel svgCanvasPanel;

	public static final String RESET_TRANSFORM_ACTION = "ResetTransformAction";
     * A window used for full screen display
     */
    protected JWindow window;

	public static final String ZOOM_IN_ACTION = "ZoomInAction";
     * The memory monitor frame.
     */
    protected static JFrame memoryMonitorFrame;

	public static final String ZOOM_OUT_ACTION = "ZoomOutAction";
     * The current path.
     */
    protected File currentPath = new File("");

	public static final String PREVIOUS_TRANSFORM_ACTION = "PreviousTransformAction";
     * The current export path.
     */
    protected File currentSavePath = new File("");

	public static final String NEXT_TRANSFORM_ACTION = "NextTransformAction";
     * The back action
     */
    protected BackAction backAction = new BackAction();

	public static final String USE_STYLESHEET_ACTION = "UseStylesheetAction";
     * The forward action
     */
    protected ForwardAction forwardAction = new ForwardAction();

	public static final String PLAY_ACTION = "PlayAction";
     * The play action
     */
    protected PlayAction playAction = new PlayAction();

	public static final String PAUSE_ACTION = "PauseAction";
     * The pause action
     */
    protected PauseAction pauseAction = new PauseAction();

	public static final String STOP_ACTION = "StopAction";
     * The stop action
     */
    protected StopAction stopAction = new StopAction();

	public static final String MONITOR_ACTION = "MonitorAction";
     * The previous transform action
     */
    protected PreviousTransformAction previousTransformAction =
        new PreviousTransformAction();

	public static final String DOM_VIEWER_ACTION = "DOMViewerAction";
     * The next transform action
     */
    protected NextTransformAction nextTransformAction =
        new NextTransformAction();

	public static final String TIMELINE_VIEWER_ACTION = "TimelineViewerAction";
     * The use (author) stylesheet action
     */
    protected UseStylesheetAction useStylesheetAction =
        new UseStylesheetAction();

	public static final String SET_TRANSFORM_ACTION = "SetTransformAction";
     * The debug flag.
     */
    protected boolean debug;

	public static final String FIND_DIALOG_ACTION = "FindDialogAction";
     * The auto adjust flag.
     */
    protected boolean autoAdjust = true;

	public static final String THUMBNAIL_DIALOG_ACTION = "ThumbnailDialogAction";
     * Whether the update manager was stopped.
     */
    protected boolean managerStopped;

	public static final String FLUSH_ACTION = "FlushAction";
     * The SVG user agent.
     */
    protected SVGUserAgent userAgent = new UserAgent();

	public static final String TOGGLE_DEBUGGER_ACTION = "ToggleDebuggerAction";
     * The current document.
     */
    protected SVGDocument svgDocument;

	/**
	 * The cursor indicating that an operation is pending.
	 */
	public static final Cursor WAIT_CURSOR = new Cursor(Cursor.WAIT_CURSOR);

	/**
	 * The default cursor.
	 */
	public static final Cursor DEFAULT_CURSOR = new Cursor(
			Cursor.DEFAULT_CURSOR);

	/**
	 * Name for the os-name property
	 */
	public static final String PROPERTY_OS_NAME = Resources
			.getString("JSVGViewerFrame.property.os.name");

	/**
	 * Name for the os.name default
	 */
	public static final String PROPERTY_OS_NAME_DEFAULT = Resources
			.getString("JSVGViewerFrame.property.os.name.default");

	/**
	 * Name for the os.name property prefix we are looking for in OpenAction to
	 * work around JFileChooser bug
	 */
	public static final String PROPERTY_OS_WINDOWS_PREFIX = Resources
			.getString("JSVGViewerFrame.property.os.windows.prefix");

	/**
	 * Resource string name for the Open dialog.
	 */
	protected static final String OPEN_TITLE = "Open.title";

	/**
	 * The input handlers
	 */
	protected static Vector handlers;

	/**
	 * The default input handler
	 */
	protected static SquiggleInputHandler defaultHandler = new SVGInputHandler();

	/**
	 * The resource bundle
	 */
	protected static ResourceBundle bundle;

	/**
	 * The resource manager
	 */
	protected static ResourceManager resources;
	static {
		bundle = ResourceBundle.getBundle(RESOURCES, Locale.getDefault());
		resources = new ResourceManager(bundle);
	}

	/**
	 * The current application.
	 */
	protected Application application;

	/**
	 * The JSVGCanvas.
	 */
	protected Canvas svgCanvas;

	/**
	 * An extension of JSVGCanvas that exposes the Rhino interpreter.
	 */
	protected static class Canvas extends JSVGCanvas {
        application = app;

		/**
		 * Creates a new Canvas.
		 */
		public Canvas(SVGUserAgent ua, boolean eventsEnabled,
				boolean selectableText) {
			super(ua, eventsEnabled, selectableText);
		}

		/**
		 * Returns the Rhino interpreter for this canvas.
		 */
		public Object getRhinoInterpreter() {
			if (bridgeContext == null) {
				return null;
			}
			return bridgeContext.getInterpreter("text/ecmascript");
		}
	}

	/**
	 * The panel where the svgCanvas is displayed
	 */
	protected JPanel svgCanvasPanel;

	/**
	 * A window used for full screen display
	 */
	protected JWindow window;
                    return s;
                }

	/**
	 * The memory monitor frame.
	 */
	protected static JFrame memoryMonitorFrame;

	/**
	 * The current path.
	 */
	protected File currentPath = new File("");
                 */
                public void setMySize(Dimension d) {
                    setPreferredSize(d);
                    invalidate();
                    if (JSVGViewerFrame.this.autoAdjust) {
                        Platform.unmaximize(JSVGViewerFrame.this);
                        JSVGViewerFrame.this.pack();
                    }
                }

	/**
	 * The current export path.
	 */
	protected File currentSavePath = new File("");

	/**
	 * The back action
	 */
	protected BackAction backAction = new BackAction();

	/**
	 * The forward action
	 */
	protected ForwardAction forwardAction = new ForwardAction();

	/**
	 * The play action
	 */
	protected PlayAction playAction = new PlayAction();

	/**
	 * The pause action
	 */
	protected PauseAction pauseAction = new PauseAction();
        imap.put(key, FULL_SCREEN_ACTION);

	/**
	 * The stop action
	 */
	protected StopAction stopAction = new StopAction();

	/**
	 * The previous transform action
	 */
	protected PreviousTransformAction previousTransformAction = new PreviousTransformAction();
        listeners.put(RELOAD_ACTION, new ReloadAction());
        listeners.put(SAVE_AS_ACTION, new SaveAsAction());
        listeners.put(BACK_ACTION, backAction);
        listeners.put(FORWARD_ACTION, forwardAction);
        listeners.put(PRINT_ACTION, new PrintAction());
        listeners.put(EXPORT_AS_JPG_ACTION, new ExportAsJPGAction());
        listeners.put(EXPORT_AS_PNG_ACTION, new ExportAsPNGAction());
        listeners.put(EXPORT_AS_TIFF_ACTION, new ExportAsTIFFAction());
        listeners.put(PREFERENCES_ACTION, new PreferencesAction());
        listeners.put(CLOSE_ACTION, new CloseAction());
        listeners.put(EXIT_ACTION, application.createExitAction(this));
        listeners.put(VIEW_SOURCE_ACTION, new ViewSourceAction());

	/**
	 * The next transform action
	 */
	protected NextTransformAction nextTransformAction = new NextTransformAction();
                      cMap.get(JSVGCanvas.ZOOM_IN_ACTION));
        listeners.put(ZOOM_OUT_ACTION,
                      cMap.get(JSVGCanvas.ZOOM_OUT_ACTION));

	/**
	 * The use (author) stylesheet action
	 */
	protected UseStylesheetAction useStylesheetAction = new UseStylesheetAction();

	/**
	 * The debug flag.
	 */
	protected boolean debug;

	/**
	 * The auto adjust flag.
	 */
	protected boolean autoAdjust = true;
        listeners.put(MONITOR_ACTION, new MonitorAction());
        listeners.put(DOM_VIEWER_ACTION, new DOMViewerAction());
        listeners.put(SET_TRANSFORM_ACTION, new SetTransformAction());
        listeners.put(FIND_DIALOG_ACTION, new FindDialogAction());
        listeners.put(THUMBNAIL_DIALOG_ACTION, new ThumbnailDialogAction());
        listeners.put(FLUSH_ACTION, new FlushAction());
        listeners.put(TOGGLE_DEBUGGER_ACTION, new ToggleDebuggerAction());

	/**
	 * Whether the update manager was stopped.
	 */
	protected boolean managerStopped;
            JMenuBar mb =
                mf.createJMenuBar("MenuBar", application.getUISpecialization());
            setJMenuBar(mb);

	/**
	 * The SVG user agent.
	 */
	protected SVGUserAgent userAgent = new UserAgent();

	/**
	 * The current document.
	 */
	protected SVGDocument svgDocument;
                }
            }
            p = new JPanel(new BorderLayout());

	/**
	 * The descriptor associated with the current document.
	 */
	protected DocumentDescriptor docDescriptor;
            getContentPane().add(p, BorderLayout.NORTH);
            p.add(tb, BorderLayout.NORTH);
            p.add(new javax.swing.JSeparator(), BorderLayout.CENTER);
            p.add(locationBar = new LocationBar(), BorderLayout.SOUTH);
            locationBar.setBorder(BorderFactory.createEmptyBorder(2, 2, 2, 2));

	/**
	 * Document text, stored when the document is loaded
	 */
	protected String docText;

	/**
	 * The URI chooser.
	 */
	protected URIChooser uriChooser;

	/**
	 * The DOM viewer.
	 */
	protected DOMViewer domViewer;

	/**
	 * The Timeline viewer.
	 */
	protected TimelineViewer timelineViewer;

	/**
	 * The Find dialog.
	 */
	protected FindDialog findDialog;
        svgCanvas.addLinkActivationListener(this);
        svgCanvas.addUpdateManagerListener(this);

	/**
	 * The Find dialog.
	 */
	protected ThumbnailDialog thumbnailDialog;
                        statusBar.setYPosition(e.getY());
                    } else {
                        try {
                            AffineTransform at;
                            at = svgCanvas.getViewBoxTransform();
                            if (at != null) {
                                at = at.createInverse();
                                Point2D p2d =
                                    at.transform(new Point2D.Float(e.getX(), e.getY()),
                                                 null);
                                statusBar.setXPosition((float)p2d.getX());
                                statusBar.setYPosition((float)p2d.getY());
                                return;
                            }
                        } catch (NoninvertibleTransformException ex) {
                        }
                        statusBar.setXPosition(e.getX());
                        statusBar.setYPosition(e.getY());
                    }
                }
            });
        svgCanvas.addMouseListener(new MouseAdapter() {
                public void mouseExited(MouseEvent e) {
                    Dimension dim = svgCanvas.getSize();
                    if (svgDocument == null) {
                        statusBar.setWidth(dim.width);
                        statusBar.setHeight(dim.height);
                    } else {
                        try {
                            AffineTransform at;
                            at = svgCanvas.getViewBoxTransform();
                            if (at != null) {
                                at = at.createInverse();
                                Point2D o =
                                    at.transform(new Point2D.Float(0, 0),
                                                 null);
                                Point2D p2d =
                                    at.transform(new Point2D.Float(dim.width,
                                                                   dim.height),
                                                 null);
                                statusBar.setWidth((float)(p2d.getX() - o.getX()));
                                statusBar.setHeight((float)(p2d.getY() - o.getY()));
                                return;
                            }
                        } catch (NoninvertibleTransformException ex) {
                        }
                        statusBar.setWidth(dim.width);
                        statusBar.setHeight(dim.height);
                    }
                }
            });
        svgCanvas.addComponentListener(new ComponentAdapter() {
                public void componentResized(ComponentEvent e) {
                    Dimension dim = svgCanvas.getSize();
                    if (svgDocument == null) {
                        statusBar.setWidth(dim.width);
                        statusBar.setHeight(dim.height);
                    } else {
                        try {
                            AffineTransform at;
                            at = svgCanvas.getViewBoxTransform();
                            if (at != null) {
                                at = at.createInverse();
                                Point2D o =
                                    at.transform(new Point2D.Float(0, 0),
                                                 null);
                                Point2D p2d =
                                    at.transform(new Point2D.Float(dim.width,
                                                                   dim.height),
                                                 null);
                                statusBar.setWidth((float)(p2d.getX() - o.getX()));
                                statusBar.setHeight((float)(p2d.getY() - o.getY()));
                                return;
                            }
                        } catch (NoninvertibleTransformException ex) {
                        }
                        statusBar.setWidth(dim.width);
                        statusBar.setHeight(dim.height);
                    }
                }
            });

	/**
	 * The transform dialog
	 */
	protected JAffineTransformChooser.Dialog transformDialog;
                String t = "";
                if (i != -1) {
                    t = st.substring(i + 1);
                    st = st.substring(0, i);
                }

	/**
	 * The location bar.
	 */
	protected LocationBar locationBar;

	/**
	 * The status bar.
	 */
	protected StatusBar statusBar;
                            return;
                        } else {
                            try {
                                st = f.getCanonicalPath();
                                if (st.startsWith("/")) {
                                    st = "file:" + st;
                                } else {
                                    st = "file:/" + st;
                                }
                            } catch (IOException ex) {
                            }
                        }
                    }
                }catch(SecurityException se){
                    // Could not patch the file URI for security
                    // reasons (e.g., when run as an unsigned
                    // JavaWebStart jar): file access is not
                    // allowed. Loading will fail, but there is
                    // nothing more to do at this point.
                }

	/**
	 * The initial frame title.
	 */
	protected String title;
                    ParsedURL purl = new ParsedURL(docPURL, st);
                    fi = (fi == null) ? "" : fi;
                    if (docPURL.equals(purl) && t.equals(fi)) {
                        return;
                    }
                }
                if (t.length() != 0) {
                    st += '#' + t;
                }
                locationBar.setText(st);
                locationBar.addToHistory(st);
                showSVGDocument(st);
            }
        });
    }

	/**
	 * The local history.
	 */
	protected LocalHistory localHistory;
        hideDebugger();
        svgCanvas.dispose();
        super.dispose();
    }

	/**
	 * The transform history.
	 */
	protected TransformHistory transformHistory = new TransformHistory();
        debug = b;
    }

	/**
	 * The alternate style-sheet title.
	 */
	protected String alternateStyleSheet;
        autoAdjust = b;
    }

	/**
	 * The debugger object.
	 */
	protected Debugger debugger;
        return svgCanvas;
    }

	/**
	 * Creates a new SVG viewer frame.
	 */
	public JSVGViewerFrame(Application app) {
		application = app;
            return f.getAbsoluteFile();
        }
        return f;
    }

		addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				application.closeJSVGViewerFrame(JSVGViewerFrame.this);
			}
		});
            debugger = new Debugger(this, locationBar.getText());
            debugger.initialize();
        }
    }

		//
		// Set the frame's maximum size so that content
		// bigger than the screen does not cause the creation
		// of unnecessary large images.
		//
		svgCanvas = new Canvas(userAgent, true, true) {
			Dimension screenSize;
            debugger.dispose();
            debugger = null;
        }
    }

			{
				screenSize = Toolkit.getDefaultToolkit().getScreenSize();
				setMaximumSize(screenSize);
			}

			public Dimension getPreferredSize() {
				Dimension s = super.getPreferredSize();
				if (s.width > screenSize.width)
					s.width = screenSize.width;
				if (s.height > screenSize.height)
					s.height = screenSize.height;
				return s;
			}

			/**
			 * This method is called when the component knows the desired size
			 * of the window (based on width/height of outermost SVG element).
			 * We override it to immediately pack this frame.
			 */
			public void setMySize(Dimension d) {
				setPreferredSize(d);
				invalidate();
				if (JSVGViewerFrame.this.autoAdjust) {
					Platform.unmaximize(JSVGViewerFrame.this);
					JSVGViewerFrame.this.pack();
				}
			}

			public void setDisableInteractions(boolean b) {
				super.setDisableInteractions(b);
         */
        protected static Class contextFactoryClass;

				// Disable/Enable all our different ways to adjust the
				// rendering transform (menus, toolbar, thumbnail, keyboard).
        protected static final int GO_METHOD                    = 1;
        protected static final int SET_EXIT_ACTION_METHOD       = 2;
        protected static final int ATTACH_TO_METHOD             = 3;
        protected static final int DETACH_METHOD                = 4;
        protected static final int DISPOSE_METHOD               = 5;
        protected static final int GET_DEBUG_FRAME_METHOD       = 6;

				((Action) listeners.get(SET_TRANSFORM_ACTION)).setEnabled(!b);
         * Rhino debugger class constructor.
         */
        protected static Constructor debuggerConstructor;

				if (thumbnailDialog != null)
					thumbnailDialog.setInteractionEnabled(!b);
			}
		};

		javax.swing.ActionMap map = svgCanvas.getActionMap();
		map.put(FULL_SCREEN_ACTION, new FullScreenAction());
		javax.swing.InputMap imap = svgCanvas
				.getInputMap(JComponent.WHEN_FOCUSED);
		KeyStroke key = KeyStroke.getKeyStroke(KeyEvent.VK_F11, 0);
		imap.put(key, FULL_SCREEN_ACTION);

		svgCanvas.setDoubleBufferedRendering(true);
         * The {@code getContextFactory} method on the {@link
         * org.apache.batik.script.rhino.RhinoInterpreter} class.
         */
        protected static Method getContextFactoryMethod;

		listeners.put(ABOUT_ACTION, new AboutAction());
		listeners.put(OPEN_ACTION, new OpenAction());
		listeners.put(OPEN_LOCATION_ACTION, new OpenLocationAction());
		listeners.put(NEW_WINDOW_ACTION, new NewWindowAction());
		listeners.put(RELOAD_ACTION, new ReloadAction());
		listeners.put(SAVE_AS_ACTION, new SaveAsAction());
		listeners.put(BACK_ACTION, backAction);
		listeners.put(FORWARD_ACTION, forwardAction);
		listeners.put(PRINT_ACTION, new PrintAction());
		listeners.put(EXPORT_AS_JPG_ACTION, new ExportAsJPGAction());
		listeners.put(EXPORT_AS_PNG_ACTION, new ExportAsPNGAction());
		listeners.put(EXPORT_AS_TIFF_ACTION, new ExportAsTIFFAction());
		listeners.put(PREFERENCES_ACTION, new PreferencesAction());
		listeners.put(CLOSE_ACTION, new CloseAction());
		listeners.put(EXIT_ACTION, application.createExitAction(this));
		listeners.put(VIEW_SOURCE_ACTION, new ViewSourceAction());
                    dc.getMethod("dispose", (Class[]) null),
                    dc.getMethod("getDebugFrame", (Class[]) null)
                };
                getContextFactoryMethod =
                    rhinoInterpreterClass.getMethod("getContextFactory",
                                                    (Class[]) null);
                debuggerClass = dc;
                isPresent = true;
            } catch (ClassNotFoundException cnfe) {
            } catch (NoSuchMethodException nsme) {
            } catch (SecurityException se) {
            }
        }

		javax.swing.ActionMap cMap = svgCanvas.getActionMap();
		listeners.put(RESET_TRANSFORM_ACTION, cMap
				.get(JSVGCanvas.RESET_TRANSFORM_ACTION));
		listeners.put(ZOOM_IN_ACTION, cMap.get(JSVGCanvas.ZOOM_IN_ACTION));
		listeners.put(ZOOM_OUT_ACTION, cMap.get(JSVGCanvas.ZOOM_OUT_ACTION));

		listeners.put(PREVIOUS_TRANSFORM_ACTION, previousTransformAction);
		key = KeyStroke.getKeyStroke(KeyEvent.VK_K, KeyEvent.CTRL_MASK);
		imap.put(key, previousTransformAction);
        protected JSVGViewerFrame svgFrame;

		listeners.put(NEXT_TRANSFORM_ACTION, nextTransformAction);
		key = KeyStroke.getKeyStroke(KeyEvent.VK_L, KeyEvent.CTRL_MASK);
		imap.put(key, nextTransformAction);
        public Debugger(JSVGViewerFrame frame, String url) {
            svgFrame = frame;
            try {
                debuggerInstance = debuggerConstructor.newInstance
                    (new Object[] { "JavaScript Debugger - " + url });
            } catch (IllegalAccessException iae) {
                throw new RuntimeException(iae.getMessage());
            } catch (InvocationTargetException ite) {
                ite.printStackTrace();
                throw new RuntimeException(ite.getMessage());
            } catch (InstantiationException ie) {
                throw new RuntimeException(ie.getMessage());
            }
        }

		listeners.put(USE_STYLESHEET_ACTION, useStylesheetAction);
		listeners.put(PLAY_ACTION, playAction);
		listeners.put(PAUSE_ACTION, pauseAction);
		listeners.put(STOP_ACTION, stopAction);
		listeners.put(MONITOR_ACTION, new MonitorAction());
		listeners.put(DOM_VIEWER_ACTION, new DOMViewerAction());
		listeners.put(TIMELINE_VIEWER_ACTION, new TimelineViewerAction());
		listeners.put(SET_TRANSFORM_ACTION, new SetTransformAction());
		listeners.put(FIND_DIALOG_ACTION, new FindDialogAction());
		listeners.put(THUMBNAIL_DIALOG_ACTION, new ThumbnailDialogAction());
		listeners.put(FLUSH_ACTION, new FlushAction());
		listeners.put(TOGGLE_DEBUGGER_ACTION, new ToggleDebuggerAction());

		JPanel p = null;
		try {
			// Create the menu
			MenuFactory mf = new MenuFactory(bundle, this);
			JMenuBar mb = mf.createJMenuBar("MenuBar", application
					.getUISpecialization());
			setJMenuBar(mb);
            // items that can't be used and change 'Exit' to 'Close'.
            JFrame   debugGui = getDebugFrame();
            JMenuBar menuBar  = debugGui.getJMenuBar();
            JMenu    menu     = menuBar.getMenu(0);
            menu.getItem(0).setEnabled(false); // Open...
            menu.getItem(1).setEnabled(false); // Run...
            menu.getItem(3).setText
                (Resources.getString("Close.text")); // Exit -> "Close"
            menu.getItem(3).setAccelerator
                (KeyStroke.getKeyStroke(KeyEvent.VK_W, Event.CTRL_MASK));

			localHistory = new LocalHistory(mb, this);
            debugGui.pack();
            setExitAction(new Runnable() {
                    public void run() {
                        svgFrame.hideDebugger();
                    }});
            WindowAdapter wa = new WindowAdapter() {
                    public void windowClosing(WindowEvent e) {
                        svgFrame.hideDebugger();
                    }};
            debugGui.addWindowListener(wa);
            debugGui.setVisible(true);
            attach();
        }

			String[] uri = application.getVisitedURIs();
			for (int i = 0; i < uri.length; i++) {
				if (uri[i] != null && !"".equals(uri[i])) {
					localHistory.update(uri[i]);
				}
			}
			p = new JPanel(new BorderLayout());
            }
        }

			// Create the toolbar
			ToolBarFactory tbf = new ToolBarFactory(bundle, this);
			JToolBar tb = tbf.createJToolBar("ToolBar");
			tb.setFloatable(false);
			getContentPane().add(p, BorderLayout.NORTH);
			p.add(tb, BorderLayout.NORTH);
			p.add(new javax.swing.JSeparator(), BorderLayout.CENTER);
			p.add(locationBar = new LocationBar(), BorderLayout.SOUTH);
			locationBar.setBorder(BorderFactory.createEmptyBorder(2, 2, 2, 2));
            } catch (IllegalAccessException iae) {
                throw new RuntimeException(iae.getMessage());
            }
        }

		} catch (MissingResourceException e) {
			System.out.println(e.getMessage());
			System.exit(0);
		}
            try {
                debuggerMethods[SET_EXIT_ACTION_METHOD].invoke
                    (debuggerInstance, new Object[] { r });
            } catch (InvocationTargetException ite) {
                throw new RuntimeException(ite.getMessage());
            } catch (IllegalAccessException iae) {
                throw new RuntimeException(iae.getMessage());
            }
        }

		svgCanvasPanel = new JPanel(new BorderLayout());
		svgCanvasPanel.setBorder(BorderFactory.createEtchedBorder());
         */
        public void attachTo(Object contextFactory) {
            try {
                debuggerMethods[ATTACH_TO_METHOD].invoke
                    (debuggerInstance, new Object[] { contextFactory });
            } catch (InvocationTargetException ite) {
                throw new RuntimeException(ite.getMessage());
            } catch (IllegalAccessException iae) {
                throw new RuntimeException(iae.getMessage());
            }
        }

		svgCanvasPanel.add(svgCanvas, BorderLayout.CENTER);
		p = new JPanel(new BorderLayout());
		p.add(svgCanvasPanel, BorderLayout.CENTER);
		p.add(statusBar = new StatusBar(), BorderLayout.SOUTH);
            try {
                debuggerMethods[DETACH_METHOD].invoke(debuggerInstance,
                                                      (Object[]) null);
            } catch (InvocationTargetException ite) {
                throw new RuntimeException(ite.getMessage());
            } catch (IllegalAccessException iae) {
                throw new RuntimeException(iae.getMessage());
            }
        }

		getContentPane().add(p, BorderLayout.CENTER);
         * Calls {@code go} on {@link #debuggerInstance}.
         */
        public void go() {
            try {
                debuggerMethods[GO_METHOD].invoke(debuggerInstance,
                                                  (Object[]) null);
            } catch (InvocationTargetException ite) {
                throw new RuntimeException(ite.getMessage());
            } catch (IllegalAccessException iae) {
                throw new RuntimeException(iae.getMessage());
            }
        }

		svgCanvas.addSVGDocumentLoaderListener(this);
		svgCanvas.addGVTTreeBuilderListener(this);
		svgCanvas.addSVGLoadEventDispatcherListener(this);
		svgCanvas.addGVTTreeRendererListener(this);
		svgCanvas.addLinkActivationListener(this);
		svgCanvas.addUpdateManagerListener(this);
                    (debuggerInstance, (Object[]) null);
            } catch (InvocationTargetException ite) {
                throw new RuntimeException(ite.getMessage());
            } catch (IllegalAccessException iae) {
                throw new RuntimeException(iae.getMessage());
            }
        }

		svgCanvas.addMouseMotionListener(new MouseMotionAdapter() {
			public void mouseMoved(MouseEvent e) {
				if (svgDocument == null) {
					statusBar.setXPosition(e.getX());
					statusBar.setYPosition(e.getY());
				} else {
					try {
						AffineTransform at;
						at = svgCanvas.getViewBoxTransform();
						if (at != null) {
							at = at.createInverse();
							Point2D p2d = at.transform(new Point2D.Float(e
									.getX(), e.getY()), null);
							statusBar.setXPosition((float) p2d.getX());
							statusBar.setYPosition((float) p2d.getY());
							return;
						}
					} catch (NoninvertibleTransformException ex) {
					}
					statusBar.setXPosition(e.getX());
					statusBar.setYPosition(e.getY());
				}
			}
		});
		svgCanvas.addMouseListener(new MouseAdapter() {
			public void mouseExited(MouseEvent e) {
				Dimension dim = svgCanvas.getSize();
				if (svgDocument == null) {
					statusBar.setWidth(dim.width);
					statusBar.setHeight(dim.height);
				} else {
					try {
						AffineTransform at;
						at = svgCanvas.getViewBoxTransform();
						if (at != null) {
							at = at.createInverse();
							Point2D o = at.transform(new Point2D.Float(0, 0),
									null);
							Point2D p2d = at.transform(new Point2D.Float(
									dim.width, dim.height), null);
							statusBar.setWidth((float) (p2d.getX() - o.getX()));
							statusBar
									.setHeight((float) (p2d.getY() - o.getY()));
							return;
						}
					} catch (NoninvertibleTransformException ex) {
					}
					statusBar.setWidth(dim.width);
					statusBar.setHeight(dim.height);
				}
			}
		});
		svgCanvas.addComponentListener(new ComponentAdapter() {
			public void componentResized(ComponentEvent e) {
				Dimension dim = svgCanvas.getSize();
				if (svgDocument == null) {
					statusBar.setWidth(dim.width);
					statusBar.setHeight(dim.height);
				} else {
					try {
						AffineTransform at;
						at = svgCanvas.getViewBoxTransform();
						if (at != null) {
							at = at.createInverse();
							Point2D o = at.transform(new Point2D.Float(0, 0),
									null);
							Point2D p2d = at.transform(new Point2D.Float(
									dim.width, dim.height), null);
							statusBar.setWidth((float) (p2d.getX() - o.getX()));
							statusBar
									.setHeight((float) (p2d.getY() - o.getY()));
							return;
						}
					} catch (NoninvertibleTransformException ex) {
					}
					statusBar.setWidth(dim.width);
					statusBar.setHeight(dim.height);
				}
			}
		});

		locationBar.addActionListener(new AbstractAction() {
			public void actionPerformed(ActionEvent e) {
				String st = locationBar.getText().trim();
				int i = st.indexOf('#');
				String t = "";
				if (i != -1) {
					t = st.substring(i + 1);
					st = st.substring(0, i);
				}
                throw new RuntimeException(ite.getMessage());
            } catch (IllegalAccessException iae) {
                throw new RuntimeException(iae.getMessage());
            }
        }
    }

				if (st.equals(""))
					return;
     */
    public class AboutAction extends AbstractAction {
        public AboutAction(){
        }

				try {
					File f = new File(st);
					if (f.exists()) {
						if (f.isDirectory()) {
							return;
						} else {
							try {
								st = f.getCanonicalPath();
								if (st.startsWith("/")) {
									st = "file:" + st;
								} else {
									st = "file:/" + st;
								}
							} catch (IOException ex) {
							}
						}
					}
				} catch (SecurityException se) {
					// Could not patch the file URI for security
					// reasons (e.g., when run as an unsigned
					// JavaWebStart jar): file access is not
					// allowed. Loading will fail, but there is
					// nothing more to do at this point.
				}

				String fi = svgCanvas.getFragmentIdentifier();
				if (svgDocument != null) {
					ParsedURL docPURL = new ParsedURL(svgDocument.getURL());
					ParsedURL purl = new ParsedURL(docPURL, st);
					fi = (fi == null) ? "" : fi;
					if (docPURL.equals(purl) && t.equals(fi)) {
						return;
					}
				}
				if (t.length() != 0) {
					st += '#' + t;
				}
				locationBar.setText(st);
				locationBar.addToHistory(st);
				showSVGDocument(st);
			}
		});
	}

	/**
	 * Call dispose on canvas as well.
	 */
	public void dispose() {
		hideDebugger();
		svgCanvas.dispose();
		super.dispose();
	}
                fileDialog.setFilenameFilter(new FilenameFilter() {
                    public boolean accept(File dir, String name) {
                        Iterator iter = getHandlers().iterator();
                        while (iter.hasNext()) {
                            SquiggleInputHandler handler
                                = (SquiggleInputHandler)iter.next();
                            if (handler.accept(new File(dir, name))) {
                                return true;
                            }
                        }
                        return false;
                    }
                });
                fileDialog.setVisible(true);
                String filename = fileDialog.getFile();
                if (fileDialog != null) {
                    String dirname = fileDialog.getDirectory();
                    f = new File(dirname, filename);
                }
            } else {
                JFileChooser fileChooser = null;

	/**
	 * Whether to show the debug traces.
	 */
	public void setDebug(boolean b) {
		debug = b;
	}

	/**
	 * Whether to auto adjust the canvas to the size of the document.
	 */
	public void setAutoAdjust(boolean b) {
		autoAdjust = b;
	}

	/**
	 * Returns the main JSVGCanvas of this frame.
	 */
	public JSVGCanvas getJSVGCanvas() {
		return svgCanvas;
	}

	/**
	 * Needed to work-around JFileChooser bug with abstract Files
	 */
	private static File makeAbsolute(File f) {
		if (!f.isAbsolute()) {
			return f.getAbsoluteFile();
		}
		return f;
	}
                }

	/**
	 * Shows the Rhino debugger.
	 */
	public void showDebugger() {
		if (debugger == null && Debugger.isPresent) {
			debugger = new Debugger(this, locationBar.getText());
			debugger.initialize();
		}
	}

	/**
	 * Hides and destroys the Rhino debugger.
	 */
	public void hideDebugger() {
		if (debugger != null) {
			debugger.clearAllBreakpoints();
			debugger.go();
			debugger.dispose();
			debugger = null;
		}
	}
    }

	/**
	 * Rhino debugger class.
	 */
	protected static class Debugger {
        try {
            ParsedURL purl = new ParsedURL(uri);
            SquiggleInputHandler
                handler = getInputHandler(purl);

		/**
		 * Whether the Rhino debugger classes are present.
		 */
		protected static boolean isPresent;
                userAgent.displayError(e);
            }
        }

		/**
		 * The Rhino debugger class.
		 */
		protected static Class debuggerClass;

		/**
		 * The Rhino ContextFactory class.
		 */
		protected static Class contextFactoryClass;
        Iterator iter = getHandlers().iterator();
        SquiggleInputHandler handler = null;

		// Indexes into the debuggerMethods array.
		protected static final int CLEAR_ALL_BREAKPOINTS_METHOD = 0;
                (SquiggleInputHandler)iter.next();
            if (curHandler.accept(purl)) {
                handler = curHandler;
                break;
            }
        }

		protected static final int GO_METHOD = 1;
        if (handler == null) {
            handler = defaultHandler;
        }

		protected static final int SET_EXIT_ACTION_METHOD = 2;
    }

		protected static final int ATTACH_TO_METHOD = 3;

		protected static final int DETACH_METHOD = 4;
     * Returns the list of input file handler.
     */
    protected static Vector getHandlers() {
        if (handlers != null) {
            return handlers;
        }

		protected static final int DISPOSE_METHOD = 5;
        registerHandler(new SVGInputHandler());

		protected static final int GET_DEBUG_FRAME_METHOD = 6;
        while (iter.hasNext()) {
            SquiggleInputHandler handler
                = (SquiggleInputHandler)iter.next();

		/**
		 * Rhino debugger class constructor.
		 */
		protected static Constructor debuggerConstructor;

		/**
		 * Rhino debugger class methods.
		 */
		protected static Method[] debuggerMethods;

		/**
		 * The RhinoInterpreter class.
		 */
		protected static Class rhinoInterpreterClass;
    public static synchronized
        void registerHandler(SquiggleInputHandler handler) {
        Vector handlers = getHandlers();
        handlers.addElement(handler);
    }

		/**
		 * The {@code getContextFactory} method on the {@link
		 * org.apache.batik.script.rhino.RhinoInterpreter} class.
		 */
		protected static Method getContextFactoryMethod;
        public void actionPerformed(ActionEvent e) {
            if (uriChooser == null) {
                uriChooser = new URIChooser(JSVGViewerFrame.this);
                uriChooser.setFileFilter(new SVGFileFilter());
                uriChooser.pack();
                Rectangle fr = getBounds();
                Dimension sd = uriChooser.getSize();
                uriChooser.setLocation(fr.x + (fr.width  - sd.width) / 2,
                                       fr.y + (fr.height - sd.height) / 2);
            }
            if (uriChooser.showDialog() == URIChooser.OK_OPTION) {
                String s = uriChooser.getText();
                if (s == null) return;
                int i = s.indexOf( '#' );
                String t = "";
                if (i != -1) {
                    t = s.substring(i + 1);
                    s = s.substring(0, i);
                }
                if (!s.equals("")) {
                    File f = new File(s);
                    if (f.exists()) {
                        if (f.isDirectory()) {
                            s = null;
                        } else {
                            try {
                                s = f.getCanonicalPath();
                                if (s.startsWith("/")) {
                                    s = "file:" + s;
                                } else {
                                    s = "file:/" + s;
                                }
                            } catch (IOException ex) {
                            }
                        }
                    }
                    if (s != null) {
                        if (svgDocument != null) {
                            ParsedURL docPURL
                                = new ParsedURL(svgDocument.getURL());
                            ParsedURL purl = new ParsedURL(docPURL, s);
                            String fi = svgCanvas.getFragmentIdentifier();
                            if (docPURL.equals(purl) && t.equals(fi)) {
                                return;
                            }
                        }
                        if (t.length() != 0) {
                            s += '#' + t;
                        }

		static {
			try {
				Class dc = Class
						.forName("org.mozilla.javascript.tools.debugger.Main");
				Class cfc = Class
						.forName("org.mozilla.javascript.ContextFactory");
				rhinoInterpreterClass = Class
						.forName("org.apache.batik.script.rhino.RhinoInterpreter");
				debuggerConstructor = dc
						.getConstructor(new Class[] { String.class });
				debuggerMethods = new Method[] {
						dc.getMethod("clearAllBreakpoints", (Class[]) null),
						dc.getMethod("go", (Class[]) null),
						dc.getMethod("setExitAction",
								new Class[] { Runnable.class }),
						dc.getMethod("attachTo", new Class[] { cfc }),
						dc.getMethod("detach", (Class[]) null),
						dc.getMethod("dispose", (Class[]) null),
						dc.getMethod("getDebugFrame", (Class[]) null) };
				getContextFactoryMethod = rhinoInterpreterClass.getMethod(
						"getContextFactory", (Class[]) null);
				debuggerClass = dc;
				isPresent = true;
			} catch (ClassNotFoundException cnfe) {
			} catch (NoSuchMethodException nsme) {
			} catch (SecurityException se) {
			}
		}

		/**
		 * The Rhino debugger instance.
		 */
		protected Object debuggerInstance;
        public NewWindowAction() {}
        public void actionPerformed(ActionEvent e) {
            JSVGViewerFrame vf = application.createAndShowJSVGViewerFrame();

		/**
		 * The JSVGViewerFrame.
		 */
		protected JSVGViewerFrame svgFrame;
            vf.svgCanvas.setDoubleBufferedRendering
                (svgCanvas.getDoubleBufferedRendering());
        }
    }

		/**
		 * Creates a new Debugger.
		 */
		public Debugger(JSVGViewerFrame frame, String url) {
			svgFrame = frame;
			try {
				debuggerInstance = debuggerConstructor
						.newInstance(new Object[] { "JavaScript Debugger - "
								+ url });
			} catch (IllegalAccessException iae) {
				throw new RuntimeException(iae.getMessage());
			} catch (InvocationTargetException ite) {
				ite.printStackTrace();
				throw new RuntimeException(ite.getMessage());
			} catch (InstantiationException ie) {
				throw new RuntimeException(ie.getMessage());
			}
		}

		/**
		 * Sets the document URL to use in the window title.
		 */
		public void setDocumentURL(String url) {
			getDebugFrame().setTitle("JavaScript Debugger - " + url);
		}
            application.closeJSVGViewerFrame(JSVGViewerFrame.this);
        }
    }

		/**
		 * Initializes the debugger by massaging the GUI and attaching it to the
		 * Rhino interpreter's {@link org.mozilla.javascript.ContextFactory}.
		 */
		public void initialize() {
			// Customize the menubar a bit, disable menu
			// items that can't be used and change 'Exit' to 'Close'.
			JFrame debugGui = getDebugFrame();
			JMenuBar menuBar = debugGui.getJMenuBar();
			JMenu menu = menuBar.getMenu(0);
			menu.getItem(0).setEnabled(false); // Open...
			menu.getItem(1).setEnabled(false); // Run...
			menu.getItem(3).setText(Resources.getString("Close.text")); // Exit
			// ->
			// "Close"
			menu.getItem(3).setAccelerator(
					KeyStroke.getKeyStroke(KeyEvent.VK_W, Event.CTRL_MASK));

			debugGui.setSize(600, 460);
			debugGui.pack();
			setExitAction(new Runnable() {
				public void run() {
					svgFrame.hideDebugger();
				}
			});
			WindowAdapter wa = new WindowAdapter() {
				public void windowClosing(WindowEvent e) {
					svgFrame.hideDebugger();
				}
			};
			debugGui.addWindowListener(wa);
			debugGui.setVisible(true);
			attach();
		}

		/**
		 * Attaches the debugger to the canvas' current interpreter.
		 */
		public void attach() {
			Object interpreter = svgFrame.svgCanvas.getRhinoInterpreter();
			if (interpreter != null) {
				attachTo(getContextFactory(interpreter));
			}
		}

		/**
		 * Calls {@code getDebugFrame} on {@link #debuggerInstance}.
		 */
		protected JFrame getDebugFrame() {
			try {
				return (JFrame) debuggerMethods[GET_DEBUG_FRAME_METHOD].invoke(
						debuggerInstance, (Object[]) null);
			} catch (InvocationTargetException ite) {
				throw new RuntimeException(ite.getMessage());
			} catch (IllegalAccessException iae) {
				throw new RuntimeException(iae.getMessage());
			}
		}

		/**
		 * Calls {@code setExitAction} on {@link #debuggerInstance}.
		 */
		protected void setExitAction(Runnable r) {
			try {
				debuggerMethods[SET_EXIT_ACTION_METHOD].invoke(
						debuggerInstance, new Object[] { r });
			} catch (InvocationTargetException ite) {
				throw new RuntimeException(ite.getMessage());
			} catch (IllegalAccessException iae) {
				throw new RuntimeException(iae.getMessage());
			}
		}

		/**
		 * Calls {@code attachTo} on {@link #debuggerInstance}.
		 */
		public void attachTo(Object contextFactory) {
			try {
				debuggerMethods[ATTACH_TO_METHOD].invoke(debuggerInstance,
						new Object[] { contextFactory });
			} catch (InvocationTargetException ite) {
				throw new RuntimeException(ite.getMessage());
			} catch (IllegalAccessException iae) {
				throw new RuntimeException(iae.getMessage());
			}
		}

		/**
		 * Calls {@code detach} on {@link #debuggerInstance}.
		 */
		public void detach() {
			try {
				debuggerMethods[DETACH_METHOD].invoke(debuggerInstance,
						(Object[]) null);
			} catch (InvocationTargetException ite) {
				throw new RuntimeException(ite.getMessage());
			} catch (IllegalAccessException iae) {
				throw new RuntimeException(iae.getMessage());
			}
		}

		/**
		 * Calls {@code go} on {@link #debuggerInstance}.
		 */
		public void go() {
			try {
				debuggerMethods[GO_METHOD].invoke(debuggerInstance,
						(Object[]) null);
			} catch (InvocationTargetException ite) {
				throw new RuntimeException(ite.getMessage());
			} catch (IllegalAccessException iae) {
				throw new RuntimeException(iae.getMessage());
			}
		}
                            uri += '#' +fragment;
                        }

		/**
		 * Calls {@code clearAllBreakpoints} on {@link #debuggerInstance}.
		 */
		public void clearAllBreakpoints() {
			try {
				debuggerMethods[CLEAR_ALL_BREAKPOINTS_METHOD].invoke(
						debuggerInstance, (Object[]) null);
			} catch (InvocationTargetException ite) {
				throw new RuntimeException(ite.getMessage());
			} catch (IllegalAccessException iae) {
				throw new RuntimeException(iae.getMessage());
			}
		}

		/**
		 * Calls {@code dispose} on {@link #debuggerInstance}.
		 */
		public void dispose() {
			try {
				debuggerMethods[DISPOSE_METHOD].invoke(debuggerInstance,
						(Object[]) null);
			} catch (InvocationTargetException ite) {
				throw new RuntimeException(ite.getMessage());
			} catch (IllegalAccessException iae) {
				throw new RuntimeException(iae.getMessage());
			}
		}

		/**
		 * Calls {@code getContextFactory} on the given instance of
		 * {@link org.apache.batik.script.rhino.RhinoInterpreter}.
		 */
		protected Object getContextFactory(Object rhinoInterpreter) {
			try {
				return getContextFactoryMethod.invoke(rhinoInterpreter,
						(Object[]) null);
			} catch (InvocationTargetException ite) {
				throw new RuntimeException(ite.getMessage());
			} catch (IllegalAccessException iae) {
				throw new RuntimeException(iae.getMessage());
			}
		}
	}

	/**
	 * To show the about dialog
	 */
	public class AboutAction extends AbstractAction {
		public AboutAction() {
		}

		public void actionPerformed(ActionEvent e) {
			AboutDialog dlg = new AboutDialog(JSVGViewerFrame.this);
			// Work around pack() bug on some platforms
			dlg.setSize(dlg.getPreferredSize());
			dlg.setLocationRelativeTo(JSVGViewerFrame.this);
			dlg.setVisible(true);
			dlg.toFront();
		}
	}

	/**
	 * To open a new file.
	 */
	public class OpenAction extends AbstractAction {

		public OpenAction() {
		}
                        //
                        try {
                            pt.print();
                        } catch (PrinterException ex) {
                            userAgent.displayError(ex);
                        }
                    }
                }.start();
            }
        }
    }

		public void actionPerformed(ActionEvent e) {
			File f = null;
			if (Platform.isOSX) {
				FileDialog fileDialog = new FileDialog(JSVGViewerFrame.this,
						Resources.getString(OPEN_TITLE));
				fileDialog.setFilenameFilter(new FilenameFilter() {
					public boolean accept(File dir, String name) {
						Iterator iter = getHandlers().iterator();
						while (iter.hasNext()) {
							SquiggleInputHandler handler = (SquiggleInputHandler) iter
									.next();
							if (handler.accept(new File(dir, name))) {
								return true;
							}
						}
						return false;
					}
				});
				fileDialog.setVisible(true);
				String filename = fileDialog.getFile();
				if (fileDialog != null) {
					String dirname = fileDialog.getDirectory();
					f = new File(dirname, filename);
				}
			} else {
				JFileChooser fileChooser = null;

				// Apply work around Windows problem when security is enabled,
				// and when prior to JDK 1.4.
				String os = System.getProperty(PROPERTY_OS_NAME,
						PROPERTY_OS_NAME_DEFAULT);
				SecurityManager sm = System.getSecurityManager();
            fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
            fileChooser.addChoosableFileFilter(new ImageFileFilter(".svg"));

				if (priorJDK1_4 && sm != null
						&& os.indexOf(PROPERTY_OS_WINDOWS_PREFIX) != -1) {
					fileChooser = new JFileChooser(makeAbsolute(currentPath),
							new WindowsAltFileSystemView());
				} else {
					fileChooser = new JFileChooser(makeAbsolute(currentPath));
				}

				fileChooser.setFileHidingEnabled(false);
				fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);

				//
				// Add file filters from the handlers map
				//
				Iterator iter = getHandlers().iterator();
				while (iter.hasNext()) {
					SquiggleInputHandler handler = (SquiggleInputHandler) iter
							.next();
					fileChooser
							.addChoosableFileFilter(new SquiggleInputHandlerFilter(
									handler));
				}

				int choice = fileChooser.showOpenDialog(JSVGViewerFrame.this);
				if (choice == JFileChooser.APPROVE_OPTION) {
					f = fileChooser.getSelectedFile();
					currentPath = f;
				}
			}

			if (f != null) {
				try {
					String furl = f.toURL().toString();
					showSVGDocument(furl);
				} catch (MalformedURLException ex) {
					if (userAgent != null) {
						userAgent.displayError(ex);
					}
				}
			}
		}
	}

	/**
	 * Shows the given document into the viewer frame
	 */
	public void showSVGDocument(String uri) {
		try {
			ParsedURL purl = new ParsedURL(uri);
			SquiggleInputHandler handler = getInputHandler(purl);
                w = new OutputStreamWriter(tos, "utf-8");
            } catch (Exception ex) {
                userAgent.displayError(ex);
                return;
            }

			handler.handle(purl, JSVGViewerFrame.this);
		} catch (Exception e) {
			if (userAgent != null) {
				userAgent.displayError(e);
			}
		}

	}
                    public void run() {
                        String doneStr = resources.getString("Message.done");
                        statusBar.setMessage(doneStr);
                    }
                };
            Runnable r = new Runnable() {
                    public void run() {
                        try {
                            // Write standard XML header.
                            writer.write
                                ("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
                                writer.write (EOL);

	/**
	 * Returns the input handler for the given URI
	 */
	public SquiggleInputHandler getInputHandler(ParsedURL purl)
			throws IOException {
		Iterator iter = getHandlers().iterator();
		SquiggleInputHandler handler = null;
                                writer.write (SVGConstants.SVG_SYSTEM_ID);
                                writer.write ("'>");
                                writer.write (EOL);
                                writer.write (EOL);
                            }
                            Element root = svgDoc.getRootElement();
                            boolean doXMLBase = useXMLBase;
                            if (root.hasAttributeNS
                                (XMLConstants.XML_NAMESPACE_URI, "base"))
                                doXMLBase = false;

		while (iter.hasNext()) {
			SquiggleInputHandler curHandler = (SquiggleInputHandler) iter
					.next();
			if (curHandler.accept(purl)) {
				handler = curHandler;
				break;
			}
		}

		// No handler found, use the default one.
		if (handler == null) {
			handler = defaultHandler;
		}
                            } else {
                                DOMUtilities.writeDocument(svgDoc, writer);
                            }

		return handler;
	}

	/**
	 * Returns the list of input file handler.
	 */
	protected static Vector getHandlers() {
		if (handlers != null) {
			return handlers;
		}

		handlers = new Vector();
		registerHandler(new SVGInputHandler());
                            } else {
                                EventQueue.invokeLater(doneRun);
                            }
                        } catch (Exception ex) {
                            userAgent.displayError(ex);
                        }
                    }
                };

		Iterator iter = Service.providers(SquiggleInputHandler.class);
		while (iter.hasNext()) {
			SquiggleInputHandler handler = (SquiggleInputHandler) iter.next();
            } else {
                r.run();
            }
        }
    }

			registerHandler(handler);
		}
     */
    public class ExportAsJPGAction extends AbstractAction {
        public ExportAsJPGAction() {}
        public void actionPerformed(ActionEvent e) {
            JFileChooser fileChooser =
                new JFileChooser(makeAbsolute(currentSavePath));
            fileChooser.setDialogTitle(resources.getString("ExportAsJPG.title"));
            fileChooser.setFileHidingEnabled(false);
            fileChooser.setFileSelectionMode
                (JFileChooser.FILES_ONLY);
            fileChooser.addChoosableFileFilter(new ImageFileFilter(".jpg"));

		return handlers;
	}
                float quality =
                    JPEGOptionPanel.showDialog(JSVGViewerFrame.this);

	/**
	 * Registers an input file handler by adding it to the handlers map.
	 * 
	 * @param handler
	 *            the new input handler to register.
	 */
	public static synchronized void registerHandler(SquiggleInputHandler handler) {
		Vector handlers = getHandlers();
		handlers.addElement(handler);
	}

	/**
	 * To open a new document.
	 */
	public class OpenLocationAction extends AbstractAction {
		public OpenLocationAction() {
		}
                            (JPEGTranscoder.KEY_XML_PARSER_CLASSNAME,
                                application.getXMLParserClassName());
                    }
                    trans.addTranscodingHint
                        (JPEGTranscoder.KEY_QUALITY, new Float(quality));

		public void actionPerformed(ActionEvent e) {
			if (uriChooser == null) {
				uriChooser = new URIChooser(JSVGViewerFrame.this);
				uriChooser.setFileFilter(new SVGFileFilter());
				uriChooser.pack();
				Rectangle fr = getBounds();
				Dimension sd = uriChooser.getSize();
				uriChooser.setLocation(fr.x + (fr.width - sd.width) / 2, fr.y
						+ (fr.height - sd.height) / 2);
			}
			if (uriChooser.showDialog() == URIChooser.OK_OPTION) {
				String s = uriChooser.getText();
				if (s == null)
					return;
				int i = s.indexOf('#');
				String t = "";
				if (i != -1) {
					t = s.substring(i + 1);
					s = s.substring(0, i);
				}
				if (!s.equals("")) {
					File f = new File(s);
					if (f.exists()) {
						if (f.isDirectory()) {
							s = null;
						} else {
							try {
								s = f.getCanonicalPath();
								if (s.startsWith("/")) {
									s = "file:" + s;
								} else {
									s = "file:/" + s;
								}
							} catch (IOException ex) {
							}
						}
					}
					if (s != null) {
						if (svgDocument != null) {
							ParsedURL docPURL = new ParsedURL(svgDocument
									.getURL());
							ParsedURL purl = new ParsedURL(docPURL, s);
							String fi = svgCanvas.getFragmentIdentifier();
							if (docPURL.equals(purl) && t.equals(fi)) {
								return;
							}
						}
						if (t.length() != 0) {
							s += '#' + t;
						}

						showSVGDocument(s);
					}
				}
			}
		}
	}
                        public void run() {
                            try {
                                currentSavePath = f;
                                OutputStream ostream =
                                    new BufferedOutputStream(new FileOutputStream(f));
                                trans.writeImage(img, new TranscoderOutput(ostream));
                                ostream.close();
                            } catch (Exception ex) { }
                            statusBar.setMessage
                                (resources.getString("Message.done"));
                        }
                    }.start();
                }
            }
        }
    }

	/**
	 * To open a new window.
	 */
	public class NewWindowAction extends AbstractAction {
		public NewWindowAction() {
		}
            JFileChooser fileChooser =
                new JFileChooser(makeAbsolute(currentSavePath));
            fileChooser.setDialogTitle(resources.getString("ExportAsPNG.title"));
            fileChooser.setFileHidingEnabled(false);
            fileChooser.setFileSelectionMode
                (JFileChooser.FILES_ONLY);
            fileChooser.addChoosableFileFilter(new ImageFileFilter(".png"));

		public void actionPerformed(ActionEvent e) {
			JSVGViewerFrame vf = application.createAndShowJSVGViewerFrame();

			// Copy the current settings to the new window.
			vf.autoAdjust = autoAdjust;
			vf.debug = debug;
			vf.svgCanvas.setProgressivePaint(svgCanvas.getProgressivePaint());
			vf.svgCanvas.setDoubleBufferedRendering(svgCanvas
					.getDoubleBufferedRendering());
		}
	}

	/**
	 * To show the preferences.
	 */
	public class PreferencesAction extends AbstractAction {
		public PreferencesAction() {
		}

		public void actionPerformed(ActionEvent e) {
			application.showPreferenceDialog(JSVGViewerFrame.this);
		}
	}
                    if (application.getXMLParserClassName() != null) {
                        trans.addTranscodingHint
                            (JPEGTranscoder.KEY_XML_PARSER_CLASSNAME,
                                application.getXMLParserClassName());
                    }
                    trans.addTranscodingHint(PNGTranscoder.KEY_FORCE_TRANSPARENT_WHITE,
                                             Boolean.TRUE );

	/**
	 * To close the last document.
	 */
	public class CloseAction extends AbstractAction {
		public CloseAction() {
		}

		public void actionPerformed(ActionEvent e) {
			application.closeJSVGViewerFrame(JSVGViewerFrame.this);
		}
	}

	/**
	 * To reload the current document.
	 */
	public class ReloadAction extends AbstractAction {
		public ReloadAction() {
		}
                                currentSavePath = f;
                                OutputStream ostream =
                                    new BufferedOutputStream(new FileOutputStream(f));
                                trans.writeImage(img,
                                                 new TranscoderOutput(ostream));
                                ostream.close();
                            } catch (Exception ex) {}
                            statusBar.setMessage
                                (resources.getString("Message.done"));
                        }
                    }.start();
                }
            }
        }
    }

		public void actionPerformed(ActionEvent e) {
			if ((e.getModifiers() & ActionEvent.SHIFT_MASK) == 1) {
				svgCanvas.flushImageCache();
			}
			if (svgDocument != null) {
				localHistory.reload();
			}
		}
	}
            fileChooser.setFileHidingEnabled(false);
            fileChooser.setFileSelectionMode
                (JFileChooser.FILES_ONLY);
            fileChooser.addChoosableFileFilter(new ImageFileFilter(".tiff"));

	/**
	 * To go back to the previous document
	 */
	public class BackAction extends AbstractAction implements
			JComponentModifier {
		List components = new LinkedList();
                        (resources.getString("Message.exportAsTIFF"));

		public BackAction() {
		}
                    int h = buffer.getHeight();
                    final ImageTranscoder trans = new TIFFTranscoder();
                    if (application.getXMLParserClassName() != null) {
                        trans.addTranscodingHint
                            (JPEGTranscoder.KEY_XML_PARSER_CLASSNAME,
                                application.getXMLParserClassName());
                    }
                    final BufferedImage img = trans.createImage(w, h);

		public void actionPerformed(ActionEvent e) {
			if (localHistory.canGoBack()) {
				localHistory.back();
			}
		}
                            try {
                                currentSavePath = f;
                                OutputStream ostream = new BufferedOutputStream
                                    (new FileOutputStream(f));
                                trans.writeImage
                                    (img, new TranscoderOutput(ostream));
                                ostream.close();
                            } catch (Exception ex) {}
                            statusBar.setMessage
                                (resources.getString("Message.done"));
                        }
                    }.start();
                }
            }
        }
    }

		public void addJComponent(JComponent c) {
			components.add(c);
			c.setEnabled(false);
		}
        public ViewSourceAction() {}
        public void actionPerformed(ActionEvent e) {
            if (svgDocument == null) {
                return;
            }

		protected void update() {
			boolean b = localHistory.canGoBack();
			Iterator it = components.iterator();
			while (it.hasNext()) {
				((JComponent) it.next()).setEnabled(b);
			}
		}
	}

	/**
	 * To go forward to the next document
	 */
	public class ForwardAction extends AbstractAction implements
			JComponentModifier {
		List components = new LinkedList();

		public ForwardAction() {
		}
            scroll.setVerticalScrollBarPolicy
                (JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
            fr.getContentPane().add(scroll, BorderLayout.CENTER);

		public void actionPerformed(ActionEvent e) {
			if (localHistory.canGoForward()) {
				localHistory.forward();
			}
		}

		public void addJComponent(JComponent c) {
			components.add(c);
			c.setEnabled(false);
		}

		protected void update() {
			boolean b = localHistory.canGoForward();
			Iterator it = components.iterator();
			while (it.hasNext()) {
				((JComponent) it.next()).setEnabled(b);
			}
		}
	}

	/**
	 * To print the current document.
	 */
	public class PrintAction extends AbstractAction {
		public PrintAction() {
		}

		public void actionPerformed(ActionEvent e) {
			if (svgDocument != null) {
				final SVGDocument doc = svgDocument;
				new Thread() {
					public void run() {
						String uri = doc.getURL();
						String fragment = svgCanvas.getFragmentIdentifier();
						if (fragment != null) {
							uri += '#' + fragment;
						}
    }

						//
						// Build a PrintTranscoder to handle printing
						// of the svgDocument object
						//
						PrintTranscoder pt = new PrintTranscoder();
        public void actionPerformed(ActionEvent e) {
            svgCanvas.flush();
            // Force redraw...
            svgCanvas.setRenderingTransform(svgCanvas.getRenderingTransform());
        }
    }

						//
						// Set transcoding hints
						//
						if (application.getXMLParserClassName() != null) {
							pt.addTranscodingHint(
									JPEGTranscoder.KEY_XML_PARSER_CLASSNAME,
									application.getXMLParserClassName());
						}

						pt.addTranscodingHint(
								PrintTranscoder.KEY_SHOW_PAGE_DIALOG,
								Boolean.TRUE);
            } else {
                hideDebugger();
            }
        }
    }

						pt.addTranscodingHint(
								PrintTranscoder.KEY_SHOW_PRINTER_DIALOG,
								Boolean.TRUE);
    public class PreviousTransformAction extends    AbstractAction
                                         implements JComponentModifier {
        List components = new LinkedList();
        public PreviousTransformAction() {}
        public void actionPerformed(ActionEvent e) {
            if (transformHistory.canGoBack()) {
                transformHistory.back();
                update();
                nextTransformAction.update();
                svgCanvas.setRenderingTransform(transformHistory.currentTransform());
            }
        }

						//
						// Do transcoding now
						//
						pt.transcode(new TranscoderInput(uri), null);

						//
						// Print
						//
						try {
							pt.print();
						} catch (PrinterException ex) {
							userAgent.displayError(ex);
						}
					}
				}.start();
			}
		}
	}

	/**
	 * To save the current document as SVG.
	 */
	public class SaveAsAction extends AbstractAction {
		public SaveAsAction() {
		}
        public NextTransformAction() {}
        public void actionPerformed(ActionEvent e) {
            if (transformHistory.canGoForward()) {
                transformHistory.forward();
                update();
                previousTransformAction.update();
                svgCanvas.setRenderingTransform(transformHistory.currentTransform());
            }
        }

		public void actionPerformed(ActionEvent e) {
			JFileChooser fileChooser;
			fileChooser = new JFileChooser(makeAbsolute(currentSavePath));
			fileChooser.setDialogTitle(resources.getString("SaveAs.title"));
			fileChooser.setFileHidingEnabled(false);
			fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
			fileChooser.addChoosableFileFilter(new ImageFileFilter(".svg"));

			int choice = fileChooser.showSaveDialog(JSVGViewerFrame.this);
			if (choice != JFileChooser.APPROVE_OPTION)
				return;
            while (it.hasNext()) {
                ((JComponent)it.next()).setEnabled(b);
            }
        }
    }

			final File f = fileChooser.getSelectedFile();
     * To apply the selected author stylesheet
     */
    public class UseStylesheetAction extends    AbstractAction
                                     implements JComponentModifier {

			SVGOptionPanel sop;
			sop = SVGOptionPanel.showDialog(JSVGViewerFrame.this);

			final boolean useXMLBase = sop.getUseXMLBase();
			final boolean prettyPrint = sop.getPrettyPrint();
			sop = null;

			final SVGDocument svgDoc = svgCanvas.getSVGDocument();
			if (svgDoc == null)
				return;

			statusBar.setMessage(resources.getString("Message.saveAs"));
			currentSavePath = f;
			OutputStreamWriter w = null;
			try {
				OutputStream tos = null;
				tos = new FileOutputStream(f);
				tos = new BufferedOutputStream(tos);
				w = new OutputStreamWriter(tos, "utf-8");
			} catch (Exception ex) {
				userAgent.displayError(ex);
				return;
			}

			final OutputStreamWriter writer = w;
            alternateStyleSheet = null;
            Iterator it = components.iterator();
            SVGDocument doc = svgCanvas.getSVGDocument();
            while (it.hasNext()) {
                JComponent stylesheetMenu = (JComponent)it.next();
                stylesheetMenu.removeAll();
                stylesheetMenu.setEnabled(false);

			final Runnable doneRun = new Runnable() {
				public void run() {
					String doneStr = resources.getString("Message.done");
					statusBar.setMessage(doneStr);
				}
			};
			Runnable r = new Runnable() {
				public void run() {
					try {
						// Write standard XML header.
						writer
								.write("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
						writer.write(EOL);

						Node fc = svgDoc.getFirstChild();
						if (fc.getNodeType() != Node.DOCUMENT_TYPE_NODE) {
							// Not DT node in Document, so
							// provide Document Type dec.
							writer.write("<!DOCTYPE svg PUBLIC '");
							writer.write(SVGConstants.SVG_PUBLIC_ID);
							writer.write("' '");
							writer.write(SVGConstants.SVG_SYSTEM_ID);
							writer.write("'>");
							writer.write(EOL);
							writer.write(EOL);
						}
						Element root = svgDoc.getRootElement();
						boolean doXMLBase = useXMLBase;
						if (root.hasAttributeNS(XMLConstants.XML_NAMESPACE_URI,
								"base"))
							doXMLBase = false;

						if (doXMLBase) {
							root.setAttributeNS(XMLConstants.XML_NAMESPACE_URI,
									"xml:base", svgDoc.getURL());
						}
                                        doc = (SVGOMDocument)svgCanvas.getSVGDocument();
                                        doc.clearViewCSS();
                                        alternateStyleSheet = title;
                                        svgCanvas.setSVGDocument(doc);
                                    }
                                });

						if (prettyPrint) {
							SVGTranscoder trans = new SVGTranscoder();
							trans.transcode(new TranscoderInput(svgDoc),
									new TranscoderOutput(writer));
						} else {
							DOMUtilities.writeDocument(svgDoc, writer);
						}
        }
    }

						writer.close();
     * To restart after a pause.
     */
    public class PlayAction extends   AbstractAction
                            implements JComponentModifier {
        List components = new LinkedList();
        public PlayAction() {}
        public void actionPerformed(ActionEvent e) {
            svgCanvas.resumeProcessing();
        }

						if (doXMLBase)
							root.removeAttributeNS(
									XMLConstants.XML_NAMESPACE_URI, "xml:base");
        }

						if (EventQueue.isDispatchThread()) {
							doneRun.run();
						} else {
							EventQueue.invokeLater(doneRun);
						}
					} catch (Exception ex) {
						userAgent.displayError(ex);
					}
				}
			};

			UpdateManager um = svgCanvas.getUpdateManager();
			if ((um != null) && (um.isRunning())) {
				um.getUpdateRunnableQueue().invokeLater(r);
			} else {
				r.run();
			}
		}
	}
            svgCanvas.suspendProcessing();
        }

	/**
	 * To save the current document as JPG.
	 */
	public class ExportAsJPGAction extends AbstractAction {
		public ExportAsJPGAction() {
		}

		public void actionPerformed(ActionEvent e) {
			JFileChooser fileChooser = new JFileChooser(
					makeAbsolute(currentSavePath));
			fileChooser
					.setDialogTitle(resources.getString("ExportAsJPG.title"));
			fileChooser.setFileHidingEnabled(false);
			fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
			fileChooser.addChoosableFileFilter(new ImageFileFilter(".jpg"));

			int choice = fileChooser.showSaveDialog(JSVGViewerFrame.this);
			if (choice == JFileChooser.APPROVE_OPTION) {
				float quality = JPEGOptionPanel
						.showDialog(JSVGViewerFrame.this);
                            implements JComponentModifier {
        List components = new LinkedList();
        public StopAction() {}
        public void actionPerformed(ActionEvent e) {
            svgCanvas.stopProcessing();
        }

				final File f = fileChooser.getSelectedFile();
				BufferedImage buffer = svgCanvas.getOffScreen();
				if (buffer != null) {
					statusBar.setMessage(resources
							.getString("Message.exportAsJPG"));

					// create a BufferedImage of the appropriate type
					int w = buffer.getWidth();
					int h = buffer.getHeight();
					final ImageTranscoder trans = new JPEGTranscoder();
					if (application.getXMLParserClassName() != null) {
						trans.addTranscodingHint(
								JPEGTranscoder.KEY_XML_PARSER_CLASSNAME,
								application.getXMLParserClassName());
					}
					trans.addTranscodingHint(JPEGTranscoder.KEY_QUALITY,
							new Float(quality));

					final BufferedImage img = trans.createImage(w, h);
     * To show the set transform dialog
     */
    public class SetTransformAction extends AbstractAction {
        public SetTransformAction(){}
        public void actionPerformed(ActionEvent e){
            if (transformDialog == null){
                transformDialog
                    = JAffineTransformChooser.createDialog
                    (JSVGViewerFrame.this,
                     resources.getString("SetTransform.title"));
            }

					// paint the buffer to the image
					Graphics2D g2d = img.createGraphics();
					g2d.setColor(Color.white);
					g2d.fillRect(0, 0, w, h);
					g2d.drawImage(buffer, null, 0, 0);
					new Thread() {
						public void run() {
							try {
								currentSavePath = f;
								OutputStream ostream = new BufferedOutputStream(
										new FileOutputStream(f));
								trans.writeImage(img, new TranscoderOutput(
										ostream));
								ostream.close();
							} catch (Exception ex) {
							}
							statusBar.setMessage(resources
									.getString("Message.done"));
						}
					}.start();
				}
			}
		}
	}

	/**
	 * To save the current document as PNG.
	 */
	public class ExportAsPNGAction extends AbstractAction {
		public ExportAsPNGAction() {
		}

		public void actionPerformed(ActionEvent e) {
			JFileChooser fileChooser = new JFileChooser(
					makeAbsolute(currentSavePath));
			fileChooser
					.setDialogTitle(resources.getString("ExportAsPNG.title"));
			fileChooser.setFileHidingEnabled(false);
			fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
			fileChooser.addChoosableFileFilter(new ImageFileFilter(".png"));
                Rectangle fr = getBounds();
                Dimension md = memoryMonitorFrame.getSize();
                memoryMonitorFrame.setLocation(fr.x + (fr.width  - md.width) / 2,
                                               fr.y + (fr.height - md.height) / 2);
            }
            memoryMonitorFrame.setVisible(true);
        }
    }

			int choice = fileChooser.showSaveDialog(JSVGViewerFrame.this);
			if (choice == JFileChooser.APPROVE_OPTION) {
     */
    public class FindDialogAction extends AbstractAction {
        public FindDialogAction() {}
        public void actionPerformed(ActionEvent e) {
            if (findDialog == null) {
                findDialog = new FindDialog(JSVGViewerFrame.this, svgCanvas);
                findDialog.setGraphicsNode(svgCanvas.getGraphicsNode());
                findDialog.pack();
                Rectangle fr = getBounds();
                Dimension td = findDialog.getSize();
                findDialog.setLocation(fr.x + (fr.width  - td.width) / 2,
                                       fr.y + (fr.height - td.height) / 2);
            }
            findDialog.setVisible(true);
        }
    }

				// Start: By Jun Inamori (jun@oop-reserch.com)
				boolean isIndexed = PNGOptionPanel
						.showDialog(JSVGViewerFrame.this);
				// End: By Jun Inamori (jun@oop-reserch.com)
        public ThumbnailDialogAction() {}
        public void actionPerformed(ActionEvent e) {
            if (thumbnailDialog == null) {
                thumbnailDialog
                    = new ThumbnailDialog(JSVGViewerFrame.this, svgCanvas);
                thumbnailDialog.pack();
                Rectangle fr = getBounds();
                Dimension td = thumbnailDialog.getSize();
                thumbnailDialog.setLocation(fr.x + (fr.width  - td.width) / 2,
                                            fr.y + (fr.height - td.height) / 2);
            }
            thumbnailDialog.setInteractionEnabled
                (!svgCanvas.getDisableInteractions());
            thumbnailDialog.setVisible(true);
        }
    }

				final File f = fileChooser.getSelectedFile();
				BufferedImage buffer = svgCanvas.getOffScreen();
				if (buffer != null) {
					statusBar.setMessage(resources
							.getString("Message.exportAsPNG"));

					// create a BufferedImage of the appropriate type
					int w = buffer.getWidth();
					int h = buffer.getHeight();
					final ImageTranscoder trans = new PNGTranscoder();
					if (application.getXMLParserClassName() != null) {
						trans.addTranscodingHint(
								JPEGTranscoder.KEY_XML_PARSER_CLASSNAME,
								application.getXMLParserClassName());
					}
					trans.addTranscodingHint(
							PNGTranscoder.KEY_FORCE_TRANSPARENT_WHITE,
							Boolean.TRUE);
                svgCanvas.requestFocus();
            } else {
                // Go back to JSVGViewerFrame display
                svgCanvas.getParent().remove(svgCanvas);
                svgCanvasPanel.add(svgCanvas, BorderLayout.CENTER);
                window.setVisible(false);
            }
        }
    }

					// Start: By Jun Inamori
					if (isIndexed) {
						trans.addTranscodingHint(PNGTranscoder.KEY_INDEXED,
								new Integer(256));
					}
					// End: By Jun Inamori
            if (domViewer == null) {
                domViewer = new DOMViewer();
                if (svgDocument != null) {
                    domViewer.setDocument(svgDocument,
                                          (ViewCSS)svgDocument.getDocumentElement());
                }
                Rectangle fr = getBounds();
                Dimension td = domViewer.getSize();
                domViewer.setLocation(fr.x + (fr.width  - td.width) / 2,
                                      fr.y + (fr.height - td.height) / 2);
            }
            domViewer.setVisible(true);
        }
    }

					final BufferedImage img = trans.createImage(w, h);

					// paint the buffer to the image
					Graphics2D g2d = img.createGraphics();
					g2d.drawImage(buffer, null, 0, 0);
					new Thread() {
						public void run() {
							try {
								currentSavePath = f;
								OutputStream ostream = new BufferedOutputStream(
										new FileOutputStream(f));
								trans.writeImage(img, new TranscoderOutput(
										ostream));
								ostream.close();
							} catch (Exception ex) {
							}
							statusBar.setMessage(resources
									.getString("Message.done"));
						}
					}.start();
				}
			}
		}
	}

	/**
	 * To save the current document as TIFF.
	 */
	public class ExportAsTIFFAction extends AbstractAction {
		public ExportAsTIFFAction() {
		}
    public Action getAction(String key) throws MissingListenerException {
        Action result = (Action)listeners.get(key);
        //if (result == null) {
        //result = canvas.getAction(key);
        //}
        if (result == null) {
            throw new MissingListenerException("Can't find action.", RESOURCES, key);
        }
        return result;
    }

		public void actionPerformed(ActionEvent e) {
			JFileChooser fileChooser = new JFileChooser(
					makeAbsolute(currentSavePath));
			fileChooser.setDialogTitle(resources
					.getString("ExportAsTIFF.title"));
			fileChooser.setFileHidingEnabled(false);
			fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
			fileChooser.addChoosableFileFilter(new ImageFileFilter(".tiff"));

			int choice = fileChooser.showSaveDialog(JSVGViewerFrame.this);
			if (choice == JFileChooser.APPROVE_OPTION) {
				final File f = fileChooser.getSelectedFile();
				BufferedImage buffer = svgCanvas.getOffScreen();
				if (buffer != null) {
					statusBar.setMessage(resources
							.getString("Message.exportAsTIFF"));

					// create a BufferedImage of the appropriate type
					int w = buffer.getWidth();
					int h = buffer.getHeight();
					final ImageTranscoder trans = new TIFFTranscoder();
					if (application.getXMLParserClassName() != null) {
						trans.addTranscodingHint(
								JPEGTranscoder.KEY_XML_PARSER_CLASSNAME,
								application.getXMLParserClassName());
					}
					final BufferedImage img = trans.createImage(w, h);
        stopAction.update(true);
        svgCanvas.setCursor(WAIT_CURSOR);
    }

					// paint the buffer to the image
					Graphics2D g2d = img.createGraphics();
					g2d.drawImage(buffer, null, 0, 0);
					new Thread() {
						public void run() {
							try {
								currentSavePath = f;
								OutputStream ostream = new BufferedOutputStream(
										new FileOutputStream(f));
								trans.writeImage(img, new TranscoderOutput(
										ostream));
								ostream.close();
							} catch (Exception ex) {
							}
							statusBar.setMessage(resources
									.getString("Message.done"));
						}
					}.start();
				}
			}
		}
	}

	/**
	 * To view the source of the current document.
	 */
	public class ViewSourceAction extends AbstractAction {
		
		protected SourceViewFrame sourceViewFrame;
		
		protected Thread displayThread;
		
		public ViewSourceAction() {
		}

		public void actionPerformed(ActionEvent e) {
			if (svgDocument == null) {
				return;
			}

			final ParsedURL u = new ParsedURL(svgDocument.getURL());
     * Forces the viewer frame to show the input SVGDocument
     */
    public void setSVGDocument(SVGDocument svgDocument,
                               String svgDocumentURL,
                               String svgDocumentTitle) {
        this.svgDocument = svgDocument;

			sourceViewFrame = new SourceViewFrame(application, userAgent);
			displayThread = new Thread() {
				public void run() {
//					char[] buffer = new char[4096];
            } else {
                domViewer.dispose();
                domViewer = null;
            }
        }
        stopAction.update(false);
        svgCanvas.setCursor(DEFAULT_CURSOR);
        String s = svgDocumentURL;
        locationBar.setText(s);
        if (debugger != null) {
            debugger.detach();
            debugger.setDocumentURL(s);
        }
        if (title == null) {
            title = getTitle();
        }

					try {
						StringBuilder sb = new StringBuilder();
            setTitle(title + ": " + dt);
        } else {
            int i = s.lastIndexOf("/");
            if (i == -1)
                i = s.lastIndexOf("\\");
            if (i == -1) {
                setTitle(title + ": " + s);
            } else {
                setTitle(title + ": " + s.substring(i + 1));
            }
        }

						ParsedURL purl = new ParsedURL(svgDocument.getURL());
						InputStream is = u.openStream(getInputHandler(purl)
								.getHandledMimeTypes());
						// u.openStream(MimeTypeConstants.MIME_TYPES_SVG);

//						Reader in = XMLUtilities.createXMLDocumentReader(is);
//						int len;
//						while ((len = in.read(buffer, 0, buffer.length)) != -1) {
//							sb.append(new String(buffer, 0, len));
//						}

						BufferedReader reader = new BufferedReader(
								new InputStreamReader(is));
						String line;

						while ((line = reader.readLine()) != null) {
							sb.append(line + "\n");
						}
						
						sourceViewFrame.setText(sb.toString());
						sourceViewFrame.setTitle(u.toString());
						ImageIcon icon = new ImageIcon(getClass().getResource(
								resources.getString("ViewSource.frameicon")));
						sourceViewFrame.setIconImage(icon.getImage());
						sourceViewFrame.setSize(resources.getInteger("ViewSource.width"),
								resources.getInteger("ViewSource.height"));
						sourceViewFrame.setVisible(true);
					} catch (Exception ex) {
						userAgent.displayError(ex);
					}
				}
			};
			displayThread.start();
		}
		
		public SourceViewFrame getSourceViewFrame() {
			return sourceViewFrame;
		}
		
		public Thread getDisplayThread() {
			return displayThread;
		}
	}

	/**
	 * To flush image cache (purely for debugging purposes)
	 */
	public class FlushAction extends AbstractAction {
		public FlushAction() {
		}
            System.out.println(msg);
        }
        statusBar.setMainMessage("");
        statusBar.setMessage(msg);
        stopAction.update(false);
        svgCanvas.setCursor(DEFAULT_CURSOR);
    }

		public void actionPerformed(ActionEvent e) {
			svgCanvas.flush();
			// Force redraw...
			svgCanvas.setRenderingTransform(svgCanvas.getRenderingTransform());
		}
	}

	/**
	 * To toggle visiblity of JavaScript Debugger.
	 */
	public class ToggleDebuggerAction extends AbstractAction {
		public ToggleDebuggerAction() {
			super("Toggle Debugger Action");
		}
            System.out.println(msg);
            time = System.currentTimeMillis();
        }
        statusBar.setMainMessage(msg);
        stopAction.update(true);
        svgCanvas.setCursor(WAIT_CURSOR);
    }

		public void actionPerformed(ActionEvent e) {
			if (debugger == null) {
				showDebugger();
			} else {
				hideDebugger();
			}
		}
	}
        if (findDialog != null) {
            if(findDialog.isVisible()) {
                findDialog.setGraphicsNode(svgCanvas.getGraphicsNode());
            } else {
                findDialog.dispose();
                findDialog = null;
            }
        }
        stopAction.update(false);
        svgCanvas.setCursor(DEFAULT_CURSOR);
        svgCanvas.setSelectionOverlayXORMode
            (application.isSelectionOverlayXORMode());
        svgCanvas.requestFocus();  // request focus when load completes.
        if (debugger != null) {
            debugger.attach();
        }
    }

	/**
	 * To go back to the previous transform
	 */
	public class PreviousTransformAction extends AbstractAction implements
			JComponentModifier {
		List components = new LinkedList();
            System.out.println(msg);
        }
        statusBar.setMainMessage("");
        statusBar.setMessage(msg);
        stopAction.update(false);
        svgCanvas.setCursor(DEFAULT_CURSOR);
        svgCanvas.setSelectionOverlayXORMode
            (application.isSelectionOverlayXORMode());
    }

		public PreviousTransformAction() {
		}
     */
    public void gvtBuildFailed(GVTTreeBuilderEvent e) {
        String msg = resources.getString("Message.treeFailed");
        if (debug) {
            System.out.println(msg);
        }
        statusBar.setMainMessage("");
        statusBar.setMessage(msg);
        stopAction.update(false);
        svgCanvas.setCursor(DEFAULT_CURSOR);
        svgCanvas.setSelectionOverlayXORMode
            (application.isSelectionOverlayXORMode());
        if (autoAdjust) {
            pack();
        }
    }

		public void actionPerformed(ActionEvent e) {
			if (transformHistory.canGoBack()) {
				transformHistory.back();
				update();
				nextTransformAction.update();
				svgCanvas.setRenderingTransform(transformHistory
						.currentTransform());
			}
		}

		public void addJComponent(JComponent c) {
			components.add(c);
			c.setEnabled(false);
		}
        String msg = resources.getString("Message.onload");
        if (debug) {
            System.out.println(msg);
            time = System.currentTimeMillis();
        }
        stopAction.update(true);
        statusBar.setMainMessage(msg);
    }

		protected void update() {
			boolean b = transformHistory.canGoBack();
			Iterator it = components.iterator();
			while (it.hasNext()) {
				((JComponent) it.next()).setEnabled(b);
			}
		}
	}
        stopAction.update(false);
        statusBar.setMainMessage("");
        statusBar.setMessage(resources.getString("Message.done"));
    }

	/**
	 * To go forward to the next transform
	 */
	public class NextTransformAction extends AbstractAction implements
			JComponentModifier {
		List components = new LinkedList();
            System.out.println(msg);
        }
        stopAction.update(false);
        statusBar.setMainMessage("");
        statusBar.setMessage(msg);
    }

		public NextTransformAction() {
		}
     */
    public void svgLoadEventDispatchFailed(SVGLoadEventDispatcherEvent e) {
        String msg = resources.getString("Message.onloadFailed");
        if (debug) {
            System.out.println(msg);
        }
        stopAction.update(false);
        statusBar.setMainMessage("");
        statusBar.setMessage(msg);
    }

		public void actionPerformed(ActionEvent e) {
			if (transformHistory.canGoForward()) {
				transformHistory.forward();
				update();
				previousTransformAction.update();
				svgCanvas.setRenderingTransform(transformHistory
						.currentTransform());
			}
		}

		public void addJComponent(JComponent c) {
			components.add(c);
			c.setEnabled(false);
		}
        if (debug) {
            String msg = resources.getString("Message.treeRenderingPrep");
            System.out.println(msg);
            time = System.currentTimeMillis();
        }
        stopAction.update(true);
        svgCanvas.setCursor(WAIT_CURSOR);
        statusBar.setMainMessage(resources.getString("Message.treeRendering"));
    }

		protected void update() {
			boolean b = transformHistory.canGoForward();
			Iterator it = components.iterator();
			while (it.hasNext()) {
				((JComponent) it.next()).setEnabled(b);
			}
		}
	}
            time = System.currentTimeMillis();
            msg = resources.getString("Message.treeRenderingStart");
            System.out.println(msg);
        }
        // Do nothing
    }

	/**
	 * To apply the selected author stylesheet
	 */
	public class UseStylesheetAction extends AbstractAction implements
			JComponentModifier {
            String msg = resources.getString("Message.treeRenderingTime");
            System.out.print(msg);
            System.out.println((System.currentTimeMillis() - time) + " ms");
        }
        statusBar.setMainMessage("");
        statusBar.setMessage(resources.getString("Message.done"));
        if (!svgCanvas.isDynamic() || managerStopped) {
            stopAction.update(false);
        }
        svgCanvas.setCursor(DEFAULT_CURSOR);

		List components = new LinkedList();
        previousTransformAction.update();
        nextTransformAction.update();
    }

		public UseStylesheetAction() {
		}
     */
    public void gvtRenderingCancelled(GVTTreeRendererEvent e) {
        String msg = resources.getString("Message.treeRenderingCancelled");
        if (debug) {
            System.out.println(msg);
        }
        statusBar.setMainMessage("");
        statusBar.setMessage(msg);
        if (!svgCanvas.isDynamic()) {
            stopAction.update(false);
        }
        svgCanvas.setCursor(DEFAULT_CURSOR);
    }

		public void actionPerformed(ActionEvent e) {
		}
     */
    public void gvtRenderingFailed(GVTTreeRendererEvent e) {
        String msg = resources.getString("Message.treeRenderingFailed");
        if (debug) {
            System.out.println(msg);
        }
        statusBar.setMainMessage("");
        statusBar.setMessage(msg);
        if (!svgCanvas.isDynamic()) {
            stopAction.update(false);
        }
        svgCanvas.setCursor(DEFAULT_CURSOR);
    }

		public void addJComponent(JComponent c) {
			components.add(c);
			c.setEnabled(false);
		}

		protected void update() {
			alternateStyleSheet = null;
			Iterator it = components.iterator();
			SVGDocument doc = svgCanvas.getSVGDocument();
			while (it.hasNext()) {
				JComponent stylesheetMenu = (JComponent) it.next();
				stylesheetMenu.removeAll();
				stylesheetMenu.setEnabled(false);
            if (!url.sameFile(docURL)) {
                return;
            }

				ButtonGroup buttonGroup = new ButtonGroup();
                localHistory.update(s);
                locationBar.setText(s);
                if (debugger != null) {
                    debugger.detach();
                    debugger.setDocumentURL(s);
                }
                application.addVisitedURI(s);
                backAction.update();
                forwardAction.update();

				for (Node n = doc.getFirstChild(); n != null
						&& n.getNodeType() != Node.ELEMENT_NODE; n = n
						.getNextSibling()) {
					if (n instanceof StyleSheetProcessingInstruction) {
						StyleSheetProcessingInstruction sspi;
						sspi = (StyleSheetProcessingInstruction) n;
						HashTable attrs = sspi.getPseudoAttributes();
						final String title = (String) attrs.get("title");
						String alt = (String) attrs.get("alternate");
						if (title != null && "yes".equals(alt)) {
							JRadioButtonMenuItem button;
							button = new JRadioButtonMenuItem(title);

							button
									.addActionListener(new java.awt.event.ActionListener() {
										public void actionPerformed(
												ActionEvent e) {
											SVGOMDocument doc;
											doc = (SVGOMDocument) svgCanvas
													.getSVGDocument();
											doc.clearViewCSS();
											alternateStyleSheet = title;
											svgCanvas.setSVGDocument(doc);
										}
									});

							buttonGroup.add(button);
							stylesheetMenu.add(button);
							stylesheetMenu.setEnabled(true);
						}
					}
				}
			}
		}
	}
        playAction.update(false);
        pauseAction.update(true);
        stopAction.update(true);
    }

	/**
	 * To restart after a pause.
	 */
	public class PlayAction extends AbstractAction implements
			JComponentModifier {
		List components = new LinkedList();
            System.out.println(msg);
        }
        playAction.update(true);
        pauseAction.update(false);
    }

		public PlayAction() {
		}
     */
    public void managerResumed(UpdateManagerEvent e) {
        if (debug) {
            String msg = resources.getString("Message.updateManagerResumed");
            System.out.println(msg);
        }
        playAction.update(false);
        pauseAction.update(true);
    }

		public void actionPerformed(ActionEvent e) {
			svgCanvas.resumeProcessing();
		}
    public void managerStopped(UpdateManagerEvent e) {
        if (debug) {
            String msg = resources.getString("Message.updateManagerStopped");
            System.out.println(msg);
        }
        managerStopped = true;
        playAction.update(false);
        pauseAction.update(false);
        stopAction.update(false);
    }

		public void addJComponent(JComponent c) {
			components.add(c);
			c.setEnabled(false);
		}
    }

		public void update(boolean enabled) {
			Iterator it = components.iterator();
			while (it.hasNext()) {
				((JComponent) it.next()).setEnabled(enabled);
			}
		}
	}

	/**
	 * To pause a document.
	 */
	public class PauseAction extends AbstractAction implements
			JComponentModifier {
		List components = new LinkedList();

		public PauseAction() {
		}
     */
    protected class UserAgent implements SVGUserAgent {

		public void actionPerformed(ActionEvent e) {
			svgCanvas.suspendProcessing();
		}
        protected UserAgent() {
        }

		public void addJComponent(JComponent c) {
			components.add(c);
			c.setEnabled(false);
		}
            if (debug) {
                System.err.println(message);
            }
            JOptionPane pane =
                new JOptionPane(message, JOptionPane.ERROR_MESSAGE);
            JDialog dialog = pane.createDialog(JSVGViewerFrame.this, "ERROR");
            dialog.setModal(false);
            dialog.setVisible(true);
        }

		public void update(boolean enabled) {
			Iterator it = components.iterator();
			while (it.hasNext()) {
				((JComponent) it.next()).setEnabled(enabled);
			}
		}
	}
            JErrorPane pane =
                new JErrorPane(ex, JOptionPane.ERROR_MESSAGE);
            JDialog dialog = pane.createDialog(JSVGViewerFrame.this, "ERROR");
            dialog.setModal(false);
            dialog.setVisible(true);
        }

	/**
	 * To stop the current processing.
	 */
	public class StopAction extends AbstractAction implements
			JComponentModifier {
		List components = new LinkedList();
        }

		public StopAction() {
		}
         */
        public void showAlert(String message) {
            svgCanvas.showAlert(message);
        }

		public void actionPerformed(ActionEvent e) {
			svgCanvas.stopProcessing();
		}
        public String showPrompt(String message) {
            return svgCanvas.showPrompt(message);
        }

		public void addJComponent(JComponent c) {
			components.add(c);
			c.setEnabled(false);
		}
            return svgCanvas.showPrompt(message, defaultValue);
        }

		public void update(boolean enabled) {
			Iterator it = components.iterator();
			while (it.hasNext()) {
				((JComponent) it.next()).setEnabled(enabled);
			}
		}
	}

	/**
	 * To show the set transform dialog
	 */
	public class SetTransformAction extends AbstractAction {
		public SetTransformAction() {
		}

		public void actionPerformed(ActionEvent e) {
			if (transformDialog == null) {
				transformDialog = JAffineTransformChooser.createDialog(
						JSVGViewerFrame.this, resources
								.getString("SetTransform.title"));
			}
            return getPixelUnitToMillimeter();

			AffineTransform txf = transformDialog.showDialog();
			if (txf != null) {
				AffineTransform at = svgCanvas.getRenderingTransform();
				if (at == null) {
					at = new AffineTransform();
				}

				txf.concatenate(at);
				svgCanvas.setRenderingTransform(txf);
			}
		}
	}
        }

	/**
	 * To display the memory monitor.
	 */
	public class MonitorAction extends AbstractAction {
		public MonitorAction() {
		}
        }

		public void actionPerformed(ActionEvent e) {
			if (memoryMonitorFrame == null) {
				memoryMonitorFrame = new MemoryMonitor();
				Rectangle fr = getBounds();
				Dimension md = memoryMonitorFrame.getSize();
				memoryMonitorFrame.setLocation(
						fr.x + (fr.width - md.width) / 2, fr.y
								+ (fr.height - md.height) / 2);
			}
			memoryMonitorFrame.setVisible(true);
		}
	}
            case 600: return 400;
            case 700: return 400;
            case 800: return 400;
            case 900: return 400;
            default:
                throw new IllegalArgumentException("Bad Font Weight: " + f);
            }
        }

	/**
	 * To display the Find dialog
	 */
	public class FindDialogAction extends AbstractAction {
		public FindDialogAction() {
		}
            switch (weight) {
            case 100: return 600;
            case 200: return 600;
            case 300: return 600;
            case 400: return 600;
            case 500: return 600;
            case 600: return 700;
            case 700: return 800;
            case 800: return 900;
            case 900: return 900;
            default:
                throw new IllegalArgumentException("Bad Font Weight: " + f);
            }
        }

		public void actionPerformed(ActionEvent e) {
			if (findDialog == null) {
				findDialog = new FindDialog(JSVGViewerFrame.this, svgCanvas);
				findDialog.setGraphicsNode(svgCanvas.getGraphicsNode());
				findDialog.pack();
				Rectangle fr = getBounds();
				Dimension td = findDialog.getSize();
				findDialog.setLocation(fr.x + (fr.width - td.width) / 2, fr.y
						+ (fr.height - td.height) / 2);
			}
			findDialog.setVisible(true);
		}
	}

	/**
	 * To display the Thumbnail dialog
	 */
	public class ThumbnailDialogAction extends AbstractAction {
		public ThumbnailDialogAction() {
		}

		public void actionPerformed(ActionEvent e) {
			if (thumbnailDialog == null) {
				thumbnailDialog = new ThumbnailDialog(JSVGViewerFrame.this,
						svgCanvas);
				thumbnailDialog.pack();
				Rectangle fr = getBounds();
				Dimension td = thumbnailDialog.getSize();
				thumbnailDialog.setLocation(fr.x + (fr.width - td.width) / 2,
						fr.y + (fr.height - td.height) / 2);
			}
			thumbnailDialog.setInteractionEnabled(!svgCanvas
					.getDisableInteractions());
			thumbnailDialog.setVisible(true);
		}
	}

	/**
	 * To display the document full screen
	 */
	public class FullScreenAction extends AbstractAction {
		public FullScreenAction() {
		}

		public void actionPerformed(ActionEvent e) {
			if (window == null || !window.isVisible()) {
				if (window == null) {
					window = new JWindow(JSVGViewerFrame.this);
					Dimension size = Toolkit.getDefaultToolkit()
							.getScreenSize();
					window.setSize(size);
				}
				// Go to full screen in JWindow)
				svgCanvas.getParent().remove(svgCanvas);
				window.getContentPane().add(svgCanvas);
				window.setVisible(true);
				window.toFront();
				svgCanvas.requestFocus();
			} else {
				// Go back to JSVGViewerFrame display
				svgCanvas.getParent().remove(svgCanvas);
				svgCanvasPanel.add(svgCanvas, BorderLayout.CENTER);
				window.setVisible(false);
			}
		}
	}

	/**
	 * To display the DOM viewer of the document
	 */
	public class DOMViewerAction extends AbstractAction {
		
		public DOMViewerAction() {
		}

		public void actionPerformed(ActionEvent e) {
			if (domViewer == null) {
				domViewer = new DOMViewer();
				if (svgDocument != null) {
					domViewer.setDocument(svgDocument, (ViewCSS) svgDocument
							.getDocumentElement());
				}
				Rectangle fr = getBounds();
				Dimension td = domViewer.getSize();
				domViewer.setLocation(fr.x + (fr.width - td.width) / 2, fr.y
						+ (fr.height - td.height) / 2);
			}
			domViewer.setVisible(true);
		}
		
		public DOMViewer getDOMViewer() {
			return domViewer;
		}
	}

	/**
	 * To display the Timeline viewer of the document
	 */
	public class TimelineViewerAction extends AbstractAction {
		public TimelineViewerAction() {
		}
            if (newc) {
                application.openLink(uri);
            } else {
                showSVGDocument(uri);
            }
        }

		public void actionPerformed(ActionEvent e) {
			if (timelineViewer == null) {
				timelineViewer = new TimelineViewer(svgDocument);
				Rectangle fr = getBounds();
				Dimension td = timelineViewer.getSize();
				timelineViewer.setLocation(fr.x + (fr.width - td.width) / 2, fr.y
						+ (fr.height - td.height) / 2);
			}
			timelineViewer.setVisible(true);
		}
	}

	// ActionMap /////////////////////////////////////////////////////
        }

	/**
	 * The map that contains the action listeners
	 */
	protected Map listeners = new HashMap();
         * @param scriptType type of script, as found in the
         *        type attribute of the &lt;script&gt; element.
         * @param scriptURL url for the script, as defined in
         *        the script's xlink:href attribute. If that
         *        attribute was empty, then this parameter should
         *        be null
         * @param docURL url for the document into which the
         *        script was found.
         */
        public ScriptSecurity getScriptSecurity(String scriptType,
                                                ParsedURL scriptURL,
                                                ParsedURL docURL){
            if (!application.canLoadScriptType(scriptType)) {
                return new NoLoadScriptSecurity(scriptType);
            } else {
                switch(application.getAllowedScriptOrigin()) {
                case ResourceOrigin.ANY:
                    return new RelaxedScriptSecurity(scriptType,
                                                     scriptURL,
                                                     docURL);
                case ResourceOrigin.DOCUMENT:
                    return new DefaultScriptSecurity(scriptType,
                                                     scriptURL,
                                                     docURL);
                case ResourceOrigin.EMBEDED:
                    return new EmbededScriptSecurity(scriptType,
                                                     scriptURL,
                                                     docURL);
                default:
                    return new NoLoadScriptSecurity(scriptType);
                }
            }
        }

	/**
	 * Returns the action associated with the given string or null on error
	 * 
	 * @param key
	 *            the key mapped with the action to get
	 * @throws MissingListenerException
	 *             if the action is not found
	 */
	public Action getAction(String key) throws MissingListenerException {
		Action result = (Action) listeners.get(key);
		// if (result == null) {
		// result = canvas.getAction(key);
		// }
		if (result == null) {
			throw new MissingListenerException("Can't find action.", RESOURCES,
					key);
		}
		return result;
	}
                                    ParsedURL scriptURL,
                                    ParsedURL docURL) throws SecurityException {
            ScriptSecurity s = getScriptSecurity(scriptType,
                                                     scriptURL,
                                                     docURL);

	// SVGDocumentLoaderListener ///////////////////////////////////////////
                s.checkLoadScript();
            }
        }

	long time; // For debug.
         * Returns the security settings for the given
         * resource url and document url
         *
         * @param resourceURL url for the resource, as defined in
         *        the resource's xlink:href attribute. If that
         *        attribute was empty, then this parameter should
         *        be null
         * @param docURL url for the document into which the
         *        resource was found.
         */
        public ExternalResourceSecurity
            getExternalResourceSecurity(ParsedURL resourceURL,
                                        ParsedURL docURL){
            switch(application.getAllowedExternalResourceOrigin()) {
            case ResourceOrigin.ANY:
                return new RelaxedExternalResourceSecurity(resourceURL,
                                                           docURL);
            case ResourceOrigin.DOCUMENT:
                return new DefaultExternalResourceSecurity(resourceURL,
                                                           docURL);
            case ResourceOrigin.EMBEDED:
                return new EmbededExternalResourceSecurity(resourceURL);
            default:
                return new NoLoadExternalResourceSecurity();
            }
        }

	/**
	 * Called when the loading of a document was started.
	 */
	public void documentLoadingStarted(SVGDocumentLoaderEvent e) {
		String msg = resources.getString("Message.documentLoad");
		if (debug) {
			System.out.println(msg);
			time = System.currentTimeMillis();
		}
		statusBar.setMainMessage(msg);
		stopAction.update(true);
		svgCanvas.setCursor(WAIT_CURSOR);
	}
         * @param docURL url for the document into which the
         *        resource was found.
         */
        public void
            checkLoadExternalResource(ParsedURL resourceURL,
                                      ParsedURL docURL) throws SecurityException {
            ExternalResourceSecurity s
                =  getExternalResourceSecurity(resourceURL, docURL);

	/**
	 * Called when the loading of a document was completed.
	 */
	public void documentLoadingCompleted(SVGDocumentLoaderEvent e) {
		if (debug) {
			System.out.print(resources.getString("Message.documentLoadTime"));
			System.out.println((System.currentTimeMillis() - time) + " ms");
		}

		setSVGDocument(e.getSVGDocument(), e.getSVGDocument().getURL(), e
				.getSVGDocument().getTitle(), e.getDocumentDescriptor());
	}
    protected static class ImageFileFilter extends FileFilter {

	/**
	 * Forces the viewer frame to show the input SVGDocument
	 */
	public void setSVGDocument(SVGDocument svgDocument, String svgDocumentURL,
			String svgDocumentTitle, DocumentDescriptor docDescriptor) {
		this.svgDocument = svgDocument;
		this.docDescriptor = docDescriptor;

		if (domViewer != null) {
			if (domViewer.isVisible() && svgDocument != null) {
				domViewer.setDocument(svgDocument, (ViewCSS) svgDocument
						.getDocumentElement());
			} else {
				domViewer.dispose();
				domViewer = null;
			}
		}
		if (timelineViewer != null) {
			if (timelineViewer.isVisible() && svgDocument != null) {
//				timelineViewer.setDocument(svgDocument);
			} else {
//				timelineViewer.dispose();
				timelineViewer = null;
			}
		}
		stopAction.update(false);
		svgCanvas.setCursor(DEFAULT_CURSOR);
		String s = svgDocumentURL;
		locationBar.setText(s);
		if (debugger != null) {
			debugger.detach();
			debugger.setDocumentURL(s);
		}
		if (title == null) {
			title = getTitle();
		}

		String dt = svgDocumentTitle;
		if (dt.length() != 0) {
			setTitle(title + ": " + dt);
		} else {
			int i = s.lastIndexOf("/");
			if (i == -1)
				i = s.lastIndexOf("\\");
			if (i == -1) {
				setTitle(title + ": " + s);
			} else {
				setTitle(title + ": " + s.substring(i + 1));
			}
		}
                        accept = true;
                    }
                }
            }
            return accept;
        }

		localHistory.update(s);
		application.addVisitedURI(s);
		backAction.update();
		forwardAction.update();

		transformHistory = new TransformHistory();
		previousTransformAction.update();
		nextTransformAction.update();

		useStylesheetAction.update();
	}

	/**
	 * Called when the loading of a document was cancelled.
	 */
	public void documentLoadingCancelled(SVGDocumentLoaderEvent e) {
		String msg = resources.getString("Message.documentCancelled");
		if (debug) {
			System.out.println(msg);
		}
		statusBar.setMainMessage("");
		statusBar.setMessage(msg);
		stopAction.update(false);
		svgCanvas.setCursor(DEFAULT_CURSOR);
	}

	/**
	 * Called when the loading of a document has failed.
	 */
	public void documentLoadingFailed(SVGDocumentLoaderEvent e) {
		String msg = resources.getString("Message.documentFailed");
		if (debug) {
			System.out.println(msg);
		}
		statusBar.setMainMessage("");
		statusBar.setMessage(msg);
		stopAction.update(false);
		svgCanvas.setCursor(DEFAULT_CURSOR);
	}

	// GVTTreeBuilderListener //////////////////////////////////////////////

	/**
	 * Called when a build started. The data of the event is initialized to the
	 * old document.
	 */
	public void gvtBuildStarted(GVTTreeBuilderEvent e) {
		String msg = resources.getString("Message.treeBuild");
		if (debug) {
			System.out.println(msg);
			time = System.currentTimeMillis();
		}
		statusBar.setMainMessage(msg);
		stopAction.update(true);
		svgCanvas.setCursor(WAIT_CURSOR);
	}

	/**
	 * Called when a build was completed.
	 */
	public void gvtBuildCompleted(GVTTreeBuilderEvent e) {
		if (debug) {
			System.out.print(resources.getString("Message.treeBuildTime"));
			System.out.println((System.currentTimeMillis() - time) + " ms");
		}
		if (findDialog != null) {
			if (findDialog.isVisible()) {
				findDialog.setGraphicsNode(svgCanvas.getGraphicsNode());
			} else {
				findDialog.dispose();
				findDialog = null;
			}
		}
		stopAction.update(false);
		svgCanvas.setCursor(DEFAULT_CURSOR);
		svgCanvas.setSelectionOverlayXORMode(application
				.isSelectionOverlayXORMode());
		svgCanvas.requestFocus(); // request focus when load completes.
		if (debugger != null) {
			debugger.attach();
		}
	}

	/**
	 * Called when a build was cancelled.
	 */
	public void gvtBuildCancelled(GVTTreeBuilderEvent e) {
		String msg = resources.getString("Message.treeCancelled");
		if (debug) {
			System.out.println(msg);
		}
		statusBar.setMainMessage("");
		statusBar.setMessage(msg);
		stopAction.update(false);
		svgCanvas.setCursor(DEFAULT_CURSOR);
		svgCanvas.setSelectionOverlayXORMode(application
				.isSelectionOverlayXORMode());
	}

	/**
	 * Called when a build failed.
	 */
	public void gvtBuildFailed(GVTTreeBuilderEvent e) {
		String msg = resources.getString("Message.treeFailed");
		if (debug) {
			System.out.println(msg);
		}
		statusBar.setMainMessage("");
		statusBar.setMessage(msg);
		stopAction.update(false);
		svgCanvas.setCursor(DEFAULT_CURSOR);
		svgCanvas.setSelectionOverlayXORMode(application
				.isSelectionOverlayXORMode());
		if (autoAdjust) {
			pack();
		}
	}

	// SVGLoadEventDispatcherListener //////////////////////////////////////

	/**
	 * Called when a onload event dispatch started.
	 */
	public void svgLoadEventDispatchStarted(SVGLoadEventDispatcherEvent e) {
		String msg = resources.getString("Message.onload");
		if (debug) {
			System.out.println(msg);
			time = System.currentTimeMillis();
		}
		stopAction.update(true);
		statusBar.setMainMessage(msg);
	}

	/**
	 * Called when a onload event dispatch was completed.
	 */
	public void svgLoadEventDispatchCompleted(SVGLoadEventDispatcherEvent e) {
		if (debug) {
			System.out.print(resources.getString("Message.onloadTime"));
			System.out.println((System.currentTimeMillis() - time) + " ms");
		}
		stopAction.update(false);
		statusBar.setMainMessage("");
		statusBar.setMessage(resources.getString("Message.done"));
	}

	/**
	 * Called when a onload event dispatch was cancelled.
	 */
	public void svgLoadEventDispatchCancelled(SVGLoadEventDispatcherEvent e) {
		String msg = resources.getString("Message.onloadCancelled");
		if (debug) {
			System.out.println(msg);
		}
		stopAction.update(false);
		statusBar.setMainMessage("");
		statusBar.setMessage(msg);
	}

	/**
	 * Called when a onload event dispatch failed.
	 */
	public void svgLoadEventDispatchFailed(SVGLoadEventDispatcherEvent e) {
		String msg = resources.getString("Message.onloadFailed");
		if (debug) {
			System.out.println(msg);
		}
		stopAction.update(false);
		statusBar.setMainMessage("");
		statusBar.setMessage(msg);
	}

	// GVTTreeRendererListener /////////////////////////////////////////////

	/**
	 * Called when a rendering is in its preparing phase.
	 */
	public void gvtRenderingPrepare(GVTTreeRendererEvent e) {
		if (debug) {
			String msg = resources.getString("Message.treeRenderingPrep");
			System.out.println(msg);
			time = System.currentTimeMillis();
		}
		stopAction.update(true);
		svgCanvas.setCursor(WAIT_CURSOR);
		statusBar.setMainMessage(resources.getString("Message.treeRendering"));
	}

	/**
	 * Called when a rendering started.
	 */
	public void gvtRenderingStarted(GVTTreeRendererEvent e) {
		if (debug) {
			String msg = resources.getString("Message.treeRenderingPrepTime");
			System.out.print(msg);
			System.out.println((System.currentTimeMillis() - time) + " ms");
			time = System.currentTimeMillis();
			msg = resources.getString("Message.treeRenderingStart");
			System.out.println(msg);
		}
		// Do nothing
	}

	/**
	 * Called when a rendering was completed.
	 */
	public void gvtRenderingCompleted(GVTTreeRendererEvent e) {
		if (debug) {
			String msg = resources.getString("Message.treeRenderingTime");
			System.out.print(msg);
			System.out.println((System.currentTimeMillis() - time) + " ms");
		}
		statusBar.setMainMessage("");
		statusBar.setMessage(resources.getString("Message.done"));
		if (!svgCanvas.isDynamic() || managerStopped) {
			stopAction.update(false);
		}
		svgCanvas.setCursor(DEFAULT_CURSOR);

		transformHistory.update(svgCanvas.getRenderingTransform());
		previousTransformAction.update();
		nextTransformAction.update();
	}

	/**
	 * Called when a rendering was cancelled.
	 */
	public void gvtRenderingCancelled(GVTTreeRendererEvent e) {
		String msg = resources.getString("Message.treeRenderingCancelled");
		if (debug) {
			System.out.println(msg);
		}
		statusBar.setMainMessage("");
		statusBar.setMessage(msg);
		if (!svgCanvas.isDynamic()) {
			stopAction.update(false);
		}
		svgCanvas.setCursor(DEFAULT_CURSOR);
	}

	/**
	 * Called when a rendering failed.
	 */
	public void gvtRenderingFailed(GVTTreeRendererEvent e) {
		String msg = resources.getString("Message.treeRenderingFailed");
		if (debug) {
			System.out.println(msg);
		}
		statusBar.setMainMessage("");
		statusBar.setMessage(msg);
		if (!svgCanvas.isDynamic()) {
			stopAction.update(false);
		}
		svgCanvas.setCursor(DEFAULT_CURSOR);
	}

	// LinkActivationListener /////////////////////////////////////////

	/**
	 * Called when a link was activated.
	 */
	public void linkActivated(LinkActivationEvent e) {
		String s = e.getReferencedURI();
		if (svgDocument != null) {
			ParsedURL docURL = new ParsedURL(svgDocument.getURL());
			ParsedURL url = new ParsedURL(docURL, s);
			if (!url.sameFile(docURL)) {
				return;
			}

			if (s.indexOf('#') != -1) {
				localHistory.update(s);
				locationBar.setText(s);
				if (debugger != null) {
					debugger.detach();
					debugger.setDocumentURL(s);
				}
				application.addVisitedURI(s);
				backAction.update();
				forwardAction.update();

				transformHistory = new TransformHistory();
				previousTransformAction.update();
				nextTransformAction.update();
			}
		}
	}

	// UpdateManagerListener ////////////////////////////////////////////////

	/**
	 * Called when the manager was started.
	 */
	public void managerStarted(UpdateManagerEvent e) {
		if (debug) {
			String msg = resources.getString("Message.updateManagerStarted");
			System.out.println(msg);
		}
		managerStopped = false;
		playAction.update(false);
		pauseAction.update(true);
		stopAction.update(true);
	}

	/**
	 * Called when the manager was suspended.
	 */
	public void managerSuspended(UpdateManagerEvent e) {
		if (debug) {
			String msg = resources.getString("Message.updateManagerSuspended");
			System.out.println(msg);
		}
		playAction.update(true);
		pauseAction.update(false);
	}

	/**
	 * Called when the manager was resumed.
	 */
	public void managerResumed(UpdateManagerEvent e) {
		if (debug) {
			String msg = resources.getString("Message.updateManagerResumed");
			System.out.println(msg);
		}
		playAction.update(false);
		pauseAction.update(true);
	}

	/**
	 * Called when the manager was stopped.
	 */
	public void managerStopped(UpdateManagerEvent e) {
		if (debug) {
			String msg = resources.getString("Message.updateManagerStopped");
			System.out.println(msg);
		}
		managerStopped = true;
		playAction.update(false);
		pauseAction.update(false);
		stopAction.update(false);
	}

	/**
	 * Called when an update started.
	 */
	public void updateStarted(final UpdateManagerEvent e) {
	}

	/**
	 * Called when an update was completed.
	 */
	public void updateCompleted(final UpdateManagerEvent e) {
	}

	/**
	 * Called when an update failed.
	 */
	public void updateFailed(UpdateManagerEvent e) {
	}

	/**
	 * This class implements a SVG user agent.
	 */
	protected class UserAgent implements SVGUserAgent {

		/**
		 * Creates a new SVGUserAgent.
		 */
		protected UserAgent() {
		}

		/**
		 * Displays an error message.
		 */
		public void displayError(String message) {
			if (debug) {
				System.err.println(message);
			}
			JOptionPane pane = new JOptionPane(message,
					JOptionPane.ERROR_MESSAGE);
			JDialog dialog = pane.createDialog(JSVGViewerFrame.this, "ERROR");
			dialog.setModal(false);
			dialog.setVisible(true);
		}

		/**
		 * Displays an error resulting from the specified Exception.
		 */
		public void displayError(Exception ex) {
			if (debug) {
				ex.printStackTrace();
			}
			// JErrorPane pane =
			// new JErrorPane(ex, JOptionPane.ERROR_MESSAGE);
			ErrorConsole console = ErrorConsole.getInstance();
			if (ex instanceof LiveAttributeException) {
				LiveAttributeException lex = (LiveAttributeException) ex;
				ParsedURL purl = new ParsedURL(svgDocument.getURL());
				InputStream is = null;
				try {
					is = purl.openStream(getInputHandler(purl)
							.getHandledMimeTypes());
				} catch (IOException e) {
					e.printStackTrace();
					// do nothing, error console will report stream not
					// available
				}
				AttributeErrorInfo info = new AttributeErrorInfo(lex, svgDocument
						.getDocumentURI(), ErrorConsole.ERROR, is, lex
						.getElement(), docDescriptor,
						(ViewSourceAction) listeners.get(VIEW_SOURCE_ACTION),
						(DOMViewerAction) listeners.get(DOM_VIEWER_ACTION));
				console.add(info);
			} else {
				String uri;
				if (svgDocument == null) {
					uri = currentPath.getAbsolutePath();
				} else {
					uri = svgDocument.getDocumentURI();
				}
				ErrorInfo info = new ErrorInfo(ex,
						uri, ErrorConsole.ERROR);
				console.add(info);
			}
			ErrorConsole.showDialog(JSVGViewerFrame.this);
		}

		/**
		 * Displays a message in the User Agent interface. The given message is
		 * typically displayed in a status bar.
		 */
		public void displayMessage(String message) {
			statusBar.setMessage(message);
		}

		/**
		 * Shows an alert dialog box.
		 */
		public void showAlert(String message) {
			svgCanvas.showAlert(message);
		}

		/**
		 * Shows a prompt dialog box.
		 */
		public String showPrompt(String message) {
			return svgCanvas.showPrompt(message);
		}

		/**
		 * Shows a prompt dialog box.
		 */
		public String showPrompt(String message, String defaultValue) {
			return svgCanvas.showPrompt(message, defaultValue);
		}

		/**
		 * Shows a confirm dialog box.
		 */
		public boolean showConfirm(String message) {
			return svgCanvas.showConfirm(message);
		}

		/**
		 * Returns the size of a px CSS unit in millimeters.
		 */
		public float getPixelUnitToMillimeter() {
			return 0.26458333333333333333333333333333f; // 96dpi
		}

		/**
		 * Returns the size of a px CSS unit in millimeters. This will be
		 * removed after next release.
		 * 
		 * @see #getPixelUnitToMillimeter()
		 */
		public float getPixelToMM() {
			return getPixelUnitToMillimeter();

		}

		/**
		 * Returns the default font family.
		 */
		public String getDefaultFontFamily() {
			return application.getDefaultFontFamily();
		}

		/**
		 * Returns the medium font size.
		 */
		public float getMediumFontSize() {
			// 9pt (72pt == 1in)
			return 9f * 25.4f / (72f * getPixelUnitToMillimeter());
		}

		/**
		 * Returns a lighter font-weight.
		 */
		public float getLighterFontWeight(float f) {
			// Round f to nearest 100...
			int weight = ((int) ((f + 50) / 100)) * 100;
			switch (weight) {
			case 100:
				return 100;
			case 200:
				return 100;
			case 300:
				return 200;
			case 400:
				return 300;
			case 500:
				return 400;
			case 600:
				return 400;
			case 700:
				return 400;
			case 800:
				return 400;
			case 900:
				return 400;
			default:
				throw new IllegalArgumentException("Bad Font Weight: " + f);
			}
		}

		/**
		 * Returns a bolder font-weight.
		 */
		public float getBolderFontWeight(float f) {
			// Round f to nearest 100...
			int weight = ((int) ((f + 50) / 100)) * 100;
			switch (weight) {
			case 100:
				return 600;
			case 200:
				return 600;
			case 300:
				return 600;
			case 400:
				return 600;
			case 500:
				return 600;
			case 600:
				return 700;
			case 700:
				return 800;
			case 800:
				return 900;
			case 900:
				return 900;
			default:
				throw new IllegalArgumentException("Bad Font Weight: " + f);
			}
		}

		/**
		 * Returns the language settings.
		 */
		public String getLanguages() {
			return application.getLanguages();
		}

		/**
		 * Returns the user stylesheet uri.
		 * 
		 * @return null if no user style sheet was specified.
		 */
		public String getUserStyleSheetURI() {
			return application.getUserStyleSheetURI();
		}

		/**
		 * Returns the class name of the XML parser.
		 */
		public String getXMLParserClassName() {
			return application.getXMLParserClassName();
		}

		/**
		 * Returns true if the XML parser must be in validation mode, false
		 * otherwise.
		 */
		public boolean isXMLParserValidating() {
			return application.isXMLParserValidating();
		}

		/**
		 * Returns this user agent's CSS media.
		 */
		public String getMedia() {
			return application.getMedia();
		}

		/**
		 * Returns this user agent's alternate style-sheet title.
		 */
		public String getAlternateStyleSheet() {
			return alternateStyleSheet;
		}

		/**
		 * Opens a link.
		 * 
		 * @param uri
		 *            The document URI.
		 * @param newc
		 *            Whether the link should be activated in a new component.
		 */
		public void openLink(String uri, boolean newc) {
			if (newc) {
				application.openLink(uri);
			} else {
				showSVGDocument(uri);
			}
		}

		/**
		 * Tells whether the given extension is supported by this user agent.
		 */
		public boolean supportExtension(String s) {
			return false;
		}

		public void handleElement(Element elt, Object data) {
		}

		/**
		 * Returns the security settings for the given script type, script url
		 * and document url
		 * 
		 * @param scriptType
		 *            type of script, as found in the type attribute of the
		 *            &lt;script&gt; element.
		 * @param scriptURL
		 *            url for the script, as defined in the script's xlink:href
		 *            attribute. If that attribute was empty, then this
		 *            parameter should be null
		 * @param docURL
		 *            url for the document into which the script was found.
		 */
		public ScriptSecurity getScriptSecurity(String scriptType,
				ParsedURL scriptURL, ParsedURL docURL) {
			if (!application.canLoadScriptType(scriptType)) {
				return new NoLoadScriptSecurity(scriptType);
			} else {
				switch (application.getAllowedScriptOrigin()) {
				case ResourceOrigin.ANY:
					return new RelaxedScriptSecurity(scriptType, scriptURL,
							docURL);
				case ResourceOrigin.DOCUMENT:
					return new DefaultScriptSecurity(scriptType, scriptURL,
							docURL);
				case ResourceOrigin.EMBEDED:
					return new EmbededScriptSecurity(scriptType, scriptURL,
							docURL);
				default:
					return new NoLoadScriptSecurity(scriptType);
				}
			}
		}

		/**
		 * This method throws a SecurityException if the script of given type,
		 * found at url and referenced from docURL should not be loaded.
		 * 
		 * This is a convenience method to call checkLoadScript on the
		 * ScriptSecurity strategy returned by getScriptSecurity.
		 * 
		 * @param scriptType
		 *            type of script, as found in the type attribute of the
		 *            &lt;script&gt; element.
		 * @param scriptURL
		 *            url for the script, as defined in the script's xlink:href
		 *            attribute. If that attribute was empty, then this
		 *            parameter should be null
		 * @param docURL
		 *            url for the document into which the script was found.
		 */
		public void checkLoadScript(String scriptType, ParsedURL scriptURL,
				ParsedURL docURL) throws SecurityException {
			ScriptSecurity s = getScriptSecurity(scriptType, scriptURL, docURL);

			if (s != null) {
				s.checkLoadScript();
			}
		}

		/**
		 * Returns the security settings for the given resource url and document
		 * url
		 * 
		 * @param resourceURL
		 *            url for the resource, as defined in the resource's
		 *            xlink:href attribute. If that attribute was empty, then
		 *            this parameter should be null
		 * @param docURL
		 *            url for the document into which the resource was found.
		 */
		public ExternalResourceSecurity getExternalResourceSecurity(
				ParsedURL resourceURL, ParsedURL docURL) {
			switch (application.getAllowedExternalResourceOrigin()) {
			case ResourceOrigin.ANY:
				return new RelaxedExternalResourceSecurity(resourceURL, docURL);
			case ResourceOrigin.DOCUMENT:
				return new DefaultExternalResourceSecurity(resourceURL, docURL);
			case ResourceOrigin.EMBEDED:
				return new EmbededExternalResourceSecurity(resourceURL);
			default:
				return new NoLoadExternalResourceSecurity();
			}
		}

		/**
		 * This method throws a SecurityException if the resource found at url
		 * and referenced from docURL should not be loaded.
		 * 
		 * This is a convenience method to call checkLoadExternalResource on the
		 * ExternalResourceSecurity strategy returned by
		 * getExternalResourceSecurity.
		 * 
		 * @param resourceURL
		 *            url for the script, as defined in the resource's
		 *            xlink:href attribute. If that attribute was empty, then
		 *            this parameter should be null
		 * @param docURL
		 *            url for the document into which the resource was found.
		 */
		public void checkLoadExternalResource(ParsedURL resourceURL,
				ParsedURL docURL) throws SecurityException {
			ExternalResourceSecurity s = getExternalResourceSecurity(
					resourceURL, docURL);

			if (s != null) {
				s.checkLoadExternalResource();
			}
		}
	}

	/**
	 * A FileFilter used when exporting the SVG document as an image.
	 */
	protected static class ImageFileFilter extends FileFilter {

		/** The extension of the image filename. */
		protected String extension;

		public ImageFileFilter(String extension) {
			this.extension = extension;
		}

		/**
		 * Returns true if <tt>f</tt> is a file with the correct extension,
		 * false otherwise.
		 */
		public boolean accept(File f) {
			boolean accept = false;
			String fileName = null;
			if (f != null) {
				if (f.isDirectory()) {
					accept = true;
				} else {
					fileName = f.getPath().toLowerCase();
					if (fileName.endsWith(extension)) {
						accept = true;
					}
				}
			}
			return accept;
		}

		/**
		 * Returns the file description
		 */
		public String getDescription() {
			return extension;
		}
	}
}

Lines 213-219 Link Here

(-)sources/org/apache/batik/apps/svgbrowser/XMLInputHandler.java (-2 / +3 lines)
213	sw.close();	213	sw.close();
214		214
215	String parser = XMLResourceDescriptor.getXMLParserClassName();	215	String parser = XMLResourceDescriptor.getXMLParserClassName();
216	SAXSVGDocumentFactory f = new SAXSVGDocumentFactory(parser);	216	SAXSVGDocumentFactory f = new SAXSVGDocumentFactory(parser, true);
217	SVGDocument outDoc = null;	217	SVGDocument outDoc = null;
218		218
219	try {	219	try {
Lines 234-240 Link Here
234	svgViewerFrame.getJSVGCanvas().setSVGDocument(outDoc);	234	svgViewerFrame.getJSVGCanvas().setSVGDocument(outDoc);
235	svgViewerFrame.setSVGDocument(outDoc,	235	svgViewerFrame.setSVGDocument(outDoc,
236	uri,	236	uri,
237	outDoc.getTitle());	237	outDoc.getTitle(),
		238	f.getDocumentDescriptor());
238	}	239	}
239		240
240	/**	241	/**




import java.awt.event.ActionEvent;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;

import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.MutableTreeNode;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;

import org.apache.batik.bridge.svg12.ContentManager;
import org.apache.batik.bridge.svg12.DefaultXBLManager;

    }

    /**
     * Sets the node to be selected, none if node is null
     */
    public void setSelectionNode(Node node) {
    	panel.setSelectionNode(node);
    }
    
    /**
     * Sets the nodes to be selected, none if nodes is null
     */
    public void setSelectionNodes(Node[] nodes) {
    	panel.setSelectionNodes(nodes);
    }
    
    /**
     * Returns the action associated with the given string
     * or null on error
     * @param key the key mapped with the action to get

            return result;
        }

        public void setSelectionNode(Node node) {
        	if (node == null) {
        		setSelectionNodes(null);
        	} else {
        		setSelectionNodes(new Node[]{node});
        	}
        }
        
        public void setSelectionNodes(Node[] nodes) {
        	tree.setSelectionRow(-1);
        	if (nodes == null) {
        		return;
        	}
        	for (int i = 0; i < nodes.length; i++) {
        		DefaultMutableTreeNode treeNode = findNode(tree, nodes[i]);
        		if (treeNode != null) {
        			TreePath path = new TreePath(treeNode.getPath());
        			tree.setSelectionPath(path);
        		}
        	}
        }
        
		/**
		 * Returns the node in the tree that represents the given node in the
		 * document, or null if not found.
		 */
		protected DefaultMutableTreeNode findNode(JTree theTree, Node node) {
			DefaultMutableTreeNode root = (DefaultMutableTreeNode) theTree
					.getModel().getRoot();
			Enumeration treeNodes = root.breadthFirstEnumeration();
			while (treeNodes.hasMoreElements()) {
				DefaultMutableTreeNode currentNode = (DefaultMutableTreeNode) treeNodes
						.nextElement();
				NodeInfo userObject = (NodeInfo) currentNode.getUserObject();
				if (userObject.getNode() == node) {
					return currentNode;
				}
			}
			return null;
		}

        /**
         * To listen to the tree selection.
         */




/*

 Licensed to the Apache Software Foundation (ASF) under one or more
 contributor license agreements.  See the NOTICE file distributed with
 this work for additional information regarding copyright ownership.
 The ASF licenses this file to You under the Apache License, Version 2.0
 (the "License"); you may not use this file except in compliance with
 the License.  You may obtain a copy of the License at

 http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.

 */
package org.apache.batik.util.gui.resource;

import java.awt.BasicStroke;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Polygon;
import java.awt.Rectangle;
import java.awt.Stroke;
import java.awt.event.ActionEvent;
import java.awt.event.AdjustmentEvent;
import java.awt.event.AdjustmentListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionAdapter;
import java.awt.event.MouseMotionListener;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.ResourceBundle;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JScrollBar;
import javax.swing.JScrollPane;
import javax.swing.border.BevelBorder;

public class JFramesView extends JPanel implements ActionMap {

	/**
	 * The resource file name
	 */
	protected static final String RESOURCES = "org.apache.batik.util.gui.resource.resources.JTimeline";

	/**
	 * The resource bundle
	 */
	protected static ResourceBundle bundle;

	/**
	 * The resource manager
	 */
	protected static ResourceManager resources;

	static {
		bundle = ResourceBundle.getBundle(RESOURCES, Locale.getDefault());
		resources = new ResourceManager(bundle);
	}

	/**
	 * The button factory.
	 */
	protected ButtonFactory bf = new ButtonFactory(bundle, this);

	/**
	 * The menu factory.
	 */
	protected MenuFactory mf = new MenuFactory(bundle, this);

	private JTimelineSlider sliderPanel;

	private JPopupMenu cornerPopup;

	private JLabel timerLabel;

	private int precisionMillis = 100;

	private int pixelsPerUnit = 50;

	private float value = 1;

	private int knobPosition;

	private JScrollPane framesScrollPane;
	
	private JScrollBar verticalScrollBar;
	
	public JFramesView() {
		super(new BorderLayout());

		actions.put("CornerButtonAction", new CornerButtonAction());
		actions.put("IncreaseUnitSizeMenuItemAction",
				new IncreaseUnitSizeMenuItemAction());
		actions.put("DecreaseUnitSizeMenuItemAction",
				new DecreaseUnitSizeMenuItemAction());

		sliderPanel = new JTimelineSlider();

		framesScrollPane = new JScrollPane(
				new JTimelineFramesPanel());
		framesScrollPane.setBorder(null);
		framesScrollPane
				.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
		framesScrollPane
				.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_NEVER);
		framesScrollPane.setColumnHeaderView(sliderPanel);

		JButton cornerButton = bf.createJButton("CornerButton");
		cornerButton.setFocusable(false);
		cornerPopup = new JPopupMenu();
		cornerPopup.add(mf.createJMenuItem("IncreaseUnitSizeMenuItem"));
		cornerPopup.add(mf.createJMenuItem("DecreaseUnitSizeMenuItem"));
		framesScrollPane
				.setCorner(JScrollPane.UPPER_RIGHT_CORNER, cornerButton);
		add(framesScrollPane);

		Box footerPanel = new Box(BoxLayout.X_AXIS);
		add(footerPanel, BorderLayout.SOUTH);
		timerLabel = new JLabel("-- : -- : --");
		timerLabel.setBorder(BorderFactory
				.createBevelBorder(BevelBorder.LOWERED));
		footerPanel.add(timerLabel);
		JScrollBar horizScrollBar = new JScrollBar(JScrollBar.HORIZONTAL);
		int prefHeight = horizScrollBar.getPreferredSize().height;
		footerPanel
				.setMaximumSize(new Dimension(Integer.MAX_VALUE, prefHeight));
		footerPanel.setMinimumSize(new Dimension(0, prefHeight));
		footerPanel.setPreferredSize(footerPanel.getMinimumSize());
		footerPanel.add(horizScrollBar);
		footerPanel.add(Box.createHorizontalStrut(framesScrollPane
				.getVerticalScrollBar().getPreferredSize().width));
	}

	public JScrollBar getVerticalScrollBar() {
		return verticalScrollBar;
	}

	public void setVerticalScrollBar(JScrollBar verticalScrollBar) {
		this.verticalScrollBar = verticalScrollBar;
		add(verticalScrollBar, BorderLayout.EAST);
		verticalScrollBar.addAdjustmentListener(new AdjustmentListener() {
			public void adjustmentValueChanged(AdjustmentEvent e) {
				
			}
		});
	}

	/**
	 * The map that contains the actions
	 */
	protected Map actions = new HashMap();

	/**
	 * Returns the action associated with the given string or null on error
	 * 
	 * @param key
	 *            the key mapped with the action to get
	 * @throws MissingListenerException
	 *             if the action is not found
	 */
	public Action getAction(String key) throws MissingListenerException {
		return (Action) actions.get(key);
	}

	protected class CornerButtonAction extends AbstractAction {

		public void actionPerformed(ActionEvent evt) {
			Component invoker = (Component) evt.getSource();
			cornerPopup.show(invoker, 0, invoker.getHeight());
		}
	}

	protected class IncreaseUnitSizeMenuItemAction extends AbstractAction {

		public void actionPerformed(ActionEvent evt) {
			// TODO:
			// Increase unit size in timeline slider
		}
	}

	protected class DecreaseUnitSizeMenuItemAction extends AbstractAction {

		public void actionPerformed(ActionEvent evt) {
			// TODO:
			// Decrease unit size in timeline slider
		}
	}

	public void paint(Graphics g) {
		knobPosition = (int) (value * pixelsPerUnit) + SLIDER_X_OFFSET;

		super.paint(g);
	}

	public static final int SLIDER_X_OFFSET = 10;

	private static final Color SLIDER_KNOB_FILL_COLOR = new Color(0x77FF7777,
			true);

	private static final Color SLIDER_KNOB_STROKE_COLOR = new Color(0x00FF0000);

	private static final Stroke SLIDER_KNOB_STROKE = new BasicStroke(1,
			BasicStroke.CAP_SQUARE, BasicStroke.JOIN_BEVEL, 5.0f,
			new float[] { 5.0f }, 0.0f);

	private class JTimelineSlider extends JComponent {

		private boolean paintTrack = false;

		private Polygon knob;

		private Rectangle knobBounds;

		private boolean over;

		private MouseMotionListener mml = new MouseMotionAdapter() {
			public void mouseMoved(MouseEvent e) {
				int x = e.getX(), y = e.getY();
				boolean b = knobBounds.contains(x, y);
				if (b != b) {
					repaint();
				}
				over = b;
			}

			public void mouseDragged(MouseEvent e) {
				if (over) {
					int x = e.getX();
					if (x >= SLIDER_X_OFFSET) {
						value = (float) (x - SLIDER_X_OFFSET) / pixelsPerUnit;
						JFramesView.this.repaint();
					}
				}
			}
		};

		public JTimelineSlider() {
			int height = 30;

			setMaximumSize(new Dimension(Integer.MAX_VALUE, height));
			setMinimumSize(new Dimension(0, height));
			setPreferredSize(getMinimumSize());
			setBorder(BorderFactory.createBevelBorder(BevelBorder.RAISED));
			addMouseMotionListener(mml);

			int pos = height / 2 - 3;
			knob = new Polygon();
			knob.addPoint(-4, -pos);
			knob.addPoint(4, -pos);
			knob.addPoint(4, pos);
			knob.addPoint(-4, pos);
			knob.addPoint(-4, -pos);

			knobBounds = new Rectangle(6, height);
		}

		protected void paintComponent(Graphics g) {
			super.paintComponent(g);

			Dimension size = getSize();
			if (paintTrack) {
				int pos = size.height / 2;
				g.setColor(Color.gray);
				g.fillRect(0, pos - 1, size.width, 2);
				g.setColor(Color.white);
				g.drawLine(0, pos + 1, size.width, pos + 1);
			}

			int dx = pixelsPerUnit * precisionMillis / 1000;
			FontMetrics fm = g.getFontMetrics();
			int timeUnit = 0;
			for (int i = SLIDER_X_OFFSET; i < size.width; i += pixelsPerUnit) {
				String str = timeUnit++ + "";
				int strWidth = fm.stringWidth(str), strHeight = fm.getHeight()
						- fm.getDescent();
				g.setColor(getBackground());
				g.fillRect(i - strWidth / 2, (size.height - strHeight) / 2,
						strWidth, strHeight);
				g.setColor(Color.black);
				g.drawString(str, i - strWidth / 2,
						(size.height + strHeight) / 2);
				g.setColor(Color.gray);
				g.drawLine(i, size.height - 2, i, size.height - 7);
				g.drawLine(i, 2, i, 7);
				g.setColor(Color.lightGray);
				for (int j = i + dx; j < i + pixelsPerUnit; j += dx) {
					g.drawLine(j, size.height - 2, j, size.height - 5);
					g.drawLine(j, 2, j, 5);
				}
			}

			// Paint knob
			int x = knobPosition;
			int y = size.height / 2;
			knobBounds.x = x - knobBounds.width / 2;
			knobBounds.y = y - knobBounds.height / 2;

			g.translate(x, y);
			g.setColor(SLIDER_KNOB_FILL_COLOR);
			g.fillPolygon(knob);
			g.setColor(SLIDER_KNOB_STROKE_COLOR);
			g.drawPolygon(knob);
			g.translate(-x, -y);
		}
	}

	private class JTimelineFramesPanel extends JPanel {

		private boolean inside;

		private int hoverPosition;
		
		private MouseListener ml = new MouseAdapter() {
			public void mouseEntered(MouseEvent e) {
				inside = true;
				JFramesView.this.repaint();
			}

			public void mouseExited(MouseEvent e) {
				inside = false;
				JFramesView.this.repaint();
			}
		};

		private MouseMotionListener mml = new MouseMotionAdapter() {
			public void mouseMoved(MouseEvent e) {
				int x = e.getX() - SLIDER_X_OFFSET;
				int dx = pixelsPerUnit * precisionMillis / 1000;
				hoverPosition = SLIDER_X_OFFSET + x - x % dx;
				JFramesView.this.repaint();
			}
		};

		public JTimelineFramesPanel() {
			addMouseListener(ml);
			addMouseMotionListener(mml);
		}

		protected void paintComponent(Graphics g) {
			Dimension size = getSize();
			
			int dx = pixelsPerUnit * precisionMillis / 1000;
			g.setColor(Color.lightGray);
			for (int i = SLIDER_X_OFFSET; i < size.width; i += dx) {
				g.drawLine(i, 0, i, size.height);
			}

			g.setColor(SLIDER_KNOB_STROKE_COLOR);
			g.drawLine(knobPosition, 0, knobPosition, size.height);
			
			if (inside) {
				Graphics2D g2 = (Graphics2D)g;
				g2.setStroke(SLIDER_KNOB_STROKE);
				
				g2.drawLine(hoverPosition, 0, hoverPosition, size.height);
			}
		}
	}
}




import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JRadioButton;
import javax.swing.JToggleButton;

/**
 * This class represents a button factory which builds

    }

    /**
     * Creates and returns a new swing button initialised
     * to be used as a toolbar toggle button
     * @param name the name of the button in the resource bundle
     * @throws MissingResourceException if key is not the name of a button.
     *         It is not thrown if the mnemonic and the action keys are missing
     * @throws ResourceFormatException if the mnemonic is not a single
     *         character
     * @throws MissingListenerException if the button action is not found in
     *         the action map
     */
    public JToggleButton createJToolbarToggleButton(String name)
        throws MissingResourceException,
               ResourceFormatException,
               MissingListenerException {
        JToggleButton result;
        try {
            result = new JToolbarToggleButton(getString(name+TEXT_SUFFIX));
        } catch (MissingResourceException e) {
            result = new JToolbarToggleButton();
        }
        initializeButton(result, name);
        return result;
    }

    /**
     * Creates and returns a new swing radio button
     * @param name the name of the button in the resource bundle
     * @throws MissingResourceException if key is not the name of a button.




package org.apache.batik.util.gui.resource;

import java.awt.Cursor;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

import javax.swing.JLabel;

public class Hyperlink extends JLabel {
	private MouseListener ml = new MouseAdapter() {
		public void mouseClicked(MouseEvent e) {
			if (callback != null) {
				callback.linkClicked(new HyperlinkEvent(Hyperlink.this.getCommand()));
			}
		}
	};
	
	private HyperlinkCallback callback;
	
	private String command;
	
	private static final String HTML_TEXT = "<html><font color=\"blue\"><u>__HTML_TEXT__</u></font></html>";
	
	private String text;
	
	public Hyperlink(String text, HyperlinkCallback callback) {
		this.callback = callback;
		setLinkText(text);
		setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
		addMouseListener(ml);
	}

	public String getLinkText() {
		return text;
	}
	
	public void setLinkText(String text) {
		this.text = text;
		super.setText(HTML_TEXT.replace("__HTML_TEXT__", text));
	}

	public String getCommand() {
		return command;
	}

	public void setCommand(String command) {
		this.command = command;
	}

	public static class HyperlinkEvent {
		
		private String command;
		
		public HyperlinkEvent(String command) {
			this.command = command;
		}

		public String getCommand() {
			return command;
		}

		public void setCommand(String command) {
			this.command = command;
		}
	}
	
	public static interface HyperlinkCallback {
		public void linkClicked(HyperlinkEvent e);
	}
}


Lines 23-28 Link Here

(-)sources/org/apache/batik/util/gui/resource/JToolbarButton.java (-1 / +9 lines)
23	import java.awt.event.MouseEvent;	23	import java.awt.event.MouseEvent;
24		24
25	import javax.swing.JButton;	25	import javax.swing.JButton;
		26	import javax.swing.UIManager;
26		27
27	/**	28	/**
28	* This class represents the buttons used in toolbars.	29	* This class represents the buttons used in toolbars.
Lines 57-63 Link Here
57	}	58	}
58	setBorderPainted(false);	59	setBorderPainted(false);
59	setMargin(new Insets(2, 2, 2, 2));	60	setMargin(new Insets(2, 2, 2, 2));
60	addMouseListener(new MouseListener());	61
		62	// Windows XP look and feel seems to have a bug due to which the
		63	// size of the parent container changes when the border painted
		64	// property is set. Temporary fix: disable mouseover behavior if
		65	// installed lnf is Windows XP
		66	if (!UIManager.getLookAndFeel().getName().equals("Windows")) {
		67	addMouseListener(new MouseListener());
		68	}
61	}	69	}
62		70
63	/**	71	/**




package org.apache.batik.util.gui.resource;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Paint;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.Locale;
import java.util.ResourceBundle;

import javax.swing.BorderFactory;
import javax.swing.DefaultListModel;
import javax.swing.ImageIcon;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.JScrollBar;
import javax.swing.JScrollPane;
import javax.swing.ListCellRenderer;

import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class JDocumentTree extends JPanel {

	/**
	 * The resource file name
	 */
	protected static final String RESOURCES = "org.apache.batik.util.gui.resource.resources.JDocumentTree";

	/**
	 * The resource bundle
	 */
	protected static ResourceBundle bundle;

	/**
	 * The resource manager
	 */
	protected static ResourceManager resources;

	static {
		bundle = ResourceBundle.getBundle(RESOURCES, Locale.getDefault());
		resources = new ResourceManager(bundle);
	}

	private JList nodeList;

	private JScrollPane nodeListScrollPane;

	private DocumentTreeNode rootNode;

	public JDocumentTree() {
		this(null);
	}

	public JDocumentTree(Document document) {
		super(new BorderLayout());

		nodeList = new JList(new DefaultListModel()) {
			public String getToolTipText(MouseEvent e) {
		        int index = locationToIndex(e.getPoint());
		        if (index >= 0) {
		          DocumentTreeNode docTreeNode = (DocumentTreeNode)getModel().getElementAt(index);
		          return docTreeNode.getToolTipText();
		        } else {
		          return null;
		        }
			}
		};
		nodeList.setFixedCellHeight(25);
		nodeList.setCellRenderer(new DocTreeCellRenderer());
		nodeListScrollPane = new JScrollPane(nodeList);
		nodeListScrollPane
				.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_NEVER);
		nodeListScrollPane.setBorder(null);
		add(nodeListScrollPane);

		nodeList.addMouseListener(new MouseAdapter() {
			public void mouseClicked(MouseEvent e) {
				if (e.getClickCount() == 2) {
					DocumentTreeNode selectedNode = (DocumentTreeNode) nodeList
							.getSelectedValue();
					selectedNode.setExpanded(!selectedNode.isExpanded());
					rebuildNodeList(nodeList, rootNode);
				}
			}
		});
		
		setDocument(document);
	}

	public void setDocument(Document document) {
		if (document == null) {
			DefaultListModel model = (DefaultListModel)nodeList.getModel();
			model.removeAllElements();
		} else {
			Node root = document.getDocumentElement();
			rootNode = parse(root, null);
			rebuildNodeList(nodeList, rootNode);
		}
	}

	public JScrollBar getVerticalScrollBar() {
		return nodeListScrollPane.getVerticalScrollBar();
	}

	public void setVerticalScrollBar(JScrollBar verticalScrollBar) {
		nodeListScrollPane.setVerticalScrollBar(verticalScrollBar);
	}

	private void rebuildNodeList(JList nodeList, DocumentTreeNode node) {
		DefaultListModel listModel = (DefaultListModel) nodeList.getModel();
		listModel.clear();
		addNode(listModel, node);
	}

	private void addNode(DefaultListModel listModel, DocumentTreeNode node) {
		DocumentTreeNode parent = node.getParent();
		if (parent == null || parent.isExpanded()) {
			listModel.addElement(node);
			DocumentTreeNode[] children = node.getChildren();
			if (children != null) {
				for (int i = 0; i < children.length; i++) {
					addNode(listModel, children[i]);
				}
			}
		}
	}

	private DocumentTreeNode parse(Node node, DocumentTreeNode parent) {
		if (node == null) {
			return null;
		}
		ArrayList childDocNodes = null;
		DocumentTreeNode docNode = new DocumentTreeNode(parent, node
				.getNodeName(), node.getNodeValue(), Node.ELEMENT_NODE);
		NamedNodeMap attrMap = node.getAttributes();
		for (int i = 0; i < attrMap.getLength(); i++) {
			Node item = attrMap.item(i);
			int type = item.getNodeType();
			if (type == Node.ATTRIBUTE_NODE) {
				if (childDocNodes == null) {
					childDocNodes = new ArrayList();
				}
				DocumentTreeNode attrNode = new DocumentTreeNode(docNode, item.getNodeName(), item.getNodeValue(), Node.ATTRIBUTE_NODE);
				childDocNodes.add(attrNode);
			}
		}
		NodeList childNodes = node.getChildNodes();
		for (int i = 0; i < childNodes.getLength(); i++) {
			Node item = childNodes.item(i);
			int type = item.getNodeType();
			if (type == Node.ELEMENT_NODE) {
				if (childDocNodes == null) {
					childDocNodes = new ArrayList();
				}
				DocumentTreeNode childDocNode = parse(item, docNode);
				if (childDocNode != null) {
					childDocNodes.add(childDocNode);
				}
			}
		}
		if (childDocNodes != null) {
			docNode.setChildren((DocumentTreeNode[]) childDocNodes
					.toArray(new DocumentTreeNode[0]));
		}

		return docNode;
	}

	private class DocumentTreeNode {

		private String text;

		private String toolTipText;
		
		private DocumentTreeNode parent;

		private int type;

		private int depth;

		private DocumentTreeNode[] children;

		private boolean expanded = true;

		private boolean locked = false;

		public DocumentTreeNode(DocumentTreeNode parent, String name, String value, int type) {
			this.parent = parent;
			this.type = type;
			this.depth = parent == null ? 0 : parent.depth + 1;
			this.setText(name);
			this.setToolTipText(value);
		}

		public DocumentTreeNode getParent() {
			return parent;
		}

		public int getDepth() {
			return depth;
		}

		public DocumentTreeNode[] getChildren() {
			return children;
		}

		public int getChildCount() {
			return children == null ? 0 : children.length;
		}

		public void setChildren(DocumentTreeNode[] children) {
			this.children = children;
			if (children != null) {
				for (int i = 0; i < children.length; i++) {
					children[i].parent = this;
				}
			}
		}

		public boolean isExpanded() {
			if (parent == null) {
				return true;
			}
			if (!expanded) {
				return false;
			}
			return parent.isExpanded();
		}

		public void setExpanded(boolean expanded) {
			this.expanded = expanded;
		}

		public String getText() {
			return text;
		}

		public void setText(String text) {
			this.text = text;
		}

		public int getType() {
			return type;
		}

		public void setType(int type) {
			this.type = type;
		}

		public String getToolTipText() {
			return toolTipText;
		}

		public void setToolTipText(String toolTipText) {
			this.toolTipText = toolTipText;
		}
	}

	private class DocTreeCellRenderer extends JLabel implements
			ListCellRenderer {

		private class PaintAttributes {
			public Paint paint, paintHighlight;

			public Color colorText, colorHighlightText;
		}

		private final ImageIcon SPACER_ICON = getIcon("TreeNodeSpacer.icon");

		private final ImageIcon CLOSED_ICON = getIcon("TreeNodeClosed.icon");

		private final ImageIcon OPENED_ICON = getIcon("TreeNodeOpened.icon");

		private final ImageIcon LEAF_ICON = getIcon("TreeLeaf.icon");

		private final ImageIcon LOCK_ICON = getIcon("TreeNodeLocked.icon");

		private PaintAttributes elementPaint;

		private PaintAttributes attributePaint;

		private boolean selected;

		private int type;

		private boolean locked = true;

		public DocTreeCellRenderer() {
			setIcon(SPACER_ICON);

			Dimension dim = getPreferredSize();
			elementPaint = new PaintAttributes();
			elementPaint.paint = new Color(234, 234, 234);
			elementPaint.paintHighlight = new GradientPaint(0, 0, Color.gray,
					0, 2 * dim.height, Color.white);
			elementPaint.colorText = Color.black;
			elementPaint.colorHighlightText = Color.white;

			attributePaint = new PaintAttributes();
			attributePaint.paint = new Color(216, 216, 216);
			attributePaint.paintHighlight = new GradientPaint(0, 0,
					Color.darkGray, 0, 2 * dim.height, Color.lightGray);
			attributePaint.colorText = Color.black;
			attributePaint.colorHighlightText = Color.white;
		}

		private ImageIcon getIcon(String name) {
			return new ImageIcon(JDocumentTree.this.getClass().getResource(
					resources.getString(name)));
		}

		protected void paintComponent(Graphics g) {
			Dimension size = getSize();
			Graphics2D g2 = (Graphics2D) g;
			PaintAttributes paintAttributes;
			switch (type) {
			case Node.ATTRIBUTE_NODE:
				paintAttributes = attributePaint;
				break;
			case Node.ELEMENT_NODE:
			default:
				paintAttributes = elementPaint;
				break;
			}
			g2.setPaint(selected ? paintAttributes.paintHighlight : paintAttributes.paint);
			g2.fillRect(0, 0, size.width, size.height);

			g2.setColor(Color.lightGray);
			g2.drawLine(0, size.height - 2, size.width, size.height - 2);
			g2.setColor(Color.white);
			g2.drawLine(0, size.height - 1, size.width, size.height - 1);

			setForeground(selected ? paintAttributes.colorHighlightText : paintAttributes.colorText);
			super.paintComponent(g);

			g.setColor(Color.white);
			int x, y;
			x = size.width - 18;
			y = (size.height - 16) / 2;
			g.draw3DRect(x, y, 16, 16, false);
			if (locked) {
				LOCK_ICON.paintIcon(this, g, x, y);
			}
		}

		public Component getListCellRendererComponent(JList list, Object value,
				int index, boolean selected, boolean cellHasFocus) {
			DocumentTreeNode node = (DocumentTreeNode) value;
			this.selected = selected;
			this.type = node.getType();
			setText(node.getText());
			setBorder(BorderFactory.createEmptyBorder(0, node.depth * 10, 0, 0));
			if (node.getChildren() == null || node.getChildCount() == 0) {// leaf
				setIcon(LEAF_ICON);
			} else if (node.isExpanded()) {
				setIcon(OPENED_ICON);
			} else {
				setIcon(CLOSED_ICON);
			}

			return this;
		}
	}
}




/*

   Licensed to the Apache Software Foundation (ASF) under one or more
   contributor license agreements.  See the NOTICE file distributed with
   this work for additional information regarding copyright ownership.
   The ASF licenses this file to You under the Apache License, Version 2.0
   (the "License"); you may not use this file except in compliance with
   the License.  You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.

 */
package org.apache.batik.util.gui.resource;

import java.awt.Insets;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import javax.swing.JToggleButton;
import javax.swing.UIManager;

import org.apache.batik.util.gui.resource.JToolbarButton.MouseListener;

/**
 * This class represents the buttons used in toolbars.
 *
 * @author <a href="mailto:stephane@hillion.org">Stephane Hillion</a>
 * @version $Id: JToolbarButton.java 498555 2007-01-22 08:09:33Z cam $
 */
public class JToolbarToggleButton extends JToggleButton {
    /**
     * Creates a new toolbar button.
     */
    public JToolbarToggleButton() {
        initialize();
    }

    /**
     * Creates a new toolbar button.
     * @param txt The button text.
     */
    public JToolbarToggleButton(String txt) {
        super(txt);
        initialize();
    }

    /**
     * Initializes the button.
     */
    protected void initialize() {
        if (!System.getProperty("java.version").startsWith("1.3")) {
            setOpaque(false);
            setBackground(new java.awt.Color(0, 0, 0, 0));
        }
        setBorderPainted(false);
        setMargin(new Insets(2, 2, 2, 2));

        // Windows XP look and feel seems to have a bug due to which the
        // size of the parent container changes when the border painted
        // property is set. Temporary fix: disable mouseover behavior if
        // installed lnf is Windows XP
        if (!UIManager.getLookAndFeel().getName().equals("Windows")) {
	        addMouseListener(new MouseListener());
        }
    }

    /**
     * To manage the mouse interactions.
     */
    protected class MouseListener extends MouseAdapter {
        public void mouseEntered(MouseEvent ev) {
            setBorderPainted(true);
        }
        public void mouseExited(MouseEvent ev) {
            setBorderPainted(false);
        }
    }
}




package org.apache.batik.util.gui;

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.io.File;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.ResourceBundle;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollBar;
import javax.swing.JSeparator;
import javax.swing.JSplitPane;
import javax.swing.JToolBar;

import org.apache.batik.dom.svg.SAXSVGDocumentFactory;
import org.apache.batik.util.gui.resource.ActionMap;
import org.apache.batik.util.gui.resource.JDocumentTree;
import org.apache.batik.util.gui.resource.JFramesView;
import org.apache.batik.util.gui.resource.MissingListenerException;
import org.apache.batik.util.gui.resource.ResourceManager;
import org.apache.batik.util.gui.resource.ToolBarFactory;
import org.w3c.dom.Document;
import org.w3c.dom.svg.SVGDocument;

public class TimelineViewer extends JFrame implements ActionMap {

	/**
	 * The resource file name
	 */
	protected static final String RESOURCES = "org.apache.batik.util.gui.resources.TimelineViewer";

	/**
	 * The resource bundle
	 */
	protected static ResourceBundle bundle;

	/**
	 * The resource manager
	 */
	protected static ResourceManager resources;

	static {
		bundle = ResourceBundle.getBundle(RESOURCES, Locale.getDefault());
		resources = new ResourceManager(bundle);
	}

	/**
	 * The toolbar factory.
	 */
	protected ToolBarFactory tf = new ToolBarFactory(bundle, this);

	private Document document;

	private JDocumentTree docTree;
	
	public TimelineViewer() {
		this(null);
	}

	public TimelineViewer(Document document) {
		super("Timeline Viewer");
		
		Container contentPane = getContentPane();
		contentPane.setPreferredSize(new Dimension(800, 300));

		JSplitPane splitPane = new JSplitPane();
		splitPane.setResizeWeight(0.0);
		JPanel leftPane = new JPanel();
		splitPane.setLeftComponent(leftPane);

		leftPane.setLayout(new BorderLayout());
		leftPane.setMinimumSize(new Dimension(300, 0));
		leftPane.setPreferredSize(getMinimumSize());
		leftPane.add(createToolBar(), BorderLayout.NORTH);

		JScrollBar scrollBar = new JScrollBar(JScrollBar.VERTICAL, 0, 1, 0, 100);
		docTree = new JDocumentTree(document);
		docTree.setVerticalScrollBar(scrollBar);
		leftPane.add(docTree);

		JFramesView framesView = new JFramesView();
		framesView.setVerticalScrollBar(scrollBar);
		splitPane.setRightComponent(framesView);
		contentPane.add(splitPane);
		
		pack();
	}
	
	private JPanel createToolBar() {
		JPanel toolbarPanel = new JPanel(new BorderLayout());
		JToolBar toolbar = tf.createJToolBar("ToolBar");
		toolbar.setFloatable(false);

		toolbarPanel.add(toolbar);
		toolbarPanel.add(new JSeparator(), BorderLayout.SOUTH);

		return toolbarPanel;
	}

    /**
     * Sets the document to display.
     */
    public void setDocument(Document doc) {
        document = doc;
        docTree.setDocument(document);
    }

	
	/**
	 * The map that contains the actions
	 */
	protected Map actions = new HashMap();

	/**
	 * Returns the action associated with the given string or null on error
	 * 
	 * @param key
	 *            the key mapped with the action to get
	 * @throws MissingListenerException
	 *             if the action is not found
	 */
	public Action getAction(String key) throws MissingListenerException {
		return (Action) actions.get(key);
	}

	/**
	 * The action associated with the 'All' button.
	 */
	protected class DisplayAllButtonAction extends AbstractAction {

		public void actionPerformed(ActionEvent evt) {
		}
	}

	public static void main(String[] args) throws Exception {
		File file = new File(System.getProperty("user.home")
				+ "/Desktop/batikws/xml-batik/rect.svg");
		SAXSVGDocumentFactory f = new SAXSVGDocumentFactory(null, true);
		SVGDocument doc = (SVGDocument) f.createDocument(file.toURL()
				.toString());
		
		JFrame tv = new TimelineViewer(doc);
		tv.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
		tv.setVisible(true);
	}

//	private class DocTreeCellRenderer extends Box implements
//			TreeCellRenderer {
//
//		private final ImageIcon SPACER_ICON = getIcon("TreeNodeSpacer.icon");
//
//		private final ImageIcon CLOSED_ICON = getIcon("TreeNodeClosed.icon");
//
//		private final ImageIcon OPENED_ICON = getIcon("TreeNodeOpened.icon");
//
//		private final ImageIcon LEAF_ICON = getIcon("TreeLeaf.icon");
//
//		private Paint gradient;
//
//		private JLabel label;
//
//		private JLabel icon;
//
//		public DocTreeCellRenderer() {
//			super(BoxLayout.X_AXIS);
//			setOpaque(false);
//
//			icon = new JLabel(SPACER_ICON);
//			add(icon);
//
//			label = new JLabel();
//			add(label);
//			
//			Dimension dim = getPreferredSize();
//			gradient = new GradientPaint(0, 0, Color.white, 0,
//					2 * dim.height, Color.gray);
//		}
//
//		public void setBounds(int x, int y, int width, int height) {
//			super.setBounds(x, y, docTree.getWidth(), height);
//			System.out.println(getBounds());
//		}
//		
//		private ImageIcon getIcon(String name) {
//			String uri = resources.getString(name);
//			System.out.println(uri);
//			return new ImageIcon(TimelineViewer.this.getClass().getResource(
//					uri));
//		}
//
//		protected void paintComponent(Graphics g) {
//			Graphics2D g2 = (Graphics2D) g;
//			g2.setPaint(gradient);
//			g2.fillRect(0, 0, getWidth(), getHeight());
//
//			super.paintComponent(g);
//		}
//
//		public Component getTreeCellRendererComponent(JTree tree, Object value,
//				boolean selected, boolean expanded, boolean leaf, int row,
//				boolean hasFocus) {
//			label.setText(value.toString());
//
//			if (leaf) {
//				icon.setIcon(LEAF_ICON);
//			} else if (expanded) {
//				icon.setIcon(OPENED_ICON);
//			} else {
//				icon.setIcon(CLOSED_ICON);
//			}
//			return this;
//		}
//	}
}




package org.apache.batik.util.gui;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.Frame;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.SystemColor;
import java.awt.Toolkit;
import java.awt.datatransfer.Clipboard;
import java.awt.datatransfer.StringSelection;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.Timer;
import java.util.TimerTask;

import javax.imageio.ImageIO;
import javax.swing.AbstractAction;
import javax.swing.AbstractButton;
import javax.swing.Action;
import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.ButtonGroup;
import javax.swing.ButtonModel;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JScrollBar;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextPane;
import javax.swing.JToggleButton;
import javax.swing.JToolBar;
import javax.swing.SwingConstants;
import javax.swing.text.BadLocationException;
import javax.swing.text.DefaultHighlighter;
import javax.swing.text.Highlighter;

import org.apache.batik.apps.svgbrowser.JSVGViewerFrame.DOMViewerAction;
import org.apache.batik.apps.svgbrowser.JSVGViewerFrame.ViewSourceAction;
import org.apache.batik.apps.svgbrowser.srcview.SourceViewFrame;
import org.apache.batik.dom.AbstractDocument;
import org.apache.batik.dom.svg.LiveAttributeException;
import org.apache.batik.dom.svg.SAXSVGDocumentFactory;
import org.apache.batik.dom.util.DocumentDescriptor;
import org.apache.batik.util.gui.resource.ActionMap;
import org.apache.batik.util.gui.resource.ButtonFactory;
import org.apache.batik.util.gui.resource.JToolbarSeparator;
import org.apache.batik.util.gui.resource.MenuFactory;
import org.apache.batik.util.gui.resource.MissingListenerException;
import org.apache.batik.util.gui.resource.ResourceManager;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.svg.SVGDocument;

public class ErrorConsole implements ActionMap {

	public static class ErrorInfo {
		public Throwable throwable;

		public String uri;

		public int type;

		public ErrorInfo(Throwable throwable, String uri, int type) {
			this.throwable = throwable;
			this.uri = uri;
			this.type = type;
		}
	}

	public static class AttributeErrorInfo extends ErrorInfo {
		public InputStream inputStream;

		public Element element;

		public DocumentDescriptor docDescriptor;

		public ViewSourceAction viewSourceAction;

		public DOMViewerAction viewDOMAction;

		public AttributeErrorInfo(LiveAttributeException lex, String uri,
				int type, InputStream inputStream, Element element,
				DocumentDescriptor docDescriptor) {
			this(lex, uri, type, inputStream, element, docDescriptor, null,
					null);
		}

		public AttributeErrorInfo(LiveAttributeException lex, String uri,
				int type, InputStream inputStream, Element element,
				DocumentDescriptor docDescriptor,
				ViewSourceAction viewSourceAction, DOMViewerAction viewDOMAction) {
			super(lex, uri, type);
			this.inputStream = inputStream;
			this.element = element;
			this.docDescriptor = docDescriptor;
			this.viewSourceAction = viewSourceAction;
			this.viewDOMAction = viewDOMAction;
		}
	}

	public static final int ALL = -1, ERROR = 1, WARNING = 2, INFORMATION = 4;

	/**
	 * The resource file name
	 */
	protected static final String RESOURCES = "org.apache.batik.util.gui.resources.ErrorConsole";

	/**
	 * The resource bundle
	 */
	protected static ResourceBundle bundle;

	/**
	 * The resource manager
	 */
	protected static ResourceManager resources;

	static {
		bundle = ResourceBundle.getBundle(RESOURCES, Locale.getDefault());
		resources = new ResourceManager(bundle);
	}

	/**
	 * The button factory.
	 */
	protected ButtonFactory bf = new ButtonFactory(bundle, this);

	/**
	 * The menu factory.
	 */
	protected MenuFactory mf = new MenuFactory(bundle, this);

	private Box consoleList;

	private ButtonGroup errorGroup;

	private int displayType;

	private boolean sortOrderAscending = true;

	private JPopupMenu popupMenu;

	private Container contentPane;

	public ErrorConsole() {
		actions.put("DisplayAllButtonAction", new DisplayAllButtonAction());
		actions.put("DisplayErrorsButtonAction",
				new DisplayErrorsButtonAction());
		actions.put("DisplayWarningsButtonAction",
				new DisplayWarningsButtonAction());
		actions.put("DisplayMessagesButtonAction",
				new DisplayMessagesButtonAction());
		actions.put("ClearButtonAction", new ClearButtonAction());

		actions.put("FirstLastSortMenuAction", new FirstLastSortMenuAction());
		actions.put("LastFirstSortMenuAction", new LastFirstSortMenuAction());
		actions.put("CopyMenuAction", new CopyMenuAction());

		contentPane = new JPanel(new BorderLayout());

		JPanel errorPanel = new JPanel(new BorderLayout());
		errorPanel.setBackground(Color.white);

		JScrollPane errorScrollPane = new JScrollPane(errorPanel);
		errorScrollPane
				.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
		contentPane.add(errorScrollPane);

		errorGroup = new ButtonGroup();

		consoleList = new Box(BoxLayout.Y_AXIS);
		errorPanel.add(consoleList, BorderLayout.NORTH);

		popupMenu = createPopupMenu();

		contentPane.add(createToolBar(), BorderLayout.NORTH);
		contentPane.setPreferredSize(new Dimension(550, 400));
	}

	private JToolBar createToolBar() {
		JToolBar toolbar = new JToolBar();
		toolbar.setFloatable(false);

		BooleanButtonGroup displayGroup = new BooleanButtonGroup();

		JToggleButton displayAll = bf
				.createJToolbarToggleButton("DisplayAllButton");
		displayGroup.add(displayAll);
		displayAll.setSelected(true);
		displayType(ALL, true);
		toolbar.add(displayAll);

		JToggleButton displayErrors = bf
				.createJToolbarToggleButton("DisplayErrorsButton");
		displayGroup.addOr(displayErrors);
		toolbar.add(displayErrors);

		JToggleButton displayWarnings = bf
				.createJToolbarToggleButton("DisplayWarningsButton");
		displayGroup.addOr(displayWarnings);
		toolbar.add(displayWarnings);

		JToggleButton displayMessages = bf
				.createJToolbarToggleButton("DisplayMessagesButton");
		displayGroup.addOr(displayMessages);
		toolbar.add(displayMessages);

		toolbar.add(new JToolbarSeparator());

		JButton clear = bf.createJToolbarButton("ClearButton");
		displayGroup.add(clear);
		toolbar.add(clear);

		return toolbar;
	}

	private class BooleanButtonGroup extends ButtonGroup implements
			ItemListener {

		private List orElements = new ArrayList();

		private AbstractButton orButton = new JToggleButton();

		public BooleanButtonGroup() {
			orButton.addItemListener(this);
			add(orButton);
		}

		public void itemStateChanged(ItemEvent e) {
			if (e.getStateChange() == ItemEvent.DESELECTED) {
				if (e.getSource() == orButton) {
					for (Iterator i = orElements.iterator(); i.hasNext();) {
						AbstractButton button = (AbstractButton) i.next();
						button.setSelected(false);
					}
				} else if (orButton.isSelected()) {
					boolean selected = false;
					for (Iterator i = orElements.iterator(); i.hasNext();) {
						AbstractButton button = (AbstractButton) i.next();
						if (button.isSelected()) {
							selected = true;
							break;
						}
					}
					if (!selected) {
						((AbstractButton) e.getSource()).setSelected(true);
					}
				}
			} else if (e.getStateChange() == ItemEvent.SELECTED) {
				setSelected(((AbstractButton) e.getSource()).getModel(), true);
			}
		}

		public void addOr(AbstractButton button) {
			orElements.add(button);
			button.addItemListener(this);
		}

		public void setSelected(ButtonModel model, boolean selected) {
			for (Iterator i = orElements.iterator(); i.hasNext();) {
				AbstractButton button = (AbstractButton) i.next();
				if (button.getModel() == model) {
					orButton.setSelected(selected);
					return;
				}
			}
			super.setSelected(model, selected);
		}
	}

	private JPopupMenu createPopupMenu() {
		JPopupMenu popupMenu = mf.createJMenu("PopupMenu").getPopupMenu();
		return popupMenu;
	}

	protected static ErrorConsole instance;

	public static ErrorConsole getInstance() {
		if (instance == null) {
			instance = new ErrorConsole();
		}
		return instance;
	}

	protected static JDialog dialog;

	public static void showDialog(Component owner) {
		Frame f = JOptionPane.getFrameForComponent(owner);
		if (dialog != null && dialog.getOwner() != f) {
			dialog.dispose();
			dialog = null;
		}
		if (dialog == null) {
			dialog = new JDialog(f, "Error Console");
			dialog.getContentPane().add(getInstance().contentPane,
					BorderLayout.CENTER);

			dialog.pack();
			dialog.setDefaultCloseOperation(JDialog.HIDE_ON_CLOSE);
			dialog.setLocationRelativeTo(dialog.getOwner());
		}
		dialog.setVisible(true);
	}

	public void add(ErrorInfo info) {
		ErrorButton errorButton = new ErrorButton(info);
		errorButton.setPopupMenu(popupMenu);
		consoleList.add(errorButton);
		errorGroup.add(errorButton);
		errorButton.setVisible((displayType & errorButton.getType()) > 0);
	}

	public void add(AttributeErrorInfo info) {
		ErrorButton errorButton = new ErrorButton(info);
		errorButton.setPopupMenu(popupMenu);
		consoleList.add(errorButton);
		errorGroup.add(errorButton);
		errorButton.setVisible((displayType & errorButton.getType()) > 0);
	}

	/**
	 * The map that contains the actions
	 */
	protected Map actions = new HashMap();

	/**
	 * Returns the action associated with the given string or null on error
	 * 
	 * @param key
	 *            the key mapped with the action to get
	 * @throws MissingListenerException
	 *             if the action is not found
	 */
	public Action getAction(String key) throws MissingListenerException {
		return (Action) actions.get(key);
	}

	/**
	 * The action associated with the 'All' button.
	 */
	protected class DisplayAllButtonAction extends AbstractAction {

		public void actionPerformed(ActionEvent evt) {
			displayType(ALL, true);
		}
	}

	/**
	 * The action associated with the 'Errors' button.
	 */
	protected class DisplayErrorsButtonAction extends AbstractAction {

		public void actionPerformed(ActionEvent evt) {
			boolean selected = ((AbstractButton) evt.getSource()).isSelected();
			displayType(ERROR, selected);
		}
	}

	/**
	 * The action associated with the 'Warnings' button.
	 */
	protected class DisplayWarningsButtonAction extends AbstractAction {

		public void actionPerformed(ActionEvent evt) {
			boolean selected = ((AbstractButton) evt.getSource()).isSelected();
			displayType(WARNING, selected);
		}
	}

	/**
	 * The action associated with the 'Messages' button.
	 */
	protected class DisplayMessagesButtonAction extends AbstractAction {

		public void actionPerformed(ActionEvent evt) {
			boolean selected = ((AbstractButton) evt.getSource()).isSelected();
			displayType(INFORMATION, selected);
		}
	}

	/**
	 * The action associated with the 'Clear' button.
	 */
	protected class ClearButtonAction extends AbstractAction {

		public void actionPerformed(ActionEvent evt) {
			clearType(displayType);
			consoleList.revalidate();
		}
	}

	/**
	 * The action associated with the 'First to Last Sort' menu item.
	 */
	protected class FirstLastSortMenuAction extends AbstractAction {

		public void actionPerformed(ActionEvent evt) {
			if (sortOrderAscending) {
				return;
			}
			reverseComponentOrder(consoleList);
			sortOrderAscending = true;
		}
	}

	/**
	 * The action associated with the 'Last to First Sort' menu item.
	 */
	protected class LastFirstSortMenuAction extends AbstractAction {

		public void actionPerformed(ActionEvent evt) {
			if (!sortOrderAscending) {
				return;
			}
			reverseComponentOrder(consoleList);
			sortOrderAscending = false;
		}
	}

	private void reverseComponentOrder(Container container) {
		Component[] components = container.getComponents();
		consoleList.removeAll();
		for (int i = components.length - 1; i >= 0; i--) {
			consoleList.add(components[i]);
		}
		consoleList.revalidate();
	}

	/**
	 * The action associated with the 'Copy' menu item.
	 */
	protected class CopyMenuAction extends AbstractAction {

		public void actionPerformed(ActionEvent evt) {
			Component[] components = consoleList.getComponents();
			StringBuilder copyText = new StringBuilder();
			for (int i = 0; i < components.length; i++) {
				ErrorButton eb = (ErrorButton) components[i];
				if (eb.isSelected()) {
					copyText.append(eb.getMessageText() + "\n");
					copyText.append(eb.getDetailText() + "\n\n");
				}
			}
			String s = copyText.toString().trim();
			if (!s.equals("")) {
				Clipboard clipboard = Toolkit.getDefaultToolkit()
						.getSystemClipboard();
				clipboard.setContents(new StringSelection(s), null);
			}
		}
	}

	private void clearType(int type) {
		Component[] components = consoleList.getComponents();
		for (int i = 0; i < components.length; i++) {
			ErrorButton eb = (ErrorButton) components[i];
			if ((eb.getType() & type) > 0) {
				consoleList.remove(eb);
				errorGroup.remove(eb);
			}
		}
	}

	private void displayType(int type, boolean visible) {
		if (displayType < 0) {
			displayType = 0;
		}
		if (visible) {
			displayType |= type;
		} else {
			displayType &= ~type;
		}
		Component[] components = consoleList.getComponents();
		for (int i = 0; i < components.length; i++) {
			ErrorButton eb = (ErrorButton) components[i];
			eb.setVisible((displayType & eb.getType()) > 0);
		}
	}

	private class ErrorButton extends JToggleButton {

		private int type;

		private JTextPane messageText;

		private ImageIcon icon;

		private GradientPaint gradient;

		private JPanel details;

		private JPopupMenu popupMenu;

		private JScrollPane detailScrollPane;

		private JTextArea detailText;

		private Throbber throbber;

		private Box actionsPanel;

		private ItemListener il = new ItemListener() {
			public void itemStateChanged(ItemEvent e) {
				if (e.getStateChange() == ItemEvent.SELECTED) {
					details.setVisible(true);
				} else if (e.getStateChange() == ItemEvent.DESELECTED) {
					details.setVisible(false);
				} else {
					return;
				}
				repaint();
			}
		};

		private MouseListener ml = new MouseAdapter() {
			public void mousePressed(MouseEvent e) {
				if (e.isPopupTrigger()) {
					popupMenu.show(ErrorButton.this, e.getX(), e.getY());
				}
			}

			public void mouseReleased(MouseEvent e) {
				if (e.isPopupTrigger()) {
					popupMenu.show(ErrorButton.this, e.getX(), e.getY());
				}
			}
		};

		protected ErrorButton(int type) {
			this.type = type;

			setLayout(new BorderLayout(10, 10));
			setContentAreaFilled(false);
			setBorderPainted(false);
			setOpaque(false);
			setFocusPainted(false);
			setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
			addItemListener(il);
			addMouseListener(ml);

			String s;
			switch (type) {
			case WARNING:
				s = resources.getString("ErrorButton.warning_icon");
				break;
			case INFORMATION:
				s = resources.getString("ErrorButton.message_icon");
				break;
			case ERROR:
			default:
				s = resources.getString("ErrorButton.error_icon");
				break;
			}
			icon = new ImageIcon(getClass().getResource(s));
			add(new JLabel(icon), BorderLayout.WEST);

			Box centerPane = new Box(BoxLayout.Y_AXIS);
			add(centerPane);

			messageText = new JTextPane();
			messageText.setEditable(false);
			messageText.setOpaque(false);
			messageText.addMouseListener(new MouseAdapter() {
				public void mouseClicked(MouseEvent e) {
					passEvent(e);
				}

				public void mousePressed(MouseEvent e) {
					passEvent(e);
				}

				public void mouseReleased(MouseEvent e) {
					passEvent(e);
				}

				private void passEvent(MouseEvent e) {
					e.setSource(ErrorButton.this);
					ErrorButton.this.dispatchEvent(e);
				}
			});
			centerPane.add(messageText, BorderLayout.NORTH);

			details = new JPanel(new BorderLayout());
			details.setOpaque(false);
			details.setVisible(false);
			add(details, BorderLayout.SOUTH);

			detailText = new JTextArea();
			detailText.setFont(new Font("Monospaced", Font.PLAIN, 12));
			detailText.setEditable(false);
			detailText.setLineWrap(true);
			throbber = new Throbber();
			detailScrollPane = new JScrollPane();
			detailScrollPane.setPreferredSize(new Dimension(300, 100));
			final JPanel detailPanel = new JPanel(new BorderLayout());
			detailPanel.add(detailScrollPane);
			actionsPanel = new Box(BoxLayout.X_AXIS);
			actionsPanel.setBorder(BorderFactory.createEmptyBorder(2, 2, 2, 2));
			detailPanel.add(actionsPanel, BorderLayout.SOUTH);
			detailPanel.setOpaque(false);
			detailPanel.setVisible(false);
			final String hideDetails = resources.getString("ShowDetails.text0");
			final String showDetails = resources.getString("ShowDetails.text1");
			final JButton btnShowDetails = new JButton(showDetails);
			btnShowDetails.addActionListener(new ActionListener() {
				public void actionPerformed(ActionEvent e) {
					boolean visible = detailPanel.isVisible();
					detailPanel.setVisible(!visible);
					btnShowDetails.setText(visible ? showDetails : hideDetails);
				}
			});
			JPanel button = new JPanel(new FlowLayout(FlowLayout.LEADING));
			button.setOpaque(false);
			button.add(btnShowDetails);
			details.add(button, BorderLayout.NORTH);
			details.add(detailPanel);

			Dimension dim = getPreferredSize();
			gradient = new GradientPaint(0, 0, new Color(217, 226, 234), 0,
					2 * dim.height, new Color(193, 207, 221));

		}

		public ErrorButton(final ErrorInfo info) {
			this(info.type);

			setMessageText(info.throwable.getMessage());

			StringWriter sw = new StringWriter();
			info.throwable.printStackTrace(new PrintWriter(sw));
			sw.flush();
			setDetailText(sw.toString());
		}

		private TextInfo textInfo;

		private JButton viewSourceButton;

		private JButton viewDOMButton;

		public ErrorButton(final AttributeErrorInfo info) {
			this(info.type);

			// Get reference to original element if this is a clone
			AbstractDocument doc = (AbstractDocument) info.element
					.getOwnerDocument();
			Element importedNode = (Element) doc.getImportedNode(info.element);
			if (importedNode != null) {
				info.element = importedNode;
			}
			final Element element = info.element;

			if (info.viewSourceAction != null) {
				viewSourceButton = new JButton(resources
						.getString("ViewSource.text"));
				AbstractAction viewSourceActionDecorator = new AbstractAction() {
					public void actionPerformed(final ActionEvent e) {
						new Thread() {
							public void run() {
								info.viewSourceAction.actionPerformed(e);
								try {
									info.viewSourceAction.getDisplayThread()
											.join();
									SourceViewFrame svf = info.viewSourceAction
											.getSourceViewFrame();

									int locline = info.docDescriptor
											.getLocationLine(element), loccol = info.docDescriptor
											.getLocationColumn(element);

									String text = textInfo
											.getFormattedText(false);
									int endOffset = textInfo.getOffset(locline,
											loccol, false) - 1;

									// find end of line
									for (; endOffset < text.length()
											&& text.charAt(endOffset) != '\n'; endOffset++)
										;

									// find beginning of tag
									int startOffset = endOffset - 1;
									boolean foundTagBegin = false;
									for (; startOffset >= 0 && !foundTagBegin
											|| text.charAt(startOffset) != '\n'; startOffset--) {
										if (text.charAt(startOffset) == '<') {
											foundTagBegin = true;
										}
									}
									startOffset++;

									if (startOffset >= 0 && endOffset >= 0) {
										svf.select(startOffset, endOffset);
									}
								} catch (InterruptedException ex) {
									ex.printStackTrace();
								}
							}
						}.start();
					}
				};
				viewSourceButton.addActionListener(viewSourceActionDecorator);
				viewSourceButton.setEnabled(false);
				actionsPanel.add(viewSourceButton);
				actionsPanel.add(Box.createHorizontalStrut(5));
			}

			if (info.viewDOMAction != null) {
				viewDOMButton = new JButton(resources.getString("ViewDOM.text"));
				AbstractAction viewDOMActionDecorator = new AbstractAction() {
					public void actionPerformed(ActionEvent e) {
						info.viewDOMAction.actionPerformed(e);
						DOMViewer domViewer = info.viewDOMAction.getDOMViewer();
						domViewer.setSelectionNode(element);
					}
				};
				viewDOMButton.addActionListener(viewDOMActionDecorator);
				actionsPanel.add(viewDOMButton);
				actionsPanel.add(Box.createHorizontalStrut(5));
			}

			detailScrollPane.setViewportView(throbber);
			throbber.start();
			new Thread() {
				public void run() {
					LiveAttributeException lex = (LiveAttributeException) info.throwable;
					String attrName = lex.getAttributeName();
					String eltName = lex.getElement().getNodeName();
					setMessageText("Error in parsing value for property '"
							+ attrName + "' of element <" + eltName
							+ ">. Declaration dropped");
					String text;
					int endOffset = 0, startOffset;
					int locline = info.docDescriptor.getLocationLine(element), loccol = info.docDescriptor
							.getLocationColumn(element);
					try {
						Thread.sleep(3000);

						if (info.inputStream == null) {
							throw new NullPointerException(
									"Document text not available");
						} else {
							LinkedList lineList = new LinkedList();
							BufferedReader reader = new BufferedReader(
									new InputStreamReader(info.inputStream));
							String line;

							while ((line = reader.readLine()) != null) {
								lineList.add(line);
							}
							String[] lines = (String[]) lineList
									.toArray(new String[0]);
							textInfo = new TextInfo(lines);
							text = textInfo.getFormattedText(true);
							endOffset = textInfo.getOffset(locline, loccol,
									true) - 1;
						}
						setDetailText(text);

						Highlighter highlighter = detailText.getHighlighter();
						highlighter.removeAllHighlights();

						// find end of line
						for (; endOffset >= 0 && endOffset < text.length()
								&& text.charAt(endOffset) != '\n'; endOffset++)
							;

						// find beginning of tag
						startOffset = endOffset - 1;
						boolean foundTagBegin = false;
						for (; startOffset >= 0
								&& (!foundTagBegin || text.charAt(startOffset) != '\n'); startOffset--) {
							if (text.charAt(startOffset) == '<') {
								foundTagBegin = true;
							}
						}
						startOffset++;

						if (startOffset >= 0 && endOffset < text.length()) {
							try {
								highlighter
										.addHighlight(
												startOffset,
												endOffset,
												new DefaultHighlighter.DefaultHighlightPainter(
														Color.yellow));
							} catch (BadLocationException e) {
							}
						}

						if (viewSourceButton != null) {
							viewSourceButton.setEnabled(true);
						}
					} catch (Exception e) {
						e.printStackTrace();
						setDetailText("Error parsing file: " + info.uri);
					}

					throbber.stop();
					detailScrollPane.setViewportView(detailText);
					if (locline >= 0) {
						JScrollBar vsb = detailScrollPane
								.getVerticalScrollBar();
						vsb.setValue(vsb.getUnitIncrement(JScrollBar.VERTICAL)
								* (locline - 5));
					}
				}
			}.start();
		}

		protected class TextInfo {
			private String[] lines;

			private int indent;

			public TextInfo(String[] lines) {
				this.lines = lines.clone();
				indent = 1;
				int len = lines.length;
				while ((int) (len /= 10) > 0) {
					indent++;
				}
			}

			public String getFormattedText(boolean showLineNumbers) {
				StringBuilder sb = new StringBuilder();
				if (showLineNumbers) {
					String format = "%" + indent + "d: %s\n";
					for (int i = 0; i < lines.length; i++) {
						sb.append(String.format(format, i + 1, lines[i]));
					}
				} else {
					for (int i = 0; i < lines.length; i++) {
						sb.append(lines[i] + "\n");
					}
				}

				return sb.toString();
			}

			public int getOffset(int locline, int loccol,
					boolean withLineNumbers) {
				int offset = 0;
				for (int i = 0; i < locline; i++) {
					if (i < locline - 1) {
						offset += lines[i].length();
					} else if (i == locline - 1) {
						offset += loccol;
					}
				}
				offset += (withLineNumbers ? (indent + 3) : 1) * locline - 1;
				return offset;
			}
		}

		protected class Throbber extends JLabel {
			private ImageIcon[] tiles;

			private Timer timer;

			private int currentTileIndex;

			public Throbber() {
				setOpaque(false);
				setText(resources.getString("Throbber.text"));
				setHorizontalAlignment(SwingConstants.CENTER);
				setVerticalAlignment(SwingConstants.CENTER);
				setFont(new Font("Sans Serif", Font.PLAIN, 12));

				BufferedImage image;
				try {
					image = ImageIO.read(getClass().getResource(
							resources.getString("Throbber.image")));
					tiles = new ImageIcon[32];
					int width = image.getWidth(), height = image.getHeight();
					int twidth = width / 8, theight = height / 4;
					int index = 0;
					for (int y = theight; y <= height; y += theight) {
						for (int x = twidth; x <= width; x += twidth) {
							tiles[index++] = new ImageIcon(image.getSubimage(x
									- twidth, y - theight, twidth, theight));
						}
					}

				} catch (IOException e) {
					tiles = null;
				} finally {
					image = null;
				}
			}

			public void start() {
				stop();
				timer = new Timer();
				TimerTask timerTask = new TimerTask() {
					public void run() {
						currentTileIndex = (currentTileIndex + 1)
								% tiles.length;
						if (currentTileIndex == 0) {
							currentTileIndex = 1;
						}
						setIcon(tiles[currentTileIndex]);
					}
				};
				timer.scheduleAtFixedRate(timerTask, 0, 30);
			}

			public void stop() {
				if (timer != null) {
					timer.cancel();
				}
			}
		}

		public void paintComponent(Graphics g) {
			Graphics2D g2 = (Graphics2D) g;
			int width = getWidth(), height = getHeight();
			g2.setPaint(isSelected() ? gradient : Color.white);
			g2.fillRect(0, 0, width, height);
			g2.setColor(SystemColor.controlShadow);
			g2.drawLine(0, height - 1, width, height - 1);
			super.paintComponent(g);
		}

		public int getType() {
			return type;
		}

		public void setType(int type) {
			this.type = type;
			repaint();
		}

		public JPopupMenu getPopupMenu() {
			return popupMenu;
		}

		public void setPopupMenu(JPopupMenu popupMenu) {
			this.popupMenu = popupMenu;
		}

		public String getMessageText() {
			return messageText.getText();
		}

		public void setMessageText(String text) {
			messageText.setText(text);
		}

		public String getDetailText() {
			return detailText.getText();
		}

		public void setDetailText(String text) {
			detailText.setText(text);
		}
	}

	private static Element findElementByTagName(Node node, String tagName) {
		if (node.getNodeType() == Node.ELEMENT_NODE
				&& node.getNodeName().equals(tagName)) {
			return (Element) node;
		}
		NodeList list = node.getChildNodes();
		for (int i = 0; i < list.getLength(); i++) {
			Element e = findElementByTagName(list.item(i), tagName);
			if (e != null) {
				return e;
			}
		}
		return null;
	}

	public static void main(String[] args) throws Exception {
		ErrorConsole ec = ErrorConsole.getInstance();
		File file = new File(System.getProperty("user.home")
				+ "/Desktop/batikws/xml-batik/rect.svg");
		SAXSVGDocumentFactory f = new SAXSVGDocumentFactory(null, true);
		SVGDocument doc = (SVGDocument) f.createDocument(file.toURL()
				.toString());
		Element elt = findElementByTagName(doc.getDocumentElement(), "rect");
		DocumentDescriptor desc = f.getDocumentDescriptor();
		// ec.add(elt, doc, desc, new FileInputStream(file),
		// JOptionPane.ERROR_MESSAGE);
		// ec.add(new Exception("Test Exception"), null,
		// JOptionPane.WARNING_MESSAGE);
		// ec.add(new Exception("Test Exception"), null,
		// JOptionPane.INFORMATION_MESSAGE);
		ErrorConsole.showDialog(null);
	}
}

Lines 23-28 Link Here

(-)resources/org/apache/batik/apps/svgbrowser/resources/GUI.properties (+9 lines)
23		23
24	ViewSource.width = 750	24	ViewSource.width = 750
25	ViewSource.height = 500	25	ViewSource.height = 500
		26	ViewSource.frameicon = resources/squiggleIcon.png
26		27
27		28
28	#	29	#
Lines 401-406 Link Here
401	ScriptDebugger.mnemonic = S	402	ScriptDebugger.mnemonic = S
402	ScriptDebugger.action = ToggleDebuggerAction	403	ScriptDebugger.action = ToggleDebuggerAction
403		404
		405	TimelineViewer.type = ITEM
		406	TimelineViewer.text = Timeline Viewer...
		407	TimelineViewer.icon = resources/timeline-viewer-small.png
		408	TimelineViewer.icon.OSX =
		409	TimelineViewer.mnemonic = T
		410	TimelineViewer.action = TimelineViewerAction
		411	TimelineViewer.accelerator = ctrl F9
		412	TimelineViewer.accelerator.OSX = meta F9
404		413
405	# Help menu ##################	414	# Help menu ##################
406	Help = About	415	Help = About




# -----------------------------------------------------------------------------
#
#   Licensed to the Apache Software Foundation (ASF) under one or more
#   contributor license agreements.  See the NOTICE file distributed with
#   this work for additional information regarding copyright ownership.
#   The ASF licenses this file to You under the Apache License, Version 2.0
#   (the "License"); you may not use this file except in compliance with
#   the License.  You may obtain a copy of the License at
#
#       http://www.apache.org/licenses/LICENSE-2.0
#
#   Unless required by applicable law or agreed to in writing, software
#   distributed under the License is distributed on an "AS IS" BASIS,
#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#   See the License for the specific language governing permissions and
#   limitations under the License.
#
# The resources for the ErrorConsole
#
# Author: singh.jasleen@gmail.com
# $Id: ErrorConsole.properties 475477 2006-11-15 22:44:28Z cam $
# -----------------------------------------------------------------------------

StartButton.icon     = resources/start.png
StartButton.tooltip  = Start

BackwardButton.icon     = resources/backward.png
BackwardButton.tooltip  = Backward

PlayButton.icon     = resources/play.png
PlayButton.tooltip  = Play

ForwardButton.icon     = resources/forward.png
ForwardButton.tooltip  = Forward

EndButton.icon     = resources/end.png
EndButton.tooltip  = End

ToolBar = StartButton BackwardButton PlayButton ForwardButton \
			EndButton




# -----------------------------------------------------------------------------
#
#   Licensed to the Apache Software Foundation (ASF) under one or more
#   contributor license agreements.  See the NOTICE file distributed with
#   this work for additional information regarding copyright ownership.
#   The ASF licenses this file to You under the Apache License, Version 2.0
#   (the "License"); you may not use this file except in compliance with
#   the License.  You may obtain a copy of the License at
#
#       http://www.apache.org/licenses/LICENSE-2.0
#
#   Unless required by applicable law or agreed to in writing, software
#   distributed under the License is distributed on an "AS IS" BASIS,
#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#   See the License for the specific language governing permissions and
#   limitations under the License.
#
# The resources for the ErrorConsole
#
# Author: singh.jasleen@gmail.com
# $Id: ErrorConsole.properties 475477 2006-11-15 22:44:28Z cam $
# -----------------------------------------------------------------------------

Heading.text = SVG Error:

DisplayAllButton.text     = All
DisplayAllButton.icon     = resources/all.png
DisplayAllButton.mnemonic = A
DisplayAllButton.action   = DisplayAllButtonAction
DisplayAllButton.tooltip  = Show all entries

DisplayErrorsButton.text     = Errors
DisplayErrorsButton.icon     = resources/errors.png
DisplayErrorsButton.mnemonic = E
DisplayErrorsButton.action   = DisplayErrorsButtonAction
DisplayErrorsButton.tooltip  = Show/hide all errors

DisplayWarningsButton.text     = Warnings
DisplayWarningsButton.icon     = resources/warnings.png
DisplayWarningsButton.mnemonic = W
DisplayWarningsButton.action   = DisplayWarningsButtonAction
DisplayWarningsButton.tooltip  = Show/hide all warnings

DisplayMessagesButton.text     = Messages
DisplayMessagesButton.icon     = resources/messages.png
DisplayMessagesButton.mnemonic = M
DisplayMessagesButton.action   = DisplayMessagesButtonAction
DisplayMessagesButton.tooltip  = Show/hide all messages

ClearButton.text     = Clear
ClearButton.icon     = resources/clear.png
ClearButton.mnemonic = C
ClearButton.action   = ClearButtonAction
ClearButton.tooltip  = Permanently remove all entries

ErrorButton.warning_icon = resources/warning-small.png
ErrorButton.message_icon = resources/message-small.png
ErrorButton.error_icon = resources/error-small.png

FirstLastSortMenuItem.text     = First > Last Sort Order
FirstLastSortMenuItem.type     = ITEM
FirstLastSortMenuItem.mnemonic = F
FirstLastSortMenuItem.action   = FirstLastSortMenuAction

LastFirstSortMenuItem.text     = Last > First Sort Order
LastFirstSortMenuItem.type     = ITEM
LastFirstSortMenuItem.mnemonic = L
LastFirstSortMenuItem.action   = LastFirstSortMenuAction

CopyMenuItem.text        = Copy (Ctrl+C)
CopyMenuItem.type        = ITEM
CopyMenuItem.mnemonic    = C
CopyMenuItem.accelerator = ctrl C
CopyMenuItem.action      = CopyMenuAction

PopupMenu = FirstLastSortMenuItem LastFirstSortMenuItem - \
            CopyMenuItem
PopupMenu.text = ErrorConsolePoupup

Throbber.text  = Loading...
Throbber.image = resources/process-working.png

ViewSource.text = View Source

ViewDOM.text    = View DOM

ShowDetails.text0 = << Hide Details
ShowDetails.text1 = Show Details >>

Return to bug 42741

Lines 20-25 Link Here

(-)sources/org/apache/batik/swing/svg/SVGDocumentLoaderEvent.java (-1 / +16 lines)
20		20
21	import java.util.EventObject;	21	import java.util.EventObject;
22		22
		23	import org.apache.batik.dom.util.DocumentDescriptor;
23	import org.w3c.dom.svg.SVGDocument;	24	import org.w3c.dom.svg.SVGDocument;
24		25
25	/**	26	/**
Lines 37-50 Link Here
37	protected SVGDocument svgDocument;	38	protected SVGDocument svgDocument;
38		39
39	/**	40	/**
		41	* The document descriptor describing the document
		42	*/
		43	protected DocumentDescriptor docDescriptor;
		44
		45	/**
40	* Creates a new SVGDocumentLoaderEvent.	46	* Creates a new SVGDocumentLoaderEvent.
41	* @param source the object that originated the event, ie. the	47	* @param source the object that originated the event, ie. the
42	* SVGDocumentLoader.	48	* SVGDocumentLoader.
43	* @param doc The associated document.	49	* @param doc The associated document.
44	*/	50	*/
45	public SVGDocumentLoaderEvent(Object source, SVGDocument doc) {	51	public SVGDocumentLoaderEvent(Object source, SVGDocument doc, DocumentDescriptor desc) {
46	super(source);	52	super(source);
47	svgDocument = doc;	53	svgDocument = doc;
		54	docDescriptor = desc;
48	}	55	}
49		56
50	/**	57	/**
Lines 54-57 Link Here
54	public SVGDocument getSVGDocument() {	61	public SVGDocument getSVGDocument() {
55	return svgDocument;	62	return svgDocument;
56	}	63	}
		64
		65	/**
		66	* Returns the document descriptor for this document, or null
		67	* if the document wasn't completely loaded
		68	*/
		69	public DocumentDescriptor getDocumentDescriptor() {
		70	return docDescriptor;
		71	}
57	}	72	}

Lines 18-32 Link Here

(-)sources/org/apache/batik/bridge/DocumentLoader.java (-3 / +20 lines)
18	*/	18	*/
19	package org.apache.batik.bridge;	19	package org.apache.batik.bridge;
20		20
		21	import java.io.IOException;
21	import java.io.InputStream;	22	import java.io.InputStream;
22	import java.io.IOException;
23	import java.util.HashMap;	23	import java.util.HashMap;
24		24
25	import org.apache.batik.dom.svg.SAXSVGDocumentFactory;	25	import org.apache.batik.dom.svg.SAXSVGDocumentFactory;
26	import org.apache.batik.dom.svg.SVGDocumentFactory;	26	import org.apache.batik.dom.svg.SVGDocumentFactory;
27	import org.apache.batik.dom.util.DocumentDescriptor;	27	import org.apache.batik.dom.util.DocumentDescriptor;
28	import org.apache.batik.util.CleanerThread;	28	import org.apache.batik.util.CleanerThread;
29
30	import org.w3c.dom.Document;	29	import org.w3c.dom.Document;
31	import org.w3c.dom.Element;	30	import org.w3c.dom.Element;
32	import org.w3c.dom.svg.SVGDocument;	31	import org.w3c.dom.svg.SVGDocument;
Lines 104-110 Link Here
104	return ret;	103	return ret;
105		104
106	SVGDocument document = documentFactory.createSVGDocument(uri);	105	SVGDocument document = documentFactory.createSVGDocument(uri);
107
108	DocumentDescriptor desc = documentFactory.getDocumentDescriptor();	106	DocumentDescriptor desc = documentFactory.getDocumentDescriptor();
109	DocumentState state = new DocumentState(uri, document, desc);	107	DocumentState state = new DocumentState(uri, document, desc);
110	synchronized (cacheMap) {	108	synchronized (cacheMap) {
Lines 176-181 Link Here
176	}	174	}
177		175
178	/**	176	/**
		177	* Returns the document descriptor of the last loaded document
		178	*
		179	* @return the document descriptor of the last loaded document, or
		180	* null if no document has been loaded.
		181	*/
		182	public DocumentDescriptor getDocumentDescriptor(SVGDocument doc) {
		183	String uri = doc.getURL();
		184	DocumentState state;
		185	synchronized (cacheMap) {
		186	state = (DocumentState)cacheMap.get(uri);
		187	}
		188	if (state == null) {
		189	return null;
		190	} else {
		191	return state.desc;
		192	}
		193	}
		194
		195	/**
179	* A simple class that contains a Document and its number of nodes.	196	* A simple class that contains a Document and its number of nodes.
180	*/	197	*/
181	private class DocumentState extends CleanerThread.SoftReferenceCleared {	198	private class DocumentState extends CleanerThread.SoftReferenceCleared {

Lines 28-34 Link Here

(-)sources/org/apache/batik/bridge/SVGRectElementBridge.java (-2 / +6 lines)
28	import org.apache.batik.dom.svg.SVGOMRectElement;	28	import org.apache.batik.dom.svg.SVGOMRectElement;
29	import org.apache.batik.gvt.ShapeNode;	29	import org.apache.batik.gvt.ShapeNode;
30	import org.apache.batik.gvt.ShapePainter;	30	import org.apache.batik.gvt.ShapePainter;
31
32	import org.w3c.dom.Element;	31	import org.w3c.dom.Element;
33		32
34	/**	33	/**
Lines 116-122 Link Here
116	}	115	}
117	shapeNode.setShape(shape);	116	shapeNode.setShape(shape);
118	} catch (LiveAttributeException ex) {	117	} catch (LiveAttributeException ex) {
119	throw new BridgeException(ctx, ex);	118	if (strictParsing) {
		119	throw new BridgeException(ctx, ex);
		120	} else {
		121	ctx.userAgent.displayError(ex);
		122	shapeNode.setShape(nullShape);
		123	}
120	}	124	}
121	}	125	}
122		126

Line 0 Link Here

(-)sources/org/apache/batik/apps/svgbrowser/srcview/TextAreaPainter.java (+693 lines)
		1	/*
		2	* TextAreaPainter.java - Paints the text area
		3	* Copyright (C) 1999 Slava Pestov
		4	*
		5	* You may use and modify this package for any purpose. Redistribution is
		6	* permitted, in both source and binary form, provided that this notice
		7	* remains intact in all source distributions of this package.
		8	*/
		9	package org.apache.batik.apps.svgbrowser.srcview;
		10
		11	import javax.swing.ToolTipManager;
		12	import javax.swing.text.*;
		13	import javax.swing.JComponent;
		14	import java.awt.event.MouseEvent;
		15	import java.awt.*;
		16
		17	/**
		18	* The text area repaint manager. It performs double buffering and paints
		19	* lines of text.
		20	* @author Slava Pestov
		21	* @version $Id: TextAreaPainter.java,v 1.24 1999/12/13 03:40:30 sp Exp $
		22	*/
		23	public class TextAreaPainter extends JComponent implements TabExpander
		24	{
		25	/**
		26	* Creates a new repaint manager. This should be not be called
		27	* directly.
		28	*/
		29	public TextAreaPainter(JEditTextArea textArea, TextAreaDefaults defaults)
		30	{
		31	this.textArea = textArea;
		32
		33	setAutoscrolls(true);
		34	setDoubleBuffered(true);
		35	setOpaque(true);
		36
		37	ToolTipManager.sharedInstance().registerComponent(this);
		38
		39	currentLine = new Segment();
		40	currentLineIndex = -1;
		41
		42	setCursor(Cursor.getPredefinedCursor(Cursor.TEXT_CURSOR));
		43
		44	setFont(new Font("Monospaced",Font.PLAIN,14));
		45	setForeground(Color.black);
		46	setBackground(Color.white);
		47
		48	blockCaret = defaults.blockCaret;
		49	styles = defaults.styles;
		50	cols = defaults.cols;
		51	rows = defaults.rows;
		52	caretColor = defaults.caretColor;
		53	selectionColor = defaults.selectionColor;
		54	lineHighlightColor = defaults.lineHighlightColor;
		55	lineHighlight = defaults.lineHighlight;
		56	bracketHighlightColor = defaults.bracketHighlightColor;
		57	bracketHighlight = defaults.bracketHighlight;
		58	paintInvalid = defaults.paintInvalid;
		59	eolMarkerColor = defaults.eolMarkerColor;
		60	eolMarkers = defaults.eolMarkers;
		61	}
		62
		63	/**
		64	* Returns if this component can be traversed by pressing the
65	* Tab key. This returns false.
66	*/
67	public final boolean isManagingFocus()
68	{
69	return false;
70	}
71
72	/**
73	* Returns the syntax styles used to paint colorized text. Entry <i>n</i>
74	* will be used to paint tokens with id = <i>n</i>.
75	* @see org.gjt.sp.jedit.syntax.Token
76	*/
77	public final SyntaxStyle[] getStyles()
78	{
79	return styles;
80	}
81
82	/**
83	* Sets the syntax styles used to paint colorized text. Entry <i>n</i>
84	* will be used to paint tokens with id = <i>n</i>.
85	* @param styles The syntax styles
86	* @see org.gjt.sp.jedit.syntax.Token
87	*/
88	public final void setStyles(SyntaxStyle[] styles)
89	{
90	this.styles = styles;
91	repaint();
92	}
93
94	/**
95	* Returns the caret color.
96	*/
97	public final Color getCaretColor()
98	{
99	return caretColor;
100	}
101
102	/**
103	* Sets the caret color.
104	* @param caretColor The caret color
105	*/
106	public final void setCaretColor(Color caretColor)
107	{
108	this.caretColor = caretColor;
109	invalidateSelectedLines();
110	}
111
112	/**
113	* Returns the selection color.
114	*/
115	public final Color getSelectionColor()
116	{
117	return selectionColor;
118	}
119
120	/**
121	* Sets the selection color.
122	* @param selectionColor The selection color
123	*/
124	public final void setSelectionColor(Color selectionColor)
125	{
126	this.selectionColor = selectionColor;
127	invalidateSelectedLines();
128	}
129
130	/**
131	* Returns the line highlight color.
132	*/
133	public final Color getLineHighlightColor()
134	{
135	return lineHighlightColor;
136	}
137
138	/**
139	* Sets the line highlight color.
140	* @param lineHighlightColor The line highlight color
141	*/
142	public final void setLineHighlightColor(Color lineHighlightColor)
143	{
144	this.lineHighlightColor = lineHighlightColor;
145	invalidateSelectedLines();
146	}
147
148	/**
149	* Returns true if line highlight is enabled, false otherwise.
150	*/
151	public final boolean isLineHighlightEnabled()
152	{
153	return lineHighlight;
154	}
155
156	/**
157	* Enables or disables current line highlighting.
158	* @param lineHighlight True if current line highlight should be enabled,
159	* false otherwise
160	*/
161	public final void setLineHighlightEnabled(boolean lineHighlight)
162	{
163	this.lineHighlight = lineHighlight;
164	invalidateSelectedLines();
165	}
166
167	/**
168	* Returns the bracket highlight color.
169	*/
170	public final Color getBracketHighlightColor()
171	{
172	return bracketHighlightColor;
173	}
174
175	/**
176	* Sets the bracket highlight color.
177	* @param bracketHighlightColor The bracket highlight color
178	*/
179	public final void setBracketHighlightColor(Color bracketHighlightColor)
180	{
181	this.bracketHighlightColor = bracketHighlightColor;
182	invalidateLine(textArea.getBracketLine());
183	}
184
185	/**
186	* Returns true if bracket highlighting is enabled, false otherwise.
187	* When bracket highlighting is enabled, the bracket matching the
188	* one before the caret (if any) is highlighted.
189	*/
190	public final boolean isBracketHighlightEnabled()
191	{
192	return bracketHighlight;
193	}
194
195	/**
196	* Enables or disables bracket highlighting.
197	* When bracket highlighting is enabled, the bracket matching the
198	* one before the caret (if any) is highlighted.
199	* @param bracketHighlight True if bracket highlighting should be
200	* enabled, false otherwise
201	*/
202	public final void setBracketHighlightEnabled(boolean bracketHighlight)
203	{
204	this.bracketHighlight = bracketHighlight;
205	invalidateLine(textArea.getBracketLine());
206	}
207
208	/**
209	* Returns true if the caret should be drawn as a block, false otherwise.
210	*/
211	public final boolean isBlockCaretEnabled()
212	{
213	return blockCaret;
214	}
215
216	/**
217	* Sets if the caret should be drawn as a block, false otherwise.
218	* @param blockCaret True if the caret should be drawn as a block,
219	* false otherwise.
220	*/
221	public final void setBlockCaretEnabled(boolean blockCaret)
222	{
223	this.blockCaret = blockCaret;
224	invalidateSelectedLines();
225	}
226
227	/**
228	* Returns the EOL marker color.
229	*/
230	public final Color getEOLMarkerColor()
231	{
232	return eolMarkerColor;
233	}
234
235	/**
236	* Sets the EOL marker color.
237	* @param eolMarkerColor The EOL marker color
238	*/
239	public final void setEOLMarkerColor(Color eolMarkerColor)
240	{
241	this.eolMarkerColor = eolMarkerColor;
242	repaint();
243	}
244
245	/**
246	* Returns true if EOL markers are drawn, false otherwise.
247	*/
248	public final boolean getEOLMarkersPainted()
249	{
250	return eolMarkers;
251	}
252
253	/**
254	* Sets if EOL markers are to be drawn.
255	* @param eolMarkers True if EOL markers should be drawn, false otherwise
256	*/
257	public final void setEOLMarkersPainted(boolean eolMarkers)
258	{
259	this.eolMarkers = eolMarkers;
260	repaint();
261	}
262
263	/**
264	* Returns true if invalid lines are painted as red tildes (~),
265	* false otherwise.
266	*/
267	public boolean getInvalidLinesPainted()
268	{
269	return paintInvalid;
270	}
271
272	/**
273	* Sets if invalid lines are to be painted as red tildes.
274	* @param paintInvalid True if invalid lines should be drawn, false otherwise
275	*/
276	public void setInvalidLinesPainted(boolean paintInvalid)
277	{
278	this.paintInvalid = paintInvalid;
279	}
280
281	/**
282	* Adds a custom highlight painter.
283	* @param highlight The highlight
284	*/
285	public void addCustomHighlight(Highlight highlight)
286	{
287	highlight.init(textArea,highlights);
288	highlights = highlight;
289	}
290
291	/**
292	* Highlight interface.
293	*/
294	public interface Highlight
295	{
296	/**
297	* Called after the highlight painter has been added.
298	* @param textArea The text area
299	* @param next The painter this one should delegate to
300	*/
301	void init(JEditTextArea textArea, Highlight next);
302
303	/**
304	* This should paint the highlight and delgate to the
305	* next highlight painter.
306	* @param gfx The graphics context
307	* @param line The line number
308	* @param y The y co-ordinate of the line
309	*/
310	void paintHighlight(Graphics gfx, int line, int y);
311
312	/**
313	* Returns the tool tip to display at the specified
314	* location. If this highlighter doesn't know what to
315	* display, it should delegate to the next highlight
316	* painter.
317	* @param evt The mouse event
318	*/
319	String getToolTipText(MouseEvent evt);
320	}
321
322	/**
323	* Returns the tool tip to display at the specified location.
324	* @param evt The mouse event
325	*/
326	public String getToolTipText(MouseEvent evt)
327	{
328	if(highlights != null)
329	return highlights.getToolTipText(evt);
330	else
331	return null;
332	}
333
334	/**
335	* Returns the font metrics used by this component.
336	*/
337	public FontMetrics getFontMetrics()
338	{
339	return fm;
340	}
341
342	/**
343	* Sets the font for this component. This is overridden to update the
344	* cached font metrics and to recalculate which lines are visible.
345	* @param font The font
346	*/
347	public void setFont(Font font)
348	{
349	super.setFont(font);
350	fm = Toolkit.getDefaultToolkit().getFontMetrics(font);
351	textArea.recalculateVisibleLines();
352	}
353
354	/**
355	* Repaints the text.
356	* @param g The graphics context
357	*/
358	public void paint(Graphics gfx)
359	{
360	tabSize = fm.charWidth(' ') * ((Integer)textArea
361	.getDocument().getProperty(
362	PlainDocument.tabSizeAttribute)).intValue();
363
364	Rectangle clipRect = gfx.getClipBounds();
365
366	gfx.setColor(getBackground());
367	gfx.fillRect(clipRect.x,clipRect.y,clipRect.width,clipRect.height);
368
369	// We don't use yToLine() here because that method doesn't
370	// return lines past the end of the document
371	int height = fm.getHeight();
372	int firstLine = textArea.getFirstLine();
373	int firstInvalid = firstLine + clipRect.y / height;
374	// Because the clipRect's height is usually an even multiple
375	// of the font height, we subtract 1 from it, otherwise one
376	// too many lines will always be painted.
377	int lastInvalid = firstLine + (clipRect.y + clipRect.height - 1) / height;
378
379	try
380	{
381	TokenMarker tokenMarker = textArea.getDocument()
382	.getTokenMarker();
383	int x = textArea.getHorizontalOffset();
384
385	for(int line = firstInvalid; line <= lastInvalid; line++)
386	{
387	paintLine(gfx,tokenMarker,line,x);
388	}
389
390	if(tokenMarker != null && tokenMarker.isNextLineRequested())
391	{
392	int h = clipRect.y + clipRect.height;
393	repaint(0,h,getWidth(),getHeight() - h);
394	}
395	}
396	catch(Exception e)
397	{
398	System.err.println("Error repainting line"
399	+ " range {" + firstInvalid + ","
400	+ lastInvalid + "}:");
401	e.printStackTrace();
402	}
403	}
404
405	/**
406	* Marks a line as needing a repaint.
407	* @param line The line to invalidate
408	*/
409	public final void invalidateLine(int line)
410	{
411	repaint(0,textArea.lineToY(line) + fm.getMaxDescent() + fm.getLeading(),
412	getWidth(),fm.getHeight());
413	}
414
415	/**
416	* Marks a range of lines as needing a repaint.
417	* @param firstLine The first line to invalidate
418	* @param lastLine The last line to invalidate
419	*/
420	public final void invalidateLineRange(int firstLine, int lastLine)
421	{
422	repaint(0,textArea.lineToY(firstLine) + fm.getMaxDescent() + fm.getLeading(),
423	getWidth(),(lastLine - firstLine + 1) * fm.getHeight());
424	}
425
426	/**
427	* Repaints the lines containing the selection.
428	*/
429	public final void invalidateSelectedLines()
430	{
431	invalidateLineRange(textArea.getSelectionStartLine(),
432	textArea.getSelectionEndLine());
433	}
434
435	/**
436	* Implementation of TabExpander interface. Returns next tab stop after
437	* a specified point.
438	* @param x The x co-ordinate
439	* @param tabOffset Ignored
440	* @return The next tab stop after <i>x</i>
441	*/
442	public float nextTabStop(float x, int tabOffset)
443	{
444	int offset = textArea.getHorizontalOffset();
445	int ntabs = ((int)x - offset) / tabSize;
446	return (ntabs + 1) * tabSize + offset;
447	}
448
449	/**
450	* Returns the painter's preferred size.
451	*/
452	public Dimension getPreferredSize()
453	{
454	Dimension dim = new Dimension();
455	dim.width = fm.charWidth('w') * cols;
456	dim.height = fm.getHeight() * rows;
457	return dim;
458	}
459
460
461	/**
462	* Returns the painter's minimum size.
463	*/
464	public Dimension getMinimumSize()
465	{
466	return getPreferredSize();
467	}
468
469	// package-private members
470	int currentLineIndex;
471	Token currentLineTokens;
472	Segment currentLine;
473
474	// protected members
475	protected JEditTextArea textArea;
476
477	protected SyntaxStyle[] styles;
478	protected Color caretColor;
479	protected Color selectionColor;
480	protected Color lineHighlightColor;
481	protected Color bracketHighlightColor;
482	protected Color eolMarkerColor;
483
484	protected boolean blockCaret;
485	protected boolean lineHighlight;
486	protected boolean bracketHighlight;
487	protected boolean paintInvalid;
488	protected boolean eolMarkers;
489	protected int cols;
490	protected int rows;
491
492	protected int tabSize;
493	protected FontMetrics fm;
494
495	protected Highlight highlights;
496
497	protected void paintLine(Graphics gfx, TokenMarker tokenMarker,
498	int line, int x)
499	{
500	Font defaultFont = getFont();
501	Color defaultColor = getForeground();
502
503	currentLineIndex = line;
504	int y = textArea.lineToY(line);
505
506	if(line < 0 \|\| line >= textArea.getLineCount())
507	{
508	if(paintInvalid)
509	{
510	paintHighlight(gfx,line,y);
511	styles[Token.INVALID].setGraphicsFlags(gfx,defaultFont);
512	gfx.drawString("~",0,y + fm.getHeight());
513	}
514	}
515	else if(tokenMarker == null)
516	{
517	paintPlainLine(gfx,line,defaultFont,defaultColor,x,y);
518	}
519	else
520	{
521	paintSyntaxLine(gfx,tokenMarker,line,defaultFont,
522	defaultColor,x,y);
523	}
524	}
525
526	protected void paintPlainLine(Graphics gfx, int line, Font defaultFont,
527	Color defaultColor, int x, int y)
528	{
529	paintHighlight(gfx,line,y);
530	textArea.getLineText(line,currentLine);
531
532	gfx.setFont(defaultFont);
533	gfx.setColor(defaultColor);
534
535	y += fm.getHeight();
536	x = Utilities.drawTabbedText(currentLine,x,y,gfx,this,0);
537
538	if(eolMarkers)
539	{
540	gfx.setColor(eolMarkerColor);
541	gfx.drawString(".",x,y);
542	}
543	}
544
545	protected void paintSyntaxLine(Graphics gfx, TokenMarker tokenMarker,
546	int line, Font defaultFont, Color defaultColor, int x, int y)
547	{
548	textArea.getLineText(currentLineIndex,currentLine);
549	currentLineTokens = tokenMarker.markTokens(currentLine,
550	currentLineIndex);
551
552	paintHighlight(gfx,line,y);
553
554	gfx.setFont(defaultFont);
555	gfx.setColor(defaultColor);
556	y += fm.getHeight();
557	x = SyntaxUtilities.paintSyntaxLine(currentLine,
558	currentLineTokens,styles,this,gfx,x,y);
559
560	if(eolMarkers)
561	{
562	gfx.setColor(eolMarkerColor);
563	gfx.drawString(".",x,y);
564	}
565	}
566
567	protected void paintHighlight(Graphics gfx, int line, int y)
568	{
569	if(line >= textArea.getSelectionStartLine()
570	&& line <= textArea.getSelectionEndLine())
571	paintLineHighlight(gfx,line,y);
572
573	if(highlights != null)
574	highlights.paintHighlight(gfx,line,y);
575
576	if(bracketHighlight && line == textArea.getBracketLine())
577	paintBracketHighlight(gfx,line,y);
578
579	if(line == textArea.getCaretLine())
580	paintCaret(gfx,line,y);
581	}
582
583	protected void paintLineHighlight(Graphics gfx, int line, int y)
584	{
585	int height = fm.getHeight();
586	y += fm.getLeading() + fm.getMaxDescent();
587
588	int selectionStart = textArea.getSelectionStart();
589	int selectionEnd = textArea.getSelectionEnd();
590
591	if(selectionStart == selectionEnd)
592	{
593	if(lineHighlight)
594	{
595	gfx.setColor(lineHighlightColor);
596	gfx.fillRect(0,y,getWidth(),height);
597	}
598	}
599	else
600	{
601	gfx.setColor(selectionColor);
602
603	int selectionStartLine = textArea.getSelectionStartLine();
604	int selectionEndLine = textArea.getSelectionEndLine();
605	int lineStart = textArea.getLineStartOffset(line);
606
607	int x1, x2;
608	if(textArea.isSelectionRectangular())
609	{
610	int lineLen = textArea.getLineLength(line);
611	x1 = textArea._offsetToX(line,Math.min(lineLen,
612	selectionStart - textArea.getLineStartOffset(
613	selectionStartLine)));
614	x2 = textArea._offsetToX(line,Math.min(lineLen,
615	selectionEnd - textArea.getLineStartOffset(
616	selectionEndLine)));
617	if(x1 == x2)
618	x2++;
619	}
620	else if(selectionStartLine == selectionEndLine)
621	{
622	x1 = textArea._offsetToX(line,
623	selectionStart - lineStart);
624	x2 = textArea._offsetToX(line,
625	selectionEnd - lineStart);
626	}
627	else if(line == selectionStartLine)
628	{
629	x1 = textArea._offsetToX(line,
630	selectionStart - lineStart);
631	x2 = getWidth();
632	}
633	else if(line == selectionEndLine)
634	{
635	x1 = 0;
636	x2 = textArea._offsetToX(line,
637	selectionEnd - lineStart);
638	}
639	else
640	{
641	x1 = 0;
642	x2 = getWidth();
643	}
644
645	// "inlined" min/max()
646	gfx.fillRect(x1 > x2 ? x2 : x1,y,x1 > x2 ?
647	(x1 - x2) : (x2 - x1),height);
648	}
649
650	}
651
652	protected void paintBracketHighlight(Graphics gfx, int line, int y)
653	{
654	int position = textArea.getBracketPosition();
655	if(position == -1)
656	return;
657	y += fm.getLeading() + fm.getMaxDescent();
658	int x = textArea._offsetToX(line,position);
659	gfx.setColor(bracketHighlightColor);
660	// Hack!!! Since there is no fast way to get the character
661	// from the bracket matching routine, we use ( since all
662	// brackets probably have the same width anyway
663	gfx.drawRect(x,y,fm.charWidth('(') - 1,
664	fm.getHeight() - 1);
665	}
666
667	protected void paintCaret(Graphics gfx, int line, int y)
668	{
669	if(textArea.isCaretVisible())
670	{
671	int offset = textArea.getCaretPosition()
672	- textArea.getLineStartOffset(line);
673	int caretX = textArea._offsetToX(line,offset);
674	int caretWidth = ((blockCaret \|\|
675	textArea.isOverwriteEnabled()) ?
676	fm.charWidth('w') : 1);
677	y += fm.getLeading() + fm.getMaxDescent();
678	int height = fm.getHeight();
679
680	gfx.setColor(caretColor);
681
682	if(textArea.isOverwriteEnabled())
683	{
684	gfx.fillRect(caretX,y + height - 1,
685	caretWidth,1);
686	}
687	else
688	{
689	gfx.drawRect(caretX,y,caretWidth - 1,height - 1);
690	}
691	}
692	}
693	}

Line 0 Link Here

(-)sources/org/apache/batik/apps/svgbrowser/srcview/DefaultInputHandler.java (+347 lines)
		1	/*
		2	* DefaultInputHandler.java - Default implementation of an input handler
		3	* Copyright (C) 1999 Slava Pestov
		4	*
		5	* You may use and modify this package for any purpose. Redistribution is
		6	* permitted, in both source and binary form, provided that this notice
		7	* remains intact in all source distributions of this package.
		8	*/
		9	package org.apache.batik.apps.svgbrowser.srcview;
		10
		11	import javax.swing.KeyStroke;
		12	import java.awt.event.*;
		13	import java.awt.Toolkit;
		14	import java.util.Hashtable;
		15	import java.util.StringTokenizer;
		16
		17	/**
		18	* The default input handler. It maps sequences of keystrokes into actions
		19	* and inserts key typed events into the text area.
		20	* @author Slava Pestov
		21	* @version $Id: DefaultInputHandler.java,v 1.18 1999/12/13 03:40:30 sp Exp $
		22	*/
		23	public class DefaultInputHandler extends InputHandler
		24	{
		25	/**
		26	* Creates a new input handler with no key bindings defined.
		27	*/
		28	public DefaultInputHandler()
		29	{
		30	bindings = currentBindings = new Hashtable();
		31	}
		32
		33	/**
		34	* Sets up the default key bindings.
		35	*/
		36	public void addDefaultKeyBindings()
		37	{
		38	addKeyBinding("BACK_SPACE",BACKSPACE);
		39	addKeyBinding("C+BACK_SPACE",BACKSPACE_WORD);
		40	addKeyBinding("DELETE",DELETE);
		41	addKeyBinding("C+DELETE",DELETE_WORD);
		42
		43	addKeyBinding("ENTER",INSERT_BREAK);
		44	addKeyBinding("TAB",INSERT_TAB);
		45
		46	addKeyBinding("INSERT",OVERWRITE);
		47	addKeyBinding("C+\\",TOGGLE_RECT);
		48
		49	addKeyBinding("HOME",HOME);
		50	addKeyBinding("END",END);
		51	addKeyBinding("S+HOME",SELECT_HOME);
		52	addKeyBinding("S+END",SELECT_END);
		53	addKeyBinding("C+HOME",DOCUMENT_HOME);
		54	addKeyBinding("C+END",DOCUMENT_END);
		55	addKeyBinding("CS+HOME",SELECT_DOC_HOME);
		56	addKeyBinding("CS+END",SELECT_DOC_END);
		57
		58	addKeyBinding("PAGE_UP",PREV_PAGE);
		59	addKeyBinding("PAGE_DOWN",NEXT_PAGE);
		60	addKeyBinding("S+PAGE_UP",SELECT_PREV_PAGE);
		61	addKeyBinding("S+PAGE_DOWN",SELECT_NEXT_PAGE);
		62
		63	addKeyBinding("LEFT",PREV_CHAR);
		64	addKeyBinding("S+LEFT",SELECT_PREV_CHAR);
65	addKeyBinding("C+LEFT",PREV_WORD);
66	addKeyBinding("CS+LEFT",SELECT_PREV_WORD);
67	addKeyBinding("RIGHT",NEXT_CHAR);
68	addKeyBinding("S+RIGHT",SELECT_NEXT_CHAR);
69	addKeyBinding("C+RIGHT",NEXT_WORD);
70	addKeyBinding("CS+RIGHT",SELECT_NEXT_WORD);
71	addKeyBinding("UP",PREV_LINE);
72	addKeyBinding("S+UP",SELECT_PREV_LINE);
73	addKeyBinding("DOWN",NEXT_LINE);
74	addKeyBinding("S+DOWN",SELECT_NEXT_LINE);
75
76	addKeyBinding("C+ENTER",REPEAT);
77	}
78
79	/**
80	* Adds a key binding to this input handler. The key binding is
81	* a list of white space separated key strokes of the form
82	* <i>[modifiers+]key</i> where modifier is C for Control, A for Alt,
83	* or S for Shift, and key is either a character (a-z) or a field
84	* name in the KeyEvent class prefixed with VK_ (e.g., BACK_SPACE)
85	* @param keyBinding The key binding
86	* @param action The action
87	*/
88	public void addKeyBinding(String keyBinding, ActionListener action)
89	{
90	Hashtable current = bindings;
91
92	StringTokenizer st = new StringTokenizer(keyBinding);
93	while(st.hasMoreTokens())
94	{
95	KeyStroke keyStroke = parseKeyStroke(st.nextToken());
96	if(keyStroke == null)
97	return;
98
99	if(st.hasMoreTokens())
100	{
101	Object o = current.get(keyStroke);
102	if(o instanceof Hashtable)
103	current = (Hashtable)o;
104	else
105	{
106	o = new Hashtable();
107	current.put(keyStroke,o);
108	current = (Hashtable)o;
109	}
110	}
111	else
112	current.put(keyStroke,action);
113	}
114	}
115
116	/**
117	* Removes a key binding from this input handler. This is not yet
118	* implemented.
119	* @param keyBinding The key binding
120	*/
121	public void removeKeyBinding(String keyBinding)
122	{
123	throw new InternalError("Not yet implemented");
124	}
125
126	/**
127	* Removes all key bindings from this input handler.
128	*/
129	public void removeAllKeyBindings()
130	{
131	bindings.clear();
132	}
133
134	/**
135	* Returns a copy of this input handler that shares the same
136	* key bindings. Setting key bindings in the copy will also
137	* set them in the original.
138	*/
139	public InputHandler copy()
140	{
141	return new DefaultInputHandler(this);
142	}
143
144	/**
145	* Handle a key pressed event. This will look up the binding for
146	* the key stroke and execute it.
147	*/
148	public void keyPressed(KeyEvent evt)
149	{
150	int keyCode = evt.getKeyCode();
151	int modifiers = evt.getModifiers();
152
153	if(keyCode == KeyEvent.VK_CONTROL \|\|
154	keyCode == KeyEvent.VK_SHIFT \|\|
155	keyCode == KeyEvent.VK_ALT \|\|
156	keyCode == KeyEvent.VK_META)
157	return;
158
159	if((modifiers & ~KeyEvent.SHIFT_MASK) != 0
160	\|\| evt.isActionKey()
161	\|\| keyCode == KeyEvent.VK_BACK_SPACE
162	\|\| keyCode == KeyEvent.VK_DELETE
163	\|\| keyCode == KeyEvent.VK_ENTER
164	\|\| keyCode == KeyEvent.VK_TAB
165	\|\| keyCode == KeyEvent.VK_ESCAPE)
166	{
167	if(grabAction != null)
168	{
169	handleGrabAction(evt);
170	return;
171	}
172
173	KeyStroke keyStroke = KeyStroke.getKeyStroke(keyCode,
174	modifiers);
175	Object o = currentBindings.get(keyStroke);
176	if(o == null)
177	{
178	// Don't beep if the user presses some
179	// key we don't know about unless a
180	// prefix is active. Otherwise it will
181	// beep when caps lock is pressed, etc.
182	if(currentBindings != bindings)
183	{
184	Toolkit.getDefaultToolkit().beep();
185	// F10 should be passed on, but C+e F10
186	// shouldn't
187	repeatCount = 0;
188	repeat = false;
189	evt.consume();
190	}
191	currentBindings = bindings;
192	return;
193	}
194	else if(o instanceof ActionListener)
195	{
196	currentBindings = bindings;
197
198	executeAction(((ActionListener)o),
199	evt.getSource(),null);
200
201	evt.consume();
202	return;
203	}
204	else if(o instanceof Hashtable)
205	{
206	currentBindings = (Hashtable)o;
207	evt.consume();
208	return;
209	}
210	}
211	}
212
213	/**
214	* Handle a key typed event. This inserts the key into the text area.
215	*/
216	public void keyTyped(KeyEvent evt)
217	{
218	int modifiers = evt.getModifiers();
219	char c = evt.getKeyChar();
220	if(c != KeyEvent.CHAR_UNDEFINED &&
221	(modifiers & KeyEvent.ALT_MASK) == 0)
222	{
223	if(c >= 0x20 && c != 0x7f)
224	{
225	KeyStroke keyStroke = KeyStroke.getKeyStroke(
226	Character.toUpperCase(c));
227	Object o = currentBindings.get(keyStroke);
228
229	if(o instanceof Hashtable)
230	{
231	currentBindings = (Hashtable)o;
232	return;
233	}
234	else if(o instanceof ActionListener)
235	{
236	currentBindings = bindings;
237	executeAction((ActionListener)o,
238	evt.getSource(),
239	String.valueOf(c));
240	return;
241	}
242
243	currentBindings = bindings;
244
245	if(grabAction != null)
246	{
247	handleGrabAction(evt);
248	return;
249	}
250
251	// 0-9 adds another 'digit' to the repeat number
252	if(repeat && Character.isDigit(c))
253	{
254	repeatCount *= 10;
255	repeatCount += (c - '0');
256	return;
257	}
258
259	executeAction(INSERT_CHAR,evt.getSource(),
260	String.valueOf(evt.getKeyChar()));
261
262	repeatCount = 0;
263	repeat = false;
264	}
265	}
266	}
267
268	/**
269	* Converts a string to a keystroke. The string should be of the
270	* form <i>modifiers</i>+<i>shortcut</i> where <i>modifiers</i>
271	* is any combination of A for Alt, C for Control, S for Shift
272	* or M for Meta, and <i>shortcut</i> is either a single character,
273	* or a keycode name from the <code>KeyEvent</code> class, without
274	* the <code>VK_</code> prefix.
275	* @param keyStroke A string description of the key stroke
276	*/
277	public static KeyStroke parseKeyStroke(String keyStroke)
278	{
279	if(keyStroke == null)
280	return null;
281	int modifiers = 0;
282	int index = keyStroke.indexOf('+');
283	if(index != -1)
284	{
285	for(int i = 0; i < index; i++)
286	{
287	switch(Character.toUpperCase(keyStroke
288	.charAt(i)))
289	{
290	case 'A':
291	modifiers \|= InputEvent.ALT_MASK;
292	break;
293	case 'C':
294	modifiers \|= InputEvent.CTRL_MASK;
295	break;
296	case 'M':
297	modifiers \|= InputEvent.META_MASK;
298	break;
299	case 'S':
300	modifiers \|= InputEvent.SHIFT_MASK;
301	break;
302	}
303	}
304	}
305	String key = keyStroke.substring(index + 1);
306	if(key.length() == 1)
307	{
308	char ch = Character.toUpperCase(key.charAt(0));
309	if(modifiers == 0)
310	return KeyStroke.getKeyStroke(ch);
311	else
312	return KeyStroke.getKeyStroke(ch,modifiers);
313	}
314	else if(key.length() == 0)
315	{
316	System.err.println("Invalid key stroke: " + keyStroke);
317	return null;
318	}
319	else
320	{
321	int ch;
322
323	try
324	{
325	ch = KeyEvent.class.getField("VK_".concat(key))
326	.getInt(null);
327	}
328	catch(Exception e)
329	{
330	System.err.println("Invalid key stroke: "
331	+ keyStroke);
332	return null;
333	}
334
335	return KeyStroke.getKeyStroke(ch,modifiers);
336	}
337	}
338
339	// private members
340	private Hashtable bindings;
341	private Hashtable currentBindings;
342
343	private DefaultInputHandler(DefaultInputHandler copy)
344	{
345	bindings = currentBindings = copy.bindings;
346	}
347	}

Line 0 Link Here

(-)sources/org/apache/batik/apps/svgbrowser/srcview/XMLTokenMarker.java (+190 lines)
		1	/*
		2	* XMLTokenMarker.java - XML token marker
		3	* Copyright (C) 1998, 1999 Slava Pestov
		4	* Copyright (C) 2001 Tom Bradford
		5	*
		6	* You may use and modify this package for any purpose. Redistribution is
		7	* permitted, in both source and binary form, provided that this notice
		8	* remains intact in all source distributions of this package.
		9	*/
		10	package org.apache.batik.apps.svgbrowser.srcview;
		11
		12	import javax.swing.text.Segment;
		13
		14	/**
		15	* XML Token Marker Rewrite
		16	*
		17	* @author Tom Bradford
		18	* @version $Id: XMLTokenMarker.java,v 1.5 2001/07/29 20:45:43 tom Exp $
		19	*/
		20	public class XMLTokenMarker extends TokenMarker {
		21	public XMLTokenMarker() {
		22	}
		23
		24	public byte markTokensImpl(byte token, Segment line, int lineIndex) {
		25	char[] array = line.array;
		26	int offset = line.offset;
		27	int lastOffset = offset;
		28	int length = line.count + offset;
		29
		30	// Ugly hack to handle multi-line tags
		31	boolean sk1 = token == Token.KEYWORD1;
		32
		33	for ( int i = offset; i < length; i++ ) {
		34	int ip1 = i+1;
		35	char c = array[i];
		36	switch ( token ) {
		37	case Token.NULL: // text
		38	switch ( c ) {
		39	case '<':
		40	addToken(i-lastOffset, token);
		41	lastOffset = i;
		42	if ( SyntaxUtilities.regionMatches(false, line, ip1, "!--") ) {
		43	i += 3;
		44	token = Token.COMMENT1;
		45	}
		46	else if ( array[ip1] == '!' ) {
		47	i += 1;
		48	token = Token.COMMENT2;
		49	}
		50	else if ( array[ip1] == '?' ) {
		51	i += 1;
		52	token = Token.KEYWORD3;
		53	}
		54	else
		55	token = Token.KEYWORD1;
		56	break;
		57
		58	case '&':
		59	addToken(i - lastOffset, token);
		60	lastOffset = i;
		61	token = Token.LABEL;
		62	break;
		63	}
		64	break;
65
66	case Token.KEYWORD1: // tag
67	switch ( c ) {
68	case '>':
69	addToken(ip1-lastOffset, token);
70	lastOffset = ip1;
71	token = Token.NULL;
72	sk1 = false;
73	break;
74
75	case ' ':
76	case '\t':
77	addToken(i-lastOffset, token);
78	lastOffset = i;
79	token = Token.KEYWORD2;
80	sk1 = false;
81	break;
82
83	default:
84	if ( sk1 ) {
85	token = Token.KEYWORD2;
86	sk1 = false;
87	}
88	break;
89	}
90	break;
91
92	case Token.KEYWORD2: // attribute
93	switch ( c ) {
94	case '>':
95	addToken(ip1-lastOffset, token);
96	lastOffset = ip1;
97	token = Token.NULL;
98	break;
99
100	case '/':
101	addToken(i-lastOffset, token);
102	lastOffset = i;
103	token = Token.KEYWORD1;
104	break;
105
106	case '=':
107	addToken(i-lastOffset, token);
108	lastOffset = i;
109	token = Token.OPERATOR;
110	}
111	break;
112
113	case Token.OPERATOR: // equal for attribute
114	switch ( c ) {
115	case '\"':
116	case '\'':
117	addToken(i-lastOffset, token);
118	lastOffset = i;
119	if ( c == '\"' )
120	token = Token.LITERAL1;
121	else
122	token = Token.LITERAL2;
123	break;
124	}
125	break;
126
127	case Token.LITERAL1:
128	case Token.LITERAL2: // strings
129	if ( ( token == Token.LITERAL1 && c == '\"' )
130	\|\| ( token == Token.LITERAL2 && c == '\'' ) ) {
131	addToken(ip1-lastOffset, token);
132	lastOffset = ip1;
133	token = Token.KEYWORD1;
134	}
135	break;
136
137	case Token.LABEL: // entity
138	if ( c == ';' ) {
139	addToken(ip1-lastOffset, token);
140	lastOffset = ip1;
141	token = Token.NULL;
142	break;
143	}
144	break;
145
146	case Token.COMMENT1: // Inside a comment
147	if ( SyntaxUtilities.regionMatches(false, line, i, "-->") ) {
148	addToken((i+3)-lastOffset, token);
149	lastOffset = i+3;
150	token = Token.NULL;
151	}
152	break;
153
154	case Token.COMMENT2: // Inside a declaration
155	if ( SyntaxUtilities.regionMatches(false, line, i, ">") ) {
156	addToken(ip1-lastOffset, token);
157	lastOffset = ip1;
158	token = Token.NULL;
159	}
160	break;
161
162	case Token.KEYWORD3: // Inside a processor instruction
163	if ( SyntaxUtilities.regionMatches(false, line, i, "?>") ) {
164	addToken((i+2)-lastOffset, token);
165	lastOffset = i+2;
166	token = Token.NULL;
167	}
168	break;
169
170	default:
171	throw new InternalError("Invalid state: " + token);
172	}
173	}
174
175	switch ( token ) {
176	case Token.LABEL:
177	addToken(length-lastOffset, Token.INVALID);
178	token = Token.NULL;
179	break;
180
181	default:
182	addToken(length-lastOffset, token);
183	break;
184	}
185
186	return token;
187	}
188	}
189
190

Line 0 Link Here

(-)sources/org/apache/batik/apps/svgbrowser/srcview/TextAreaDefaults.java (+83 lines)
		1	/*
		2	* TextAreaDefaults.java - Encapsulates default values for various settings
		3	* Copyright (C) 1999 Slava Pestov
		4	*
		5	* You may use and modify this package for any purpose. Redistribution is
		6	* permitted, in both source and binary form, provided that this notice
		7	* remains intact in all source distributions of this package.
		8	*/
		9	package org.apache.batik.apps.svgbrowser.srcview;
		10
		11	import javax.swing.JPopupMenu;
		12	import java.awt.Color;
		13
		14	/**
		15	* Encapsulates default settings for a text area. This can be passed
		16	* to the constructor once the necessary fields have been filled out.
		17	* The advantage of doing this over calling lots of set() methods after
		18	* creating the text area is that this method is faster.
		19	*/
		20	public class TextAreaDefaults
		21	{
		22	private static TextAreaDefaults DEFAULTS;
		23
		24	public InputHandler inputHandler;
		25	public SyntaxDocument document;
		26	public boolean editable;
		27
		28	public boolean caretVisible;
		29	public boolean caretBlinks;
		30	public boolean blockCaret;
		31	public int electricScroll;
		32
		33	public int cols;
		34	public int rows;
		35	public SyntaxStyle[] styles;
		36	public Color caretColor;
		37	public Color selectionColor;
		38	public Color lineHighlightColor;
		39	public boolean lineHighlight;
		40	public Color bracketHighlightColor;
		41	public boolean bracketHighlight;
		42	public Color eolMarkerColor;
		43	public boolean eolMarkers;
		44	public boolean paintInvalid;
		45
		46	public JPopupMenu popup;
		47
		48	/**
		49	* Returns a new TextAreaDefaults object with the default values filled
		50	* in.
		51	*/
		52	public static TextAreaDefaults getDefaults()
		53	{
		54	if(DEFAULTS == null)
		55	{
		56	DEFAULTS = new TextAreaDefaults();
		57
		58	DEFAULTS.inputHandler = new DefaultInputHandler();
		59	DEFAULTS.inputHandler.addDefaultKeyBindings();
		60	DEFAULTS.document = new SyntaxDocument();
		61	DEFAULTS.editable = true;
		62
		63	DEFAULTS.caretVisible = true;
		64	DEFAULTS.caretBlinks = true;
65	DEFAULTS.electricScroll = 3;
66
67	DEFAULTS.cols = 80;
68	DEFAULTS.rows = 25;
69	DEFAULTS.styles = SyntaxUtilities.getDefaultSyntaxStyles();
70	DEFAULTS.caretColor = Color.red;
71	DEFAULTS.selectionColor = new Color(0xccccff);
72	DEFAULTS.lineHighlightColor = new Color(0xe0e0e0);
73	DEFAULTS.lineHighlight = true;
74	DEFAULTS.bracketHighlightColor = Color.black;
75	DEFAULTS.bracketHighlight = true;
76	DEFAULTS.eolMarkerColor = new Color(0x009999);
77	DEFAULTS.eolMarkers = true;
78	DEFAULTS.paintInvalid = true;
79	}
80
81	return DEFAULTS;
82	}
83	}

Line 0 Link Here

(-)sources/org/apache/batik/apps/svgbrowser/srcview/SyntaxStyle.java (+136 lines)
		1	/*
		2	* SyntaxStyle.java - A simple text style class
		3	* Copyright (C) 1999 Slava Pestov
		4	*
		5	* You may use and modify this package for any purpose. Redistribution is
		6	* permitted, in both source and binary form, provided that this notice
		7	* remains intact in all source distributions of this package.
		8	*/
		9	package org.apache.batik.apps.svgbrowser.srcview;
		10
		11	import java.awt.*;
		12	import java.util.StringTokenizer;
		13
		14	/**
		15	* A simple text style class. It can specify the color, italic flag,
		16	* and bold flag of a run of text.
		17	* @author Slava Pestov
		18	* @version $Id: SyntaxStyle.java,v 1.6 1999/12/13 03:40:30 sp Exp $
		19	*/
		20	public class SyntaxStyle
		21	{
		22	/**
		23	* Creates a new SyntaxStyle.
		24	* @param color The text color
		25	* @param italic True if the text should be italics
		26	* @param bold True if the text should be bold
		27	*/
		28	public SyntaxStyle(Color color, boolean italic, boolean bold)
		29	{
		30	this.color = color;
		31	this.italic = italic;
		32	this.bold = bold;
		33	}
		34
		35	/**
		36	* Returns the color specified in this style.
		37	*/
		38	public Color getColor()
		39	{
		40	return color;
		41	}
		42
		43	/**
		44	* Returns true if no font styles are enabled.
		45	*/
		46	public boolean isPlain()
		47	{
		48	return !(bold \|\| italic);
		49	}
		50
		51	/**
		52	* Returns true if italics is enabled for this style.
		53	*/
		54	public boolean isItalic()
		55	{
		56	return italic;
		57	}
		58
		59	/**
		60	* Returns true if boldface is enabled for this style.
		61	*/
		62	public boolean isBold()
		63	{
		64	return bold;
65	}
66
67	/**
68	* Returns the specified font, but with the style's bold and
69	* italic flags applied.
70	*/
71	public Font getStyledFont(Font font)
72	{
73	if(font == null)
74	throw new NullPointerException("font param must not"
75	+ " be null");
76	if(font.equals(lastFont))
77	return lastStyledFont;
78	lastFont = font;
79	lastStyledFont = new Font(font.getFamily(),
80	(bold ? Font.BOLD : 0)
81	\| (italic ? Font.ITALIC : 0),
82	font.getSize());
83	return lastStyledFont;
84	}
85
86	/**
87	* Returns the font metrics for the styled font.
88	*/
89	public FontMetrics getFontMetrics(Font font)
90	{
91	if(font == null)
92	throw new NullPointerException("font param must not"
93	+ " be null");
94	if(font.equals(lastFont) && fontMetrics != null)
95	return fontMetrics;
96	lastFont = font;
97	lastStyledFont = new Font(font.getFamily(),
98	(bold ? Font.BOLD : 0)
99	\| (italic ? Font.ITALIC : 0),
100	font.getSize());
101	fontMetrics = Toolkit.getDefaultToolkit().getFontMetrics(
102	lastStyledFont);
103	return fontMetrics;
104	}
105
106	/**
107	* Sets the foreground color and font of the specified graphics
108	* context to that specified in this style.
109	* @param gfx The graphics context
110	* @param font The font to add the styles to
111	*/
112	public void setGraphicsFlags(Graphics gfx, Font font)
113	{
114	Font _font = getStyledFont(font);
115	gfx.setFont(_font);
116	gfx.setColor(color);
117	}
118
119	/**
120	* Returns a string representation of this object.
121	*/
122	public String toString()
123	{
124	return getClass().getName() + "[color=" + color +
125	(italic ? ",italic" : "") +
126	(bold ? ",bold" : "") + "]";
127	}
128
129	// private members
130	private Color color;
131	private boolean italic;
132	private boolean bold;
133	private Font lastFont;
134	private Font lastStyledFont;
135	private FontMetrics fontMetrics;
136	}

Line 0 Link Here

(-)sources/org/apache/batik/apps/svgbrowser/srcview/StatusBar.java (+147 lines)
		1	/*
		2
		3	Licensed to the Apache Software Foundation (ASF) under one or more
		4	contributor license agreements. See the NOTICE file distributed with
		5	this work for additional information regarding copyright ownership.
		6	The ASF licenses this file to You under the Apache License, Version 2.0
		7	(the "License"); you may not use this file except in compliance with
		8	the License. You may obtain a copy of the License at
		9
		10	http://www.apache.org/licenses/LICENSE-2.0
		11
		12	Unless required by applicable law or agreed to in writing, software
		13	distributed under the License is distributed on an "AS IS" BASIS,
		14	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		15	See the License for the specific language governing permissions and
		16	limitations under the License.
		17
		18	*/
		19	package org.apache.batik.apps.svgbrowser.srcview;
		20
		21	import java.awt.Dimension;
		22	import java.util.Locale;
		23	import java.util.MissingResourceException;
		24	import java.util.ResourceBundle;
		25
		26	import javax.swing.BorderFactory;
		27	import javax.swing.Box;
		28	import javax.swing.BoxLayout;
		29	import javax.swing.JLabel;
		30	import javax.swing.JPanel;
		31	import javax.swing.border.BevelBorder;
		32
		33	import org.apache.batik.util.gui.resource.ResourceManager;
		34
		35	/**
		36	* This class represents a viewer status bar.
		37	*
		38	*/
		39	public class StatusBar extends JPanel {
		40
		41	/**
		42	* The gui resources file name
		43	*/
		44	protected static final String RESOURCES =
		45	"org.apache.batik.apps.svgbrowser.srcview.resources.StatusBarMessages";
		46
		47	/**
		48	* The resource bundle
		49	*/
		50	protected static ResourceBundle bundle;
		51
		52	/**
		53	* The resource manager
		54	*/
		55	protected static ResourceManager rManager;
		56
		57	/**
		58	* The string to be used for "Row"
		59	*/
		60	private static String rowStr;
		61
		62	/**
		63	* The string to be used for "Column"
		64	*/
65	private static String colStr;
66
67	static {
68	bundle = ResourceBundle.getBundle(RESOURCES, Locale.getDefault());
69	rManager = new ResourceManager(bundle);
70	rowStr = rManager.getString("Position.row");
71	colStr = rManager.getString("Position.column");
72	}
73
74	/**
75	* The row value
76	*/
77	protected int row;
78
79	/**
80	* The column value
81	*/
82	protected int column;
83
84	/**
85	* The position label.
86	*/
87	protected JLabel position;
88
89	/**
90	* The message label
91	*/
92	protected JLabel message;
93
94	/**
95	* Creates a new status bar.
96	*/
97	public StatusBar() throws MissingResourceException {
98	setLayout(new BoxLayout(this, BoxLayout.X_AXIS));
99	setBorder(BorderFactory.createBevelBorder(BevelBorder.LOWERED));
100
101	position = new JLabel();
102	position.setPreferredSize(new Dimension(110, 16));
103	add(position);
104
105	message = new JLabel();
106	add(message);
107
108	add(Box.createHorizontalGlue());
109	}
110
111	/**
112	* Sets the row.
113	*/
114	public void setRow(int row) {
115	this.row = row;
116	updatePosition();
117	}
118
119	/**
120	* Sets the column.
121	*/
122	public void setColumn(int column) {
123	this.column = column;
124	updatePosition();
125	}
126
127	/**
128	* Sets the row and column together
129	*/
130	public void setPosition(int row, int column) {
131	this.row = row;
132	this.column = column;
133	updatePosition();
134	}
135
136	private void updatePosition() {
137	position.setText(rowStr + " " + row + ", " + colStr + " " + column);
138	}
139
140	/**
141	* Sets the message
142	* @param s the message
143	*/
144	public void setMessage(String s) {
145	message.setText(s);
146	}
147	}

Line 0 Link Here

(-)sources/org/apache/batik/apps/svgbrowser/srcview/Token.java (+149 lines)
		1	/*
		2	* Token.java - Generic token
		3	* Copyright (C) 1998, 1999 Slava Pestov
		4	*
		5	* You may use and modify this package for any purpose. Redistribution is
		6	* permitted, in both source and binary form, provided that this notice
		7	* remains intact in all source distributions of this package.
		8	*/
		9
		10	package org.apache.batik.apps.svgbrowser.srcview;
		11
		12	/**
		13	* A linked list of tokens. Each token has three fields - a token
		14	* identifier, which is a byte value that can be looked up in the
		15	* array returned by <code>SyntaxDocument.getColors()</code>
		16	* to get a color value, a length value which is the length of the
		17	* token in the text, and a pointer to the next token in the list.
		18	*
		19	* @author Slava Pestov
		20	* @version $Id: Token.java,v 1.12 1999/12/13 03:40:30 sp Exp $
		21	*/
		22	public class Token
		23	{
		24	/**
		25	* Normal text token id. This should be used to mark
		26	* normal text.
		27	*/
		28	public static final byte NULL = 0;
		29
		30	/**
		31	* Comment 1 token id. This can be used to mark a comment.
		32	*/
		33	public static final byte COMMENT1 = 1;
		34
		35	/**
		36	* Comment 2 token id. This can be used to mark a comment.
		37	*/
		38	public static final byte COMMENT2 = 2;
		39
		40
		41	/**
		42	* Literal 1 token id. This can be used to mark a string
		43	* literal (eg, C mode uses this to mark "..." literals)
		44	*/
		45	public static final byte LITERAL1 = 3;
		46
		47	/**
		48	* Literal 2 token id. This can be used to mark an object
		49	* literal (eg, Java mode uses this to mark true, false, etc)
		50	*/
		51	public static final byte LITERAL2 = 4;
		52
		53	/**
		54	* Label token id. This can be used to mark labels
		55	* (eg, C mode uses this to mark ...: sequences)
		56	*/
		57	public static final byte LABEL = 5;
		58
		59	/**
		60	* Keyword 1 token id. This can be used to mark a
		61	* keyword. This should be used for general language
		62	* constructs.
		63	*/
		64	public static final byte KEYWORD1 = 6;
65
66	/**
67	* Keyword 2 token id. This can be used to mark a
68	* keyword. This should be used for preprocessor
69	* commands, or variables.
70	*/
71	public static final byte KEYWORD2 = 7;
72
73	/**
74	* Keyword 3 token id. This can be used to mark a
75	* keyword. This should be used for data types.
76	*/
77	public static final byte KEYWORD3 = 8;
78
79	/**
80	* Operator token id. This can be used to mark an
81	* operator. (eg, SQL mode marks +, -, etc with this
82	* token type)
83	*/
84	public static final byte OPERATOR = 9;
85
86	/**
87	* Invalid token id. This can be used to mark invalid
88	* or incomplete tokens, so the user can easily spot
89	* syntax errors.
90	*/
91	public static final byte INVALID = 10;
92
93	/**
94	* The total number of defined token ids.
95	*/
96	public static final byte ID_COUNT = 11;
97
98	/**
99	* The first id that can be used for internal state
100	* in a token marker.
101	*/
102	public static final byte INTERNAL_FIRST = 100;
103
104	/**
105	* The last id that can be used for internal state
106	* in a token marker.
107	*/
108	public static final byte INTERNAL_LAST = 126;
109
110	/**
111	* The token type, that along with a length of 0
112	* marks the end of the token list.
113	*/
114	public static final byte END = 127;
115
116	/**
117	* The length of this token.
118	*/
119	public int length;
120
121	/**
122	* The id of this token.
123	*/
124	public byte id;
125
126	/**
127	* The next token in the linked list.
128	*/
129	public Token next;
130
131	/**
132	* Creates a new token.
133	* @param length The length of the token
134	* @param id The id of the token
135	*/
136	public Token(int length, byte id)
137	{
138	this.length = length;
139	this.id = id;
140	}
141
142	/**
143	* Returns a string representation of this token.
144	*/
145	public String toString()
146	{
147	return "[id=" + id + ",length=" + length + "]";
148	}
149	}

Line 0 Link Here

(-)sources/org/apache/batik/apps/svgbrowser/srcview/TextUtilities.java (+183 lines)
		1	/*
		2	* TextUtilities.java - Utility functions used by the text area classes
		3	* Copyright (C) 1999 Slava Pestov
		4	*
		5	* You may use and modify this package for any purpose. Redistribution is
		6	* permitted, in both source and binary form, provided that this notice
		7	* remains intact in all source distributions of this package.
		8	*/
		9	package org.apache.batik.apps.svgbrowser.srcview;
		10
		11	import javax.swing.text.*;
		12
		13	/**
		14	* Class with several utility functions used by the text area component.
		15	* @author Slava Pestov
		16	* @version $Id: TextUtilities.java,v 1.4 1999/12/13 03:40:30 sp Exp $
		17	*/
		18	public class TextUtilities
		19	{
		20	/**
		21	* Returns the offset of the bracket matching the one at the
		22	* specified offset of the document, or -1 if the bracket is
		23	* unmatched (or if the character is not a bracket).
		24	* @param doc The document
		25	* @param offset The offset
		26	* @exception BadLocationException If an out-of-bounds access
		27	* was attempted on the document text
		28	*/
		29	public static int findMatchingBracket(Document doc, int offset)
		30	throws BadLocationException
		31	{
		32	if(doc.getLength() == 0)
		33	return -1;
		34	char c = doc.getText(offset,1).charAt(0);
		35	char cprime; // c` - corresponding character
		36	boolean direction; // true = back, false = forward
		37
		38	switch(c)
		39	{
		40	case '(': cprime = ')'; direction = false; break;
		41	case ')': cprime = '('; direction = true; break;
		42	case '[': cprime = ']'; direction = false; break;
		43	case ']': cprime = '['; direction = true; break;
		44	case '{': cprime = '}'; direction = false; break;
		45	case '}': cprime = '{'; direction = true; break;
		46	default: return -1;
		47	}
		48
		49	int count;
		50
		51	// How to merge these two cases is left as an exercise
		52	// for the reader.
		53
		54	// Go back or forward
		55	if(direction)
		56	{
		57	// Count is 1 initially because we have already
		58	// `found' one closing bracket
		59	count = 1;
		60
		61	// Get text[0,offset-1];
		62	String text = doc.getText(0,offset);
		63
		64	// Scan backwards
65	for(int i = offset - 1; i >= 0; i--)
66	{
67	// If text[i] == c, we have found another
68	// closing bracket, therefore we will need
69	// two opening brackets to complete the
70	// match.
71	char x = text.charAt(i);
72	if(x == c)
73	count++;
74
75	// If text[i] == cprime, we have found a
76	// opening bracket, so we return i if
77	// --count == 0
78	else if(x == cprime)
79	{
80	if(--count == 0)
81	return i;
82	}
83	}
84	}
85	else
86	{
87	// Count is 1 initially because we have already
88	// `found' one opening bracket
89	count = 1;
90
91	// So we don't have to + 1 in every loop
92	offset++;
93
94	// Number of characters to check
95	int len = doc.getLength() - offset;
96
97	// Get text[offset+1,len];
98	String text = doc.getText(offset,len);
99
100	// Scan forwards
101	for(int i = 0; i < len; i++)
102	{
103	// If text[i] == c, we have found another
104	// opening bracket, therefore we will need
105	// two closing brackets to complete the
106	// match.
107	char x = text.charAt(i);
108
109	if(x == c)
110	count++;
111
112	// If text[i] == cprime, we have found an
113	// closing bracket, so we return i if
114	// --count == 0
115	else if(x == cprime)
116	{
117	if(--count == 0)
118	return i + offset;
119	}
120	}
121	}
122
123	// Nothing found
124	return -1;
125	}
126
127	/**
128	* Locates the start of the word at the specified position.
129	* @param line The text
130	* @param pos The position
131	*/
132	public static int findWordStart(String line, int pos, String noWordSep)
133	{
134	char ch = line.charAt(pos - 1);
135
136	if(noWordSep == null)
137	noWordSep = "";
138	boolean selectNoLetter = (!Character.isLetterOrDigit(ch)
139	&& noWordSep.indexOf(ch) == -1);
140
141	int wordStart = 0;
142	for(int i = pos - 1; i >= 0; i--)
143	{
144	ch = line.charAt(i);
145	if(selectNoLetter ^ (!Character.isLetterOrDigit(ch) &&
146	noWordSep.indexOf(ch) == -1))
147	{
148	wordStart = i + 1;
149	break;
150	}
151	}
152
153	return wordStart;
154	}
155
156	/**
157	* Locates the end of the word at the specified position.
158	* @param line The text
159	* @param pos The position
160	*/
161	public static int findWordEnd(String line, int pos, String noWordSep)
162	{
163	char ch = line.charAt(pos);
164
165	if(noWordSep == null)
166	noWordSep = "";
167	boolean selectNoLetter = (!Character.isLetterOrDigit(ch)
168	&& noWordSep.indexOf(ch) == -1);
169
170	int wordEnd = line.length();
171	for(int i = pos; i < line.length(); i++)
172	{
173	ch = line.charAt(i);
174	if(selectNoLetter ^ (!Character.isLetterOrDigit(ch) &&
175	noWordSep.indexOf(ch) == -1))
176	{
177	wordEnd = i;
178	break;
179	}
180	}
181	return wordEnd;
182	}
183	}

Line 0 Link Here

(-)sources/org/apache/batik/apps/svgbrowser/srcview/KeywordMap.java (+139 lines)
		1	/*
		2	* KeywordMap.java - Fast keyword->id map
		3	* Copyright (C) 1998, 1999 Slava Pestov
		4	* Copyright (C) 1999 Mike Dillon
		5	*
		6	* You may use and modify this package for any purpose. Redistribution is
		7	* permitted, in both source and binary form, provided that this notice
		8	* remains intact in all source distributions of this package.
		9	*/
		10	package org.apache.batik.apps.svgbrowser.srcview;
		11
		12	import javax.swing.text.Segment;
		13
		14	/**
		15	* A <code>KeywordMap</code> is similar to a hashtable in that it maps keys
		16	* to values. However, the `keys' are Swing segments. This allows lookups of
		17	* text substrings without the overhead of creating a new string object.
		18	* <p>
		19	* This class is used by <code>CTokenMarker</code> to map keywords to ids.
		20	*
		21	* @author Slava Pestov, Mike Dillon
		22	* @version $Id: KeywordMap.java,v 1.16 1999/12/13 03:40:30 sp Exp $
		23	*/
		24	public class KeywordMap
		25	{
		26	/**
		27	* Creates a new <code>KeywordMap</code>.
		28	* @param ignoreCase True if keys are case insensitive
		29	*/
		30	public KeywordMap(boolean ignoreCase)
		31	{
		32	this(ignoreCase, 52);
		33	this.ignoreCase = ignoreCase;
		34	}
		35
		36	/**
		37	* Creates a new <code>KeywordMap</code>.
		38	* @param ignoreCase True if the keys are case insensitive
		39	* @param mapLength The number of `buckets' to create.
		40	* A value of 52 will give good performance for most maps.
		41	*/
		42	public KeywordMap(boolean ignoreCase, int mapLength)
		43	{
		44	this.mapLength = mapLength;
		45	this.ignoreCase = ignoreCase;
		46	map = new Keyword[mapLength];
		47	}
		48
		49	/**
		50	* Looks up a key.
		51	* @param text The text segment
		52	* @param offset The offset of the substring within the text segment
		53	* @param length The length of the substring
		54	*/
		55	public byte lookup(Segment text, int offset, int length)
		56	{
		57	if(length == 0)
		58	return Token.NULL;
		59	Keyword k = map[getSegmentMapKey(text, offset, length)];
		60	while(k != null)
		61	{
		62	if(length != k.keyword.length)
		63	{
		64	k = k.next;
65	continue;
66	}
67	if(SyntaxUtilities.regionMatches(ignoreCase,text,offset,
68	k.keyword))
69	return k.id;
70	k = k.next;
71	}
72	return Token.NULL;
73	}
74
75	/**
76	* Adds a key-value mapping.
77	* @param keyword The key
78	* @Param id The value
79	*/
80	public void add(String keyword, byte id)
81	{
82	int key = getStringMapKey(keyword);
83	map[key] = new Keyword(keyword.toCharArray(),id,map[key]);
84	}
85
86	/**
87	* Returns true if the keyword map is set to be case insensitive,
88	* false otherwise.
89	*/
90	public boolean getIgnoreCase()
91	{
92	return ignoreCase;
93	}
94
95	/**
96	* Sets if the keyword map should be case insensitive.
97	* @param ignoreCase True if the keyword map should be case
98	* insensitive, false otherwise
99	*/
100	public void setIgnoreCase(boolean ignoreCase)
101	{
102	this.ignoreCase = ignoreCase;
103	}
104
105	// protected members
106	protected int mapLength;
107
108	protected int getStringMapKey(String s)
109	{
110	return (Character.toUpperCase(s.charAt(0)) +
111	Character.toUpperCase(s.charAt(s.length()-1)))
112	% mapLength;
113	}
114
115	protected int getSegmentMapKey(Segment s, int off, int len)
116	{
117	return (Character.toUpperCase(s.array[off]) +
118	Character.toUpperCase(s.array[off + len - 1]))
119	% mapLength;
120	}
121
122	// private members
123	class Keyword
124	{
125	public Keyword(char[] keyword, byte id, Keyword next)
126	{
127	this.keyword = keyword;
128	this.id = id;
129	this.next = next;
130	}
131
132	public char[] keyword;
133	public byte id;
134	public Keyword next;
135	}
136
137	private Keyword[] map;
138	private boolean ignoreCase;
139	}

Line 0 Link Here

(-)sources/org/apache/batik/apps/svgbrowser/srcview/SyntaxUtilities.java (+157 lines)
		1	/*
		2	* SyntaxUtilities.java - Utility functions used by syntax colorizing
		3	* Copyright (C) 1999 Slava Pestov
		4	*
		5	* You may use and modify this package for any purpose. Redistribution is
		6	* permitted, in both source and binary form, provided that this notice
		7	* remains intact in all source distributions of this package.
		8	*/
		9	package org.apache.batik.apps.svgbrowser.srcview;
		10
		11	import javax.swing.text.*;
		12	import java.awt.*;
		13
		14	/**
		15	* Class with several utility functions used by jEdit's syntax colorizing
		16	* subsystem.
		17	*
		18	* @author Slava Pestov
		19	* @version $Id: SyntaxUtilities.java,v 1.9 1999/12/13 03:40:30 sp Exp $
		20	*/
		21	public class SyntaxUtilities
		22	{
		23	/**
		24	* Checks if a subregion of a <code>Segment</code> is equal to a
		25	* string.
		26	* @param ignoreCase True if case should be ignored, false otherwise
		27	* @param text The segment
		28	* @param offset The offset into the segment
		29	* @param match The string to match
		30	*/
		31	public static boolean regionMatches(boolean ignoreCase, Segment text,
		32	int offset, String match)
		33	{
		34	int length = offset + match.length();
		35	char[] textArray = text.array;
		36	if(length > text.offset + text.count)
		37	return false;
		38	for(int i = offset, j = 0; i < length; i++, j++)
		39	{
		40	char c1 = textArray[i];
		41	char c2 = match.charAt(j);
		42	if(ignoreCase)
		43	{
		44	c1 = Character.toUpperCase(c1);
		45	c2 = Character.toUpperCase(c2);
		46	}
		47	if(c1 != c2)
		48	return false;
		49	}
		50	return true;
		51	}
		52
		53	/**
		54	* Checks if a subregion of a <code>Segment</code> is equal to a
		55	* character array.
		56	* @param ignoreCase True if case should be ignored, false otherwise
		57	* @param text The segment
		58	* @param offset The offset into the segment
		59	* @param match The character array to match
		60	*/
		61	public static boolean regionMatches(boolean ignoreCase, Segment text,
		62	int offset, char[] match)
		63	{
		64	int length = offset + match.length;
65	char[] textArray = text.array;
66	if(length > text.offset + text.count)
67	return false;
68	for(int i = offset, j = 0; i < length; i++, j++)
69	{
70	char c1 = textArray[i];
71	char c2 = match[j];
72	if(ignoreCase)
73	{
74	c1 = Character.toUpperCase(c1);
75	c2 = Character.toUpperCase(c2);
76	}
77	if(c1 != c2)
78	return false;
79	}
80	return true;
81	}
82
83	/**
84	* Returns the default style table. This can be passed to the
85	* <code>setStyles()</code> method of <code>SyntaxDocument</code>
86	* to use the default syntax styles.
87	*/
88	public static SyntaxStyle[] getDefaultSyntaxStyles()
89	{
90	SyntaxStyle[] styles = new SyntaxStyle[Token.ID_COUNT];
91
92	styles[Token.COMMENT1] = new SyntaxStyle(Color.black,true,true);
93	styles[Token.COMMENT2] = new SyntaxStyle(new Color(0x990033),true,true);
94	styles[Token.KEYWORD1] = new SyntaxStyle(Color.black,false,true);
95	styles[Token.KEYWORD2] = new SyntaxStyle(Color.magenta,false,true);
96	styles[Token.KEYWORD3] = new SyntaxStyle(new Color(0x009600),false,false);
97	styles[Token.LITERAL1] = new SyntaxStyle(new Color(0x650099),false,false);
98	styles[Token.LITERAL2] = new SyntaxStyle(new Color(0x650099),false,true);
99	styles[Token.LABEL] = new SyntaxStyle(new Color(0x990033),false,true);
100	styles[Token.OPERATOR] = new SyntaxStyle(Color.black,false,true);
101	styles[Token.INVALID] = new SyntaxStyle(Color.red,false,true);
102
103	return styles;
104	}
105
106	/**
107	* Paints the specified line onto the graphics context. Note that this
108	* method munges the offset and count values of the segment.
109	* @param line The line segment
110	* @param tokens The token list for the line
111	* @param styles The syntax style list
112	* @param expander The tab expander used to determine tab stops. May
113	* be null
114	* @param gfx The graphics context
115	* @param x The x co-ordinate
116	* @param y The y co-ordinate
117	* @return The x co-ordinate, plus the width of the painted string
118	*/
119	public static int paintSyntaxLine(Segment line, Token tokens,
120	SyntaxStyle[] styles, TabExpander expander, Graphics gfx,
121	int x, int y)
122	{
123	Font defaultFont = gfx.getFont();
124	Color defaultColor = gfx.getColor();
125
126	int offset = 0;
127	for(;;)
128	{
129	byte id = tokens.id;
130	if(id == Token.END)
131	break;
132
133	int length = tokens.length;
134	if(id == Token.NULL)
135	{
136	if(!defaultColor.equals(gfx.getColor()))
137	gfx.setColor(defaultColor);
138	if(!defaultFont.equals(gfx.getFont()))
139	gfx.setFont(defaultFont);
140	}
141	else
142	styles[id].setGraphicsFlags(gfx,defaultFont);
143
144	line.count = length;
145	x = Utilities.drawTabbedText(line,x,y,gfx,expander,0);
146	line.offset += length;
147	offset += length;
148
149	tokens = tokens.next;
150	}
151
152	return x;
153	}
154
155	// private members
156	private SyntaxUtilities() {}
157	}

Line 0 Link Here

(-)sources/org/apache/batik/apps/svgbrowser/srcview/TokenMarker.java (+344 lines)
		1	/*
		2	* TokenMarker.java - Generic token marker
		3	* Copyright (C) 1998, 1999 Slava Pestov
		4	*
		5	* You may use and modify this package for any purpose. Redistribution is
		6	* permitted, in both source and binary form, provided that this notice
		7	* remains intact in all source distributions of this package.
		8	*/
		9	package org.apache.batik.apps.svgbrowser.srcview;
		10
		11	import javax.swing.text.Segment;
		12	import java.util.*;
		13
		14	/**
		15	* A token marker that splits lines of text into tokens. Each token carries
		16	* a length field and an indentification tag that can be mapped to a color
		17	* for painting that token.<p>
		18	*
		19	* For performance reasons, the linked list of tokens is reused after each
		20	* line is tokenized. Therefore, the return value of <code>markTokens</code>
		21	* should only be used for immediate painting. Notably, it cannot be
		22	* cached.
		23	*
		24	* @author Slava Pestov
		25	* @version $Id: TokenMarker.java,v 1.32 1999/12/13 03:40:30 sp Exp $
		26	*
		27	* @see org.gjt.sp.jedit.syntax.Token
		28	*/
		29	public abstract class TokenMarker
		30	{
		31	/**
		32	* A wrapper for the lower-level <code>markTokensImpl</code> method
		33	* that is called to split a line up into tokens.
		34	* @param line The line
		35	* @param lineIndex The line number
		36	*/
		37	public Token markTokens(Segment line, int lineIndex)
		38	{
		39	if(lineIndex >= length)
		40	{
		41	throw new IllegalArgumentException("Tokenizing invalid line: "
		42	+ lineIndex);
		43	}
		44
		45	lastToken = null;
		46
		47	LineInfo info = lineInfo[lineIndex];
		48	LineInfo prev;
		49	if(lineIndex == 0)
		50	prev = null;
		51	else
		52	prev = lineInfo[lineIndex - 1];
		53
		54	byte oldToken = info.token;
		55	byte token = markTokensImpl(prev == null ?
		56	Token.NULL : prev.token,line,lineIndex);
		57
		58	info.token = token;
		59
		60	/*
		61	* This is a foul hack. It stops nextLineRequested
		62	* from being cleared if the same line is marked twice.
		63	*
		64	* Why is this necessary? It's all JEditTextArea's fault.
65	* When something is inserted into the text, firing a
66	* document event, the insertUpdate() method shifts the
67	* caret (if necessary) by the amount inserted.
68	*
69	* All caret movement is handled by the select() method,
70	* which eventually pipes the new position to scrollTo()
71	* and calls repaint().
72	*
73	* Note that at this point in time, the new line hasn't
74	* yet been painted; the caret is moved first.
75	*
76	* scrollTo() calls offsetToX(), which tokenizes the line
77	* unless it is being called on the last line painted
78	* (in which case it uses the text area's painter cached
79	* token list). What scrollTo() does next is irrelevant.
80	*
81	* After scrollTo() has done it's job, repaint() is
82	* called, and eventually we end up in paintLine(), whose
83	* job is to paint the changed line. It, too, calls
84	* markTokens().
85	*
86	* The problem was that if the line started a multiline
87	* token, the first markTokens() (done in offsetToX())
88	* would set nextLineRequested (because the line end
89	* token had changed) but the second would clear it
90	* (because the line was the same that time) and therefore
91	* paintLine() would never know that it needed to repaint
92	* subsequent lines.
93	*
94	* This bug took me ages to track down, that's why I wrote
95	* all the relevant info down so that others wouldn't
96	* duplicate it.
97	*/
98	if(!(lastLine == lineIndex && nextLineRequested))
99	nextLineRequested = (oldToken != token);
100
101	lastLine = lineIndex;
102
103	addToken(0,Token.END);
104
105	return firstToken;
106	}
107
108	/**
109	* An abstract method that splits a line up into tokens. It
110	* should parse the line, and call <code>addToken()</code> to
111	* add syntax tokens to the token list. Then, it should return
112	* the initial token type for the next line.<p>
113	*
114	* For example if the current line contains the start of a
115	* multiline comment that doesn't end on that line, this method
116	* should return the comment token type so that it continues on
117	* the next line.
118	*
119	* @param token The initial token type for this line
120	* @param line The line to be tokenized
121	* @param lineIndex The index of the line in the document,
122	* starting at 0
123	* @return The initial token type for the next line
124	*/
125	protected abstract byte markTokensImpl(byte token, Segment line,
126	int lineIndex);
127
128	/**
129	* Returns if the token marker supports tokens that span multiple
130	* lines. If this is true, the object using this token marker is
131	* required to pass all lines in the document to the
132	* <code>markTokens()</code> method (in turn).<p>
133	*
134	* The default implementation returns true; it should be overridden
135	* to return false on simpler token markers for increased speed.
136	*/
137	public boolean supportsMultilineTokens()
138	{
139	return true;
140	}
141
142	/**
143	* Informs the token marker that lines have been inserted into
144	* the document. This inserts a gap in the <code>lineInfo</code>
145	* array.
146	* @param index The first line number
147	* @param lines The number of lines
148	*/
149	public void insertLines(int index, int lines)
150	{
151	if(lines <= 0)
152	return;
153	length += lines;
154	ensureCapacity(length);
155	int len = index + lines;
156	System.arraycopy(lineInfo,index,lineInfo,len,
157	lineInfo.length - len);
158
159	for(int i = index + lines - 1; i >= index; i--)
160	{
161	lineInfo[i] = new LineInfo();
162	}
163	}
164
165	/**
166	* Informs the token marker that line have been deleted from
167	* the document. This removes the lines in question from the
168	* <code>lineInfo</code> array.
169	* @param index The first line number
170	* @param lines The number of lines
171	*/
172	public void deleteLines(int index, int lines)
173	{
174	if (lines <= 0)
175	return;
176	int len = index + lines;
177	length -= lines;
178	System.arraycopy(lineInfo,len,lineInfo,
179	index,lineInfo.length - len);
180	}
181
182	/**
183	* Returns the number of lines in this token marker.
184	*/
185	public int getLineCount()
186	{
187	return length;
188	}
189
190	/**
191	* Returns true if the next line should be repainted. This
192	* will return true after a line has been tokenized that starts
193	* a multiline token that continues onto the next line.
194	*/
195	public boolean isNextLineRequested()
196	{
197	return nextLineRequested;
198	}
199
200	// protected members
201
202	/**
203	* The first token in the list. This should be used as the return
204	* value from <code>markTokens()</code>.
205	*/
206	protected Token firstToken;
207
208	/**
209	* The last token in the list. New tokens are added here.
210	* This should be set to null before a new line is to be tokenized.
211	*/
212	protected Token lastToken;
213
214	/**
215	* An array for storing information about lines. It is enlarged and
216	* shrunk automatically by the <code>insertLines()</code> and
217	* <code>deleteLines()</code> methods.
218	*/
219	protected LineInfo[] lineInfo;
220
221	/**
222	* The number of lines in the model being tokenized. This can be
223	* less than the length of the <code>lineInfo</code> array.
224	*/
225	protected int length;
226
227	/**
228	* The last tokenized line.
229	*/
230	protected int lastLine;
231
232	/**
233	* True if the next line should be painted.
234	*/
235	protected boolean nextLineRequested;
236
237	/**
238	* Creates a new <code>TokenMarker</code>. This DOES NOT create
239	* a lineInfo array; an initial call to <code>insertLines()</code>
240	* does that.
241	*/
242	protected TokenMarker()
243	{
244	lastLine = -1;
245	}
246
247	/**
248	* Ensures that the <code>lineInfo</code> array can contain the
249	* specified index. This enlarges it if necessary. No action is
250	* taken if the array is large enough already.<p>
251	*
252	* It should be unnecessary to call this under normal
253	* circumstances; <code>insertLine()</code> should take care of
254	* enlarging the line info array automatically.
255	*
256	* @param index The array index
257	*/
258	protected void ensureCapacity(int index)
259	{
260	if(lineInfo == null)
261	lineInfo = new LineInfo[index + 1];
262	else if(lineInfo.length <= index)
263	{
264	LineInfo[] lineInfoN = new LineInfo[(index + 1) * 2];
265	System.arraycopy(lineInfo,0,lineInfoN,0,
266	lineInfo.length);
267	lineInfo = lineInfoN;
268	}
269	}
270
271	/**
272	* Adds a token to the token list.
273	* @param length The length of the token
274	* @param id The id of the token
275	*/
276	protected void addToken(int length, byte id)
277	{
278	if(id >= Token.INTERNAL_FIRST && id <= Token.INTERNAL_LAST)
279	throw new InternalError("Invalid id: " + id);
280
281	if(length == 0 && id != Token.END)
282	return;
283
284	if(firstToken == null)
285	{
286	firstToken = new Token(length,id);
287	lastToken = firstToken;
288	}
289	else if(lastToken == null)
290	{
291	lastToken = firstToken;
292	firstToken.length = length;
293	firstToken.id = id;
294	}
295	else if(lastToken.next == null)
296	{
297	lastToken.next = new Token(length,id);
298	lastToken = lastToken.next;
299	}
300	else
301	{
302	lastToken = lastToken.next;
303	lastToken.length = length;
304	lastToken.id = id;
305	}
306	}
307
308	/**
309	* Inner class for storing information about tokenized lines.
310	*/
311	public class LineInfo
312	{
313	/**
314	* Creates a new LineInfo object with token = Token.NULL
315	* and obj = null.
316	*/
317	public LineInfo()
318	{
319	}
320
321	/**
322	* Creates a new LineInfo object with the specified
323	* parameters.
324	*/
325	public LineInfo(byte token, Object obj)
326	{
327	this.token = token;
328	this.obj = obj;
329	}
330
331	/**
332	* The id of the last token of the line.
333	*/
334	public byte token;
335
336	/**
337	* This is for use by the token marker implementations
338	* themselves. It can be used to store anything that
339	* is an object and that needs to exist on a per-line
340	* basis.
341	*/
342	public Object obj;
343	}
344	}

Line 0 Link Here

(-)sources/org/apache/batik/apps/svgbrowser/srcview/SyntaxDocument.java (+165 lines)
		1	/*
		2	* SyntaxDocument.java - Document that can be tokenized
		3	* Copyright (C) 1999 Slava Pestov
		4	*
		5	* You may use and modify this package for any purpose. Redistribution is
		6	* permitted, in both source and binary form, provided that this notice
		7	* remains intact in all source distributions of this package.
		8	*/
		9	package org.apache.batik.apps.svgbrowser.srcview;
		10
		11	import javax.swing.event.*;
		12	import javax.swing.text.*;
		13	import javax.swing.undo.UndoableEdit;
		14
		15	/**
		16	* A document implementation that can be tokenized by the syntax highlighting
		17	* system.
		18	*
		19	* @author Slava Pestov
		20	* @version $Id: SyntaxDocument.java,v 1.14 1999/12/13 03:40:30 sp Exp $
		21	*/
		22	public class SyntaxDocument extends PlainDocument
		23	{
		24	/**
		25	* Returns the token marker that is to be used to split lines
		26	* of this document up into tokens. May return null if this
		27	* document is not to be colorized.
		28	*/
		29	public TokenMarker getTokenMarker()
		30	{
		31	return tokenMarker;
		32	}
		33
		34	/**
		35	* Sets the token marker that is to be used to split lines of
		36	* this document up into tokens. May throw an exception if
		37	* this is not supported for this type of document.
		38	* @param tm The new token marker
		39	*/
		40	public void setTokenMarker(TokenMarker tm)
		41	{
		42	tokenMarker = tm;
		43	if(tm == null)
		44	return;
		45	tokenMarker.insertLines(0,getDefaultRootElement()
		46	.getElementCount());
		47	tokenizeLines();
		48	}
		49
		50	/**
		51	* Reparses the document, by passing all lines to the token
		52	* marker. This should be called after the document is first
		53	* loaded.
		54	*/
		55	public void tokenizeLines()
		56	{
		57	tokenizeLines(0,getDefaultRootElement().getElementCount());
		58	}
		59
		60	/**
		61	* Reparses the document, by passing the specified lines to the
		62	* token marker. This should be called after a large quantity of
		63	* text is first inserted.
		64	* @param start The first line to parse
65	* @param len The number of lines, after the first one to parse
66	*/
67	public void tokenizeLines(int start, int len)
68	{
69	if(tokenMarker == null \|\| !tokenMarker.supportsMultilineTokens())
70	return;
71
72	Segment lineSegment = new Segment();
73	Element map = getDefaultRootElement();
74
75	len += start;
76
77	try
78	{
79	for(int i = start; i < len; i++)
80	{
81	Element lineElement = map.getElement(i);
82	int lineStart = lineElement.getStartOffset();
83	getText(lineStart,lineElement.getEndOffset()
84	- lineStart - 1,lineSegment);
85	tokenMarker.markTokens(lineSegment,i);
86	}
87	}
88	catch(BadLocationException bl)
89	{
90	bl.printStackTrace();
91	}
92	}
93
94	/**
95	* Starts a compound edit that can be undone in one operation.
96	* Subclasses that implement undo should override this method;
97	* this class has no undo functionality so this method is
98	* empty.
99	*/
100	public void beginCompoundEdit() {}
101
102	/**
103	* Ends a compound edit that can be undone in one operation.
104	* Subclasses that implement undo should override this method;
105	* this class has no undo functionality so this method is
106	* empty.
107	*/
108	public void endCompoundEdit() {}
109
110	/**
111	* Adds an undoable edit to this document's undo list. The edit
112	* should be ignored if something is currently being undone.
113	* @param edit The undoable edit
114	*
115	* @since jEdit 2.2pre1
116	*/
117	public void addUndoableEdit(UndoableEdit edit) {}
118
119	// protected members
120	protected TokenMarker tokenMarker;
121
122	/**
123	* We overwrite this method to update the token marker
124	* state immediately so that any event listeners get a
125	* consistent token marker.
126	*/
127	protected void fireInsertUpdate(DocumentEvent evt)
128	{
129	if(tokenMarker != null)
130	{
131	DocumentEvent.ElementChange ch = evt.getChange(
132	getDefaultRootElement());
133	if(ch != null)
134	{
135	tokenMarker.insertLines(ch.getIndex() + 1,
136	ch.getChildrenAdded().length -
137	ch.getChildrenRemoved().length);
138	}
139	}
140
141	super.fireInsertUpdate(evt);
142	}
143
144	/**
145	* We overwrite this method to update the token marker
146	* state immediately so that any event listeners get a
147	* consistent token marker.
148	*/
149	protected void fireRemoveUpdate(DocumentEvent evt)
150	{
151	if(tokenMarker != null)
152	{
153	DocumentEvent.ElementChange ch = evt.getChange(
154	getDefaultRootElement());
155	if(ch != null)
156	{
157	tokenMarker.deleteLines(ch.getIndex() + 1,
158	ch.getChildrenRemoved().length -
159	ch.getChildrenAdded().length);
160	}
161	}
162
163	super.fireRemoveUpdate(evt);
164	}
165	}

Lines 24-32 Link Here

(-)sources/org/apache/batik/util/gui/DOMViewer.java (-1 / +57 lines)
24	import java.awt.event.ActionEvent;	24	import java.awt.event.ActionEvent;
25	import java.awt.event.ItemEvent;	25	import java.awt.event.ItemEvent;
26	import java.awt.event.ItemListener;	26	import java.awt.event.ItemListener;
27
28	import java.util.ArrayList;	27	import java.util.ArrayList;
29	import java.util.Collections;	28	import java.util.Collections;
		29	import java.util.Enumeration;
30	import java.util.HashMap;	30	import java.util.HashMap;
31	import java.util.Locale;	31	import java.util.Locale;
32	import java.util.Map;	32	import java.util.Map;
Lines 52-57 Link Here
52	import javax.swing.tree.DefaultTreeModel;	52	import javax.swing.tree.DefaultTreeModel;
53	import javax.swing.tree.MutableTreeNode;	53	import javax.swing.tree.MutableTreeNode;
54	import javax.swing.tree.TreeNode;	54	import javax.swing.tree.TreeNode;
		55	import javax.swing.tree.TreePath;
55		56
56	import org.apache.batik.bridge.svg12.ContentManager;	57	import org.apache.batik.bridge.svg12.ContentManager;
57	import org.apache.batik.bridge.svg12.DefaultXBLManager;	58	import org.apache.batik.bridge.svg12.DefaultXBLManager;
Lines 170-175 Link Here
170	}	171	}
171		172
172	/**	173	/**
		174	* Sets the node to be selected, none if node is null
		175	*/
		176	public void setSelectionNode(Node node) {
		177	panel.setSelectionNode(node);
		178	}
		179
		180	/**
		181	* Sets the nodes to be selected, none if nodes is null
		182	*/
		183	public void setSelectionNodes(Node[] nodes) {
		184	panel.setSelectionNodes(nodes);
		185	}
		186
		187	/**
173	* Returns the action associated with the given string	188	* Returns the action associated with the given string
174	* or null on error	189	* or null on error
175	* @param key the key mapped with the action to get	190	* @param key the key mapped with the action to get
Lines 412-417 Link Here
412	return result;	427	return result;
413	}	428	}
414		429
		430	public void setSelectionNode(Node node) {
		431	if (node == null) {
		432	setSelectionNodes(null);
		433	} else {
		434	setSelectionNodes(new Node[]{node});
		435	}
		436	}
		437
		438	public void setSelectionNodes(Node[] nodes) {
		439	tree.setSelectionRow(-1);
		440	if (nodes == null) {
		441	return;
		442	}
		443	for (int i = 0; i < nodes.length; i++) {
		444	DefaultMutableTreeNode treeNode = findNode(tree, nodes[i]);
		445	if (treeNode != null) {
		446	TreePath path = new TreePath(treeNode.getPath());
		447	tree.setSelectionPath(path);
		448	}
		449	}
		450	}
		451
		452	/**
		453	* Returns the node in the tree that represents the given node in the
		454	* document, or null if not found.
		455	*/
		456	protected DefaultMutableTreeNode findNode(JTree theTree, Node node) {
		457	DefaultMutableTreeNode root = (DefaultMutableTreeNode) theTree
		458	.getModel().getRoot();
		459	Enumeration treeNodes = root.breadthFirstEnumeration();
		460	while (treeNodes.hasMoreElements()) {
		461	DefaultMutableTreeNode currentNode = (DefaultMutableTreeNode) treeNodes
		462	.nextElement();
		463	NodeInfo userObject = (NodeInfo) currentNode.getUserObject();
		464	if (userObject.getNode() == node) {
		465	return currentNode;
		466	}
		467	}
		468	return null;
		469	}
		470
415	/**	471	/**
416	* To listen to the tree selection.	472	* To listen to the tree selection.
417	*/	473	*/

Line 0 Link Here

(-)sources/org/apache/batik/util/gui/resource/Hyperlink.java (+72 lines)
		1	package org.apache.batik.util.gui.resource;
		2
		3	import java.awt.Cursor;
		4	import java.awt.event.MouseAdapter;
		5	import java.awt.event.MouseEvent;
		6	import java.awt.event.MouseListener;
		7
		8	import javax.swing.JLabel;
		9
		10	public class Hyperlink extends JLabel {
		11	private MouseListener ml = new MouseAdapter() {
		12	public void mouseClicked(MouseEvent e) {
		13	if (callback != null) {
		14	callback.linkClicked(new HyperlinkEvent(Hyperlink.this.getCommand()));
		15	}
		16	}
		17	};
		18
		19	private HyperlinkCallback callback;
		20
		21	private String command;
		22
		23	private static final String HTML_TEXT = "<html><font color=\"blue\"><u>__HTML_TEXT__</u></font></html>";
		24
		25	private String text;
		26
		27	public Hyperlink(String text, HyperlinkCallback callback) {
		28	this.callback = callback;
		29	setLinkText(text);
		30	setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
		31	addMouseListener(ml);
		32	}
		33
		34	public String getLinkText() {
		35	return text;
		36	}
		37
		38	public void setLinkText(String text) {
		39	this.text = text;
		40	super.setText(HTML_TEXT.replace("__HTML_TEXT__", text));
		41	}
		42
		43	public String getCommand() {
		44	return command;
		45	}
		46
		47	public void setCommand(String command) {
		48	this.command = command;
		49	}
		50
		51	public static class HyperlinkEvent {
		52
		53	private String command;
		54
		55	public HyperlinkEvent(String command) {
		56	this.command = command;
		57	}
		58
		59	public String getCommand() {
		60	return command;
		61	}
		62
		63	public void setCommand(String command) {
		64	this.command = command;
65	}
66	}
67
68	public static interface HyperlinkCallback {
69	public void linkClicked(HyperlinkEvent e);
70	}
71	}
72

Line 0 Link Here

(-)sources/org/apache/batik/util/gui/resource/JDocumentTree.java (+375 lines)
		1	package org.apache.batik.util.gui.resource;
		2
		3	import java.awt.BorderLayout;
		4	import java.awt.Color;
		5	import java.awt.Component;
		6	import java.awt.Dimension;
		7	import java.awt.GradientPaint;
		8	import java.awt.Graphics;
		9	import java.awt.Graphics2D;
		10	import java.awt.Paint;
		11	import java.awt.event.MouseAdapter;
		12	import java.awt.event.MouseEvent;
		13	import java.util.ArrayList;
		14	import java.util.Locale;
		15	import java.util.ResourceBundle;
		16
		17	import javax.swing.BorderFactory;
		18	import javax.swing.DefaultListModel;
		19	import javax.swing.ImageIcon;
		20	import javax.swing.JComponent;
		21	import javax.swing.JLabel;
		22	import javax.swing.JList;
		23	import javax.swing.JPanel;
		24	import javax.swing.JScrollBar;
		25	import javax.swing.JScrollPane;
		26	import javax.swing.ListCellRenderer;
		27
		28	import org.w3c.dom.Document;
		29	import org.w3c.dom.NamedNodeMap;
		30	import org.w3c.dom.Node;
		31	import org.w3c.dom.NodeList;
		32
		33	public class JDocumentTree extends JPanel {
		34
		35	/**
		36	* The resource file name
		37	*/
		38	protected static final String RESOURCES = "org.apache.batik.util.gui.resource.resources.JDocumentTree";
		39
		40	/**
		41	* The resource bundle
		42	*/
		43	protected static ResourceBundle bundle;
		44
		45	/**
		46	* The resource manager
		47	*/
		48	protected static ResourceManager resources;
		49
		50	static {
		51	bundle = ResourceBundle.getBundle(RESOURCES, Locale.getDefault());
		52	resources = new ResourceManager(bundle);
		53	}
		54
		55	private JList nodeList;
		56
		57	private JScrollPane nodeListScrollPane;
		58
		59	private DocumentTreeNode rootNode;
		60
		61	public JDocumentTree() {
		62	this(null);
		63	}
		64
65	public JDocumentTree(Document document) {
66	super(new BorderLayout());
67
68	nodeList = new JList(new DefaultListModel()) {
69	public String getToolTipText(MouseEvent e) {
70	int index = locationToIndex(e.getPoint());
71	if (index >= 0) {
72	DocumentTreeNode docTreeNode = (DocumentTreeNode)getModel().getElementAt(index);
73	return docTreeNode.getToolTipText();
74	} else {
75	return null;
76	}
77	}
78	};
79	nodeList.setFixedCellHeight(25);
80	nodeList.setCellRenderer(new DocTreeCellRenderer());
81	nodeListScrollPane = new JScrollPane(nodeList);
82	nodeListScrollPane
83	.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_NEVER);
84	nodeListScrollPane.setBorder(null);
85	add(nodeListScrollPane);
86
87	nodeList.addMouseListener(new MouseAdapter() {
88	public void mouseClicked(MouseEvent e) {
89	if (e.getClickCount() == 2) {
90	DocumentTreeNode selectedNode = (DocumentTreeNode) nodeList
91	.getSelectedValue();
92	selectedNode.setExpanded(!selectedNode.isExpanded());
93	rebuildNodeList(nodeList, rootNode);
94	}
95	}
96	});
97
98	setDocument(document);
99	}
100
101	public void setDocument(Document document) {
102	if (document == null) {
103	DefaultListModel model = (DefaultListModel)nodeList.getModel();
104	model.removeAllElements();
105	} else {
106	Node root = document.getDocumentElement();
107	rootNode = parse(root, null);
108	rebuildNodeList(nodeList, rootNode);
109	}
110	}
111
112	public JScrollBar getVerticalScrollBar() {
113	return nodeListScrollPane.getVerticalScrollBar();
114	}
115
116	public void setVerticalScrollBar(JScrollBar verticalScrollBar) {
117	nodeListScrollPane.setVerticalScrollBar(verticalScrollBar);
118	}
119
120	private void rebuildNodeList(JList nodeList, DocumentTreeNode node) {
121	DefaultListModel listModel = (DefaultListModel) nodeList.getModel();
122	listModel.clear();
123	addNode(listModel, node);
124	}
125
126	private void addNode(DefaultListModel listModel, DocumentTreeNode node) {
127	DocumentTreeNode parent = node.getParent();
128	if (parent == null \|\| parent.isExpanded()) {
129	listModel.addElement(node);
130	DocumentTreeNode[] children = node.getChildren();
131	if (children != null) {
132	for (int i = 0; i < children.length; i++) {
133	addNode(listModel, children[i]);
134	}
135	}
136	}
137	}
138
139	private DocumentTreeNode parse(Node node, DocumentTreeNode parent) {
140	if (node == null) {
141	return null;
142	}
143	ArrayList childDocNodes = null;
144	DocumentTreeNode docNode = new DocumentTreeNode(parent, node
145	.getNodeName(), node.getNodeValue(), Node.ELEMENT_NODE);
146	NamedNodeMap attrMap = node.getAttributes();
147	for (int i = 0; i < attrMap.getLength(); i++) {
148	Node item = attrMap.item(i);
149	int type = item.getNodeType();
150	if (type == Node.ATTRIBUTE_NODE) {
151	if (childDocNodes == null) {
152	childDocNodes = new ArrayList();
153	}
154	DocumentTreeNode attrNode = new DocumentTreeNode(docNode, item.getNodeName(), item.getNodeValue(), Node.ATTRIBUTE_NODE);
155	childDocNodes.add(attrNode);
156	}
157	}
158	NodeList childNodes = node.getChildNodes();
159	for (int i = 0; i < childNodes.getLength(); i++) {
160	Node item = childNodes.item(i);
161	int type = item.getNodeType();
162	if (type == Node.ELEMENT_NODE) {
163	if (childDocNodes == null) {
164	childDocNodes = new ArrayList();
165	}
166	DocumentTreeNode childDocNode = parse(item, docNode);
167	if (childDocNode != null) {
168	childDocNodes.add(childDocNode);
169	}
170	}
171	}
172	if (childDocNodes != null) {
173	docNode.setChildren((DocumentTreeNode[]) childDocNodes
174	.toArray(new DocumentTreeNode[0]));
175	}
176
177	return docNode;
178	}
179
180	private class DocumentTreeNode {
181
182	private String text;
183
184	private String toolTipText;
185
186	private DocumentTreeNode parent;
187
188	private int type;
189
190	private int depth;
191
192	private DocumentTreeNode[] children;
193
194	private boolean expanded = true;
195
196	private boolean locked = false;
197
198	public DocumentTreeNode(DocumentTreeNode parent, String name, String value, int type) {
199	this.parent = parent;
200	this.type = type;
201	this.depth = parent == null ? 0 : parent.depth + 1;
202	this.setText(name);
203	this.setToolTipText(value);
204	}
205
206	public DocumentTreeNode getParent() {
207	return parent;
208	}
209
210	public int getDepth() {
211	return depth;
212	}
213
214	public DocumentTreeNode[] getChildren() {
215	return children;
216	}
217
218	public int getChildCount() {
219	return children == null ? 0 : children.length;
220	}
221
222	public void setChildren(DocumentTreeNode[] children) {
223	this.children = children;
224	if (children != null) {
225	for (int i = 0; i < children.length; i++) {
226	children[i].parent = this;
227	}
228	}
229	}
230
231	public boolean isExpanded() {
232	if (parent == null) {
233	return true;
234	}
235	if (!expanded) {
236	return false;
237	}
238	return parent.isExpanded();
239	}
240
241	public void setExpanded(boolean expanded) {
242	this.expanded = expanded;
243	}
244
245	public String getText() {
246	return text;
247	}
248
249	public void setText(String text) {
250	this.text = text;
251	}
252
253	public int getType() {
254	return type;
255	}
256
257	public void setType(int type) {
258	this.type = type;
259	}
260
261	public String getToolTipText() {
262	return toolTipText;
263	}
264
265	public void setToolTipText(String toolTipText) {
266	this.toolTipText = toolTipText;
267	}
268	}
269
270	private class DocTreeCellRenderer extends JLabel implements
271	ListCellRenderer {
272
273	private class PaintAttributes {
274	public Paint paint, paintHighlight;
275
276	public Color colorText, colorHighlightText;
277	}
278
279	private final ImageIcon SPACER_ICON = getIcon("TreeNodeSpacer.icon");
280
281	private final ImageIcon CLOSED_ICON = getIcon("TreeNodeClosed.icon");
282
283	private final ImageIcon OPENED_ICON = getIcon("TreeNodeOpened.icon");
284
285	private final ImageIcon LEAF_ICON = getIcon("TreeLeaf.icon");
286
287	private final ImageIcon LOCK_ICON = getIcon("TreeNodeLocked.icon");
288
289	private PaintAttributes elementPaint;
290
291	private PaintAttributes attributePaint;
292
293	private boolean selected;
294
295	private int type;
296
297	private boolean locked = true;
298
299	public DocTreeCellRenderer() {
300	setIcon(SPACER_ICON);
301
302	Dimension dim = getPreferredSize();
303	elementPaint = new PaintAttributes();
304	elementPaint.paint = new Color(234, 234, 234);
305	elementPaint.paintHighlight = new GradientPaint(0, 0, Color.gray,
306	0, 2 * dim.height, Color.white);
307	elementPaint.colorText = Color.black;
308	elementPaint.colorHighlightText = Color.white;
309
310	attributePaint = new PaintAttributes();
311	attributePaint.paint = new Color(216, 216, 216);
312	attributePaint.paintHighlight = new GradientPaint(0, 0,
313	Color.darkGray, 0, 2 * dim.height, Color.lightGray);
314	attributePaint.colorText = Color.black;
315	attributePaint.colorHighlightText = Color.white;
316	}
317
318	private ImageIcon getIcon(String name) {
319	return new ImageIcon(JDocumentTree.this.getClass().getResource(
320	resources.getString(name)));
321	}
322
323	protected void paintComponent(Graphics g) {
324	Dimension size = getSize();
325	Graphics2D g2 = (Graphics2D) g;
326	PaintAttributes paintAttributes;
327	switch (type) {
328	case Node.ATTRIBUTE_NODE:
329	paintAttributes = attributePaint;
330	break;
331	case Node.ELEMENT_NODE:
332	default:
333	paintAttributes = elementPaint;
334	break;
335	}
336	g2.setPaint(selected ? paintAttributes.paintHighlight : paintAttributes.paint);
337	g2.fillRect(0, 0, size.width, size.height);
338
339	g2.setColor(Color.lightGray);
340	g2.drawLine(0, size.height - 2, size.width, size.height - 2);
341	g2.setColor(Color.white);
342	g2.drawLine(0, size.height - 1, size.width, size.height - 1);
343
344	setForeground(selected ? paintAttributes.colorHighlightText : paintAttributes.colorText);
345	super.paintComponent(g);
346
347	g.setColor(Color.white);
348	int x, y;
349	x = size.width - 18;
350	y = (size.height - 16) / 2;
351	g.draw3DRect(x, y, 16, 16, false);
352	if (locked) {
353	LOCK_ICON.paintIcon(this, g, x, y);
354	}
355	}
356
357	public Component getListCellRendererComponent(JList list, Object value,
358	int index, boolean selected, boolean cellHasFocus) {
359	DocumentTreeNode node = (DocumentTreeNode) value;
360	this.selected = selected;
361	this.type = node.getType();
362	setText(node.getText());
363	setBorder(BorderFactory.createEmptyBorder(0, node.depth * 10, 0, 0));
364	if (node.getChildren() == null \|\| node.getChildCount() == 0) {// leaf
365	setIcon(LEAF_ICON);
366	} else if (node.isExpanded()) {
367	setIcon(OPENED_ICON);
368	} else {
369	setIcon(CLOSED_ICON);
370	}
371
372	return this;
373	}
374	}
375	}

Line 0 Link Here

(-)sources/org/apache/batik/util/gui/TimelineViewer.java (+222 lines)
		1	package org.apache.batik.util.gui;
		2
		3	import java.awt.BorderLayout;
		4	import java.awt.Container;
		5	import java.awt.Dimension;
		6	import java.awt.event.ActionEvent;
		7	import java.io.File;
		8	import java.util.HashMap;
		9	import java.util.Locale;
		10	import java.util.Map;
		11	import java.util.ResourceBundle;
		12
		13	import javax.swing.AbstractAction;
		14	import javax.swing.Action;
		15	import javax.swing.JDialog;
		16	import javax.swing.JFrame;
		17	import javax.swing.JPanel;
		18	import javax.swing.JScrollBar;
		19	import javax.swing.JSeparator;
		20	import javax.swing.JSplitPane;
		21	import javax.swing.JToolBar;
		22
		23	import org.apache.batik.dom.svg.SAXSVGDocumentFactory;
		24	import org.apache.batik.util.gui.resource.ActionMap;
		25	import org.apache.batik.util.gui.resource.JDocumentTree;
		26	import org.apache.batik.util.gui.resource.JFramesView;
		27	import org.apache.batik.util.gui.resource.MissingListenerException;
		28	import org.apache.batik.util.gui.resource.ResourceManager;
		29	import org.apache.batik.util.gui.resource.ToolBarFactory;
		30	import org.w3c.dom.Document;
		31	import org.w3c.dom.svg.SVGDocument;
		32
		33	public class TimelineViewer extends JFrame implements ActionMap {
		34
		35	/**
		36	* The resource file name
		37	*/
		38	protected static final String RESOURCES = "org.apache.batik.util.gui.resources.TimelineViewer";
		39
		40	/**
		41	* The resource bundle
		42	*/
		43	protected static ResourceBundle bundle;
		44
		45	/**
		46	* The resource manager
		47	*/
		48	protected static ResourceManager resources;
		49
		50	static {
		51	bundle = ResourceBundle.getBundle(RESOURCES, Locale.getDefault());
		52	resources = new ResourceManager(bundle);
		53	}
		54
		55	/**
		56	* The toolbar factory.
		57	*/
		58	protected ToolBarFactory tf = new ToolBarFactory(bundle, this);
		59
		60	private Document document;
		61
		62	private JDocumentTree docTree;
		63
		64	public TimelineViewer() {
65	this(null);
66	}
67
68	public TimelineViewer(Document document) {
69	super("Timeline Viewer");
70
71	Container contentPane = getContentPane();
72	contentPane.setPreferredSize(new Dimension(800, 300));
73
74	JSplitPane splitPane = new JSplitPane();
75	splitPane.setResizeWeight(0.0);
76	JPanel leftPane = new JPanel();
77	splitPane.setLeftComponent(leftPane);
78
79	leftPane.setLayout(new BorderLayout());
80	leftPane.setMinimumSize(new Dimension(300, 0));
81	leftPane.setPreferredSize(getMinimumSize());
82	leftPane.add(createToolBar(), BorderLayout.NORTH);
83
84	JScrollBar scrollBar = new JScrollBar(JScrollBar.VERTICAL, 0, 1, 0, 100);
85	docTree = new JDocumentTree(document);
86	docTree.setVerticalScrollBar(scrollBar);
87	leftPane.add(docTree);
88
89	JFramesView framesView = new JFramesView();
90	framesView.setVerticalScrollBar(scrollBar);
91	splitPane.setRightComponent(framesView);
92	contentPane.add(splitPane);
93
94	pack();
95	}
96
97	private JPanel createToolBar() {
98	JPanel toolbarPanel = new JPanel(new BorderLayout());
99	JToolBar toolbar = tf.createJToolBar("ToolBar");
100	toolbar.setFloatable(false);
101
102	toolbarPanel.add(toolbar);
103	toolbarPanel.add(new JSeparator(), BorderLayout.SOUTH);
104
105	return toolbarPanel;
106	}
107
108	/**
109	* Sets the document to display.
110	*/
111	public void setDocument(Document doc) {
112	document = doc;
113	docTree.setDocument(document);
114	}
115
116
117	/**
118	* The map that contains the actions
119	*/
120	protected Map actions = new HashMap();
121
122	/**
123	* Returns the action associated with the given string or null on error
124	*
125	* @param key
126	* the key mapped with the action to get
127	* @throws MissingListenerException
128	* if the action is not found
129	*/
130	public Action getAction(String key) throws MissingListenerException {
131	return (Action) actions.get(key);
132	}
133
134	/**
135	* The action associated with the 'All' button.
136	*/
137	protected class DisplayAllButtonAction extends AbstractAction {
138
139	public void actionPerformed(ActionEvent evt) {
140	}
141	}
142
143	public static void main(String[] args) throws Exception {
144	File file = new File(System.getProperty("user.home")
145	+ "/Desktop/batikws/xml-batik/rect.svg");
146	SAXSVGDocumentFactory f = new SAXSVGDocumentFactory(null, true);
147	SVGDocument doc = (SVGDocument) f.createDocument(file.toURL()
148	.toString());
149
150	JFrame tv = new TimelineViewer(doc);
151	tv.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
152	tv.setVisible(true);
153	}
154
155	// private class DocTreeCellRenderer extends Box implements
156	// TreeCellRenderer {
157	//
158	// private final ImageIcon SPACER_ICON = getIcon("TreeNodeSpacer.icon");
159	//
160	// private final ImageIcon CLOSED_ICON = getIcon("TreeNodeClosed.icon");
161	//
162	// private final ImageIcon OPENED_ICON = getIcon("TreeNodeOpened.icon");
163	//
164	// private final ImageIcon LEAF_ICON = getIcon("TreeLeaf.icon");
165	//
166	// private Paint gradient;
167	//
168	// private JLabel label;
169	//
170	// private JLabel icon;
171	//
172	// public DocTreeCellRenderer() {
173	// super(BoxLayout.X_AXIS);
174	// setOpaque(false);
175	//
176	// icon = new JLabel(SPACER_ICON);
177	// add(icon);
178	//
179	// label = new JLabel();
180	// add(label);
181	//
182	// Dimension dim = getPreferredSize();
183	// gradient = new GradientPaint(0, 0, Color.white, 0,
184	// 2 * dim.height, Color.gray);
185	// }
186	//
187	// public void setBounds(int x, int y, int width, int height) {
188	// super.setBounds(x, y, docTree.getWidth(), height);
189	// System.out.println(getBounds());
190	// }
191	//
192	// private ImageIcon getIcon(String name) {
193	// String uri = resources.getString(name);
194	// System.out.println(uri);
195	// return new ImageIcon(TimelineViewer.this.getClass().getResource(
196	// uri));
197	// }
198	//
199	// protected void paintComponent(Graphics g) {
200	// Graphics2D g2 = (Graphics2D) g;
201	// g2.setPaint(gradient);
202	// g2.fillRect(0, 0, getWidth(), getHeight());
203	//
204	// super.paintComponent(g);
205	// }
206	//
207	// public Component getTreeCellRendererComponent(JTree tree, Object value,
208	// boolean selected, boolean expanded, boolean leaf, int row,
209	// boolean hasFocus) {
210	// label.setText(value.toString());
211	//
212	// if (leaf) {
213	// icon.setIcon(LEAF_ICON);
214	// } else if (expanded) {
215	// icon.setIcon(OPENED_ICON);
216	// } else {
217	// icon.setIcon(CLOSED_ICON);
218	// }
219	// return this;
220	// }
221	// }
222	}

Line 0 Link Here

(-)resources/org/apache/batik/util/gui/resources/TimelineViewer.properties (+40 lines)
	1	# -----------------------------------------------------------------------------
	2	#
	3	# Licensed to the Apache Software Foundation (ASF) under one or more
	4	# contributor license agreements. See the NOTICE file distributed with
	5	# this work for additional information regarding copyright ownership.
	6	# The ASF licenses this file to You under the Apache License, Version 2.0
	7	# (the "License"); you may not use this file except in compliance with
	8	# the License. You may obtain a copy of the License at
	9	#
	10	# http://www.apache.org/licenses/LICENSE-2.0
	11	#
	12	# Unless required by applicable law or agreed to in writing, software
	13	# distributed under the License is distributed on an "AS IS" BASIS,
	14	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	15	# See the License for the specific language governing permissions and
	16	# limitations under the License.
	17	#
	18	# The resources for the ErrorConsole
	19	#
	20	# Author: singh.jasleen@gmail.com
	21	# $Id: ErrorConsole.properties 475477 2006-11-15 22:44:28Z cam $
	22	# -----------------------------------------------------------------------------
	23
	24	StartButton.icon = resources/start.png
	25	StartButton.tooltip = Start
	26
	27	BackwardButton.icon = resources/backward.png
	28	BackwardButton.tooltip = Backward
	29
	30	PlayButton.icon = resources/play.png
	31	PlayButton.tooltip = Play
	32
	33	ForwardButton.icon = resources/forward.png
	34	ForwardButton.tooltip = Forward
	35
	36	EndButton.icon = resources/end.png
	37	EndButton.tooltip = End
	38
	39	ToolBar = StartButton BackwardButton PlayButton ForwardButton \
	40	EndButton