codeseed.java

SWING的界面UI包 SWING的界面UI包

/*
 * CodeSeed.java
 *
 * Created on 2007-9-6, 22:01:04
 *
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package dyno.swing.designer.beans.code;

import com.sun.tools.javac.Main;
import dyno.swing.beans.layouts.AbsoluteLayout;
import dyno.swing.designer.beans.AdapterBus;
import dyno.swing.designer.beans.Constants;
import dyno.swing.designer.beans.ContainerAdapter;
import dyno.swing.designer.beans.SwingDesigner;
import dyno.swing.designer.beans.Util;
import dyno.swing.designer.properties.items.ItemProvider;
import dyno.swing.designer.properties.types.EventHandler;
import dyno.swing.designer.properties.types.Item;
import dyno.swing.designer.properties.wrappers.ItemWrapper;
import dyno.swing.designer.properties.wrappers.SourceCoder;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.LayoutManager;
import java.beans.BeanInfo;
import java.beans.Beans;
import java.beans.EventSetDescriptor;
import java.beans.Introspector;
import java.beans.MethodDescriptor;
import java.beans.PropertyDescriptor;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.io.StringReader;
import java.io.StringWriter;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
import java.util.Stack;
import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.RootPaneContainer;

/**
 *
 * @author William Chen
 */
public class CodeSeed {

    static {
        Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {

                    public void run() {
                        cleanCacheDir();
                    }
                }));
    }
    private String class_name;
    private String packager;
    private String source_code;
    private CodeBlock current_code;
    private SwingDesigner designer;
    private Prototype prototype;
    private Item guitype;

    public void setPackager(String packager) {
        this.packager = packager;
    }

    private String generatePrototype(PrintWriter writer) {
        prototype = new Prototype();
        for (CodeBlock block : current_code.getCodes()) {
            switch (block.getType()) {
                case source:
                    break;
                case code:
                    break;
                case declare:
                    prototype.setDeclaration(block);
                    break;
                case init:
                    prototype.setInit(block);
                    break;
                case get:
                    prototype.addGet(block);
                    break;
                case custom:
                    break;
                case listener:
                    break;
                case event:
                    break;
                case packager:
                    prototype.setPackager(block);
                    break;
                case importer:
                    prototype.addImporter(block);
                    break;
            }
        }
        return prototype.generatePrototypeSourceCode(writer, guitype);
    }

    public CodeSeed(SwingDesigner designer) {
        this.designer = designer;
    }

    public void setClassName(String class_name) {
        this.class_name = class_name;
    }

    private Class compileAndLoad(String className, File srcFile, PrintWriter pw) {
        try {
            if (pw != null) {
                Main.compile(new String[]{srcFile.getCanonicalPath()}, pw);
            } else {
                Main.compile(new String[]{srcFile.getCanonicalPath()});
            }
            PrototypeClassLoader loader = new PrototypeClassLoader();
            return loader.loadClass(className);
        } catch (Exception e) {
            e.printStackTrace(pw);
        }
        return null;
    }

    private CodeBlock analyseCode() {
        try {
            Stack<CodeBlock> stack = new Stack<CodeBlock>();
            CodeBlock source = new CodeBlock(CodeType.source, null);
            stack.push(source);
            BufferedReader reader = new BufferedReader(new StringReader(source_code));
            String line;
            while ((line = reader.readLine()) != null) {
                String trim_line = line.trim();
                if (trim_line.startsWith("package")) {
                    stack.peek().addCode(new CodeBlock(CodeType.packager, line));
                } else if (trim_line.startsWith("import")) {
                    stack.peek().addCode(new CodeBlock(CodeType.importer, line));
                } else if (trim_line.startsWith("//[")) {
                    String signature = trim_line.substring(3);
                    String ctype = signature;
                    String para = null;
                    int left = signature.indexOf("(");
                    if (left != -1) {
                        ctype = signature.substring(0, left);
                        para = signature.substring(left + 1);
                        int right = signature.indexOf(")");
                        if (right != -1) {
                            para = signature.substring(left + 1, right);
                        }
                    }
                    CodeType type = CodeType.valueOf(ctype);
                    CodeBlock block = new CodeBlock(type, para);
                    stack.peek().addCode(block);
                    stack.push(block);
                } else if (trim_line.startsWith("//]")) {
                    stack.pop();
                } else {
                    CodeBlock code = new CodeBlock(CodeType.code, line);
                    stack.peek().addCode(code);
                }
            }
            return stack.pop();
        } catch (Exception ex) {
            ex.printStackTrace();
            return null;
        }
    }

    private void initListeners(Component comp) {
        for (CodeBlock block : current_code.getCodes()) {
            switch (block.getType()) {
                case init:
                    initComponentListener(comp, block);
                    break;
                case get:
                    String comp_name = block.getParam();
                    Component component = this.getComponentByName(comp, comp_name);
                    if (component != null) {
                        initComponentListener(component, block);
                    }
                    break;
            }
        }
    }

    private void initComponentListener(Component comp, CodeBlock block) {
        for (CodeBlock code : block.getCodes()) {
            switch (code.getType()) {
                case listener:
                    addComponentListener(comp, code);
                    break;
            }
        }
    }

    private void addComponentListener(Component component, CodeBlock code) {
        HashMap<EventSetDescriptor, HashMap<String, EventHandler>> eventHandlers = (HashMap<EventSetDescriptor, HashMap<String, EventHandler>>) ((JComponent) component).getClientProperty("event.handler");
        if (eventHandlers == null) {
            eventHandlers = new HashMap<EventSetDescriptor, HashMap<String, EventHandler>>();
            ((JComponent) component).putClientProperty("event.handler", eventHandlers);
        }
        String eventSetName = code.getParam();
        EventSetDescriptor esd = Util.getESD(eventSetName, component);
        HashMap<String, EventHandler> handlers = eventHandlers.get(esd);
        if (handlers == null) {
            handlers = new HashMap<String, EventHandler>();
            eventHandlers.put(esd, handlers);
        }
        for (CodeBlock block : code.getCodes()) {
            switch (block.getType()) {
                case event:
                    String mName = block.getParam();
                    String content = "";
                    ArrayList<CodeBlock> lines = block.getCodes();
                    if (lines != null) {
                        for (CodeBlock line : lines) {
                            content += line.getParam() + "\n";
                        }
                    }
                    try {
                        EventHandler handler = new EventHandler(mName);
                        handler.setCode_buffer(content);
                        handlers.put(mName, handler);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    break;
            }
        }
    }

    private void initRootComponent(CodeBlock init_block, ArrayList<CodeBlock> custom_codes, Component rootComponent) {
        init_block.addCodeLine("\tprivate void initComponents(){");
        initRootComponentProperties(init_block, rootComponent);
        initRootComponentChildren(init_block, rootComponent);
        initRootComponentEvents(init_block, rootComponent);
        init_block.addAllCode(custom_codes);
        init_block.addCodeLine("\t}");
    }

    private SourceCoder getSourceCoder(Object value, PropertyDescriptor property) {
        Class clazz = property.getPropertyType();
        if (value != null) {
            clazz = value.getClass();
        }
        Class<? extends SourceCoder> coderClass = Util.getSourceCoder(clazz);
        if (coderClass != null) {
            try {
                return coderClass.newInstance();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        } else {
            String itemString = (String) property.getValue("items");
            if (!Util.isStringNull(itemString)) {
                try {
                    ItemProvider provider = (ItemProvider) Beans.instantiate(getClass().getClassLoader(), itemString);
                    ItemWrapper wrapper = new ItemWrapper(provider);
                    return wrapper;
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
        return null;
    }

    private void initComponentChildren(CodeBlock child_block, Component child) {
        if (Util.isDesigningContainer(designer, child)) {
            Container childContainer = (Container) child;
            initContainerChildren(child_block, childContainer);
        }
    }

    private void initComponentEvents(CodeBlock child_block, Component child) {
        JComponent jcomponent = (JComponent) child;
        HashMap<EventSetDescriptor, HashMap<String, EventHandler>> eventHandlers = (HashMap<EventSetDescriptor, HashMap<String, EventHandler>>) jcomponent.getClientProperty("event.handler");
        if (eventHandlers != null) {
            Set<EventSetDescriptor> keys = eventHandlers.keySet();
            for (EventSetDescriptor key : keys) {
                HashMap<String, EventHandler> handlers = eventHandlers.get(key);
                if (!handlers.isEmpty() && hasHandler(handlers)) {
                    CodeBlock listener_block = new CodeBlock(CodeType.listener, key.getName());
                    child_block.addCode(listener_block);
                    initComponentListenerBlock(child, key, listener_block, handlers);
                }
            }
        }
    }

    private void initComponentListenerBlock(Component child, EventSetDescriptor esd, CodeBlock listener_block, HashMap<String, EventHandler> handlers) {
        String var = Util.getComponentName(child);
        listener_block.addCodeLine("\t\t\t" + var + "." + esd.getAddListenerMethod().getName() + "(new " + esd.getListenerType().getName() + "(){");
        MethodDescriptor[] methods = esd.getListenerMethodDescriptors();
        for (MethodDescriptor method : methods) {
            String code_line = "\t\t\t\tpublic void " + method.getMethod().getName() + "(";
            Class[] paraTypes = method.getMethod().getParameterTypes();
            for (int i = 0; i < paraTypes.length; i++) {
                if (i != 0) {
                    code_line += ",";
                }
                code_line += paraTypes[i].getName() + " event";
            }
            code_line += ") {";
            listener_block.addCodeLine(code_line);
            String mHandler = method.getName();
            EventHandler handler = handlers.get(mHandler);
            String code_buffer = handler.getCode_buffer();
            if (code_buffer != null) {
                CodeBlock body_block = new CodeBlock(CodeType.event, mHandler);
                body_block.addSourceCode(code_buffer);
                listener_block.addCode(body_block);
            }
            listener_block.addCodeLine("\t\t\t\t}");
        }
        listener_block.addCodeLine("\t\t\t});");
    }

    private void initComponentProperties(CodeBlock child_block, Component child) {
        try {
            String cname = Util.getComponentName(child);
            if (Util.isDesigningContainer(designer, child)) {
                ContainerAdapter adapter = (ContainerAdapter) AdapterBus.createComponentAdapter(designer, child);
                String code = adapter.getLayoutCode();
                if (code != null) {
                    code = code.replaceAll("\\Q" + Constants.VAR_CONTAINER + "\\E", cname);
                    child_block.addSourceCode(code, "\t\t\t");
                }
            }
            BeanInfo info = Introspector.getBeanInfo(child.getClass());
            PropertyDescriptor[] properties = info.getPropertyDescriptors();
            for (PropertyDescriptor property : properties) {
                if (Util.isPropertyChanged(designer.getDesignLnf(), child, property)) {
                    Method m = property.getWriteMethod();
                    Deprecated dep = m.getAnnotation(Deprecated.class);
                    if (dep == null) {
                        Object beanValue = Util.readBeanValue(child, property);
                        String objectString = beanValue == null ? "null" : beanValue.toString();
                        SourceCoder coder = getSourceCoder(beanValue, property);
                        if (coder != null) {
                            objectString = coder.getJavaCode(beanValue);
                        }
                        String code_line = "\t\t\t" + cname + "." + property.getWriteMethod().getName() + "(" + objectString + ");";
                        child_block.addCodeLine(code_line);
                    }
                }
            }
            Container parent = child.getParent();
            if (parent != null) {
                LayoutManager layout = parent.getLayout();
                if (layout == null || layout instanceof AbsoluteLayout) {
                    child_block.addCodeLine("\t\t\t" + cname + ".setBounds(" + child.getX() + ", " + child.getY() + ", " + child.getWidth() + ", " + child.getHeight() + ");");
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    private void initRootComponentChildren(CodeBlock init_block, Component rootComponent) {
        if (rootComponent instanceof Container) {
            Container rootContainer = (Container) rootComponent;
            initContainerChildren(init_block, rootContainer);
        }
    }

    private void initContainerChildren(CodeBlock block, Container container) {
        Component[] children = getChildren(container);
        for (Component child : children) {
            initContainerChild(container, child);
            ContainerAdapter adapter = (ContainerAdapter) AdapterBus.createComponentAdapter(designer, container);
            String code = adapter.getAddComponentCode(child);
            String parentName = "this";
            String tabs = "\t\t";
            if (!designer.isRootComponent(container)) {
                parentName = Util.getComponentName(container);