/*
* Copyright (c) 1997, 2010, 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.text.html;
import sun.awt.AppContext;
import java.lang.reflect.Method;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.MalformedURLException;
import java.net.URL;
import javax.swing.text.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.swing.event.*;
import javax.swing.plaf.TextUI;
import java.util.*;
import javax.accessibility.*;
import java.lang.ref.*;
/**
* The Swing JEditorPane text component supports different kinds
* of content via a plug-in mechanism called an EditorKit. Because
* HTML is a very popular format of content, some support is provided
* by default. The default support is provided by this class, which
* supports HTML version 3.2 (with some extensions), and is migrating
* toward version 4.0.
* The <applet> tag is not supported, but some support is provided
* for the <object> tag.
* <p>
* There are several goals of the HTML EditorKit provided, that have
* an effect upon the way that HTML is modeled. These
* have influenced its design in a substantial way.
* <dl>
* <p>
* <dt>
* Support editing
* <dd>
* It might seem fairly obvious that a plug-in for JEditorPane
* should provide editing support, but that fact has several
* design considerations. There are a substantial number of HTML
* documents that don't properly conform to an HTML specification.
* These must be normalized somewhat into a correct form if one
* is to edit them. Additionally, users don't like to be presented
* with an excessive amount of structure editing, so using traditional
* text editing gestures is preferred over using the HTML structure
* exactly as defined in the HTML document.
* <p>
* The modeling of HTML is provided by the class <code>HTMLDocument</code>.
* Its documention describes the details of how the HTML is modeled.
* The editing support leverages heavily off of the text package.
* <p>
* <dt>
* Extendable/Scalable
* <dd>
* To maximize the usefulness of this kit, a great deal of effort
* has gone into making it extendable. These are some of the
* features.
* <ol>
* <li>
* The parser is replacable. The default parser is the Hot Java
* parser which is DTD based. A different DTD can be used, or an
* entirely different parser can be used. To change the parser,
* reimplement the getParser method. The default parser is
* dynamically loaded when first asked for, so the class files
* will never be loaded if an alternative parser is used. The
* default parser is in a separate package called parser below
* this package.
* <li>
* The parser drives the ParserCallback, which is provided by
* HTMLDocument. To change the callback, subclass HTMLDocument
* and reimplement the createDefaultDocument method to return
* document that produces a different reader. The reader controls
* how the document is structured. Although the Document provides
* HTML support by default, there is nothing preventing support of
* non-HTML tags that result in alternative element structures.
* <li>
* The default view of the models are provided as a hierarchy of
* View implementations, so one can easily customize how a particular
* element is displayed or add capabilities for new kinds of elements
* by providing new View implementations. The default set of views
* are provided by the <code>HTMLFactory</code> class. This can
* be easily changed by subclassing or replacing the HTMLFactory
* and reimplementing the getViewFactory method to return the alternative
* factory.
* <li>
* The View implementations work primarily off of CSS attributes,
* which are kept in the views. This makes it possible to have
* multiple views mapped over the same model that appear substantially
* different. This can be especially useful for printing. For
* most HTML attributes, the HTML attributes are converted to CSS
* attributes for display. This helps make the View implementations
* more general purpose
* </ol>
* <p>
* <dt>
* Asynchronous Loading
* <dd>
* Larger documents involve a lot of parsing and take some time
* to load. By default, this kit produces documents that will be
* loaded asynchronously if loaded using <code>JEditorPane.setPage</code>.
* This is controlled by a property on the document. The method
* <a href="#createDefaultDocument">createDefaultDocument</a> can
* be overriden to change this. The batching of work is done
* by the <code>HTMLDocument.HTMLReader</code> class. The actual
* work is done by the <code>DefaultStyledDocument</code> and
* <code>AbstractDocument</code> classes in the text package.
* <p>
* <dt>
* Customization from current LAF
* <dd>
* HTML provides a well known set of features without exactly
* specifying the display characteristics. Swing has a theme
* mechanism for its look-and-feel implementations. It is desirable
* for the look-and-feel to feed display characteristics into the
* HTML views. An user with poor vision for example would want
* high contrast and larger than typical fonts.
* <p>
* The support for this is provided by the <code>StyleSheet</code>
* class. The presentation of the HTML can be heavily influenced
* by the setting of the StyleSheet property on the EditorKit.
* <p>
* <dt>
* Not lossy
* <dd>
* An EditorKit has the ability to be read and save documents.
* It is generally the most pleasing to users if there is no loss
* of data between the two operation. The policy of the HTMLEditorKit
* will be to store things not recognized or not necessarily visible
* so they can be subsequently written out. The model of the HTML document
* should therefore contain all information discovered while reading the
* document. This is constrained in some ways by the need to support
* editing (i.e. incorrect documents sometimes must be normalized).
* The guiding principle is that information shouldn't be lost, but
* some might be synthesized to produce a more correct model or it might
* be rearranged.
* </dl>
*
* @author Timothy Prinzing
*/
public class HTMLEditorKit extends StyledEditorKit implements Accessible {
private JEditorPane theEditor;
/**
* Constructs an HTMLEditorKit, creates a StyleContext,
* and loads the style sheet.
*/
public HTMLEditorKit() {
}
/**
* Get the MIME type of the data that this
* kit represents support for. This kit supports
* the type <code>text/html</code>.
*
* @return the type
*/
public String getContentType() {
return "text/html";
}
/**
* Fetch a factory that is suitable for producing
* views of any models that are produced by this
* kit.
*
* @return the factory
*/
public ViewFactory getViewFactory() {
return defaultFactory;
}
/**
* Create an uninitialized text storage model
* that is appropriate for this type of editor.
*
* @return the model
*/
public Document createDefaultDocument() {
StyleSheet styles = getStyleSheet();
StyleSheet ss = new StyleSheet();
ss.addStyleSheet(styles);
HTMLDocument doc = new HTMLDocument(ss);
doc.setParser(getParser());
doc.setAsynchronousLoadPriority(4);
doc.setTokenThreshold(100);
return doc;
}
/**
* Try to get an HTML parser from the document. If no parser is set for
* the document, return the editor kit's default parser. It is an error
* if no parser could be obtained from the editor kit.
*/
private Parser ensureParser(HTMLDocument doc) throws IOException {
Parser p = doc.getParser();
if (p == null) {
p = getParser();
}
if (p == null) {
throw new IOException("Can't load parser");
}
return p;
}
/**
* Inserts content from the given stream. If <code>doc</code> is
* an instance of HTMLDocument, this will read
* HTML 3.2 text. Inserting HTML into a non-empty document must be inside
* the body Element, if you do not insert into the body an exception will
* be thrown. When inserting into a non-empty document all tags outside
* of the body (head, title) will be dropped.
*
* @param in the stream to read from
* @param doc the destination for the insertion
* @param pos the location in the document to place the
* content
* @exception IOException on any I/O error
* @exception BadLocationException if pos represents an invalid
* location within the document
* @exception RuntimeException (will eventually be a BadLocationException)
* if pos is invalid
*/
public void read(Reader in, Document doc, int pos) throws IOException, BadLocationException {
if (doc instanceof HTMLDocument) {
HTMLDocument hdoc = (HTMLDocument) doc;
if (pos > doc.getLength()) {
throw new BadLocationException("Invalid location", pos);
}
Parser p = ensureParser(hdoc);
ParserCallback receiver = hdoc.getReader(pos);
Boolean ignoreCharset = (Boolean)doc.getProperty("IgnoreCharsetDirective");
p.parse(in, receiver, (ignoreCharset == null) ? false : ignoreCharset.booleanValue());
receiver.flush();
} else {
super.read(in, doc, pos);
}
}
/**
* Inserts HTML into an existing document.
*
* @param doc the document to insert into
* @param offset the offset to insert HTML at
* @param popDepth the number of ElementSpec.EndTagTypes to generate before
* inserting
* @param pushDepth the number of ElementSpec.StartTagTypes with a direction
* of ElementSpec.JoinNextDirection that should be generated
* before inserting, but after the end tags have been generated
* @param insertTag the first tag to start inserting into document
* @exception RuntimeException (will eventually be a BadLocationException)
* if pos is invalid
*/
public void insertHTML(HTMLDocument doc, int offset, String html,
int popDepth, int pushDepth,
HTML.Tag insertTag) throws
BadLocationException, IOException {
if (offset > doc.getLength()) {
throw new BadLocationException("Invalid location", offset);
}
Parser p = ensureParser(doc);
ParserCallback receiver = doc.getReader(offset, popDepth, pushDepth,
insertTag);
Boolean ignoreCharset = (Boolean)doc.getProperty
("IgnoreCharsetDirective");
p.parse(new StringReader(html), receiver, (ignoreCharset == null) ?
false : ignoreCharset.booleanValue());
receiver.flush();
}
/**
* Write content from a document to the given stream
* in a format appropriate for this kind of content handler.
*
* @param out the stream to write to
* @param doc the source for the write
* @param pos the location in the document to fetch the
* content
* @param len the amount to write out
* @exception IOException on any I/O error
* @exception BadLocationException if pos represents an invalid
* location within the document
*/
public void write(Writer out, Document doc, int pos, int len)
throws IOException, BadLocationException {
if (doc instanceof HTMLDocument) {
HTMLWriter w = new HTMLWriter(out, (HTMLDocument)doc, pos, len);
w.write();
} else if (doc instanceof StyledDocument) {
MinimalHTMLWriter w = new MinimalHTMLWriter(out, (StyledDocument)doc, pos, len);
w.write();
} else {
super.write(out, doc, pos, len);
}
}
/**
* Called when the kit is being installed into the
* a JEditorPane.
*
* @param c the JEditorPane
*/
public void install(JEditorPane c) {
c.addMouseListener(linkHandler);
c.addMouseMotionListener(linkHandler);
c.addCaretListener(nextLinkAction);
super.install(c);
theEditor = c;
}
/**
* Called when the kit is being removed from the
* JEditorPane. This is used to unregister any
* listeners that were attached.
*
* @param c the JEditorPane
*/
public void deinstall(JEditorPane c) {
c.removeMouseListener(linkHandler);
c.removeMouseMotionListener(linkHandler);
c.removeCaretListener(nextLinkAction);
super.deinstall(c);
theEditor = null;
}
/**
* Default Cascading Style Sheet file that sets
* up the tag views.
*/
public static final String DEFAULT_CSS = "default.css";
/**
* Set the set of styles to be used to render the various
* HTML elements. These styles are specified in terms of
* CSS specifications. Each document produced by the kit
* will have a copy of the sheet which it can add the
* document specific styles to. By default, the StyleSheet
* specified is shared by all HTMLEditorKit instances.
* This should be reimplemented to provide a finer granularity
* if desired.
*/
public void setStyleSheet(StyleSheet s) {
if (s == null) {
AppContext.getAppContext().remove(DEFAULT_STYLES_KEY);
} else {
AppContext.getAppContext().put(DEFAULT_STYLES_KEY, s);
}
}
/**
* Get the set of styles currently being used to render the
* HTML elements. By default the resource specified by
* DEFAULT_CSS gets loaded, and is shared by all HTMLEditorKit
* instances.
*/
public StyleSheet getStyleSheet() {
AppContext appContext = AppContext.getAppContext();
StyleSheet defaultStyles = (StyleSheet) appContext.get(DEFAULT_STYLES_KEY);
if (defaultStyles == null) {
defaultStyles = new StyleSheet();
appContext.put(DEFAULT_STYLES_KEY, defaultStyles);
try {
InputStream is = HTMLEditorKit.getResourceAsStream(DEFAULT_CSS);
Reader r = new BufferedReader(
new InputStreamReader(is, "ISO-8859-1"));
defaultStyles.loadRules(r, null);
r.close();
} catch (Throwable e) {
// on error we simply have no styles... the html
// will look mighty wrong but still function.
}
}
return defaultStyles;
}
/**
* Fetch a resource relative to the HTMLEditorKit classfile.
* If this is called on 1.2 the loading will occur under the
* protection of a doPrivileged call to allow the HTMLEditorKit
* to function when used in an applet.
*
* @param name the name of the resource, relative to the
* HTMLEditorKit class
* @return a stream representing the resource
*/
static InputStream getResourceAsStream(String name) {
try {
return ResourceLoader.getResourceAsStream(name);
} catch (Throwable e) {
// If the class doesn't exist or we have some other
// problem we just try to call getResourceAsStream directly.
return HTMLEditorKit.class.getResourceAsStream(name);
}
}
/**
* Fetches the command list for the editor. This is
* the list of commands supported by the superclass
* augmented by the collection of commands defined
* locally for style operations.
*
* @return the command list
*/
public Action[] getActions() {
return TextAction.augmentList(super.getActions(), this.defaultActions);
}
/**
* Copies the key/values in <code>element</code>s AttributeSet into
* <code>set</code>. This does not copy component, icon, or element
* names attributes. Subclasses may wish to refine what is and what
* isn't copied here. But be sure to first remove all the attributes that
* are in <code>set</code>.<p>
* This is called anytime the caret moves over a different location.
*
*/
protected void createInputAttributes(Element element,
MutableAttributeSet set) {
set.removeAttributes(set);
set.addAttributes(element.getAttributes());
set.removeAttribute(StyleConstants.ComposedTextAttribute);
Object o = set.getAttribute(StyleConstants.NameAttribute);
if (o instanceof HTML.Tag) {
HTML.Tag tag = (HTML.Tag)o;
// PENDING: we need a better way to express what shouldn't be
// copied when editing...
if(tag == HTML.Tag.IMG) {
// Remove the related image attributes, src, width, height
set.removeAttribute(HTML.Attribute.SRC);
set.removeAttribute(HTML.Attribute.HEIGHT);
set.removeAttribute(HTML.Attribute.WIDTH);
set.addAttribute(StyleConstants.NameAttribute,
HTML.Tag.CONTENT);
}
else if (tag == HTML.Tag.HR || tag == HTML.Tag.BR) {
// Don't copy HRs or BRs either.
set.addAttribute(StyleConstants.NameAttribute,
HTML.Tag.CONTENT);
}
else if (tag == HTML.Tag.COMMENT) {
// Don't copy COMMENTs either
set.addAttribute(StyleConstants.NameAttribute,
HTML.Tag.CONTENT);
set.removeAttribute(HTML.Attribute.COMMENT);
}
else if (tag == HTML.Tag.INPUT) {
// or INPUT either
set.addAttribute(StyleConstants.NameAttribute,
HTML.Tag.CONTENT);
set.removeAttribute(HTML.Tag.INPUT);
}
else if (tag instanceof HTML.UnknownTag) {
// Don't copy unknowns either:(
set.addAttribute(StyleConstants.NameAttribute,
HTML.Tag.CONTENT);
set.removeAttribute(HTML.Attribute.ENDTAG);
}
}
}
/**
* Gets the input attributes used for the styled
* editing actions.
*
* @return the attribute set
*/
public MutableAttributeSet getInputAttributes() {
if (input == null) {
input = getStyleSheet().addStyle(null, null);
}
return input;
}
/**
* Sets the default cursor.
*
* @since 1.3
*/
public void setDefaultCursor(Cursor cursor) {
defaultCursor = cursor;
}
/**
* Returns the default cursor.
*
* @since 1.3
*/
public Cursor getDefaultCursor() {
return defaultCursor;
}
/**
* Sets the cursor to use over links.
*
* @since 1.3
*/
public void setLinkCursor(Cursor cursor) {
linkCursor = cursor;
}
/**
* Returns the cursor to use over hyper links.
* @since 1.3
*/
public Cursor getLinkCursor() {
return linkCursor;
}
/**
* Indicates whether an html form submission is processed automatically
* or only <code>FormSubmitEvent</code> is fired.
*
* @return true if html form submission is processed automatically,
* false otherwise.
*
* @see #setAutoFormSubmission
* @since 1.5
*/
public boolean isAutoFormSubmission() {
return isAutoFormSubmission;
}
/**
* Specifies if an html form submission is processed
* automatically or only <code>FormSubmitEvent</code> is fired.
* By default it is set to true.
*
* @see #isAutoFormSubmission
* @see FormSubmitEvent
* @since 1.5
*/
public void setAutoFormSubmission(boolean isAuto) {
isAutoFormSubmission = isAuto;
}
/**
* Creates a copy of the editor kit.
*
* @return the copy
*/
public Object clone() {
HTMLEditorKit o = (HTMLEditorKit)super.clone();
if (o != null) {
o.input = null;
o.linkHandler = new LinkController();
}
return o;
}
/**
* Fetch the parser to use for reading HTML streams.
* This can be reimplemented to provide a different
* parser. The default implementation is loaded dynamically
* to avoid the overhead of loading the default parser if
* it's not used. The default parser is the HotJava parser
* using an HTML 3.2 DTD.
*/
protected Parser getParser() {
if (defaultParser == null) {
try {
Class c = Class.forName("javax.swing.text.html.parser.ParserDelegator");
defaultParser = (Parser) c.newInstance();
} catch (Throwable e) {
}
}
return defaultParser;
}
// ----- Accessibility support -----
private AccessibleContext accessibleContext;
/**
* returns the AccessibleContext associated with this editor kit
*
* @return the AccessibleContext associated with this editor kit
* @since 1.4
*/
public AccessibleContext getAccessibleContext() {
if (theEditor == null) {
return null;
}
if (accessibleContext == null) {
AccessibleHTML a = new AccessibleHTML(theEditor);
accessibleContext = a.getAccessibleContext();
}
return accessibleContext;
}
// --- variables ------------------------------------------
private static final Cursor MoveCursor = Cursor.getPredefinedCursor
(Cursor.HAND_CURSOR);
private static final Cursor DefaultCursor = Cursor.getPredefinedCursor
(Cursor.DEFAULT_CURSOR);
/** Shared factory for creating HTML Views. */
private static final ViewFactory defaultFactory = new HTMLFactory();
MutableAttributeSet input;
private static final Object DEFAULT_STYLES_KEY = new Object();
private LinkController linkHandler = new LinkController();
private static Parser defaultParser = null;
private Cursor defaultCursor = DefaultCursor;
private Cursor linkCursor = MoveCursor;
private boolean isAutoFormSubmission = true;
/**
* Class to watch the associated component and fire
* hyperlink events on it when appropriate.
*/
public static class LinkController extends MouseAdapter implements MouseMotionListener, Serializable {
private Element curElem = null;
/**
* If true, the current element (curElem) represents an image.
*/
private boolean curElemImage = false;
private String href = null;
/** This is used by viewToModel to avoid allocing a new array each
* time. */
private transient Position.Bias[] bias = new Position.Bias[1];
/**
* Current offset.
*/
private int curOffset;
/**
* Called for a mouse click event.
* If the component is read-only (ie a browser) then
* the clicked event is used to drive an attempt to
* follow the reference specified by a link.
*
* @param e the mouse event
* @see MouseListener#mouseClicked
*/
public void mouseClicked(MouseEvent e) {
JEditorPane editor = (JEditorPane) e.getSource();
if (! editor.isEditable() && editor.isEnabled() &&
SwingUtilities.isLeftMouseButton(e)) {
Point pt = new Point(e.getX(), e.getY());
int pos = editor.viewToModel(pt);
if (pos >= 0) {
activateLink(pos, editor, e.getX(), e.getY());
}
}
}
// ignore the drags
public void mouseDragged(MouseEvent e) {
}
// track the moving of the mouse.
public void mouseMoved(MouseEvent e) {
JEditorPane editor = (JEditorPane) e.getSource();
if (!editor.isEnabled()) {
return;
}
HTMLEditorKit kit = (HTMLEditorKit)editor.getEditorKit();
boolean adjustCursor = true;
Cursor newCursor = kit.getDefaultCursor();
if (!editor.isEditable()) {
Point pt = new Point(e.getX(), e.getY());
int pos = editor.getUI().viewToModel(editor, pt, bias);
if (bias[0] == Position.Bias.Backward && pos > 0) {
pos--;
}
if (pos >= 0 &&(editor.getDocument() instanceof HTMLDocument)){
HTMLDocument hdoc = (HTMLDocument)editor.getDocument();
Element elem = hdoc.getCharacterElement(pos);
if (!doesElementContainLocation(editor, elem, pos,
e.getX(), e.getY())) {
elem = null;
}
if (curElem != elem || curElemImage) {
Element lastElem = curElem;
curElem = elem;
String href = null;
curElemImage = false;
if (elem != null) {
AttributeSet a = elem.getAttributes();
AttributeSet anchor = (AttributeSet)a.
getAttribute(HTML.Tag.A);
if (anchor == null) {
curElemImage = (a.getAttribute(StyleConstants.
NameAttribute) == HTML.Tag.IMG);
if (curElemImage) {
href = getMapHREF(editor, hdoc, elem, a,
pos, e.getX(), e.getY());
}
}
else {
href = (String)anchor.getAttribute
(HTML.Attribute.HREF);
}
}
if (href != this.href) {
// reference changed, fire event(s)
fireEvents(editor, hdoc, href, lastElem);
this.href = href;
if (href != null) {
newCursor = kit.getLinkCursor();
}
}
else {
adjustCursor = false;
}
}
else {
adjustCursor = false;
}
curOffset = pos;
}
}
if (adjustCursor && editor.getCursor() != newCursor) {
editor.setCursor(newCursor);
}
}
/**
* Returns a string anchor if the passed in element has a
* USEMAP that contains the passed in location.
*/
private String getMapHREF(JEditorPane html, HTMLDocument hdoc,
Element elem, AttributeSet attr, int offset,
int x, int y) {
Object useMap = attr.getAttribute(HTML.Attribute.USEMAP);
if (useMap != null && (useMap instanceof String)) {
Map m = hdoc.getMap((String)useMap);
if (m != null && offset < hdoc.getLength()) {
Rectangle bounds;
TextUI ui = html.getUI();
try {
Shape lBounds = ui.modelToView(html, offset,
Position.Bias.Forward);
Shape rBounds = ui.modelToView(html, offset + 1,
Position.Bias.Backward);
bounds = lBounds.getBounds();
bounds.add((rBounds instanceof Rectangle) ?
(Rectangle)rBounds : rBounds.getBounds());
} catch (BadLocationException ble) {
bounds = null;
}
if (bounds != null) {
AttributeSet area = m.getArea(x - bounds.x,
y - bounds.y,
bounds.width,
bounds.height);
if (area != null) {
return (String)area.getAttribute(HTML.Attribute.
HREF);
}
}
}
}
return null;
}
/**
* Returns true if the View representing <code>e</code> contains
* the location <code>x</code>, <code>y</code>. <code>offset</code>
* gives the offset into the Document to check for.
*/
private boolean doesElementContainLocation(JEditorPane editor,
Element e, int offset,
int x, int y) {
if (e != null && offset > 0 && e.getStartOffset() == offset) {
try {
TextUI ui = editor.getUI();
Shape s1 = ui.modelToView(editor, offset,
Position.Bias.Forward);
if (s1 == null) {
return false;
}
Rectangle r1 = (s1 instanceof Rectangle) ? (Rectangle)s1 :
s1.getBounds();
Shape s2 = ui.modelToView(editor, e.getEndOffset(),
Position.Bias.Backward);
if (s2 != null) {
Rectangle r2 = (s2 instanceof Rectangle) ? (Rectangle)s2 :
s2.getBounds();
r1.add(r2);
}
return r1.contains(x, y);
} catch (BadLocationException ble) {
}
}
return true;
}
/**
* Calls linkActivated on the associated JEditorPane
* if the given position represents a link.<p>This is implemented
* to forward to the method with the same name, but with the following
* args both == -1.
*
* @param pos the position
* @param editor the editor pane
*/
protected void activateLink(int pos, JEditorPane editor) {
activateLink(pos, editor, -1, -1);
}
/**
* Calls linkActivated on the associated JEditorPane
* if the given position represents a link. If this was the result
* of a mouse click, <code>x</code> and
* <code>y</code> will give the location of the mouse, otherwise
* they will be < 0.
*
* @param pos the position
* @param html the editor pane
*/
void activateLink(int pos, JEditorPane html, int x, int y) {
Document doc = html.getDocument();
if (doc instanceof HTMLDocument) {
HTMLDocument hdoc = (HTMLDocument) doc;
Element e = hdoc.getCharacterElement(pos);
AttributeSet a = e.getAttributes();
AttributeSet anchor = (AttributeSet)a.getAttribute(HTML.Tag.A);
HyperlinkEvent linkEvent = null;
String description;
if (anchor == null) {
href = getMapHREF(html, hdoc, e, a, pos, x, y);
}
else {
href = (String)anchor.getAttribute(HTML.Attribute.HREF);
}
if (href != null) {
linkEvent = createHyperlinkEvent(html, hdoc, href, anchor,
e);
}
if (linkEvent != null) {
html.fireHyperlinkUpdate(linkEvent);
}
}
}
/**
* Creates and returns a new instance of HyperlinkEvent. If
* <code>hdoc</code> is a frame document a HTMLFrameHyperlinkEvent
* will be created.
*/
HyperlinkEvent createHyperlinkEvent(JEditorPane html,
HTMLDocument hdoc, String href,
AttributeSet anchor,
Element element) {
URL u;
try {
URL base = hdoc.getBase();
u = new URL(base, href);
// Following is a workaround for 1.2, in which
// new URL("file://...", "#...") causes the filename to
// be lost.
if (href != null && "file".equals(u.getProtocol()) &&
href.startsWith("#")) {
String baseFile = base.getFile();
String newFile = u.getFile();
if (baseFile != null && newFile != null &&
!newFile.startsWith(baseFile)) {
u = new URL(base, baseFile + href);
}
}
} catch (MalformedURLException m) {
u = null;
}
HyperlinkEvent linkEvent = null;
if (!hdoc.isFrameDocument()) {
linkEvent = new HyperlinkEvent(html, HyperlinkEvent.EventType.
ACTIVATED, u, href, element);
} else {
String target = (anchor != null) ?
(String)anchor.getAttribute(HTML.Attribute.TARGET) : null;
if ((target == null) || (target.equals(""))) {
target = hdoc.getBaseTarget();
}
if ((target == null) || (target.equals(""))) {
target = "_self";
}
linkEvent = new HTMLFrameHyperlinkEvent(html, HyperlinkEvent.
EventType.ACTIVATED, u, href, element, target);
}
return linkEvent;
}
void fireEvents(JEditorPane editor, HTMLDocument doc, String href,
Element lastElem) {
if (this.href != null) {
// fire an exited event on the old link
URL u;
try {
u = new URL(doc.getBase(), this.href);
} catch (MalformedURLException m) {
u = null;
}
HyperlinkEvent exit = new HyperlinkEvent(editor,
HyperlinkEvent.EventType.EXITED, u, this.href,
lastElem);
editor.fireHyperlinkUpdate(exit);
}
if (href != null) {
// fire an entered event on the new link
URL u;
try {
u = new URL(doc.getBase(), href);
} catch (MalformedURLException m) {
u = null;
}
HyperlinkEvent entered = new HyperlinkEvent(editor,
HyperlinkEvent.EventType.ENTERED,
u, href, curElem);
editor.fireHyperlinkUpdate(entered);
}
}
}
/**
* Interface to be supported by the parser. This enables
* providing a different parser while reusing some of the
* implementation provided by this editor kit.
*/
public static abstract class Parser {
/**
* Parse the given stream and drive the given callback
* with the results of the parse. This method should
* be implemented to be thread-safe.
*/
public abstract void parse(Reader r, ParserCallback cb, boolean ignoreCharSet) throws IOException;
}
/**
* The result of parsing drives these callback methods.
* The open and close actions should be balanced. The
* <code>flush</code> method will be the last method
* called, to give the receiver a chance to flush any
* pending data into the document.
* <p>Refer to DocumentParser, the default parser used, for further
* information on the contents of the AttributeSets, the positions, and
* other info.
*
* @see javax.swing.text.html.parser.DocumentParser
*/
public static class ParserCallback {
/**
* This is passed as an attribute in the attributeset to indicate
* the element is implied eg, the string '<>foo<\t>'
* contains an implied html element and an implied body element.
*
* @since 1.3
*/
public static final Object IMPLIED = "_implied_";
public void flush() throws BadLocationException {
}
public void handleText(char[] data, int pos) {
}
public void handleComment(char[] data, int pos) {
}
public void handleStartTag(HTML.Tag t, MutableAttributeSet a, int pos) {
}
public void handleEndTag(HTML.Tag t, int pos) {
}
public void handleSimpleTag(HTML.Tag t, MutableAttributeSet a, int pos) {
}
public void handleError(String errorMsg, int pos){
}
/**
* This is invoked after the stream has been parsed, but before
* <code>flush</code>. <code>eol</code> will be one of \n, \r
* or \r\n, which ever is encountered the most in parsing the
* stream.
*
* @since 1.3
*/
public void handleEndOfLineString(String eol) {
}
}
/**
* A factory to build views for HTML. The following
* table describes what this factory will build by
* default.
*
* <table summary="Describes the tag and view created by this factory by default">
* <tr>
* <th align=left>Tag<th align=left>View created
* </tr><tr>
* <td>HTML.Tag.CONTENT<td>InlineView
* </tr><tr>
* <td>HTML.Tag.IMPLIED<td>javax.swing.text.html.ParagraphView
* </tr><tr>
* <td>HTML.Tag.P<td>javax.swing.text.html.ParagraphView
* </tr><tr>
* <td>HTML.Tag.H1<td>javax.swing.text.html.ParagraphView
* </tr><tr>
* <td>HTML.Tag.H2<td>javax.swing.text.html.ParagraphView
* </tr><tr>
* <td>HTML.Tag.H3<td>javax.swing.text.html.ParagraphView
* </tr><tr>
* <td>HTML.Tag.H4<td>javax.swing.text.html.ParagraphView
* </tr><tr>
* <td>HTML.Tag.H5<td>javax.swing.text.html.ParagraphView
* </tr><tr>
* <td>HTML.Tag.H6<td>javax.swing.text.html.ParagraphView
* </tr><tr>
* <td>HTML.Tag.DT<td>javax.swing.text.html.ParagraphView
* </tr><tr>
* <td>HTML.Tag.MENU<td>ListView
* </tr><tr>
* <td>HTML.Tag.DIR<td>ListView
* </tr><tr>
* <td>HTML.Tag.UL<td>ListView
* </tr><tr>
* <td>HTML.Tag.OL<td>ListView
* </tr><tr>
* <td>HTML.Tag.LI<td>BlockView
* </tr><tr>
* <td>HTML.Tag.DL<td>BlockView
* </tr><tr>
* <td>HTML.Tag.DD<td>BlockView
* </tr><tr>
* <td>HTML.Tag.BODY<td>BlockView
* </tr><tr>
* <td>HTML.Tag.HTML<td>BlockView
* </tr><tr>
* <td>HTML.Tag.CENTER<td>BlockView
* </tr><tr>
* <td>HTML.Tag.DIV<td>BlockView
* </tr><tr>
* <td>HTML.Tag.BLOCKQUOTE<td>BlockView
* </tr><tr>
* <td>HTML.Tag.PRE<td>BlockView
* </tr><tr>
* <td>HTML.Tag.BLOCKQUOTE<td>BlockView
* </tr><tr>
* <td>HTML.Tag.PRE<td>BlockView
* </tr><tr>
* <td>HTML.Tag.IMG<td>ImageView
* </tr><tr>
* <td>HTML.Tag.HR<td>HRuleView
* </tr><tr>
* <td>HTML.Tag.BR<td>BRView
* </tr><tr>
* <td>HTML.Tag.TABLE<td>javax.swing.text.html.TableView
* </tr><tr>
* <td>HTML.Tag.INPUT<td>FormView
* </tr><tr>
* <td>HTML.Tag.SELECT<td>FormView
* </tr><tr>
* <td>HTML.Tag.TEXTAREA<td>FormView
* </tr><tr>
* <td>HTML.Tag.OBJECT<td>ObjectView
* </tr><tr>
* <td>HTML.Tag.FRAMESET<td>FrameSetView
* </tr><tr>
* <td>HTML.Tag.FRAME<td>FrameView
* </tr>
* </table>
*/
public static class HTMLFactory implements ViewFactory {
/**
* Creates a view from an element.
*
* @param elem the element
* @return the view
*/
public View create(Element elem) {
AttributeSet attrs = elem.getAttributes();
Object elementName =
attrs.getAttribute(AbstractDocument.ElementNameAttribute);
Object o = (elementName != null) ?
null : attrs.getAttribute(StyleConstants.NameAttribute);
if (o instanceof HTML.Tag) {
HTML.Tag kind = (HTML.Tag) o;
if (kind == HTML.Tag.CONTENT) {
return new InlineView(elem);
} else if (kind == HTML.Tag.IMPLIED) {
String ws = (String) elem.getAttributes().getAttribute(
CSS.Attribute.WHITE_SPACE);
if ((ws != null) && ws.equals("pre")) {
return new LineView(elem);
}
return new javax.swing.text.html.ParagraphView(elem);
} else if ((kind == HTML.Tag.P) ||
(kind == HTML.Tag.H1) ||
(kind == HTML.Tag.H2) ||
(kind == HTML.Tag.H3) ||
(kind == HTML.Tag.H4) ||
(kind == HTML.Tag.H5) ||
(kind == HTML.Tag.H6) ||
(kind == HTML.Tag.DT)) {
// paragraph
return new javax.swing.text.html.ParagraphView(elem);
} else if ((kind == HTML.Tag.MENU) ||
(kind == HTML.Tag.DIR) ||
(kind == HTML.Tag.UL) ||
(kind == HTML.Tag.OL)) {
return new ListView(elem);
} else if (kind == HTML.Tag.BODY) {
return new BodyBlockView(elem);
} else if (kind == HTML.Tag.HTML) {
return new BlockView(elem, View.Y_AXIS);
} else if ((kind == HTML.Tag.LI) ||
(kind == HTML.Tag.CENTER) ||
(kind == HTML.Tag.DL) ||
(kind == HTML.Tag.DD) ||
(kind == HTML.Tag.DIV) ||
(kind == HTML.Tag.BLOCKQUOTE) ||
(kind == HTML.Tag.PRE) ||
(kind == HTML.Tag.FORM)) {
// vertical box
return new BlockView(elem, View.Y_AXIS);
} else if (kind == HTML.Tag.NOFRAMES) {
return new NoFramesView(elem, View.Y_AXIS);
} else if (kind==HTML.Tag.IMG) {
return new ImageView(elem);
} else if (kind == HTML.Tag.ISINDEX) {
return new IsindexView(elem);
} else if (kind == HTML.Tag.HR) {
return new HRuleView(elem);
} else if (kind == HTML.Tag.BR) {
return new BRView(elem);
} else if (kind == HTML.Tag.TABLE) {
return new javax.swing.text.html.TableView(elem);
} else if ((kind == HTML.Tag.INPUT) ||
(kind == HTML.Tag.SELECT) ||
(kind == HTML.Tag.TEXTAREA)) {
return new FormView(elem);
} else if (kind == HTML.Tag.OBJECT) {
return new ObjectView(elem);
} else if (kind == HTML.Tag.FRAMESET) {
if (elem.getAttributes().isDefined(HTML.Attribute.ROWS)) {
return new FrameSetView(elem, View.Y_AXIS);
} else if (elem.getAttributes().isDefined(HTML.Attribute.COLS)) {
return new FrameSetView(elem, View.X_AXIS);
}
throw new RuntimeException("Can't build a" + kind + ", " + elem + ":" +
"no ROWS or COLS defined.");
} else if (kind == HTML.Tag.FRAME) {
return new FrameView(elem);
} else if (kind instanceof HTML.UnknownTag) {
return new HiddenTagView(elem);
} else if (kind == HTML.Tag.COMMENT) {
return new CommentView(elem);
} else if (kind == HTML.Tag.HEAD) {
// Make the head never visible, and never load its
// children. For Cursor positioning,
// getNextVisualPositionFrom is overriden to always return
// the end offset of the element.
return new BlockView(elem, View.X_AXIS) {
public float getPreferredSpan(int axis) {
return 0;
}
public float getMinimumSpan(int axis) {
return 0;
}
public float getMaximumSpan(int axis) {
return 0;
}
protected void loadChildren(ViewFactory f) {
}
public Shape modelToView(int pos, Shape a,
Position.Bias b) throws BadLocationException {
return a;
}
public int getNextVisualPositionFrom(int pos,
Position.Bias b, Shape a,
int direction, Position.Bias[] biasRet) {
return getElement().getEndOffset();
}
};
} else if ((kind == HTML.Tag.TITLE) ||
(kind == HTML.Tag.META) ||
(kind == HTML.Tag.LINK) ||
(kind == HTML.Tag.STYLE) ||
(kind == HTML.Tag.SCRIPT) ||
(kind == HTML.Tag.AREA) ||
(kind == HTML.Tag.MAP) ||
(kind == HTML.Tag.PARAM) ||
(kind == HTML.Tag.APPLET)) {
return new HiddenTagView(elem);
}
}
// If we get here, it's either an element we don't know about
// or something from StyledDocument that doesn't have a mapping to HTML.
String nm = (elementName != null) ? (String)elementName :
elem.getName();
if (nm != null) {
if (nm.equals(AbstractDocument.ContentElementName)) {
return new LabelView(elem);
} else if (nm.equals(AbstractDocument.ParagraphElementName)) {
return new ParagraphView(elem);
} else if (nm.equals(AbstractDocument.SectionElementName)) {
return new BoxView(elem, View.Y_AXIS);
} else if (nm.equals(StyleConstants.ComponentElementName)) {
return new ComponentView(elem);
} else if (nm.equals(StyleConstants.IconElementName)) {
return new IconView(elem);
}
}
// default to text display
return new LabelView(elem);
}
static class BodyBlockView extends BlockView implements ComponentListener {
public BodyBlockView(Element elem) {
super(elem,View.Y_AXIS);
}
// reimplement major axis requirements to indicate that the
// block is flexible for the body element... so that it can
// be stretched to fill the background properly.
protected SizeRequirements calculateMajorAxisRequirements(int axis, SizeRequirements r) {
r = super.calculateMajorAxisRequirements(axis, r);
r.maximum = Integer.MAX_VALUE;
return r;
}
protected void layoutMinorAxis(int targetSpan, int axis, int[] offsets, int[] spans) {
Container container = getContainer();
Container parentContainer;
if (container != null
&& (container instanceof javax.swing.JEditorPane)
&& (parentContainer = container.getParent()) != null
&& (parentContainer instanceof javax.swing.JViewport)) {
JViewport viewPort = (JViewport)parentContainer;
Object cachedObject;
if (cachedViewPort != null) {
if ((cachedObject = cachedViewPort.get()) != null) {
if (cachedObject != viewPort) {
((JComponent)cachedObject).removeComponentListener(this);
}
} else {
cachedViewPort = null;
}
}
if (cachedViewPort == null) {
viewPort.addComponentListener(this);
cachedViewPort = new WeakReference(viewPort);
}
componentVisibleWidth = viewPort.getExtentSize().width;
if (componentVisibleWidth > 0) {
Insets insets = container.getInsets();
viewVisibleWidth = componentVisibleWidth - insets.left - getLeftInset();
//try to use viewVisibleWidth if it is smaller than targetSpan
targetSpan = Math.min(targetSpan, viewVisibleWidth);
}
} else {
if (cachedViewPort != null) {
Object cachedObject;
if ((cachedObject = cachedViewPort.get()) != null) {
((JComponent)cachedObject).removeComponentListener(this);
}
cachedViewPort = null;
}
}
super.layoutMinorAxis(targetSpan, axis, offsets, spans);
}
public void setParent(View parent) {
//if parent == null unregister component listener
if (parent == null) {
if (cachedViewPort != null) {
Object cachedObject;
if ((cachedObject = cachedViewPort.get()) != null) {
((JComponent)cachedObject).removeComponentListener(this);
}
cachedViewPort = null;
}
}
super.setParent(parent);
}
public void componentResized(ComponentEvent e) {
if ( !(e.getSource() instanceof JViewport) ) {
return;
}
JViewport viewPort = (JViewport)e.getSource();
if (componentVisibleWidth != viewPort.getExtentSize().width) {
Document doc = getDocument();
if (doc instanceof AbstractDocument) {
AbstractDocument document = (AbstractDocument)getDocument();
document.readLock();
try {
layoutChanged(X_AXIS);
preferenceChanged(null, true, true);
} finally {
document.readUnlock();
}
}
}
}
public void componentHidden(ComponentEvent e) {
}
public void componentMoved(ComponentEvent e) {
}
public void componentShown(ComponentEvent e) {
}
/*
* we keep weak reference to viewPort if and only if BodyBoxView is listening for ComponentEvents
* only in that case cachedViewPort is not equal to null.
* we need to keep this reference in order to remove BodyBoxView from viewPort listeners.
*
*/
private Reference cachedViewPort = null;
private boolean isListening = false;
private int viewVisibleWidth = Integer.MAX_VALUE;
private int componentVisibleWidth = Integer.MAX_VALUE;
}
}
// --- Action implementations ------------------------------
/** The bold action identifier
*/
public static final String BOLD_ACTION = "html-bold-action";
/** The italic action identifier
*/
public static final String ITALIC_ACTION = "html-italic-action";
/** The paragraph left indent action identifier
*/
public static final String PARA_INDENT_LEFT = "html-para-indent-left";
/** The paragraph right indent action identifier
*/
public static final String PARA_INDENT_RIGHT = "html-para-indent-right";
/** The font size increase to next value action identifier
*/
public static final String FONT_CHANGE_BIGGER = "html-font-bigger";
/** The font size decrease to next value action identifier
*/
public static final String FONT_CHANGE_SMALLER = "html-font-smaller";
/** The Color choice action identifier
The color is passed as an argument
*/
public static final String COLOR_ACTION = "html-color-action";
/** The logical style choice action identifier
The logical style is passed in as an argument
*/
public static final String LOGICAL_STYLE_ACTION = "html-logical-style-action";
/**
* Align images at the top.
*/
public static final String IMG_ALIGN_TOP = "html-image-align-top";
/**
* Align images in the middle.
*/
public static final String IMG_ALIGN_MIDDLE = "html-image-align-middle";
/**
* Align images at the bottom.
*/
public static final String IMG_ALIGN_BOTTOM = "html-image-align-bottom";
/**
* Align images at the border.
*/
public static final String IMG_BORDER = "html-image-border";
/** HTML used when inserting tables. */
private static final String INSERT_TABLE_HTML = "<table border=1><tr><td></td></tr></table>";
/** HTML used when inserting unordered lists. */
private static final String INSERT_UL_HTML = "<ul><li></li></ul>";
/** HTML used when inserting ordered lists. */
private static final String INSERT_OL_HTML = "<ol><li></li></ol>";
/** HTML used when inserting hr. */
private static final String INSERT_HR_HTML = "<hr>";
/** HTML used when inserting pre. */
private static final String INSERT_PRE_HTML = "<pre></pre>";
private static final NavigateLinkAction nextLinkAction =
new NavigateLinkAction("next-link-action");
private static final NavigateLinkAction previousLinkAction =
new NavigateLinkAction("previous-link-action");
private static final ActivateLinkAction activateLinkAction =
new ActivateLinkAction("activate-link-action");
private static final Action[] defaultActions = {
new InsertHTMLTextAction("InsertTable", INSERT_TABLE_HTML,
HTML.Tag.BODY, HTML.Tag.TABLE),
new InsertHTMLTextAction("InsertTableRow", INSERT_TABLE_HTML,
HTML.Tag.TABLE, HTML.Tag.TR,
HTML.Tag.BODY, HTML.Tag.TABLE),
new InsertHTMLTextAction("InsertTableDataCell", INSERT_TABLE_HTML,
HTML.Tag.TR, HTML.Tag.TD,
HTML.Tag.BODY, HTML.Tag.TABLE),
new InsertHTMLTextAction("InsertUnorderedList", INSERT_UL_HTML,
HTML.Tag.BODY, HTML.Tag.UL),
new InsertHTMLTextAction("InsertUnorderedListItem", INSERT_UL_HTML,
HTML.Tag.UL, HTML.Tag.LI,
HTML.Tag.BODY, HTML.Tag.UL),
new InsertHTMLTextAction("InsertOrderedList", INSERT_OL_HTML,
HTML.Tag.BODY, HTML.Tag.OL),
new InsertHTMLTextAction("InsertOrderedListItem", INSERT_OL_HTML,
HTML.Tag.OL, HTML.Tag.LI,
HTML.Tag.BODY, HTML.Tag.OL),
new InsertHRAction(),
new InsertHTMLTextAction("InsertPre", INSERT_PRE_HTML,
HTML.Tag.BODY, HTML.Tag.PRE),
nextLinkAction, previousLinkAction, activateLinkAction,
new BeginAction(beginAction, false),
new BeginAction(selectionBeginAction, true)
};
// link navigation support
private boolean foundLink = false;
private int prevHypertextOffset = -1;
private Object linkNavigationTag;
/**
* An abstract Action providing some convenience methods that may
* be useful in inserting HTML into an existing document.
* <p>NOTE: None of the convenience methods obtain a lock on the
* document. If you have another thread modifying the text these
* methods may have inconsistent behavior, or return the wrong thing.
*/
public static abstract class HTMLTextAction extends StyledTextAction {
public HTMLTextAction(String name) {
super(name);
}
/**
* @return HTMLDocument of <code>e</code>.
*/
protected HTMLDocument getHTMLDocument(JEditorPane e) {
Document d = e.getDocument();
if (d instanceof HTMLDocument) {
return (HTMLDocument) d;
}
throw new IllegalArgumentException("document must be HTMLDocument");
}
/**
* @return HTMLEditorKit for <code>e</code>.
*/
protected HTMLEditorKit getHTMLEditorKit(JEditorPane e) {
EditorKit k = e.getEditorKit();
if (k instanceof HTMLEditorKit) {
return (HTMLEditorKit) k;
}
throw new IllegalArgumentException("EditorKit must be HTMLEditorKit");
}
/**
* Returns an array of the Elements that contain <code>offset</code>.
* The first elements corresponds to the root.
*/
protected Element[] getElementsAt(HTMLDocument doc, int offset) {
return getElementsAt(doc.getDefaultRootElement(), offset, 0);
}
/**
* Recursive method used by getElementsAt.
*/
private Element[] getElementsAt(Element parent, int offset,
int depth) {
if (parent.isLeaf()) {
Element[] retValue = new Element[depth + 1];
retValue[depth] = parent;
return retValue;
}
Element[] retValue = getElementsAt(parent.getElement
(parent.getElementIndex(offset)), offset, depth + 1);
retValue[depth] = parent;
return retValue;
}
/**
* Returns number of elements, starting at the deepest leaf, needed
* to get to an element representing <code>tag</code>. This will
* return -1 if no elements is found representing <code>tag</code>,
* or 0 if the parent of the leaf at <code>offset</code> represents
* <code>tag</code>.
*/
protected int elementCountToTag(HTMLDocument doc, int offset,
HTML.Tag tag) {
int depth = -1;
Element e = doc.getCharacterElement(offset);
while (e != null && e.getAttributes().getAttribute
(StyleConstants.NameAttribute) != tag) {
e = e.getParentElement();
depth++;
}
if (e == null) {
return -1;
}
return depth;
}
/**
* Returns the deepest element at <code>offset</code> matching
* <code>tag</code>.
*/
protected Element findElementMatchingTag(HTMLDocument doc, int offset,
HTML.Tag tag) {
Element e = doc.getDefaultRootElement();
Element lastMatch = null;
while (e != null) {
if (e.getAttributes().getAttribute
(StyleConstants.NameAttribute) == tag) {
lastMatch = e;
}
e = e.getElement(e.getElementIndex(offset));
}
return lastMatch;
}
}
/**
* InsertHTMLTextAction can be used to insert an arbitrary string of HTML
* into an existing HTML document. At least two HTML.Tags need to be
* supplied. The first Tag, parentTag, identifies the parent in
* the document to add the elements to. The second tag, addTag,
* identifies the first tag that should be added to the document as
* seen in the HTML string. One important thing to remember, is that
* the parser is going to generate all the appropriate tags, even if
* they aren't in the HTML string passed in.<p>
* For example, lets say you wanted to create an action to insert
* a table into the body. The parentTag would be HTML.Tag.BODY,
* addTag would be HTML.Tag.TABLE, and the string could be something
* like <table><tr><td></td></tr></table>.
* <p>There is also an option to supply an alternate parentTag and
* addTag. These will be checked for if there is no parentTag at
* offset.
*/
public static class InsertHTMLTextAction extends HTMLTextAction {
public InsertHTMLTextAction(String name, String html,
HTML.Tag parentTag, HTML.Tag addTag) {
this(name, html, parentTag, addTag, null, null);
}
public InsertHTMLTextAction(String name, String html,
HTML.Tag parentTag,
HTML.Tag addTag,
HTML.Tag alternateParentTag,
HTML.Tag alternateAddTag) {
this(name, html, parentTag, addTag, alternateParentTag,
alternateAddTag, true);
}
/* public */
InsertHTMLTextAction(String name, String html,
HTML.Tag parentTag,
HTML.Tag addTag,
HTML.Tag alternateParentTag,
HTML.Tag alternateAddTag,
boolean adjustSelection) {
super(name);
this.html = html;
this.parentTag = parentTag;
this.addTag = addTag;
this.alternateParentTag = alternateParentTag;
this.alternateAddTag = alternateAddTag;
this.adjustSelection = adjustSelection;
}
/**
* A cover for HTMLEditorKit.insertHTML. If an exception it
* thrown it is wrapped in a RuntimeException and thrown.
*/
protected void insertHTML(JEditorPane editor, HTMLDocument doc,
int offset, String html, int popDepth,
int pushDepth, HTML.Tag addTag) {
try {
getHTMLEditorKit(editor).insertHTML(doc, offset, html,
popDepth, pushDepth,
addTag);
} catch (IOException ioe) {
throw new RuntimeException("Unable to insert: " + ioe);
} catch (BadLocationException ble) {
throw new RuntimeException("Unable to insert: " + ble);
}
}
/**
* This is invoked when inserting at a boundary. It determines
* the number of pops, and then the number of pushes that need
* to be performed, and then invokes insertHTML.
* @since 1.3
*/
protected void insertAtBoundary(JEditorPane editor, HTMLDocument doc,
int offset, Element insertElement,
String html, HTML.Tag parentTag,
HTML.Tag addTag) {
insertAtBoundry(editor, doc, offset, insertElement, html,
parentTag, addTag);
}
/**
* This is invoked when inserting at a boundary. It determines
* the number of pops, and then the number of pushes that need
* to be performed, and then invokes insertHTML.
* @deprecated As of Java 2 platform v1.3, use insertAtBoundary
*/
@Deprecated
protected void insertAtBoundry(JEditorPane editor, HTMLDocument doc,
int offset, Element insertElement,
String html, HTML.Tag parentTag,
HTML.Tag addTag) {
// Find the common parent.
Element e;
Element commonParent;
boolean isFirst = (offset == 0);
if (offset > 0 || insertElement == null) {
e = doc.getDefaultRootElement();
while (e != null && e.getStartOffset() != offset &&
!e.isLeaf()) {
e = e.getElement(e.getElementIndex(offset));
}
commonParent = (e != null) ? e.getParentElement() : null;
}
else {
// If inserting at the origin, the common parent is the
// insertElement.
commonParent = insertElement;
}
if (commonParent != null) {
// Determine how many pops to do.
int pops = 0;
int pushes = 0;
if (isFirst && insertElement != null) {
e = commonParent;
while (e != null && !e.isLeaf()) {
e = e.getElement(e.getElementIndex(offset));
pops++;
}
}
else {
e = commonParent;
offset--;
while (e != null && !e.isLeaf()) {
e = e.getElement(e.getElementIndex(offset));
pops++;
}
// And how many pushes
e = commonParent;
offset++;
while (e != null && e != insertElement) {
e = e.getElement(e.getElementIndex(offset));
pushes++;
}
}
pops = Math.max(0, pops - 1);
// And insert!
insertHTML(editor, doc, offset, html, pops, pushes, addTag);
}
}
/**
* If there is an Element with name <code>tag</code> at
* <code>offset</code>, this will invoke either insertAtBoundary
* or <code>insertHTML</code>. This returns true if there is
* a match, and one of the inserts is invoked.
*/
/*protected*/
boolean insertIntoTag(JEditorPane editor, HTMLDocument doc,
int offset, HTML.Tag tag, HTML.Tag addTag) {
Element e = findElementMatchingTag(doc, offset, tag);
if (e != null && e.getStartOffset() == offset) {
insertAtBoundary(editor, doc, offset, e, html,
tag, addTag);
return true;
}
else if (offset > 0) {
int depth = elementCountToTag(doc, offset - 1, tag);
if (depth != -1) {
insertHTML(editor, doc, offset, html, depth, 0, addTag);
return true;
}
}
return false;
}
/**
* Called after an insertion to adjust the selection.
*/
/* protected */
void adjustSelection(JEditorPane pane, HTMLDocument doc,
int startOffset, int oldLength) {
int newLength = doc.getLength();
if (newLength != oldLength && startOffset < newLength) {
if (startOffset > 0) {
String text;
try {
text = doc.getText(startOffset - 1, 1);
} catch (BadLocationException ble) {
text = null;
}
if (text != null && text.length() > 0 &&
text.charAt(0) == '\n') {
pane.select(startOffset, startOffset);
}
else {
pane.select(startOffset + 1, startOffset + 1);
}
}
else {
pane.select(1, 1);
}
}
}
/**
* Inserts the HTML into the document.
*
* @param ae the event
*/
public void actionPerformed(ActionEvent ae) {
JEditorPane editor = getEditor(ae);
if (editor != null) {
HTMLDocument doc = getHTMLDocument(editor);
int offset = editor.getSelectionStart();
int length = doc.getLength();
boolean inserted;
// Try first choice
if (!insertIntoTag(editor, doc, offset, parentTag, addTag) &&
alternateParentTag != null) {
// Then alternate.
inserted = insertIntoTag(editor, doc, offset,
alternateParentTag,
alternateAddTag);
}
else {
inserted = true;
}
if (adjustSelection && inserted) {
adjustSelection(editor, doc, offset, length);
}
}
}
/** HTML to insert. */
protected String html;
/** Tag to check for in the document. */
protected HTML.Tag parentTag;
/** Tag in HTML to start adding tags from. */
protected HTML.Tag addTag;
/** Alternate Tag to check for in the document if parentTag is
* not found. */
protected HTML.Tag alternateParentTag;
/** Alternate tag in HTML to start adding tags from if parentTag
* is not found and alternateParentTag is found. */
protected HTML.Tag alternateAddTag;
/** True indicates the selection should be adjusted after an insert. */
boolean adjustSelection;
}
/**
* InsertHRAction is special, at actionPerformed time it will determine
* the parent HTML.Tag based on the paragraph element at the selection
* start.
*/
static class InsertHRAction extends InsertHTMLTextAction {
InsertHRAction() {
super("InsertHR", "<hr>", null, HTML.Tag.IMPLIED, null, null,
false);
}
/**
* Inserts the HTML into the document.
*
* @param ae the event
*/
public void actionPerformed(ActionEvent ae) {
JEditorPane editor = getEditor(ae);
if (editor != null) {
HTMLDocument doc = getHTMLDocument(editor);
int offset = editor.getSelectionStart();
Element paragraph = doc.getParagraphElement(offset);
if (paragraph.getParentElement() != null) {
parentTag = (HTML.Tag)paragraph.getParentElement().
getAttributes().getAttribute
(StyleConstants.NameAttribute);
super.actionPerformed(ae);
}
}
}
}
/*
* Returns the object in an AttributeSet matching a key
*/
static private Object getAttrValue(AttributeSet attr, HTML.Attribute key) {
Enumeration names = attr.getAttributeNames();
while (names.hasMoreElements()) {
Object nextKey = names.nextElement();
Object nextVal = attr.getAttribute(nextKey);
if (nextVal instanceof AttributeSet) {
Object value = getAttrValue((AttributeSet)nextVal, key);
if (value != null) {
return value;
}
} else if (nextKey == key) {
return nextVal;
}
}
return null;
}
/*
* Action to move the focus on the next or previous hypertext link
* or object. TODO: This method relies on support from the
* javax.accessibility package. The text package should support
* keyboard navigation of text elements directly.
*/
static class NavigateLinkAction extends TextAction implements CaretListener {
private static final FocusHighlightPainter focusPainter =
new FocusHighlightPainter(null);
private final boolean focusBack;
/*
* Create this action with the appropriate identifier.
*/
public NavigateLinkAction(String actionName) {
super(actionName);
focusBack = "previous-link-action".equals(actionName);
}
/**
* Called when the caret position is updated.
*
* @param e the caret event
*/
public void caretUpdate(CaretEvent e) {
Object src = e.getSource();
if (src instanceof JTextComponent) {
JTextComponent comp = (JTextComponent) src;
HTMLEditorKit kit = getHTMLEditorKit(comp);
if (kit != null && kit.foundLink) {
kit.foundLink = false;
// TODO: The AccessibleContext for the editor should register
// as a listener for CaretEvents and forward the events to
// assistive technologies listening for such events.
comp.getAccessibleContext().firePropertyChange(
AccessibleContext.ACCESSIBLE_HYPERTEXT_OFFSET,
new Integer(kit.prevHypertextOffset),
new Integer(e.getDot()));
}
}
}
/*
* The operation to perform when this action is triggered.
*/
public void actionPerformed(ActionEvent e) {
JTextComponent comp = getTextComponent(e);
if (comp == null || comp.isEditable()) {
return;
}
Document doc = comp.getDocument();
HTMLEditorKit kit = getHTMLEditorKit(comp);
if (doc == null || kit == null) {
return;
}
// TODO: Should start successive iterations from the
// current caret position.
ElementIterator ei = new ElementIterator(doc);
int currentOffset = comp.getCaretPosition();
int prevStartOffset = -1;
int prevEndOffset = -1;
// highlight the next link or object after the current caret position
Element nextElement = null;
while ((nextElement = ei.next()) != null) {
String name = nextElement.getName();
AttributeSet attr = nextElement.getAttributes();
Object href = getAttrValue(attr, HTML.Attribute.HREF);
if (!(name.equals(HTML.Tag.OBJECT.toString())) && href == null) {
continue;
}
int elementOffset = nextElement.getStartOffset();
if (focusBack) {
if (elementOffset >= currentOffset &&
prevStartOffset >= 0) {
kit.foundLink = true;
comp.setCaretPosition(prevStartOffset);
moveCaretPosition(comp, kit, prevStartOffset,
prevEndOffset);
kit.prevHypertextOffset = prevStartOffset;
return;
}
} else { // focus forward
if (elementOffset > currentOffset) {
kit.foundLink = true;
comp.setCaretPosition(elementOffset);
moveCaretPosition(comp, kit, elementOffset,
nextElement.getEndOffset());
kit.prevHypertextOffset = elementOffset;
return;
}
}
prevStartOffset = nextElement.getStartOffset();
prevEndOffset = nextElement.getEndOffset();
}
if (focusBack && prevStartOffset >= 0) {
kit.foundLink = true;
comp.setCaretPosition(prevStartOffset);
moveCaretPosition(comp, kit, prevStartOffset, prevEndOffset);
kit.prevHypertextOffset = prevStartOffset;
return;
}
}
/*
* Moves the caret from mark to dot
*/
private void moveCaretPosition(JTextComponent comp, HTMLEditorKit kit,
int mark, int dot) {
Highlighter h = comp.getHighlighter();
if (h != null) {
int p0 = Math.min(dot, mark);
int p1 = Math.max(dot, mark);
try {
if (kit.linkNavigationTag != null) {
h.changeHighlight(kit.linkNavigationTag, p0, p1);
} else {
kit.linkNavigationTag =
h.addHighlight(p0, p1, focusPainter);
}
} catch (BadLocationException e) {
}
}
}
private HTMLEditorKit getHTMLEditorKit(JTextComponent comp) {
if (comp instanceof JEditorPane) {
EditorKit kit = ((JEditorPane) comp).getEditorKit();
if (kit instanceof HTMLEditorKit) {
return (HTMLEditorKit) kit;
}
}
return null;
}
/**
* A highlight painter that draws a one-pixel border around
* the highlighted area.
*/
static class FocusHighlightPainter extends
DefaultHighlighter.DefaultHighlightPainter {
FocusHighlightPainter(Color color) {
super(color);
}
/**
* Paints a portion of a highlight.
*
* @param g the graphics context
* @param offs0 the starting model offset >= 0
* @param offs1 the ending model offset >= offs1
* @param bounds the bounding box of the view, which is not
* necessarily the region to paint.
* @param c the editor
* @param view View painting for
* @return region in which drawing occurred
*/
public Shape paintLayer(Graphics g, int offs0, int offs1,
Shape bounds, JTextComponent c, View view) {
Color color = getColor();
if (color == null) {
g.setColor(c.getSelectionColor());
}
else {
g.setColor(color);
}
if (offs0 == view.getStartOffset() &&
offs1 == view.getEndOffset()) {
// Contained in view, can just use bounds.
Rectangle alloc;
if (bounds instanceof Rectangle) {
alloc = (Rectangle)bounds;
}
else {
alloc = bounds.getBounds();
}
g.drawRect(alloc.x, alloc.y, alloc.width - 1, alloc.height);
return alloc;
}
else {
// Should only render part of View.
try {
// --- determine locations ---
Shape shape = view.modelToView(offs0, Position.Bias.Forward,
offs1,Position.Bias.Backward,
bounds);
Rectangle r = (shape instanceof Rectangle) ?
(Rectangle)shape : shape.getBounds();
g.drawRect(r.x, r.y, r.width - 1, r.height);
return r;
} catch (BadLocationException e) {
// can't render
}
}
// Only if exception
return null;
}
}
}
/*
* Action to activate the hypertext link that has focus.
* TODO: This method relies on support from the
* javax.accessibility package. The text package should support
* keyboard navigation of text elements directly.
*/
static class ActivateLinkAction extends TextAction {
/**
* Create this action with the appropriate identifier.
*/
public ActivateLinkAction(String actionName) {
super(actionName);
}
/*
* activates the hyperlink at offset
*/
private void activateLink(String href, HTMLDocument doc,
JEditorPane editor, int offset) {
try {
URL page =
(URL)doc.getProperty(Document.StreamDescriptionProperty);
URL url = new URL(page, href);
HyperlinkEvent linkEvent = new HyperlinkEvent
(editor, HyperlinkEvent.EventType.
ACTIVATED, url, url.toExternalForm(),
doc.getCharacterElement(offset));
editor.fireHyperlinkUpdate(linkEvent);
} catch (MalformedURLException m) {
}
}
/*
* Invokes default action on the object in an element
*/
private void doObjectAction(JEditorPane editor, Element elem) {
View view = getView(editor, elem);
if (view != null && view instanceof ObjectView) {
Component comp = ((ObjectView)view).getComponent();
if (comp != null && comp instanceof Accessible) {
AccessibleContext ac = ((Accessible)comp).getAccessibleContext();
if (ac != null) {
AccessibleAction aa = ac.getAccessibleAction();
if (aa != null) {
aa.doAccessibleAction(0);
}
}
}
}
}
/*
* Returns the root view for a document
*/
private View getRootView(JEditorPane editor) {
return editor.getUI().getRootView(editor);
}
/*
* Returns a view associated with an element
*/
private View getView(JEditorPane editor, Element elem) {
Object lock = lock(editor);
try {
View rootView = getRootView(editor);
int start = elem.getStartOffset();
if (rootView != null) {
return getView(rootView, elem, start);
}
return null;
} finally {
unlock(lock);
}
}
private View getView(View parent, Element elem, int start) {
if (parent.getElement() == elem) {
return parent;
}
int index = parent.getViewIndex(start, Position.Bias.Forward);
if (index != -1 && index < parent.getViewCount()) {
return getView(parent.getView(index), elem, start);
}
return null;
}
/*
* If possible acquires a lock on the Document. If a lock has been
* obtained a key will be retured that should be passed to
* <code>unlock</code>.
*/
private Object lock(JEditorPane editor) {
Document document = editor.getDocument();
if (document instanceof AbstractDocument) {
((AbstractDocument)document).readLock();
return document;
}
return null;
}
/*
* Releases a lock previously obtained via <code>lock</code>.
*/
private void unlock(Object key) {
if (key != null) {
((AbstractDocument)key).readUnlock();
}
}
/*
* The operation to perform when this action is triggered.
*/
public void actionPerformed(ActionEvent e) {
JTextComponent c = getTextComponent(e);
if (c.isEditable() || !(c instanceof JEditorPane)) {
return;
}
JEditorPane editor = (JEditorPane)c;
Document d = editor.getDocument();
if (d == null || !(d instanceof HTMLDocument)) {
return;
}
HTMLDocument doc = (HTMLDocument)d;
ElementIterator ei = new ElementIterator(doc);
int currentOffset = editor.getCaretPosition();
// invoke the next link or object action
String urlString = null;
String objString = null;
Element currentElement = null;
while ((currentElement = ei.next()) != null) {
String name = currentElement.getName();
AttributeSet attr = currentElement.getAttributes();
Object href = getAttrValue(attr, HTML.Attribute.HREF);
if (href != null) {
if (currentOffset >= currentElement.getStartOffset() &&
currentOffset <= currentElement.getEndOffset()) {
activateLink((String)href, doc, editor, currentOffset);
return;
}
} else if (name.equals(HTML.Tag.OBJECT.toString())) {
Object obj = getAttrValue(attr, HTML.Attribute.CLASSID);
if (obj != null) {
if (currentOffset >= currentElement.getStartOffset() &&
currentOffset <= currentElement.getEndOffset()) {
doObjectAction(editor, currentElement);
return;
}
}
}
}
}
}
private static int getBodyElementStart(JTextComponent comp) {
Element rootElement = comp.getDocument().getRootElements()[0];
for (int i = 0; i < rootElement.getElementCount(); i++) {
Element currElement = rootElement.getElement(i);
if("body".equals(currElement.getName())) {
return currElement.getStartOffset();
}
}
return 0;
}
/*
* Move the caret to the beginning of the document.
* @see DefaultEditorKit#beginAction
* @see HTMLEditorKit#getActions
*/
static class BeginAction extends TextAction {
/* Create this object with the appropriate identifier. */
BeginAction(String nm, boolean select) {
super(nm);
this.select = select;
}
/** The operation to perform when this action is triggered. */
public void actionPerformed(ActionEvent e) {
JTextComponent target = getTextComponent(e);
int bodyStart = getBodyElementStart(target);
if (target != null) {
if (select) {
target.moveCaretPosition(bodyStart);
} else {
target.setCaretPosition(bodyStart);
}
}
}
private boolean select;
}
}