OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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

Browse Source 
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
This commit is contained in:
Michael Koch 2003-02-27 10:52:41 +00:00 committed by Michael Koch
parent 6fc19dc929
commit 3894fe3207
4 changed files with 497 additions and 360 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
libjava/ChangeLog
View File

@ -1,3 +1,10 @@
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> 2003-02-25 Michael Koch <konqueror@gmx.de>
* gnu/java/nio/MappedByteFileBuffer.java, * gnu/java/nio/MappedByteFileBuffer.java,

344
libjava/java/beans/Beans.java
View File

@ -43,166 +43,216 @@ import java.applet.*;
import gnu.java.io.*; 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 * @author John Keiser
* @since JDK1.1 * @since 1.1
* @version 1.1.0, 29 Jul 1998 * @version 1.1.0, 29 Jul 1998
* *
*/ */
public class Beans { public class Beans
static boolean designTime = false; {
static boolean guiAvailable = true; 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.
}
/** /**
* Once again, we have a java.beans class with only * Allows you to instantiate a Bean. This method takes
* static methods that can be instantiated. When * a ClassLoader from which to read the Bean and the
* will the madness end? :) * name of the Bean.<P>
*/ *
public Beans() { * 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)
* Allows you to instantiate a Bean. This method takes {
* a ClassLoader from which to read the Bean and the Applet a = (Applet)bean;
* name of the Bean.<P> //a.setAppletContext(???);
* //a.setStub(???);
* The Bean name should be a dotted name, like a class. if(serStream == null)
* It can represent several things. Beans will search {
* for the Bean using the name like this:<P> a.init();
* <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; return bean;
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; * Get the Bean as a different class type.
//a.setAppletContext(???); * This should be used instead of casting to get a new
//a.setStub(???); * type view of a Bean, because in the future there may
if(serStream == null) { * be new types of Bean, even Beans spanning multiple
a.init(); * 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;
}
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);
}
/** /**
* Get the Bean as a different class type. * Find out whether the GUI is available to use.
* This should be used instead of casting to get a new * Defaults to true.
* type view of a Bean, because in the future there may *
* be new types of Bean, even Beans spanning multiple * @return whether the GUI is available to use.
* Objects. */
* @param bean the Bean to cast. public static boolean isGuiAvailable()
* @param newClass the Class to cast it to. {
* @return the Bean as a new view, or if the operation return guiAvailable;
* 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 * Find out whether it is design time. Design time means
* class type. * we are in a RAD tool.
* This should be used instead of instanceof to determine * Defaults to false.
* a Bean's castability, because in the future there may *
* be new types of Bean, even Beans spanning multiple * @return whether it is design time.
* Objects. */
* @param bean the Bean to cast. public static boolean isDesignTime()
* @param newClass the Class to cast it to. {
* @return whether the Bean can be cast to the class type return designTime;
* in question. }
*/
public static boolean isInstanceOf(Object bean, Class newBeanClass) {
return newBeanClass.isInstance(bean);
}
/** /**
* Find out whether the GUI is available to use. * Set whether the GUI is available to use.
* Defaults to true. * @param guiAvailable whether the GUI is available to use.
* @return whether the GUI is available to use. */
*/ public static void setGuiAvailable(boolean guiAvailable)
public static boolean isGuiAvailable() { throws SecurityException
return guiAvailable; {
} Beans.guiAvailable = guiAvailable;
}
/** /**
* Find out whether it is design time. Design time means * Set whether it is design time. Design time means we
* we are in a RAD tool. * are in a RAD tool.
* Defaults to false. *
* @return whether it is design time. * @param designTime whether it is design time.
*/ */
public static boolean isDesignTime() { public static void setDesignTime(boolean designTime)
return designTime; throws SecurityException
} {
Beans.designTime = 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;
}
} }

259
libjava/java/beans/FeatureDescriptor.java
View File

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

247
libjava/java/beans/PropertyEditorManager.java
View File

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