jdk-sandbox: comparison jdk/make/src/classes/build/tools/swingbeaninfo/GenSwingBeanInfo.java

equal deleted inserted replaced

-:07b686da11c4
+:c7d7946239de
+/*
+* Copyright (c) 1998, 2004, Oracle and/or its affiliates. All rights reserved.
+* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+*
+* This code is free software; you can redistribute it and/or modify it
+* under the terms of the GNU General Public License version 2 only, as
+* published by the Free Software Foundation.  Oracle designates this
+* particular file as subject to the "Classpath" exception as provided
+* by Oracle in the LICENSE file that accompanied this code.
+*
+* This code is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+* version 2 for more details (a copy is included in the LICENSE file that
+* accompanied this code).
+*
+* You should have received a copy of the GNU General Public License version
+* 2 along with this work; if not, write to the Free Software Foundation,
+* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+*
+* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+* or visit www.oracle.com if you need additional information or have any
+* questions.
+*/
+package build.tools.swingbeaninfo;
+import java.beans.BeanInfo;
+import java.beans.BeanDescriptor;
+import java.beans.Introspector;
+import java.beans.IntrospectionException;
+import java.beans.PropertyDescriptor;
+import java.io.*;
+import java.util.Hashtable;
+import java.util.HashMap;
+import java.util.Iterator;
+/**
+* A utlity for generating a BeanInfo source file from a template and a
+* Hashtable with hints that were generated from a doclet.
+* it's neccessary to write things like the per property descriptions
+* by hand.  To run the application:
+* <pre>
+* java GenSwingBeanInfo <class name>
+* </pre>
+* Code for a bean info class is written to out.  If the class is
+* swing package, you don't need to fully specify its name.
+*
+* @author Hans Muller
+* @author Rich Schiavi
+* @author Mark Davidson
+*/
+public class GenSwingBeanInfo {
+private final static String BEANINFO_SUFFIX = "BeanInfo.java";
+// Tokens in @(...)
+private final static String TOK_BEANPACKAGE = "BeanPackageName";
+private final static String TOK_BEANCLASS = "BeanClassName";
+private final static String TOK_BEANOBJECT = "BeanClassObject";
+private final static String TOK_CLASSDESC = "ClassDescriptors";
+private final static String TOK_BEANDESC = "BeanDescription";
+private final static String TOK_PROPDESC = "BeanPropertyDescriptors";
+private final static String TOK_ENUMVARS = "EnumVariables";
+private String enumcode;  // Generated code for enumerated properties.
+private boolean DEBUG = false;
+private String fileDir;
+private String templateFilename;
+/**
+* Public constructor
+* @param fileDir Location to put the generated source files.
+* @param templateFilename Location of the BeanInfo template
+* @param debug Flag to turn on debugging
+*/
+public GenSwingBeanInfo(String fileDir, String templateFilename, boolean debug)  {
+this.fileDir = fileDir;
+this.templateFilename = templateFilename;
+this.DEBUG = debug;
+}
+/**
+* Opens a BeanInfo PrintStream for the class.
+*/
+private PrintStream initOutputFile(String classname) {
+try {
+OutputStream out = new FileOutputStream(fileDir + File.separator + classname + BEANINFO_SUFFIX);
+BufferedOutputStream bout = new BufferedOutputStream(out);
+return new PrintStream(out);
+} catch (IOException e){
+//    System.err.println("GenSwingBeanInfo: " + e.toString());
+}
+return null;
+}
+private static void messageAndExit(String msg) {
+System.err.println("\n" + msg);
+System.exit(1);
+}
+/**
+* Load the contents of the BeanInfo template into a string and
+* return the string.
+*/
+private String loadTemplate() {
+String template = "<no template>";
+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:
+* <pre>
+*      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"
+*              }
+*           );
+* </pre>
+*
+* @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 = "<A description of this component>.";
+String beanPropertyDescriptors = "<createSwingPropertyDescriptor code>";
+String classPropertyDescriptors = "<createSwingClassPropertyDescriptor code>";
+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 @(<token>) 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("<createSwingClassPropertyDescriptor code>"))) {
+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;
+}
+}
+}

changeset 21805	c7d7946239de
parent 5506	202f599c92aa
child 23010	6dadb192ad81