/*
 * Adapter.java
 *
 * Created on 2007年5月2日, 下午11:28
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */
package dyno.swing.designer.beans;

import dyno.swing.designer.beans.adapters.borders.DefaultBorderAdapter;
import dyno.swing.designer.beans.adapters.component.DefaultComponentAdapter;
import dyno.swing.designer.beans.adapters.layout.DefaultLayoutAdapter;
import java.awt.Component;
import java.awt.Container;
import java.awt.LayoutManager;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Properties;
import java.util.Set;
import javax.swing.JComponent;
import javax.swing.RootPaneContainer;
import javax.swing.border.Border;


/**
 * 適配器中樞，為組件和組件適配器、布局和布局適配器，提供映射關(guān)系的中樞
 * 這個(gè)類是整個(gè)設(shè)計(jì)器的擴(kuò)展點(diǎn)。如果需要擴(kuò)展新的組件類型或者布局管理器的特殊行為，
 * 只需要在components.properties和layouts.properties添加新的映射關(guān)系就可以了。
 *
 * @author William Chen
 */
public class AdapterBus {

    //組件類<-->組件適配器類，在component.properties中定義，該映射表還為該組件子類提供實(shí)例化幫助
    private static HashMap<Class<? extends Component>, Class<? extends ComponentAdapter>> componentAdapterClasses;
    //組件類<-->組件適配器，由上一個(gè)映射關(guān)系生成
    //private static HashMap<Class<?extends Component>, ComponentAdapter> componentAdapters;
    //布局類<-->布局適配器，在layouts.properties中定義
    private static HashMap<Class<? extends LayoutManager>, Class<? extends LayoutAdapter>> layoutAdapters;
    private static HashMap<Class<? extends Border>, Class<? extends BorderAdapter>> borderAdapters;
    static {
        //初始化
        initComponentAdapters();
        initLayoutAdapters();
        initBorderAdapters();
    }

    /**
     * 初始化組件適配器
     */
    @SuppressWarnings(value = "unchecked")
    private static void initComponentAdapters() {
        try {
            componentAdapterClasses = new HashMap<Class<? extends Component>, Class<? extends ComponentAdapter>>();

            Properties prop = new Properties();
            prop.load(AdapterBus.class.getResourceAsStream("components.properties"));

            Set<String> keys = prop.stringPropertyNames();

            for (String compClassName : keys) {
                String adapterClassName = prop.getProperty(compClassName);
                Class<? extends Component> compClass = (Class<? extends Component>) Class.forName(compClassName);
                Class<? extends ComponentAdapter> adapterClass = (Class<? extends ComponentAdapter>) Class.forName(adapterClassName);
                componentAdapterClasses.put(compClass, adapterClass);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * 初始化布局適配器
     */
    @SuppressWarnings(value = "unchecked")
    private static void initLayoutAdapters() {
        try {
            layoutAdapters = new HashMap<Class<? extends LayoutManager>, Class<? extends LayoutAdapter>>();

            Properties prop = new Properties();
            prop.load(AdapterBus.class.getResourceAsStream("layouts.properties"));

            Set<String> keys = prop.stringPropertyNames();

            for (String layoutClassName : keys) {
                String adapterClassName = prop.getProperty(layoutClassName);
                Class<LayoutManager> layoutClass = (Class<LayoutManager>) Class.forName(layoutClassName);
                Class<LayoutAdapter> adapterClass = (Class<LayoutAdapter>) Class.forName(adapterClassName);
                layoutAdapters.put(layoutClass, adapterClass);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    private static void initBorderAdapters() {
        try {
            borderAdapters = new HashMap<Class<? extends Border>, Class<? extends BorderAdapter>>();

            Properties prop = new Properties();
            prop.load(AdapterBus.class.getResourceAsStream("borders.properties"));

            Set<String> keys = prop.stringPropertyNames();

            for (String borderClassName : keys) {
                String adapterClassName = prop.getProperty(borderClassName);
                Class<Border> borderClass = (Class<Border>) Class.forName(borderClassName);
                Class<BorderAdapter> adapterClass = (Class<BorderAdapter>) Class.forName(adapterClassName);
                borderAdapters.put(borderClass, adapterClass);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * 獲取組件類型是componentClass對(duì)應(yīng)的組件適配器，如果初始映射表中沒(méi)有該適配器，
     * 則繼續(xù)查找其父類對(duì)應(yīng)的適配器，直至查找到Component類為止，如果還是沒(méi)有查找到，
     * 則使用缺省的組件適配器：DefaultComponentAdapter
     *
     * @return 該組件類所對(duì)應(yīng)的組件適配器對(duì)象
     */
    public static ComponentAdapter createComponentAdapter(SwingDesigner designer, Component component) {
        Class<? extends Component> componentClass = component.getClass();
        ComponentAdapter adapter;

        //如映射中沒(méi)有，則查找其父類、祖先類直到Component或者空
        Class parentClass = searchAdapterClass(componentAdapterClasses, componentClass, Component.class);

        if ((parentClass == null) || (parentClass == Component.class)) {
            //如果沒(méi)有查找到則使用缺省的組件適配器
            adapter = new DefaultComponentAdapter(designer, component);
        } else {
            try {
                //查找了，則為實(shí)例化一個(gè)適配器
                Class<? extends ComponentAdapter> adapterClass = componentAdapterClasses.get(parentClass);
                Constructor<? extends ComponentAdapter> cons = adapterClass.getConstructor(SwingDesigner.class, Component.class);
                adapter = cons.newInstance(designer, component);
            } catch (Exception ex) {
                ex.printStackTrace();
                //實(shí)例化失敗，則轉(zhuǎn)為缺省的組件適配器
                adapter = new DefaultComponentAdapter(designer, component);
            }
        }
        return adapter;
    }

    private static Class searchAdapterClass(HashMap maps, Class clazz, Class stop) {
        Class parentClass = clazz;
        while ((parentClass != null) && (parentClass != stop) && (maps.get(parentClass) == null)) {
            parentClass = parentClass.getSuperclass();
        }
        return parentClass;
    }
    public static JComponent getJComponent(Component component){
        JComponent jcomponent;
        if (component instanceof JComponent) {
            jcomponent = (JComponent) component;
        } else if (component instanceof RootPaneContainer) {
            jcomponent = (JComponent)((RootPaneContainer) component).getContentPane();
        } else {
            return null;
        }
        return jcomponent;
    }
    /**
     * 獲取組件類型是componentClass對(duì)應(yīng)的組件適配器，如果初始映射表中沒(méi)有該適配器，
     * 則繼續(xù)查找其父類對(duì)應(yīng)的適配器，直至查找到Component類為止，如果還是沒(méi)有查找到，
     * 則使用缺省的組件適配器：DefaultComponentAdapter
     *
     * @return 該組件類所對(duì)應(yīng)的組件適配器對(duì)象
     */
    public static ComponentAdapter getComponentAdapter(SwingDesigner designer, Component component) {
        JComponent jcomponent=getJComponent(component);
        ComponentAdapter adapter = (ComponentAdapter) jcomponent.getClientProperty("component.adapter");
        if (adapter == null) {
            adapter = createComponentAdapter(designer, component);
            jcomponent.putClientProperty("component.adapter", adapter);
        }
        return adapter;
    }

    /**
     * 獲取layoutClass布局管理器對(duì)應(yīng)的布局適配器
     */
    public static LayoutAdapter getLayoutAdapter(SwingDesigner designer, Container container) {
        LayoutManager layout = container.getLayout();
        Class<? extends LayoutManager> layoutClass = layout.getClass();
        Class parentClass = searchAdapterClass(layoutAdapters, layoutClass, LayoutManager.class);
        if (parentClass == null || parentClass == LayoutManager.class) {
            return new DefaultLayoutAdapter(designer, container);
        } else {
            Class<? extends LayoutAdapter> adapterClass = layoutAdapters.get(parentClass);
            try {
                Constructor<? extends LayoutAdapter> cons = adapterClass.getConstructor(SwingDesigner.class, Container.class);
                LayoutAdapter adapter = cons.newInstance(designer, container);
                return adapter;
            } catch (Exception e) {
                e.printStackTrace();
                LayoutAdapter adapter = new DefaultLayoutAdapter(designer, container);
                return adapter;
            }
        }
    }

    /**
     * 獲取layoutClass布局管理器對(duì)應(yīng)的布局適配器
     */
    public static BorderAdapter getBorderAdapter(Border border) {
        Class<? extends Border> borderClass = border.getClass();
        Class parentClass = searchAdapterClass(borderAdapters, borderClass, Border.class);
        if (parentClass == null || parentClass == Border.class) {
            return new DefaultBorderAdapter(border);
        } else {
            Class<? extends BorderAdapter> adapterClass = borderAdapters.get(parentClass);
            try {
                Constructor<? extends BorderAdapter> cons = adapterClass.getConstructor(Border.class);
                BorderAdapter adapter = cons.newInstance(border);
                return adapter;
            } catch (Exception e) {
                e.printStackTrace();
                BorderAdapter adapter = new DefaultBorderAdapter(border);
                return adapter;
            }
        }
    }
}