util.java

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

            if (comparator != null) {
                return comparator;
            }
        }
        return null;
    }

    public static Object readBeanValue(Object bean, PropertyDescriptor property) {
        try {
            Method m = property.getReadMethod();
            return m.invoke(bean);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static String getGetName(String cname) {
        return "get" + Character.toUpperCase(cname.charAt(0)) + cname.substring(1);
    }

    public static boolean isDesigningContainer(SwingDesigner designer, Component comp) {
        ComponentAdapter adapter = AdapterBus.getComponentAdapter(designer, comp);
        return adapter instanceof ContainerAdapter;
    }

    public static Component findDesigningParent(Component comp) {
        Component parent = comp.getParent();
        if (Util.isRootComponent(parent) || Util.isDesigning(parent)) {
            return parent;
        }
        return findDesigningParent(parent);
    }

    public static boolean isRootComponent(Component root) {
        Container parent = root.getParent();
        return parent == null;
    }
    private static HashMap<Class, Comparator> comparators;
    static {
        comparators = new HashMap<Class, Comparator>();
        comparators.put(DefaultComboBoxModel.class, new DefaultComboBoxModelComparator());
        comparators.put(Font.class, new FontComparator());
        comparators.put(Color.class, new ColorComparator());
        comparators.put(ListModel.class, new ListModelComparator());
        comparators.put(SpinnerModel.class, new SpinnerModelComparator());
        comparators.put(String.class, new StringComparator());
        comparators.put(EmptyBorder.class, new EmptyBorderComparator());
        comparators.put(CompoundBorder.class, new CompoundBorderComparator());
        comparators.put(BasicBorders.MarginBorder.class, new BasicBordersMarginBorderComparator());
        comparators.put(BasicBorders.RadioButtonBorder.class, new BasicBordersRadioButtonBorderComparator());
        comparators.put(LineBorder.class, new LineBorderComparator());
        comparators.put(BasicBorders.SplitPaneBorder.class, new BasicBorderSplitPaneBorderComparator());
        comparators.put(AbstractBorder.class, new AbstractBorderComparator());
        comparators.put(Icon.class, new IconComparator());
    }

    private static class IconComparator implements Comparator<Icon> {

        public int compare(Icon o1, Icon o2) {
            return 0;
        }
    }

    private static class AbstractBorderComparator implements Comparator<AbstractBorder> {

        public int compare(AbstractBorder o1, AbstractBorder o2) {
            return 0;
        }
    }

    private static class BasicBorderSplitPaneBorderComparator implements Comparator<BasicBorders.SplitPaneBorder> {

        public int compare(SplitPaneBorder o1, SplitPaneBorder o2) {
            return 0;
        }
    }

    private static class LineBorderComparator implements Comparator<LineBorder> {

        public int compare(LineBorder o1, LineBorder o2) {
            Color c1 = o1.getLineColor();
            Color c2 = o2.getLineColor();
            int t1 = o1.getThickness();
            int t2 = o2.getThickness();
            boolean b1 = o1.getRoundedCorners();
            boolean b2 = o2.getRoundedCorners();
            if (c1 == c2) {
                return t1 == t2 && b1 == b2 ? 0 : 1;
            } else {
                if (c1 != null && c2 != null && c1.equals(c2)) {
                    return t1 == t2 && b1 == b2 ? 0 : 1;
                } else {
                    return 1;
                }
            }
        }
    }

    private static class BasicBordersRadioButtonBorderComparator implements Comparator<BasicBorders.RadioButtonBorder> {

        public int compare(RadioButtonBorder o1, RadioButtonBorder o2) {
            return 0;
        }
    }

    private static class BasicBordersMarginBorderComparator implements Comparator<BasicBorders.MarginBorder> {

        public int compare(MarginBorder o1, MarginBorder o2) {
            return 0;
        }
    }

    private static class CompoundBorderComparator implements Comparator<CompoundBorder> {

        public int compare(CompoundBorder o1, CompoundBorder o2) {
            Border inner1 = o1.getInsideBorder();
            Border inner2 = o2.getInsideBorder();
            if (!borderEquals(inner1, inner2)) {
                return 1;
            }
            Border outer1 = o1.getOutsideBorder();
            Border outer2 = o2.getOutsideBorder();
            if (!borderEquals(outer1, outer2)) {
                return 1;
            }
            return 0;
        }

        boolean borderEquals(Border b1, Border b2) {
            if (b1 != null && b2 != null) {
                if (b1.getClass() == b2.getClass()) {
                    Comparator comparator = getComparator(b1.getClass());
                    if (comparator != null) {
                        return comparator.compare(b1, b2) == 0;
                    } else if (b1.equals(b2)) {
                        return true;
                    } else {
                        return false;
                    }
                } else {
                    return false;
                }
            } else {
                return false;
            }
        }
    }

    private static class EmptyBorderComparator implements Comparator<EmptyBorder> {

        public int compare(EmptyBorder o1, EmptyBorder o2) {
            Insets insets1 = o1.getBorderInsets();
            Insets insets2 = o2.getBorderInsets();
            if (insets1.equals(insets2)) {
                return 0;
            }
            return 1;
        }
    }

    private static class StringComparator implements Comparator<String> {

        public int compare(String o1, String o2) {
            if (o1 == null) {
                if (o2 == null) {
                    return 0;
                } else if (o2.trim().length() == 0) {
                    return 0;
                } else {
                    return -1;
                }
            } else {
                if (o2 == null) {
                    if (o1.trim().length() == 0) {
                        return 0;
                    } else {
                        return 1;
                    }
                } else if (o1.trim().length() == 0 && o2.trim().length() == 0) {
                    return 0;
                } else {
                    return o1.compareTo(o2);
                }
            }
        }
    }

    private static class SpinnerModelComparator implements Comparator<SpinnerModel> {

        @Override
        public int compare(SpinnerModel o1, SpinnerModel o2) {
            if (o1 == null) {
                if (o2 == null) {
                    return 0;
                } else {
                    return -1;
                }
            } else if (o2 == null) {
                return 1;
            }
            Class c1 = o1.getClass();
            Class c2 = o2.getClass();
            if (c1 == c2) {
                return 0;
            } else {
                return 1;
            }
        }
    }

    private static class ListModelComparator implements Comparator<ListModel> {

        @Override
        public int compare(ListModel o1, ListModel o2) {
            if (o1 == null) {
                if (o2 == null) {
                    return 0;
                } else {
                    return -1;
                }
            } else if (o2 == null) {
                return 1;
            }
            Class c1 = o1.getClass();
            Class c2 = o2.getClass();
            if (c1 == c2) {
                return 0;
            } else {
                return 1;
            }
        }
    }

    private static class ColorComparator implements Comparator<Color> {

        @Override
        public int compare(Color o1, Color o2) {
            if (o1 == null) {
                if (o2 == null) {
                    return 0;
                } else {
                    return -1;
                }
            } else if (o2 == null) {
                return 1;
            }
            int r1 = o1.getRed();
            int g1 = o1.getGreen();
            int b1 = o1.getBlue();
            int r2 = o2.getRed();
            int g2 = o2.getGreen();
            int b2 = o2.getBlue();
            boolean e = r1 == r2 && g1 == g2 && b1 == b2;
            return e ? 0 : 1;
        }
    }

    private static class DefaultComboBoxModelComparator implements Comparator<DefaultComboBoxModel> {

        @Override
        public int compare(DefaultComboBoxModel o1, DefaultComboBoxModel o2) {
            if (o1 == null) {
                if (o2 == null) {
                    return 0;
                } else {
                    return -1;
                }
            } else if (o2 == null) {
                return 1;
            }
            int s1 = o1.getSize();
            int s2 = o2.getSize();
            if (s1 < s2) {
                return -1;
            } else if (s1 == s2) {
                return 0;
            } else {
                return 1;
            }
        }
    }

    private static class FontComparator implements Comparator<Font> {

        @Override
        public int compare(Font o1, Font o2) {
            if (o1 == null) {
                if (o2 == null) {
                    return 0;
                } else {
                    return -1;
                }
            } else if (o2 == null) {
                return 1;
            }
            String f1 = o1.getFamily();
            String n1 = o1.getName();
            String f2 = o2.getFamily();
            String n2 = o2.getName();
            int st1 = o1.getStyle();
            int st2 = o2.getStyle();
            int s1 = o1.getSize();
            int s2 = o2.getSize();
            boolean e = (f1.equals(f2) || f1.equals(n2) || f2.equals(n1)) && st1 == st2 && s1 == s2;
            if (e) {
                return 0;
            }
            return 1;
        }
    }

    public static String getCapitalName(String name) {
        return "" + Character.toUpperCase(name.charAt(0)) + name.substring(1);
    }

    public static EventSetDescriptor getESD(String esn, Component component) {
        try {
            BeanInfo info = Introspector.getBeanInfo(component.getClass());
            EventSetDescriptor[] esds = info.getEventSetDescriptors();
            if (esds != null) {
                for (EventSetDescriptor esd : esds) {
                    if (esd.getName().equals(esn)) {
                        return esd;
                    }
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }
}