Java Swing根据图片创建不规则窗体(二)

本来这篇文章是应该上午就写好的，可是写到一半，公司无线网络居然断掉了，郁闷.....

 

先来张效果图吧，这是仿CF界面做的一个Demo，因为个人没有美工能力，所以这个透明PNG图片处理的十分粗糙，导致窗体看起来有锯齿.

 

 

有了上一章做理论铺垫，这一章就直接上代码吧：

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package cn.ysh.studio.swing.window;

import com.sun.awt.AWTUtilities;
import java.awt.Image;
import java.awt.MediaTracker;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Shape;
import java.awt.Toolkit;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionAdapter;
import java.awt.geom.Area;
import java.awt.image.PixelGrabber;
import java.io.IOException;
import java.util.ArrayList;
import javax.swing.JFrame;

/**
 *
 * @author 杨胜寒
 */
public class CreateShape {

    private Image img;
    private JFrame jf;
    private Point origin;

    public CreateShape(JFrame jf, String image) throws InterruptedException, IOException {
        this.jf = jf;
        MediaTracker mt = new MediaTracker(jf);
        //获取指定图片
        img = Toolkit.getDefaultToolkit().getImage(getClass().getResource(image));
        mt.addImage(img, 0);
        //等待就绪
        mt.waitForAll();
        initialize(); //窗体初始化
    }

    private void initialize() throws IOException {
        //设定窗体大小和图片一样大
        jf.setSize(img.getWidth(null), img.getHeight(null));
        //设定禁用窗体装饰，这样就取消了默认的窗体结构
        jf.setUndecorated(true);
        //初始化用于移动窗体的原点
        origin = new Point();
        //调用AWTUtilities的setWindowShape方法设定本窗体为制定的Shape形状
        AWTUtilities.setWindowShape(jf, getImageShape(img));
        //设定窗体可见度
        AWTUtilities.setWindowOpacity(jf, 0.8f);
        jf.setLocationRelativeTo(null);
    }

    /**
     * 因为取消了默认的窗体结构，所以这里需要实现自定义的窗体鼠标监听
     */
    public void addDragLisener() {
        jf.addMouseListener(
                new MouseAdapter() {

                    @Override
                    public void mousePressed(MouseEvent e) {
                        origin.x = e.getX();
                        origin.y = e.getY();
                    }
                    //窗体上单击鼠标右键关闭程序

                    @Override
                    public void mouseClicked(MouseEvent e) {
                        if (e.getButton() == MouseEvent.BUTTON3) {
                            System.exit(0);
                        }
                    }

                    @Override
                    public void mouseReleased(MouseEvent e) {
                        super.mouseReleased(e);
                    }

                    @Override
                    public void mouseEntered(MouseEvent e) {
                        jf.repaint();
                    }
                });

        jf.addMouseMotionListener(
                new MouseMotionAdapter() {

                    @Override
                    public void mouseDragged(MouseEvent e) {
                        Point p = jf.getLocation();
                        jf.setLocation(p.x + e.getX() - origin.x, p.y + e.getY() - origin.y);
                    }
                });


    }

    public Shape getImageShape(Image img) {
        ArrayList<Integer> x = new ArrayList<Integer>();
        ArrayList<Integer> y = new ArrayList<Integer>();
        int width = img.getWidth(null);//图像宽度
        int height = img.getHeight(null);//图像高度

        //筛选像素
        //首先获取图像所有的像素信息
        PixelGrabber pgr = new PixelGrabber(img, 0, 0, -1, -1, true);
        try {
            pgr.grabPixels();
        } catch (InterruptedException ex) {
            ex.getStackTrace();
        }
        int pixels[] = (int[]) pgr.getPixels();
        for (int i = 0; i < pixels.length; i++) {
            //筛选，将不透明的像素的坐标加入到坐标ArrayList x和y中
            int alpha = getAlpha(pixels[i]);
            if (alpha == 0) {
                continue;
            } else {
                x.add(i % width > 0 ? i % width - 1 : 0);
                y.add(i % width == 0 ? (i == 0 ? 0 : i / width - 1) : i / width);
            }
        }
        int[][] matrix = new int[height][width];
        for (int i = 0; i < height; i++) {
            for (int j = 0; j < width; j++) {
                matrix[i][j] = 0;
            }
        }

        //导入坐标ArrayList中的不透明坐标信息
        for (int c = 0; c < x.size(); c++) {
            matrix[y.get(c)][x.get(c)] = 1;
        }

        Area rec = new Area();
        int temp = 0;

        for (int i = 0; i < height; i++) {
            for (int j = 0; j < width; j++) {
                if (matrix[i][j] == 1) {
                    if (temp == 0) {
                        temp = j;
                    } else if (j == width) {
                        if (temp == 0) {
                            Rectangle rectemp = new Rectangle(j, i, 1, 1);
                            rec.add(new Area(rectemp));
                        } else {
                            Rectangle rectemp = new Rectangle(temp, i, j - temp, 1);
                            rec.add(new Area(rectemp));
                            temp = 0;
                        }
                    }
                } else {
                    if (temp != 0) {
                        Rectangle rectemp = new Rectangle(temp, i, j - temp, 1);
                        rec.add(new Area(rectemp));
                        temp = 0;
                    }
                }
            }
            temp = 0;
        }
        return rec;
    }

    private int getAlpha(int pixel) {
        return (pixel >> 24) & 0xff;
    }
}

 

个人觉得注释写的还是蛮清楚的，在此也就不对程序代码做过多解释了，就简单说一下吧：

第一步，获取一个图片，作为裁切窗体的模板；

第二步，取消窗体默认装饰，并为其添加自定义鼠标监听，以实现常规的窗体拖动等事件；

第三步，扫描图片像素，分拣不透明像素，然后生成不规则形状，并以此裁切窗体；

第四步，设置窗体透明度，显示窗体

 

上述四步中，最值得说的是第三步:扫描图片像素矩阵信息，过滤透明像素，生成不规则区域，裁切窗体。

扫描像素矩阵：图片的像素信息的存储形式有点像一个矩阵(二维数组)，有规则的行和列，在java中，使用PixelGrabber类可以轻易获取一张图片的像素矩阵信息，但是通过getPixels()方法返回的像素信息却是一维数组，这一点要注意，稍后会详述；

过滤透明像素：从像素数组中一次检出每个像素，检查其是否透明，如果透明则放弃该像素点，够则将像素在矩阵(注意不是上面提到的一维数组)中的坐标信息记录到两个List中；

在内存中生成不规则形状：像素分拣之后，会得到两个长度相同的List，这两个List分别记录了非透明像素点在图片像素矩阵中的X坐标和Y坐标，这里需要将二者融合到一个二维数组中，融合之后的这个二维数组，跟原始的像素矩阵一样大小，不同的是，它的的所有点只有两个值：1或0,1代表非透明点，0代表透明点。有了这个“特殊”的像素矩阵之后，还要在内存中生成不规则形状，这个稍微有点饶，我尽量说的详细一点：程序会遍历这个二维数组，跟踪每一个非透明像素(值为非0)点直到遇到一个透明点或这一行结束(简单点说，就是在每一行中检出连续的非透明点)，然后基于这些点，构建一个"区域"，java中由Rectangle和Area类负责构建这个"区域"，最后将这些连续的或不连续的非透明块组合起来生成一个Area对象，即大功告成，成功在内存中生成了图片的形状！

裁切窗体：这个就简单了，Java Swing自带的有API接口，非常简单

AWTUtilities.setWindowShape(jf, getImageShape(img));

 有兴趣的童鞋可以看看setWindowShape(Window window, Shape shape)方法的API。

 

使用上面这个类来成为一个指定的JFrame裁切形状就非常简单啦，看代码：

 

JFrame sample = new ShapWindowTest();
sample.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
sample.setVisible(true);
sample.setTitle("Java Swing 不规则窗体范例");

 

原创文章，转载请注明出处: http://www.yshjava.cn/post/324.html