探秘JDK7之二：半透明和任意形状的窗口

昨天为大家带来了“探秘JDK 7：将会出现新的语言特性”，今天我们从Java SE 6u10(Build 12)开始和大家探讨一下Java引入的com.sun.awt.AWTUtilities类提供半透明和任意形状窗口的支持，这是个临时类，因为6u10不是一个Java SE主版本，没有提供抽象窗口工具集API(Abstract Window Toolkit API，AWT API)，也没有修改现有API。在JDK 7中，AWTUtilities类将不复存在，AWT类也做了许多改变，以更好地支持半透明和任意形状的窗口，本文将为大家介绍一下JDK 7中提供的3种半透明窗口，另外也会涉及到任意形状窗口的介绍。

创新互联公司主要从事网站建设、网站制作、网页设计、企业做网站、公司建网站等业务。立足成都服务向阳,10多年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:028-86922220

简单的半透明窗口

简单的半透明窗口就是透明度均匀分布的窗口，所有像素的不透明度值都一样，这个值越小，窗口越透明，达到最小值时，窗口就是完全透明的了，相反，如果值越大则越不透明。

JDK 7给java.awt.Window类增加了public void setOpacity(float opacity)和public float getOpacity()两个方法来实现简单的半透明窗口效果，前一个方法需要一个不透明度参数，其取值范围是0.0(完全透明)-1.0(完全不透明)。

在窗口上调用setOpacity()方法激活其简单半透明效果，注意指定的参数值不能小于0.0，也不能大于1.0，否则setOpacity()会抛出一个IllegalArgumentException异常。

如果窗口处于全屏模式且不透明度值小于1.0，setOpacity()方法会抛出一个java.awt.IllegalComponentStateException异常，如果不支持简单透明度且不透明度值小于1.0，它会抛出UnsupportedOperationException异常。

java.awt.GraphicsDevice类提供了一个public Window getFullScreenWindow()方法确定窗口是否处于全屏模式，这个类也提供了一个public boolean isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency translucencyKind)方法确定当前的显示设备是否支持简单透明效果，如果显示设备支持这个方法参数指定的半透明效果，isWindowTranslucencySupported()就返回True，对于简单半透明效果，这个方法的参数必须是GraphicsDevice.WindowTranslucency.TRANSLUCENT，如下所示：

 
 
 
 
    
  
  
  
  
  1. GraphicsEnvironment ge; 
    2. 
  
  
  
  
  2. ge = GraphicsEnvironment.getLocalGraphicsEnvironment (); 
    3. 
  
  
  
  
  3. if (!ge.getDefaultScreenDevice (). 
    4. 
  
  
  
  
  4.         isWindowTranslucencySupported (GraphicsDevice.WindowTranslucency.TRANSLUCENT)) 
    5. 
  
  
  
  
  5. { 
    6. 
  
  
  
  
  6.     System.err.println ("simple translucency isn't supported"); 
    7. 
  
  
  
  
  7.     return; 
    8. 
  
  
  
  
  8. }
    9.

我创建了一个STDemo程序演示简单半透明效果，使用滑块调节框架窗口的透明度，清单1显示了这个程序的源代码。

清单1. STDemo.java

 
 
 
 
    
  
  
  
  
  1. // STDemo.java 
    2. 
  
  
  
  
  2. import java.awt.EventQueue; 
    3. 
  
  
  
  
  3. import java.awt.FlowLayout; 
    4. 
  
  
  
  
  4. import java.awt.GraphicsDevice; 
    5. 
  
  
  
  
  5. import java.awt.GraphicsEnvironment; 
    6. 
  
  
  
  
  6. import javax.swing.JFrame; 
    7. 
  
  
  
  
  7. import javax.swing.JLabel; 
    8. 
  
  
  
  
  8. import javax.swing.JPanel; 
    9. 
  
  
  
  
  9. import javax.swing.JSlider; 
    10. 
  
  
  
  
  10. import javax.swing.event.ChangeEvent; 
    11. 
  
  
  
  
  11. import javax.swing.event.ChangeListener; 
    12. 
  
  
  
  
  12. public class STDemo extends JFrame 
    13. 
  
  
  
  
  13. { 
    14. 
  
  
  
  
  14.    public STDemo () 
    15. 
  
  
  
  
  15.    { 
    16. 
  
  
  
  
  16.       super ("Simple Translucency Demo"); 
    17. 
  
  
  
  
  17.       setDefaultCloseOperation (EXIT_ON_CLOSE); 
    18. 
  
  
  
  
  18.       final JSlider slider = new JSlider (0, 100, 100); 
    19. 
  
  
  
  
  19.       ChangeListener cl; 
    20. 
  
  
  
  
  20.       cl = new ChangeListener () 
    21. 
  
  
  
  
  21.            { 
    22. 
  
  
  
  
  22.                public void stateChanged (ChangeEvent ce) 
    23. 
  
  
  
  
  23.                {     
    24. 
  
  
  
  
  24.                   JSlider source = (JSlider) ce.getSource (); 
    25. 
  
  
  
  
  25.                   STDemo.this.setOpacity (source.getValue ()/100.0f); 
    26. 
  
  
  
  
  26.                } 
    27. 
  
  
  
  
  27.            }; 
    28. 
  
  
  
  
  28.       slider.addChangeListener (cl); 
    29. 
  
  
  
  
  29.       getContentPane ().setLayout (new FlowLayout ()); 
    30. 
  
  
  
  
  30.       getContentPane ().add (new JLabel ("TRANSP")); 
    31. 
  
  
  
  
  31.       getContentPane ().add (new JPanel () {{ add (slider); }}); 
    32. 
  
  
  
  
  32.       getContentPane ().add (new JLabel ("OPAQUE")); 
    33. 
  
  
  
  
  33.       getRootPane ().setDoubleBuffered (false); 
    34. 
  
  
  
  
  34.       pack (); 
    35. 
  
  
  
  
  35.       setVisible (true); 
    36. 
  
  
  
  
  36.    } 
    37. 
  
  
  
  
  37.    public static void main (String [] args) 
    38. 
  
  
  
  
  38.    { 
    39. 
  
  
  
  
  39.       Runnable r; 
    40. 
  
  
  
  
  40.       r = new Runnable () 
    41. 
  
  
  
  
  41.           { 
    42. 
  
  
  
  
  42.               public void run () 
    43. 
  
  
  
  
  43.               { 
    44. 
  
  
  
  
  44.                  GraphicsEnvironment ge; 
    45. 
  
  
  
  
  45.                  ge = GraphicsEnvironment.getLocalGraphicsEnvironment (); 
    46. 
  
  
  
  
  46.                  if (!ge.getDefaultScreenDevice (). 
    47. 
  
  
  
  
  47.                          isWindowTranslucencySupported 
    48. 
  
  
  
  
  48.                            (GraphicsDevice.WindowTranslucency. 
    49. 
  
  
  
  
  49.                                            TRANSLUCENT)) 
    50. 
  
  
  
  
  50.                  { 
    51. 
  
  
  
  
  51.                      System.err.println ("simple translucency isn't "+ 
    52. 
  
  
  
  
  52.                                          "supported"); 
    53. 
  
  
  
  
  53.                      return; 
    54. 
  
  
  
  
  54.                  } 
    55. 
  
  
  
  
  55.                  new STDemo (); 
    56. 
  
  
  
  
  56.               } 
    57. 
  
  
  
  
  57.           }; 
    58. 
  
  
  
  
  58.       EventQueue.invokeLater (r); 
    59. 
  
  
  
  
  59.    } 
    60. 
  
  
  
  
  60. } 
    61. 
  
  
  
  
  61.

上面的代码创建了一个滑块，为该组件注册了一个变化监听器，当滑块组件移动时，这个组件触发变化事件，监听器调用setOpacity()，参数就使用滑块的当前值。

上面的代码使用new JPanel () {{ add (slider); }}创建了一个Swing面板，并在面板上添加了一个滑块组件，从本质上讲，这个快捷方式是先实例化JPanel的一个子类，然后用这个子类的实例初始化滑块组件。

Swing组件的双倍缓存可以制造出意想不到的视觉效果，当你拖动滑块使窗口完全透明时，你将只能看到滑块本身，但清单1中的代码通过getRootPane ().setDoubleBuffered (false);禁用了双倍缓存。

编译并运行STDemo，移动滑块就能看到简单半透明窗口效果了，如图1所示。

图 1 窗口及其内容全部处于均匀透明的状态

#p#

像素级半透明窗口

像素级半透明允许你控制窗口中每个像素的不透明度，这样就可以营造出窗口的一部分比另一部分更透明的效果，虽然像素级半透明也可以实现窗口透明度均匀，但与简单半透明方法比起来，它更占资源。

JDK 7通过修改Window的public void setBackground(Color bgColor)方法，检查参数的alpha部分提供像素级半透明效果的支持，如果alpha不等于1.0(窗口不透明)，在窗口上绘制每个像素时将会使用alpha值。

真实的半透明级别

绘制像素时使用的真实半透明值也依赖于传递给Window的setOpacity()方法的值，以及Window的当前形状。

如果窗口处于全屏模式且背景色的alpha值小于1.0，这个方法将会抛出IllegalComponentStateException异常，如果不支持像素级半透明且alpha值小于1.0，将会抛出UnsupportedOperationException异常。

为了避免后一个异常，调用GraphicsDevice's isWindowTranslucencySupported()方法时，参数必须使用GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSLUCENT，并检查返回的值，如下所示：

 
 
 
 
    
  
  
  
  
  1. GraphicsEnvironment ge; 
    2. 
  
  
  
  
  2. ge = GraphicsEnvironment.getLocalGraphicsEnvironment (); 
    3. 
  
  
  
  
  3. if (!ge.getDefaultScreenDevice (). 
    4. 
  
  
  
  
  4.         isWindowTranslucencySupported (GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSLUCENT)) 
    5. 
  
  
  
  
  5. { 
    6. 
  
  
  
  
  6.     System.err.println ("per-pixel translucency isn't supported"); 
    7. 
  
  
  
  
  7.     return; 
    8. 
  
  
  
  
  8. }
    9.

另外，确定窗口本身是否支持像素级半透明效果也很重要，可调用java.awt.GraphicsConfiguration's public Boolean isTranslucencyCapable()方法来判断，如果支持的话，这个方法返回Ture，如下所示：

 
 
 
 
    
  
  
  
  
  1. / The following code fragment continues from the previous code fragment, but assumes that  
    2. 
  
  
  
  
  2. // the current class is a descendent of java.awt.Window. 
    3. 
  
  
  
  
  3. if (!getGraphicsConfiguration ().isTranslucencyCapable ()) 
    4. 
  
  
  
  
  4. { 
    5. 
  
  
  
  
  5.     System.err.println ("per-pixel translucency not in effect for this graphics configuration"); 
    6. 
  
  
  
  
  6.     System.exit (0); 
    7. 
  
  
  
  
  7. } 
    8. 
  
  
  
  
  8.

如果你想确定当前背景色的alpha，可调用Window的public Color getBackground()方法，你也可以调用新的public boolean isOpaque()方法确定窗口当前是否是不透明的(返回True)。

我创建了一个PPTDemo程序演示像素级半透明窗口，清单2显示了它的代码，因为这个窗口是未加装饰的，你需要点击它的关闭按钮来终止它。

清单2. PPTDemo.java

 
 
 
 
    
  
  
  
  
  1. // PPTDemo.java 
    2. 
  
  
  
  
  2. import java.awt.Color; 
    3. 
  
  
  
  
  3. import java.awt.Dimension; 
    4. 
  
  
  
  
  4. import java.awt.EventQueue; 
    5. 
  
  
  
  
  5. import java.awt.GradientPaint; 
    6. 
  
  
  
  
  6. import java.awt.Graphics; 
    7. 
  
  
  
  
  7. import java.awt.Graphics2D; 
    8. 
  
  
  
  
  8. import java.awt.GraphicsDevice; 
    9. 
  
  
  
  
  9. import java.awt.GraphicsEnvironment; 
    10. 
  
  
  
  
  10. import java.awt.event.ActionEvent; 
    11. 
  
  
  
  
  11. import java.awt.event.ActionListener; 
    12. 
  
  
  
  
  12. import javax.swing.Box; 
    13. 
  
  
  
  
  13. import javax.swing.BoxLayout; 
    14. 
  
  
  
  
  14. import javax.swing.JButton; 
    15. 
  
  
  
  
  15. import javax.swing.JFrame; 
    16. 
  
  
  
  
  16. import javax.swing.JPanel; 
    17. 
  
  
  
  
  17. public class PPTDemo extends JFrame 
    18. 
  
  
  
  
  18. { 
    19. 
  
  
  
  
  19.    public PPTDemo () 
    20. 
  
  
  
  
  20.    { 
    21. 
  
  
  
  
  21.       super ("Per-Pixel Translucency Demo"); 
    22. 
  
  
  
  
  22.       JPanel gradPanel = new JPanel () 
    23. 
  
  
  
  
  23.                          { 
    24. 
  
  
  
  
  24.                              // Transparent red 
    25. 
  
  
  
  
  25.                              Color colorA = new Color (255, 0, 0, 0); 
    26. 
  
  
  
  
  26.                              // Solid red 
    27. 
  
  
  
  
  27.                              Color colorB = new Color (255, 0, 0, 255); 
    28. 
  
  
  
  
  28.                              protected void paintComponent (Graphics g) 
    29. 
  
  
  
  
  29.                              { 
    30. 
  
  
  
  
  30.                                  Graphics2D g2d = (Graphics2D) g; 
    31. 
  
  
  
  
  31.                                  GradientPaint gp; 
    32. 
  
  
  
  
  32.                                  gp = new GradientPaint (0.0f, 0.0f, colorA, 
    33. 
  
  
  
  
  33.                                                          0.0f, getHeight (), 
    34. 
  
  
  
  
  34.                                                          colorB, true); 
    35. 
  
  
  
  
  35.                                  g2d.setPaint (gp); 
    36. 
  
  
  
  
  36.                                  g2d.fillRect (0, 0, getWidth (), 
    37. 
  
  
  
  
  37.                                                getHeight ()); 
    38. 
  
  
  
  
  38.                                   
    39. 
  
  
  
  
  39.                              } 
    40. 
  
  
  
  
  40.                          }; 
    41. 
  
  
  
  
  41.       gradPanel.setPreferredSize (new Dimension (300, 200)); 
    42. 
  
  
  
  
  42.       gradPanel.setLayout (new BoxLayout (gradPanel, BoxLayout.Y_AXIS)); 
    43. 
  
  
  
  
  43.       JButton btnClose = new JButton ("Close"); 
    44. 
  
  
  
  
  44.       ActionListener al; 
    45. 
  
  
  
  
  45.       al = new ActionListener () 
    46. 
  
  
  
  
  46.            { 
    47. 
  
  
  
  
  47.                public void actionPerformed (ActionEvent ae) 
    48. 
  
  
  
  
  48.                { 
    49. 
  
  
  
  
  49.                   System.exit (0); 
    50. 
  
  
  
  
  50.                } 
    51. 
  
  
  
  
  51.            }; 
    52. 
  
  
  
  
  52.       btnClose.addActionListener (al); 
    53. 
  
  
  
  
  53.       btnClose.setAlignmentX (0.5f); 
    54. 
  
  
  
  
  54.       gradPanel.add (Box.createVerticalGlue ()); 
    55. 
  
  
  
  
  55.       gradPanel.add (btnClose); 
    56. 
  
  
  
  
  56.       gradPanel.add (Box.createVerticalGlue ()); 
    57. 
  
  
  
  
  57.       setContentPane (gradPanel); 
    58. 
  
  
  
  
  58.       if (!getGraphicsConfiguration ().isTranslucencyCapable ()) 
    59. 
  
  
  
  
  59.       { 
    60. 
  
  
  
  
  60.           System.err.println ("per-pixel translucency not in effect for "+ 
    61. 
  
  
  
  
  61.                               "this graphics configuration"); 
    62. 
  
  
  
  
  62.           System.exit (0); 
    63. 
  
  
  
  
  63.       } 
    64. 
  
  
  
  
  64.       setBackground (new Color (0, 0, 0, 0)); // Achieve per-pixel 
    65. 
  
  
  
  
  65.                                               // translucency. 
    66. 
  
  
  
  
  66.       pack (); 
    67. 
  
  
  
  
  67.       setLocationRelativeTo (null); 
    68. 
  
  
  
  
  68.       setVisible (true); 
    69. 
  
  
  
  
  69.    } 
    70. 
  
  
  
  
  70.    public static void main (String [] args) 
    71. 
  
  
  
  
  71.    { 
    72. 
  
  
  
  
  72.       Runnable r; 
    73. 
  
  
  
  
  73.       r = new Runnable () 
    74. 
  
  
  
  
  74.           { 
    75. 
  
  
  
  
  75.               public void run () 
    76. 
  
  
  
  
  76.               { 
    77. 
  
  
  
  
  77.                  GraphicsEnvironment ge; 
    78. 
  
  
  
  
  78.                  ge = GraphicsEnvironment.getLocalGraphicsEnvironment (); 
    79. 
  
  
  
  
  79.                  if (!ge.getDefaultScreenDevice (). 
    80. 
  
  
  
  
  80.                          isWindowTranslucencySupported 
    81. 
  
  
  
  
  81.                            (GraphicsDevice.WindowTranslucency. 
    82. 
  
  
  
  
  82.                                            PERPIXEL_TRANSLUCENT)) 
    83. 
  
  
  
  
  83.                  { 
    84. 
  
  
  
  
  84.                      System.err.println ("per-pixel translucency isn't "+ 
    85. 
  
  
  
  
  85.                                          "supported"); 
    86. 
  
  
  
  
  86.                      return; 
    87. 
  
  
  
  
  87.                  } 
    88. 
  
  
  
  
  88.                  new PPTDemo (); 
    89. 
  
  
  
  
  89.               } 
    90. 
  
  
  
  
  90.           }; 
    91. 
  
  
  
  
  91.       EventQueue.invokeLater (r); 
    92. 
  
  
  
  
  92.    } 
    93. 
  
  
  
  
  93. }
    94.

上面的代码显示了用JPanel类创建了两个java.awt.Color对象，alpha值为0时透明，为255时不透明，它的paintComponent()方法和java.awt.GradientPaint一起给面板的表面涂上了一层梯度式alpha值。

后面的代码将这个面板作为框架窗口的内容面板，并验证窗口的图形配置是否支持像素级半透明，最后调用setBackground()方法开启像素级半透明窗口效果。

调整窗口的大小后，清单2中的代码调用setLocationRelativeTo(null)让面板在屏幕上居中，接着调用setVisible(true)方法控制面板的半透明显示：上方透明，下方不透明，中间半透明，如图2所示。

图 2 从上到下，透明度不断减小

#p#

像素级透明和任意形状的窗口

像素级透明和像素级半透明类似，这种半透明模式主要用于任意形状窗口中的内容。

任意形状窗口是未加装饰的窗口，其外观与特定几何形状一致(如圆，圆角矩形等)，形状外的像素是透明的，在这些像素上点击才显示背景。

JDK 7通过向Window增加public void setShape(Shape shape)和public Shape getShape()方法支持像素级透明和任意形状的窗口，向前一个方法传递一个java.awt.Shape实例给当前窗口指定一个形状。

如果窗口处于全屏模式且传递来一个非空形状时，setShape()方法会抛出IllegalComponentStateException异常，如果不支持像素级透明且传递来一个非空形状时，抛出UnsupportedOperationException异常。

为了避免后一个异常，调用GraphicsDevice's isWindowTranslucencySupported()方法时，参数必须使用raphicsDevice.WindowTranslucency.PERPIXEL_TRANSPARENT，并检查返回的值，如下所示：

 
 
 
 
    
  
  
  
  
  1. GraphicsEnvironment ge; 
    2. 
  
  
  
  
  2. ge = GraphicsEnvironment.getLocalGraphicsEnvironment (); 
    3. 
  
  
  
  
  3. if (!ge.getDefaultScreenDevice (). 
    4. 
  
  
  
  
  4.         isWindowTranslucencySupported (GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSPARENT)) 
    5. 
  
  
  
  
  5. { 
    6. 
  
  
  
  
  6.     System.err.println ("per-pixel transparency isn't supported"); 
    7. 
  
  
  
  
  7.     return; 
    8. 
  
  
  
  
  8. }
    9.

我创建了一个PPTSWDemo程序演示像素级透明和任意形状的窗口，我们将清单2中显示出来的圆角矩形改成椭圆形状，清单3显示了这个程序的源代码。

清单3. PPTSWDemo.java

 
 
 
 
    
  
  
  
  
  1. // PPTSWDemo.java 
    2. 
  
  
  
  
  2. import java.awt.Color; 
    3. 
  
  
  
  
  3. import java.awt.Dimension; 
    4. 
  
  
  
  
  4. import java.awt.EventQueue; 
    5. 
  
  
  
  
  5. import java.awt.GradientPaint; 
    6. 
  
  
  
  
  6. import java.awt.Graphics; 
    7. 
  
  
  
  
  7. import java.awt.Graphics2D; 
    8. 
  
  
  
  
  8. import java.awt.GraphicsDevice; 
    9. 
  
  
  
  
  9. import java.awt.GraphicsEnvironment; 
    10. 
  
  
  
  
  10. import java.awt.Shape; 
    11. 
  
  
  
  
  11. import java.awt.event.ActionEvent; 
    12. 
  
  
  
  
  12. import java.awt.event.ActionListener; 
    13. 
  
  
  
  
  13. import java.awt.geom.Ellipse2D; 
    14. 
  
  
  
  
  14. import javax.swing.Box; 
    15. 
  
  
  
  
  15. import javax.swing.BoxLayout; 
    16. 
  
  
  
  
  16. import javax.swing.JButton; 
    17. 
  
  
  
  
  17. import javax.swing.JFrame; 
    18. 
  
  
  
  
  18. import javax.swing.JPanel; 
    19. 
  
  
  
  
  19. public class PPTSWDemo extends JFrame 
    20. 
  
  
  
  
  20. { 
    21. 
  
  
  
  
  21.    public PPTSWDemo () 
    22. 
  
  
  
  
  22.    { 
    23. 
  
  
  
  
  23.       super ("Per-Pixel Transparency and Shaped Window Demo"); 
    24. 
  
  
  
  
  24.       setUndecorated (true); // Avoid decorated window artifacts. 
    25. 
  
  
  
  
  25.       JPanel gradPanel = new JPanel () 
    26. 
  
  
  
  
  26.                          { 
    27. 
  
  
  
  
  27.                              // Solid white 
    28. 
  
  
  
  
  28.                              Color colorA = new Color (255, 255, 255); 
    29. 
  
  
  
  
  29.                              // Solid red 
    30. 
  
  
  
  
  30.                              Color colorB = new Color (255, 0, 0); 
    31. 
  
  
  
  
  31.                              protected void paintComponent (Graphics g) 
    32. 
  
  
  
  
  32.                              { 
    33. 
  
  
  
  
  33.                                  Graphics2D g2d = (Graphics2D) g; 
    34. 
  
  
  
  
  34.                                  GradientPaint gp; 
    35. 
  
  
  
  
  35.                                  gp = new GradientPaint (0.0f, 0.0f, colorA, 
    36. 
  
  
  
  
  36.                                                          0.0f, getHeight (), 
    37. 
  
  
  
  
  37.                                                          colorB, true); 
    38. 
  
  
  
  
  38.                                  g2d.setPaint (gp); 
    39. 
  
  
  
  
  39.                                  g2d.fillRect (0, 0, getWidth (), 
    40. 
  
  
  
  
  40.                                                getHeight ()); 
    41. 
  
  
  
  
  41.                                   
    42. 
  
  
  
  
  42.                              } 
    43. 
  
  
  
  
  43.                          }; 
    44. 
  
  
  
  
  44.       gradPanel.setPreferredSize (new Dimension (300, 200)); 
    45. 
  
  
  
  
  45.       gradPanel.setLayout (new BoxLayout (gradPanel, BoxLayout.Y_AXIS)); 
    46. 
  
  
  
  
  46.       JButton btnClose = new JButton ("Close"); 
    47. 
  
  
  
  
  47.       ActionListener al; 
    48. 
  
  
  
  
  48.       al = new ActionListener () 
    49. 
  
  
  
  
  49.            { 
    50. 
  
  
  
  
  50.                public void actionPerformed (ActionEvent ae) 
    51. 
  
  
  
  
  51.                { 
    52. 
  
  
  
  
  52.                   System.exit (0); 
    53. 
  
  
  
  
  53.                } 
    54. 
  
  
  
  
  54.            }; 
    55. 
  
  
  
  
  55.       btnClose.addActionListener (al); 
    56. 
  
  
  
  
  56.       btnClose.setAlignmentX (0.5f); 
    57. 
  
  
  
  
  57.       gradPanel.add (Box.createVerticalGlue ()); 
    58. 
  
  
  
  
  58.       gradPanel.add (btnClose); 
    59. 
  
  
  
  
  59.       gradPanel.add (Box.createVerticalGlue ()); 
    60. 
  
  
  
  
  60.       setContentPane (gradPanel); 
    61. 
  
  
  
  
  61.       pack (); 
    62. 
  
  
  
  
  62.       setShape (new Ellipse2D.Float (0, 0, getWidth (), getHeight ())); 
    63. 
  
  
  
  
  63.       setLocationRelativeTo (null); 
    64. 
  
  
  
  
  64.       setVisible (true); 
    65. 
  
  
  
  
  65.    } 
    66. 
  
  
  
  
  66.    public static void main (String [] args) 
    67. 
  
  
  
  
  67.    { 
    68. 
  
  
  
  
  68.       Runnable r; 
    69. 
  
  
  
  
  69.       r = new Runnable () 
    70. 
  
  
  
  
  70.           { 
    71. 
  
  
  
  
  71.               public void run () 
    72. 
  
  
  
  
  72.               { 
    73. 
  
  
  
  
  73.                  GraphicsEnvironment ge; 
    74. 
  
  
  
  
  74.                  ge = GraphicsEnvironment.getLocalGraphicsEnvironment (); 
    75. 
  
  
  
  
  75.                  if (!ge.getDefaultScreenDevice (). 
    76. 
  
  
  
  
  76.                          isWindowTranslucencySupported 
    77. 
  
  
  
  
  77.                            (GraphicsDevice.WindowTranslucency. 
    78. 
  
  
  
  
  78.                                            PERPIXEL_TRANSPARENT)) 
    79. 
  
  
  
  
  79.                  { 
    80. 
  
  
  
  
  80.                      System.err.println ("per-pixel transparency isn't "+ 
    81. 
  
  
  
  
  81.                                          "supported"); 
    82. 
  
  
  
  
  82.                      return; 
    83. 
  
  
  
  
  83.                  } 
    84. 
  
  
  
  
  84.                  new PPTSWDemo (); 
    85. 
  
  
  
  
  85.               } 
    86. 
  
  
  
  
  86.           }; 
    87. 
  
  
  
  
  87.       EventQueue.invokeLater (r); 
    88. 
  
  
  
  
  88.    } 
    89. 
  
  
  
  
  89. }
    90.

在验证了支持像素级透明后，清单3执行setShape (new Ellipse2D.Float (0, 0, getWidth (), getHeight ()));将框架窗口改成椭圆形，效果如图3所示。

图 3 梯度式透明现在限制在椭圆范围内

遗憾的是，任意形状窗口的边缘有锯齿，也许等到JDK 7正式发布，使用像素级半透明和抗锯齿功能可以解决掉这个问题。

#p#

半透明联合像素级透明和任意形状窗口

你可以联合像素级半透明(或简单半透明)和像素级透明实现一个半透明的任意形状窗口，我创建了一个CTSWDemo程序演示这是可能的，清单4中的代码扩展了前面的例子，包括了像素级半透明代码。

清单 4. CTSWDemo.java

 
 
 
 
    
  
  
  
  
  1. // CTSWDemo.java 
    2. 
  
  
  
  
  2. import java.awt.Color; 
    3. 
  
  
  
  
  3. import java.awt.Dimension; 
    4. 
  
  
  
  
  4. import java.awt.EventQueue; 
    5. 
  
  
  
  
  5. import java.awt.GradientPaint; 
    6. 
  
  
  
  
  6. import java.awt.Graphics; 
    7. 
  
  
  
  
  7. import java.awt.Graphics2D; 
    8. 
  
  
  
  
  8. import java.awt.GraphicsDevice; 
    9. 
  
  
  
  
  9. import java.awt.GraphicsEnvironment; 
    10. 
  
  
  
  
  10. import java.awt.Shape; 
    11. 
  
  
  
  
  11. import java.awt.event.ActionEvent; 
    12. 
  
  
  
  
  12. import java.awt.event.ActionListener; 
    13. 
  
  
  
  
  13. import java.awt.geom.Ellipse2D; 
    14. 
  
  
  
  
  14. import javax.swing.Box; 
    15. 
  
  
  
  
  15. import javax.swing.BoxLayout; 
    16. 
  
  
  
  
  16. import javax.swing.JButton; 
    17. 
  
  
  
  
  17. import javax.swing.JFrame; 
    18. 
  
  
  
  
  18. import javax.swing.JPanel; 
    19. 
  
  
  
  
  19. public class CTSWDemo extends JFrame 
    20. 
  
  
  
  
  20. { 
    21. 
  
  
  
  
  21.    public CTSWDemo () 
    22. 
  
  
  
  
  22.    { 
    23. 
  
  
  
  
  23.       super ("Combined Translucency with Per-Pixel Transparency and Shaped "+ 
    24. 
  
  
  
  
  24.              "Window Demo"); 
    25. 
  
  
  
  
  25.       setUndecorated (true); // Avoid decorated window artifacts. 
    26. 
  
  
  
  
  26.       JPanel gradPanel = new JPanel () 
    27. 
  
  
  
  
  27.                          { 
    28. 
  
  
  
  
  28.                              Color colorA = new Color (255, 0, 0, 0); 
    29. 
  
  
  
  
  29.                              Color colorB = new Color (255, 0, 0, 255); 
    30. 
  
  
  
  
  30.                              protected void paintComponent (Graphics g) 
    31. 
  
  
  
  
  31.                              { 
    32. 
  
  
  
  
  32.                                  Graphics2D g2d = (Graphics2D) g; 
    33. 
  
  
  
  
  33.                                  GradientPaint gp; 
    34. 
  
  
  
  
  34.                                  gp = new GradientPaint (0.0f, 0.0f, colorA, 
    35. 
  
  
  
  
  35.                                                          0.0f, getHeight (), 
    36. 
  
  
  
  
  36.                                                          colorB, true); 
    37. 
  
  
  
  
  37.                                  g2d.setPaint (gp); 
    38. 
  
  
  
  
  38.                                  g2d.fillRect (0, 0, getWidth (), 
    39. 
  
  
  
  
  39.                                                getHeight ()); 
    40. 
  
  
  
  
  40.                                   
    41. 
  
  
  
  
  41.                              } 
    42. 
  
  
  
  
  42.                          }; 
    43. 
  
  
  
  
  43.       gradPanel.setPreferredSize (new Dimension (300, 200)); 
    44. 
  
  
  
  
  44.       gradPanel.setLayout (new BoxLayout (gradPanel, BoxLayout.Y_AXIS)); 
    45. 
  
  
  
  
  45.       JButton btnClose = new JButton ("Close"); 
    46. 
  
  
  
  
  46.       ActionListener al; 
    47. 
  
  
  
  
  47.       al = new ActionListener () 
    48. 
  
  
  
  
  48.            { 
    49. 
  
  
  
  
  49.                public void actionPerformed (ActionEvent ae) 
    50. 
  
  
  
  
  50.                { 
    51. 
  
  
  
  
  51.                   System.exit (0); 
    52. 
  
  
  
  
  52.                } 
    53. 
  
  
  
  
  53.            }; 
    54. 
  
  
  
  
  54.       btnClose.addActionListener (al); 
    55. 
  
  
  
  
  55.       btnClose.setAlignmentX (0.5f); 
    56. 
  
  
  
  
  56.       gradPanel.add (Box.createVerticalGlue ()); 
    57. 
  
  
  
  
  57.       gradPanel.add (btnClose); 
    58. 
  
  
  
  
  58.       gradPanel.add (Box.createVerticalGlue ()); 
    59. 
  
  
  
  
  59.       setContentPane (gradPanel); 
    60. 
  
  
  
  
  60.       if (!getGraphicsConfiguration ().isTranslucencyCapable ()) 
    61. 
  
  
  
  
  61.       { 
    62. 
  
  
  
  
  62.           System.err.println ("per-pixel translucency not in effect for this "+ 
    63. 
  
  
  
  
  63.                               "graphics configuration"); 
    64. 
  
  
  
  
  64.           System.exit (0); 
    65. 
  
  
  
  
  65.       } 
    66. 
  
  
  
  
  66.       setBackground (new Color (0, 0, 0, 0)); // Achieve per-pixel 
    67. 
  
  
  
  
  67.                                               // translucency. 
    68. 
  
  
  
  
  68.       pack (); 
    69. 
  
  
  
  
  69.       setShape (new Ellipse2D.Float (0, 0, getWidth (), getHeight ())); 
    70. 
  
  
  
  
  70.       setLocationRelativeTo (null); 
    71. 
  
  
  
  
  71.       setVisible (true); 
    72. 
  
  
  
  
  72.    } 
    73. 
  
  
  
  
  73.    public static void main (String [] args) 
    74. 
  
  
  
  
  74.    { 
    75. 
  
  
  
  
  75.       Runnable r; 
    76. 
  
  
  
  
  76.       r = new Runnable () 
    77. 
  
  
  
  
  77.           { 
    78. 
  
  
  
  
  78.               public void run () 
    79. 
  
  
  
  
  79.               { 
    80. 
  
  
  
  
  80.                  GraphicsEnvironment ge; 
    81. 
  
  
  
  
  81.                  ge = GraphicsEnvironment.getLocalGraphicsEnvironment (); 
    82. 
  
  
  
  
  82.                  if (!ge.getDefaultScreenDevice (). 
    83. 
  
  
  
  
  83.                          isWindowTranslucencySupported 
    84. 
  
  
  
  
  84.                            (GraphicsDevice.WindowTranslucency. 
    85. 
  
  
  
  
  85.                                            PERPIXEL_TRANSLUCENT)) 
    86. 
  
  
  
  
  86.                  { 
    87. 
  
  
  
  
  87.                      System.err.println ("per-pixel translucency isn't "+ 
    88. 
  
  
  
  
  88.                                          "supported"); 
    89. 
  
  
  
  
  89.                      return; 
    90. 
  
  
  
  
  90.                  } 
    91. 
  
  
  
  
  91.                  if (!ge.getDefaultScreenDevice (). 
    92. 
  
  
  
  
  92.                          isWindowTranslucencySupported 
    93. 
  
  
  
  
  93.                            (GraphicsDevice.WindowTranslucency. 
    94. 
  
  
  
  
  94.                                            PERPIXEL_TRANSPARENT)) 
    95. 
  
  
  
  
  95.                  { 
    96. 
  
  
  
  
  96.                      System.err.println ("per-pixel transparency isn't "+ 
    97. 
  
  
  
  
  97.                                          "supported"); 
    98. 
  
  
  
  
  98.    &nb            
    
                当前题目：探秘JDK7之二：半透明和任意形状的窗口
                
    
                网页URL：http://www.mswzjz.cn/qtweb/news24/137974.html
            
    
            
    
                攀枝花网站建设、攀枝花网站运维推广公司-贝锐智能，是专注品牌与效果的网络营销公司；服务项目有等
                                
    
            
    
                广告
                
            
    
            
    
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                贝锐智能

贝锐智能技术为您推荐以下文章

网站策划知识

分类信息网站

恒翔机电　　 　绵阳电信服务器托管　　 　南充主机托管　　 　成都网站设计　　 　眉山网站建设　　 　虚拟主机　　 　名片设计　　 　成都光华电信机房　　 　交互设计　　 　顺泽窗帘　　 　响应式网站　　 　网站推广公司　　 　彭山网站制作　　 　手机网站制作　　 　搜索引擎优化　　 　企业网站设计　　 　成都门窗定制　　 　成都学生服定制　　 　香港主机　　 　成都公司注册代办