public PropertyDescriptor[] getPropertyDescriptors() {
    try {
      PropertyDescriptor rootDirStr =
          new PropertyDescriptor("rootDirStr", getBeanDescriptor().getBeanClass());
      rootDirStr.setBound(true);
      rootDirStr.setPropertyEditorClass(JTextFieldEditor.class);
      rootDirStr.setDisplayName("<html><font color='green'>root dir:");
      rootDirStr.setShortDescription("The directory root to search for change sets. ");

      PropertyDescriptor validateChangeSets =
          new PropertyDescriptor("validateChangeSets", getBeanDescriptor().getBeanClass());
      validateChangeSets.setBound(true);
      validateChangeSets.setPropertyEditorClass(CheckboxEditor.class);
      validateChangeSets.setDisplayName("<html><font color='green'>validate:");
      validateChangeSets.setShortDescription("Select if you want to validate change sets. ");

      PropertyDescriptor validators =
          new PropertyDescriptor("validators", getBeanDescriptor().getBeanClass());
      validators.setBound(true);
      validators.setPropertyEditorClass(JTextFieldEditor.class);
      validators.setDisplayName("<html><font color='green'>validators:");
      validators.setShortDescription("The validators used on the change sets. ");

      PropertyDescriptor rv[] = {rootDirStr, validateChangeSets, validators};
      return rv;
    } catch (IntrospectionException e) {
      throw new Error(e.toString());
    }
  }
예제 #2
0
  static {
    try {
      EventSetDescriptor propertyChange =
          new EventSetDescriptor(
              BEAN_CLASS, "propertyChange", PropertyChangeListener.class, "propertyChange");
      propertyChange.setDisplayName(ResourceBundleLoader.getText("EVT_NAME_PROPERTY_CHANGE"));
      propertyChange.setShortDescription(ResourceBundleLoader.getText("EVT_DESC_PROPERTY_CHANGE"));

      eventSetDescriptors_ = new EventSetDescriptor[] {propertyChange};

      PropertyDescriptor path = new PropertyDescriptor("path", BEAN_CLASS);
      path.setBound(true);
      path.setConstrained(false);
      path.setDisplayName(ResourceBundleLoader.getText("PROP_NAME_PATH"));
      path.setShortDescription(ResourceBundleLoader.getText("PROP_DESC_PATH"));

      PropertyDescriptor system = new PropertyDescriptor("system", BEAN_CLASS);
      system.setBound(true);
      system.setConstrained(false);
      system.setDisplayName(ResourceBundleLoader.getText("PROP_NAME_SYSTEM"));
      system.setShortDescription(ResourceBundleLoader.getText("PROP_DESC_SYSTEM"));

      propertyDescriptors_ = new PropertyDescriptor[] {path, system};
    } catch (IntrospectionException e) {
      Trace.log(Trace.ERROR, "Unexpected IntrospectionException:", e);
      throw new InternalErrorException(InternalErrorException.UNEXPECTED_EXCEPTION);
    }
  }
  public PropertyDescriptor[] getPropertyDescriptors() {
    try {
      PropertyDescriptor radius = new PropertyDescriptor("radius", beanClass);
      radius.setBound(true);

      PropertyDescriptor original = new PropertyDescriptor("original", beanClass);
      PropertyDescriptor result = new PropertyDescriptor("result", beanClass);

      original.setBound(true);
      result.setBound(true);

      PropertyDescriptor[] propertyDescriptors = {radius, original, result};
      return propertyDescriptors;

    } catch (IntrospectionException e) {
      throw new Error(e.toString());
    }
  }
 /**
  * Gets the addressDataSelectionModel property descriptor.
  *
  * @return java.beans.PropertyDescriptor
  */
 public java.beans.PropertyDescriptor addressDataSelectionModelPropertyDescriptor() {
   java.beans.PropertyDescriptor aDescriptor = null;
   try {
     try {
       /* Using methods via getMethod is the faster way to create the addressDataSelectionModel property descriptor. */
       java.lang.reflect.Method aGetMethod = null;
       try {
         /* Attempt to find the method using getMethod with parameter types. */
         java.lang.Class aGetMethodParameterTypes[] = {};
         aGetMethod =
             getBeanClass().getMethod("getAddressDataSelectionModel", aGetMethodParameterTypes);
       } catch (java.lang.Throwable exception) {
         /* Since getMethod failed, call findMethod. */
         handleException(exception);
         aGetMethod = findMethod(getBeanClass(), "getAddressDataSelectionModel", 0);
       }
       ;
       java.lang.reflect.Method aSetMethod = null;
       try {
         /* Attempt to find the method using getMethod with parameter types. */
         java.lang.Class aSetMethodParameterTypes[] = {
           com.javadude.articles.vaddmvc2.AddressDataSelectionModel.class
         };
         aSetMethod =
             getBeanClass().getMethod("setAddressDataSelectionModel", aSetMethodParameterTypes);
       } catch (java.lang.Throwable exception) {
         /* Since getMethod failed, call findMethod. */
         handleException(exception);
         aSetMethod = findMethod(getBeanClass(), "setAddressDataSelectionModel", 1);
       }
       ;
       aDescriptor =
           new java.beans.PropertyDescriptor("addressDataSelectionModel", aGetMethod, aSetMethod);
     } catch (java.lang.Throwable exception) {
       /* Since we failed using methods, try creating a default property descriptor. */
       handleException(exception);
       aDescriptor =
           new java.beans.PropertyDescriptor("addressDataSelectionModel", getBeanClass());
     }
     ;
     aDescriptor.setBound(true);
     /* aDescriptor.setConstrained(false); */
     /* aDescriptor.setDisplayName("addressDataSelectionModel"); */
     /* aDescriptor.setShortDescription("addressDataSelectionModel"); */
     /* aDescriptor.setExpert(false); */
     /* aDescriptor.setHidden(false); */
     /* aDescriptor.setValue("preferred", new java.lang.Boolean(false)); */
     /* aDescriptor.setValue("ivjDesignTimeProperty", new java.lang.Boolean(true)); */
   } catch (java.lang.Throwable exception) {
     handleException(exception);
   }
   ;
   return aDescriptor;
 }
  public PropertyDescriptor[] getPropertyDescriptors() {
    try {
      PropertyDescriptor listName =
          new PropertyDescriptor("listName", TakeFirstItemInAttachmentList.class);
      listName.setBound(true);
      listName.setPropertyEditorClass(PropertyNameLabelEditor.class);
      listName.setDisplayName("<html><font color='green'>Name of temporary list:");
      listName.setShortDescription("Name of the temporary list.");

      PropertyDescriptor conceptKey =
          new PropertyDescriptor("conceptKey", TakeFirstItemInAttachmentList.class);
      conceptKey.setBound(true);
      conceptKey.setPropertyEditorClass(PropertyNameLabelEditor.class);
      conceptKey.setDisplayName("<html><font color='green'>Concept key:");
      conceptKey.setShortDescription("Concept key.");

      PropertyDescriptor rv[] = {listName, conceptKey};
      return rv;
    } catch (IntrospectionException e) {
      throw new Error(e.toString());
    }
  }
  public PropertyDescriptor[] getPropertyDescriptors() {
    try {
      PropertyDescriptor profilePropName =
          new PropertyDescriptor("profilePropName", getBeanDescriptor().getBeanClass());
      profilePropName.setBound(true);
      profilePropName.setPropertyEditorClass(PropertyNameLabelEditor.class);
      profilePropName.setDisplayName("<html><font color='green'>profile property:");
      profilePropName.setShortDescription("The property containing the profile to change.");

      PropertyDescriptor editPathEntry =
          new PropertyDescriptor("editPathEntry", getBeanDescriptor().getBeanClass());
      editPathEntry.setBound(true);
      editPathEntry.setPropertyEditorClass(ConceptLabelPropEditor.class);
      editPathEntry.setDisplayName("<html><font color='green'>editing path:");
      editPathEntry.setShortDescription("The property that contains the editing path.");

      PropertyDescriptor rv[] = {profilePropName, editPathEntry};
      return rv;
    } catch (IntrospectionException e) {
      throw new Error(e.toString());
    }
  }
  public PropertyDescriptor[] getPropertyDescriptors() {
    try {
      PropertyDescriptor queueType = new PropertyDescriptor("queueType", ToQueue.class);
      queueType.setBound(true);
      queueType.setPropertyEditorClass(ConceptLabelEditor.class);
      queueType.setDisplayName("Queue type:");
      queueType.setShortDescription("The type of queue to place this process into.");

      PropertyDescriptor rv[] = {queueType};
      return rv;
    } catch (IntrospectionException e) {
      throw new Error(e.toString());
    }
  }
  public PropertyDescriptor[] getPropertyDescriptors() {
    try {
      PropertyDescriptor profilePropName =
          new PropertyDescriptor("profilePropName", getBeanDescriptor().getBeanClass());
      profilePropName.setBound(true);
      profilePropName.setPropertyEditorClass(PropertyNameLabelEditor.class);
      profilePropName.setDisplayName("<html><font color='green'>profile prop:");
      profilePropName.setShortDescription("The property that contains the working profile.");

      PropertyDescriptor rv[] = {profilePropName};
      return rv;
    } catch (IntrospectionException e) {
      throw new Error(e.toString());
    }
  }
  public PropertyDescriptor[] getPropertyDescriptors() {
    try {
      PropertyDescriptor name = new PropertyDescriptor("name", beanClass),
          background = new PropertyDescriptor("background", beanClass),
          foreground = new PropertyDescriptor("foreground", beanClass),
          font = new PropertyDescriptor("font", beanClass),
          enabled = new PropertyDescriptor("enabled", beanClass),
          visible = new PropertyDescriptor("visible", beanClass),
          focusable = new PropertyDescriptor("focusable", beanClass);

      enabled.setExpert(true);
      visible.setHidden(true);

      background.setBound(true);
      foreground.setBound(true);
      font.setBound(true);
      focusable.setBound(true);

      PropertyDescriptor[] rv = {name, background, foreground, font, enabled, visible, focusable};
      return rv;
    } catch (IntrospectionException e) {
      throw new Error(e.toString());
    }
  }
  public PropertyDescriptor[] getPropertyDescriptors() {
    try {

      PropertyDescriptor inputPropName =
          new PropertyDescriptor("inputPropName", getBeanDescriptor().getBeanClass());
      inputPropName.setBound(true);
      inputPropName.setPropertyEditorClass(PropertyNameLabelEditor.class);
      inputPropName.setDisplayName("<html><font color='green'>input set property");
      inputPropName.setShortDescription("");

      PropertyDescriptor rv[] = {inputPropName};
      return rv;
    } catch (IntrospectionException e) {
      throw new Error(e.toString());
    }
  }
예제 #11
0
  /*
   * see java.beans.FeatureDescriptor#FeatureDescriptor(FeatureDescriptor)
   */
  public static void copyNonMethodProperties(PropertyDescriptor source, PropertyDescriptor target)
      throws IntrospectionException {

    target.setExpert(source.isExpert());
    target.setHidden(source.isHidden());
    target.setPreferred(source.isPreferred());
    target.setName(source.getName());
    target.setShortDescription(source.getShortDescription());
    target.setDisplayName(source.getDisplayName());

    // copy all attributes (emulating behavior of private FeatureDescriptor#addTable)
    Enumeration<String> keys = source.attributeNames();
    while (keys.hasMoreElements()) {
      String key = keys.nextElement();
      target.setValue(key, source.getValue(key));
    }

    // see java.beans.PropertyDescriptor#PropertyDescriptor(PropertyDescriptor)
    target.setPropertyEditorClass(source.getPropertyEditorClass());
    target.setBound(source.isBound());
    target.setConstrained(source.isConstrained());
  }
예제 #12
0
  static {
    try {
      PropertyDescriptor pd = null;
      sProperties = new ArrayList<PropertyDescriptor>(PhysicalObjectBeanInfo.getPropertyList());
      /*
      			pd = new PropertyDescriptor("boundingArea",baseClass);
      			pd.setBound(true);
      			sProperties.add(pd);

      */
      pd = new PropertyDescriptor("application", baseClass);
      pd.setBound(true);
      sProperties.add(pd);
      pd = new PropertyDescriptor("dip", baseClass);
      sProperties.add(pd);
      pd = new PropertyDescriptor("generatingB", baseClass);
      pd.setBound(true);
      sProperties.add(pd);
      pd = new PropertyDescriptor("globalField", baseClass);
      pd.setBound(true);
      sProperties.add(pd);
      pd = new PropertyDescriptor("numStripes", baseClass);
      pd.setBound(true);
      sProperties.add(pd);
      pd = new PropertyDescriptor("spreadAxis", baseClass);
      pd.setBound(true);
      sProperties.add(pd);
      pd = new PropertyDescriptor("strike", baseClass);
      pd.setBound(true);
      sProperties.add(pd);
      pd = new PropertyDescriptor("stripsDip", baseClass);
      pd.setBound(true);
      sProperties.add(pd);

      TDebug.println(baseClass.getName() + "BeanInfo: array complete");
    } catch (IntrospectionException ie) {
      TDebug.println(ie.getMessage());
    }
  }
예제 #13
0
  /**
   * Creates {@code PropertyDescriptor} from the specified property info.
   *
   * @param entry the pair of values, where the {@code key} is the base name of the property (the
   *     rest of the method name) and the {@code value} is the automatically generated property info
   * @param bound the flag indicating whether it is possible to treat this property as a bound
   *     property
   * @since 9
   */
  PropertyDescriptor(Entry<String, PropertyInfo> entry, boolean bound) {
    String base = entry.getKey();
    PropertyInfo info = entry.getValue();
    setName(Introspector.decapitalize(base));
    setReadMethod0(info.getReadMethod());
    setWriteMethod0(info.getWriteMethod());
    setPropertyType(info.getPropertyType());
    setConstrained(info.isConstrained());
    setBound(bound && info.is(PropertyInfo.Name.bound));

    boolean isExpert = info.is(PropertyInfo.Name.expert);
    setValue(PropertyInfo.Name.expert.name(), isExpert); // compatibility
    setExpert(isExpert);

    boolean isHidden = info.is(PropertyInfo.Name.hidden);
    setValue(PropertyInfo.Name.hidden.name(), isHidden); // compatibility
    setHidden(isHidden);

    setPreferred(info.is(PropertyInfo.Name.preferred));

    boolean isRequired = info.is(PropertyInfo.Name.required);
    setValue(PropertyInfo.Name.required.name(), isRequired);

    boolean visual = info.is(PropertyInfo.Name.visualUpdate);
    setValue(PropertyInfo.Name.visualUpdate.name(), visual);

    Object description = info.get(PropertyInfo.Name.description);
    if (description != null) {
      setShortDescription(description.toString());
    }
    Object values = info.get(PropertyInfo.Name.enumerationValues);
    if (values != null) {
      setValue(PropertyInfo.Name.enumerationValues.name(), values);
    }
    this.baseName = base;
  }
  // Static initializer.
  static {
    try {
      // Events.
      EventSetDescriptor event1 =
          new EventSetDescriptor(
              beanClass_, "propertyChange", PropertyChangeListener.class, "propertyChange");
      event1.setDisplayName(rbl_.getText("EVT_NAME_PROPERTY_CHANGE"));
      event1.setShortDescription(rbl_.getText("EVT_DESC_PROPERTY_CHANGE"));

      EventSetDescriptor event2 =
          new EventSetDescriptor(
              beanClass_, "actionCompleted", ActionCompletedListener.class, "actionCompleted");
      event2.setDisplayName(rbl_.getText("EVT_NAME_ACTION_COMPLETED"));
      event2.setShortDescription(rbl_.getText("EVT_DESC_ACTION_COMPLETED"));

      EventSetDescriptor event3 =
          new EventSetDescriptor(
              beanClass_, "propertyChange", VetoableChangeListener.class, "vetoableChange");
      event3.setDisplayName(rbl_.getText("EVT_NAME_PROPERTY_VETO"));
      event3.setShortDescription(rbl_.getText("EVT_DESC_PROPERTY_VETO"));

      events_ = new EventSetDescriptor[] {event1, event2, event3};

      // Properties.
      PropertyDescriptor classPath =
          new PropertyDescriptor("classPath", beanClass_, "getClassPath", "setClassPath");
      classPath.setBound(true);
      classPath.setConstrained(true);
      classPath.setDisplayName(rbl_.getText("PROP_NAME_JAC_CLASSPATH"));
      classPath.setShortDescription(rbl_.getText("PROP_DESC_JAC_CLASSPATH"));

      PropertyDescriptor classPathSecurityChkLvl =
          new PropertyDescriptor(
              "securityCheckLevel", beanClass_, "getSecurityCheckLevel", "setSecurityCheckLevel");
      classPathSecurityChkLvl.setBound(true);
      classPathSecurityChkLvl.setConstrained(true);
      classPathSecurityChkLvl.setDisplayName(rbl_.getText("PROP_NAME_JAC_SECCHKLVL"));
      classPathSecurityChkLvl.setShortDescription(rbl_.getText("PROP_DESC_JAC_SECCHKLVL"));

      PropertyDescriptor garbageCollectInitialSize =
          new PropertyDescriptor(
              "garbageCollectionInitialSize",
              beanClass_,
              "getGarbageCollectionInitialSize",
              "setGarbageCollectionInitialSize");
      garbageCollectInitialSize.setBound(true);
      garbageCollectInitialSize.setConstrained(true);
      garbageCollectInitialSize.setDisplayName(rbl_.getText("PROP_NAME_JAC_GCINIT"));
      garbageCollectInitialSize.setShortDescription(rbl_.getText("PROP_DESC_JAC_GCINIT"));

      PropertyDescriptor garbageCollectMaximumSize =
          new PropertyDescriptor(
              "garbageCollectionMaximumSize",
              beanClass_,
              "getGarbageCollectionMaximumSize",
              "setGarbageCollectionMaximumSize");
      garbageCollectMaximumSize.setBound(true);
      garbageCollectMaximumSize.setConstrained(true);
      garbageCollectMaximumSize.setDisplayName(rbl_.getText("PROP_NAME_JAC_GCMAX"));
      garbageCollectMaximumSize.setShortDescription(rbl_.getText("PROP_DESC_JAC_GCMAX"));

      PropertyDescriptor garbageCollectionFrequency =
          new PropertyDescriptor(
              "garbageCollectionFrequency",
              beanClass_,
              "getGarbageCollectionFrequency",
              "setGarbageCollectionFrequency");
      garbageCollectionFrequency.setBound(true);
      garbageCollectionFrequency.setConstrained(true);
      garbageCollectionFrequency.setDisplayName(rbl_.getText("PROP_NAME_JAC_GCFREQ"));
      garbageCollectionFrequency.setShortDescription(rbl_.getText("PROP_DESC_JAC_GCFREQ"));

      PropertyDescriptor garbageCollectionPriority =
          new PropertyDescriptor(
              "garbageCollectionPriority",
              beanClass_,
              "getGarbageCollectionPriority",
              "setGarbageCollectionPriority");
      garbageCollectionPriority.setBound(true);
      garbageCollectionPriority.setConstrained(true);
      garbageCollectionPriority.setDisplayName(rbl_.getText("PROP_NAME_JAC_GCPRIORITY"));
      garbageCollectionPriority.setShortDescription(rbl_.getText("PROP_DESC_JAC_GCPRIORITY"));

      PropertyDescriptor interpret =
          new PropertyDescriptor("interpret", beanClass_, "getInterpret", "setInterpret");
      interpret.setBound(true);
      interpret.setConstrained(true);
      interpret.setDisplayName(rbl_.getText("PROP_NAME_JAC_INTERPRET"));
      interpret.setShortDescription(rbl_.getText("PROP_DESC_JAC_INTERPRET"));

      PropertyDescriptor javaApplication =
          new PropertyDescriptor(
              "javaApplication", beanClass_, "getJavaApplication", "setJavaApplication");
      javaApplication.setBound(true);
      javaApplication.setConstrained(true);
      javaApplication.setDisplayName(rbl_.getText("PROP_NAME_JAC_JAVAAPP"));
      javaApplication.setShortDescription(rbl_.getText("PROP_DESC_JAC_JAVAAPP"));

      PropertyDescriptor optimization =
          new PropertyDescriptor("optimization", beanClass_, "getOptimization", "setOptimization");
      optimization.setBound(true);
      optimization.setConstrained(true);
      optimization.setDisplayName(rbl_.getText("PROP_NAME_JAC_OPTIMIZE"));
      optimization.setShortDescription(rbl_.getText("PROP_DESC_JAC_OPTIMIZE"));

      PropertyDescriptor option =
          new PropertyDescriptor("option", beanClass_, "getOptions", "setOptions");
      option.setBound(true);
      option.setConstrained(true);
      option.setDisplayName(rbl_.getText("PROP_NAME_JAC_OPTION"));
      option.setShortDescription(rbl_.getText("PROP_DESC_JAC_OPTION"));

      PropertyDescriptor parameters =
          new PropertyDescriptor("parameters", beanClass_, "getParameters", "setParameters");
      parameters.setBound(true);
      parameters.setConstrained(true);
      parameters.setDisplayName(rbl_.getText("PROP_NAME_JAC_PARAMETERS"));
      parameters.setShortDescription(rbl_.getText("PROP_DESC_JAC_PARAMETERS"));

      PropertyDescriptor portSearch =
          new PropertyDescriptor("findPort", beanClass_, "isFindPort", "setFindPort");
      portSearch.setBound(true);
      portSearch.setConstrained(true);
      portSearch.setDisplayName(rbl_.getText("PROP_NAME_JAC_PORTSEARCH"));
      portSearch.setShortDescription(rbl_.getText("PROP_DESC_JAC_PORTSEARCH"));

      properties_ =
          new PropertyDescriptor[] {
            classPath,
            classPathSecurityChkLvl,
            garbageCollectInitialSize,
            garbageCollectMaximumSize,
            garbageCollectionFrequency,
            garbageCollectionPriority,
            interpret,
            javaApplication,
            parameters,
            optimization,
            option,
            portSearch,
          };
    } catch (IntrospectionException e) {
      throw new Error(e.toString());
    }
  }
예제 #15
0
  static {
    try {
      EventSetDescriptor changed =
          new EventSetDescriptor(
              beanClass,
              "propertyChange",
              java.beans.PropertyChangeListener.class,
              "propertyChange");
      changed.setDisplayName(loader_.getText("EVT_NAME_PROPERTY_CHANGE"));
      changed.setShortDescription(loader_.getText("EVT_DESC_PROPERTY_CHANGE"));

      EventSetDescriptor veto =
          new EventSetDescriptor(
              beanClass,
              "propertyChange",
              java.beans.VetoableChangeListener.class,
              "vetoableChange");
      veto.setDisplayName(loader_.getText("EVT_NAME_PROPERTY_VETO"));
      veto.setShortDescription(loader_.getText("EVT_DESC_PROPERTY_VETO"));

      EventSetDescriptor[] events = {changed, veto};

      events_ = events;

      // ***** PROPERTIES
      PropertyDescriptor alignment =
          new PropertyDescriptor("alignment", beanClass, "getAlignment", "setAlignment");
      alignment.setBound(true);
      alignment.setConstrained(true);
      alignment.setDisplayName(loader_.getText("PROP_NAME_ALIGNMENT"));
      alignment.setShortDescription(loader_.getText("PROP_HTBL_DESC_ALIGNMENT"));

      PropertyDescriptor borderWidth =
          new PropertyDescriptor("borderWidth", beanClass, "getBorderWidth", "setBorderWidth");
      borderWidth.setBound(true);
      borderWidth.setConstrained(true);
      borderWidth.setDisplayName(loader_.getText("PROP_NAME_BORDERWIDTH"));
      borderWidth.setShortDescription(loader_.getText("PROP_DESC_BORDERWIDTH"));

      // PropertyDescriptor caption = new PropertyDescriptor("caption", beanClass,
      //                                "getCaption", "setCaption");
      Class[] parameterList = {HTMLTableCaption.class};
      PropertyDescriptor caption =
          new PropertyDescriptor(
              "caption",
              beanClass.getMethod("getCaption", (java.lang.Class[]) null),
              beanClass.getMethod("setCaption", parameterList)); // @pdc cast for jdk1.5

      caption.setBound(true);
      caption.setConstrained(true);
      caption.setDisplayName(loader_.getText("PROP_NAME_CAPTION"));
      caption.setShortDescription(loader_.getText("PROP_DESC_CAPTION"));

      PropertyDescriptor cellPadding =
          new PropertyDescriptor("cellPadding", beanClass, "getCellPadding", "setCellPadding");
      cellPadding.setBound(true);
      cellPadding.setConstrained(true);
      cellPadding.setDisplayName(loader_.getText("PROP_NAME_CELLPADDING"));
      cellPadding.setShortDescription(loader_.getText("PROP_DESC_CELLPADDING"));

      PropertyDescriptor cellSpacing =
          new PropertyDescriptor("cellSpacing", beanClass, "getCellSpacing", "setCellSpacing");
      cellSpacing.setBound(true);
      cellSpacing.setConstrained(true);
      cellSpacing.setDisplayName(loader_.getText("PROP_NAME_CELLSPACING"));
      cellSpacing.setShortDescription(loader_.getText("PROP_DESC_CELLSPACING"));

      PropertyDescriptor header =
          new PropertyDescriptor("header", beanClass, "getHeader", "setHeader");
      header.setBound(true);
      header.setConstrained(true);
      header.setDisplayName(loader_.getText("PROP_NAME_HEADER"));
      header.setShortDescription(loader_.getText("PROP_DESC_HEADER"));

      PropertyDescriptor useHeader =
          new PropertyDescriptor("headerInUse", beanClass, "isHeaderInUse", "setHeaderInUse");
      useHeader.setBound(true);
      useHeader.setConstrained(true);
      useHeader.setDisplayName(loader_.getText("PROP_NAME_HEADERINUSE"));
      useHeader.setShortDescription(loader_.getText("PROP_DESC_HEADERINUSE"));

      PropertyDescriptor width = new PropertyDescriptor("width", beanClass, "getWidth", "setWidth");
      width.setBound(true);
      width.setConstrained(true);
      width.setDisplayName(loader_.getText("PROP_NAME_WIDTH"));
      width.setShortDescription(loader_.getText("PROP_HTBL_DESC_WIDTH"));

      PropertyDescriptor widthInPercent =
          new PropertyDescriptor(
              "widthInPercent", beanClass, "isWidthInPercent", "setWidthInPercent");
      widthInPercent.setBound(true);
      widthInPercent.setConstrained(true);
      widthInPercent.setDisplayName(loader_.getText("PROP_NAME_WPERCENT"));
      widthInPercent.setShortDescription(loader_.getText("PROP_HTBL_DESC_WPERCENT"));

      PropertyDescriptor lang =
          new PropertyDescriptor("lang", beanClass, "getLanguage", "setLanguage"); // $B1A
      lang.setBound(true); // $B1A
      lang.setConstrained(true); // $B1A
      lang.setDisplayName(loader_.getText("PROP_NAME_LANGUAGE")); // $B1A
      lang.setShortDescription(loader_.getText("PROP_DESC_LANGUAGE")); // $B1A

      PropertyDescriptor dir =
          new PropertyDescriptor("dir", beanClass, "getDirection", "setDirection"); // $B1A
      dir.setBound(true); // $B1A
      dir.setConstrained(true); // $B1A
      dir.setDisplayName(loader_.getText("PROP_NAME_DIRECTION")); // $B1A
      dir.setShortDescription(loader_.getText("PROP_DESC_DIRECTION")); // $B1A

      PropertyDescriptor useFO =
          new PropertyDescriptor("useFO", beanClass, "isUseFO", "setUseFO"); // @C1A
      useFO.setBound(true); // @C1A
      useFO.setConstrained(false); // @C1A
      useFO.setDisplayName(loader_.getText("PROP_NAME_FORMATTING_OBJECT")); // @C1A
      useFO.setShortDescription(loader_.getText("PROP_DESC_FORMATTING_OBJECT")); // @C1A

      properties_ =
          new PropertyDescriptor[] {
            alignment,
            borderWidth,
            caption,
            cellPadding,
            cellSpacing,
            header,
            useHeader,
            width,
            widthInPercent,
            lang,
            dir,
            useFO
          }; // $B1C     //@C1A
    } catch (Exception e) {
      throw new Error(e.toString());
    }
  }