abstractpropertyeditor.java

报表设计软件,很好的

/**
 * ========================================
 * JFreeReport : a free Java report library
 * ========================================
 *
 * Project Info:  http://www.jfree.org/jfreereport/index.html
 * Project Lead:  Thomas Morgner ([e-mail]);
 *
 * (C) Copyright 2000-2003, by Simba Management Limited and Contributors.
 *
 * This library is free software; you can redistribute it and/or modify it under the terms
 * of the GNU Lesser General Public License as published by the Free Software Foundation;
 * either version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License along with this
 * library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * ------------------------------
 * AbstractPropertyEditor.java
 * ------------------------------
 * (C)opyright 2003, by Thomas Morgner and Contributors.
 *
 * Original Author:  Thomas Morgner;
 * Contributor(s):   David Gilbert (for Simba Management Limited);
 *
 * $Id: AbstractPropertyEditor.java,v 1.2 2004/04/20 18:54:42 taqua Exp $
 *
 * Changes
 * -------------------------
 * 21.10.2003 : Initial version
 *
 */

package org.jfree.designer.propertyeditors;

import java.awt.Component;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.beans.PropertyEditor;
import java.util.Iterator;

public abstract class AbstractPropertyEditor
        implements PropertyEditor
{
  private Object value;
  private final PropertyChangeSupport support;
  private final ReverseLookupMap valueMap;

  public AbstractPropertyEditor ()
  {
    support = new PropertyChangeSupport(this);
    valueMap = new ReverseLookupMap();
  }

  /**
   * Register a listener for the PropertyChange event.  When a PropertyEditor changes its
   * value it should fire a PropertyChange event on all registered
   * PropertyChangeListeners, specifying the null value for the property name and itself
   * as the source.
   *
   * @param listener An object to be invoked when a PropertyChange event is fired.
   */
  public final void addPropertyChangeListener (final PropertyChangeListener listener)
  {
    support.addPropertyChangeListener(listener);
  }

  /**
   * Remove a listener for the PropertyChange event.
   *
   * @param listener The PropertyChange listener to be removed.
   */
  public final void removePropertyChangeListener (final PropertyChangeListener listener)
  {
    support.removePropertyChangeListener(listener);
  }

  /**
   * Determines whether this property editor is paintable.
   *
   * @return True if the class will honor the paintValue method.
   */

  public boolean isPaintable ()
  {
    return false;
  }

  /**
   * Paint a representation of the value into a given area of screen real estate.  Note
   * that the propertyEditor is responsible for doing its own clipping so that it fits
   * into the given rectangle.
   * <p/>
   * If the PropertyEditor doesn't honor paint requests (see isPaintable) this method
   * should be a silent noop.
   * <p/>
   * The given Graphics object will have the default font, color, etc of the parent
   * container.  The PropertyEditor may change graphics attributes such as font and color
   * and doesn't need to restore the old values.
   *
   * @param gfx Graphics object to paint into.
   * @param box Rectangle within graphics object into which we should paint.
   */
  public void paintValue (final Graphics gfx, final Rectangle box)
  {
  }

  /**
   * Determines whether this property editor supports a custom editor.
   *
   * @return True if the propertyEditor can provide a custom editor.
   */
  public final boolean supportsCustomEditor ()
  {
    return false;
  }

  /**
   * Gets the property value.
   *
   * @return The value of the property.  Primitive types such as "int" will be wrapped as
   *         the corresponding object type such as "java.lang.Integer".
   */
  public Object getValue ()
  {
    return value;
  }

  /**
   * Set (or change) the object that is to be edited.  Primitive types such as "int" must
   * be wrapped as the corresponding object type such as "java.lang.Integer".
   *
   * @param value The new target object to be edited.  Note that this object should not be
   *              modified by the PropertyEditor, rather the PropertyEditor should create
   *              a new object to hold any modified value.
   */
  public void setValue (final Object value)
  {
    final Object oldValue = this.value;
    this.value = value;
    support.firePropertyChange(null, oldValue, value);
  }


  /**
   * Set the property value by parsing a given String.  May raise
   * java.lang.IllegalArgumentException if either the String is badly formatted or if this
   * kind of property can't be expressed as text.
   *
   * @param text The string to be parsed.
   */
  public void setAsText (final String text)
          throws IllegalArgumentException
  {
    final Object object = valueMap.getReverse(text);
    if (object == null)
    {
      throw new IllegalArgumentException("This value is invalid: " + text);
    }
    setValue(object);
  }

  /**
   * If the property value must be one of a set of known tagged values, then this method
   * should return an array of the tags.  This can be used to represent (for example) enum
   * values.  If a PropertyEditor supports tags, then it should support the use of
   * setAsText with a tag value as a way of setting the value and the use of getAsText to
   * identify the current value.
   *
   * @return The tag values for this property.  May be null if this property cannot be
   *         represented as a tagged value.
   */
  public final String[] getTags ()
  {
    if (valueMap.size() == 0)
    {
      return null;
    }

    final String[] reval = new String[valueMap.size()];
    final Iterator values = valueMap.values();
    int cnt = 0;
    while (values.hasNext())
    {
      reval[cnt] = (String) values.next();
      cnt++;
    }
    return reval;
  }

  public final ReverseLookupMap getValueMap ()
  {
    return valueMap;
  }

  /**
   * A PropertyEditor may choose to make available a full custom Component that edits its
   * property value.  It is the responsibility of the PropertyEditor to hook itself up to
   * its editor Component itself and to report property value changes by firing a
   * PropertyChange event. <P> The higher-level code that calls getCustomEditor may either
   * embed the Component in some larger property sheet, or it may put it in its own
   * individual dialog, or ...
   *
   * @return A java.awt.Component that will allow a human to directly edit the current
   *         property value.  May be null if this is not supported.
   */

  public Component getCustomEditor ()
  {
    return null;
  }

  /**
   * Gets the property value as text.
   *
   * @return The property value as a human editable string. <p>   Returns null if the
   *         value can't be expressed as an editable string. <p>   If a non-null value is
   *         returned, then the PropertyEditor should be prepared to parse that string
   *         back in setAsText().
   */
  public String getAsText ()
  {
    if (getValue() == null)
    {
      return null;
    }
    final Object value = valueMap.get(getValue());
    if (value == null)
    {
      return "<null>";
    }
    return value.toString();
  }


}