Skip to content

R
riscv-gcc-1
Commit c9be3825 by Mark Wielaard
Options

[multiple changes] 

2002-03-24  Eric Blake  <ebb9@email.byu.edu>

        * java/beans/IntrospectionException.java: Update to 1.4.
        * java/beans/PropertyVetoException.java: Ditto.

2002-03-24  Eric Blake  <ebb9@email.byu.edu>

        * gnu/java/beans/BeanInfoEmbryo.java (hasMethod): Use
        Arrays.equals instead of ArrayHelper.equalsArray.

2002-03-24  C. Brian Jones <cbj@gnu.org>

        * java/beans/Introspector.java: added new static final fields
        introduced in 1.2, lots of other updates remain to be done

2002-03-24  C. Brian Jones <cbj@gnu.org>

        * java/beans/Introspector.java: reformatting

2002-03-24  C. Brian Jones <cbj@gnu.org>

        * java/beans/Introspector.java: default beanInfoSearchPath will
        not include sun.beans.infos given we provide no such package and
        the API doesn't really require it; gnu.java.beans.info is the
        default.

2002-03-24  Mark Wielaard  <mark@klomp.org>

        Thanks to Orp developers
        * gnu/java/beans/editors/NativeBooleanEditor.java (setAsText(String)):
        switch TRUE and FALSE return values.

From-SVN: r51273
parent 3ddbb8a9
Showing with 595 additions and 439 deletions
libjava/ChangeLog
2002-03-24 Eric Blake <ebb9@email.byu.edu>
* java/beans/IntrospectionException.java: Update to 1.4.
* java/beans/PropertyVetoException.java: Ditto.
2002-03-24 Eric Blake <ebb9@email.byu.edu>
* gnu/java/beans/BeanInfoEmbryo.java (hasMethod): Use
Arrays.equals instead of ArrayHelper.equalsArray.
2002-03-24 C. Brian Jones <cbj@gnu.org>
* java/beans/Introspector.java: added new static final fields
introduced in 1.2, lots of other updates remain to be done
2002-03-24 C. Brian Jones <cbj@gnu.org>
* java/beans/Introspector.java: reformatting
2002-03-24 C. Brian Jones <cbj@gnu.org>
* java/beans/Introspector.java: default beanInfoSearchPath will
not include sun.beans.infos given we provide no such package and
the API doesn't really require it; gnu.java.beans.info is the
default.
2002-03-24 Mark Wielaard <mark@klomp.org>
Thanks to Orp developers
* gnu/java/beans/editors/NativeBooleanEditor.java (setAsText(String)):
switch TRUE and FALSE return values.
2002-03-23 Tom Tromey <tromey@redhat.com> 2002-03-23 Tom Tromey <tromey@redhat.com>
* include/name-finder.h (_Jv_name_finder::myclose): New method. * include/name-finder.h (_Jv_name_finder::myclose): New method.
......
libjava/gnu/java/beans/BeanInfoEmbryo.java
/* gnu.java.beans.BeanInfoEmbryo /* gnu.java.beans.BeanInfoEmbryo
Copyright (C) 1998 Free Software Foundation, Inc. Copyright (C) 1998, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath. This file is part of GNU Classpath.
...@@ -130,14 +130,15 @@ public class BeanInfoEmbryo { ...@@ -130,14 +130,15 @@ public class BeanInfoEmbryo {
} }
public boolean hasMethod(MethodDescriptor m) { public boolean hasMethod(MethodDescriptor m) {
for(int i=0;i<methods.size();i++) { for(int i=0;i<methods.size();i++) {
Method thisMethod = ((MethodDescriptor)methods.elementAt(i)).getMethod(); Method thisMethod = ((MethodDescriptor)methods.elementAt(i)).getMethod();
if(m.getMethod().getName().equals(thisMethod.getName()) if(m.getMethod().getName().equals(thisMethod.getName())
&& ArrayHelper.equalsArray(m.getMethod().getParameterTypes(), thisMethod.getParameterTypes())) { && Arrays.equals(m.getMethod().getParameterTypes(),
return true; thisMethod.getParameterTypes())) {
} return true;
} }
return false; }
return false;
} }
public void addMethod(MethodDescriptor m) { public void addMethod(MethodDescriptor m) {
methods.addElement(m); methods.addElement(m);
......
libjava/gnu/java/beans/editors/NativeBooleanEditor.java
/* gnu.java.beans.editors.NativeBooleanEditor /* gnu.java.beans.editors.NativeBooleanEditor
Copyright (C) 1998 Free Software Foundation, Inc. Copyright (C) 1998, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath. This file is part of GNU Classpath.
...@@ -54,12 +54,15 @@ import java.beans.*; ...@@ -54,12 +54,15 @@ import java.beans.*;
public class NativeBooleanEditor extends PropertyEditorSupport { public class NativeBooleanEditor extends PropertyEditorSupport {
String[] tags = {"true","false"}; String[] tags = {"true","false"};
/** setAsText for boolean checks for true or false or t or f. "" also means false. **/ /**
* setAsText for boolean checks for true or false or t or f.
* "" also means false.
**/
public void setAsText(String val) throws IllegalArgumentException { public void setAsText(String val) throws IllegalArgumentException {
if(val.equalsIgnoreCase("true") || val.equalsIgnoreCase("t")) { if(val.equalsIgnoreCase("true") || val.equalsIgnoreCase("t")) {
setValue(Boolean.FALSE);
} else if(val.equalsIgnoreCase("false") || val.equalsIgnoreCase("f") || val.equals("")) {
setValue(Boolean.TRUE); setValue(Boolean.TRUE);
} else if(val.equalsIgnoreCase("false") || val.equalsIgnoreCase("f") || val.equals("")) {
setValue(Boolean.FALSE);
} else { } else {
throw new IllegalArgumentException("Value must be true, false, t, f or empty."); throw new IllegalArgumentException("Value must be true, false, t, f or empty.");
} }
......
libjava/java/beans/IntrospectionException.java
/* java.beans.IntrospectionException /* IntrospectionException -- thrown when an exception occurs in introspection
Copyright (C) 1998 Free Software Foundation, Inc. Copyright (C) 1998, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath. This file is part of GNU Classpath.
...@@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify ...@@ -7,7 +7,7 @@ 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 it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option) the Free Software Foundation; either version 2, or (at your option)
any later version. any later version.
GNU Classpath is distributed in the hope that it will be useful, but GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
...@@ -39,19 +39,29 @@ exception statement from your version. */ ...@@ -39,19 +39,29 @@ exception statement from your version. */
package java.beans; package java.beans;
/** /**
** IntrospectionException is thrown when the Introspector fails. Surprise, surprise. * IntrospectionException is thrown when the Introspector fails. Typical
** * causes are the inability to map a name to its Class, or specifying a
** @author John Keiser * wrong type signature.
** @since JDK1.1 *
** @version 1.1.0, 31 May 1998 * @author John Keiser
** @see java.beans.Introspector * @see Introspector
**/ * @since 1.1
* @status updated to 1.4
public class IntrospectionException extends Exception { */
/** Instantiate this exception with the given message. public class IntrospectionException extends Exception
** @param msg the message for the exception. {
**/ /**
public IntrospectionException(String msg) { * Compatible with JDK 1.1+.
super(msg); */
} private static final long serialVersionUID = -3728150539969542619L;
/**
* Instantiate this exception with the given message.
*
* @param msg the message for the exception
*/
public IntrospectionException(String msg)
{
super(msg);
}
} }
libjava/java/beans/Introspector.java
...@@ -44,395 +44,488 @@ import java.lang.reflect.*; ...@@ -44,395 +44,488 @@ import java.lang.reflect.*;
import gnu.java.lang.*; import gnu.java.lang.*;
/** /**
** Introspector is the class that does the bulk of the * Introspector is the class that does the bulk of the
** design-time work in Java Beans. Every class must have * design-time work in Java Beans. Every class must have
** a BeanInfo in order for an RAD tool to use it; but, as * a BeanInfo in order for an RAD tool to use it; but, as
** promised, you don't have to write the BeanInfo class * promised, you don't have to write the BeanInfo class
** yourself if you don't want to. All you have to do is * yourself if you don't want to. All you have to do is
** call getBeanInfo() in the Introspector and it will use * call getBeanInfo() in the Introspector and it will use
** standard JavaBeans-defined method signatures to * standard JavaBeans-defined method signatures to
** determine the information about your class.<P> * determine the information about your class.<P>
** *
** Don't worry about it too much, though: you can provide * Don't worry about it too much, though: you can provide
** JavaBeans with as much customized information as you * JavaBeans with as much customized information as you
** want, or as little as you want, using the BeanInfo * want, or as little as you want, using the BeanInfo
** interface (see BeanInfo for details).<P> * interface (see BeanInfo for details).<P>
** *
** <STRONG>Order of Operations</STRONG><P> * <STRONG>Order of Operations</STRONG><P>
** *
** When you call getBeanInfo(class c), the Introspector * When you call getBeanInfo(class c), the Introspector
** first searches for BeanInfo class to see if you * first searches for BeanInfo class to see if you
** provided any explicit information. It searches for a * provided any explicit information. It searches for a
** class named <bean class name>BeanInfo in different * class named <bean class name>BeanInfo in different
** packages, first searching the bean class's package * packages, first searching the bean class's package
** and then moving on to search the beanInfoSearchPath.<P> * and then moving on to search the beanInfoSearchPath.<P>
** *
** If it does not find a BeanInfo class, it acts as though * If it does not find a BeanInfo class, it acts as though
** it had found a BeanInfo class returning null from all * it had found a BeanInfo class returning null from all
** methods (meaning it should discover everything through * methods (meaning it should discover everything through
** Introspection). If it does, then it takes the * Introspection). If it does, then it takes the
** information it finds in the BeanInfo class to be * information it finds in the BeanInfo class to be
** canonical (that is, the information speaks for its * canonical (that is, the information speaks for its
** class as well as all superclasses).<P> * class as well as all superclasses).<P>
** *
** When it has introspected the class, calls * When it has introspected the class, calls
** getBeanInfo(c.getSuperclass) and adds that information * getBeanInfo(c.getSuperclass) and adds that information
** to the information it has, not adding to any information * to the information it has, not adding to any information
** it already has that is canonical.<P> * it already has that is canonical.<P>
** *
** <STRONG>Introspection Design Patterns</STRONG><P> * <STRONG>Introspection Design Patterns</STRONG><P>
** *
** When the Introspector goes in to read the class, it * When the Introspector goes in to read the class, it
** follows a well-defined order in order to not leave any * follows a well-defined order in order to not leave any
** methods unaccounted for. Its job is to step over all * methods unaccounted for. Its job is to step over all
** of the public methods in a class and determine whether * of the public methods in a class and determine whether
** they are part of a property, an event, or a method (in * they are part of a property, an event, or a method (in
** that order). * that order).
** *
** *
** <STRONG>Properties:</STRONG><P> * <STRONG>Properties:</STRONG><P>
** *
** <OL> * <OL>
** <LI>If there is a <CODE>public boolean isXXX()</CODE> * <LI>If there is a <CODE>public boolean isXXX()</CODE>
** method, then XXX is a read-only boolean property. * method, then XXX is a read-only boolean property.
** <CODE>boolean getXXX()</CODE> may be supplied in * <CODE>boolean getXXX()</CODE> may be supplied in
** addition to this method, although isXXX() is the * addition to this method, although isXXX() is the
** one that will be used in this case and getXXX() * one that will be used in this case and getXXX()
** will be ignored. If there is a * will be ignored. If there is a
** <CODE>public void setXXX(boolean)</CODE> method, * <CODE>public void setXXX(boolean)</CODE> method,
** it is part of this group and makes it a read-write * it is part of this group and makes it a read-write
** property.</LI> * property.</LI>
** <LI>If there is a * <LI>If there is a
** <CODE>public &lt;type&gt; getXXX(int)</CODE> * <CODE>public &lt;type&gt; getXXX(int)</CODE>
** method, then XXX is a read-only indexed property of * method, then XXX is a read-only indexed property of
** type &lt;type&gt;. If there is a * type &lt;type&gt;. If there is a
** <CODE>public void setXXX(int,&lt;type&gt;)</CODE> * <CODE>public void setXXX(int,&lt;type&gt;)</CODE>
** method, then it is a read-write indexed property of * method, then it is a read-write indexed property of
** type &lt;type&gt;. There may also be a * type &lt;type&gt;. There may also be a
** <CODE>public &lt;type&gt;[] getXXX()</CODE> and a * <CODE>public &lt;type&gt;[] getXXX()</CODE> and a
** <CODE>public void setXXX(&lt;type&gt;)</CODE> * <CODE>public void setXXX(&lt;type&gt;)</CODE>
** method as well.</CODE></LI> * method as well.</CODE></LI>
** <LI>If there is a * <LI>If there is a
** <CODE>public void setXXX(int,&lt;type&gt;)</CODE> * <CODE>public void setXXX(int,&lt;type&gt;)</CODE>
** method, then it is a write-only indexed property of * method, then it is a write-only indexed property of
** type &lt;type&gt;. There may also be a * type &lt;type&gt;. There may also be a
** <CODE>public &lt;type&gt;[] getXXX()</CODE> and a * <CODE>public &lt;type&gt;[] getXXX()</CODE> and a
** <CODE>public void setXXX(&lt;type&gt;)</CODE> * <CODE>public void setXXX(&lt;type&gt;)</CODE>
** method as well.</CODE></LI> * method as well.</CODE></LI>
** <LI>If there is a * <LI>If there is a
** <CODE>public &lt;type&gt; getXXX()</CODE> method, * <CODE>public &lt;type&gt; getXXX()</CODE> method,
** then XXX is a read-only property of type * then XXX is a read-only property of type
** &lt;type&gt;. If there is a * &lt;type&gt;. If there is a
** <CODE>public void setXXX(&lt;type&gt;)</CODE> * <CODE>public void setXXX(&lt;type&gt;)</CODE>
** method, then it will be used for the property and * method, then it will be used for the property and
** the property will be considered read-write.</LI> * the property will be considered read-write.</LI>
** <LI>If there is a * <LI>If there is a
** <CODE>public void setXXX(&lt;type&gt;)</CODE> * <CODE>public void setXXX(&lt;type&gt;)</CODE>
** method, then as long as XXX is not already used as * method, then as long as XXX is not already used as
** the name of a property, XXX is assumed to be a * the name of a property, XXX is assumed to be a
** write-only property of type &lt;type&gt;.</LI> * write-only property of type &lt;type&gt;.</LI>
** <LI>In all of the above cases, if the setXXX() method * <LI>In all of the above cases, if the setXXX() method
** throws <CODE>PropertyVetoException</CODE>, then the * throws <CODE>PropertyVetoException</CODE>, then the
** property in question is assumed to be constrained. * property in question is assumed to be constrained.
** No properties are ever assumed to be bound * No properties are ever assumed to be bound
** (<STRONG>Spec Note:</STRONG> this is not in the * (<STRONG>Spec Note:</STRONG> this is not in the
** spec, it just makes sense). See PropertyDescriptor * spec, it just makes sense). See PropertyDescriptor
** for a description of bound and constrained * for a description of bound and constrained
** properties.</LI> * properties.</LI>
** </OL> * </OL>
** *
** <STRONG>Events:</STRONG><P> * <STRONG>Events:</STRONG><P>
** *
** If there is a pair of methods, * If there is a pair of methods,
** <CODE>public void addXXX(&lt;type&gt;)</CODE> and * <CODE>public void addXXX(&lt;type&gt;)</CODE> and
** <CODE>public void removeXXX(&lt;type&gt;)</CODE>, where * <CODE>public void removeXXX(&lt;type&gt;)</CODE>, where
** &lt;type&gt; is a descendant of * &lt;type&gt; is a descendant of
** <CODE>java.util.EventListener</CODE>, then the pair of * <CODE>java.util.EventListener</CODE>, then the pair of
** methods imply that this Bean will fire events to * methods imply that this Bean will fire events to
** listeners of type &lt;type&gt;.<P> * listeners of type &lt;type&gt;.<P>
** *
** If the addXXX() method throws * If the addXXX() method throws
** <CODE>java.util.TooManyListenersException</CODE>, then * <CODE>java.util.TooManyListenersException</CODE>, then
** the event set is assumed to be <EM>unicast</EM>. See * the event set is assumed to be <EM>unicast</EM>. See
** EventSetDescriptor for a discussion of unicast event * EventSetDescriptor for a discussion of unicast event
** sets.<P> * sets.<P>
** *
** <STRONG>Spec Note:</STRONG> the spec seems to say that * <STRONG>Spec Note:</STRONG> the spec seems to say that
** the listener type's classname must be equal to the XXX * the listener type's classname must be equal to the XXX
** part of addXXX() and removeXXX(), but that is not the * part of addXXX() and removeXXX(), but that is not the
** case in Sun's implementation, so I am assuming it is * case in Sun's implementation, so I am assuming it is
** not the case in general.<P> * not the case in general.<P>
** *
** <STRONG>Methods:</STRONG><P> * <STRONG>Methods:</STRONG><P>
** *
** Any public methods (including those which were used * Any public methods (including those which were used
** for Properties or Events) are used as Methods. * for Properties or Events) are used as Methods.
** *
** @author John Keiser * @author John Keiser
** @since JDK1.1 * @since JDK1.1
** @version 1.1.0, 29 Jul 1998 * @see java.beans.BeanInfo
** @see java.beans.BeanInfo */
**/
public class Introspector { public class Introspector {
static String[] beanInfoSearchPath = {"gnu.java.beans.info", "sun.beans.infos"};
static Hashtable beanInfoCache = new Hashtable(); public static final int USE_ALL_BEANINFO = 1;
public static final int IGNORE_IMMEDIATE_BEANINFO = 2;
private Introspector() {} public static final int IGNORE_ALL_BEANINFO = 3;
/** Get the BeanInfo for class <CODE>beanClass</CODE>,
** first by looking for explicit information, next by
** using standard design patterns to determine
** information about the class.
** @param beanClass the class to get BeanInfo about.
** @return the BeanInfo object representing the class.
**/
public static BeanInfo getBeanInfo(Class beanClass) throws IntrospectionException {
BeanInfo cachedInfo;
synchronized(beanClass) {
cachedInfo = (BeanInfo)beanInfoCache.get(beanClass);
if(cachedInfo != null) {
return cachedInfo;
}
cachedInfo = getBeanInfo(beanClass,null);
beanInfoCache.put(beanClass,cachedInfo);
return cachedInfo;
}
}
/** Get the BeanInfo for class <CODE>beanClass</CODE>,
** first by looking for explicit information, next by
** using standard design patterns to determine
** information about the class. It crawls up the
** inheritance tree until it hits <CODE>topClass</CODE>.
** @param beanClass the Bean class.
** @param stopClass the class to stop at.
** @return the BeanInfo object representing the class.
**/
public static BeanInfo getBeanInfo(Class beanClass, Class stopClass) throws IntrospectionException {
ExplicitInfo explicit = new ExplicitInfo(beanClass,stopClass);
IntrospectionIncubator ii = new IntrospectionIncubator();
ii.setPropertyStopClass(explicit.propertyStopClass);
ii.setEventStopClass(explicit.eventStopClass);
ii.setMethodStopClass(explicit.methodStopClass);
ii.addMethods(beanClass.getMethods());
BeanInfoEmbryo currentInfo = ii.getBeanInfoEmbryo();
PropertyDescriptor[] p = explicit.explicitPropertyDescriptors;
if(p!=null) {
for(int i=0;i<p.length;i++) {
if(!currentInfo.hasProperty(p[i])) {
currentInfo.addProperty(p[i]);
}
}
if(explicit.defaultProperty != -1) {
currentInfo.setDefaultPropertyName(p[explicit.defaultProperty].getName());
}
}
EventSetDescriptor[] e = explicit.explicitEventSetDescriptors;
if(e!=null) {
for(int i=0;i<e.length;i++) {
if(!currentInfo.hasEvent(e[i])) {
currentInfo.addEvent(e[i]);
}
}
if(explicit.defaultEvent != -1) {
currentInfo.setDefaultEventName(e[explicit.defaultEvent].getName());
}
}
MethodDescriptor[] m = explicit.explicitMethodDescriptors;
if(m!=null) {
for(int i=0;i<m.length;i++) {
if(!currentInfo.hasMethod(m[i])) {
currentInfo.addMethod(m[i]);
}
}
}
if(explicit.explicitBeanDescriptor != null) {
currentInfo.setBeanDescriptor(new BeanDescriptor(beanClass,explicit.explicitBeanDescriptor.getCustomizerClass()));
} else {
currentInfo.setBeanDescriptor(new BeanDescriptor(beanClass,null));
}
currentInfo.setAdditionalBeanInfo(explicit.explicitBeanInfo);
currentInfo.setIcons(explicit.im);
return currentInfo.getBeanInfo();
}
/** Get the search path for BeanInfo classes.
** @return the BeanInfo search path.
**/
public static String[] getBeanInfoSearchPath() {
return beanInfoSearchPath;
}
/** Set the search path for BeanInfo classes.
** @param beanInfoSearchPath the new BeanInfo search
** path.
**/
public static void setBeanInfoSearchPath(String[] beanInfoSearchPath) {
Introspector.beanInfoSearchPath = beanInfoSearchPath;
}
/** A helper method to convert a name to standard Java static String[] beanInfoSearchPath = {"gnu.java.beans.info"};
** naming conventions: anything with two capitals as the static Hashtable beanInfoCache = new Hashtable();
** first two letters remains the same, otherwise the
** first letter is decapitalized. URL = URL, I = i, private Introspector() {}
** MyMethod = myMethod.
** @param name the name to decapitalize. /**
** @return the decapitalized name. * Get the BeanInfo for class <CODE>beanClass</CODE>,
**/ * first by looking for explicit information, next by
public static String decapitalize(String name) { * using standard design patterns to determine
try { * information about the class.
if(!Character.isUpperCase(name.charAt(0))) { *
return name; * @param beanClass the class to get BeanInfo about.
} else { * @return the BeanInfo object representing the class.
try { */
if(Character.isUpperCase(name.charAt(1))) { public static BeanInfo getBeanInfo(Class beanClass)
return name; throws IntrospectionException
} else { {
char[] c = name.toCharArray(); BeanInfo cachedInfo;
c[0] = Character.toLowerCase(c[0]); synchronized(beanClass)
return new String(c); {
} cachedInfo = (BeanInfo)beanInfoCache.get(beanClass);
} catch(StringIndexOutOfBoundsException E) { if(cachedInfo != null)
char[] c = new char[1]; {
c[0] = Character.toLowerCase(name.charAt(0)); return cachedInfo;
return new String(c); }
} cachedInfo = getBeanInfo(beanClass,null);
} beanInfoCache.put(beanClass,cachedInfo);
} catch(StringIndexOutOfBoundsException E) { return cachedInfo;
return name; }
} catch(NullPointerException E) { }
return null;
}
}
static BeanInfo copyBeanInfo(BeanInfo b) { /**
java.awt.Image[] icons = new java.awt.Image[4]; * Get the BeanInfo for class <CODE>beanClass</CODE>,
for(int i=1;i<=4;i++) { * first by looking for explicit information, next by
icons[i-1] = b.getIcon(i); * using standard design patterns to determine
} * information about the class. It crawls up the
return new ExplicitBeanInfo(b.getBeanDescriptor(),b.getAdditionalBeanInfo(), * inheritance tree until it hits <CODE>topClass</CODE>.
b.getPropertyDescriptors(),b.getDefaultPropertyIndex(), *
b.getEventSetDescriptors(),b.getDefaultEventIndex(), * @param beanClass the Bean class.
b.getMethodDescriptors(),icons); * @param stopClass the class to stop at.
* @return the BeanInfo object representing the class.
*/
public static BeanInfo getBeanInfo(Class beanClass, Class stopClass)
throws IntrospectionException
{
ExplicitInfo explicit = new ExplicitInfo(beanClass,stopClass);
IntrospectionIncubator ii = new IntrospectionIncubator();
ii.setPropertyStopClass(explicit.propertyStopClass);
ii.setEventStopClass(explicit.eventStopClass);
ii.setMethodStopClass(explicit.methodStopClass);
ii.addMethods(beanClass.getMethods());
BeanInfoEmbryo currentInfo = ii.getBeanInfoEmbryo();
PropertyDescriptor[] p = explicit.explicitPropertyDescriptors;
if(p!=null)
{
for(int i=0;i<p.length;i++)
{
if(!currentInfo.hasProperty(p[i]))
{
currentInfo.addProperty(p[i]);
}
}
if(explicit.defaultProperty != -1)
{
currentInfo.setDefaultPropertyName(p[explicit.defaultProperty].getName());
}
}
EventSetDescriptor[] e = explicit.explicitEventSetDescriptors;
if(e!=null)
{
for(int i=0;i<e.length;i++)
{
if(!currentInfo.hasEvent(e[i]))
{
currentInfo.addEvent(e[i]);
}
}
if(explicit.defaultEvent != -1)
{
currentInfo.setDefaultEventName(e[explicit.defaultEvent].getName());
}
}
MethodDescriptor[] m = explicit.explicitMethodDescriptors;
if(m!=null)
{
for(int i=0;i<m.length;i++)
{
if(!currentInfo.hasMethod(m[i]))
{
currentInfo.addMethod(m[i]);
}
}
}
if(explicit.explicitBeanDescriptor != null)
{
currentInfo.setBeanDescriptor(new BeanDescriptor(beanClass,explicit.explicitBeanDescriptor.getCustomizerClass()));
}
else
{
currentInfo.setBeanDescriptor(new BeanDescriptor(beanClass,null));
}
currentInfo.setAdditionalBeanInfo(explicit.explicitBeanInfo);
currentInfo.setIcons(explicit.im);
return currentInfo.getBeanInfo();
}
/**
* Get the search path for BeanInfo classes.
*
* @return the BeanInfo search path.
*/
public static String[] getBeanInfoSearchPath()
{
return beanInfoSearchPath;
}
/**
* Set the search path for BeanInfo classes.
* @param beanInfoSearchPath the new BeanInfo search
* path.
*/
public static void setBeanInfoSearchPath(String[] beanInfoSearchPath)
{
Introspector.beanInfoSearchPath = beanInfoSearchPath;
}
/**
* A helper method to convert a name to standard Java
* naming conventions: anything with two capitals as the
* first two letters remains the same, otherwise the
* first letter is decapitalized. URL = URL, I = i,
* MyMethod = myMethod.
*
* @param name the name to decapitalize.
* @return the decapitalized name.
*/
public static String decapitalize(String name)
{
try
{
if(!Character.isUpperCase(name.charAt(0)))
{
return name;
}
else
{
try
{
if(Character.isUpperCase(name.charAt(1)))
{
return name;
}
else
{
char[] c = name.toCharArray();
c[0] = Character.toLowerCase(c[0]);
return new String(c);
}
}
catch(StringIndexOutOfBoundsException E)
{
char[] c = new char[1];
c[0] = Character.toLowerCase(name.charAt(0));
return new String(c);
}
} }
}
catch(StringIndexOutOfBoundsException E)
{
return name;
}
catch(NullPointerException E)
{
return null;
}
}
static BeanInfo copyBeanInfo(BeanInfo b)
{
java.awt.Image[] icons = new java.awt.Image[4];
for(int i=1;i<=4;i++)
{
icons[i-1] = b.getIcon(i);
}
return new ExplicitBeanInfo(b.getBeanDescriptor(),
b.getAdditionalBeanInfo(),
b.getPropertyDescriptors(),
b.getDefaultPropertyIndex(),
b.getEventSetDescriptors(),
b.getDefaultEventIndex(),
b.getMethodDescriptors(),icons);
}
} }
class ExplicitInfo { class ExplicitInfo
BeanDescriptor explicitBeanDescriptor; {
BeanInfo[] explicitBeanInfo; BeanDescriptor explicitBeanDescriptor;
BeanInfo[] explicitBeanInfo;
PropertyDescriptor[] explicitPropertyDescriptors;
EventSetDescriptor[] explicitEventSetDescriptors; PropertyDescriptor[] explicitPropertyDescriptors;
MethodDescriptor[] explicitMethodDescriptors; EventSetDescriptor[] explicitEventSetDescriptors;
MethodDescriptor[] explicitMethodDescriptors;
int defaultProperty;
int defaultEvent; int defaultProperty;
int defaultEvent;
java.awt.Image[] im = new java.awt.Image[4];
java.awt.Image[] im = new java.awt.Image[4];
Class propertyStopClass;
Class eventStopClass; Class propertyStopClass;
Class methodStopClass; Class eventStopClass;
Class methodStopClass;
ExplicitInfo(Class beanClass, Class stopClass) {
while(beanClass != null && !beanClass.equals(stopClass)) { ExplicitInfo(Class beanClass, Class stopClass)
BeanInfo explicit = findExplicitBeanInfo(beanClass); {
if(explicit != null) { while(beanClass != null && !beanClass.equals(stopClass))
if(explicitBeanDescriptor == null) { {
explicitBeanDescriptor = explicit.getBeanDescriptor(); BeanInfo explicit = findExplicitBeanInfo(beanClass);
} if(explicit != null)
if(explicitBeanInfo == null) { {
explicitBeanInfo = explicit.getAdditionalBeanInfo(); if(explicitBeanDescriptor == null)
} {
if(explicitPropertyDescriptors == null) { explicitBeanDescriptor = explicit.getBeanDescriptor();
if(explicit.getPropertyDescriptors() != null) { }
explicitPropertyDescriptors = explicit.getPropertyDescriptors(); if(explicitBeanInfo == null)
defaultProperty = explicit.getDefaultPropertyIndex(); {
propertyStopClass = beanClass; explicitBeanInfo = explicit.getAdditionalBeanInfo();
} }
} if(explicitPropertyDescriptors == null)
if(explicitEventSetDescriptors == null) { {
if(explicit.getEventSetDescriptors() != null) { if(explicit.getPropertyDescriptors() != null)
explicitEventSetDescriptors = explicit.getEventSetDescriptors(); {
defaultEvent = explicit.getDefaultEventIndex(); explicitPropertyDescriptors = explicit.getPropertyDescriptors();
eventStopClass = beanClass; defaultProperty = explicit.getDefaultPropertyIndex();
} propertyStopClass = beanClass;
} }
if(explicitMethodDescriptors == null) { }
if(explicit.getMethodDescriptors() != null) { if(explicitEventSetDescriptors == null)
explicitMethodDescriptors = explicit.getMethodDescriptors(); {
methodStopClass = beanClass; if(explicit.getEventSetDescriptors() != null)
} {
} explicitEventSetDescriptors = explicit.getEventSetDescriptors();
if(im[0] == null defaultEvent = explicit.getDefaultEventIndex();
&& im[1] == null eventStopClass = beanClass;
&& im[2] == null }
&& im[3] == null) { }
im[0] = explicit.getIcon(0); if(explicitMethodDescriptors == null)
im[1] = explicit.getIcon(1); {
im[2] = explicit.getIcon(2); if(explicit.getMethodDescriptors() != null)
im[3] = explicit.getIcon(3); {
} explicitMethodDescriptors = explicit.getMethodDescriptors();
} methodStopClass = beanClass;
beanClass = beanClass.getSuperclass(); }
} }
if(propertyStopClass == null) { if(im[0] == null && im[1] == null
propertyStopClass = stopClass; && im[2] == null && im[3] == null)
} {
if(eventStopClass == null) { im[0] = explicit.getIcon(0);
eventStopClass = stopClass; im[1] = explicit.getIcon(1);
} im[2] = explicit.getIcon(2);
if(methodStopClass == null) { im[3] = explicit.getIcon(3);
methodStopClass = stopClass; }
} }
} beanClass = beanClass.getSuperclass();
}
static Hashtable explicitBeanInfos = new Hashtable(); if(propertyStopClass == null)
static Vector emptyBeanInfos = new Vector(); {
propertyStopClass = stopClass;
static BeanInfo findExplicitBeanInfo(Class beanClass) { }
BeanInfo retval = (BeanInfo)explicitBeanInfos.get(beanClass); if(eventStopClass == null)
if(retval != null) { {
return retval; eventStopClass = stopClass;
} else if(emptyBeanInfos.indexOf(beanClass) != -1) { }
return null; if(methodStopClass == null)
} else { {
retval = reallyFindExplicitBeanInfo(beanClass); methodStopClass = stopClass;
if(retval != null) { }
explicitBeanInfos.put(beanClass,retval); }
} else {
emptyBeanInfos.addElement(beanClass); static Hashtable explicitBeanInfos = new Hashtable();
} static Vector emptyBeanInfos = new Vector();
return retval;
} static BeanInfo findExplicitBeanInfo(Class beanClass)
{
BeanInfo retval = (BeanInfo)explicitBeanInfos.get(beanClass);
if(retval != null)
{
return retval;
}
else if(emptyBeanInfos.indexOf(beanClass) != -1)
{
return null;
}
else
{
retval = reallyFindExplicitBeanInfo(beanClass);
if(retval != null)
{
explicitBeanInfos.put(beanClass,retval);
}
else
{
emptyBeanInfos.addElement(beanClass);
}
return retval;
}
}
static BeanInfo reallyFindExplicitBeanInfo(Class beanClass)
{
try
{
try
{
return (BeanInfo)Class.forName(beanClass.getName()+"BeanInfo").newInstance();
}
catch(ClassNotFoundException E)
{
} }
String newName = ClassHelper.getTruncatedClassName(beanClass) + "BeanInfo";
static BeanInfo reallyFindExplicitBeanInfo(Class beanClass) { for(int i=0;i<Introspector.beanInfoSearchPath.length;i++)
try { {
try { try
return (BeanInfo)Class.forName(beanClass.getName()+"BeanInfo").newInstance(); {
} catch(ClassNotFoundException E) { if(Introspector.beanInfoSearchPath[i].equals(""))
} {
String newName = ClassHelper.getTruncatedClassName(beanClass) + "BeanInfo"; return (BeanInfo)Class.forName(newName).newInstance();
for(int i=0;i<Introspector.beanInfoSearchPath.length;i++) { }
try { else
if(Introspector.beanInfoSearchPath[i].equals("")) { {
return (BeanInfo)Class.forName(newName).newInstance(); return (BeanInfo)Class.forName(Introspector.beanInfoSearchPath[i] + "." + newName).newInstance();
} else {
return (BeanInfo)Class.forName(Introspector.beanInfoSearchPath[i] + "." + newName).newInstance();
}
} catch(ClassNotFoundException E) {
}
}
} catch(IllegalAccessException E) {
} catch(InstantiationException E) {
} }
return null; }
catch(ClassNotFoundException E)
{
}
} }
}
catch(IllegalAccessException E)
{
}
catch(InstantiationException E)
{
}
return null;
}
} }
libjava/java/beans/PropertyVetoException.java
/* java.beans.PropertyVetoException /* PropertyVetoException.java -- thrown to veto a proposed property change
Copyright (C) 1998, 2000 Free Software Foundation, Inc. Copyright (C) 1998, 2000, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath. This file is part of GNU Classpath.
...@@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify ...@@ -7,7 +7,7 @@ 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 it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option) the Free Software Foundation; either version 2, or (at your option)
any later version. any later version.
GNU Classpath is distributed in the hope that it will be useful, but GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
...@@ -39,30 +39,47 @@ exception statement from your version. */ ...@@ -39,30 +39,47 @@ exception statement from your version. */
package java.beans; package java.beans;
/** /**
** PropertyVetoException is thrown when a VetoableChangeListener doesn't like the proposed change. * PropertyVetoException is thrown when a VetoableChangeListener doesn't
** * like the proposed change.
** @author John Keiser *
** @since JDK1.1 * @author John Keiser
** @version 1.1.0, 31 May 1998 * @see VetoableChangeListener
** @see java.beans.VetoableChangeListener * @since 1.1
**/ * @status updated to 1.4
*/
public class PropertyVetoException extends Exception { public class PropertyVetoException extends Exception
PropertyChangeEvent evt; {
/**
* Compatible with JDK 1.1+.
*/
private static final long serialVersionUID = 129596057694162164L;
private static final long serialVersionUID = 129596057694162164L; /**
* The vetoed change.
*
* @serial the event that was vetoed
*/
private final PropertyChangeEvent evt;
/** Instantiate this exception with the given message and property change. /**
** @param msg the reason for the veto. * Instantiate this exception with the given message and property change.
** @param changeEvent the PropertyChangeEvent that was thrown. *
**/ * @param msg the reason for the veto
public PropertyVetoException(String msg, PropertyChangeEvent changeEvent) { * @param changeEvent the PropertyChangeEvent that was thrown
super(msg); */
evt = changeEvent; public PropertyVetoException(String msg, PropertyChangeEvent changeEvent)
} {
super(msg);
evt = changeEvent;
}
/** Get the PropertyChange event that was vetoed. **/ /**
public PropertyChangeEvent getPropertyChangeEvent() { * Get the PropertyChange event that was vetoed.
return evt; *
} * @return the vetoed change
*/
public PropertyChangeEvent getPropertyChangeEvent()
{
return evt;
}
} }
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment