Back to index...

	/*
	* Copyright (c) 1998, 2019, 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.plaf.basic;

	import java.io.*;
	import java.awt.*;
	import java.net.URL;

	import javax.accessibility.AccessibleContext;
	import javax.swing.*;
	import javax.swing.text.*;
	import javax.swing.text.html.*;

	import sun.swing.SwingUtilities2;

	/**
	* Support for providing html views for the swing components.
	* This translates a simple html string to a javax.swing.text.View
	* implementation that can render the html and provide the necessary
	* layout semantics.
	*
	* @author Timothy Prinzing
	* @since 1.3
	*/
	public class BasicHTML {

	/**
	* Create an html renderer for the given component and
	* string of html.
	*/
	public static View createHTMLView(JComponent c, String html) {
	BasicEditorKit kit = getFactory();
	Document doc = kit.createDefaultDocument(c.getFont(),
	c.getForeground());
	Object base = c.getClientProperty(documentBaseKey);
	if (base instanceof URL) {
	((HTMLDocument)doc).setBase((URL)base);
	}
	Reader r = new StringReader(html);
	try {
	kit.read(r, doc, 0);
	} catch (Throwable e) {
	}
	ViewFactory f = kit.getViewFactory();
	View hview = f.create(doc.getDefaultRootElement());
	View v = new Renderer(c, f, hview);
	return v;
	}

	/**
	* Returns the baseline for the html renderer.
	*
	* @param view the View to get the baseline for
	* @param w the width to get the baseline for
	* @param h the height to get the baseline for
	* @throws IllegalArgumentException if width or height is < 0
	* @return baseline or a value < 0 indicating there is no reasonable
	* baseline
	* @see java.awt.FontMetrics
	* @see javax.swing.JComponent#getBaseline(int,int)
	* @since 1.6
	*/
	public static int getHTMLBaseline(View view, int w, int h) {
	if (w < 0 \|\| h < 0) {
	throw new IllegalArgumentException(
	"Width and height must be >= 0");
	}
	if (view instanceof Renderer) {
	return getBaseline(view.getView(0), w, h);
	}
	return -1;
	}

	/**
	* Gets the baseline for the specified component. This digs out
	* the View client property, and if non-null the baseline is calculated
	* from it. Otherwise the baseline is the value <code>y + ascent</code>.
	*/
	static int getBaseline(JComponent c, int y, int ascent,
	int w, int h) {
	View view = (View)c.getClientProperty(BasicHTML.propertyKey);
	if (view != null) {
	int baseline = getHTMLBaseline(view, w, h);
	if (baseline < 0) {
	return baseline;
	}
	return y + baseline;
	}
	return y + ascent;
	}

	/**
	* Gets the baseline for the specified View.
	*/
	static int getBaseline(View view, int w, int h) {
	if (hasParagraph(view)) {
	view.setSize(w, h);
	return getBaseline(view, new Rectangle(0, 0, w, h));
	}
	return -1;
	}

	private static int getBaseline(View view, Shape bounds) {
	if (view.getViewCount() == 0) {
	return -1;
	}
	AttributeSet attributes = view.getElement().getAttributes();
	Object name = null;
	if (attributes != null) {
	name = attributes.getAttribute(StyleConstants.NameAttribute);
	}
	int index = 0;
	if (name == HTML.Tag.HTML && view.getViewCount() > 1) {
	// For html on widgets the header is not visible, skip it.
	index++;
	}
	bounds = view.getChildAllocation(index, bounds);
	if (bounds == null) {
	return -1;
	}
	View child = view.getView(index);
	if (view instanceof javax.swing.text.ParagraphView) {
	Rectangle rect;
	if (bounds instanceof Rectangle) {
	rect = (Rectangle)bounds;
	}
	else {
	rect = bounds.getBounds();
	}
	return rect.y + (int)(rect.height *
	child.getAlignment(View.Y_AXIS));
	}
	return getBaseline(child, bounds);
	}

	private static boolean hasParagraph(View view) {
	if (view instanceof javax.swing.text.ParagraphView) {
	return true;
	}
	if (view.getViewCount() == 0) {
	return false;
	}
	AttributeSet attributes = view.getElement().getAttributes();
	Object name = null;
	if (attributes != null) {
	name = attributes.getAttribute(StyleConstants.NameAttribute);
	}
	int index = 0;
	if (name == HTML.Tag.HTML && view.getViewCount() > 1) {
	// For html on widgets the header is not visible, skip it.
	index = 1;
	}
	return hasParagraph(view.getView(index));
	}

	/**
	* Check the given string to see if it should trigger the
	* html rendering logic in a non-text component that supports
	* html rendering.
	*/
	public static boolean isHTMLString(String s) {
	if (s != null) {
	if ((s.length() >= 6) && (s.charAt(0) == '<') && (s.charAt(5) == '>')) {
	String tag = s.substring(1,5);
	return tag.equalsIgnoreCase(propertyKey);
	}
	}
	return false;
	}

	/**
	* Stash the HTML render for the given text into the client
	* properties of the given JComponent. If the given text is
	* <em>NOT HTML</em> the property will be cleared of any
	* renderer.
	* <p>
	* This method is useful for ComponentUI implementations
	* that are static (i.e. shared) and get their state
	* entirely from the JComponent.
	*/
	public static void updateRenderer(JComponent c, String text) {
	View value = null;
	View oldValue = (View)c.getClientProperty(BasicHTML.propertyKey);
	Boolean htmlDisabled = (Boolean) c.getClientProperty(htmlDisable);
	if (htmlDisabled != Boolean.TRUE && BasicHTML.isHTMLString(text)) {
	value = BasicHTML.createHTMLView(c, text);
	}
	if (value != oldValue && oldValue != null) {
	for (int i = 0; i < oldValue.getViewCount(); i++) {
	oldValue.getView(i).setParent(null);
	}
	}
	c.putClientProperty(BasicHTML.propertyKey, value);
	String currentAccessibleNameProperty =
	(String) c.getClientProperty(AccessibleContext.ACCESSIBLE_NAME_PROPERTY);
	String previousParsedText = null;
	if (currentAccessibleNameProperty != null && oldValue != null) {
	try {
	previousParsedText =
	(oldValue.getDocument().getText(0, oldValue.getDocument().getLength())).trim();
	} catch (BadLocationException e) {
	}
	}

	// AccessibleContext.ACCESSIBLE_NAME_PROPERTY should be set from here only if,
	// 1. If AccessibleContext.ACCESSIBLE_NAME_PROPERTY was NOT set before
	// i.e. currentAccessibleNameProperty is null. and,
	// 2. If AccessibleContext.ACCESSIBLE_NAME_PROPERTY was previously set from this method
	// using the value.getDocument().getText().
	if (currentAccessibleNameProperty == null \|\|
	currentAccessibleNameProperty.equals(previousParsedText)) {
	String parsedText = null;
	if (value != null) {
	try {
	parsedText =
	(value.getDocument().getText(0, value.getDocument().getLength())).trim();
	} catch (BadLocationException e) {
	}
	}
	c.putClientProperty(AccessibleContext.ACCESSIBLE_NAME_PROPERTY, parsedText);
	}
	}

	/**
	* If this client property of a JComponent is set to Boolean.TRUE
	* the component's 'text' property is never treated as HTML.
	*/
	private static final String htmlDisable = "html.disable";

	/**
	* Key to use for the html renderer when stored as a
	* client property of a JComponent.
	*/
	public static final String propertyKey = "html";

	/**
	* Key stored as a client property to indicate the base that relative
	* references are resolved against. For example, lets say you keep
	* your images in the directory resources relative to the code path,
	* you would use the following the set the base:
	* <pre>
	* jComponent.putClientProperty(documentBaseKey,
	* xxx.class.getResource("resources/"));
	* </pre>
	*/
	public static final String documentBaseKey = "html.base";

	static BasicEditorKit getFactory() {
	if (basicHTMLFactory == null) {
	basicHTMLViewFactory = new BasicHTMLViewFactory();
	basicHTMLFactory = new BasicEditorKit();
	}
	return basicHTMLFactory;
	}

	/**
	* The source of the html renderers
	*/
	private static BasicEditorKit basicHTMLFactory;

	/**
	* Creates the Views that visually represent the model.
	*/
	private static ViewFactory basicHTMLViewFactory;

	/**
	* Overrides to the default stylesheet. Should consider
	* just creating a completely fresh stylesheet.
	*/
	private static final String styleChanges =
	"p { margin-top: 0; margin-bottom: 0; margin-left: 0; margin-right: 0 }" +
	"body { margin-top: 0; margin-bottom: 0; margin-left: 0; margin-right: 0 }";

	/**
	* The views produced for the ComponentUI implementations aren't
	* going to be edited and don't need full html support. This kit
	* alters the HTMLEditorKit to try and trim things down a bit.
	* It does the following:
	* <ul>
	* <li>It doesn't produce Views for things like comments,
	* head, title, unknown tags, etc.
	* <li>It installs a different set of css settings from the default
	* provided by HTMLEditorKit.
	* </ul>
	*/
	static class BasicEditorKit extends HTMLEditorKit {
	/** Shared base style for all documents created by us use. */
	private static StyleSheet defaultStyles;

	/**
	* Overriden to return our own slimmed down style sheet.
	*/
	public StyleSheet getStyleSheet() {
	if (defaultStyles == null) {
	defaultStyles = new StyleSheet();
	StringReader r = new StringReader(styleChanges);
	try {
	defaultStyles.loadRules(r, null);
	} catch (Throwable e) {
	// don't want to die in static initialization...
	// just display things wrong.
	}
	r.close();
	defaultStyles.addStyleSheet(super.getStyleSheet());
	}
	return defaultStyles;
	}

	/**
	* Sets the async policy to flush everything in one chunk, and
	* to not display unknown tags.
	*/
	public Document createDefaultDocument(Font defaultFont,
	Color foreground) {
	StyleSheet styles = getStyleSheet();
	StyleSheet ss = new StyleSheet();
	ss.addStyleSheet(styles);
	BasicDocument doc = new BasicDocument(ss, defaultFont, foreground);
	doc.setAsynchronousLoadPriority(Integer.MAX_VALUE);
	doc.setPreservesUnknownTags(false);
	return doc;
	}

	/**
	* Returns the ViewFactory that is used to make sure the Views don't
	* load in the background.
	*/
	public ViewFactory getViewFactory() {
	return basicHTMLViewFactory;
	}
	}


	/**
	* BasicHTMLViewFactory extends HTMLFactory to force images to be loaded
	* synchronously.
	*/
	static class BasicHTMLViewFactory extends HTMLEditorKit.HTMLFactory {
	public View create(Element elem) {
	View view = super.create(elem);

	if (view instanceof ImageView) {
	((ImageView)view).setLoadsSynchronously(true);
	}
	return view;
	}
	}


	/**
	* The subclass of HTMLDocument that is used as the model. getForeground
	* is overridden to return the foreground property from the Component this
	* was created for.
	*/
	static class BasicDocument extends HTMLDocument {
	/** The host, that is where we are rendering. */
	// private JComponent host;

	BasicDocument(StyleSheet s, Font defaultFont, Color foreground) {
	super(s);
	setPreservesUnknownTags(false);
	setFontAndColor(defaultFont, foreground);
	}

	/**
	* Sets the default font and default color. These are set by
	* adding a rule for the body that specifies the font and color.
	* This allows the html to override these should it wish to have
	* a custom font or color.
	*/
	private void setFontAndColor(Font font, Color fg) {
	getStyleSheet().addRule(sun.swing.SwingUtilities2.
	displayPropertiesToCSS(font,fg));
	}
	}


	/**
	* Root text view that acts as an HTML renderer.
	*/
	static class Renderer extends View {

	Renderer(JComponent c, ViewFactory f, View v) {
	super(null);
	host = c;
	factory = f;
	view = v;
	view.setParent(this);
	// initially layout to the preferred size
	setSize(view.getPreferredSpan(X_AXIS), view.getPreferredSpan(Y_AXIS));
	}

	/**
	* Fetches the attributes to use when rendering. At the root
	* level there are no attributes. If an attribute is resolved
	* up the view hierarchy this is the end of the line.
	*/
	public AttributeSet getAttributes() {
	return null;
	}

	/**
	* Determines the preferred span for this view along an axis.
	*
	* @param axis may be either X_AXIS or Y_AXIS
	* @return the span the view would like to be rendered into.
	* Typically the view is told to render into the span
	* that is returned, although there is no guarantee.
	* The parent may choose to resize or break the view.
	*/
	public float getPreferredSpan(int axis) {
	if (axis == X_AXIS) {
	// width currently laid out to
	return width;
	}
	return view.getPreferredSpan(axis);
	}

	/**
	* Determines the minimum span for this view along an axis.
	*
	* @param axis may be either X_AXIS or Y_AXIS
	* @return the span the view would like to be rendered into.
	* Typically the view is told to render into the span
	* that is returned, although there is no guarantee.
	* The parent may choose to resize or break the view.
	*/
	public float getMinimumSpan(int axis) {
	return view.getMinimumSpan(axis);
	}

	/**
	* Determines the maximum span for this view along an axis.
	*
	* @param axis may be either X_AXIS or Y_AXIS
	* @return the span the view would like to be rendered into.
	* Typically the view is told to render into the span
	* that is returned, although there is no guarantee.
	* The parent may choose to resize or break the view.
	*/
	public float getMaximumSpan(int axis) {
	return Integer.MAX_VALUE;
	}

	/**
	* Specifies that a preference has changed.
	* Child views can call this on the parent to indicate that
	* the preference has changed. The root view routes this to
	* invalidate on the hosting component.
	* <p>
	* This can be called on a different thread from the
	* event dispatching thread and is basically unsafe to
	* propagate into the component. To make this safe,
	* the operation is transferred over to the event dispatching
	* thread for completion. It is a design goal that all view
	* methods be safe to call without concern for concurrency,
	* and this behavior helps make that true.
	*
	* @param child the child view
	* @param width true if the width preference has changed
	* @param height true if the height preference has changed
	*/
	public void preferenceChanged(View child, boolean width, boolean height) {
	host.revalidate();
	host.repaint();
	}

	/**
	* Determines the desired alignment for this view along an axis.
	*
	* @param axis may be either X_AXIS or Y_AXIS
	* @return the desired alignment, where 0.0 indicates the origin
	* and 1.0 the full span away from the origin
	*/
	public float getAlignment(int axis) {
	return view.getAlignment(axis);
	}

	/**
	* Renders the view.
	*
	* @param g the graphics context
	* @param allocation the region to render into
	*/
	public void paint(Graphics g, Shape allocation) {
	Rectangle alloc = allocation.getBounds();
	view.setSize(alloc.width, alloc.height);
	view.paint(g, allocation);
	}

	/**
	* Sets the view parent.
	*
	* @param parent the parent view
	*/
	public void setParent(View parent) {
	throw new Error("Can't set parent on root view");
	}

	/**
	* Returns the number of views in this view. Since
	* this view simply wraps the root of the view hierarchy
	* it has exactly one child.
	*
	* @return the number of views
	* @see #getView
	*/
	public int getViewCount() {
	return 1;
	}

	/**
	* Gets the n-th view in this container.
	*
	* @param n the number of the view to get
	* @return the view
	*/
	public View getView(int n) {
	return view;
	}

	/**
	* Provides a mapping from the document model coordinate space
	* to the coordinate space of the view mapped to it.
	*
	* @param pos the position to convert
	* @param a the allocated region to render into
	* @return the bounding box of the given position
	*/
	public Shape modelToView(int pos, Shape a, Position.Bias b) throws BadLocationException {
	return view.modelToView(pos, a, b);
	}

	/**
	* Provides a mapping from the document model coordinate space
	* to the coordinate space of the view mapped to it.
	*
	* @param p0 the position to convert >= 0
	* @param b0 the bias toward the previous character or the
	* next character represented by p0, in case the
	* position is a boundary of two views.
	* @param p1 the position to convert >= 0
	* @param b1 the bias toward the previous character or the
	* next character represented by p1, in case the
	* position is a boundary of two views.
	* @param a the allocated region to render into
	* @return the bounding box of the given position is returned
	* @exception BadLocationException if the given position does
	* not represent a valid location in the associated document
	* @exception IllegalArgumentException for an invalid bias argument
	* @see View#viewToModel
	*/
	public Shape modelToView(int p0, Position.Bias b0, int p1,
	Position.Bias b1, Shape a) throws BadLocationException {
	return view.modelToView(p0, b0, p1, b1, a);
	}

	/**
	* Provides a mapping from the view coordinate space to the logical
	* coordinate space of the model.
	*
	* @param x x coordinate of the view location to convert
	* @param y y coordinate of the view location to convert
	* @param a the allocated region to render into
	* @return the location within the model that best represents the
	* given point in the view
	*/
	public int viewToModel(float x, float y, Shape a, Position.Bias[] bias) {
	return view.viewToModel(x, y, a, bias);
	}

	/**
	* Returns the document model underlying the view.
	*
	* @return the model
	*/
	public Document getDocument() {
	return view.getDocument();
	}

	/**
	* Returns the starting offset into the model for this view.
	*
	* @return the starting offset
	*/
	public int getStartOffset() {
	return view.getStartOffset();
	}

	/**
	* Returns the ending offset into the model for this view.
	*
	* @return the ending offset
	*/
	public int getEndOffset() {
	return view.getEndOffset();
	}

	/**
	* Gets the element that this view is mapped to.
	*
	* @return the view
	*/
	public Element getElement() {
	return view.getElement();
	}

	/**
	* Sets the view size.
	*
	* @param width the width
	* @param height the height
	*/
	public void setSize(float width, float height) {
	this.width = (int) width;
	view.setSize(width, height);
	}

	/**
	* Fetches the container hosting the view. This is useful for
	* things like scheduling a repaint, finding out the host
	* components font, etc. The default implementation
	* of this is to forward the query to the parent view.
	*
	* @return the container
	*/
	public Container getContainer() {
	return host;
	}

	/**
	* Fetches the factory to be used for building the
	* various view fragments that make up the view that
	* represents the model. This is what determines
	* how the model will be represented. This is implemented
	* to fetch the factory provided by the associated
	* EditorKit.
	*
	* @return the factory
	*/
	public ViewFactory getViewFactory() {
	return factory;
	}

	private int width;
	private View view;
	private ViewFactory factory;
	private JComponent host;

	}
	}

Back to index...