BlogJava-Jiangshachina-随笔分类-Swing

Custom Layout Manager: PyramidLayout(原)

Sha Jiang — Sun, 15 Jul 2012 14:14:00 GMT

Custom Layout Manager: PyramidLayout

    已有太多关于自定义部局管理器的文章了。本文仅是一篇学习笔记，描述了如何实现一种像堆金字塔似的部局管理器，很简单，也有点儿意思，可能你也会感兴趣的。(2012.07.17最后更新)

    I have developed Swing application for several years, although I'm not professional GUI developer, I'm shamed of never creating any custom layout manager. Maybe the existing Swing layout managers are too powerful to create new ones. At least, GridBagLayout is powerful enough for my real works. And we have much more flexible GroupLayout and SpringLayout, of course, both of them are too complex, in fact I never use them directly. However I indirectly take advantage of GroupLayout due to using NetBeans' GUI designer Matisse.

1. Layout Manager basics
    Let's start with some layout manager foundation. Before this time I learn to customize layout, I always think layout manager is very mysterious. Layout is like a magic player that put a variety of components to right positions in containers. I haven't browsed any code of any layout, event the simplest one. That's why I think layout is mystery. But it's simple for me now.
    Generally, all of layout implements one or both of LayoutManager and LayoutManager2 interfaces. LayoutManager2 is LayoutManager's sub-interface, then if someone implements LayoutManager2 that means it really implements LayoutManager. Mostly all modern layouts implements LayoutManager2.
    Interface LayoutManager defines the basic methods must be implemented by every layout, all of them are intuitional: add new component--addLayoutComponent(); remove component--removeLayoutComponent(); calculate preferred size--preferredLayoutSize(); calculate minimum size--minimumLayoutSize(); how to layout the components--layoutContainer(). Absolutely, the layoutContainer() method is essential, you must instruct the parent container how to allocate space(bounds) for every component.
    The extension interface LayoutManager2 introduces more methods that if you have to: support constraints--addLayoutComponent(Component, Object); specify maximum size--maximumLayoutSize(); specify alignment--getLayoutAlignmentX() and getLayoutAlignmentY(); destroy specific caches or reset some variables when invaliding container--invalidateLayout().

2. PyramidLayout
    Now let's feature a simple and funny layout manager--PyramidLayout. The layout allows container to add components like building a Pyramid, as shown as the image below,

    As the above, PyramidLayout puts the first component on the bottom, then puts the second on top of the first, but its bounds is smaller, ... It looks like a Pyramid, doesn't it? Here is the full codes,

public class PyramidLayout implements LayoutManager2 {

    private List<Component> comps = new LinkedList<Component>();

    public void addLayoutComponent(final Component comp,
            final Object constraints) {
        synchronized (comp.getTreeLock()) {
            comps.add(comp);
        }
    }

    public void addLayoutComponent(final String name, final Component comp) {
        addLayoutComponent(comp, null);
    }

    public void removeLayoutComponent(final Component comp) {
        synchronized (comp.getTreeLock()) {
            comps.remove(comp);
        }
    }

    public float getLayoutAlignmentX(final Container target) {
        return 0.5F;
    }

    public float getLayoutAlignmentY(final Container target) {
        return 0.5F;
    }

    public void invalidateLayout(final Container target) {
        System.out.println();
    }

    public Dimension preferredLayoutSize(final Container parent) {
        synchronized (parent.getTreeLock()) {
            Insets insets = parent.getInsets();
            int width = insets.left + insets.right;
            int height = insets.top + insets.bottom;
            if (comps.size() == 0) {
                return new Dimension(width, height);
            }

            Dimension size = comps.get(0).getPreferredSize();
            width += size.width;
            height += size.height;

            return new Dimension(width, height);
        }
    }

    public Dimension minimumLayoutSize(final Container parent) {
        synchronized (parent.getTreeLock()) {
            Insets insets = parent.getInsets();
            int width = insets.left + insets.right;
            int height = insets.top + insets.bottom;
            if (comps.size() == 0) {
                return new Dimension(width, height);
            }

            Dimension size = comps.get(0).getMinimumSize();
            width += size.width;
            height += size.height;

            return new Dimension(width, height);
        }
    }

    public Dimension maximumLayoutSize(final Container target) {
        return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
    }

    public void layoutContainer(final Container parent) {
        synchronized (parent.getTreeLock()) {
            Dimension parentSize = parent.getSize();
            int compsCount = comps.size();
            Dimension step = new Dimension(parentSize.width / (2 * compsCount),
                    parentSize.height / (2 * compsCount));

            for (int i = 0; i < compsCount; i++) {
                Component comp = comps.get(i);
                comp.setBounds(calcBounds(parentSize, step, i));
                parent.setComponentZOrder(comp, compsCount - i - 1);
            }
        }
    }

    private Rectangle calcBounds(Dimension parentSize, Dimension step, int index) {
        int x = step.width * index;
        int y = step.height * index;
        int width = parentSize.width - step.width * 2 * index;
        int height = parentSize.height - step.height * 2 * index;
        return new Rectangle(x, y, width, height);
    }
}

    Collection instance "comps" manages all of components, in this case, I take a LinkedList object to add and remove UI components. The layout doesn't concern any constraint, so the two addLayoutComponent() methods have the same actions. Please see the codes for details.
    As aforementioned, layoutContainer() method really takes charge of layouting the components. The key work is allocating space for each component, namely, specifying the bounds. Calculating bounds values just applies the simplest arithmetic operations.
    According to the intention, the bottom component fills the whole parent container, so it determines the preferred and the minimum sizes. For details, please take a look at methods preferredLayoutSize() and minimumLayoutSize(). Since the layout manager doesn't take care of the maximum size, the maximumLayoutSize() method simply returns a constant value.

Sha Jiang 2012-07-15 22:14 发表评论

构建不规则窗体(原)

Sha Jiang — Tue, 31 May 2011 12:46:00 GMT

构建不规则窗体

在开发一个新浪微博Swing客户端的过程中希望能展现不规则的窗体界面，原来JDK 6 update 10提供了创建指定形状窗体的特性，简单易用，记于此处。(2010.05.31最后更新)

Java从JDK 6 update 10开始将内建支持构建指定形状的窗体，类com.sun.awt.AWTUtilities中的方法setWindowShape会根据不同的Shape实现去构造相应形状的窗体。AWTUtilities类是放在SUN的包中，在使用该方法时应该通过反射去进行调用，如下代码所示，

Class clazz = Class.forName("com.sun.awt.AWTUtilities");
Method method = clazz.getMethod("setWindowShape", Window.class, Shape.class);

1. 创建正常窗体
先创建一个简单的界面，它使用BorderLayout，在其中安放5个JButton，如下代码所示，

public class ShapedFrame extends JFrame {

    private static final long serialVersionUID = -2291343874280454383L;

    private JButton centerButton = new JButton("Center");

    public ShapedFrame() {
        super("Shaped Frame");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        initUI();
    }

    private void initUI() {
        Container container = getContentPane();
        container.setLayout(new BorderLayout());

        container.add(new JButton("TOP"), BorderLayout.PAGE_START);
        container.add(new JButton("RIGHT"), BorderLayout.LINE_END);
        container.add(new JButton("BOTTOM"), BorderLayout.PAGE_END);
        container.add(new JButton("LEFT"), BorderLayout.LINE_START);
        container.add(centerButton, BorderLayout.CENTER);
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {

            @Override
            public void run() {
                ShapedFrame frame = new ShapedFrame();
                frame.setSize(new Dimension(400, 300));
                frame.setUndecorated(true);
                setAtCenter(frame);
                frame.setVisible(true);
            }
        });
    }

    // 将Window置于屏幕正中
    private static void setAtCenter(Window window) {
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        window.setLocation((screenSize.width - window.getWidth()) / 2,
                (screenSize.height - window.getHeight()) / 2);
    }
}

执行上述程序的效果如下图所示，

2. 创建不规则窗体
基于上述程序创建不规则窗体，使整个窗体正好缺失掉RIGHT JButton所在的区域，如下代码所示，

public class ShapedFrame extends JFrame {

    private static final long serialVersionUID = -2291343874280454383L;

    private static Method method = null;

    static {
        try {
            Class clazz = Class.forName("com.sun.awt.AWTUtilities");
            method = clazz.getMethod("setWindowShape", Window.class, Shape.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private JButton centerButton = new JButton("Center");

    public ShapedFrame() {
        super("Shaped Frame");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        initUI();
        addComponentListener(componentListener);
    }

    private void initUI() {
        Container container = getContentPane();
        container.setLayout(new BorderLayout());

        container.add(new JButton("TOP"), BorderLayout.PAGE_START);
        container.add(new JButton("RIGHT"), BorderLayout.LINE_END);
        container.add(new JButton("BOTTOM"), BorderLayout.PAGE_END);
        container.add(new JButton("LEFT"), BorderLayout.LINE_START);
        container.add(centerButton, BorderLayout.CENTER);
    }

    private ComponentListener componentListener = new ComponentAdapter() {

        @Override
        public void componentResized(ComponentEvent evt) { // 当UI组件(JFrame)的尺寸发生改变时，调用该方法
            Rectangle frameRect = getBounds();
            Rectangle spaceRect = centerButton.getBounds();

            Point o1 = new Point(0, 0);
            Point o2 = new Point(frameRect.width, 0);
            Point o3 = new Point(frameRect.width, frameRect.height);
            Point o4 = new Point(0, frameRect.height);

            Point i1 = new Point(spaceRect.x + spaceRect.width, spaceRect.y);
            Point i2 = new Point(frameRect.width, spaceRect.y);
            Point i3 = new Point(frameRect.width, spaceRect.y
                    + spaceRect.height);
            Point i4 = new Point(spaceRect.x + spaceRect.width, spaceRect.y + spaceRect.height);

            int[] xpoints = new int[] { o1.x, o2.x, i2.x, i1.x, i4.x, i3.x, o3.x, o4.x };
            int[] ypoints = new int[] { o1.y, o2.y, i2.y, i1.y, i4.y, i3.y, o3.y, o4.y };
            int npoints = 8
            // 构建一个六边形，将RIGHT JButton所处的位置空缺出来
            Shape shape = new Polygon(xpoints, ypoints, npoints);

            setWindowShape(ShapedFrame.this, shape);
        }
    };

    // 设置Window的形状
    private static void setWindowShape(Window window, Shape shape) {
        try {
            method.invoke(null, window, shape);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {

            @Override
            public void run() {
                ShapedFrame frame = new ShapedFrame();
                frame.setSize(new Dimension(400, 300));
                frame.setUndecorated(true);
                setAtCenter(frame);
                frame.setVisible(true);
            }
        });
    }

    // 将Window置于屏幕正中
    private static void setAtCenter(Window window) {
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        window.setLocation((screenSize.width - window.getWidth()) / 2,
                (screenSize.height - window.getHeight()) / 2);
    }
}

执行上述程序后，会有如下图所示的效果，

Sha Jiang 2011-05-31 20:46 发表评论

你所不知道的五件事情--改进Swing(译)

Sha Jiang — Mon, 25 Oct 2010 14:23:00 GMT

摘要: 你所不知道的五件事情--改进Swing 这是Ted Neward在IBM developerWorks中5 things系列文章中的一篇，讲述了关于改进Swing应用的一些窍门，值得大家学习。(2010.10.25最后更新) 摘要：Swing已是一个比较老的工具集了，在美观的用户界面出来之前需要开发很长时间。它缺少一些你在开发富UI时所需的组件。幸运地是，像 Substance，Swi... 阅读全文

Sha Jiang 2010-10-25 22:23 发表评论

数据加载模糊进度指示面板的实现与应用(原)

Sha Jiang — Sun, 29 Nov 2009 12:33:00 GMT

数据加载模糊进度指示面板的实现与应用

当在加载数据(或其它耗时工作)时，需要显示一个进度指示面板，本文介绍了一种简易的实现方式。(2009.11.30最后更新)

对于许多Swing应用，在与用户的交互过程中可能需要与数据库进行通信(如，加载数据)。而这个过程往往比较耗时，为了不造成"假死"现象，一般都会显示一个模糊进度指示器(不一定使用JProgressBar，简单地用一个图片代替即可)，当数据加载完毕后，该进度指示器自动消失。
一般地，该模糊进度指示器不会展示在一个弹出的对话框中(因为这样不美观)，而是直接显示在需要展示被加载数据的面板中，并且对该面板进行模糊处理。实现这一功能的关键就在于，在屏幕的同一区域内展示两层面板：一层是展示数据的面板；另一层是展示进度指示器的面板。当加载数据时，显示进度指示器面板，并模糊数据面板；当数据加载完毕后，隐藏进度指示器面板，并使数据面板清晰显示。下面将使用org.jdesktop.swingx.StackLayout方式来实现上述功能。

1. LoadingPanel--加载指示器面板
首先创建一个加载指示器面板。如前所述，我们不必使用真正的进度条作为进度指示器，仅需要使用一张动态图片来代替即可。LoadingPanel的完整代码如下所示，

public class LoadingPanel extends JPanel {

    private static final long serialVersionUID = 1962748329465603630L;

    private String mesg = null;

    public LoadingPanel(String mesg) {
        this.mesg = mesg;
        initUI();
        interceptInput();
        setOpaque(false);
        setVisible(false);
    }

    private void initUI() {
        JLabel label = new JLabel(mesg);
        label.setHorizontalAlignment(JLabel.CENTER);
        label.setIcon(new ImageIcon(getClass().getResource("/path/to/spinner.gif")));

        setLayout(new BorderLayout());
        add(label, BorderLayout.CENTER);
    }

    private void interceptInput() {
        addMouseListener(new MouseAdapter() {});
        addMouseMotionListener(new MouseMotionAdapter() {});
        addKeyListener(new KeyAdapter() {});

        addComponentListener(new ComponentAdapter() {
            @Override
            public void componentShown(ComponentEvent e) {
                requestFocusInWindow();
            }
        });
        setFocusTraversalKeysEnabled(false);
    }
}

上述代码很容易理解，LoadingPanel中仅有一个JLabel，它会展示一张图片(spinner.gif)及一段信息。但有两段代码需要特别说明：
[1]构造器中的两行代码

setVisible(false);
setOpaque(false);

LoadingPanel只在加载数据时才显示，其它时候是不显示的，所以它默认不可见。另外，在显示LoadingPanel的同时，我们仍然希望能看到数据面板，所以LoadingPanel应该是透明的。
[2]interceptInput方法
当LoadingPanel显示之后，我们不希望用户还能够操作数据面板，那么就需要屏蔽掉用户(鼠标，键盘)输入。

addMouseListener(new MouseAdapter() {});
addMouseMotionListener(new MouseMotionAdapter() {});
addKeyListener(new KeyAdapter() {});

上述三行代码就使得LoadingPanel能捕获所有的鼠标与键盘事件，并忽略掉它们。但仅仅如此还不够，在展示LoadingPanel时，数据面板中的某个UI组件很可能已经获得焦点了，那么用户仍然可以通过键盘操控数据面板中的组件(因为系统会把键盘事件发送给当前获取焦点的组件)。而且，即使数据面板中没有任何组件获得焦点，用户仍然可以通过Tab键把焦点转移到数据面板中的组件上。为了阻止这一操作，还需要加上如下几行代码，

addComponentListener(new ComponentAdapter() { // 一旦LoadingPanel可见，即获取焦点
    @Override
    public void componentShown(ComponentEvent e) {
        requestFocusInWindow();
    }
});
setFocusTraversalKeysEnabled(false); // 阻止用户转移焦点

2. 示例程序
在此处的示例程序中，数据面板(dataPanel)中仅有一个按钮，当点击该按钮时会显示loadingPanel，且模糊掉dataPanel，并会启动一个新的线程，该线程会在睡眠大约3秒(模拟耗时的数据加载工作)之后隐藏loadingPanel，且使dataPanel重新清晰可见。
值得注意的是，该示例程序使用了SwingX中的两个组件：JXPanel和StackLayout。JXPanel提供了一个方法(setAlpha)以方便地设置Panel的透明度(Alpha值)；而StackLayout允许在同一块区域内添加多层组件，并能同时展示所有层的组件(而，CardLayout一次只能显示某一层的组件)。完整的示例程序如下所示，

public class LoadDataDemo extends JFrame {

    private static final long serialVersionUID = 5927602404779391420L;

    private JXPanel dataPanel = null; // 使用org.jdesktop.swingx.JXPanel，以方便设置清晰度

    private LoadingPanel loadingPanel = null;

    public LoadDataDemo() {
        super("LoadData Demo");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        initUI();
    }

    private void initUI() {
        JButton button = new JButton("Load Data");
        button.addActionListener(handler);
        dataPanel = new JXPanel(new FlowLayout(FlowLayout.CENTER));
        dataPanel.add(button);

        loadingPanel = new LoadingPanel("Loading");

        // 使用org.jdesktop.swingx.StackLayout，将loadingPanel置于dataPanel的上方
        JPanel centerPanel = new JXPanel(new StackLayout());
        centerPanel.add(dataPanel, StackLayout.TOP);
        centerPanel.add(loadingPanel, StackLayout.TOP);

        Container container = getContentPane();
        container.setLayout(new BorderLayout());
        container.add(centerPanel, BorderLayout.CENTER);
    }

    transient private ActionListener handler = new ActionListener() {

        public void actionPerformed(ActionEvent e) {
            // 将dataPanel及其子组件的清晰度设置为50%；并显示loadingPanel
            dataPanel.setAlpha(0.5F);
            loadingPanel.setVisible(true);

            Thread thread = new Thread() {
                public void run() {
                    try {
                        Thread.sleep(3000L); // 睡眠约3秒钟，以模拟加载数据的过程
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 数据加载完毕后，重新隐藏loadingPanel；并使dataPanel及其子组件重新清晰可见
                    loadingPanel.setVisible(false);
                    dataPanel.setAlpha(1F);
                };
            };
            thread.start();
        }
    };

    public static void main(String[] args) {
        LoadDataDemo demo = new LoadDataDemo();
        demo.setSize(new Dimension(400, 300));
        demo.setVisible(true);
    }
}

3. 不使用SwingX
SwingX为我们提供了一系列功能强大，使用简易的Swing扩展组件，我强烈建议你去使用它。但若因故，你不准备使用它时，我们仍然有替代的解决方案，但此处仅简述一二。
[1]对于设置Alpha值，需要创建一个继承自JPanel的DataPanel类，覆写paintComponent方法，在其中使用Alpha合成，

Graphics2D.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));

[2]对于StackLayout，我们可以使用GlassPane(玻璃窗格)或LayeredPane(分层窗格)进行替换，将LoadingPanel设置为GlassPane或LayeredPanel中的一层。由于一个JFrame只有一个GlassPane，为了程序的灵活性，一般首选使用LayeredPane。

Sha Jiang 2009-11-29 20:33 发表评论

利用SwingX与TimingFramework实现淡入淡出(原)

Sha Jiang — Mon, 28 Sep 2009 01:46:00 GMT

利用SwingX与TimingFramework实现淡入淡出

本文使用SwingX与TimingFramework展示了如何实现淡入淡出效果，程序简洁实用，希望对大家能有所助益。(2009.09.28最后更新)

在Swing中使用AlphaComposite设置界面的半透明度，再配合javax.swing.Timer可以比较容易地实现淡入淡出效果。但需要我们继承具体的UI组件，并重写它的paintComponent方法，同时还要为Timer提供一个ActionListener的实现。这些对于程序员来说，显得有些乏味。
幸运地是，SwingX中的JXPanel(JPanel的子类)通过setAlpha方法来设置半透明度，JXPanel中的所有UI组件都可随之半透明化。TimingFramework提供的Animator可以帮助我们非线性地设置JXPanel中的alpha值。故，我们在实现淡入淡出时，可以使用JXPanel来替代JPanel，用Animator来替代Timer。

下面是一个非常简单的示例，该示例在一个使用CardLayout的JPanel--cardPanel，中另包含了两个JXPanel--panelA和panelB，这两个子容器中又分别有一个JButton--buttonA和buttonB。当点击buttonA时，将淡入显示panelB；当点击buttonB时，将淡入显示panelA。

1 public class FadingCardDemo extends JFrame {
2
3     private static final long serialVersionUID = 8005909309849021746L;
4
5     private String CARD_A = "CARD_A";
6     private String CARD_B = "CARD_B";
7
8     private JPanel cardPanel = null;
9     private JXPanel panelA = null;
10     private JXPanel panelB = null;
11     private JButton buttonA = null;
12     private JButton buttonB = null;
13
14     public FadingCardDemo() {
15         super("FadingButton Demo");
16         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
17         initUI();
18     }
19
20     private void initUI() {
21         cardPanel = new JPanel(new CardLayout());
22
23         buttonA = new JButton("Button A");
24         buttonA.addActionListener(actionHandler);
25         panelA = new JXPanel(new BorderLayout());
26         panelA.add(buttonA, BorderLayout.CENTER);
27         cardPanel.add(panelA, CARD_A);
28
29         buttonB = new JButton("Button B");
30         buttonB.addActionListener(actionHandler);
31         panelB = new JXPanel(new BorderLayout());
32         panelB.add(buttonB, BorderLayout.CENTER);
33         cardPanel.add(panelB, CARD_B);
34
35         Container container = getContentPane();
36         container.setLayout(new BorderLayout());
37         container.add(cardPanel, BorderLayout.CENTER);
38     }
39
40     private ActionListener actionHandler = new ActionListener() {
41
42         private Animator animator = null;
43
44         public void actionPerformed(ActionEvent e) {
45             if (animator == null) {
46                 animator = new Animator(2000);
47                 animator.setDeceleration(0.2F);
48                 animator.setAcceleration(0.4F);
49             } else if (animator.isRunning()) {
50                 animator.stop();
51             }
52
53             JButton button = (JButton) e.getSource();
54             if (button == buttonA) {
55                 animator.addTarget(new PropertySetter(panelB, "alpha", 1.0F));
56                 panelB.setAlpha(0.1F);
57                 ((CardLayout) cardPanel.getLayout()).show(cardPanel, CARD_B);
58             } else if (button == buttonB) {
59                 animator.addTarget(new PropertySetter(panelA, "alpha", 1.0F));
60                 panelA.setAlpha(0.1F);
61                 ((CardLayout) cardPanel.getLayout()).show(cardPanel, CARD_A);
62             }
63             animator.start();
64         }
65     };
66
67     public static void main(String[] args) {
68         SwingUtilities.invokeLater(new Runnable() {
69             public void run() {
70                 FadingCardDemo demo = new FadingCardDemo();
71                 demo.setSize(new Dimension(400, 300));
72                 demo.setVisible(true);
73             }
74         });
75     }
76 }

Sha Jiang 2009-09-28 09:46 发表评论

一个简单的CheckBox Tree实现(原)

Sha Jiang — Wed, 05 Aug 2009 13:10:00 GMT

一个简单的CheckBox Tree实现

CheckBox Tree是一个十分常用的UI组件，它能使用户方便地按特定规则勾选树中的节点。本文实现了一种简单的Checking规则：当勾选了某节点后，该节点的所有下级节点全部被勾选；当取消勾选某节点后，该节点的所有下级节点全部被取消勾选。(2009.08.05最后更新)

实现CheckBox Tree的常用方法，就是使用JCheckBox作为JTree的TreeCellRendrer，并且需要实现特定的Checking规则来勾选/取消勾选CheckBox。

1. 树节点
DefaultMutableTreeNode是最常用的TreeNode实现，此处我们将扩展这一实现--CheckBoxTreeNode，增加一个属性isChecked，用于标识该节点是否要被勾选上。该类的完整代码如下所示：

public class CheckBoxTreeNode extends DefaultMutableTreeNode {

       private static final long serialVersionUID = 3195314943599939279L;

       private boolean isChecked = false;

       public CheckBoxTreeNode(Object userObject) {
               super(userObject);
       }

       public boolean isChecked() {
               return isChecked;
       }

       public void setChecked(boolean isChecked) {
               this.isChecked = isChecked;
       }
}

2. 渲染器
如本文开头所述，我们将使用JCheckBox作为树节点展现形式的渲染器，同时确定对节点进行勾选或取消勾选的规则。CheckBoxTreeCellRenderer本身即是一个JCheckBox，那么在实现getTreeCellRendererComponent方法时，只简单地返回它自己的实例即可，而对于勾选或取消勾选的条件，则由CheckBoxTreeNode中的isChecked属性来确定，完整的代码如下所示：

public class CheckBoxTreeCellRenderer extends JCheckBox implements TreeCellRenderer {

       private static final long serialVersionUID = -6432020851855339311L;

       public CheckBoxTreeCellRenderer() {
               setOpaque(false);
       }

       public Component getTreeCellRendererComponent(JTree tree, Object value,
                       boolean selected, boolean expanded, boolean leaf, int row,
                       boolean hasFocus) {
               CheckBoxTreeNode node = ((CheckBoxTreeNode) value); // 获取树节点对象。
               setText(node.toString()); // 设置CheckBox所展示的文本。

               // 当树节点被设置为勾选时，则该节点对应的CheckBox被勾选上；否则，取消勾选。
               if (node.isChecked()) {
                       setSelected(true);
                       setForeground(Color.BLUE);
               } else {
                       setSelected(false);
                       setForeground(tree.getForeground());
               }
               return this;
       }
}

3. 树
此处对JTree进行扩展，创建CheckBoxTree，该类只是为JTree添加了一个MouseListener，以侦听鼠标选中树节点后，如何设置勾选标记，并重绘树。

public class CheckBoxTree extends JTree {

       private static final long serialVersionUID = -217950037507321241L;

       public CheckBoxTree(TreeModel newModel) {
               super(newModel);
               addCheckingListener();
       }

       private void addCheckingListener() {
               addMouseListener(new MouseAdapter() {

                       @Override
                       public void mousePressed(MouseEvent e) {
                               int row = getRowForLocation(e.getX(), e.getY());
                               TreePath treePath = getPathForRow(row);
                               if (treePath == null) {
                                       return;
                               }

                               CheckBoxTreeNode node = ((CheckBoxTreeNode) treePath.getLastPathComponent());
                               boolean checking = !node.isChecked(); // 如果该节点已被勾选上，则此次将取消勾选；反之，亦反。
                               checkNode(node, checking);

                               repaint(); // 重绘整棵树。
                       }

                       // 递归地勾选或取消勾选指定节点及其所有下级节点的CheckBox。
                       private void checkNode(CheckBoxTreeNode node, boolean checking) {
                               node.setChecked(checking);
                               if (!node.isLeaf()) {
                                       Enumeration<CheckBoxTreeNode> children = node.children();
                                       while (children.hasMoreElements()) {
                                               checkNode(children.nextElement(), checking);
                                       }
                               }
                       }
               });
       }
}

上述程序有两个关键点：1. 设置当前节点及其子节点的勾选标记--checkNode；2. 重绘树--repaint。调用repaint方法对树进行绘制时，方法TreeCellRenderer.getTreeCellRendererComponent就会被调用，此时程序就会根据checkNode方法设定的isChecked来勾选或取消勾选对应的树节点CheckBox。简言之，就是先设置树型数据中的勾选标记，然后渲染器再根据这些标记来渲染CheckBox。

Sha Jiang 2009-08-05 21:10 发表评论

判定一个点是否在三角形内(原)

Sha Jiang — Thu, 24 Jul 2008 09:02:00 GMT

判定一个点是否在三角形内

如何判定一个点P是否存在于指定的三角形ABC内，这肯定是一个简单的问题，本文仅用一个图形界面程序展示了该问题，有兴趣的朋友可以看看。(2008.07.24最后更新)

在此处使用一种常见且简便的方法：如果三角形PAB，PAC和PBC的面积之和与三角形ABC的面积相等，即可判定点P在三角形ABC内(包括在三条边上)。
可知，该方法的关键在于如何计算三角形的面积。幸运地是，当知道三角形顶点(A，B和C)的坐标((Ax, Ay)，(Bx, By)和(Cx, Cy))之后，即可计算出其面积：

S = |(Ax * By + Bx * Cy + Cx * Zy - Ay * Bx - By * Cx - Cy * Ax) / 2|

关键的代码如下，

// 由给定的三个顶点的坐标，计算三角形面积。
// Point(java.awt.Point)代表点的坐标。
private static double triangleArea(Point pos1, Point pos2, Point pos3) {
    double result = Math.abs((pos1.x * pos2.y + pos2.x * pos3.y + pos3.x * pos1.y
            - pos2.x * pos1.y - pos3.x * pos2.y - pos1.x * pos3.y) / 2.0D);
    return result;
}

// 判断点pos是否在指定的三角形内。
private static boolean inTriangle(Point pos, Point posA, Point posB,
        Point posC) {
    double triangleArea = triangleArea(posA, posB, posC);
    double area = triangleArea(pos, posA, posB);
    area += triangleArea(pos, posA, posC);
    area += triangleArea(pos, posB, posC);
    double epsilon = 0.0001;  // 由于浮点数的计算存在着误差，故指定一个足够小的数，用于判定两个面积是否(近似)相等。
    if (Math.abs(triangleArea - area) < epsilon) {
        return true;
    }
    return false;
}

执行该应用程序，用鼠标在其中点击三次，即可绘制一个三角形，如下组图所示：

然后仅需移动鼠标，就会出现一个空心圆圈。如果圆圈的中心在三角内(包含在三条边上)，则圆圈显示为红色；否则，显示为蓝色。如下组图所示：

完整代码如下：

public class CanvasPanel extends JPanel {

    private static final long serialVersionUID = -6665936180725885346L;

    private Point firstPoint = null;

    private Point secondPoint = null;

    private Point thirdPoint = null;

    public CanvasPanel() {
        setBackground(Color.WHITE);
        addMouseListener(mouseAdapter);
        addMouseMotionListener(mouseAdapter);
    }

    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        drawTriangel(g);
    }

    private void drawTriangel(Graphics g) {
        if (firstPoint != null && secondPoint != null) {
            g.drawLine(firstPoint.x, firstPoint.y, secondPoint.x, secondPoint.y);
            if (thirdPoint != null) {
                g.drawLine(firstPoint.x, firstPoint.y, thirdPoint.x, thirdPoint.y);
                g.drawLine(secondPoint.x, secondPoint.y, thirdPoint.x, thirdPoint.y);
            }
        }
    }

    private static boolean inTriangle(Point pos, Point posA, Point posB,
            Point posC) {
        double triangeArea = triangleArea(posA, posB, posC);
        double area = triangleArea(pos, posA, posB);
        area += triangleArea(pos, posA, posC);
        area += triangleArea(pos, posB, posC);
        double epsilon = 0.0001;
        if (Math.abs(triangeArea - area) < epsilon) {
            return true;
        }
        return false;
    }

    private static double triangleArea(Point pos1, Point pos2, Point pos3) {
        double result = Math.abs((pos1.x * pos2.y + pos2.x * pos3.y + pos3.x * pos1.y
                            - pos2.x * pos1.y - pos3.x * pos2.y - pos1.x * pos3.y) / 2.0D);
        return result;
    }

    private MouseInputAdapter mouseAdapter = new MouseInputAdapter() {

        public void mouseReleased(MouseEvent e) {
            Point pos = e.getPoint();
            if (firstPoint == null) {
                firstPoint = pos;
            } else if (secondPoint == null) {
                secondPoint = pos;
                Graphics g = CanvasPanel.this.getGraphics();
                CanvasPanel.this.paintComponent(g);
                g.drawLine(firstPoint.x, firstPoint.y, secondPoint.x, secondPoint.y);
            } else if (thirdPoint == null) {
                thirdPoint = pos;
                Graphics g = CanvasPanel.this.getGraphics();
                CanvasPanel.this.paintComponent(g);
                g.drawLine(firstPoint.x, firstPoint.y, secondPoint.x, secondPoint.y);
                g.drawLine(firstPoint.x, firstPoint.y, thirdPoint.x, thirdPoint.y);
                g.drawLine(secondPoint.x, secondPoint.y, thirdPoint.x, thirdPoint.y);
            }
        }

        public void mouseMoved(MouseEvent e) {
            Point pos = e.getPoint();
            Graphics2D g2 = (Graphics2D) CanvasPanel.this.getGraphics();
            CanvasPanel.this.paintComponent(g2);
            if (firstPoint != null && secondPoint == null) {
                g2.drawLine(firstPoint.x, firstPoint.y, pos.x, pos.y);
            } else if (firstPoint != null && secondPoint != null && thirdPoint == null) {
                g2.drawLine(firstPoint.x, firstPoint.y, pos.x, pos.y);
                g2.drawLine(secondPoint.x, secondPoint.y, pos.x, pos.y);
            } else if (firstPoint != null && secondPoint != null && thirdPoint != null) {
                if (inTriangle(pos, firstPoint, secondPoint, thirdPoint)) {
                    g2.setColor(Color.RED);
                } else {
                    g2.setColor(Color.BLUE);
                }
                int radius = 4;
                g2.drawOval(pos.x - radius, pos.y - radius, radius * 2, radius * 2);
            }
        }
    };
}

public class Triangle extends JFrame {

    private static final long serialVersionUID = 1L;

    private CanvasPanel mainPanel = null;

    public Triangle() {
        setTitle("Triangle");
        setSize(new Dimension(300, 200));
        setResizable(false);

        init();

        Container container = getContentPane();
        container.add(mainPanel);

        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setVisible(true);
    }

    private void init() {
        mainPanel = new CanvasPanel();
    }

    public static void main(String[] args) {
        new Triangle();
    }
}

Sha Jiang 2008-07-24 17:02 发表评论