Subversion Repositories openrisc

/* StyledEditorKit.java --

   Copyright (C) 2002, 2004 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.text;

import java.awt.Color;

import java.awt.event.ActionEvent;

import javax.swing.Action;

import javax.swing.JEditorPane;

import javax.swing.event.CaretEvent;

import javax.swing.event.CaretListener;

/**

 * An {@link EditorKit} that supports editing styled text.

 *

 * @author Andrew Selkirk

 * @author Roman Kennke (roman@kennke.org)

 */

public class StyledEditorKit extends DefaultEditorKit

{

  /** The serialVersionUID. */

  private static final long serialVersionUID = 7002391892985555948L;

  /**

   * Toggles the underline attribute for the selected text.

   */

  public static class UnderlineAction extends StyledEditorKit.StyledTextAction

  {

    /**

     * Creates an instance of <code>UnderlineAction</code>.

     */

    public UnderlineAction()

    {

      super("font-underline");

    }

    /**

     * Performs the action.

     *

     * @param event the <code>ActionEvent</code> that describes the action

     */

    public void actionPerformed(ActionEvent event)

    {

      JEditorPane editor = getEditor(event);

      StyledDocument doc = getStyledDocument(editor);

      Element el = doc.getCharacterElement(editor.getSelectionStart());

      boolean isUnderline = StyleConstants.isUnderline(el.getAttributes());

      SimpleAttributeSet atts = new SimpleAttributeSet();

      StyleConstants.setUnderline(atts, ! isUnderline);

      setCharacterAttributes(editor, atts, false);

    }

  }

  /**

   * Toggles the italic attribute for the selected text.

   */

  public static class ItalicAction extends StyledEditorKit.StyledTextAction

  {

    /**

     * Creates an instance of <code>ItalicAction</code>.

     */

    public ItalicAction()

    {

      super("font-italic");

    }

    /**

     * Performs the action.

     *

     * @param event the <code>ActionEvent</code> that describes the action

     */

    public void actionPerformed(ActionEvent event)

    {

      JEditorPane editor = getEditor(event);

      StyledDocument doc = getStyledDocument(editor);

      Element el = doc.getCharacterElement(editor.getSelectionStart());

      boolean isItalic = StyleConstants.isItalic(el.getAttributes());

      SimpleAttributeSet atts = new SimpleAttributeSet();

      StyleConstants.setItalic(atts, ! isItalic);

      setCharacterAttributes(editor, atts, false);

    }

  }

  /**

   * Toggles the bold attribute for the selected text.

   */

  public static class BoldAction extends StyledEditorKit.StyledTextAction

  {

    /**

     * Creates an instance of <code>BoldAction</code>.

     */

    public BoldAction()

    {

      super("font-bold");

    }

    /**

     * Performs the action.

     *

     * @param event the <code>ActionEvent</code> that describes the action

     */

    public void actionPerformed(ActionEvent event)

    {

      JEditorPane editor = getEditor(event);

      StyledDocument doc = getStyledDocument(editor);

      Element el = doc.getCharacterElement(editor.getSelectionStart());

      boolean isBold = StyleConstants.isBold(el.getAttributes());

      SimpleAttributeSet atts = new SimpleAttributeSet();

      StyleConstants.setBold(atts, ! isBold);

      setCharacterAttributes(editor, atts, false);

    }

  }

  /**

   * Sets the alignment attribute on the selected text.

   */

  public static class AlignmentAction extends StyledEditorKit.StyledTextAction

  {

    /**

     * The aligment to set.

     */

    private int a;

    /**

     * Creates a new instance of <code>AlignmentAction</code> to set the

     * alignment to <code>a</code>.

     *

     * @param nm the name of the Action

     * @param a the alignment to set

     */

    public AlignmentAction(String nm, int a)

    {

      super(nm);

      this.a = a;

    }

    /**

     * Performs the action.

     *

     * @param event the <code>ActionEvent</code> that describes the action

     */

    public void actionPerformed(ActionEvent event)

    {

      SimpleAttributeSet atts = new SimpleAttributeSet();

      StyleConstants.setAlignment(atts, a);

      setParagraphAttributes(getEditor(event), atts, false);

    }

  }

  /**

   * Sets the foreground color attribute on the selected text.

   */

  public static class ForegroundAction extends StyledEditorKit.StyledTextAction

  {

    /**

     * The foreground color to set.

     */

    private Color fg;

    /**

     * Creates a new instance of <code>ForegroundAction</code> to set the

     * foreground color to <code>fg</code>.

     *

     * @param nm the name of the Action

     * @param fg the foreground color to set

     */

    public ForegroundAction(String nm, Color fg)

    {

      super(nm);

      this.fg = fg;

    }

    /**

     * Performs the action.

     *

     * @param event the <code>ActionEvent</code> that describes the action

     */

    public void actionPerformed(ActionEvent event)

    {

      SimpleAttributeSet atts = new SimpleAttributeSet();

      StyleConstants.setForeground(atts, fg);

      setCharacterAttributes(getEditor(event), atts, false);

    }

  }

  /**

   * Sets the font size attribute on the selected text.

   */

  public static class FontSizeAction extends StyledEditorKit.StyledTextAction

  {

    /**

     * The font size to set.

     */

    private int size;

    /**

     * Creates a new instance of <code>FontSizeAction</code> to set the

     * font size to <code>size</code>.

     *

     * @param nm the name of the Action

     * @param size the font size to set

     */

    public FontSizeAction(String nm, int size)

    {

      super(nm);

      this.size = size;

    }

    /**

     * Performs the action.

     *

     * @param event the <code>ActionEvent</code> that describes the action

     */

    public void actionPerformed(ActionEvent event)

    {

      SimpleAttributeSet atts = new SimpleAttributeSet();

      StyleConstants.setFontSize(atts, size);

      setCharacterAttributes(getEditor(event), atts, false);

    }

  }

  /**

   * Sets the font family attribute on the selected text.

   */

  public static class FontFamilyAction extends StyledEditorKit.StyledTextAction

  {

    /**

     * The font family to set.

     */

    private String family;

    /**

     * Creates a new instance of <code>FontFamilyAction</code> to set the

     * font family to <code>family</code>.

     *

     * @param nm the name of the Action

     * @param family the font family to set

     */

    public FontFamilyAction(String nm, String family)

    {

      super(nm);

      this.family = family;

    }

    /**

     * Performs the action.

     *

     * @param event the <code>ActionEvent</code> that describes the action

     */

    public void actionPerformed(ActionEvent event)

    {

      SimpleAttributeSet atts = new SimpleAttributeSet();

      StyleConstants.setFontFamily(atts, family);

      setCharacterAttributes(getEditor(event), atts, false);

    }

  }

  /**

   * The abstract superclass of all styled TextActions. This class

   * provides some useful methods to manipulate the text attributes.

   */

  public abstract static class StyledTextAction extends TextAction

  {

    /**

     * Creates a new instance of <code>StyledTextAction</code>.

     *

     * @param nm the name of the <code>StyledTextAction</code>

     */

    public StyledTextAction(String nm)

    {

      super(nm);

    }

    /**

     * Returns the <code>JEditorPane</code> component from which the

     * <code>ActionEvent</code> originated.

     *

     * @param event the <code>ActionEvent</code>

     * @return the <code>JEditorPane</code> component from which the

     *         <code>ActionEvent</code> originated

     */

    protected final JEditorPane getEditor(ActionEvent event)

    {

      return (JEditorPane) getTextComponent(event);

    }

    /**

     * Sets the specified character attributes on the currently selected

     * text of <code>editor</code>. If <code>editor</code> does not have

     * a selection, then the attributes are used as input attributes

     * for newly inserted content.

     *

     * @param editor the <code>JEditorPane</code> component

     * @param atts the text attributes to set

     * @param replace if <code>true</code> the current attributes of the

     *        selection are replaces, otherwise they are merged

     */

    protected final void setCharacterAttributes(JEditorPane editor,

                                                AttributeSet atts,

                                                boolean replace)

    {

      int p0 = editor.getSelectionStart();

      int p1 = editor.getSelectionEnd();

      if (p0 != p1)

        {

          StyledDocument doc = getStyledDocument(editor);

          doc.setCharacterAttributes(p0, p1 - p0, atts, replace);

        }

      // Update input attributes.

      StyledEditorKit kit = getStyledEditorKit(editor);

      MutableAttributeSet inputAtts = kit.getInputAttributes();

      if (replace)

        {

          inputAtts.removeAttributes(inputAtts);

        }

      inputAtts.addAttributes(atts);

    }

    /**

     * Returns the {@link StyledDocument} that is used by <code>editor</code>.

     *

     * @param editor the <code>JEditorPane</code> from which to get the

     *        <code>StyledDocument</code>

     *

     * @return the {@link StyledDocument} that is used by <code>editor</code>

     */

    protected final StyledDocument getStyledDocument(JEditorPane editor)

    {

      Document doc = editor.getDocument();

      if (!(doc instanceof StyledDocument))

        throw new AssertionError("The Document for StyledEditorKits is "

                                 + "expected to be a StyledDocument.");

      return (StyledDocument) doc;

    }

    /**

     * Returns the {@link StyledEditorKit} that is used by <code>editor</code>.

     *

     * @param editor the <code>JEditorPane</code> from which to get the

     *        <code>StyledEditorKit</code>

     *

     * @return the {@link StyledEditorKit} that is used by <code>editor</code>

     */

    protected final StyledEditorKit getStyledEditorKit(JEditorPane editor)

    {

      EditorKit kit = editor.getEditorKit();

      if (!(kit instanceof StyledEditorKit))

        throw new AssertionError("The EditorKit for StyledDocuments is "

                                 + "expected to be a StyledEditorKit.");

      return (StyledEditorKit) kit;

    }

    /**

     * Sets the specified character attributes on the paragraph that

     * contains the currently selected

     * text of <code>editor</code>. If <code>editor</code> does not have

     * a selection, then the attributes are set on the paragraph that

     * contains the current caret position.

     *

     * @param editor the <code>JEditorPane</code> component

     * @param atts the text attributes to set

     * @param replace if <code>true</code> the current attributes of the

     *        selection are replaces, otherwise they are merged

     */

    protected final void setParagraphAttributes(JEditorPane editor,

                                                AttributeSet atts,

                                                boolean replace)

    {

      Document doc = editor.getDocument();

      if (doc instanceof StyledDocument)

        {

          StyledDocument styleDoc = (StyledDocument) editor.getDocument();

          EditorKit kit = editor.getEditorKit();

          if (!(kit instanceof StyledEditorKit))

            {

              StyledEditorKit styleKit = (StyledEditorKit) kit;

              int start = editor.getSelectionStart();

              int end = editor.getSelectionEnd();

              int dot = editor.getCaret().getDot();

              if (start == dot && end == dot)

                {

                  // If there is no selection, then we only update the

                  // input attributes.

                  MutableAttributeSet inputAttributes =

                    styleKit.getInputAttributes();

                  inputAttributes.addAttributes(atts);

                }

              else

                styleDoc.setParagraphAttributes(start, end, atts, replace);

            }

          else

            throw new AssertionError("The EditorKit for StyledTextActions "

                                     + "is expected to be a StyledEditorKit");

        }

      else

        throw new AssertionError("The Document for StyledTextActions is "

                                 + "expected to be a StyledDocument.");

    }

  }

  /**

   * A {@link ViewFactory} that is able to create {@link View}s for

   * the <code>Element</code>s that are supported by

   * <code>StyledEditorKit</code>, namely the following types of Elements:

   *

   * <ul>

   * <li>{@link AbstractDocument#ContentElementName}</li>

   * <li>{@link AbstractDocument#ParagraphElementName}</li>

   * <li>{@link AbstractDocument#SectionElementName}</li>

   * <li>{@link StyleConstants#ComponentElementName}</li>

   * <li>{@link StyleConstants#IconElementName}</li>

   * </ul>

   */

  static class StyledViewFactory

    implements ViewFactory

  {

    /**

     * Creates a {@link View} for the specified <code>Element</code>.

     *

     * @param element the <code>Element</code> to create a <code>View</code>

     *        for

     * @return the <code>View</code> for the specified <code>Element</code>

     *         or <code>null</code> if the type of <code>element</code> is

     *         not supported

     */

    public View create(Element element)

    {

      String name = element.getName();

      View view = null;

      if (name.equals(AbstractDocument.ContentElementName))

        view = new LabelView(element);

      else if (name.equals(AbstractDocument.ParagraphElementName))

        view = new ParagraphView(element);

      else if (name.equals(AbstractDocument.SectionElementName))

        view = new BoxView(element, View.Y_AXIS);

      else if (name.equals(StyleConstants.ComponentElementName))

        view = new ComponentView(element);

      else if (name.equals(StyleConstants.IconElementName))

        view = new IconView(element);

      else

        throw new AssertionError("Unknown Element type: "

                                 + element.getClass().getName() + " : "

                                 + name);

      return view;

    }

  }

  /**

   * Keeps track of the caret position and updates the currentRun

   * <code>Element</code> and the <code>inputAttributes</code>.

   */

  class CaretTracker

    implements CaretListener

  {

    /**

     * Notifies an update of the caret position.

     *

     * @param ev the event for the caret update

     */

    public void caretUpdate(CaretEvent ev)

    {

      Object source = ev.getSource();

      if (!(source instanceof JTextComponent))

        throw new AssertionError("CaretEvents are expected to come from a"

                                 + "JTextComponent.");

      JTextComponent text = (JTextComponent) source;

      Document doc = text.getDocument();

      if (!(doc instanceof StyledDocument))

        throw new AssertionError("The Document used by StyledEditorKits is"

                                 + "expected to be a StyledDocument");

      StyledDocument styleDoc = (StyledDocument) doc;

      currentRun = styleDoc.getCharacterElement(ev.getDot());

      createInputAttributes(currentRun, inputAttributes);

    }

  }

  /**

   * Stores the <code>Element</code> at the current caret position. This

   * is updated by {@link CaretTracker}.

   */

  Element currentRun;

  /**

   * The current input attributes. This is updated by {@link CaretTracker}.

   */

  MutableAttributeSet inputAttributes;

  /**

   * The CaretTracker that keeps track of the current input attributes, and

   * the current character run Element.

   */

  CaretTracker caretTracker;

  /**

   * The ViewFactory for StyledEditorKits.

   */

  StyledViewFactory viewFactory;

  /**

   * Creates a new instance of <code>StyledEditorKit</code>.

   */

  public StyledEditorKit()

  {

    inputAttributes = new SimpleAttributeSet();

  }

  /**

   * Creates an exact copy of this <code>StyledEditorKit</code>.

   *

   * @return an exact copy of this <code>StyledEditorKit</code>

   */

  public Object clone()

  {

    StyledEditorKit clone = (StyledEditorKit) super.clone();

    // FIXME: Investigate which fields must be copied.

    return clone;

  }

  /**

   * Returns the <code>Action</code>s supported by this {@link EditorKit}.

   * This includes the {@link BoldAction}, {@link ItalicAction} and

   * {@link UnderlineAction} as well as the <code>Action</code>s supported

   * by {@link DefaultEditorKit}.

   *

   * The other <code>Action</code>s of <code>StyledEditorKit</code> are not

   * returned here, since they require a parameter and thus custom

   * instantiation.

   *

   * @return the <code>Action</code>s supported by this {@link EditorKit}

   */

  public Action[] getActions()

  {

    Action[] actions1 = super.getActions();

    Action[] myActions = new Action[] {

      new FontSizeAction("font-size-8", 8),

      new FontSizeAction("font-size-10", 10),

      new FontSizeAction("font-size-12", 12),

      new FontSizeAction("font-size-14", 14),

      new FontSizeAction("font-size-16", 16),

      new FontSizeAction("font-size-18", 18),

      new FontSizeAction("font-size-24", 24),

      new FontSizeAction("font-size-36", 36),

      new FontSizeAction("font-size-48", 48),

      new FontFamilyAction("font-family-Serif", "Serif"),

      new FontFamilyAction("font-family-Monospaced", "Monospaced"),

      new FontFamilyAction("font-family-SansSerif", "SansSerif"),

      new AlignmentAction("left-justify", StyleConstants.ALIGN_LEFT),

      new AlignmentAction("center-justify", StyleConstants.ALIGN_CENTER),

      new AlignmentAction("right-justify", StyleConstants.ALIGN_RIGHT),

      new BoldAction(),

      new ItalicAction(),

      new UnderlineAction()

    };

    return TextAction.augmentList(actions1, myActions);

  }

  /**

   * Returns the current input attributes. These are automatically set on

   * any newly inserted content, if not specified otherwise.

   *

   * @return the current input attributes

   */

  public MutableAttributeSet getInputAttributes()

  {

    return inputAttributes;

  }

  /**

   * Returns the {@link Element} that represents the character run at the

   * current caret position.

   *

   * @return the {@link Element} that represents the character run at the

   *         current caret position

   */

  public Element getCharacterAttributeRun()

  {

    return currentRun;

  }

  /**

   * Creates the default {@link Document} supported by this

   * <code>EditorKit</code>. This is an instance of

   * {@link DefaultStyledDocument} in this case but may be overridden by

   * subclasses.

   *

   * @return an instance of <code>DefaultStyledDocument</code>

   */

  public Document createDefaultDocument()

  {

    return new DefaultStyledDocument();

  }

  /**

   * Installs this <code>EditorKit</code> on the specified {@link JEditorPane}.

   * This basically involves setting up required listeners on the

   * <code>JEditorPane</code>.

   *

   * @param component the <code>JEditorPane</code> to install this

   *        <code>EditorKit</code> on

   */

  public void install(JEditorPane component)

  {

    CaretTracker tracker = new CaretTracker();

    component.addCaretListener(tracker);

  }

  /**

   * Deinstalls this <code>EditorKit</code> from the specified

   * {@link JEditorPane}. This basically involves removing all listeners from

   * <code>JEditorPane</code> that have been set up by this

   * <code>EditorKit</code>.

   *

   * @param component the <code>JEditorPane</code> from which to deinstall this

   *        <code>EditorKit</code>

   */

  public void deinstall(JEditorPane component)

  {

    CaretTracker t = caretTracker;

    if (t != null)

      component.removeCaretListener(t);

    caretTracker = null;

  }

  /**

   * Returns a {@link ViewFactory} that is able to create {@link View}s

   * for {@link Element}s that are supported by this <code>EditorKit</code>,

   * namely the following types of <code>Element</code>s:

   *

   * <ul>

   * <li>{@link AbstractDocument#ContentElementName}</li>

   * <li>{@link AbstractDocument#ParagraphElementName}</li>

   * <li>{@link AbstractDocument#SectionElementName}</li>

   * <li>{@link StyleConstants#ComponentElementName}</li>

   * <li>{@link StyleConstants#IconElementName}</li>

   * </ul>

   *

   * @return a {@link ViewFactory} that is able to create {@link View}s

   *          for {@link Element}s that are supported by this <code>EditorKit</code>

   */

  public ViewFactory getViewFactory()

  {

    if (viewFactory == null)

      viewFactory = new StyledViewFactory();

    return viewFactory;

  }

  /**

   * Copies the text attributes from <code>element</code> to <code>set</code>.

   * This is called everytime when the caret position changes to keep

   * track of the current input attributes. The attributes in <code>set</code>

   * are cleaned before adding the attributes of <code>element</code>.

   *

   * This method filters out attributes for element names, <code>Icon</code>s

   * and <code>Component</code>s.

   *

   * @param element the <code>Element</code> from which to copy the text

   *         attributes

   * @param set the inputAttributes to copy the attributes to

   */

  protected void createInputAttributes(Element element,

                                       MutableAttributeSet set)

  {

    // FIXME: Filter out component, icon and element name attributes.

    set.removeAttributes(set);

    set.addAttributes(element.getAttributes());

  }

}