codeseed.java

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

                tabs += "\t";
            }
            code = code.replaceAll("\\Q" + Constants.VAR_CONTAINER + "\\E", parentName);
            block.addSourceCode(code, tabs);
        }
    }

    private void initContainerChild(Container container, Component child) {
        if (declaration == null) {
            declaration = new CodeBlock(CodeType.declare, null);
            copy.insetCodeAt(init_line_no, declaration);
        }
        CodeBlock child_block = findGetChild(child);
        String cname = Util.getComponentName(child);
        String classname = child.getClass().getName();
        declaration.addCodeLine("\tprivate " + classname + " " + cname + ";");
        if (child_block == null) {
            child_block = new CodeBlock(CodeType.get, cname);
        }
        copy.insetCodeAt(init_line_no, child_block);
        ArrayList<CodeBlock> custom_codes = new ArrayList<CodeBlock>();
        ArrayList<CodeBlock> body_codes = child_block.getCodes();
        if (body_codes != null) {
            for (CodeBlock line_block : body_codes) {
                if (line_block.getType() == CodeType.custom) {
                    custom_codes.add(line_block);
                }
            }
        }
        child_block.clearCodes();
        child_block.addCodeLine("\tprivate " + classname + " " + Util.getGetName(cname) + "(){");
        child_block.addCodeLine("\t\tif(" + cname + " == null){");
        child_block.addCodeLine("\t\t\t" + cname + " = new " + classname + "();");
        initComponentProperties(child_block, child);
        initComponentChildren(child_block, child);
        initComponentEvents(child_block, child);
        child_block.addAllCode(custom_codes);
        child_block.addCodeLine("\t\t}");
        child_block.addCodeLine("\t\treturn " + cname + ";");
        child_block.addCodeLine("\t}");
    }

    private CodeBlock findGetChild(Component child) {
        String cname = Util.getComponentName(child);
        for (CodeBlock block : current_code.getCodes()) {
            if (block.getType() == CodeType.get) {
                if (cname.equals(block.getParam())) {
                    return block;
                }
            }
        }
        return null;
    }

    private void initRootComponentEvents(CodeBlock init_block, Component rootComponent) {
        JComponent jcomponent = AdapterBus.getJComponent(rootComponent);
        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());
                    init_block.addCode(listener_block);
                    initRootListenerBlock(key, listener_block, handlers);
                }
            }
        }
    }

    private void initRootListenerBlock(EventSetDescriptor esd, CodeBlock listener_block, HashMap<String, EventHandler> handlers) {
        listener_block.addCodeLine("\t\t" + esd.getAddListenerMethod().getName() + "(new " + esd.getListenerType().getName() + "(){");
        MethodDescriptor[] methods = esd.getListenerMethodDescriptors();
        for (MethodDescriptor method : methods) {
            String code_line = "\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}");
        }
        listener_block.addCodeLine("\t\t});");
    }

    private boolean hasHandler(HashMap<String, EventHandler> hm) {
        Set<String> keys = hm.keySet();
        for (String key : keys) {
            EventHandler h = (EventHandler) hm.get(key);
            if (h != null && h.getCode_buffer() != null) {
                return true;
            }
        }
        return false;
    }

    private void initRootComponentProperties(CodeBlock init_block, Component rootComponent) {
        try {
            JComponent jRootComponent = AdapterBus.getJComponent(rootComponent);
            LayoutManager layout = jRootComponent.getLayout();
            boolean default_layout = rootComponent instanceof RootPaneContainer && layout != null && layout instanceof BorderLayout ||
                    rootComponent instanceof JPanel && layout != null && layout instanceof FlowLayout;
            if (!default_layout) {
                if (layout == null) {
                    init_block.addCodeLine("\t\tthis.setLayout(null);");
                } else {
                    ContainerAdapter adapter = (ContainerAdapter) AdapterBus.createComponentAdapter(designer, rootComponent);
                    String code = adapter.getLayoutCode();
                    if (code != null) {
                        code = code.replaceAll("\\Q" + Constants.VAR_CONTAINER + "\\E", "this");
                        init_block.addSourceCode(code, "\t\t");
                    }
                }
            }
            BeanInfo info = Introspector.getBeanInfo(rootComponent.getClass());
            PropertyDescriptor[] properties = info.getPropertyDescriptors();
            for (PropertyDescriptor property : properties) {
                if (Util.isPropertyChanged(designer.getDesignLnf(), rootComponent, property)) {
                    Object beanValue = Util.readBeanValue(rootComponent, 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" + property.getWriteMethod().getName() + "(" + objectString + ");";
                    init_block.addCodeLine(code_line);
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public void initSourceCode() {
        StringWriter sw = new StringWriter();
        PrintWriter writer = new PrintWriter(sw);
        if (packager != null) {
            writer.println("package " + packager + ";");
        }
        writer.println("public class " + class_name + " extends " + guitype.getCode() + " {");
        writer.println("\tpublic " + class_name + "(){");
        writer.println("\t\tinitComponents();");
        writer.println("\t}");
        writer.println("\t//[init(400, 300)");
        writer.println("\tprivate void initComponents(){");
        writer.println("\t}");
        writer.println("\t//]");
        writer.println("}");
        writer.close();
        source_code = sw.toString();
    }
    private int init_line_no;
    private CodeBlock declaration;
    private CodeBlock copy;

    private void reset() {
        init_line_no = -1;
        declaration = null;
        copy = null;
    }

    public String generateSourceCode(Component rootComponent) {
        reset();
        copy = new CodeBlock(CodeType.source, null);
        ArrayList<CodeBlock> blocks = current_code.getCodes();
        CodeBlock init_block = null;
        for (int i = 0; i < blocks.size(); i++) {
            CodeBlock block = blocks.get(i);
            switch (block.getType()) {
                case packager:
                case importer:
                case init:
                    init_line_no = copy.getBlockCount() + 1;
                    init_block = block;
                case code:
                    copy.addCode(block);
                    break;
            }
        }
        ArrayList<CodeBlock> custom_codes = new ArrayList<CodeBlock>();
        blocks = init_block.getCodes();
        for (int i = 0; i < blocks.size(); i++) {
            CodeBlock block = blocks.get(i);
            CodeType type = block.getType();
            if (type == CodeType.custom) {
                custom_codes.add(block);
            }
        }
        init_block.clearCodes();
        init_block.setParam("" + rootComponent.getWidth() + ", " + rootComponent.getHeight());
        initRootComponent(init_block, custom_codes, rootComponent);
        current_code = copy;
        source_code = current_code.getSourceCode();
        return source_code;
    }

    private Component[] getChildren(Container container) {
        ArrayList<Component> components = new ArrayList<Component>();
        _collectDesigningComponents(container, components);
        return components.toArray(new Component[0]);
    }

    private void _collectDesigningComponents(Container container, ArrayList<Component> components) {
        int count = container.getComponentCount();
        for (int i = 0; i < count; i++) {
            Component child = container.getComponent(i);
            if (Util.isDesigning(child)) {
                components.add(child);
            } else if (child instanceof Container) {
                _collectDesigningComponents((Container) child, components);
            }
        }
    }

    public static File getCodeBufferDir() {
        File codeBufferDir = new File(new File("."), ".swing_designer_buffer");
        if (!codeBufferDir.exists()) {
            codeBufferDir.mkdir();
        }
        return codeBufferDir;
    }

    private static File getCodeBufferFile() {
        File codeBufferDir = getCodeBufferDir();
        return new File(codeBufferDir, "temp.java");
    }

    private static void cleanCacheDir() {
        deleteDir(getCodeBufferDir());
    }

    private static void deleteDir(File dir) {
        if (dir.exists()) {
            for (File file : dir.listFiles()) {
                if (file.isDirectory()) {
                    deleteDir(file);
                } else {
                    file.delete();
                }
            }
            dir.delete();
        }
    }

    public String generateSourceFile() {
        try {
            File bf = getCodeBufferFile();
            PrintWriter writer = new PrintWriter(new BufferedWriter(new FileWriter(bf)));
            String cName = generatePrototype(writer);
            writer.close();
            return cName;
        } catch (Exception ex) {
            ex.printStackTrace();
            return null;
        }
    }

    public Component generateComponent(PrintWriter pw) {
        try {
            current_code = analyseCode();
            String className = generateSourceFile();
            File srcFile = saveToFile(className);

            Class clazz = compileAndLoad(className, srcFile, pw);
            if (clazz != null) {
                Component comp = (Component) clazz.newInstance();
                if (comp != null) {
                    initComponentName(comp);
                    initListeners(comp);
                    comp.setSize(getInitSize());
                    return comp;
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace(pw);
        }
        return null;
    }

    private Dimension getInitSize() {
        CodeBlock init_block = prototype.getInit();
        String param = init_block.getParam();
        if (param != null) {
            int coma = param.indexOf(",");
            if (coma != -1) {
                String xStr = param.substring(0, coma).trim();
                String yStr = param.substring(coma + 1).trim();
                int x = Integer.parseInt(xStr);
                int y = Integer.parseInt(yStr);
                return new Dimension(x, y);
            }
        }
        return new Dimension(400, 300);
    }

    private Component getComponentByName(Component root, String varName) {
        try {
            Class clazz = root.getClass();
            Field field = clazz.getDeclaredField(varName);
            field.setAccessible(true);
            return (Component) field.get(root);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    private void initComponentName(Component comp) {
        Class clazz = comp.getClass();
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            try {
                field.setAccessible(true);
                Component subcomp = (Component) field.get(comp);
                if (!Util.isDesigning(subcomp)) {
                    Util.setComponentName(subcomp, field.getName());
                }
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
        if (!Util.isDesigning(comp)) {
            Util.setComponentName(comp, getClassName());
        }
    }

    public String getClassName() {
        return class_name;
    }

    public String getSourceCode() {
        return source_code;
    }

    public void setSourceCode(String source_code) {
        this.source_code = source_code;
    }

    private File saveToFile(String cName) {
        String file_name = cName;
        String pack = null;
        int dot = cName.lastIndexOf(".");
        if (dot != -1) {
            file_name = cName.substring(dot + 1);
            pack = cName.substring(0, dot);
            pack = pack.replace('.', '/');
        }
        file_name += ".java";
        File bf = getCodeBufferFile();
        if (pack != null) {
            File dir = getCodeBufferDir();
            File src_dir = new File(dir, pack);
            if (!src_dir.exists()) {
                src_dir.mkdirs();
            }
            File newfile = new File(src_dir, file_name);
            bf.renameTo(newfile);
            return newfile;
        } else {
            File newfile = new File(getCodeBufferDir(), file_name);
            bf.renameTo(newfile);
            return newfile;
        }
    }

    public Item getGuitype() {
        return guitype;
    }

    public void setGuitype(Item guitype) {
        this.guitype = guitype;
    }
}