Java根据图片建立不规则窗体详解

JAVA程序的外表总是一板一眼的，看多了难免审美疲劳，能不能使我们的JAVA程序外观变得更美观更独特呢？答案是肯定的，我们可以让JAVA程序根据图片来生成自定义的不规则窗体。比如下图的这种外观：

图中的这个人物(蕾米莉亚)便是定义好的不规则窗体，怎么样？很漂亮吧！那么让我们开始学习吧。

    首先要说明一下，本方法是基于com.sun.awt.AWTUtilities这个类实现的，而这个类只能在jdk-6u10版本以后的版本才能体现出来的，在本文中讨论的所有 API 在新 com.sun.awt.AWTUtilities 类中出现，该类不是官方支持的部分 API。它在 Java SE 7 中的位置最有可能发生改变，签名方法可能在现在和最终的 Consumer JRE 发行之间发生轻微变化。 

所以当你的JDK版本不匹配的时候需要你将JDK插件更新。 
地址: http://java.sun.com/javase/downloads/index.jsp

=================================================================
     
好了，准备工作妥当，下面就让我们通过代码来学习根据图片制作不规则窗体的方法。

IrregularFormSample.java

import java.awt.Graphics;
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;
import com.sun.awt.AWTUtilities;

/**
* 不规则窗体示例
* @author Hexen
*/
public class IrregularFormSample extends JFrame {

   private static final long serialVersionUID = 1L;
   private Point origin; //用于移动窗体
   private Image img; //用来设定窗体不规则样式的图片

   public IrregularFormSample() {
     super();
    
     /* 首先初始化一张图片，我们可以选择一张有透明部分的不规则图片
     * (当然我们要选择支持Alpha(透明)层的图片格式，如PNG)，这张
     * 图片将被用来生成与其形状相同的不规则窗体
    */
    MediaTracker mt= new MediaTracker( this);
    img=Toolkit.getDefaultToolkit().createImage( "remi.png");
    mt.addImage(img, 0);
     try {
      mt.waitForAll();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    
     try {
      initialize(); //窗体初始化
    } catch (IOException e) {
      e.printStackTrace();
    }    
  }

  
   /**
    * 窗体初始化
    * @throws IOException
    */
   private void initialize() throws IOException {
     //设定窗体大小和图片一样大
     this.setSize(img.getWidth( null), img.getHeight( null));
     //设定禁用窗体装饰，这样就取消了默认的窗体结构
     this.setUndecorated( true);
     //初始化用于移动窗体的原点
     this.origin= new Point();
    
     //调用AWTUtilities的setWindowShape方法设定本窗体为制定的Shape形状
    AWTUtilities.setWindowShape( this,getImageShape(img));        
     //设定窗体可见度
    AWTUtilities.setWindowOpacity( this, 0.8f);
    
     this.setLocationRelativeTo( null);
    
     //由于取消了默认的窗体结构，所以我们要手动设置一下移动窗体的方法
    addMouseListener(
         new MouseAdapter(){
           public void mousePressed(MouseEvent e){
            origin.x = e.getX();
            origin.y = e.getY();
          }
           //窗体上单击鼠标右键关闭程序
           public void mouseClicked(MouseEvent e) {
             if(e.getButton()==MouseEvent.BUTTON3)
              System.exit(0);
          }
           public void mouseReleased(MouseEvent e) {
             super.mouseReleased(e);
          }
          @Override
           public void mouseEntered(MouseEvent e) {
            repaint();              
          }            
        }
    );

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

  
   /**
    * 将Image图像转换为Shape图形
    * @param img
    * @param isFiltrate
    * @return Image图像的Shape图形表示
    * @author Hexen
    */
   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);
      }      
    }
    
     //建立图像矩阵并初始化(0为透明,1为不透明)
     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类所表示区域可以进行合并，我们逐一水平"扫描"图像矩阵的每一行，
     * 将不透明的像素生成为Rectangle，再将每一行的Rectangle通过Area类的rec
     * 对象进行合并，最后形成一个完整的Shape图形
     */
    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;
  }

  
   /**
    * 获取像素的Alpha值
    * @param pixel
    * @return 像素的Alpha值
    */
   private int getAlpha( int pixel) {
     return (pixel >> 24) & 0xff;
  }
  
  
   /* 我们可以选择在窗体上绘制图片，是窗体完全呈现出图片的样式，
    * 当然我们也可以根据需要不绘制它，而采取其他操作
    */
  @Override
   public void paint(Graphics g) {
     super.paint(g);
    g.drawImage(img, 0, 0, null);
  }
  
   public static void main(String[] args) {
        IrregularFormSample sample = new IrregularFormSample();
        sample.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        sample.setVisible( true);
  }  
}

使用这种方法，我们可以自由的定义窗体外观，使我们的JAVA程序更加美观。现在就去尝试一下吧！