fullscreentest.java

来自「java learn PPT java learn PPT java learn」· Java 代码 · 共 308 行

     import java.awt.*;
     import java.awt.image.BufferStrategy;
     import java.applet.*;
     import java.awt.event.*;
     import java.util.*;

     public class FullscreenTest extends Applet implements Runnable, 
                                                           ActionListener,
                                                           MouseMotionListener
     {
          // 用来绘制的窗体frame或者全屏frame
          protected Frame  frame;

          // 图形环境可用的图像设备
          protected GraphicsDevice device;

          // 标志是窗体模式还是全屏模式
          protected boolean frameWindowed;

          // frame的大小
          protected Rectangle bounds;

          // 窗体方式绘制的屏外图像         
          protected Image offscreen;

          // 用来选择是用窗体模式还是全屏模式的按钮
          protected Button windowed;
          protected Button fullscreen;
          protected Label  desc;

          // Actor2D 对象数组
          protected Actor2D[] actors;

          // 动画线程
          protected Thread animation;

          public void init()
          {
               // 创建applet的可视化组件
               Panel p;

               setLayout(new BorderLayout());

               p = new Panel();
               p.add(new Label("Choose your destiny!")); 
               add(p, BorderLayout.NORTH);
          
               p = new Panel();
               windowed = new Button("Give me the Blue pill!");
               windowed.addActionListener(this);
               windowed.addMouseMotionListener(this);
               p.add(windowed);

               fullscreen = new Button("I want the Red pill!");
               fullscreen.addActionListener(this);
               fullscreen.addMouseMotionListener(this);
               p.add(fullscreen);

               add(p, BorderLayout.CENTER);

               p = new Panel();
               desc = new Label("                     ");
               p.add(desc);
               add(p, BorderLayout.SOUTH);

               // 设置frame的可视化组件

               ActorGroup2D group = new AsteroidGroup();
               group.init(this);
     
               group.MIN_X_POS = 0;
               group.MIN_Y_POS = 0;

               group.MAX_X_POS = 800;
               group.MAX_Y_POS = 600;

               Random random = new Random();
               actors = new Asteroid[10];
               for(int i = 0; i < 10; i++)
               {
                    actors[i] = new Asteroid(group);
                    actors[i].setPos(Math.abs(random.nextInt(800)), 
                                     Math.abs(random.nextInt(600)));
               }

               bounds = null;

               // 为动画创建一个新的线程
               animation = new Thread(this);
          }

          public void stop()
          {
               animation = null;
          }

          public void run()
          {
               // 全屏模式的代码
               if(! frameWindowed)
               {
                    // 创建一个链交换策略
                    frame.createBufferStrategy(3);
     
                    Thread x = Thread.currentThread();
                    while(x == animation && frame.isShowing())
                    {
                         BufferStrategy bufferStrategy = frame.getBufferStrategy();

                         // 更新并绘制frame
                         do
                         {
                              Graphics2D g2d = (Graphics2D) bufferStrategy.getDrawGraphics();

                              for(int i = 0; i < 10; i++)
                              {
                                   actors[i].update();
                              }

                               paintFrame(g2d);
                               bufferStrategy.show();
                               g2d.dispose();

                         }     while(bufferStrategy.contentsLost());

                         try 
                         {
                              Thread.sleep(10);
                         }
                         catch (InterruptedException e) { break; }
                    }
               }

               // 窗体模式的代码
               else
               {
                    Graphics2D g2d;

                    Thread x = Thread.currentThread();
                    frame.show();
                    while(x == animation && frame.isVisible())
                    {
                         // 更新并绘制frame
                         g2d = (Graphics2D) offscreen.getGraphics();                    

                         for(int i = 0; i < 10; i++) 
                         {
                              actors[i].update();
                         }

                         paintFrame(g2d);
                         g2d.dispose();
                         frame.getGraphics().drawImage(offscreen, 0, 0, this);
                         
                         try 
                         {
                              Thread.sleep(10);
                         }
                         catch (InterruptedException e) { break; }
                    }
               }             
          }

          // 绘制一帧动画-- 传入的Graphics2D容器可以进行窗体模式绘制
          // 也可进行全屏模式绘制
          protected void paintFrame(Graphics2D g2d)
          {
               g2d.setPaint(Color.BLACK);
               g2d.fillRect(0, 0, bounds.width, bounds.height);

               for(int i = 0; i < 10; i++)
               {
                    actors[i].paint(g2d);
               }
          }

          // 以窗体模式或者全屏模式打开frame 
          protected void openFrame()
          {
               // 用全屏模式打开窗体的代码
               if(! frameWindowed)
               { 
                    try 
                    {                     
                         // 从图形环境中得到默认的图形设备
                         device = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();

                         // 使用图形设备创建一个Frame
                         frame = new Frame(device.getDefaultConfiguration());

                         // 不要绘制frame的修饰
                         frame.setUndecorated(true);

                         // 由于绘制是主动进行的,所以忽略操作系统发来的绘制请求
                         frame.setIgnoreRepaint(true);

                         // 创建全屏窗体
                         device.setFullScreenWindow(frame);

                         // 如果支持的话,调整窗体的大小
                         if (device.isDisplayChangeSupported()) 
                         {
                              // 在恢复到窗体模式之前尝试几种显示模式

                              if(displayModeSupported(800, 600, 32))
                              {
                                   device.setDisplayMode(new DisplayMode(800, 600, 32, 0));
                              }
                              else if(displayModeSupported(800, 600, 16))
                              {
                                   device.setDisplayMode(new DisplayMode(800, 600, 16, 0));
                              }
                              else if(displayModeSupported(640, 480, 16))
                              {
                                   device.setDisplayMode(new DisplayMode(640, 480, 16, 0));
                              }
                         }

                         bounds = frame.getBounds();

                         // 启动动画
                         animation.start();
                    }
                    catch (Exception e) 
                    {
                         e.printStackTrace();
                    }
               }

               else // 窗体模式
               { 
                    // 创建一个大小为800像素x 600像素的标准Frame

                    offscreen = createImage(800, 600);
                           
                    frame = new Frame();
                    frame.setSize(800, 600);
                    frame.addWindowListener(new WindowAdapter()
                         {
                              public void windowClosing(WindowEvent e)
                              {
                                   frame.hide();
                                   frame.setVisible(false);
                                   frame.dispose();
                              }
                         } );

                    bounds = frame.getBounds();

                    animation.start();
               }
          }

          // 判断当前的图形设备是否支持所传入的显示模式
          private boolean displayModeSupported(int width, int height, int bitDepth)
          {
               DisplayMode[] modes = device.getDisplayModes();
               for(int i = 0; i < modes.length; i++) 
               {
                    if(width    == modes[i].getWidth()  &&
                       height   == modes[i].getHeight() &&
                       bitDepth == modes[i].getBitDepth())
                    {
                         return true;
                    }
               }

               // 找不到兼容的显示模式!    
               return false;
          }

          // 以全屏或者窗体模式打开frame          
          public void actionPerformed(ActionEvent e)
          {
               if(windowed == e.getSource())
               {
                    frameWindowed = true;
                    windowed.setEnabled(false);
                    fullscreen.setEnabled(false);
                    openFrame();
               }

               else if(fullscreen == e.getSource())
               {
                    frameWindowed = false;
                    windowed.setEnabled(false);
                    fullscreen.setEnabled(false);
                    openFrame();
               }
          }

          // 更新选择按钮的描述 
          public void mouseMoved(MouseEvent e)    
          {
               if(windowed == e.getSource())
               {
                    desc.setText(" Enter windowed mode ");
               }

               else if(fullscreen == e.getSource())
               {
                    desc.setText("Enter fullscreen mode");
               }
          }

          public void mouseDragged(MouseEvent e)  {  }

     }    // FullscreenTest