package nl.tudelft.dsol.introspection.beans;
   
   import java.awt.Image;
   import java.beans.EventSetDescriptor;
   import java.beans.IntrospectionException;
   import java.beans.MethodDescriptor;
   import java.beans.PropertyDescriptor;
   import java.beans.SimpleBeanInfo;
   
  /***
   * <p>
   * (c) copyright 2002-2005-2004 <a href="http://www.simulation.tudelft.nl">Delft
   * University of Technology </a>, the Netherlands. <br>
   * See for project information <a
   * href="http://www.simulation.tudelft.nl">www.simulation.tudelft.nl </a> <br>
   * License of use: <a href="http://www.gnu.org/copyleft/lesser.html">Lesser
   * General Public License (LGPL) </a>, no warranty.
   * 
   * @author <a
   *         href="http://web.eur.nl/fbk/dep/dep1/Introduction/Staff/People/Lang">Niels
   *         Lang </a><a href="http://www.peter-jacobs.com/index.htm">Peter
   *         Jacobs </a>
   * @version 1.1 Apr 15, 2004
   * @since 1.5
   */
  public class SubTestBean2BeanInfo extends SimpleBeanInfo
  {
  
      /*** Property identifiers //GEN-FIRST:Properties */
      private static final int PROPERTY_testProp1 = 0;
  
      /*** Property array */
      private static PropertyDescriptor[] properties = new PropertyDescriptor[1];
  
      static
      {
          try
          {
              properties[PROPERTY_testProp1] = new PropertyDescriptor(
                      "testProp1", SubTestBean2.class, "getTestProp1",
                      "setTestProp1");
          } catch (IntrospectionException e)
          {
              e.printStackTrace();
          }
  
          // Here you can add code for customizing the properties array.
      }
  
      // EventSet identifiers//GEN-FIRST:Events
  
      /*** EventSet array */
      private static EventSetDescriptor[] eventSets = new EventSetDescriptor[0];
  
      // GEN-HEADEREND:Events
  
      // Here you can add code for customizing the event sets array.
  
      // GEN-LAST:Events
  
      // Method identifiers //GEN-FIRST:Methods
  
      /*** Method array */
      private static MethodDescriptor[] methods = new MethodDescriptor[0];
  
      // GEN-HEADEREND:Methods
  
      // Here you can add code for customizing the methods array.
  
      // GEN-LAST:Methods
  
      /*** iconColor */
      private static Image iconColor16 = null; // GEN-BEGIN:IconsDef
  
      /*** iconColor */
      private static Image iconColor32 = null;
  
      /*** iconColor */
      private static Image iconMono16 = null;
  
      /*** iconColor */
      private static Image iconMono32 = null; // GEN-END:IconsDef
  
      /*** iconName */
      private static String iconNameC16 = null;
  
      /*** iconName */
      private static String iconNameC32 = null;
  
      /*** iconName */
      private static String iconNameM16 = null;
  
      /*** iconName */
      private static String iconNameM32 = null;
  
      /*** iconName */
      private static int defaultPropertyIndex = -1;
  
      /***
      * Gets the bean's <code>PropertyDescriptor</code>s.
      * 
      * @return An array of PropertyDescriptors describing the editable
      *         properties supported by this bean. May return null if the
      *         information should be obtained by automatic analysis.
      *         <p>
      *         If a property is indexed, then its entry in the result array will
      *         belong to the IndexedPropertyDescriptor subclass of
      *         PropertyDescriptor. A client of getPropertyDescriptors can use
      *         "instanceof" to check if a given PropertyDescriptor is an
      *         IndexedPropertyDescriptor.
      */
     @Override
     public PropertyDescriptor[] getPropertyDescriptors()
     {
         return properties;
     }
 
     /***
      * Gets the bean's <code>EventSetDescriptor</code>s.
      * 
      * @return An array of EventSetDescriptors describing the kinds of events
      *         fired by this bean. May return null if the information should be
      *         obtained by automatic analysis.
      */
     @Override
     public EventSetDescriptor[] getEventSetDescriptors()
     {
         return eventSets;
     }
 
     /***
      * Gets the bean's <code>MethodDescriptor</code>s.
      * 
      * @return An array of MethodDescriptors describing the methods implemented
      *         by this bean. May return null if the information should be
      *         obtained by automatic analysis.
      */
     @Override
     public MethodDescriptor[] getMethodDescriptors()
     {
         return methods;
     }
 
     /***
      * A bean may have a "default" property that is the property that will
      * mostly commonly be initially chosen for update by human's who are
      * customizing the bean.
      * 
      * @return Index of default property in the PropertyDescriptor array
      *         returned by getPropertyDescriptors.
      *         <P>
      *         Returns -1 if there is no default property.
      */
     @Override
     public int getDefaultPropertyIndex()
     {
         return defaultPropertyIndex;
     }
 
     /***
      * A bean may have a "default" event that is the event that will mostly
      * commonly be used by human's when using the bean.
      * 
      * @return Index of default event in the EventSetDescriptor array returned
      *         by getEventSetDescriptors.
      *         <P>
      *         Returns -1 if there is no default event.
      */
     @Override
     public int getDefaultEventIndex()
     {
         return defaultPropertyIndex;
     }
 
     /***
      * This method returns an image object that can be used to represent the
      * bean in toolboxes, toolbars, etc. Icon images will typically be GIFs, but
      * may in future include other formats.
      * <p>
      * Beans aren't required to provide icons and may return null from this
      * method.
      * <p>
      * There are four possible flavors of icons (16x16 color, 32x32 color, 16x16
      * mono, 32x32 mono). If a bean choses to only support a single icon we
      * recommend supporting 16x16 color.
      * <p>
      * We recommend that icons have a "transparent" background so they can be
      * rendered onto an existing background.
      * 
      * @param iconKind The kind of icon requested. This should be one of the
      *        constant values ICON_COLOR_16x16, ICON_COLOR_32x32,
      *        ICON_MONO_16x16, or ICON_MONO_32x32.
      * @return An image object representing the requested icon. May return null
      *         if no suitable icon is available.
      */
     @Override
     public Image getIcon(final int iconKind)
     {
         switch (iconKind)
         {
             case ICON_COLOR_16x16:
                 if (iconNameC16 == null)
                 {
                     return null;
                 }
 
                 if (iconColor16 == null)
                 {
                     iconColor16 = loadImage(iconNameC16);
                 }
                 return iconColor16;
 
             case ICON_COLOR_32x32:
                 if (iconNameC32 == null)
                 {
                     return null;
                 }
 
                 if (iconColor32 == null)
                 {
                     iconColor32 = loadImage(iconNameC32);
                 }
                 return iconColor32;
 
             case ICON_MONO_16x16:
                 if (iconNameM16 == null)
                 {
                     return null;
                 }
 
                 if (iconMono16 == null)
                 {
                     iconMono16 = loadImage(iconNameM16);
                 }
                 return iconMono16;
 
             case ICON_MONO_32x32:
                 if (iconNameM32 == null)
                 {
                     return null;
                 }
 
                 if (iconNameM32 == null)
                 {
                     iconMono32 = loadImage(iconNameM32);
                 }
                 return iconMono32;
             default:
                 return null;
         }
     }
 
 }