";
+
+ try {
+ File file = new File(templateFilename);
+ DataInputStream stream = new DataInputStream(new FileInputStream(file));
+ BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
+ StringBuffer buffer = new StringBuffer();
+
+ int c;
+ while((c = reader.read()) != -1) {
+ buffer.append((char)c);
+ }
+
+ template = buffer.toString();
+ reader.close();
+ } catch (IOException e) {
+ System.out.println(e.getMessage());
+ messageAndExit("GenSwingBeanInfo: Couldn't load template: " + templateFilename + e);
+ }
+ return template;
+ }
+
+
+ /**
+ * Generates a string for the BeanDescriptor
+ */
+ private String genBeanDescriptor(DocBeanInfo dbi) {
+ String code = "";
+ int beanflags = dbi.beanflags;
+
+ // we support export, hidden, preferred
+ if ((beanflags & DocBeanInfo.EXPERT) != 0)
+ code += " sun.swing.BeanInfoUtils.EXPERT, Boolean.TRUE,\n";
+ if ((beanflags & DocBeanInfo.HIDDEN) !=0)
+ code += " sun.swing.BeanInfoUtils.HIDDEN, Boolean.TRUE,\n";
+ /* 1.2 only - make sure build flag build using 1.2 */
+ if ((beanflags & DocBeanInfo.PREFERRED) !=0)
+ code += " sun.swing.BeanInfoUtils.PREFERRED, Boolean.TRUE,\n";
+ if (!(dbi.customizerclass.equals("null")))
+ code += " sun.swing.BeanInfoUtils.CUSTOMIZERCLASS, " + dbi.customizerclass + ".class,\n";
+
+ if (dbi.attribs != null) {
+ code += genAttributes(dbi.attribs);
+ }
+
+ return code;
+ }
+
+ /**
+ * Generates the code for the attributes table.
+ */
+ private String genAttributes(HashMap attribs) {
+ StringBuffer code = new StringBuffer();
+ String key;
+ String value;
+
+ Iterator iterator = attribs.keySet().iterator();
+ while(iterator.hasNext()) {
+ key = (String)iterator.next();
+ value = (String)attribs.get(key);
+
+ if (value.equals("true") || value.equals("false")) {
+ // Substitute the "true" and "false" for codegen Boolean values.
+ if(value.equals("true"))
+ value = "Boolean.TRUE";
+ else
+ value = "Boolean.FALSE";
+
+ code.append(" \"").append(key).append("\", ").append(value).append(",\n");
+ } else {
+ code.append(" \"").append(key).append("\", \"").append(value).append("\",\n");
+ }
+ }
+ return code.toString();
+ }
+
+ /**
+ * Generates the code for the enumeration.
+ * XXX - side effect: Modifies the enumcode field variable.
+ */
+ private String genEnumeration(String propName, HashMap enums) {
+ String objectName = propName + "Enumeration";
+ String key;
+ String value;
+
+ StringBuffer code = new StringBuffer("\n\t\tObject[] ");
+ code.append(objectName).append(" = new Object[] { \n");
+
+ Iterator iterator = enums.keySet().iterator();
+ while(iterator.hasNext()) {
+ key = (String)iterator.next();
+ value = (String)enums.get(key);
+
+ code.append("\t\t\t\"").append(key).append("\" , new Integer(");
+ code.append(value).append("), \"").append(value).append("\",\n");
+ }
+ // Close the statically initialized Object[]
+ code.replace(code.length() - 2, code.length(), "\n\t\t};\n");
+
+ // Add this string to the enumeration code.
+ enumcode += code.toString();
+
+ // Return the PropertyDescriptor init string;
+ return " \"enumerationValues\", " + objectName + ",\n";
+ }
+
+ /**
+ * Generate the createPropertyDescriptor() calls, one per property.
+ * A fully specified createPropertyDescriptor() call looks like this:
+ *
+ * createPropertyDescriptor("contentPane", new Object[] {
+ * BOUND, Boolean.TRUE,
+ * CONSTRAINED, Boolean.TRUE,
+ * PROPERTYEDITORCLASS, package.MyEditor.cl
+ * WRITEMETHOD, "setContentPane",
+ * DISPLAYNAME, "contentPane",
+ * EXPERT, Boolean.FALSE,
+ * HIDDEN, Boolean.FALSE,
+ * PREFERRED, Boolean.TRUE,
+ * SHORTDESCRIPTION, "A top level window with a window manager border",
+ * "random attribute","random value"
+ * }
+ * );
+ *
+ *
+ * @param info The actual BeanInfo class generated from from the Intospector.
+ * @param dochash Set of DocBeanInfo pairs for each property. This information
+ * is used to suplement the instrospected properties.
+ * @return A snippet of source code which would construct all the PropertyDescriptors.
+ */
+ private String genPropertyDescriptors(BeanInfo info, Hashtable dochash) {
+ String code = "";
+ enumcode = " "; // code for enumerated properties.
+ PropertyDescriptor[] pds = info.getPropertyDescriptors();
+ boolean hash_match = false;
+ DocBeanInfo dbi = null;
+
+ for(int i = 0; i < pds.length; i++) {
+ if (pds[i].getReadMethod() != null) {
+ code += "\ncreatePropertyDescriptor(\"" + pds[i].getName() + "\", new Object[] {\n";
+
+ if (DEBUG)
+ System.out.println("Introspected propertyDescriptor: " + pds[i].getName());
+
+ if (dochash.size() > 0 && dochash.containsKey(pds[i].getName())) {
+ dbi = (DocBeanInfo)dochash.remove(pds[i].getName());
+ // override/set properties on this *introspected*
+ // BeanInfo pds using our DocBeanInfo class values
+ setDocInfoProps(dbi, pds[i]);
+ hash_match = true;
+ if (DEBUG)
+ System.out.println("DocBeanInfo class exists for propertyDescriptor: " + pds[i].getName() + "\n");
+ } else {
+ hash_match = false;
+ }
+
+ // Do I need to do anything with this property descriptor
+ if (hash_match) {
+ if ((dbi.beanflags & DocBeanInfo.BOUND) != 0) {
+ code += " sun.swing.BeanInfoUtils.BOUND, Boolean.TRUE,\n";
+ } else {
+ code += " sun.swing.BeanInfoUtils.BOUND, Boolean.FALSE,\n";
+ }
+ }
+
+ if (pds[i].isConstrained()) {
+ code += " sun.swing.BeanInfoUtils.CONSTRAINED, Boolean.TRUE,\n";
+ }
+
+ if (pds[i].getPropertyEditorClass() != null) {
+ String className = pds[i].getPropertyEditorClass().getName();
+ code += " sun.swing.BeanInfoUtils.PROPERTYEDITORCLASS, " + className + ".class,\n";
+ } else if ((hash_match) && (!(dbi.propertyeditorclass.equals("null")))) {
+ code += " sun.swing.BeanInfoUtils.PROPERTYEDITORCLASS, " + dbi.propertyeditorclass + ".class,\n";
+ }
+
+ if ((hash_match) && (!(dbi.customizerclass.equals("null")))) {
+ code += " sun.swing.BeanInfoUtils.CUSTOMIZERCLASS, " + dbi.customizerclass + ".class,\n";
+ }
+
+ if ((hash_match) && (dbi.enums != null)) {
+ code += genEnumeration(pds[i].getName(), dbi.enums);
+ }
+
+ if (!pds[i].getDisplayName().equals(pds[i].getName())) {
+ code += " sun.swing.BeanInfoUtils.DISPLAYNAME, \"" + pds[i].getDisplayName() + "\",\n";
+ }
+
+ if (pds[i].isExpert()) {
+ code += " sun.swing.BeanInfoUtils.EXPERT, Boolean.TRUE,\n";
+ }
+
+ if (pds[i].isHidden()) {
+ code += " sun.swing.BeanInfoUtils.HIDDEN, Boolean.TRUE,\n";
+ }
+
+ if (pds[i].isPreferred()) {
+ code += " sun.swing.BeanInfoUtils.PREFERRED, Boolean.TRUE,\n";
+ }
+
+ // user attributes
+ if (hash_match) {
+ if (dbi.attribs != null) {
+ code += genAttributes(dbi.attribs);
+ }
+ }
+ code += " sun.swing.BeanInfoUtils.SHORTDESCRIPTION, \"" + pds[i].getShortDescription() + "\",\n";
+
+ // Print the closing brackets. If this is the last array initializer,
+ // don't print the trailing comma.
+ if (i == (pds.length - 1)) {
+ code += " }\n)\n";
+ } else {
+ code += " }\n),\n";
+ }
+
+ } // end if ( readMethod != null )
+ } // end for
+ return code;
+ }
+
+ /**
+ * Sets properties from the BeanInfo supplement on the
+ * introspected PropertyDescriptor
+ */
+ private void setDocInfoProps(DocBeanInfo dbi, PropertyDescriptor pds) {
+ int beanflags = dbi.beanflags;
+
+ if ((beanflags & DocBeanInfo.BOUND) != 0)
+ pds.setBound(true);
+ if ((beanflags & DocBeanInfo.EXPERT) != 0)
+ pds.setExpert(true);
+ if ((beanflags & DocBeanInfo.CONSTRAINED) != 0)
+ pds.setConstrained(true);
+ if ((beanflags & DocBeanInfo.HIDDEN) !=0)
+ pds.setHidden(true);
+ if ((beanflags & DocBeanInfo.PREFERRED) !=0)
+ pds.setPreferred(true);
+
+ if (!(dbi.desc.equals("null"))){
+ pds.setShortDescription(dbi.desc);
+ }
+ if (!(dbi.displayname.equals("null"))){
+ pds.setDisplayName(dbi.displayname);
+ }
+ }
+
+ /**
+ * Generates the BeanInfo source file using instrospection and a
+ * Hashtable full of hints. This the only public method in this class.
+ *
+ * @param classname Root name of the class. i.e., JButton
+ * @param dochash A hashtable containing the DocBeanInfo.
+ */
+ public void genBeanInfo(String packageName, String classname, Hashtable dochash) {
+ // The following initial values are just examples. All of these
+ // fields are initialized below.
+ String beanClassName = "JInternalFrame";
+ String beanClassObject = "javax.swing.JInternalFrame.class";
+ String beanDescription = ".";
+ String beanPropertyDescriptors = "";
+ String classPropertyDescriptors = "";
+
+ Class cls = getClass(packageName, classname);
+ if (cls == null){
+ messageAndExit("Can't find class: " + classname);
+ }
+
+ // Get the output stream.
+ PrintStream out = initOutputFile(classname);
+
+ // Run the Introspector and initialize the variables
+
+ BeanInfo beanInfo = null;
+ BeanDescriptor beanDescriptor = null;
+
+ try {
+ if (cls == javax.swing.JComponent.class) {
+ // Go all the way up the heirarchy for JComponent
+ beanInfo = Introspector.getBeanInfo(cls);
+ } else {
+ beanInfo = Introspector.getBeanInfo(cls, cls.getSuperclass());
+ }
+ beanDescriptor = beanInfo.getBeanDescriptor();
+ beanDescription = beanDescriptor.getShortDescription();
+ } catch (IntrospectionException e) {
+ messageAndExit("Introspection failed for " + cls.getName() + " " + e);
+ }
+
+ beanClassName = beanDescriptor.getName();
+ beanClassObject = cls.getName() + ".class";
+
+ if (DEBUG){
+ System.out.println(">>>>GenSwingBeanInfo class: " + beanClassName);
+ }
+ // Generate the Class BeanDescriptor information first
+ if (dochash.size() > 0) {
+ if (dochash.containsKey(beanClassName)) {
+ DocBeanInfo dbi = (DocBeanInfo)dochash.remove(beanClassName);
+ classPropertyDescriptors = genBeanDescriptor(dbi);
+ if (DEBUG)
+ System.out.println("ClassPropertyDescriptors: " + classPropertyDescriptors);
+ if (!(dbi.desc.equals("null")))
+ beanDescription = dbi.desc;
+ } else
+ beanDescription = beanDescriptor.getShortDescription();
+ } else
+ beanDescription = beanDescriptor.getShortDescription();
+
+ // Generate the Property descriptors
+ beanPropertyDescriptors = genPropertyDescriptors(beanInfo,dochash);
+
+ // Dump the template to out, substituting values for
+ // @(token) tokens as they're encountered.
+
+ int currentIndex = 0;
+ // not loading this to get around build issue for now
+ String template = loadTemplate();
+
+ // This loop substitutes the "@(...)" tags in the template with the ones for the
+ // current class.
+ while (currentIndex < template.length()) {
+ // Find the Token
+ int tokenStart = template.indexOf("@(", currentIndex);
+ if (tokenStart != -1) {
+ out.print(template.substring(currentIndex, tokenStart));
+
+ int tokenEnd = template.indexOf(")", tokenStart);
+ if (tokenEnd == -1) {
+ messageAndExit("Bad @() beginning at " + tokenStart);
+ }
+ String token = template.substring(tokenStart+2, tokenEnd);
+
+ if (token.equals(TOK_BEANCLASS)) {
+ out.print(beanClassName);
+ } else if (token.equals(TOK_CLASSDESC)) {
+ if (!(classPropertyDescriptors.equals(""))) {
+ printDescriptors(out, classPropertyDescriptors, template, tokenStart);
+ }
+ } else if (token.equals(TOK_BEANPACKAGE)){
+ out.print(packageName);
+ } else if (token.equals(TOK_BEANOBJECT)) {
+ out.print(beanClassObject);
+ } else if (token.equals(TOK_BEANDESC)) {
+ out.print(beanDescription);
+ } else if (token.equals(TOK_ENUMVARS)){
+ out.print(enumcode);
+ } else if (token.equals(TOK_PROPDESC)) {
+ printDescriptors(out, beanPropertyDescriptors, template, tokenStart);
+ } else if (token.equals("#")) {
+ // Ignore the @(#) Version Control tag if it exists.
+ } else {
+ messageAndExit("Unrecognized token @(" + token + ")");
+ }
+ currentIndex = tokenEnd + 1;
+ } else {
+ // tokenStart == -1 - We are finsihed.
+ out.print(template.substring(currentIndex, template.length()));
+ break;
+ }
+ }
+ out.close();
+ }
+
+ /**
+ * Returns the class from the package name and the class root name.
+ *
+ * @param packageName The name of the package of the containing class.
+ * @param rootname The root name of the class. i.e, JButton
+ * @return The class instance or null.
+ */
+ private Class getClass(String packageName, String rootname) {
+ Class cls = null;
+ String classname = rootname;
+
+ if (packageName != null || !packageName.equals("")) {
+ classname = packageName + "." + rootname;
+ }
+
+ try {
+ cls = Class.forName(classname);
+ } catch (ClassNotFoundException e) {
+ // Fail silently.
+ }
+ return cls;
+ }
+
+ /**
+ * Prints the formated descriptors to the PrintStream
+ * @param out Open PrintStream
+ * @param s String descriptor
+ * @param template Template
+ * @param tokenStart Index into the template
+ */
+ private void printDescriptors(PrintStream out, String s,
+ String template, int tokenStart) {
+ String indent = "";
+
+ // Find the newline that preceeds @(BeanPropertyDescriptors) to
+ // calculate the indent.
+ for (int i = tokenStart; i >= 0; i--) {
+ if (template.charAt(i) == '\n') {
+ char[] chars = new char[tokenStart - i];
+ for (int j = 0; j < chars.length; j++) {
+ chars[j] = ' ';
+ }
+ indent = new String(chars);
+ break;
+ }
+ }
+
+ int i = 0;
+ while(i < s.length()) {
+ int nlIndex = s.indexOf('\n', i);
+ out.print(s.substring(i, nlIndex+1));
+ out.print(indent);
+ i = nlIndex + 1;
+ }
+ }
+
+
+}