/* * @(#)ImageView.java	1.56 03/12/19 * * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */package javax.swing.text.html;import java.awt.*;import java.awt.event.*;import java.awt.image.ImageObserver;import java.io.*;import java.net.*;import java.util.Dictionary;import javax.swing.*;import javax.swing.text.*;import javax.swing.event.*;/** * View of an Image, intended to support the HTML &lt;IMG&gt; tag. * Supports scaling via the HEIGHT and WIDTH attributes of the tag. * If the image is unable to be loaded any text specified via the * <code>ALT</code> attribute will be rendered. * <p> * While this class has been part of swing for a while now, it is public * as of 1.4. * * @author  Scott Violet * @version 1.56 12/19/03 * @see IconView * @since 1.4 */public class ImageView extends View {    /**     * If true, when some of the bits are available a repaint is done.     * <p>     * This is set to false as swing does not offer a repaint that takes a     * delay. If this were true, a bunch of immediate repaints would get     * generated that end up significantly delaying the loading of the image     * (or anything else going on for that matter).     */    private static boolean sIsInc = false;    /**     * Repaint delay when some of the bits are available.     */    private static int sIncRate = 100;    /**     * Icon used while the image is being loaded.     */    private static Icon sPendingImageIcon;    /**     * Icon used if the image could not be found.     */    private static Icon sMissingImageIcon;    /**     * File name for <code>sPendingImageIcon</code>.     */    private static final String PENDING_IMAGE_SRC = "icons/image-delayed.gif";    /**     * File name for <code>sMissingImageIcon</code>.     */    private static final String MISSING_IMAGE_SRC = "icons/image-failed.gif";    /**     * Document property for image cache.     */    private static final String IMAGE_CACHE_PROPERTY = "imageCache";        // Height/width to use before we know the real size, these should at least    // the size of <code>sMissingImageIcon</code> and    // <code>sPendingImageIcon</code>    private static final int DEFAULT_WIDTH = 38;    private static final int DEFAULT_HEIGHT= 38;    /**     * Default border to use if one is not specified.     */    private static final int DEFAULT_BORDER = 2;    // Bitmask values    private static final int LOADING_FLAG = 1;    private static final int LINK_FLAG = 2;    private static final int WIDTH_FLAG = 4;    private static final int HEIGHT_FLAG = 8;    private static final int RELOAD_FLAG = 16;    private static final int RELOAD_IMAGE_FLAG = 32;    private static final int SYNC_LOAD_FLAG = 64;    private AttributeSet attr;    private Image image;    private int width;    private int height;    /** Bitmask containing some of the above bitmask values. Because the     * image loading notification can happen on another thread access to     * this is synchronized (at least for modifying it). */    private int state;    private Container container;    private Rectangle fBounds;    private Color borderColor;    // Size of the border, the insets contains this valid. For example, if    // the HSPACE attribute was 4 and BORDER 2, leftInset would be 6.    private short borderSize;    // Insets, obtained from the painter.    private short leftInset;    private short rightInset;    private short topInset;    private short bottomInset;    /**     * We don't directly implement ImageObserver, instead we use an instance     * that calls back to us.     */    private ImageObserver imageObserver;    /**     * Used for alt text. Will be non-null if the image couldn't be found,     * and there is valid alt text.     */    private View altView;    /** Alignment along the vertical (Y) axis. */    private float vAlign;    /**     * Creates a new view that represents an IMG element.     *     * @param elem the element to create a view for     */    public ImageView(Element elem) {    	super(elem);	fBounds = new Rectangle();        imageObserver = new ImageHandler();        state = RELOAD_FLAG | RELOAD_IMAGE_FLAG;    }    /**     * Returns the text to display if the image can't be loaded. This is     * obtained from the Elements attribute set with the attribute name     * <code>HTML.Attribute.ALT</code>.     */    public String getAltText() {        return (String)getElement().getAttributes().getAttribute            (HTML.Attribute.ALT);    }    /**     * Return a URL for the image source,      * or null if it could not be determined.     */    public URL getImageURL() { 	String src = (String)getElement().getAttributes().                             getAttribute(HTML.Attribute.SRC); 	if (src == null) {            return null;        }	URL reference = ((HTMLDocument)getDocument()).getBase();        try { 	    URL u = new URL(reference,src);	    return u;        } catch (MalformedURLException e) {	    return null;        }    }        /**     * Returns the icon to use if the image couldn't be found.     */    public Icon getNoImageIcon() {        loadDefaultIconsIfNecessary();        return sMissingImageIcon;    }    /**     * Returns the icon to use while in the process of loading the image.     */    public Icon getLoadingImageIcon() {        loadDefaultIconsIfNecessary();        return sPendingImageIcon;    }    /**     * Returns the image to render.     */    public Image getImage() {        sync();        return image;    }    /**     * Sets how the image is loaded. If <code>newValue</code> is true,     * the image we be loaded when first asked for, otherwise it will     * be loaded asynchronously. The default is to not load synchronously,     * that is to load the image asynchronously.     */    public void setLoadsSynchronously(boolean newValue) {        synchronized(this) {            if (newValue) {                state |= SYNC_LOAD_FLAG;            }            else {                state = (state | SYNC_LOAD_FLAG) ^ SYNC_LOAD_FLAG;            }        }    }    /**     * Returns true if the image should be loaded when first asked for.     */    public boolean getLoadsSynchronously() {        return ((state & SYNC_LOAD_FLAG) != 0);    }    /**     * Convenience method to get the StyleSheet.     */    protected StyleSheet getStyleSheet() {	HTMLDocument doc = (HTMLDocument) getDocument();	return doc.getStyleSheet();    }    /**     * Fetches the attributes to use when rendering.  This is     * implemented to multiplex the attributes specified in the     * model with a StyleSheet.     */    public AttributeSet getAttributes() {        sync();	return attr;    }    /**     * For images the tooltip text comes from text specified with the     * <code>ALT</code> attribute. This is overriden to return     * <code>getAltText</code>.     *     * @see JTextComponent#getToolTipText     */    public String getToolTipText(float x, float y, Shape allocation) {        return getAltText();    }    /**     * Update any cached values that come from attributes.     */    protected void setPropertiesFromAttributes() {        StyleSheet sheet = getStyleSheet();        this.attr = sheet.getViewAttributes(this);        // Gutters        borderSize = (short)getIntAttr(HTML.Attribute.BORDER, isLink() ?                                       DEFAULT_BORDER : 0);        leftInset = rightInset = (short)(getIntAttr(HTML.Attribute.HSPACE,                                                    0) + borderSize);        topInset = bottomInset = (short)(getIntAttr(HTML.Attribute.VSPACE,                                                    0) + borderSize);        borderColor = ((StyledDocument)getDocument()).getForeground                      (getAttributes());        AttributeSet attr = getElement().getAttributes();        // Alignment.        // PENDING: This needs to be changed to support the CSS versions        // when conversion from ALIGN to VERTICAL_ALIGN is complete.        Object alignment = attr.getAttribute(HTML.Attribute.ALIGN);        vAlign = 1.0f;        if (alignment != null) {            alignment = alignment.toString();            if ("top".equals(alignment)) {                vAlign = 0f;            }            else if ("middle".equals(alignment)) {                vAlign = .5f;            }        }        AttributeSet anchorAttr = (AttributeSet)attr.getAttribute(HTML.Tag.A);        if (anchorAttr != null && anchorAttr.isDefined            (HTML.Attribute.HREF)) {            synchronized(this) {                state |= LINK_FLAG;            }        }        else {            synchronized(this) {                state = (state | LINK_FLAG) ^ LINK_FLAG;            }        }    }    /**     * Establishes the parent view for this view.     * Seize this moment to cache the AWT Container I'm in.     */    public void setParent(View parent) {        View oldParent = getParent();	super.setParent(parent);	container = (parent != null) ? getContainer() : null;        if (oldParent != parent) {            synchronized(this) {                state |= RELOAD_FLAG;            }        }    }    /**     * Invoked when the Elements attributes have changed. Recreates the image.     */    public void changedUpdate(DocumentEvent e, Shape a, ViewFactory f) {    	super.changedUpdate(e,a,f);        synchronized(this) {            state |= RELOAD_FLAG | RELOAD_IMAGE_FLAG;        }        // Assume the worst.        preferenceChanged(null, true, true);    }    /**     * Paints the View.     *     * @param g the rendering surface to use     * @param a the allocated region to render into     * @see View#paint     */    public void paint(Graphics g, Shape a) {        sync();	Rectangle rect = (a instanceof Rectangle) ? (Rectangle)a :                         a.getBounds();        Image image = getImage();        Rectangle clip = g.getClipBounds();	fBounds.setBounds(rect);        paintHighlights(g, a);        paintBorder(g, rect);        if (clip != null) {            g.clipRect(rect.x + leftInset, rect.y + topInset,                       rect.width - leftInset - rightInset,                       rect.height - topInset - bottomInset);        }        if (image != null) {