Back to index...

	/*
	* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package javax.swing;


	import java.awt.*;
	import java.lang.reflect.*;
	import java.net.*;
	import java.util.*;
	import java.io.*;

	import javax.swing.plaf.*;
	import javax.swing.text.*;
	import javax.swing.event.*;
	import javax.swing.text.html.*;
	import javax.accessibility.*;

	/**
	* A text component to edit various kinds of content.
	* You can find how-to information and examples of using editor panes in
	* <a href="https://docs.oracle.com/javase/tutorial/uiswing/components/text.html">Using Text Components</a>,
	* a section in <em>The Java Tutorial.</em>
	*
	* <p>
	* This component uses implementations of the
	* <code>EditorKit</code> to accomplish its behavior. It effectively
	* morphs into the proper kind of text editor for the kind
	* of content it is given. The content type that editor is bound
	* to at any given time is determined by the <code>EditorKit</code> currently
	* installed. If the content is set to a new URL, its type is used
	* to determine the <code>EditorKit</code> that should be used to
	* load the content.
	* <p>
	* By default, the following types of content are known:
	* <dl>
	* <dt><b>text/plain</b>
	* <dd>Plain text, which is the default the type given isn't
	* recognized. The kit used in this case is an extension of
	* <code>DefaultEditorKit</code> that produces a wrapped plain text view.
	* <dt><b>text/html</b>
	* <dd>HTML text. The kit used in this case is the class
	* <code>javax.swing.text.html.HTMLEditorKit</code>
	* which provides HTML 3.2 support.
	* <dt><b>text/rtf</b>
	* <dd>RTF text. The kit used in this case is the class
	* <code>javax.swing.text.rtf.RTFEditorKit</code>
	* which provides a limited support of the Rich Text Format.
	* </dl>
	* <p>
	* There are several ways to load content into this component.
	* <ol>
	* <li>
	* The {@link #setText setText} method can be used to initialize
	* the component from a string. In this case the current
	* <code>EditorKit</code> will be used, and the content type will be
	* expected to be of this type.
	* <li>
	* The {@link #read read} method can be used to initialize the
	* component from a <code>Reader</code>. Note that if the content type is HTML,
	* relative references (e.g. for things like images) can't be resolved
	* unless the <base> tag is used or the <em>Base</em> property
	* on <code>HTMLDocument</code> is set.
	* In this case the current <code>EditorKit</code> will be used,
	* and the content type will be expected to be of this type.
	* <li>
	* The {@link #setPage setPage} method can be used to initialize
	* the component from a URL. In this case, the content type will be
	* determined from the URL, and the registered <code>EditorKit</code>
	* for that content type will be set.
	* </ol>
	* <p>
	* Some kinds of content may provide hyperlink support by generating
	* hyperlink events. The HTML <code>EditorKit</code> will generate
	* hyperlink events if the <code>JEditorPane</code> is <em>not editable</em>
	* (<code>JEditorPane.setEditable(false);</code> has been called).
	* If HTML frames are embedded in the document, the typical response would be
	* to change a portion of the current document. The following code
	* fragment is a possible hyperlink listener implementation, that treats
	* HTML frame events specially, and simply displays any other activated
	* hyperlinks.
	* <pre>

	class Hyperactive implements HyperlinkListener {

	public void hyperlinkUpdate(HyperlinkEvent e) {
	if (e.getEventType() == HyperlinkEvent.EventType.ACTIVATED) {
	JEditorPane pane = (JEditorPane) e.getSource();
	if (e instanceof HTMLFrameHyperlinkEvent) {
	HTMLFrameHyperlinkEvent evt = (HTMLFrameHyperlinkEvent)e;
	HTMLDocument doc = (HTMLDocument)pane.getDocument();
	doc.processHTMLFrameHyperlinkEvent(evt);
	} else {
	try {
	pane.setPage(e.getURL());
	} catch (Throwable t) {
	t.printStackTrace();
	}
	}
	}
	}
	}

	* </pre>
	* <p>
	* For information on customizing how <b>text/html</b> is rendered please see
	* {@link #W3C_LENGTH_UNITS} and {@link #HONOR_DISPLAY_PROPERTIES}
	* <p>
	* Culturally dependent information in some documents is handled through
	* a mechanism called character encoding. Character encoding is an
	* unambiguous mapping of the members of a character set (letters, ideographs,
	* digits, symbols, or control functions) to specific numeric code values. It
	* represents the way the file is stored. Example character encodings are
	* ISO-8859-1, ISO-8859-5, Shift-jis, Euc-jp, and UTF-8. When the file is
	* passed to an user agent (<code>JEditorPane</code>) it is converted to
	* the document character set (ISO-10646 aka Unicode).
	* <p>
	* There are multiple ways to get a character set mapping to happen
	* with <code>JEditorPane</code>.
	* <ol>
	* <li>
	* One way is to specify the character set as a parameter of the MIME
	* type. This will be established by a call to the
	* {@link #setContentType setContentType} method. If the content
	* is loaded by the {@link #setPage setPage} method the content
	* type will have been set according to the specification of the URL.
	* It the file is loaded directly, the content type would be expected to
	* have been set prior to loading.
	* <li>
	* Another way the character set can be specified is in the document itself.
	* This requires reading the document prior to determining the character set
	* that is desired. To handle this, it is expected that the
	* <code>EditorKit</code>.read operation throw a
	* <code>ChangedCharSetException</code> which will
	* be caught. The read is then restarted with a new Reader that uses
	* the character set specified in the <code>ChangedCharSetException</code>
	* (which is an <code>IOException</code>).
	* </ol>
	* <p>
	* <dl>
	* <dt><b><font size=+1>Newlines</font></b>
	* <dd>
	* For a discussion on how newlines are handled, see
	* <a href="text/DefaultEditorKit.html">DefaultEditorKit</a>.
	* </dl>
	*
	* <p>
	* <strong>Warning:</strong> Swing is not thread safe. For more
	* information see <a
	* href="package-summary.html#threading">Swing's Threading
	* Policy</a>.
	* <p>
	* <strong>Warning:</strong>
	* Serialized objects of this class will not be compatible with
	* future Swing releases. The current serialization support is
	* appropriate for short term storage or RMI between applications running
	* the same version of Swing. As of 1.4, support for long term storage
	* of all JavaBeans™
	* has been added to the <code>java.beans</code> package.
	* Please see {@link java.beans.XMLEncoder}.
	*
	* @beaninfo
	* attribute: isContainer false
	* description: A text component to edit various types of content.
	*
	* @author Timothy Prinzing
	*/
	public class JEditorPane extends JTextComponent {

	/**
	* Creates a new <code>JEditorPane</code>.
	* The document model is set to <code>null</code>.
	*/
	public JEditorPane() {
	super();
	setFocusCycleRoot(true);
	setFocusTraversalPolicy(new LayoutFocusTraversalPolicy() {
	public Component getComponentAfter(Container focusCycleRoot,
	Component aComponent) {
	if (focusCycleRoot != JEditorPane.this \|\|
	(!isEditable() && getComponentCount() > 0)) {
	return super.getComponentAfter(focusCycleRoot,
	aComponent);
	} else {
	Container rootAncestor = getFocusCycleRootAncestor();
	return (rootAncestor != null)
	? rootAncestor.getFocusTraversalPolicy().
	getComponentAfter(rootAncestor,
	JEditorPane.this)
	: null;
	}
	}
	public Component getComponentBefore(Container focusCycleRoot,
	Component aComponent) {
	if (focusCycleRoot != JEditorPane.this \|\|
	(!isEditable() && getComponentCount() > 0)) {
	return super.getComponentBefore(focusCycleRoot,
	aComponent);
	} else {
	Container rootAncestor = getFocusCycleRootAncestor();
	return (rootAncestor != null)
	? rootAncestor.getFocusTraversalPolicy().
	getComponentBefore(rootAncestor,
	JEditorPane.this)
	: null;
	}
	}
	public Component getDefaultComponent(Container focusCycleRoot)
	{
	return (focusCycleRoot != JEditorPane.this \|\|
	(!isEditable() && getComponentCount() > 0))
	? super.getDefaultComponent(focusCycleRoot)
	: null;
	}
	protected boolean accept(Component aComponent) {
	return (aComponent != JEditorPane.this)
	? super.accept(aComponent)
	: false;
	}
	});
	LookAndFeel.installProperty(this,
	"focusTraversalKeysForward",
	JComponent.
	getManagingFocusForwardTraversalKeys());
	LookAndFeel.installProperty(this,
	"focusTraversalKeysBackward",
	JComponent.
	getManagingFocusBackwardTraversalKeys());
	}

	/**
	* Creates a <code>JEditorPane</code> based on a specified URL for input.
	*
	* @param initialPage the URL
	* @exception IOException if the URL is <code>null</code>
	* or cannot be accessed
	*/
	public JEditorPane(URL initialPage) throws IOException {
	this();
	setPage(initialPage);
	}

	/**
	* Creates a <code>JEditorPane</code> based on a string containing
	* a URL specification.
	*
	* @param url the URL
	* @exception IOException if the URL is <code>null</code> or
	* cannot be accessed
	*/
	public JEditorPane(String url) throws IOException {
	this();
	setPage(url);
	}

	/**
	* Creates a <code>JEditorPane</code> that has been initialized
	* to the given text. This is a convenience constructor that calls the
	* <code>setContentType</code> and <code>setText</code> methods.
	*
	* @param type mime type of the given text
	* @param text the text to initialize with; may be <code>null</code>
	* @exception NullPointerException if the <code>type</code> parameter
	* is <code>null</code>
	*/
	public JEditorPane(String type, String text) {
	this();
	setContentType(type);
	setText(text);
	}

	/**
	* Adds a hyperlink listener for notification of any changes, for example
	* when a link is selected and entered.
	*
	* @param listener the listener
	*/
	public synchronized void addHyperlinkListener(HyperlinkListener listener) {
	listenerList.add(HyperlinkListener.class, listener);
	}

	/**
	* Removes a hyperlink listener.
	*
	* @param listener the listener
	*/
	public synchronized void removeHyperlinkListener(HyperlinkListener listener) {
	listenerList.remove(HyperlinkListener.class, listener);
	}

	/**
	* Returns an array of all the <code>HyperLinkListener</code>s added
	* to this JEditorPane with addHyperlinkListener().
	*
	* @return all of the <code>HyperLinkListener</code>s added or an empty
	* array if no listeners have been added
	* @since 1.4
	*/
	public synchronized HyperlinkListener[] getHyperlinkListeners() {
	return listenerList.getListeners(javax.swing.event.HyperlinkListener.class);
	}

	/**
	* Notifies all listeners that have registered interest for
	* notification on this event type. This is normally called
	* by the currently installed <code>EditorKit</code> if a content type
	* that supports hyperlinks is currently active and there
	* was activity with a link. The listener list is processed
	* last to first.
	*
	* @param e the event
	* @see EventListenerList
	*/
	public void fireHyperlinkUpdate(HyperlinkEvent e) {
	// Guaranteed to return a non-null array
	Object[] listeners = listenerList.getListenerList();
	// Process the listeners last to first, notifying
	// those that are interested in this event
	for (int i = listeners.length-2; i>=0; i-=2) {
	if (listeners[i]==HyperlinkListener.class) {
	((HyperlinkListener)listeners[i+1]).hyperlinkUpdate(e);
	}
	}
	}


	/**
	* Sets the current URL being displayed. The content type of the
	* pane is set, and if the editor kit for the pane is
	* non-<code>null</code>, then
	* a new default document is created and the URL is read into it.
	* If the URL contains and reference location, the location will
	* be scrolled to by calling the <code>scrollToReference</code>
	* method. If the desired URL is the one currently being displayed,
	* the document will not be reloaded. To force a document
	* reload it is necessary to clear the stream description property
	* of the document. The following code shows how this can be done:
	*
	* <pre>
	* Document doc = jEditorPane.getDocument();
	* doc.putProperty(Document.StreamDescriptionProperty, null);
	* </pre>
	*
	* If the desired URL is not the one currently being
	* displayed, the <code>getStream</code> method is called to
	* give subclasses control over the stream provided.
	* <p>
	* This may load either synchronously or asynchronously
	* depending upon the document returned by the <code>EditorKit</code>.
	* If the <code>Document</code> is of type
	* <code>AbstractDocument</code> and has a value returned by
	* <code>AbstractDocument.getAsynchronousLoadPriority</code>
	* that is greater than or equal to zero, the page will be
	* loaded on a separate thread using that priority.
	* <p>
	* If the document is loaded synchronously, it will be
	* filled in with the stream prior to being installed into
	* the editor with a call to <code>setDocument</code>, which
	* is bound and will fire a property change event. If an
	* <code>IOException</code> is thrown the partially loaded
	* document will
	* be discarded and neither the document or page property
	* change events will be fired. If the document is
	* successfully loaded and installed, a view will be
	* built for it by the UI which will then be scrolled if
	* necessary, and then the page property change event
	* will be fired.
	* <p>
	* If the document is loaded asynchronously, the document
	* will be installed into the editor immediately using a
	* call to <code>setDocument</code> which will fire a
	* document property change event, then a thread will be
	* created which will begin doing the actual loading.
	* In this case, the page property change event will not be
	* fired by the call to this method directly, but rather will be
	* fired when the thread doing the loading has finished.
	* It will also be fired on the event-dispatch thread.
	* Since the calling thread can not throw an <code>IOException</code>
	* in the event of failure on the other thread, the page
	* property change event will be fired when the other
	* thread is done whether the load was successful or not.
	*
	* @param page the URL of the page
	* @exception IOException for a <code>null</code> or invalid
	* page specification, or exception from the stream being read
	* @see #getPage
	* @beaninfo
	* description: the URL used to set content
	* bound: true
	* expert: true
	*/
	public void setPage(URL page) throws IOException {
	if (page == null) {
	throw new IOException("invalid url");
	}
	URL loaded = getPage();


	// reset scrollbar
	if (!page.equals(loaded) && page.getRef() == null) {
	scrollRectToVisible(new Rectangle(0,0,1,1));
	}
	boolean reloaded = false;
	Object postData = getPostData();
	if ((loaded == null) \|\| !loaded.sameFile(page) \|\| (postData != null)) {
	// different url or POST method, load the new content

	int p = getAsynchronousLoadPriority(getDocument());
	if (p < 0) {
	// open stream synchronously
	InputStream in = getStream(page);
	if (kit != null) {
	Document doc = initializeModel(kit, page);

	// At this point, one could either load up the model with no
	// view notifications slowing it down (i.e. best synchronous
	// behavior) or set the model and start to feed it on a separate
	// thread (best asynchronous behavior).
	p = getAsynchronousLoadPriority(doc);
	if (p >= 0) {
	// load asynchronously
	setDocument(doc);
	synchronized(this) {
	pageLoader = new PageLoader(doc, in, loaded, page);
	pageLoader.execute();
	}
	return;
	}
	read(in, doc);
	setDocument(doc);
	reloaded = true;
	}
	} else {
	// we may need to cancel background loading
	if (pageLoader != null) {
	pageLoader.cancel(true);
	}

	// Do everything in a background thread.
	// Model initialization is deferred to that thread, too.
	pageLoader = new PageLoader(null, null, loaded, page);
	pageLoader.execute();
	return;
	}
	}
	final String reference = page.getRef();
	if (reference != null) {
	if (!reloaded) {
	scrollToReference(reference);
	}
	else {
	// Have to scroll after painted.
	SwingUtilities.invokeLater(new Runnable() {
	public void run() {
	scrollToReference(reference);
	}
	});
	}
	getDocument().putProperty(Document.StreamDescriptionProperty, page);
	}
	firePropertyChange("page", loaded, page);
	}

	/**
	* Create model and initialize document properties from page properties.
	*/
	private Document initializeModel(EditorKit kit, URL page) {
	Document doc = kit.createDefaultDocument();
	if (pageProperties != null) {
	// transfer properties discovered in stream to the
	// document property collection.
	for (Enumeration<String> e = pageProperties.keys(); e.hasMoreElements() ;) {
	String key = e.nextElement();
	doc.putProperty(key, pageProperties.get(key));
	}
	pageProperties.clear();
	}
	if (doc.getProperty(Document.StreamDescriptionProperty) == null) {
	doc.putProperty(Document.StreamDescriptionProperty, page);
	}
	return doc;
	}

	/**
	* Return load priority for the document or -1 if priority not supported.
	*/
	private int getAsynchronousLoadPriority(Document doc) {
	return (doc instanceof AbstractDocument ?
	((AbstractDocument) doc).getAsynchronousLoadPriority() : -1);
	}

	/**
	* This method initializes from a stream. If the kit is
	* set to be of type <code>HTMLEditorKit</code>, and the
	* <code>desc</code> parameter is an <code>HTMLDocument</code>,
	* then it invokes the <code>HTMLEditorKit</code> to initiate
	* the read. Otherwise it calls the superclass
	* method which loads the model as plain text.
	*
	* @param in the stream from which to read
	* @param desc an object describing the stream
	* @exception IOException as thrown by the stream being
	* used to initialize
	* @see JTextComponent#read
	* @see #setDocument
	*/
	public void read(InputStream in, Object desc) throws IOException {

	if (desc instanceof HTMLDocument &&
	kit instanceof HTMLEditorKit) {
	HTMLDocument hdoc = (HTMLDocument) desc;
	setDocument(hdoc);
	read(in, hdoc);
	} else {
	String charset = (String) getClientProperty("charset");
	Reader r = (charset != null) ? new InputStreamReader(in, charset) :
	new InputStreamReader(in);
	super.read(r, desc);
	}
	}


	/**
	* This method invokes the <code>EditorKit</code> to initiate a
	* read. In the case where a <code>ChangedCharSetException</code>
	* is thrown this exception will contain the new CharSet.
	* Therefore the <code>read</code> operation
	* is then restarted after building a new Reader with the new charset.
	*
	* @param in the inputstream to use
	* @param doc the document to load
	*
	*/
	void read(InputStream in, Document doc) throws IOException {
	if (! Boolean.TRUE.equals(doc.getProperty("IgnoreCharsetDirective"))) {
	final int READ_LIMIT = 1024 * 10;
	in = new BufferedInputStream(in, READ_LIMIT);
	in.mark(READ_LIMIT);
	}
	try {
	String charset = (String) getClientProperty("charset");
	Reader r = (charset != null) ? new InputStreamReader(in, charset) :
	new InputStreamReader(in);
	kit.read(r, doc, 0);
	} catch (BadLocationException e) {
	throw new IOException(e.getMessage());
	} catch (ChangedCharSetException changedCharSetException) {
	String charSetSpec = changedCharSetException.getCharSetSpec();
	if (changedCharSetException.keyEqualsCharSet()) {
	putClientProperty("charset", charSetSpec);
	} else {
	setCharsetFromContentTypeParameters(charSetSpec);
	}
	try {
	in.reset();
	} catch (IOException exception) {
	//mark was invalidated
	in.close();
	URL url = (URL)doc.getProperty(Document.StreamDescriptionProperty);
	if (url != null) {
	URLConnection conn = url.openConnection();
	in = conn.getInputStream();
	} else {
	//there is nothing we can do to recover stream
	throw changedCharSetException;
	}
	}
	try {
	doc.remove(0, doc.getLength());
	} catch (BadLocationException e) {}
	doc.putProperty("IgnoreCharsetDirective", Boolean.valueOf(true));
	read(in, doc);
	}
	}


	/**
	* Loads a stream into the text document model.
	*/
	class PageLoader extends SwingWorker<URL, Object> {

	/**
	* Construct an asynchronous page loader.
	*/
	PageLoader(Document doc, InputStream in, URL old, URL page) {
	this.in = in;
	this.old = old;
	this.page = page;
	this.doc = doc;
	}

	/**
	* Try to load the document, then scroll the view
	* to the reference (if specified). When done, fire
	* a page property change event.
	*/
	protected URL doInBackground() {
	boolean pageLoaded = false;
	try {
	if (in == null) {
	in = getStream(page);
	if (kit == null) {
	// We received document of unknown content type.
	UIManager.getLookAndFeel().
	provideErrorFeedback(JEditorPane.this);
	return old;
	}
	}

	if (doc == null) {
	try {
	SwingUtilities.invokeAndWait(new Runnable() {
	public void run() {
	doc = initializeModel(kit, page);
	setDocument(doc);
	}
	});
	} catch (InvocationTargetException ex) {
	UIManager.getLookAndFeel().provideErrorFeedback(
	JEditorPane.this);
	return old;
	} catch (InterruptedException ex) {
	UIManager.getLookAndFeel().provideErrorFeedback(
	JEditorPane.this);
	return old;
	}
	}

	read(in, doc);
	URL page = (URL) doc.getProperty(Document.StreamDescriptionProperty);
	String reference = page.getRef();
	if (reference != null) {
	// scroll the page if necessary, but do it on the
	// event thread... that is the only guarantee that
	// modelToView can be safely called.
	Runnable callScrollToReference = new Runnable() {
	public void run() {
	URL u = (URL) getDocument().getProperty
	(Document.StreamDescriptionProperty);
	String ref = u.getRef();
	scrollToReference(ref);
	}
	};
	SwingUtilities.invokeLater(callScrollToReference);
	}
	pageLoaded = true;
	} catch (IOException ioe) {
	UIManager.getLookAndFeel().provideErrorFeedback(JEditorPane.this);
	} finally {
	if (pageLoaded) {
	SwingUtilities.invokeLater(new Runnable() {
	public void run() {
	JEditorPane.this.firePropertyChange("page", old, page);
	}
	});
	}
	return (pageLoaded ? page : old);
	}
	}

	/**
	* The stream to load the document with
	*/
	InputStream in;

	/**
	* URL of the old page that was replaced (for the property change event)
	*/
	URL old;

	/**
	* URL of the page being loaded (for the property change event)
	*/
	URL page;

	/**
	* The Document instance to load into. This is cached in case a
	* new Document is created between the time the thread this is created
	* and run.
	*/
	Document doc;
	}

	/**
	* Fetches a stream for the given URL, which is about to
	* be loaded by the <code>setPage</code> method. By
	* default, this simply opens the URL and returns the
	* stream. This can be reimplemented to do useful things
	* like fetch the stream from a cache, monitor the progress
	* of the stream, etc.
	* <p>
	* This method is expected to have the the side effect of
	* establishing the content type, and therefore setting the
	* appropriate <code>EditorKit</code> to use for loading the stream.
	* <p>
	* If this the stream was an http connection, redirects
	* will be followed and the resulting URL will be set as
	* the <code>Document.StreamDescriptionProperty</code> so that relative
	* URL's can be properly resolved.
	*
	* @param page the URL of the page
	*/
	protected InputStream getStream(URL page) throws IOException {
	final URLConnection conn = page.openConnection();
	if (conn instanceof HttpURLConnection) {
	HttpURLConnection hconn = (HttpURLConnection) conn;
	hconn.setInstanceFollowRedirects(false);
	Object postData = getPostData();
	if (postData != null) {
	handlePostData(hconn, postData);
	}
	int response = hconn.getResponseCode();
	boolean redirect = (response >= 300 && response <= 399);

	/*
	* In the case of a redirect, we want to actually change the URL
	* that was input to the new, redirected URL
	*/
	if (redirect) {
	String loc = conn.getHeaderField("Location");
	if (loc.startsWith("http", 0)) {
	page = new URL(loc);
	} else {
	page = new URL(page, loc);
	}
	return getStream(page);
	}
	}

	// Connection properties handler should be forced to run on EDT,
	// as it instantiates the EditorKit.
	if (SwingUtilities.isEventDispatchThread()) {
	handleConnectionProperties(conn);
	} else {
	try {
	SwingUtilities.invokeAndWait(new Runnable() {
	public void run() {
	handleConnectionProperties(conn);
	}
	});
	} catch (InterruptedException e) {
	throw new RuntimeException(e);
	} catch (InvocationTargetException e) {
	throw new RuntimeException(e);
	}
	}
	return conn.getInputStream();
	}

	/**
	* Handle URL connection properties (most notably, content type).
	*/
	private void handleConnectionProperties(URLConnection conn) {
	if (pageProperties == null) {
	pageProperties = new Hashtable<String, Object>();
	}
	String type = conn.getContentType();
	if (type != null) {
	setContentType(type);
	pageProperties.put("content-type", type);
	}
	pageProperties.put(Document.StreamDescriptionProperty, conn.getURL());
	String enc = conn.getContentEncoding();
	if (enc != null) {
	pageProperties.put("content-encoding", enc);
	}
	}

	private Object getPostData() {
	return getDocument().getProperty(PostDataProperty);
	}

	private void handlePostData(HttpURLConnection conn, Object postData)
	throws IOException {
	conn.setDoOutput(true);
	DataOutputStream os = null;
	try {
	conn.setRequestProperty("Content-Type",
	"application/x-www-form-urlencoded");
	os = new DataOutputStream(conn.getOutputStream());
	os.writeBytes((String) postData);
	} finally {
	if (os != null) {
	os.close();
	}
	}
	}


	/**
	* Scrolls the view to the given reference location
	* (that is, the value returned by the <code>UL.getRef</code>
	* method for the URL being displayed). By default, this
	* method only knows how to locate a reference in an
	* HTMLDocument. The implementation calls the
	* <code>scrollRectToVisible</code> method to
	* accomplish the actual scrolling. If scrolling to a
	* reference location is needed for document types other
	* than HTML, this method should be reimplemented.
	* This method will have no effect if the component
	* is not visible.
	*
	* @param reference the named location to scroll to
	*/
	public void scrollToReference(String reference) {
	Document d = getDocument();
	if (d instanceof HTMLDocument) {
	HTMLDocument doc = (HTMLDocument) d;
	HTMLDocument.Iterator iter = doc.getIterator(HTML.Tag.A);
	for (; iter.isValid(); iter.next()) {
	AttributeSet a = iter.getAttributes();
	String nm = (String) a.getAttribute(HTML.Attribute.NAME);
	if ((nm != null) && nm.equals(reference)) {
	// found a matching reference in the document.
	try {
	int pos = iter.getStartOffset();
	Rectangle r = modelToView(pos);
	if (r != null) {
	// the view is visible, scroll it to the
	// center of the current visible area.
	Rectangle vis = getVisibleRect();
	//r.y -= (vis.height / 2);
	r.height = vis.height;
	scrollRectToVisible(r);
	setCaretPosition(pos);
	}
	} catch (BadLocationException ble) {
	UIManager.getLookAndFeel().provideErrorFeedback(JEditorPane.this);
	}
	}
	}
	}
	}

	/**
	* Gets the current URL being displayed. If a URL was
	* not specified in the creation of the document, this
	* will return <code>null</code>, and relative URL's will not be
	* resolved.
	*
	* @return the URL, or <code>null</code> if none
	*/
	public URL getPage() {
	return (URL) getDocument().getProperty(Document.StreamDescriptionProperty);
	}

	/**
	* Sets the current URL being displayed.
	*
	* @param url the URL for display
	* @exception IOException for a <code>null</code> or invalid URL
	* specification
	*/
	public void setPage(String url) throws IOException {
	if (url == null) {
	throw new IOException("invalid url");
	}
	URL page = new URL(url);
	setPage(page);
	}

	/**
	* Gets the class ID for the UI.
	*
	* @return the string "EditorPaneUI"
	* @see JComponent#getUIClassID
	* @see UIDefaults#getUI
	*/
	public String getUIClassID() {
	return uiClassID;
	}

	/**
	* Creates the default editor kit (<code>PlainEditorKit</code>) for when
	* the component is first created.
	*
	* @return the editor kit
	*/
	protected EditorKit createDefaultEditorKit() {
	return new PlainEditorKit();
	}

	/**
	* Fetches the currently installed kit for handling content.
	* <code>createDefaultEditorKit</code> is called to set up a default
	* if necessary.
	*
	* @return the editor kit
	*/
	public EditorKit getEditorKit() {
	if (kit == null) {
	kit = createDefaultEditorKit();
	isUserSetEditorKit = false;
	}
	return kit;
	}

	/**
	* Gets the type of content that this editor
	* is currently set to deal with. This is
	* defined to be the type associated with the
	* currently installed <code>EditorKit</code>.
	*
	* @return the content type, <code>null</code> if no editor kit set
	*/
	public final String getContentType() {
	return (kit != null) ? kit.getContentType() : null;
	}

	/**
	* Sets the type of content that this editor
	* handles. This calls <code>getEditorKitForContentType</code>,
	* and then <code>setEditorKit</code> if an editor kit can
	* be successfully located. This is mostly convenience method
	* that can be used as an alternative to calling
	* <code>setEditorKit</code> directly.
	* <p>
	* If there is a charset definition specified as a parameter
	* of the content type specification, it will be used when
	* loading input streams using the associated <code>EditorKit</code>.
	* For example if the type is specified as
	* <code>text/html; charset=EUC-JP</code> the content
	* will be loaded using the <code>EditorKit</code> registered for
	* <code>text/html</code> and the Reader provided to
	* the <code>EditorKit</code> to load unicode into the document will
	* use the <code>EUC-JP</code> charset for translating
	* to unicode. If the type is not recognized, the content
	* will be loaded using the <code>EditorKit</code> registered
	* for plain text, <code>text/plain</code>.
	*
	* @param type the non-<code>null</code> mime type for the content editing
	* support
	* @see #getContentType
	* @beaninfo
	* description: the type of content
	* @throws NullPointerException if the <code>type</code> parameter
	* is <code>null</code>
	*/
	public final void setContentType(String type) {
	// The type could have optional info is part of it,
	// for example some charset info. We need to strip that
	// of and save it.
	int parm = type.indexOf(";");
	if (parm > -1) {
	// Save the paramList.
	String paramList = type.substring(parm);
	// update the content type string.
	type = type.substring(0, parm).trim();
	if (type.toLowerCase().startsWith("text/")) {
	setCharsetFromContentTypeParameters(paramList);
	}
	}
	if ((kit == null) \|\| (! type.equals(kit.getContentType()))
	\|\| !isUserSetEditorKit) {
	EditorKit k = getEditorKitForContentType(type);
	if (k != null && k != kit) {
	setEditorKit(k);
	isUserSetEditorKit = false;
	}
	}

	}

	/**
	* This method gets the charset information specified as part
	* of the content type in the http header information.
	*/
	private void setCharsetFromContentTypeParameters(String paramlist) {
	String charset;
	try {
	// paramlist is handed to us with a leading ';', strip it.
	int semi = paramlist.indexOf(';');
	if (semi > -1 && semi < paramlist.length()-1) {
	paramlist = paramlist.substring(semi + 1);
	}

	if (paramlist.length() > 0) {
	// parse the paramlist into attr-value pairs & get the
	// charset pair's value
	HeaderParser hdrParser = new HeaderParser(paramlist);
	charset = hdrParser.findValue("charset");
	if (charset != null) {
	putClientProperty("charset", charset);
	}
	}
	}
	catch (IndexOutOfBoundsException e) {
	// malformed parameter list, use charset we have
	}
	catch (NullPointerException e) {
	// malformed parameter list, use charset we have
	}
	catch (Exception e) {
	// malformed parameter list, use charset we have; but complain
	System.err.println("JEditorPane.getCharsetFromContentTypeParameters failed on: " + paramlist);
	e.printStackTrace();
	}
	}


	/**
	* Sets the currently installed kit for handling
	* content. This is the bound property that
	* establishes the content type of the editor.
	* Any old kit is first deinstalled, then if kit is
	* non-<code>null</code>,
	* the new kit is installed, and a default document created for it.
	* A <code>PropertyChange</code> event ("editorKit") is always fired when
	* <code>setEditorKit</code> is called.
	* <p>
	* <em>NOTE: This has the side effect of changing the model,
	* because the <code>EditorKit</code> is the source of how a
	* particular type
	* of content is modeled. This method will cause <code>setDocument</code>
	* to be called on behalf of the caller to ensure integrity
	* of the internal state.</em>
	*
	* @param kit the desired editor behavior
	* @see #getEditorKit
	* @beaninfo
	* description: the currently installed kit for handling content
	* bound: true
	* expert: true
	*/
	public void setEditorKit(EditorKit kit) {
	EditorKit old = this.kit;
	isUserSetEditorKit = true;
	if (old != null) {
	old.deinstall(this);
	}
	this.kit = kit;
	if (this.kit != null) {
	this.kit.install(this);
	setDocument(this.kit.createDefaultDocument());
	}
	firePropertyChange("editorKit", old, kit);
	}

	/**
	* Fetches the editor kit to use for the given type
	* of content. This is called when a type is requested
	* that doesn't match the currently installed type.
	* If the component doesn't have an <code>EditorKit</code> registered
	* for the given type, it will try to create an
	* <code>EditorKit</code> from the default <code>EditorKit</code> registry.
	* If that fails, a <code>PlainEditorKit</code> is used on the
	* assumption that all text documents can be represented
	* as plain text.
	* <p>
	* This method can be reimplemented to use some
	* other kind of type registry. This can
	* be reimplemented to use the Java Activation
	* Framework, for example.
	*
	* @param type the non-<code>null</code> content type
	* @return the editor kit
	*/
	public EditorKit getEditorKitForContentType(String type) {
	if (typeHandlers == null) {
	typeHandlers = new Hashtable<String, EditorKit>(3);
	}
	EditorKit k = typeHandlers.get(type);
	if (k == null) {
	k = createEditorKitForContentType(type);
	if (k != null) {
	setEditorKitForContentType(type, k);
	}
	}
	if (k == null) {
	k = createDefaultEditorKit();
	}
	return k;
	}

	/**
	* Directly sets the editor kit to use for the given type. A
	* look-and-feel implementation might use this in conjunction
	* with <code>createEditorKitForContentType</code> to install handlers for
	* content types with a look-and-feel bias.
	*
	* @param type the non-<code>null</code> content type
	* @param k the editor kit to be set
	*/
	public void setEditorKitForContentType(String type, EditorKit k) {
	if (typeHandlers == null) {
	typeHandlers = new Hashtable<String, EditorKit>(3);
	}
	typeHandlers.put(type, k);
	}

	/**
	* Replaces the currently selected content with new content
	* represented by the given string. If there is no selection
	* this amounts to an insert of the given text. If there
	* is no replacement text (i.e. the content string is empty
	* or <code>null</code>) this amounts to a removal of the
	* current selection. The replacement text will have the
	* attributes currently defined for input. If the component is not
	* editable, beep and return.
	*
	* @param content the content to replace the selection with. This
	* value can be <code>null</code>
	*/
	@Override
	public void replaceSelection(String content) {
	if (! isEditable()) {
	UIManager.getLookAndFeel().provideErrorFeedback(JEditorPane.this);
	return;
	}
	EditorKit kit = getEditorKit();
	if(kit instanceof StyledEditorKit) {
	try {
	Document doc = getDocument();
	Caret caret = getCaret();
	boolean composedTextSaved = saveComposedText(caret.getDot());
	int p0 = Math.min(caret.getDot(), caret.getMark());
	int p1 = Math.max(caret.getDot(), caret.getMark());
	if (doc instanceof AbstractDocument) {
	((AbstractDocument)doc).replace(p0, p1 - p0, content,
	((StyledEditorKit)kit).getInputAttributes());
	}
	else {
	if (p0 != p1) {
	doc.remove(p0, p1 - p0);
	}
	if (content != null && content.length() > 0) {
	doc.insertString(p0, content, ((StyledEditorKit)kit).
	getInputAttributes());
	}
	}
	if (composedTextSaved) {
	restoreComposedText();
	}
	} catch (BadLocationException e) {
	UIManager.getLookAndFeel().provideErrorFeedback(JEditorPane.this);
	}
	}
	else {
	super.replaceSelection(content);
	}
	}

	/**
	* Creates a handler for the given type from the default registry
	* of editor kits. The registry is created if necessary. If the
	* registered class has not yet been loaded, an attempt
	* is made to dynamically load the prototype of the kit for the
	* given type. If the type was registered with a <code>ClassLoader</code>,
	* that <code>ClassLoader</code> will be used to load the prototype.
	* If there was no registered <code>ClassLoader</code>,
	* <code>Class.forName</code> will be used to load the prototype.
	* <p>
	* Once a prototype <code>EditorKit</code> instance is successfully
	* located, it is cloned and the clone is returned.
	*
	* @param type the content type
	* @return the editor kit, or <code>null</code> if there is nothing
	* registered for the given type
	*/
	public static EditorKit createEditorKitForContentType(String type) {
	Hashtable<String, EditorKit> kitRegistry = getKitRegisty();
	EditorKit k = kitRegistry.get(type);
	if (k == null) {
	// try to dynamically load the support
	String classname = getKitTypeRegistry().get(type);
	ClassLoader loader = getKitLoaderRegistry().get(type);
	try {
	Class c;
	if (loader != null) {
	c = loader.loadClass(classname);
	} else {
	// Will only happen if developer has invoked
	// registerEditorKitForContentType(type, class, null).
	c = Class.forName(classname, true, Thread.currentThread().
	getContextClassLoader());
	}
	k = (EditorKit) c.newInstance();
	kitRegistry.put(type, k);
	} catch (Throwable e) {
	k = null;
	}
	}

	// create a copy of the prototype or null if there
	// is no prototype.
	if (k != null) {
	return (EditorKit) k.clone();
	}
	return null;
	}

	/**
	* Establishes the default bindings of <code>type</code> to
	* <code>classname</code>.
	* The class will be dynamically loaded later when actually
	* needed, and can be safely changed before attempted uses
	* to avoid loading unwanted classes. The prototype
	* <code>EditorKit</code> will be loaded with <code>Class.forName</code>
	* when registered with this method.
	*
	* @param type the non-<code>null</code> content type
	* @param classname the class to load later
	*/
	public static void registerEditorKitForContentType(String type, String classname) {
	registerEditorKitForContentType(type, classname,Thread.currentThread().
	getContextClassLoader());
	}

	/**
	* Establishes the default bindings of <code>type</code> to
	* <code>classname</code>.
	* The class will be dynamically loaded later when actually
	* needed using the given <code>ClassLoader</code>,
	* and can be safely changed
	* before attempted uses to avoid loading unwanted classes.
	*
	* @param type the non-<code>null</code> content type
	* @param classname the class to load later
	* @param loader the <code>ClassLoader</code> to use to load the name
	*/
	public static void registerEditorKitForContentType(String type, String classname, ClassLoader loader) {
	getKitTypeRegistry().put(type, classname);
	if (loader != null) {
	getKitLoaderRegistry().put(type, loader);
	} else {
	getKitLoaderRegistry().remove(type);
	}
	getKitRegisty().remove(type);
	}

	/**
	* Returns the currently registered <code>EditorKit</code>
	* class name for the type <code>type</code>.
	*
	* @param type the non-<code>null</code> content type
	*
	* @since 1.3
	*/
	public static String getEditorKitClassNameForContentType(String type) {
	return getKitTypeRegistry().get(type);
	}

	private static Hashtable<String, String> getKitTypeRegistry() {
	loadDefaultKitsIfNecessary();
	return (Hashtable)SwingUtilities.appContextGet(kitTypeRegistryKey);
	}

	private static Hashtable<String, ClassLoader> getKitLoaderRegistry() {
	loadDefaultKitsIfNecessary();
	return (Hashtable)SwingUtilities.appContextGet(kitLoaderRegistryKey);
	}

	private static Hashtable<String, EditorKit> getKitRegisty() {
	Hashtable ht = (Hashtable)SwingUtilities.appContextGet(kitRegistryKey);
	if (ht == null) {
	ht = new Hashtable(3);
	SwingUtilities.appContextPut(kitRegistryKey, ht);
	}
	return ht;
	}

	/**
	* This is invoked every time the registries are accessed. Loading
	* is done this way instead of via a static as the static is only
	* called once when running in plugin resulting in the entries only
	* appearing in the first applet.
	*/
	private static void loadDefaultKitsIfNecessary() {
	if (SwingUtilities.appContextGet(kitTypeRegistryKey) == null) {
	synchronized(defaultEditorKitMap) {
	if (defaultEditorKitMap.size() == 0) {
	defaultEditorKitMap.put("text/plain",
	"javax.swing.JEditorPane$PlainEditorKit");
	defaultEditorKitMap.put("text/html",
	"javax.swing.text.html.HTMLEditorKit");
	defaultEditorKitMap.put("text/rtf",
	"javax.swing.text.rtf.RTFEditorKit");
	defaultEditorKitMap.put("application/rtf",
	"javax.swing.text.rtf.RTFEditorKit");
	}
	}
	Hashtable ht = new Hashtable();
	SwingUtilities.appContextPut(kitTypeRegistryKey, ht);
	ht = new Hashtable();
	SwingUtilities.appContextPut(kitLoaderRegistryKey, ht);
	for (String key : defaultEditorKitMap.keySet()) {
	registerEditorKitForContentType(key,defaultEditorKitMap.get(key));
	}

	}
	}

	// --- java.awt.Component methods --------------------------

	/**
	* Returns the preferred size for the <code>JEditorPane</code>.
	* The preferred size for <code>JEditorPane</code> is slightly altered
	* from the preferred size of the superclass. If the size
	* of the viewport has become smaller than the minimum size
	* of the component, the scrollable definition for tracking
	* width or height will turn to false. The default viewport
	* layout will give the preferred size, and that is not desired
	* in the case where the scrollable is tracking. In that case
	* the <em>normal</em> preferred size is adjusted to the
	* minimum size. This allows things like HTML tables to
	* shrink down to their minimum size and then be laid out at
	* their minimum size, refusing to shrink any further.
	*
	* @return a <code>Dimension</code> containing the preferred size
	*/
	public Dimension getPreferredSize() {
	Dimension d = super.getPreferredSize();
	Container parent = SwingUtilities.getUnwrappedParent(this);
	if (parent instanceof JViewport) {
	JViewport port = (JViewport) parent;
	TextUI ui = getUI();
	int prefWidth = d.width;
	int prefHeight = d.height;
	if (! getScrollableTracksViewportWidth()) {
	int w = port.getWidth();
	Dimension min = ui.getMinimumSize(this);
	if (w != 0 && w < min.width) {
	// Only adjust to min if we have a valid size
	prefWidth = min.width;
	}
	}
	if (! getScrollableTracksViewportHeight()) {
	int h = port.getHeight();
	Dimension min = ui.getMinimumSize(this);
	if (h != 0 && h < min.height) {
	// Only adjust to min if we have a valid size
	prefHeight = min.height;
	}
	}
	if (prefWidth != d.width \|\| prefHeight != d.height) {
	d = new Dimension(prefWidth, prefHeight);
	}
	}
	return d;
	}

	// --- JTextComponent methods -----------------------------

	/**
	* Sets the text of this <code>TextComponent</code> to the specified
	* content,
	* which is expected to be in the format of the content type of
	* this editor. For example, if the type is set to <code>text/html</code>
	* the string should be specified in terms of HTML.
	* <p>
	* This is implemented to remove the contents of the current document,
	* and replace them by parsing the given string using the current
	* <code>EditorKit</code>. This gives the semantics of the
	* superclass by not changing
	* out the model, while supporting the content type currently set on
	* this component. The assumption is that the previous content is
	* relatively
	* small, and that the previous content doesn't have side effects.
	* Both of those assumptions can be violated and cause undesirable results.
	* To avoid this, create a new document,
	* <code>getEditorKit().createDefaultDocument()</code>, and replace the
	* existing <code>Document</code> with the new one. You are then assured the
	* previous <code>Document</code> won't have any lingering state.
	* <ol>
	* <li>
	* Leaving the existing model in place means that the old view will be
	* torn down, and a new view created, where replacing the document would
	* avoid the tear down of the old view.
	* <li>
	* Some formats (such as HTML) can install things into the document that
	* can influence future contents. HTML can have style information embedded
	* that would influence the next content installed unexpectedly.
	* </ol>
	* <p>
	* An alternative way to load this component with a string would be to
	* create a StringReader and call the read method. In this case the model
	* would be replaced after it was initialized with the contents of the
	* string.
	*
	* @param t the new text to be set; if <code>null</code> the old
	* text will be deleted
	* @see #getText
	* @beaninfo
	* description: the text of this component
	*/
	public void setText(String t) {
	try {
	Document doc = getDocument();
	doc.remove(0, doc.getLength());
	if (t == null \|\| t.equals("")) {
	return;
	}
	Reader r = new StringReader(t);
	EditorKit kit = getEditorKit();
	kit.read(r, doc, 0);
	} catch (IOException ioe) {
	UIManager.getLookAndFeel().provideErrorFeedback(JEditorPane.this);
	} catch (BadLocationException ble) {
	UIManager.getLookAndFeel().provideErrorFeedback(JEditorPane.this);
	}
	}

	/**
	* Returns the text contained in this <code>TextComponent</code>
	* in terms of the
	* content type of this editor. If an exception is thrown while
	* attempting to retrieve the text, <code>null</code> will be returned.
	* This is implemented to call <code>JTextComponent.write</code> with
	* a <code>StringWriter</code>.
	*
	* @return the text
	* @see #setText
	*/
	public String getText() {
	String txt;
	try {
	StringWriter buf = new StringWriter();
	write(buf);
	txt = buf.toString();
	} catch (IOException ioe) {
	txt = null;
	}
	return txt;
	}

	// --- Scrollable ----------------------------------------

	/**
	* Returns true if a viewport should always force the width of this
	* <code>Scrollable</code> to match the width of the viewport.
	*
	* @return true if a viewport should force the Scrollables width to
	* match its own, false otherwise
	*/
	public boolean getScrollableTracksViewportWidth() {
	Container parent = SwingUtilities.getUnwrappedParent(this);
	if (parent instanceof JViewport) {
	JViewport port = (JViewport) parent;
	TextUI ui = getUI();
	int w = port.getWidth();
	Dimension min = ui.getMinimumSize(this);
	Dimension max = ui.getMaximumSize(this);
	if ((w >= min.width) && (w <= max.width)) {
	return true;
	}
	}
	return false;
	}

	/**
	* Returns true if a viewport should always force the height of this
	* <code>Scrollable</code> to match the height of the viewport.
	*
	* @return true if a viewport should force the
	* <code>Scrollable</code>'s height to match its own,
	* false otherwise
	*/
	public boolean getScrollableTracksViewportHeight() {
	Container parent = SwingUtilities.getUnwrappedParent(this);
	if (parent instanceof JViewport) {
	JViewport port = (JViewport) parent;
	TextUI ui = getUI();
	int h = port.getHeight();
	Dimension min = ui.getMinimumSize(this);
	if (h >= min.height) {
	Dimension max = ui.getMaximumSize(this);
	if (h <= max.height) {
	return true;
	}
	}
	}
	return false;
	}

	// --- Serialization ------------------------------------

	/**
	* See <code>readObject</code> and <code>writeObject</code> in
	* <code>JComponent</code> for more
	* information about serialization in Swing.
	*/
	private void writeObject(ObjectOutputStream s) throws IOException {
	s.defaultWriteObject();
	if (getUIClassID().equals(uiClassID)) {
	byte count = JComponent.getWriteObjCounter(this);
	JComponent.setWriteObjCounter(this, --count);
	if (count == 0 && ui != null) {
	ui.installUI(this);
	}
	}
	}

	// --- variables ---------------------------------------

	private SwingWorker<URL, Object> pageLoader;

	/**
	* Current content binding of the editor.
	*/
	private EditorKit kit;
	private boolean isUserSetEditorKit;

	private Hashtable<String, Object> pageProperties;

	/** Should be kept in sync with javax.swing.text.html.FormView counterpart. */
	final static String PostDataProperty = "javax.swing.JEditorPane.postdata";

	/**
	* Table of registered type handlers for this editor.
	*/
	private Hashtable<String, EditorKit> typeHandlers;

	/*
	* Private AppContext keys for this class's static variables.
	*/
	private static final Object kitRegistryKey =
	new StringBuffer("JEditorPane.kitRegistry");
	private static final Object kitTypeRegistryKey =
	new StringBuffer("JEditorPane.kitTypeRegistry");
	private static final Object kitLoaderRegistryKey =
	new StringBuffer("JEditorPane.kitLoaderRegistry");

	/**
	* @see #getUIClassID
	* @see #readObject
	*/
	private static final String uiClassID = "EditorPaneUI";


	/**
	* Key for a client property used to indicate whether
	* <a href="http://www.w3.org/TR/CSS21/syndata.html#length-units">
	* w3c compliant</a> length units are used for html rendering.
	* <p>
	* By default this is not enabled; to enable
	* it set the client {@link #putClientProperty property} with this name
	* to <code>Boolean.TRUE</code>.
	*
	* @since 1.5
	*/
	public static final String W3C_LENGTH_UNITS = "JEditorPane.w3cLengthUnits";

	/**
	* Key for a client property used to indicate whether
	* the default font and foreground color from the component are
	* used if a font or foreground color is not specified in the styled
	* text.
	* <p>
	* The default varies based on the look and feel;
	* to enable it set the client {@link #putClientProperty property} with
	* this name to <code>Boolean.TRUE</code>.
	*
	* @since 1.5
	*/
	public static final String HONOR_DISPLAY_PROPERTIES = "JEditorPane.honorDisplayProperties";

	static final Map<String, String> defaultEditorKitMap = new HashMap<String, String>(0);

	/**
	* Returns a string representation of this <code>JEditorPane</code>.
	* This method
	* is intended to be used only for debugging purposes, and the
	* content and format of the returned string may vary between
	* implementations. The returned string may be empty but may not
	* be <code>null</code>.
	*
	* @return a string representation of this <code>JEditorPane</code>
	*/
	protected String paramString() {
	String kitString = (kit != null ?
	kit.toString() : "");
	String typeHandlersString = (typeHandlers != null ?
	typeHandlers.toString() : "");

	return super.paramString() +
	",kit=" + kitString +
	",typeHandlers=" + typeHandlersString;
	}


	/////////////////
	// Accessibility support
	////////////////


	/**
	* Gets the AccessibleContext associated with this JEditorPane.
	* For editor panes, the AccessibleContext takes the form of an
	* AccessibleJEditorPane.
	* A new AccessibleJEditorPane instance is created if necessary.
	*
	* @return an AccessibleJEditorPane that serves as the
	* AccessibleContext of this JEditorPane
	*/
	public AccessibleContext getAccessibleContext() {
	if (getEditorKit() instanceof HTMLEditorKit) {
	if (accessibleContext == null \|\| accessibleContext.getClass() !=
	AccessibleJEditorPaneHTML.class) {
	accessibleContext = new AccessibleJEditorPaneHTML();
	}
	} else if (accessibleContext == null \|\| accessibleContext.getClass() !=
	AccessibleJEditorPane.class) {
	accessibleContext = new AccessibleJEditorPane();
	}
	return accessibleContext;
	}

	/**
	* This class implements accessibility support for the
	* <code>JEditorPane</code> class. It provides an implementation of the
	* Java Accessibility API appropriate to editor pane user-interface
	* elements.
	* <p>
	* <strong>Warning:</strong>
	* Serialized objects of this class will not be compatible with
	* future Swing releases. The current serialization support is
	* appropriate for short term storage or RMI between applications running
	* the same version of Swing. As of 1.4, support for long term storage
	* of all JavaBeans™
	* has been added to the <code>java.beans</code> package.
	* Please see {@link java.beans.XMLEncoder}.
	*/
	protected class AccessibleJEditorPane extends AccessibleJTextComponent {

	/**
	* Gets the accessibleDescription property of this object. If this
	* property isn't set, returns the content type of this
	* <code>JEditorPane</code> instead (e.g. "plain/text", "html/text").
	*
	* @return the localized description of the object; <code>null</code>
	* if this object does not have a description
	*
	* @see #setAccessibleName
	*/
	public String getAccessibleDescription() {
	String description = accessibleDescription;

	// fallback to client property
	if (description == null) {
	description = (String)getClientProperty(AccessibleContext.ACCESSIBLE_DESCRIPTION_PROPERTY);
	}
	if (description == null) {
	description = JEditorPane.this.getContentType();
	}
	return description;
	}

	/**
	* Gets the state set of this object.
	*
	* @return an instance of AccessibleStateSet describing the states
	* of the object
	* @see AccessibleStateSet
	*/
	public AccessibleStateSet getAccessibleStateSet() {
	AccessibleStateSet states = super.getAccessibleStateSet();
	states.add(AccessibleState.MULTI_LINE);
	return states;
	}
	}

	/**
	* This class provides support for <code>AccessibleHypertext</code>,
	* and is used in instances where the <code>EditorKit</code>
	* installed in this <code>JEditorPane</code> is an instance of
	* <code>HTMLEditorKit</code>.
	* <p>
	* <strong>Warning:</strong>
	* Serialized objects of this class will not be compatible with
	* future Swing releases. The current serialization support is
	* appropriate for short term storage or RMI between applications running
	* the same version of Swing. As of 1.4, support for long term storage
	* of all JavaBeans™
	* has been added to the <code>java.beans</code> package.
	* Please see {@link java.beans.XMLEncoder}.
	*/
	protected class AccessibleJEditorPaneHTML extends AccessibleJEditorPane {

	private AccessibleContext accessibleContext;

	public AccessibleText getAccessibleText() {
	return new JEditorPaneAccessibleHypertextSupport();
	}

	protected AccessibleJEditorPaneHTML () {
	HTMLEditorKit kit = (HTMLEditorKit)JEditorPane.this.getEditorKit();
	accessibleContext = kit.getAccessibleContext();
	}

	/**
	* Returns the number of accessible children of the object.
	*
	* @return the number of accessible children of the object.
	*/
	public int getAccessibleChildrenCount() {
	if (accessibleContext != null) {
	return accessibleContext.getAccessibleChildrenCount();
	} else {
	return 0;
	}
	}

	/**
	* Returns the specified Accessible child of the object. The Accessible
	* children of an Accessible object are zero-based, so the first child
	* of an Accessible child is at index 0, the second child is at index 1,
	* and so on.
	*
	* @param i zero-based index of child
	* @return the Accessible child of the object
	* @see #getAccessibleChildrenCount
	*/
	public Accessible getAccessibleChild(int i) {
	if (accessibleContext != null) {
	return accessibleContext.getAccessibleChild(i);
	} else {
	return null;
	}
	}

	/**
	* Returns the Accessible child, if one exists, contained at the local
	* coordinate Point.
	*
	* @param p The point relative to the coordinate system of this object.
	* @return the Accessible, if it exists, at the specified location;
	* otherwise null
	*/
	public Accessible getAccessibleAt(Point p) {
	if (accessibleContext != null && p != null) {
	try {
	AccessibleComponent acomp =
	accessibleContext.getAccessibleComponent();
	if (acomp != null) {
	return acomp.getAccessibleAt(p);
	} else {
	return null;
	}
	} catch (IllegalComponentStateException e) {
	return null;
	}
	} else {
	return null;
	}
	}
	}

	/**
	* What's returned by
	* <code>AccessibleJEditorPaneHTML.getAccessibleText</code>.
	*
	* Provides support for <code>AccessibleHypertext</code> in case
	* there is an HTML document being displayed in this
	* <code>JEditorPane</code>.
	*
	*/
	protected class JEditorPaneAccessibleHypertextSupport
	extends AccessibleJEditorPane implements AccessibleHypertext {

	public class HTMLLink extends AccessibleHyperlink {
	Element element;

	public HTMLLink(Element e) {
	element = e;
	}

	/**
	* Since the document a link is associated with may have
	* changed, this method returns whether this Link is valid
	* anymore (with respect to the document it references).
	*
	* @return a flag indicating whether this link is still valid with
	* respect to the AccessibleHypertext it belongs to
	*/
	public boolean isValid() {
	return JEditorPaneAccessibleHypertextSupport.this.linksValid;
	}

	/**
	* Returns the number of accessible actions available in this Link
	* If there are more than one, the first one is NOT considered the
	* "default" action of this LINK object (e.g. in an HTML imagemap).
	* In general, links will have only one AccessibleAction in them.
	*
	* @return the zero-based number of Actions in this object
	*/
	public int getAccessibleActionCount() {
	return 1;
	}

	/**
	* Perform the specified Action on the object
	*
	* @param i zero-based index of actions
	* @return true if the the action was performed; else false.
	* @see #getAccessibleActionCount
	*/
	public boolean doAccessibleAction(int i) {
	if (i == 0 && isValid() == true) {
	URL u = (URL) getAccessibleActionObject(i);
	if (u != null) {
	HyperlinkEvent linkEvent =
	new HyperlinkEvent(JEditorPane.this, HyperlinkEvent.EventType.ACTIVATED, u);
	JEditorPane.this.fireHyperlinkUpdate(linkEvent);
	return true;
	}
	}
	return false; // link invalid or i != 0
	}

	/**
	* Return a String description of this particular
	* link action. The string returned is the text
	* within the document associated with the element
	* which contains this link.
	*
	* @param i zero-based index of the actions
	* @return a String description of the action
	* @see #getAccessibleActionCount
	*/
	public String getAccessibleActionDescription(int i) {
	if (i == 0 && isValid() == true) {
	Document d = JEditorPane.this.getDocument();
	if (d != null) {
	try {
	return d.getText(getStartIndex(),
	getEndIndex() - getStartIndex());
	} catch (BadLocationException exception) {
	return null;
	}
	}
	}
	return null;
	}

	/**
	* Returns a URL object that represents the link.
	*
	* @param i zero-based index of the actions
	* @return an URL representing the HTML link itself
	* @see #getAccessibleActionCount
	*/
	public Object getAccessibleActionObject(int i) {
	if (i == 0 && isValid() == true) {
	AttributeSet as = element.getAttributes();
	AttributeSet anchor =
	(AttributeSet) as.getAttribute(HTML.Tag.A);
	String href = (anchor != null) ?
	(String) anchor.getAttribute(HTML.Attribute.HREF) : null;
	if (href != null) {
	URL u;
	try {
	u = new URL(JEditorPane.this.getPage(), href);
	} catch (MalformedURLException m) {
	u = null;
	}
	return u;
	}
	}
	return null; // link invalid or i != 0
	}

	/**
	* Return an object that represents the link anchor,
	* as appropriate for that link. E.g. from HTML:
	* <a href="http://www.sun.com/access">Accessibility</a>
	* this method would return a String containing the text:
	* 'Accessibility'.
	*
	* Similarly, from this HTML:
	* <a HREF="#top"><img src="top-hat.gif" alt="top hat"></a>
	* this might return the object ImageIcon("top-hat.gif", "top hat");
	*
	* @param i zero-based index of the actions
	* @return an Object representing the hypertext anchor
	* @see #getAccessibleActionCount
	*/
	public Object getAccessibleActionAnchor(int i) {
	return getAccessibleActionDescription(i);
	}


	/**
	* Get the index with the hypertext document at which this
	* link begins
	*
	* @return index of start of link
	*/
	public int getStartIndex() {
	return element.getStartOffset();
	}

	/**
	* Get the index with the hypertext document at which this
	* link ends
	*
	* @return index of end of link
	*/
	public int getEndIndex() {
	return element.getEndOffset();
	}
	}

	private class LinkVector extends Vector<HTMLLink> {
	public int baseElementIndex(Element e) {
	HTMLLink l;
	for (int i = 0; i < elementCount; i++) {
	l = elementAt(i);
	if (l.element == e) {
	return i;
	}
	}
	return -1;
	}
	}

	LinkVector hyperlinks;
	boolean linksValid = false;

	/**
	* Build the private table mapping links to locations in the text
	*/
	private void buildLinkTable() {
	hyperlinks.removeAllElements();
	Document d = JEditorPane.this.getDocument();
	if (d != null) {
	ElementIterator ei = new ElementIterator(d);
	Element e;
	AttributeSet as;
	AttributeSet anchor;
	String href;
	while ((e = ei.next()) != null) {
	if (e.isLeaf()) {
	as = e.getAttributes();
	anchor = (AttributeSet) as.getAttribute(HTML.Tag.A);
	href = (anchor != null) ?
	(String) anchor.getAttribute(HTML.Attribute.HREF) : null;
	if (href != null) {
	hyperlinks.addElement(new HTMLLink(e));
	}
	}
	}
	}
	linksValid = true;
	}

	/**
	* Make one of these puppies
	*/
	public JEditorPaneAccessibleHypertextSupport() {
	hyperlinks = new LinkVector();
	Document d = JEditorPane.this.getDocument();
	if (d != null) {
	d.addDocumentListener(new DocumentListener() {
	public void changedUpdate(DocumentEvent theEvent) {
	linksValid = false;
	}
	public void insertUpdate(DocumentEvent theEvent) {
	linksValid = false;
	}
	public void removeUpdate(DocumentEvent theEvent) {
	linksValid = false;
	}
	});
	}
	}

	/**
	* Returns the number of links within this hypertext doc.
	*
	* @return number of links in this hypertext doc.
	*/
	public int getLinkCount() {
	if (linksValid == false) {
	buildLinkTable();
	}
	return hyperlinks.size();
	}

	/**
	* Returns the index into an array of hyperlinks that
	* is associated with this character index, or -1 if there
	* is no hyperlink associated with this index.
	*
	* @param charIndex index within the text
	* @return index into the set of hyperlinks for this hypertext doc.
	*/
	public int getLinkIndex(int charIndex) {
	if (linksValid == false) {
	buildLinkTable();
	}
	Element e = null;
	Document doc = JEditorPane.this.getDocument();
	if (doc != null) {
	for (e = doc.getDefaultRootElement(); ! e.isLeaf(); ) {
	int index = e.getElementIndex(charIndex);
	e = e.getElement(index);
	}
	}

	// don't need to verify that it's an HREF element; if
	// not, then it won't be in the hyperlinks Vector, and
	// so indexOf will return -1 in any case
	return hyperlinks.baseElementIndex(e);
	}

	/**
	* Returns the index into an array of hyperlinks that
	* index. If there is no hyperlink at this index, it returns
	* null.
	*
	* @param linkIndex into the set of hyperlinks for this hypertext doc.
	* @return string representation of the hyperlink
	*/
	public AccessibleHyperlink getLink(int linkIndex) {
	if (linksValid == false) {
	buildLinkTable();
	}
	if (linkIndex >= 0 && linkIndex < hyperlinks.size()) {
	return hyperlinks.elementAt(linkIndex);
	} else {
	return null;
	}
	}

	/**
	* Returns the contiguous text within the document that
	* is associated with this hyperlink.
	*
	* @param linkIndex into the set of hyperlinks for this hypertext doc.
	* @return the contiguous text sharing the link at this index
	*/
	public String getLinkText(int linkIndex) {
	if (linksValid == false) {
	buildLinkTable();
	}
	Element e = (Element) hyperlinks.elementAt(linkIndex);
	if (e != null) {
	Document d = JEditorPane.this.getDocument();
	if (d != null) {
	try {
	return d.getText(e.getStartOffset(),
	e.getEndOffset() - e.getStartOffset());
	} catch (BadLocationException exception) {
	return null;
	}
	}
	}
	return null;
	}
	}

	static class PlainEditorKit extends DefaultEditorKit implements ViewFactory {

	/**
	* Fetches a factory that is suitable for producing
	* views of any models that are produced by this
	* kit. The default is to have the UI produce the
	* factory, so this method has no implementation.
	*
	* @return the view factory
	*/
	public ViewFactory getViewFactory() {
	return this;
	}

	/**
	* Creates a view from the given structural element of a
	* document.
	*
	* @param elem the piece of the document to build a view of
	* @return the view
	* @see View
	*/
	public View create(Element elem) {
	Document doc = elem.getDocument();
	Object i18nFlag
	= doc.getProperty("i18n"/AbstractDocument.I18NProperty/);
	if ((i18nFlag != null) && i18nFlag.equals(Boolean.TRUE)) {
	// build a view that support bidi
	return createI18N(elem);
	} else {
	return new WrappedPlainView(elem);
	}
	}

	View createI18N(Element elem) {
	String kind = elem.getName();
	if (kind != null) {
	if (kind.equals(AbstractDocument.ContentElementName)) {
	return new PlainParagraph(elem);
	} else if (kind.equals(AbstractDocument.ParagraphElementName)){
	return new BoxView(elem, View.Y_AXIS);
	}
	}
	return null;
	}

	/**
	* Paragraph for representing plain-text lines that support
	* bidirectional text.
	*/
	static class PlainParagraph extends javax.swing.text.ParagraphView {

	PlainParagraph(Element elem) {
	super(elem);
	layoutPool = new LogicalView(elem);
	layoutPool.setParent(this);
	}

	protected void setPropertiesFromAttributes() {
	Component c = getContainer();
	if ((c != null)
	&& (! c.getComponentOrientation().isLeftToRight()))
	{
	setJustification(StyleConstants.ALIGN_RIGHT);
	} else {
	setJustification(StyleConstants.ALIGN_LEFT);
	}
	}

	/**
	* Fetch the constraining span to flow against for
	* the given child index.
	*/
	public int getFlowSpan(int index) {
	Component c = getContainer();
	if (c instanceof JTextArea) {
	JTextArea area = (JTextArea) c;
	if (! area.getLineWrap()) {
	// no limit if unwrapped
	return Integer.MAX_VALUE;
	}
	}
	return super.getFlowSpan(index);
	}

	protected SizeRequirements calculateMinorAxisRequirements(int axis,
	SizeRequirements r)
	{
	SizeRequirements req
	= super.calculateMinorAxisRequirements(axis, r);
	Component c = getContainer();
	if (c instanceof JTextArea) {
	JTextArea area = (JTextArea) c;
	if (! area.getLineWrap()) {
	// min is pref if unwrapped
	req.minimum = req.preferred;
	}
	}
	return req;
	}

	/**
	* This class can be used to represent a logical view for
	* a flow. It keeps the children updated to reflect the state
	* of the model, gives the logical child views access to the
	* view hierarchy, and calculates a preferred span. It doesn't
	* do any rendering, layout, or model/view translation.
	*/
	static class LogicalView extends CompositeView {

	LogicalView(Element elem) {
	super(elem);
	}

	protected int getViewIndexAtPosition(int pos) {
	Element elem = getElement();
	if (elem.getElementCount() > 0) {
	return elem.getElementIndex(pos);
	}
	return 0;
	}

	protected boolean
	updateChildren(DocumentEvent.ElementChange ec,
	DocumentEvent e, ViewFactory f)
	{
	return false;
	}

	protected void loadChildren(ViewFactory f) {
	Element elem = getElement();
	if (elem.getElementCount() > 0) {
	super.loadChildren(f);
	} else {
	View v = new GlyphView(elem);
	append(v);
	}
	}

	public float getPreferredSpan(int axis) {
	if( getViewCount() != 1 )
	throw new Error("One child view is assumed.");

	View v = getView(0);
	//((GlyphView)v).setGlyphPainter(null);
	return v.getPreferredSpan(axis);
	}

	/**
	* Forward the DocumentEvent to the given child view. This
	* is implemented to reparent the child to the logical view
	* (the children may have been parented by a row in the flow
	* if they fit without breaking) and then execute the
	* superclass behavior.
	*
	* @param v the child view to forward the event to.
	* @param e the change information from the associated document
	* @param a the current allocation of the view
	* @param f the factory to use to rebuild if the view has
	* children
	* @see #forwardUpdate
	* @since 1.3
	*/
	protected void forwardUpdateToView(View v, DocumentEvent e,
	Shape a, ViewFactory f) {
	v.setParent(this);
	super.forwardUpdateToView(v, e, a, f);
	}

	// The following methods don't do anything useful, they
	// simply keep the class from being abstract.

	public void paint(Graphics g, Shape allocation) {
	}

	protected boolean isBefore(int x, int y, Rectangle alloc) {
	return false;
	}

	protected boolean isAfter(int x, int y, Rectangle alloc) {
	return false;
	}

	protected View getViewAtPoint(int x, int y, Rectangle alloc) {
	return null;
	}

	protected void childAllocation(int index, Rectangle a) {
	}
	}
	}
	}

	/* This is useful for the nightmare of parsing multi-part HTTP/RFC822 headers
	* sensibly:
	* From a String like: 'timeout=15, max=5'
	* create an array of Strings:
	* { {"timeout", "15"},
	* {"max", "5"}
	* }
	* From one like: 'Basic Realm="FuzzFace" Foo="Biz Bar Baz"'
	* create one like (no quotes in literal):
	* { {"basic", null},
	* {"realm", "FuzzFace"}
	* {"foo", "Biz Bar Baz"}
	* }
	* keys are converted to lower case, vals are left as is....
	*
	* author Dave Brown
	*/


	static class HeaderParser {

	/* table of key/val pairs - maxes out at 10!!!!*/
	String raw;
	String[][] tab;

	public HeaderParser(String raw) {
	this.raw = raw;
	tab = new String[10][2];
	parse();
	}

	private void parse() {

	if (raw != null) {
	raw = raw.trim();
	char[] ca = raw.toCharArray();
	int beg = 0, end = 0, i = 0;
	boolean inKey = true;
	boolean inQuote = false;
	int len = ca.length;
	while (end < len) {
	char c = ca[end];
	if (c == '=') { // end of a key
	tab[i][0] = new String(ca, beg, end-beg).toLowerCase();
	inKey = false;
	end++;
	beg = end;
	} else if (c == '\"') {
	if (inQuote) {
	tab[i++][1]= new String(ca, beg, end-beg);
	inQuote=false;
	do {
	end++;
	} while (end < len && (ca[end] == ' ' \|\| ca[end] == ','));
	inKey=true;
	beg=end;
	} else {
	inQuote=true;
	end++;
	beg=end;
	}
	} else if (c == ' ' \|\| c == ',') { // end key/val, of whatever we're in
	if (inQuote) {
	end++;
	continue;
	} else if (inKey) {
	tab[i++][0] = (new String(ca, beg, end-beg)).toLowerCase();
	} else {
	tab[i++][1] = (new String(ca, beg, end-beg));
	}
	while (end < len && (ca[end] == ' ' \|\| ca[end] == ',')) {
	end++;
	}
	inKey = true;
	beg = end;
	} else {
	end++;
	}
	}
	// get last key/val, if any
	if (--end > beg) {
	if (!inKey) {
	if (ca[end] == '\"') {
	tab[i++][1] = (new String(ca, beg, end-beg));
	} else {
	tab[i++][1] = (new String(ca, beg, end-beg+1));
	}
	} else {
	tab[i][0] = (new String(ca, beg, end-beg+1)).toLowerCase();
	}
	} else if (end == beg) {
	if (!inKey) {
	if (ca[end] == '\"') {
	tab[i++][1] = String.valueOf(ca[end-1]);
	} else {
	tab[i++][1] = String.valueOf(ca[end]);
	}
	} else {
	tab[i][0] = String.valueOf(ca[end]).toLowerCase();
	}
	}
	}

	}

	public String findKey(int i) {
	if (i < 0 \|\| i > 10)
	return null;
	return tab[i][0];
	}

	public String findValue(int i) {
	if (i < 0 \|\| i > 10)
	return null;
	return tab[i][1];
	}

	public String findValue(String key) {
	return findValue(key, null);
	}

	public String findValue(String k, String Default) {
	if (k == null)
	return Default;
	k = k.toLowerCase();
	for (int i = 0; i < 10; ++i) {
	if (tab[i][0] == null) {
	return Default;
	} else if (k.equals(tab[i][0])) {
	return tab[i][1];
	}
	}
	return Default;
	}

	public int findInt(String k, int Default) {
	try {
	return Integer.parseInt(findValue(k, String.valueOf(Default)));
	} catch (Throwable t) {
	return Default;
	}
	}
	}

	}

Back to index...