StandardBeanInfo(Class<?> beanClass,
    BeanInfo explicitBeanInfo,
    Class<?> stopClass) throws IntrospectionException 
{
        this.beanClass = beanClass;
        /*--------------------------------------------------------------------------------------
         * There are 3 aspects of BeanInfo that must be supplied:
         * a) PropertyDescriptors
         * b) MethodDescriptors
         * c) EventSetDescriptors
         * Each of these may be optionally provided in the explicitBeanInfo object relating to
         * this bean.  Where the explicitBeanInfo provides one of these aspects, it is used
         * without question and no introspection of the beanClass is performed for that aspect.
         * There are also 3 optional items of BeanInfo that may be provided by the 
         * explicitBeanInfo object:
         * 1) BeanDescriptor
         * 2) DefaultEventIndex
         * 3) DefaultPropertyIndex
         * These aspects of the beanClass cannot be derived through introspection of the class.
         * If they are not provided by the explicitBeanInfo, then they must be left null in the 
         * returned BeanInfo, otherwise they will be copied from the explicitBeanInfo 
         --------------------------------------------------------------------------------------*/
        if (explicitBeanInfo != null) {
            this.explicitBeanInfo = explicitBeanInfo;
            events = explicitBeanInfo.getEventSetDescriptors();
            methods = explicitBeanInfo.getMethodDescriptors();
            properties = explicitBeanInfo.getPropertyDescriptors();
            defaultEventIndex = explicitBeanInfo.getDefaultEventIndex();
            if (defaultEventIndex <  0 || defaultEventIndex  >= events.length) {
                defaultEventIndex = -1;
            }
            defaultPropertyIndex = explicitBeanInfo.getDefaultPropertyIndex();
            if (defaultPropertyIndex <  0
                    || defaultPropertyIndex  >= properties.length) {
                defaultPropertyIndex = -1;
            }
            additionalBeanInfo = explicitBeanInfo.getAdditionalBeanInfo();
            for (int i = 0; i <  4; i++) {
                icon[i] = explicitBeanInfo.getIcon(i + 1);
            }
            if (events != null)
                explicitEvents = true;
            if (methods != null)
                explicitMethods = true;
            if (properties != null)
                explicitProperties = true;
        }
        if (methods == null) {
            methods = introspectMethods();
        }
        if (properties == null) {
            properties = introspectProperties(stopClass);
        }
        if (events == null) {
            events = introspectEvents();
        }
}

 public BeanInfo[] getAdditionalBeanInfo() 
{
        return null;
}

 public BeanDescriptor getBeanDescriptor() 
{
        if (explicitBeanInfo != null) {
            BeanDescriptor beanDesc = explicitBeanInfo.getBeanDescriptor();
            if (beanDesc != null) {
                return beanDesc;
            }
        }
        return new BeanDescriptor(beanClass);
}

 public int getDefaultEventIndex() 
{
        return this.defaultEventIndex;
}

 public int getDefaultPropertyIndex() 
{
        return this.defaultPropertyIndex;
}

 public EventSetDescriptor[] getEventSetDescriptors() 
{
        return events;
}

 public Image getIcon(int iconKind) 
{
        return (Image)icon[iconKind - 1];
}

 public MethodDescriptor[] getMethodDescriptors() 
{
        return methods;
}

 public PropertyDescriptor[] getPropertyDescriptors() 
{
        return properties;
}

  void init() 
{
        if (this.events == null) {
            events = new EventSetDescriptor[0];
        }
        if (this.properties == null) {
            this.properties = new PropertyDescriptor[0];
        }
        if (properties != null) {
            String defaultPropertyName = (defaultPropertyIndex != -1 ? properties[defaultPropertyIndex]
                    .getName()
                    : null);
            Arrays.sort(properties, comparator);
            if (null != defaultPropertyName) {
                for (int i = 0; i <  properties.length; i++) {
                    if (defaultPropertyName.equals(properties[i].getName())) {
                        defaultPropertyIndex = i;
                        break;
                    }
                }
            }
        }
}

  void mergeBeanInfo(BeanInfo beanInfo,
    boolean force) throws IntrospectionException 
{
        if (force || !explicitProperties) {
            PropertyDescriptor[] superDescs = beanInfo.getPropertyDescriptors();
            if (superDescs != null) {
                if (getPropertyDescriptors() != null) {
                    properties = mergeProps(superDescs, beanInfo
                            .getDefaultPropertyIndex());
                } else {
                    properties = superDescs;
                    defaultPropertyIndex = beanInfo.getDefaultPropertyIndex();
                }
            }
        }
        if (force || !explicitMethods) {
            MethodDescriptor[] superMethods = beanInfo.getMethodDescriptors();
            if (superMethods != null) {
                if (methods != null) {
                    methods = mergeMethods(superMethods);
                } else {
                    methods = superMethods;
                }
            }
        }
        if (force || !explicitEvents) {
            EventSetDescriptor[] superEvents = beanInfo
                    .getEventSetDescriptors();
            if (superEvents != null) {
                if (events != null) {
                    events = mergeEvents(superEvents, beanInfo
                            .getDefaultEventIndex());
                } else {
                    events = superEvents;
                    defaultEventIndex = beanInfo.getDefaultEventIndex();
                }
            }
        }
}