/*
* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
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;
}
}
}
}