Beans.java, [...]: Reformated to GNU style.

2003-02-27  Michael Koch  <konqueror@gmx.de>

	* java/beans/Beans.java,
	java/beans/FeatureDescriptor.java
	java/beans/PropertyEditorManager.java:
	Reformated to GNU style.

From-SVN: r63501

libjava/ChangeLog

+2003-02-27  Michael Koch  <konqueror@gmx.de>
+
+	* java/beans/Beans.java,
+	java/beans/FeatureDescriptor.java
+	java/beans/PropertyEditorManager.java:
+	Reformated to GNU style.
+
 2003-02-25  Michael Koch  <konqueror@gmx.de>
 
 	* gnu/java/nio/MappedByteFileBuffer.java,

libjava/java/beans/Beans.java

@@ -43,166 +43,216 @@ import java.applet.*;
 import gnu.java.io.*;
 
 /**
- * <code>Beans</code> provides some helper methods that allow the basic operations of Bean-ness.
+ * <code>Beans</code> provides some helper methods that allow the basic
+ * operations of Bean-ness.
  *
  * @author John Keiser
- * @since JDK1.1
+ * @since 1.1
  * @version 1.1.0, 29 Jul 1998
  *
  */
-public class Beans {
-	static boolean designTime = false;
-	static boolean guiAvailable = true;
-
-
-	/**
-	 * Once again, we have a java.beans class with only
-	 * static methods that can be instantiated.  When
-	 * will the madness end? :)
-	 */
-	public Beans() {
-	}
-
-	/**
-	 * Allows you to instantiate a Bean.  This method takes
-	 * a ClassLoader from which to read the Bean and the
-	 * name of the Bean.<P>
-	 *
-	 * The Bean name should be a dotted name, like a class.
-	 * It can represent several things.  Beans will search
-	 * for the Bean using the name like this:<P>
-	 * <OL>
-	 * <LI>Searches for a serialized instance of the Bean
-	 * using getResource(), mangling the Bean name by
-	 * replacing the dots with slashes and appending .ser
-	 * (for example, gnu.beans.BlahDeBlah would cause
-	 * Beans to search for gnu/beans/BlahDeBlah.ser using
-	 * getResource()).</LI>
-	 * <LI>Searches for the Bean class using the beanName,
-	 * and then instantiates it with the no-arg constructor.
-	 * At that point, if it is an Applet, it provides it
-	 * with AppletContext and AppletStub, and then calls
-	 * init().</LI>
-	 * </OL>
-	 * @param cl the ClassLoader to use, or <CODE>null</CODE>
-	 *        to use the default ClassLoader.
-	 * @param beanName the name of the Bean.
-	 * @return the Bean.
-	 * @XXX
-	 */
-	public static Object instantiate(ClassLoader cl, String beanName) throws IOException, ClassNotFoundException {
-		Object bean;
-
-		InputStream serStream;
-		if(cl == null) {
-			serStream = ClassLoader.getSystemResourceAsStream(beanName.replace('.','/')+".ser");
-		} else {
-			serStream = cl.getResourceAsStream(beanName.replace('.','/')+".ser");
-		}
-		if(serStream != null) {
-			if(cl == null) {
-				ObjectInputStream ois = new ObjectInputStream(serStream);
-				bean = ois.readObject();
-			} else {
-				ClassLoaderObjectInputStream ois = new ClassLoaderObjectInputStream(serStream, cl);
-				bean = ois.readObject();
-			}
-		} else if(cl == null) {
-			Class beanClass = Class.forName(beanName);
-			try {
-				bean = beanClass.newInstance();
-			} catch(IllegalAccessException E) {
-				bean = null;
-			} catch(InstantiationException E) {
-				bean = null;
-			}
-		} else {
-			Class beanClass = cl.loadClass(beanName);
-			try {
-				bean = beanClass.newInstance();
-			} catch(IllegalAccessException E) {
-				bean = null;
-			} catch(InstantiationException E) {
-				bean = null;
-			}
-		}
-
-		if(bean instanceof Applet) {
-			Applet a = (Applet)bean;
-			//a.setAppletContext(???);
-			//a.setStub(???);
-			if(serStream == null) {
-				a.init();
-			}
-		}
-
-		return bean;
-	}
-
-	/**
-	 * Get the Bean as a different class type.
-	 * This should be used instead of casting to get a new
-	 * type view of a Bean, because in the future there may
-	 * be new types of Bean, even Beans spanning multiple
-	 * Objects.
-	 * @param bean the Bean to cast.
-	 * @param newClass the Class to cast it to.
-	 * @return the Bean as a new view, or if the operation
-	 *         could not be performed, the Bean itself.
-	 */
-	public static Object getInstanceOf(Object bean, Class newClass) {
-		return bean;
-	}
-
-	/**
-	 * Determine whether the Bean can be cast to a different
-	 * class type.
-	 * This should be used instead of instanceof to determine
-	 * a Bean's castability, because in the future there may
-	 * be new types of Bean, even Beans spanning multiple
-	 * Objects.
-	 * @param bean the Bean to cast.
-	 * @param newClass the Class to cast it to.
-	 * @return whether the Bean can be cast to the class type
-	 *         in question.
-	 */
-	public static boolean isInstanceOf(Object bean, Class newBeanClass) {
-		return newBeanClass.isInstance(bean);
-	}
-
-	/**
-	 * Find out whether the GUI is available to use.
-	 * Defaults to true.
-	 * @return whether the GUI is available to use.
-	 */
-	public static boolean isGuiAvailable() {
-		return guiAvailable;
-	}
-
-	/**
-	 * Find out whether it is design time.  Design time means
-	 * we are in a RAD tool.
-	 * Defaults to false.
-	 * @return whether it is design time.
-	 */
-	public static boolean isDesignTime() {
-		return designTime;
-	}
-
-	/**
-	 * Set whether the GUI is available to use.
-	 * @param guiAvailable whether the GUI is available to use.
-	 */
-	public static void setGuiAvailable(boolean guiAvailable) throws SecurityException {
-		Beans.guiAvailable = guiAvailable;
-	}
-
-	/**
-	 * Set whether it is design time.  Design time means we
-	 * are in a RAD tool.
-	 * @param designTime whether it is design time.
-	 */
-	public static void setDesignTime(boolean designTime) throws SecurityException {
-		Beans.designTime = designTime;
-	}
+public class Beans
+{
+  static boolean designTime = false;
+  static boolean guiAvailable = true;
+
+  /**
+   * Once again, we have a java.beans class with only
+   * static methods that can be instantiated.  When
+   * will the madness end? :)
+   */
+  public Beans()
+  {
+    // Do nothing here.
+  }
+
+  /**
+   * Allows you to instantiate a Bean.  This method takes
+   * a ClassLoader from which to read the Bean and the
+   * name of the Bean.<P>
+   *
+   * The Bean name should be a dotted name, like a class.
+   * It can represent several things.  Beans will search
+   * for the Bean using the name like this:<P>
+   * <OL>
+   * <LI>Searches for a serialized instance of the Bean
+   * using getResource(), mangling the Bean name by
+   * replacing the dots with slashes and appending .ser
+   * (for example, gnu.beans.BlahDeBlah would cause
+   * Beans to search for gnu/beans/BlahDeBlah.ser using
+   * getResource()).</LI>
+   * <LI>Searches for the Bean class using the beanName,
+   * and then instantiates it with the no-arg constructor.
+   * At that point, if it is an Applet, it provides it
+   * with AppletContext and AppletStub, and then calls
+   * init().</LI>
+   * </OL>
+   *
+   * @param cl the ClassLoader to use, or <CODE>null</CODE>
+   *        to use the default ClassLoader.
+   * @param beanName the name of the Bean.
+   *
+   * @return the Bean.
+   *
+   * @XXX
+   */
+  public static Object instantiate (ClassLoader cl, String beanName)
+    throws IOException, ClassNotFoundException
+  {
+    Object bean;
+    InputStream serStream;
+    
+    if (cl == null)
+      {
+        serStream = ClassLoader.getSystemResourceAsStream
+          (beanName.replace ('.','/')+".ser");
+      }
+    else
+      {
+        serStream = cl.getResourceAsStream (beanName.replace ('.', '/')
+                                            + ".ser");
+      }
+    
+    if (serStream != null)
+      {
+        if(cl == null)
+          {
+            ObjectInputStream ois = new ObjectInputStream(serStream);
+            bean = ois.readObject();
+          }
+        else
+          {
+            ClassLoaderObjectInputStream ois =
+              new ClassLoaderObjectInputStream (serStream, cl);
+            bean = ois.readObject();
+          }
+      }
+    else if(cl == null)
+      {
+        Class beanClass = Class.forName(beanName);
+        try
+          {
+            bean = beanClass.newInstance();
+          }
+        catch(IllegalAccessException E)
+          {
+            bean = null;
+          }
+        catch(InstantiationException E)
+          {
+            bean = null;
+          }
+      }
+    else
+      {
+        Class beanClass = cl.loadClass(beanName);
+        try
+          {
+            bean = beanClass.newInstance();
+          }
+        catch(IllegalAccessException E)
+          {
+            bean = null;
+          }
+        catch(InstantiationException E)
+          {
+            bean = null;
+          }
+      }
+
+    if(bean instanceof Applet)
+      {
+        Applet a = (Applet)bean;
+        //a.setAppletContext(???);
+        //a.setStub(???);
+        if(serStream == null)
+          {
+            a.init();
+          }
+      }
+
+    return bean;
+  }
+
+  /**
+   * Get the Bean as a different class type.
+   * This should be used instead of casting to get a new
+   * type view of a Bean, because in the future there may
+   * be new types of Bean, even Beans spanning multiple
+   * Objects.
+   *
+   * @param bean the Bean to cast.
+   * @param newClass the Class to cast it to.
+   *
+   * @return the Bean as a new view, or if the operation
+   *         could not be performed, the Bean itself.
+   */
+  public static Object getInstanceOf(Object bean, Class newClass)
+  {
+    return bean;
+  }
+
+  /**
+   * Determine whether the Bean can be cast to a different
+   * class type.
+   * This should be used instead of instanceof to determine
+   * a Bean's castability, because in the future there may
+   * be new types of Bean, even Beans spanning multiple
+   * Objects.
+   *
+   * @param bean the Bean to cast.
+   * @param newClass the Class to cast it to.
+   *
+   * @return whether the Bean can be cast to the class type
+   *         in question.
+   */
+  public static boolean isInstanceOf(Object bean, Class newBeanClass)
+  {
+    return newBeanClass.isInstance(bean);
+  }
+
+  /**
+   * Find out whether the GUI is available to use.
+   * Defaults to true.
+   *
+   * @return whether the GUI is available to use.
+   */
+  public static boolean isGuiAvailable()
+  {
+    return guiAvailable;
+  }
+
+  /**
+   * Find out whether it is design time.  Design time means
+   * we are in a RAD tool.
+   * Defaults to false.
+   *
+   * @return whether it is design time.
+   */
+  public static boolean isDesignTime()
+  {
+    return designTime;
+  }
+
+  /**
+   * Set whether the GUI is available to use.
+   * @param guiAvailable whether the GUI is available to use.
+   */
+  public static void setGuiAvailable(boolean guiAvailable)
+    throws SecurityException
+  {
+    Beans.guiAvailable = guiAvailable;
+  }
+
+  /**
+   * Set whether it is design time.  Design time means we
+   * are in a RAD tool.
+   *
+   * @param designTime whether it is design time.
+   */
+  public static void setDesignTime(boolean designTime)
+    throws SecurityException
+  {
+    Beans.designTime = designTime;
+  }
 }

libjava/java/beans/FeatureDescriptor.java

@@ -41,126 +41,175 @@ package java.beans;
 import java.util.*;
 
 /**
- ** FeatureDescriptor is the common superclass for all JavaBeans Descriptor classes.
- ** JavaBeans descriptors are abstract descriptors of properties,
- ** events, methods, beans, etc.<P>
- **
- ** <STRONG>Documentation Convention:</STRONG> for proper
- ** Internalization of Beans inside an RAD tool, sometimes there
- ** are two names for a property or method: a programmatic, or
- ** locale-independent name, which can be used anywhere, and a
- ** localized, display name, for ease of use.  In the
- ** documentation I will specify different String values as
- ** either <EM>programmatic</EM> or <EM>localized</EM> to
- ** make this distinction clear.
- **
- ** @author John Keiser
- ** @since JDK1.1
- ** @version 1.1.0, 31 May 1998
- **/
-
-public class FeatureDescriptor {
-	String name;
-	String displayName;
-	String shortDescription;
-	boolean expert;
-	boolean hidden;
-
-	Hashtable valueHash;
-
-	/** Instantiate this FeatureDescriptor with appropriate default values.**/
-	public FeatureDescriptor() {
-		valueHash = new Hashtable();
-	}
-
-	/** Get the programmatic name of this feature. **/
-	public String getName() {
-		return name;
-	}
-
-	/** Set the programmatic name of this feature.
-	 ** @param name the new name for this feature.
-	 **/
-	public void setName(String name) {
-		this.name = name;
-	}
-
-	/** Get the localized (display) name of this feature. **/
-	public String getDisplayName() {
-		return displayName;
-	}
-
-	/** Set the localized (display) name of this feature.
-	 ** @param displayName the new display name for this feature.
-	 **/
-	public void setDisplayName(String displayName) {
-		this.displayName = displayName;
-	}
-
-	/** Get the localized short description for this feature. **/
-	public String getShortDescription() {
-		return shortDescription;
-	}
-
-	/** Set the localized short description for this feature.
-	 ** @param shortDescription the new short description for this feature.
-	 **/
-	public void setShortDescription(String shortDescription) {
-		this.shortDescription = shortDescription;
-	}
-
-	/** Indicates whether this feature is for expert use only.
-	 ** @return true if for use by experts only, or false if anyone can use it.
-	 **/
-	public boolean isExpert() {
-		return expert;
-	}
-
-	/** Set whether this feature is for expert use only.
-	 ** @param expert true if for use by experts only, or false if anyone can use it.
-	 **/
-	public void setExpert(boolean expert) {
-		this.expert = expert;
-	}
-
-	/** Indicates whether this feature is for use by tools only.
-	 ** If it is for use by tools only, then it should not be displayed.
-	 ** @return true if tools only should use it, or false if anyone can see it.
-	 **/
-	public boolean isHidden() {
-		return hidden;
-	}
-
-	/** Set whether this feature is for use by tools only.
-	 ** If it is for use by tools only, then it should not be displayed.
-	 ** @param hidden true if tools only should use it, or false if anyone can see it.
-	 **/
-	public void setHidden(boolean hidden) {
-		this.hidden = hidden;
-	}
-
-
-	/** Get an arbitrary value set with setValue().
-	 ** @param name the programmatic name of the key.
-	 ** @return the value associated with this name, or null if there is none.
-	 **/
-	public Object getValue(String name) {
-		return valueHash.get(name);
-	}
-
-	/** Set an arbitrary string-value pair with this feature.
-	 ** @param name the programmatic name of the key.
-	 ** @param value the value to associate with the name.
-	 **/
-	public void setValue(String name, Object value) {
-		valueHash.put(name, value);
-	}
-
-	/** Get a list of the programmatic key names set with setValue().
-	 ** @return an Enumerator over all the programmatic key names associated
-	 ** with this feature.
-	 **/
-	public Enumeration attributeNames() {
-		return valueHash.keys();
-	}
+ * FeatureDescriptor is the common superclass for all JavaBeans Descriptor
+ * classes. JavaBeans descriptors are abstract descriptors of properties,
+ * events, methods, beans, etc.<P>
+ *
+ * <STRONG>Documentation Convention:</STRONG> for proper
+ * Internalization of Beans inside an RAD tool, sometimes there
+ * are two names for a property or method: a programmatic, or
+ * locale-independent name, which can be used anywhere, and a
+ * localized, display name, for ease of use.  In the
+ * documentation I will specify different String values as
+ * either <EM>programmatic</EM> or <EM>localized</EM> to
+ * make this distinction clear.
+ *
+ * @author John Keiser
+ * @since 1.1
+ * @version 1.1.0, 31 May 1998
+ */
+
+public class FeatureDescriptor
+{
+  String name;
+  String displayName;
+  String shortDescription;
+  boolean expert;
+  boolean hidden;
+
+  Hashtable valueHash;
+
+  /**
+   * Instantiate this FeatureDescriptor with appropriate default values.
+   */
+  public FeatureDescriptor()
+  {
+    valueHash = new Hashtable();
+  }
+
+  /**
+   * Get the programmatic name of this feature.
+   */
+  public String getName()
+  {
+    return name;
+  }
+
+  /**
+   * Set the programmatic name of this feature.
+   *
+   * @param name the new name for this feature.
+   */
+  public void setName(String name)
+  {
+    this.name = name;
+  }
+
+  /**
+   * Get the localized (display) name of this feature.
+   */
+  public String getDisplayName()
+  {
+    return displayName;
+  }
+
+  /**
+   * Set the localized (display) name of this feature.
+   *
+   * @param displayName the new display name for this feature.
+   */
+  public void setDisplayName(String displayName)
+  {
+    this.displayName = displayName;
+  }
+
+  /**
+   * Get the localized short description for this feature.
+   */
+  public String getShortDescription()
+  {
+    return shortDescription;
+  }
+
+  /**
+   * Set the localized short description for this feature.
+   *
+   * @param shortDescription the new short description for this feature.
+   */
+  public void setShortDescription(String shortDescription)
+  {
+    this.shortDescription = shortDescription;
+  }
+
+  /**
+   * Indicates whether this feature is for expert use only.
+   *
+   * @return true if for use by experts only,
+   * or false if anyone can use it.
+   */
+  public boolean isExpert()
+  {
+    return expert;
+  }
+
+  /**
+   * Set whether this feature is for expert use only.
+   *
+   * @param expert true if for use by experts only,
+   * or false if anyone can use it.
+   */
+  public void setExpert(boolean expert)
+  {
+    this.expert = expert;
+  }
+
+  /**
+   * Indicates whether this feature is for use by tools only.
+   * If it is for use by tools only, then it should not be displayed.
+   *
+   * @return true if tools only should use it,
+   * or false if anyone can see it.
+   */
+  public boolean isHidden()
+  {
+    return hidden;
+  }
+
+  /**
+   * Set whether this feature is for use by tools only.
+   * If it is for use by tools only, then it should not be displayed.
+   *
+   * @param hidden true if tools only should use it,
+   * or false if anyone can see it.
+   */
+  public void setHidden(boolean hidden)
+  {
+    this.hidden = hidden;
+  }
+
+
+  /**
+   * Get an arbitrary value set with setValue().
+   *
+   * @param name the programmatic name of the key.
+   *
+   * @return the value associated with this name,
+   * or null if there is none.
+   */
+  public Object getValue(String name)
+  {
+    return valueHash.get(name);
+  }
+
+  /**
+   * Set an arbitrary string-value pair with this feature.
+   *
+   * @param name the programmatic name of the key.
+   * @param value the value to associate with the name.
+   */
+  public void setValue(String name, Object value)
+  {
+    valueHash.put(name, value);
+  }
+
+  /**
+   * Get a list of the programmatic key names set with setValue().
+   *
+   * @return an Enumerator over all the programmatic key names associated
+   * with this feature.
+   */
+  public Enumeration attributeNames()
+  {
+    return valueHash.keys();
+  }
 }

libjava/java/beans/PropertyEditorManager.java

@@ -41,121 +41,152 @@ package java.beans;
 import gnu.java.lang.ClassHelper;
 
 /**
- ** PropertyEditorManager is used to find property editors
- ** for various types (not necessarily Beans).<P>
- **
- ** It first checks to see if the property editor is
- ** already registered; if it is, that property editor is
- ** used.  Next it takes the type's classname and appends
- ** "Editor" to it, and searches first in the class's
- ** package and then in the property editor search path.<P>
- **
- ** Default property editors are provided for:<P>
- ** <OL>
- ** <LI>boolean, byte, short, int, long, float, and double</LI>
- ** <LI>java.lang.String</LI>
- ** <LI>java.awt.Color</LI>
- ** <LI>java.awt.Font</LI>
- ** <OL>
- **
- ** <STRONG>Spec Suggestion:</STRONG> Perhaps an editor for
- ** Filename or something like it should be provided.  As well
- ** as char.
- **
- ** @author John Keiser
- ** @since JDK1.1
- ** @version 1.1.0, 29 Jul 1998
- **/
-
-public class PropertyEditorManager {
-	static java.util.Hashtable editors = new java.util.Hashtable();
-	static String[] editorSearchPath = {"gnu.java.beans.editors","sun.beans.editors"};
-
-	static {
-		registerEditor(java.lang.Boolean.TYPE, gnu.java.beans.editors.NativeBooleanEditor.class);
-		registerEditor(java.lang.Byte.TYPE,    gnu.java.beans.editors.NativeByteEditor.class);
-		registerEditor(java.lang.Short.TYPE,   gnu.java.beans.editors.NativeShortEditor.class);
-		registerEditor(java.lang.Integer.TYPE, gnu.java.beans.editors.NativeIntEditor.class);
-		registerEditor(java.lang.Long.TYPE,    gnu.java.beans.editors.NativeLongEditor.class);
-		registerEditor(java.lang.Float.TYPE,   gnu.java.beans.editors.NativeFloatEditor.class);
-		registerEditor(java.lang.Double.TYPE,  gnu.java.beans.editors.NativeDoubleEditor.class);
-		registerEditor(java.lang.String.class, gnu.java.beans.editors.StringEditor.class);
-		registerEditor(java.awt.Color.class,   gnu.java.beans.editors.ColorEditor.class);
-		registerEditor(java.awt.Font.class,    gnu.java.beans.editors.FontEditor.class);
-	}
-
-	/** Beats me why this class can be instantiated, but there
-	 ** you have it.
-	 **/
-	public PropertyEditorManager() { }
-
-	/** Register an editor for a class.  Replaces old editor
-	 ** if there was one registered before.
-	 ** @param editedClass the class that the property editor
-	 **        will edit.
-	 ** @param editorClass the PropertyEditor class.
-	 **/
-	public static void registerEditor(Class editedClass, Class editorClass) {
-		editors.put(editedClass, editorClass);
-	}
-
-	/** Returns a new instance of the property editor for the
-	 ** specified class.
-	 ** @param editedClass the class that the property editor
-	 **        will edit.
-	 ** @return a PropertyEditor instance that can edit the
-	 **         specified class.
-	 **/
-	public static PropertyEditor findEditor(Class editedClass) {
-		try {
-
-		Class found = (Class)editors.get(editedClass);
-		if(found != null) {
-			return (PropertyEditor)found.newInstance();
-		}
-
-		try {
-			found = Class.forName(editedClass.getName()+"Editor");
-			registerEditor(editedClass,found);
-			return (PropertyEditor)found.newInstance();
-		} catch(ClassNotFoundException E) {
-		}
-
-		String appendName = "." + ClassHelper.getTruncatedClassName(editedClass) + "Editor";
-		synchronized(editorSearchPath) {
-			for(int i=0;i<editorSearchPath.length;i++) {
-				try {
-					found = Class.forName(editorSearchPath[i] + appendName);
-					registerEditor(editedClass,found);
-					return (PropertyEditor)found.newInstance();
-				} catch(ClassNotFoundException E) {
-				}
-			}
-		}
-
-		} catch(InstantiationException E) {
-		} catch(IllegalAccessException E) {
-		}
-		return null;
-	}
-
-	/** Get the editor search path.
-	 ** As a minor departure from the spec, the default value
-	 ** for the editor search path is "gnu.java.beans.editors",
-	 ** "sun.beans.editors".
-	 ** @return the editor search path.
-	 **/
-	public static String[] getEditorSearchPath() {
-		return editorSearchPath;
-	}
-
-	/** Set the editor search path.
-	 ** @param editorSearchPath the new value for the editor
-	 **        search path.
-	 **/
-	public static void setEditorSearchPath(String[] editorSearchPath) {
-		synchronized(editorSearchPath) {
-			PropertyEditorManager.editorSearchPath = editorSearchPath;
-		}
-	}
+ * PropertyEditorManager is used to find property editors
+ * for various types (not necessarily Beans).<P>
+ *
+ * It first checks to see if the property editor is
+ * already registered; if it is, that property editor is
+ * used.  Next it takes the type's classname and appends
+ * "Editor" to it, and searches first in the class's
+ * package and then in the property editor search path.<P>
+ *
+ * Default property editors are provided for:<P>
+ * <OL>
+ * <LI>boolean, byte, short, int, long, float, and double</LI>
+ * <LI>java.lang.String</LI>
+ * <LI>java.awt.Color</LI>
+ * <LI>java.awt.Font</LI>
+ * <OL>
+ *
+ * <STRONG>Spec Suggestion:</STRONG> Perhaps an editor for
+ * Filename or something like it should be provided.  As well
+ * as char.
+ *
+ * @author John Keiser
+ * @since 1.1
+ * @version 1.1.0, 29 Jul 1998
+ */
+
+public class PropertyEditorManager
+{
+  static java.util.Hashtable editors = new java.util.Hashtable();
+  static String[] editorSearchPath = {"gnu.java.beans.editors","sun.beans.editors"};
+
+  static
+    {
+      registerEditor(java.lang.Boolean.TYPE, gnu.java.beans.editors.NativeBooleanEditor.class);
+      registerEditor(java.lang.Byte.TYPE,    gnu.java.beans.editors.NativeByteEditor.class);
+      registerEditor(java.lang.Short.TYPE,   gnu.java.beans.editors.NativeShortEditor.class);
+      registerEditor(java.lang.Integer.TYPE, gnu.java.beans.editors.NativeIntEditor.class);
+      registerEditor(java.lang.Long.TYPE,    gnu.java.beans.editors.NativeLongEditor.class);
+      registerEditor(java.lang.Float.TYPE,   gnu.java.beans.editors.NativeFloatEditor.class);
+      registerEditor(java.lang.Double.TYPE,  gnu.java.beans.editors.NativeDoubleEditor.class);
+      registerEditor(java.lang.String.class, gnu.java.beans.editors.StringEditor.class);
+      registerEditor(java.awt.Color.class,   gnu.java.beans.editors.ColorEditor.class);
+      registerEditor(java.awt.Font.class,    gnu.java.beans.editors.FontEditor.class);
+    }
+
+  /**
+   * Beats me why this class can be instantiated, but there
+   * you have it.
+   */
+  public PropertyEditorManager()
+  {
+    // Do nothing here
+  }
+
+  /**
+   * Register an editor for a class.  Replaces old editor
+   * if there was one registered before.
+   *
+   * @param editedClass the class that the property editor
+   *        will edit.
+   * @param editorClass the PropertyEditor class.
+   */
+  public static void registerEditor(Class editedClass, Class editorClass)
+  {
+    editors.put(editedClass, editorClass);
+  }
+
+  /**
+   * Returns a new instance of the property editor for the
+   * specified class.
+   *
+   * @param editedClass the class that the property editor
+   *        will edit.
+   * @return a PropertyEditor instance that can edit the
+   *         specified class.
+   */
+  public static PropertyEditor findEditor(Class editedClass)
+  {
+    try
+      {
+        Class found = (Class)editors.get(editedClass);
+        if(found != null)
+          {
+            return (PropertyEditor)found.newInstance();
+          }
+
+        try
+          {
+            found = Class.forName(editedClass.getName()+"Editor");
+            registerEditor(editedClass,found);
+            return (PropertyEditor)found.newInstance();
+          }
+        catch(ClassNotFoundException E)
+          {
+          }
+
+        String appendName = "." + ClassHelper.getTruncatedClassName(editedClass) + "Editor";
+        synchronized(editorSearchPath)
+          {
+            for(int i=0;i<editorSearchPath.length;i++)
+              {
+                try
+                  {
+                    found = Class.forName(editorSearchPath[i] + appendName);
+                    registerEditor(editedClass,found);
+                    return (PropertyEditor)found.newInstance();
+                  }
+                catch(ClassNotFoundException E)
+                  {
+                  }
+              }
+          }
+      }
+    catch(InstantiationException E)
+      {
+      }
+    catch(IllegalAccessException E)
+      {
+      }
+    
+    return null;
+  }
+
+  /**
+   * Get the editor search path.
+   * As a minor departure from the spec, the default value
+   * for the editor search path is "gnu.java.beans.editors",
+   * "sun.beans.editors".
+   *
+   * @return the editor search path.
+   */
+  public static String[] getEditorSearchPath()
+  {
+    return editorSearchPath;
+  }
+
+  /**
+   * Set the editor search path.
+   *
+   * @param editorSearchPath the new value for the editor search path.
+   */
+  public static void setEditorSearchPath(String[] editorSearchPath)
+  {
+    synchronized(editorSearchPath)
+      {
+        PropertyEditorManager.editorSearchPath = editorSearchPath;
+      }
+  }
 }