594 lines
15 KiB
Java
594 lines
15 KiB
Java
package javax.swing.text.html;
|
|
|
|
import gnu.javax.swing.text.html.ImageViewIconFactory;
|
|
import gnu.javax.swing.text.html.css.Length;
|
|
|
|
import java.awt.Graphics;
|
|
import java.awt.Image;
|
|
import java.awt.MediaTracker;
|
|
import java.awt.Rectangle;
|
|
import java.awt.Shape;
|
|
import java.awt.Toolkit;
|
|
import java.awt.image.ImageObserver;
|
|
import java.net.MalformedURLException;
|
|
import java.net.URL;
|
|
|
|
import javax.swing.Icon;
|
|
import javax.swing.SwingUtilities;
|
|
import javax.swing.text.AbstractDocument;
|
|
import javax.swing.text.AttributeSet;
|
|
import javax.swing.text.BadLocationException;
|
|
import javax.swing.text.Document;
|
|
import javax.swing.text.Element;
|
|
import javax.swing.text.View;
|
|
import javax.swing.text.Position.Bias;
|
|
import javax.swing.text.html.HTML.Attribute;
|
|
|
|
/**
|
|
* A view, representing a single image, represented by the HTML IMG tag.
|
|
*
|
|
* @author Audrius Meskauskas (AudriusA@Bioinformatics.org)
|
|
*/
|
|
public class ImageView extends View
|
|
{
|
|
/**
|
|
* Tracks image loading state and performs the necessary layout updates.
|
|
*/
|
|
class Observer
|
|
implements ImageObserver
|
|
{
|
|
|
|
public boolean imageUpdate(Image image, int flags, int x, int y, int width, int height)
|
|
{
|
|
boolean widthChanged = false;
|
|
if ((flags & ImageObserver.WIDTH) != 0 && spans[X_AXIS] == null)
|
|
widthChanged = true;
|
|
boolean heightChanged = false;
|
|
if ((flags & ImageObserver.HEIGHT) != 0 && spans[Y_AXIS] == null)
|
|
heightChanged = true;
|
|
if (widthChanged || heightChanged)
|
|
safePreferenceChanged(ImageView.this, widthChanged, heightChanged);
|
|
boolean ret = (flags & ALLBITS) != 0;
|
|
return ret;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* True if the image loads synchronuosly (on demand). By default, the image
|
|
* loads asynchronuosly.
|
|
*/
|
|
boolean loadOnDemand;
|
|
|
|
/**
|
|
* The image icon, wrapping the image,
|
|
*/
|
|
Image image;
|
|
|
|
/**
|
|
* The image state.
|
|
*/
|
|
byte imageState = MediaTracker.LOADING;
|
|
|
|
/**
|
|
* True when the image needs re-loading, false otherwise.
|
|
*/
|
|
private boolean reloadImage;
|
|
|
|
/**
|
|
* True when the image properties need re-loading, false otherwise.
|
|
*/
|
|
private boolean reloadProperties;
|
|
|
|
/**
|
|
* True when the width is set as CSS/HTML attribute.
|
|
*/
|
|
private boolean haveWidth;
|
|
|
|
/**
|
|
* True when the height is set as CSS/HTML attribute.
|
|
*/
|
|
private boolean haveHeight;
|
|
|
|
/**
|
|
* True when the image is currently loading.
|
|
*/
|
|
private boolean loading;
|
|
|
|
/**
|
|
* The current width of the image.
|
|
*/
|
|
private int width;
|
|
|
|
/**
|
|
* The current height of the image.
|
|
*/
|
|
private int height;
|
|
|
|
/**
|
|
* Our ImageObserver for tracking the loading state.
|
|
*/
|
|
private ImageObserver observer;
|
|
|
|
/**
|
|
* The CSS width and height.
|
|
*
|
|
* Package private to avoid synthetic accessor methods.
|
|
*/
|
|
Length[] spans;
|
|
|
|
/**
|
|
* The cached attributes.
|
|
*/
|
|
private AttributeSet attributes;
|
|
|
|
/**
|
|
* Creates the image view that represents the given element.
|
|
*
|
|
* @param element the element, represented by this image view.
|
|
*/
|
|
public ImageView(Element element)
|
|
{
|
|
super(element);
|
|
spans = new Length[2];
|
|
observer = new Observer();
|
|
reloadProperties = true;
|
|
reloadImage = true;
|
|
loadOnDemand = false;
|
|
}
|
|
|
|
/**
|
|
* Load or reload the image. This method initiates the image reloading. After
|
|
* the image is ready, the repaint event will be scheduled. The current image,
|
|
* if it already exists, will be discarded.
|
|
*/
|
|
private void reloadImage()
|
|
{
|
|
loading = true;
|
|
reloadImage = false;
|
|
haveWidth = false;
|
|
haveHeight = false;
|
|
image = null;
|
|
width = 0;
|
|
height = 0;
|
|
try
|
|
{
|
|
loadImage();
|
|
updateSize();
|
|
}
|
|
finally
|
|
{
|
|
loading = false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the image alignment. This method works handling standart alignment
|
|
* attributes in the HTML IMG tag (align = top bottom middle left right).
|
|
* Depending from the parameter, either horizontal or vertical alingment
|
|
* information is returned.
|
|
*
|
|
* @param axis -
|
|
* either X_AXIS or Y_AXIS
|
|
*/
|
|
public float getAlignment(int axis)
|
|
{
|
|
AttributeSet attrs = getAttributes();
|
|
Object al = attrs.getAttribute(Attribute.ALIGN);
|
|
|
|
// Default is top left aligned.
|
|
if (al == null)
|
|
return 0.0f;
|
|
|
|
String align = al.toString();
|
|
|
|
if (axis == View.X_AXIS)
|
|
{
|
|
if (align.equals("middle"))
|
|
return 0.5f;
|
|
else if (align.equals("left"))
|
|
return 0.0f;
|
|
else if (align.equals("right"))
|
|
return 1.0f;
|
|
else
|
|
return 0.0f;
|
|
}
|
|
else if (axis == View.Y_AXIS)
|
|
{
|
|
if (align.equals("middle"))
|
|
return 0.5f;
|
|
else if (align.equals("top"))
|
|
return 0.0f;
|
|
else if (align.equals("bottom"))
|
|
return 1.0f;
|
|
else
|
|
return 0.0f;
|
|
}
|
|
else
|
|
throw new IllegalArgumentException("axis " + axis);
|
|
}
|
|
|
|
/**
|
|
* Get the text that should be shown as the image replacement and also as the
|
|
* image tool tip text. The method returns the value of the attribute, having
|
|
* the name {@link Attribute#ALT}. If there is no such attribute, the image
|
|
* name from the url is returned. If the URL is not available, the empty
|
|
* string is returned.
|
|
*/
|
|
public String getAltText()
|
|
{
|
|
Object rt = getAttributes().getAttribute(Attribute.ALT);
|
|
if (rt != null)
|
|
return rt.toString();
|
|
else
|
|
{
|
|
URL u = getImageURL();
|
|
if (u == null)
|
|
return "";
|
|
else
|
|
return u.getFile();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the combination of the document and the style sheet attributes.
|
|
*/
|
|
public AttributeSet getAttributes()
|
|
{
|
|
if (attributes == null)
|
|
attributes = getStyleSheet().getViewAttributes(this);
|
|
return attributes;
|
|
}
|
|
|
|
/**
|
|
* Get the image to render. May return null if the image is not yet loaded.
|
|
*/
|
|
public Image getImage()
|
|
{
|
|
updateState();
|
|
return image;
|
|
}
|
|
|
|
/**
|
|
* Get the URL location of the image to render. If this method returns null,
|
|
* the "no image" icon is rendered instead. By defaul, url must be present as
|
|
* the "src" property of the IMG tag. If it is missing, null is returned and
|
|
* the "no image" icon is rendered.
|
|
*
|
|
* @return the URL location of the image to render.
|
|
*/
|
|
public URL getImageURL()
|
|
{
|
|
Element el = getElement();
|
|
String src = (String) el.getAttributes().getAttribute(Attribute.SRC);
|
|
URL url = null;
|
|
if (src != null)
|
|
{
|
|
URL base = ((HTMLDocument) getDocument()).getBase();
|
|
try
|
|
{
|
|
url = new URL(base, src);
|
|
}
|
|
catch (MalformedURLException ex)
|
|
{
|
|
// Return null.
|
|
}
|
|
}
|
|
return url;
|
|
}
|
|
|
|
/**
|
|
* Get the icon that should be displayed while the image is loading and hence
|
|
* not yet available.
|
|
*
|
|
* @return an icon, showing a non broken sheet of paper with image.
|
|
*/
|
|
public Icon getLoadingImageIcon()
|
|
{
|
|
return ImageViewIconFactory.getLoadingImageIcon();
|
|
}
|
|
|
|
/**
|
|
* Get the image loading strategy.
|
|
*
|
|
* @return false (default) if the image is loaded when the view is
|
|
* constructed, true if the image is only loaded on demand when
|
|
* rendering.
|
|
*/
|
|
public boolean getLoadsSynchronously()
|
|
{
|
|
return loadOnDemand;
|
|
}
|
|
|
|
/**
|
|
* Get the icon that should be displayed when the image is not available.
|
|
*
|
|
* @return an icon, showing a broken sheet of paper with image.
|
|
*/
|
|
public Icon getNoImageIcon()
|
|
{
|
|
return ImageViewIconFactory.getNoImageIcon();
|
|
}
|
|
|
|
/**
|
|
* Get the preferred span of the image along the axis. The image size is first
|
|
* requested to the attributes {@link Attribute#WIDTH} and
|
|
* {@link Attribute#HEIGHT}. If they are missing, and the image is already
|
|
* loaded, the image size is returned. If there are no attributes, and the
|
|
* image is not loaded, zero is returned.
|
|
*
|
|
* @param axis -
|
|
* either X_AXIS or Y_AXIS
|
|
* @return either width of height of the image, depending on the axis.
|
|
*/
|
|
public float getPreferredSpan(int axis)
|
|
{
|
|
AttributeSet attrs = getAttributes();
|
|
|
|
Image image = getImage();
|
|
|
|
if (axis == View.X_AXIS)
|
|
{
|
|
if (spans[axis] != null)
|
|
return spans[axis].getValue();
|
|
else if (image != null)
|
|
return image.getWidth(getContainer());
|
|
else
|
|
return getNoImageIcon().getIconWidth();
|
|
}
|
|
else if (axis == View.Y_AXIS)
|
|
{
|
|
if (spans[axis] != null)
|
|
return spans[axis].getValue();
|
|
else if (image != null)
|
|
return image.getHeight(getContainer());
|
|
else
|
|
return getNoImageIcon().getIconHeight();
|
|
}
|
|
else
|
|
throw new IllegalArgumentException("axis " + axis);
|
|
}
|
|
|
|
/**
|
|
* Get the associated style sheet from the document.
|
|
*
|
|
* @return the associated style sheet.
|
|
*/
|
|
protected StyleSheet getStyleSheet()
|
|
{
|
|
HTMLDocument doc = (HTMLDocument) getDocument();
|
|
return doc.getStyleSheet();
|
|
}
|
|
|
|
/**
|
|
* Get the tool tip text. This is overridden to return the value of the
|
|
* {@link #getAltText()}. The parameters are ignored.
|
|
*
|
|
* @return that is returned by getAltText().
|
|
*/
|
|
public String getToolTipText(float x, float y, Shape shape)
|
|
{
|
|
return getAltText();
|
|
}
|
|
|
|
/**
|
|
* Paints the image or one of the two image state icons. The image is resized
|
|
* to the shape bounds. If there is no image available, the alternative text
|
|
* is displayed besides the image state icon.
|
|
*
|
|
* @param g
|
|
* the Graphics, used for painting.
|
|
* @param bounds
|
|
* the bounds of the region where the image or replacing icon must be
|
|
* painted.
|
|
*/
|
|
public void paint(Graphics g, Shape bounds)
|
|
{
|
|
updateState();
|
|
Rectangle r = bounds instanceof Rectangle ? (Rectangle) bounds
|
|
: bounds.getBounds();
|
|
Image image = getImage();
|
|
if (image != null)
|
|
{
|
|
g.drawImage(image, r.x, r.y, r.width, r.height, observer);
|
|
}
|
|
else
|
|
{
|
|
Icon icon = getNoImageIcon();
|
|
if (icon != null)
|
|
icon.paintIcon(getContainer(), g, r.x, r.y);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set if the image should be loaded only when needed (synchronuosly). By
|
|
* default, the image loads asynchronuosly. If the image is not yet ready, the
|
|
* icon, returned by the {@link #getLoadingImageIcon()}, is displayed.
|
|
*/
|
|
public void setLoadsSynchronously(boolean load_on_demand)
|
|
{
|
|
loadOnDemand = load_on_demand;
|
|
}
|
|
|
|
/**
|
|
* Update all cached properties from the attribute set, returned by the
|
|
* {@link #getAttributes}.
|
|
*/
|
|
protected void setPropertiesFromAttributes()
|
|
{
|
|
AttributeSet atts = getAttributes();
|
|
StyleSheet ss = getStyleSheet();
|
|
float emBase = ss.getEMBase(atts);
|
|
float exBase = ss.getEXBase(atts);
|
|
spans[X_AXIS] = (Length) atts.getAttribute(CSS.Attribute.WIDTH);
|
|
if (spans[X_AXIS] != null)
|
|
{
|
|
spans[X_AXIS].setFontBases(emBase, exBase);
|
|
}
|
|
spans[Y_AXIS] = (Length) atts.getAttribute(CSS.Attribute.HEIGHT);
|
|
if (spans[Y_AXIS] != null)
|
|
{
|
|
spans[Y_AXIS].setFontBases(emBase, exBase);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Maps the picture co-ordinates into the image position in the model. As the
|
|
* image is not divideable, this is currently implemented always to return the
|
|
* start offset.
|
|
*/
|
|
public int viewToModel(float x, float y, Shape shape, Bias[] bias)
|
|
{
|
|
return getStartOffset();
|
|
}
|
|
|
|
/**
|
|
* This is currently implemented always to return the area of the image view,
|
|
* as the image is not divideable by character positions.
|
|
*
|
|
* @param pos character position
|
|
* @param area of the image view
|
|
* @param bias bias
|
|
*
|
|
* @return the shape, where the given character position should be mapped.
|
|
*/
|
|
public Shape modelToView(int pos, Shape area, Bias bias)
|
|
throws BadLocationException
|
|
{
|
|
return area;
|
|
}
|
|
|
|
/**
|
|
* Starts loading the image asynchronuosly. If the image must be loaded
|
|
* synchronuosly instead, the {@link #setLoadsSynchronously} must be
|
|
* called before calling this method. The passed parameters are not used.
|
|
*/
|
|
public void setSize(float width, float height)
|
|
{
|
|
updateState();
|
|
// TODO: Implement this when we have an alt view for the alt=... attribute.
|
|
}
|
|
|
|
/**
|
|
* This makes sure that the image and properties have been loaded.
|
|
*/
|
|
private void updateState()
|
|
{
|
|
if (reloadImage)
|
|
reloadImage();
|
|
if (reloadProperties)
|
|
setPropertiesFromAttributes();
|
|
}
|
|
|
|
/**
|
|
* Actually loads the image.
|
|
*/
|
|
private void loadImage()
|
|
{
|
|
URL src = getImageURL();
|
|
Image newImage = null;
|
|
if (src != null)
|
|
{
|
|
// Call getImage(URL) to allow the toolkit caching of that image URL.
|
|
Toolkit tk = Toolkit.getDefaultToolkit();
|
|
newImage = tk.getImage(src);
|
|
tk.prepareImage(newImage, -1, -1, observer);
|
|
if (newImage != null && getLoadsSynchronously())
|
|
{
|
|
// Load image synchronously.
|
|
MediaTracker tracker = new MediaTracker(getContainer());
|
|
tracker.addImage(newImage, 0);
|
|
try
|
|
{
|
|
tracker.waitForID(0);
|
|
}
|
|
catch (InterruptedException ex)
|
|
{
|
|
Thread.interrupted();
|
|
}
|
|
|
|
}
|
|
}
|
|
image = newImage;
|
|
}
|
|
|
|
/**
|
|
* Updates the size parameters of the image.
|
|
*/
|
|
private void updateSize()
|
|
{
|
|
int newW = 0;
|
|
int newH = 0;
|
|
Image newIm = getImage();
|
|
if (newIm != null)
|
|
{
|
|
AttributeSet atts = getAttributes();
|
|
// Fetch width.
|
|
Length l = spans[X_AXIS];
|
|
if (l != null)
|
|
{
|
|
newW = (int) l.getValue();
|
|
haveWidth = true;
|
|
}
|
|
else
|
|
{
|
|
newW = newIm.getWidth(observer);
|
|
}
|
|
// Fetch height.
|
|
l = spans[Y_AXIS];
|
|
if (l != null)
|
|
{
|
|
newH = (int) l.getValue();
|
|
haveHeight = true;
|
|
}
|
|
else
|
|
{
|
|
newW = newIm.getWidth(observer);
|
|
}
|
|
// Go and trigger loading.
|
|
Toolkit tk = Toolkit.getDefaultToolkit();
|
|
if (haveWidth || haveHeight)
|
|
tk.prepareImage(newIm, width, height, observer);
|
|
else
|
|
tk.prepareImage(newIm, -1, -1, observer);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calls preferenceChanged from the event dispatch thread and within
|
|
* a read lock to protect us from threading issues.
|
|
*
|
|
* @param v the view
|
|
* @param width true when the width changed
|
|
* @param height true when the height changed
|
|
*/
|
|
void safePreferenceChanged(final View v, final boolean width,
|
|
final boolean height)
|
|
{
|
|
if (SwingUtilities.isEventDispatchThread())
|
|
{
|
|
Document doc = getDocument();
|
|
if (doc instanceof AbstractDocument)
|
|
((AbstractDocument) doc).readLock();
|
|
try
|
|
{
|
|
preferenceChanged(v, width, height);
|
|
}
|
|
finally
|
|
{
|
|
if (doc instanceof AbstractDocument)
|
|
((AbstractDocument) doc).readUnlock();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SwingUtilities.invokeLater(new Runnable()
|
|
{
|
|
public void run()
|
|
{
|
|
safePreferenceChanged(v, width, height);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|