Subversion Repositories openrisc

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)

  {

    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)

      {

        // 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);

          }

        });

      }

  }

}