+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,
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;
+ }
}
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();
+ }
}
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;
+ }
+ }
}
projects / gcc.git / commitdiff