1 files changed, 471 insertions, 0 deletions
diff --git a/libjava/classpath/javax/swing/plaf/basic/BasicHTML.java b/libjava/classpath/javax/swing/plaf/basic/BasicHTML.java
new file mode 100644
index 000000000..a7ce8b15b
--- /dev/null
+++ b/libjava/classpath/javax/swing/plaf/basic/BasicHTML.java
@@ -0,0 +1,471 @@
+/* BasicHTML.java -- Provides HTML support to ComponentUI implementations
+   Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package javax.swing.plaf.basic;
+
+import java.awt.Container;
+import java.awt.Graphics;
+import java.awt.Rectangle;
+import java.awt.Shape;
+import java.io.IOException;
+import java.io.StringReader;
+
+import javax.swing.JComponent;
+import javax.swing.SwingConstants;
+import javax.swing.event.DocumentEvent;
+import javax.swing.text.AttributeSet;
+import javax.swing.text.BadLocationException;
+import javax.swing.text.Document;
+import javax.swing.text.EditorKit;
+import javax.swing.text.Element;
+import javax.swing.text.Position;
+import javax.swing.text.View;
+import javax.swing.text.ViewFactory;
+import javax.swing.text.html.HTMLDocument;
+import javax.swing.text.html.HTMLEditorKit;
+
+/**
+ * Provides support for HTML rendering to {@link javax.swing.plaf.ComponentUI}
+ * implementations.
+ *
+ * @author Roman Kennke (kennke@aicas.com)
+ */
+public class BasicHTML
+{
+
+  /**
+   * This class serves as the root view for HTML rendering components.
+   * Its purpose and implementation is similar to the BasicTextUI.RootView
+   * class, only that is implements some stuff differently due to the nature
+   * of not beeing inside a JTextComponent.
+   *
+   * @author Roman Kennke (kennke@aicas.com)
+   */
+  private static class HTMLRootView extends View
+  {
+    /**
+     * The real root view.
+     */
+    private View view;
+
+    /**
+     * The component on which to render the view.
+     */
+    private JComponent component;
+
+    /**
+     * The EditorKit.
+     */
+    private EditorKit editorKit;
+
+    /**
+     * The document to use.
+     */
+    private Document document;
+
+    /**
+     * Creates a new RootView.
+     */
+    public HTMLRootView(JComponent c, View view, EditorKit kit, Document doc)
+    {
+      super(null);
+      component = c;
+      editorKit = kit;
+      document = doc;
+      setView(view);
+      setSize(view.getPreferredSpan(X_AXIS), view.getPreferredSpan(Y_AXIS));
+    }
+
+    /**
+     * Returns the ViewFactory for this RootView. If the current EditorKit
+     * provides a ViewFactory, this is used. Otherwise the TextUI itself
+     * is returned as a ViewFactory.
+     *
+     * @return the ViewFactory for this RootView
+     */
+    public ViewFactory getViewFactory()
+    {
+      return editorKit.getViewFactory();
+    }
+
+    /**
+     * Indicates that the preferences of one of the child view has changed.
+     * This calls revalidate on the text component.
+     *
+     * @param v the child view which's preference has changed
+     * @param width <code>true</code> if the width preference has changed
+     * @param height <code>true</code> if the height preference has changed
+     */
+    public void preferenceChanged(View v, boolean width, boolean height)
+    {
+      component.revalidate();
+    }
+
+    /**
+     * Sets the real root view.
+     *
+     * @param v the root view to set
+     */
+    public void setView(View v)
+    {
+      if (view != null)
+        view.setParent(null);
+
+      if (v != null)
+        v.setParent(this);
+
+      view = v;
+    }
+
+    /**
+     * Overridden to forward to real view.
+     */
+    public void setSize(float w, float h)
+    {
+      view.setSize(w, h);
+    }
+
+    /**
+     * Returns the real root view, regardless of the index.
+     *
+     * @param index not used here
+     *
+     * @return the real root view, regardless of the index.
+     */
+    public View getView(int index)
+    {
+      return view;
+    }
+
+    /**
+     * Returns <code>1</code> since the RootView always contains one
+     * child, that is the real root of the View hierarchy.
+     *
+     * @return <code>1</code> since the RootView always contains one
+     *         child, that is the real root of the View hierarchy
+     */
+    public int getViewCount()
+    {
+      int count = 0;
+      if (view != null)
+        count = 1;
+      return count;
+    }
+
+    /**
+     * Returns the <code>Container</code> that contains this view. This
+     * normally will be the text component that is managed by this TextUI.
+     *
+     * @return the <code>Container</code> that contains this view
+     */
+    public Container getContainer()
+    {
+      return component;
+    }
+
+    /**
+     * Returns the preferred span along the specified <code>axis</code>.
+     * This is delegated to the real root view.
+     *
+     * @param axis the axis for which the preferred span is queried
+     *
+     * @return the preferred span along the axis
+     */
+    public float getPreferredSpan(int axis)
+    {
+      if (view != null)
+        return view.getPreferredSpan(axis);
+
+      return Integer.MAX_VALUE;
+    }
+
+    /**
+     * Paints the view. This is delegated to the real root view.
+     *
+     * @param g the <code>Graphics</code> context to paint to
+     * @param s the allocation for the View
+     */
+    public void paint(Graphics g, Shape s)
+    {
+      if (view != null)
+        {
+          Rectangle b = s.getBounds();
+          view.setSize(b.width, b.height);
+          view.paint(g, s);
+        }
+    }
+
+
+    /**
+     * Maps a position in the document into the coordinate space of the View.
+     * The output rectangle usually reflects the font height but has a width
+     * of zero.
+     *
+     * This is delegated to the real root view.
+     *
+     * @param position the position of the character in the model
+     * @param a the area that is occupied by the view
+     * @param bias either {@link Position.Bias#Forward} or
+     *        {@link Position.Bias#Backward} depending on the preferred
+     *        direction bias. If <code>null</code> this defaults to
+     *        <code>Position.Bias.Forward</code>
+     *
+     * @return a rectangle that gives the location of the document position
+     *         inside the view coordinate space
+     *
+     * @throws BadLocationException if <code>pos</code> is invalid
+     * @throws IllegalArgumentException if b is not one of the above listed
+     *         valid values
+     */
+    public Shape modelToView(int position, Shape a, Position.Bias bias)
+      throws BadLocationException
+    {
+      return view.modelToView(position, a, bias);
+    }
+
+    /**
+     * Maps coordinates from the <code>View</code>'s space into a position
+     * in the document model.
+     *
+     * @param x the x coordinate in the view space
+     * @param y the y coordinate in the view space
+     * @param a the allocation of this <code>View</code>
+     * @param b the bias to use
+     *
+     * @return the position in the document that corresponds to the screen
+     *         coordinates <code>x, y</code>
+     */
+    public int viewToModel(float x, float y, Shape a, Position.Bias[] b)
+    {
+      return view.viewToModel(x, y, a, b);
+    }
+
+    /**
+     * Notification about text insertions. These are forwarded to the
+     * real root view.
+     *
+     * @param ev the DocumentEvent describing the change
+     * @param shape the current allocation of the view's display
+     * @param vf the ViewFactory to use for creating new Views
+     */
+    public void insertUpdate(DocumentEvent ev, Shape shape, ViewFactory vf)
+    {
+      view.insertUpdate(ev, shape, vf);
+    }
+
+    /**
+     * Notification about text removals. These are forwarded to the
+     * real root view.
+     *
+     * @param ev the DocumentEvent describing the change
+     * @param shape the current allocation of the view's display
+     * @param vf the ViewFactory to use for creating new Views
+     */
+    public void removeUpdate(DocumentEvent ev, Shape shape, ViewFactory vf)
+    {
+      view.removeUpdate(ev, shape, vf);
+    }
+
+    /**
+     * Notification about text changes. These are forwarded to the
+     * real root view.
+     *
+     * @param ev the DocumentEvent describing the change
+     * @param shape the current allocation of the view's display
+     * @param vf the ViewFactory to use for creating new Views
+     */
+    public void changedUpdate(DocumentEvent ev, Shape shape, ViewFactory vf)
+    {
+      view.changedUpdate(ev, shape, vf);
+    }
+
+    /**
+     * Returns the document position that is (visually) nearest to the given
+     * document position <code>pos</code> in the given direction <code>d</code>.
+     *
+     * @param pos the document position
+     * @param b the bias for <code>pos</code>
+     * @param a the allocation for the view
+     * @param d the direction, must be either {@link SwingConstants#NORTH},
+     *        {@link SwingConstants#SOUTH}, {@link SwingConstants#WEST} or
+     *        {@link SwingConstants#EAST}
+     * @param biasRet an array of {@link Position.Bias} that can hold at least
+     *        one element, which is filled with the bias of the return position
+     *        on method exit
+     *
+     * @return the document position that is (visually) nearest to the given
+     *         document position <code>pos</code> in the given direction
+     *         <code>d</code>
+     *
+     * @throws BadLocationException if <code>pos</code> is not a valid offset in
+     *         the document model
+     */
+    public int getNextVisualPositionFrom(int pos, Position.Bias b, Shape a,
+                                         int d, Position.Bias[] biasRet)
+      throws BadLocationException
+    {
+      return view.getNextVisualPositionFrom(pos, b, a, d, biasRet);
+    }
+
+    public int getStartOffset()
+    {
+      return 0;
+    }
+
+    public int getEndOffset()
+    {
+      return getDocument().getLength();
+    }
+
+    public Document getDocument()
+    {
+      return document;
+    }
+
+    /**
+     * Overridden to return null, as a RootView has no attributes on its own.
+     */
+    public AttributeSet getAttributes()
+    {
+      return null;
+    }
+
+    /**
+     * Overridden to provide an element for the view.
+     */
+    public Element getElement()
+    {
+      return view.getElement();
+    }
+  }
+
+  /**
+   * The key that is used to store a HTML view in a JComponent's client
+   * properties.
+   */
+  public static final String propertyKey = "html";
+
+  /**
+   * The key that is used to store the document base in a JComponent's client
+   * properties. The document base is used to resolve relative references
+   * in HTML.
+   */
+  public static final String documentBaseKey = "html.base";
+
+  /**
+   * Creates a new instance of BasicHTML. This should not be necessary since
+   * all methods in this class are static.
+   */
+  public BasicHTML()
+  {
+    // Nothing to do here.
+  }
+
+  /**
+   * Creates a {@link View} instance that can be used by the component
+   * <code>c</code> to render the HTML string <code>html</code>.
+   *
+   * @param c the component that needs to render the HTML string
+   * @param html the HTML string to be rendered
+   *
+   * @return a view that can render the HTML string
+   */
+  public static View createHTMLView(JComponent c, String html)
+  {
+    // TODO: This might be wrong. Lets see if it turns out good when
+    // the javax.swing.text.html package is in a good shape.
+    HTMLDocument doc = new HTMLDocument();
+    HTMLEditorKit kit = new HTMLEditorKit();
+    StringReader reader = new StringReader(html);
+    try
+      {
+        kit.read(reader, doc, 0);
+      }
+    catch (IOException ex)
+      {
+        AssertionError err = new AssertionError("unexpected IOException");
+        err.initCause(ex);
+        throw err;
+      }
+    catch (BadLocationException ex)
+      {
+        AssertionError err =
+          new AssertionError("unexpected BadLocationException");
+        err.initCause(ex);
+        throw err;
+      }
+    ViewFactory vf = kit.getViewFactory();
+    Element root = doc.getDefaultRootElement();
+    View view = vf.create(root);
+    HTMLRootView rootView = new HTMLRootView(c, view, kit, doc);
+    return rootView;
+  }
+
+  /**
+   * Returns <code>true</code> if <code>s</code> is HTML, <code>false</code>
+   * otherwise.
+   *
+   * @param s the string to test
+   *
+   * @return <code>true</code> if <code>s</code> is HTML, <code>false</code>
+   *         otherwise
+   */
+  public static boolean isHTMLString(String s)
+  {
+    // We consider a string to be HTML if it contains both the '<' and '>'
+    // character at least once.
+    return (s != null) && s.contains("<") && s.contains(">");
+  }
+
+  /**
+   * Stores a HTML renderer in <code>c</code>'s client property if
+   * <code>text</code> is HTML, otherwise it clears the corresponding client
+   * property. This is useful for {@link javax.swing.plaf.ComponentUI}
+   * implementations that are shared between it's components.
+   *
+   * @param c the component to update the renderer for
+   * @param text the string to be rendered
+   */
+  public static void updateRenderer(JComponent c, String text)
+  {
+    if (isHTMLString(text))
+      c.putClientProperty(propertyKey, createHTMLView(c, text));
+    else
+      c.putClientProperty(propertyKey, null);
+  }
+}