Java Game Programming

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
 
// Swing Program Template
@SuppressWarnings("serial")
public class SwingTemplateJPanel extends JPanel {
   // Name-constants
   public static final int CANVAS_WIDTH = 640;
   public static final int CANVAS_HEIGHT = 480;
   public static final String TITLE = "...Title...";
   // ......
 
   // private variables of GUI components
   // ......
 
   /** Constructor to setup the GUI components */
   public SwingTemplateJPanel() {
      setPreferredSize(new Dimension(CANVAS_WIDTH, CANVAS_HEIGHT));
      // "this" JPanel container sets layout
      // setLayout(new ....Layout());
 
      // Allocate the UI components
      // .....
 
      // "this" JPanel adds components
      // add(....)
 
      // Source object adds listener
      // .....
   }
 
   /** Custom painting codes on this JPanel */
   @Override
   public void paintComponent(Graphics g) {
      super.paintComponent(g);  // paint background
      setBackground(Color.BLACK);
 
      // Your custom painting codes
      // ......
   }
 
   /** The entry main() method */
   public static void main(String[] args) {
      // Run GUI codes in the Event-Dispatching thread for thread safety
      SwingUtilities.invokeLater(new Runnable() {
         public void run() {
            JFrame frame = new JFrame(TITLE);
            frame.setContentPane(new SwingTemplateJPanel());
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.pack();             // "this" JFrame packs its components
            frame.setLocationRelativeTo(null); // center the application window
            frame.setVisible(true);            // show it
         }
      });
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import javax.swing.*;
 
/** Swing Program Template for running as Applet */
@SuppressWarnings("serial")
public class SwingTemplateApplet extends JApplet {
 
   /** init() to setup the UI components */
   @Override
   public void init() {
      // Run GUI codes in the Event-Dispatching thread for thread safety
      try {
         SwingUtilities.invokeAndWait(new Runnable() { // Applet uses invokeAndWait()
            @Override
            public void run() {
               // Set the content-pane of the JApplet to an instance of main JPanel
               setContentPane(new SwingTemplateJPanel());
            }
         });
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

import java.awt.*;
import java.awt.geom.AffineTransform;
import javax.swing.*;
 
/** Test applying affine transform on vector graphics */
@SuppressWarnings("serial")
public class AffineTransformDemo extends JPanel {
   // Named-constants for dimensions
   public static final int CANVAS_WIDTH = 640;
   public static final int CANVAS_HEIGHT = 480;
   public static final String TITLE = "Affine Transform Demo";
 
   // Define an arrow shape using a polygon centered at (0, 0)
   int[] polygonXs = { -20, 0, +20, 0};
   int[] polygonYs = { 20, 10, 20, -20};
   Shape shape = new Polygon(polygonXs, polygonYs, polygonXs.length);
   double x = 50.0, y = 50.0;  // (x, y) position of this Shape
 
   /** Constructor to set up the GUI components */
   public AffineTransformDemo() {
      setPreferredSize(new Dimension(CANVAS_WIDTH, CANVAS_HEIGHT));
   }
 
   /** Custom painting codes on this JPanel */
   @Override
   public void paintComponent(Graphics g) {
      super.paintComponent(g);    // paint background
      setBackground(Color.WHITE);
      Graphics2D g2d = (Graphics2D)g;
 
      // Save the current transform of the graphics contexts.
      AffineTransform saveTransform = g2d.getTransform();
      // Create a identity affine transform, and apply to the Graphics2D context
      AffineTransform identity = new AffineTransform();
      g2d.setTransform(identity);
 
      // Paint Shape (with identity transform), centered at (0, 0) as defined.
      g2d.setColor(Color.GREEN);
      g2d.fill(shape);
      // Translate to the initial (x, y) position, scale, and paint
      g2d.translate(x, y);
      g2d.scale(1.2, 1.2);
      g2d.fill(shape);
 
      // Try more transforms
      for (int i = 0; i < 5; ++i) {
         g2d.translate(50.0, 5.0);  // translates by (50, 5)
         g2d.setColor(Color.BLUE);
         g2d.fill(shape);
         g2d.rotate(Math.toRadians(15.0)); // rotates about transformed origin
         g2d.setColor(Color.RED);
         g2d.fill(shape);
      }
      // Restore original transform before returning
      g2d.setTransform(saveTransform);
   }
 
   /** The Entry main method */
   public static void main(String[] args) {
      // Run the GUI codes on the Event-Dispatching thread for thread safety
      SwingUtilities.invokeLater(new Runnable() {
         @Override
         public void run() {
            JFrame frame = new JFrame(TITLE);
            frame.setContentPane(new AffineTransformDemo());
            frame.pack();
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setLocationRelativeTo(null); // center the application window
            frame.setVisible(true);
         }
      });
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

import java.awt.*;
import java.io.IOException;
import java.net.URL;
import javax.imageio.ImageIO;
import javax.swing.*;
 
/** Test loading an external image into a BufferedImage using ImageIO.read() */
@SuppressWarnings("serial")
public class LoadImageDemo extends JPanel {
   // Named-constants
   public static final int CANVAS_WIDTH = 640;
   public static final int CANVAS_HEIGHT = 480;
   public static final String TITLE = "Load Image Demo";
 
   private String imgFileName = "images/duke.gif"; // relative to project root (or bin)
   private Image img;  // a BufferedImage object
 
   /** Constructor to set up the GUI components */
   public LoadImageDemo() {
      // Load an external image via URL
      URL imgUrl = getClass().getClassLoader().getResource(imgFileName);
      if (imgUrl == null) {
         System.err.println("Couldn't find file: " + imgFileName);
      } else {
         try {
            img = ImageIO.read(imgUrl);
         } catch (IOException ex) {
            ex.printStackTrace();
         }
      }
 
      setPreferredSize(new Dimension(CANVAS_WIDTH, CANVAS_HEIGHT));
   }
 
   /** Custom painting codes on this JPanel */
   @Override
   public void paintComponent(Graphics g) {
      super.paintComponent(g);    // paint background
      setBackground(Color.WHITE);
      g.drawImage(img, 50, 50, null);
   }
 
   /** The Entry main method */
   public static void main(String[] args) {
      // Run the GUI codes on the Event-Dispatching thread for thread safety
      SwingUtilities.invokeLater(new Runnable() {
         @Override
         public void run() {
            JFrame frame = new JFrame("Load Image Demo");
            frame.setContentPane(new LoadImageDemo());
            frame.pack();
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setVisible(true);
         }
      });
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

import java.awt.geom.AffineTransform;
import javax.imageio.ImageIO;
import java.net.URL;
import java.awt.*;
import javax.swing.*;
import java.io.*;
 
/** Test applying affine transform on images */
@SuppressWarnings("serial")
public class ImageTransformDemo extends JPanel {
   // Named-constants for dimensions
   public static final int CANVAS_WIDTH = 640;
   public static final int CANVAS_HEIGHT = 480;
   public static final String TITLE = "Image Transform Demo";
 
   // Image
   private String imgFileName = "images/duke.png"; // relative to project root or bin
   private Image img;
   private int imgWidth, imgHeight;    // width and height of the image
   private double x = 100.0, y = 80.0; // center (x, y), with initial value
 
   /** Constructor to set up the GUI components */
   public ImageTransformDemo() {
      // URL can read from disk file and JAR file
      URL url = getClass().getClassLoader().getResource(imgFileName);
      if (url == null) {
         System.err.println("Couldn't find file: " + imgFileName);
      } else {
         try {
            img = ImageIO.read(url);
            imgWidth = img.getWidth(this);
            imgHeight = img.getHeight(this);
         } catch (IOException ex) {
            ex.printStackTrace();
         }
      }
 
      this.setPreferredSize(new Dimension(CANVAS_WIDTH, CANVAS_HEIGHT));
   }
 
   /** Custom painting codes on this JPanel */
   @Override
   public void paintComponent(Graphics g) {
      super.paintComponent(g);    // paint background
      setBackground(Color.WHITE);
 
      Graphics2D g2d = (Graphics2D) g;
      g2d.drawImage(img, 0, 0, this);  // Display with top-left corner at (0, 0)
 
      // drawImage() does not use the current transform of the Graphics2D context
      // Need to create a AffineTransform and pass into drawImage()
      AffineTransform transform = new AffineTransform();  // identity transform
      // Display the image with its center at the initial (x, y)
      transform.translate(x - imgWidth/2, y - imgHeight/2);
      g2d.drawImage(img, transform, this);
      // Try applying more transform to this image
      for (int i = 0; i < 5; ++i) {
         transform.translate(70.0, 5.0);
         transform.rotate(Math.toRadians(15), imgWidth/2, imgHeight/2); // about its center
         transform.scale(0.9, 0.9);
         g2d.drawImage(img, transform, this);
      }
   }
 
   /** The Entry main method */
   public static void main(String[] args) {
      // Run the GUI codes on the Event-Dispatching thread for thread safety
      SwingUtilities.invokeLater(new Runnable() {
         @Override
         public void run() {
            JFrame frame = new JFrame(TITLE);
            frame.setContentPane(new ImageTransformDemo());
            frame.pack();
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setLocationRelativeTo(null); // center the application window
            frame.setVisible(true);
         }
      });
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

import java.awt.geom.AffineTransform;
import javax.imageio.ImageIO;
import java.net.URL;
import java.awt.*;
import javax.swing.*;
import java.io.*;
 
/** Animating image frames. Each frame has its own file */
@SuppressWarnings("serial")
public class AnimatedFramesDemo extends JPanel {
   // Named-constants
   static final int CANVAS_WIDTH = 640;
   static final int CANVAS_HEIGHT = 480;
   public static final String TITLE = "Animated Frame Demo";
 
   private String[] imgFilenames = {
         "images/pacman_1.png", "images/pacman_2.png", "images/pacman_3.png"};
   private Image[] imgFrames;    // array of Images to be animated
   private int currentFrame = 0; // current frame number
   private int frameRate = 5;    // frame rate in frames per second
   private int imgWidth, imgHeight;    // width and height of the image
   private double x = 100.0, y = 80.0; // (x,y) of the center of image
   private double speed = 8;           // displacement in pixels per move
   private double direction = 0;       // in degrees
   private double rotationSpeed = 1;   // in degrees per move
 
   // Used to carry out the affine transform on images
   private AffineTransform transform = new AffineTransform();
 
   /** Constructor to set up the GUI components */
   public AnimatedFramesDemo() {
      // Setup animation
      loadImages(imgFilenames);
      Thread animationThread = new Thread () {
         @Override
         public void run() {
            while (true) {
               update();   // update the position and image
               repaint();  // Refresh the display
               try {
                  Thread.sleep(1000 / frameRate); // delay and yield to other threads
               } catch (InterruptedException ex) { }
            }
         }
      };
      animationThread.start();  // start the thread to run animation
 
      // Setup GUI
      setPreferredSize(new Dimension(CANVAS_WIDTH, CANVAS_HEIGHT));
   }
 
   /** Helper method to load all image frames, with the same height and width */
   private void loadImages(String[] imgFileNames) {
      int numFrames = imgFileNames.length;
      imgFrames = new Image[numFrames];  // allocate the array
      URL imgUrl = null;
      for (int i = 0; i < numFrames; ++i) {
         imgUrl = getClass().getClassLoader().getResource(imgFileNames[i]);
         if (imgUrl == null) {
            System.err.println("Couldn't find file: " + imgFileNames[i]);
         } else {
            try {
               imgFrames[i] = ImageIO.read(imgUrl);  // load image via URL
            } catch (IOException ex) {
               ex.printStackTrace();
            }
         }
      }
      imgWidth = imgFrames[0].getWidth(null);
      imgHeight = imgFrames[0].getHeight(null);
   }
 
   /** Update the position based on speed and direction of the sprite */
   public void update() {
      x += speed * Math.cos(Math.toRadians(direction));  // x-position
      if (x >= CANVAS_WIDTH) {
         x -= CANVAS_WIDTH;
      } else if (x < 0) {
         x += CANVAS_WIDTH;
      }
      y += speed * Math.sin(Math.toRadians(direction));  // y-position
      if (y >= CANVAS_HEIGHT) {
         y -= CANVAS_HEIGHT;
      } else if (y < 0) {
         y += CANVAS_HEIGHT;
      }
      direction += rotationSpeed;  // update direction based on rotational speed
      if (direction >= 360) {
         direction -= 360;
      } else if (direction < 0) {
         direction += 360;
      }
      ++currentFrame;    // display next frame
      if (currentFrame >= imgFrames.length) {
         currentFrame = 0;
      }
   }
 
   /** Custom painting codes on this JPanel */
   @Override
   public void paintComponent(Graphics g) {
      super.paintComponent(g);  // paint background
      setBackground(Color.WHITE);
      Graphics2D g2d = (Graphics2D) g;
 
      transform.setToIdentity();
      // The origin is initially set at the top-left corner of the image.
      // Move the center of the image to (x, y).
      transform.translate(x - imgWidth / 2, y - imgHeight / 2);
      // Rotate about the center of the image
      transform.rotate(Math.toRadians(direction),
            imgWidth / 2, imgHeight / 2);
      // Apply the transform to the image and draw
      g2d.drawImage(imgFrames[currentFrame], transform, null);
   }
 
   /** The Entry main method */
   public static void main(String[] args) {
      // Run the GUI codes on the Event-Dispatching thread for thread safety
      SwingUtilities.invokeLater(new Runnable() {
         @Override
         public void run() {
            JFrame frame = new JFrame(TITLE);
            frame.setContentPane(new AnimatedFramesDemo());
            frame.pack();
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setLocationRelativeTo(null); // center the application window
            frame.setVisible(true);
         }
      });
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

import javax.imageio.ImageIO;
import java.net.URL;
import java.awt.*;
import javax.swing.*;
import java.io.*;
 
/** Animating image frames. All frames kept in a stripe. */
@SuppressWarnings("serial")
public class AnimatedFramesInStripe extends JPanel {
   // Named-constants
   static final int CANVAS_WIDTH = 640;
   static final int CANVAS_HEIGHT = 480;
   public static final String TITLE = "Animated Frame Demo";
 
   private String imgFilename = "images/GhostStripe.png";
   private int numRows, numCols, numFrames;
   private Image img;         // for the entire image stripe
   private int currentFrame;  // current frame number
   private int frameRate = 5; // frame rate in frames per second
   private int imgWidth, imgHeight;  // width and height of the image
   private double x = 100.0, y = 80.0; // (x,y) of the center of image
   private double speed = 8;           // displacement in pixels per move
   private double direction = 0;       // in degrees
   private double rotationSpeed = 1;   // in degrees per move
 
   /** Constructor to set up the GUI components */
   public AnimatedFramesInStripe() {
      // Setup animation
      loadImage(imgFilename, 2, 4);
      Thread animationThread = new Thread () {
         @Override
         public void run() {
            while (true) {
               update();   // update the position and image
               repaint();  // Refresh the display
               try {
                  Thread.sleep(1000 / frameRate); // delay and yield to other threads
               } catch (InterruptedException ex) { }
            }
         }
      };
      animationThread.start();  // start the thread to run animation
 
      // Setup GUI
      setPreferredSize(new Dimension(CANVAS_WIDTH, CANVAS_HEIGHT));
   }
 
   /** Helper method to load image. All frames have the same height and width */
   private void loadImage(String imgFileName, int numRows, int numCols) {
      URL imgUrl = getClass().getClassLoader().getResource(imgFileName);
      if (imgUrl == null) {
         System.err.println("Couldn't find file: " + imgFileName);
      } else {
         try {
            img = ImageIO.read(imgUrl);  // load image via URL
         } catch (IOException ex) {
            ex.printStackTrace();
         }
      }
      numFrames = numRows * numCols;
      this.imgHeight = img.getHeight(null) / numRows;
      this.imgWidth = img.getWidth(null) / numCols;
      this.numRows = numRows;
      this.numCols = numCols;
      currentFrame = 0;
   }
 
   /** Returns the top-left x-coordinate of the given frame number. */
   private int getCurrentFrameX() {
      return (currentFrame % numCols) * imgWidth;
   }
 
   /** Returns the top-left y-coordinate of the given frame number. */
   private int getCurrentFrameY() {
      return (currentFrame / numCols) * imgHeight;
   }
 
   /** Update the position based on speed and direction of the sprite */
   public void update() {
      x += speed * Math.cos(Math.toRadians(direction));  // x-position
      if (x >= CANVAS_WIDTH) {
         x -= CANVAS_WIDTH;
      } else if (x < 0) {
         x += CANVAS_WIDTH;
      }
      y += speed * Math.sin(Math.toRadians(direction));  // y-position
      if (y >= CANVAS_HEIGHT) {
         y -= CANVAS_HEIGHT;
      } else if (y < 0) {
         y += CANVAS_HEIGHT;
      }
      direction += rotationSpeed;  // update direction based on rotational speed
      if (direction >= 360) {
         direction -= 360;
      } else if (direction < 0) {
         direction += 360;
      }
      ++currentFrame;    // displays next frame
      if (currentFrame >= numFrames) {
         currentFrame = 0;
      }
   }
 
   /** Custom painting codes on this JPanel */
   @Override
   public void paintComponent(Graphics g) {
      super.paintComponent(g); // paint background
      setBackground(Color.WHITE);
      Graphics2D g2d = (Graphics2D) g;
 
      int frameX = getCurrentFrameX();
      int frameY = getCurrentFrameY();
      g2d.drawImage(img,
            (int)x - imgWidth / 2, (int)y - imgHeight / 2,
            (int)x + imgWidth / 2, (int)y + imgHeight / 2,
            frameX, frameY, frameX + imgWidth, frameY + imgHeight, null);
   }
 
   /** The Entry main method */
   public static void main(String[] args) {
      // Run the GUI codes on the Event-Dispatching thread for thread safety
      SwingUtilities.invokeLater(new Runnable() {
         @Override
         public void run() {
            JFrame frame = new JFrame(TITLE);
            frame.setContentPane(new AnimatedFramesInStripe());
            frame.pack();
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setLocationRelativeTo(null); // center the application window
           frame.setVisible(true);
         }
      });
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
 
/** Testing the full-screen mode */
@SuppressWarnings("serial")
public class FullScreenDemo extends JFrame {
 
   /** Constructor to set up the GUI components */
   public FullScreenDemo() {
      // Check if full screen mode supported?
      GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
      GraphicsDevice defaultScreen = env.getDefaultScreenDevice();
      if (!defaultScreen.isFullScreenSupported()) {
         System.err.println("Full Screen mode is not supported!");
         System.exit(1);
      }
 
      // Use ESC key to quit
      addKeyListener(new KeyAdapter() {
         @Override
         public void keyPressed(KeyEvent e) {
            if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
               System.exit(0);
            }
         }
      });
 
      setContentPane(new DrawCanvas());
      setDefaultCloseOperation(EXIT_ON_CLOSE);
      setUndecorated(true);
      setResizable(false);
      defaultScreen.setFullScreenWindow(this); // full-screen mode
      setVisible(true);
   }
 
   /** DrawCanvas (inner class) is a JPanel used for custom drawing */
   private class DrawCanvas extends JPanel {
      @Override
      public void paintComponent(Graphics g) {
         super.paintComponent(g);
         setBackground(Color.BLACK);
 
         // Paint messages
         g.setColor(Color.YELLOW);
         g.setFont(new Font(Font.DIALOG, Font.BOLD, 30));
         FontMetrics fm = g.getFontMetrics();
         String msg = "In Full-Screen mode";
         int msgWidth = fm.stringWidth(msg);
         int msgAscent = fm.getAscent();
         int msgX = getWidth() / 2 - msgWidth / 2;
         int msgY = getHeight() / 2 + msgAscent / 2;
         g.drawString(msg, msgX, msgY);
 
         g.setColor(Color.WHITE);
         g.setFont(new Font(Font.DIALOG, Font.PLAIN, 18));
         fm = g.getFontMetrics();
         msg = "Press ESC to quit";
         msgWidth = fm.stringWidth(msg);
         int msgHeight = fm.getHeight();
         msgX = getWidth() / 2 - msgWidth / 2;
         msgY += msgHeight * 1.5;
         g.drawString(msg, msgX, msgY);
      }
   }
 
   /** The Entry main method */
   public static void main(String[] args) {
      // Run the GUI codes on the Event-Dispatching thread for thread safety
      SwingUtilities.invokeLater(new Runnable() {
         @Override
         public void run() {
            new FullScreenDemo();
         }
      });
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
 
/** Testing the full-screen mode */
@SuppressWarnings("serial")
public class FullScreenEscDemo extends JFrame {
   // Windowed mode settings
   private static String winModeTitle =
         "Switching between Full Screen Mode and Windowed Mode Demo";
   private static int winModeX, winModeY;          // top-left corner (x, y)
   private static int winModeWidth, winModeHeight; // width and height
 
   private boolean inFullScreenMode;    // in fullscreen or windowed mode?
   private boolean fullScreenSupported; // is fullscreen supported?
 
   /** Constructor to set up the GUI components */
   public FullScreenEscDemo() {
      // Get the screen width and height
      Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
      // Set the windowed mode initial width and height to about fullscreen
      winModeWidth = (int)dim.getWidth();
      winModeHeight = (int)dim.getHeight() - 35; // minus task bar
      winModeX = 0;
      winModeY = 0;
 
      // Check if full screen mode supported?
      GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
      final GraphicsDevice defaultScreen = env.getDefaultScreenDevice();
      fullScreenSupported = defaultScreen.isFullScreenSupported();
 
      if (fullScreenSupported) {
         setUndecorated(true);
         setResizable(false);
         defaultScreen.setFullScreenWindow(this); // full-screen mode
         inFullScreenMode = true;
      } else {
         setUndecorated(false);
         setResizable(true);
         defaultScreen.setFullScreenWindow(null); // windowed mode
         setBounds(winModeX, winModeY, winModeWidth, winModeHeight);
         inFullScreenMode = false;
      }
 
      // Use ESC key to switch between Windowed and fullscreen modes
      this.addKeyListener(new KeyAdapter() {
         @Override
         public void keyPressed(KeyEvent e) {
            if (e.getKeyCode() == KeyEvent.VK_SPACE) {
               if (fullScreenSupported) {
                  if (!inFullScreenMode) {
                     // Switch to fullscreen mode
                     setVisible(false);
                     setResizable(false);
                     dispose();
                     setUndecorated(true);
                     defaultScreen.setFullScreenWindow(FullScreenEscDemo.this);
                     setVisible(true);
                  } else {
                     // Switch to windowed mode
                     setVisible(false);
                     dispose();
                     setUndecorated(false);
                     setResizable(true);
                     defaultScreen.setFullScreenWindow(null);
                     setBounds(winModeX, winModeY, winModeWidth, winModeHeight);
                     setVisible(true);
                  }
                  inFullScreenMode = !inFullScreenMode;
                  repaint();
               }
            } else if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
               System.exit(0);
            }
         }
      });
 
      // To save the window width and height if the window has been resized.
      this.addComponentListener(new ComponentAdapter() {
         @Override
         public void componentMoved(ComponentEvent e) {
            if (!inFullScreenMode) {
               winModeX = getX();
               winModeY = getY();
            }
         }
 
         @Override
         public void componentResized(ComponentEvent e) {
            if (!inFullScreenMode) {
               winModeWidth = getWidth();
               winModeHeight = getHeight();
            }
         }
      });
 
      setContentPane(new DrawCanvas());
      setDefaultCloseOperation(EXIT_ON_CLOSE);
      setTitle(winModeTitle);
      setVisible(true);
   }
 
   /** DrawCanvas (inner class) is a JPanel used for custom drawing */
   private class DrawCanvas extends JPanel {
      @Override
      public void paintComponent(Graphics g) {
         super.paintComponent(g);
         setBackground(Color.BLACK);
 
         // Draw a box to indicate the borders
         Graphics2D g2d = (Graphics2D)g;
         g2d.setStroke(new BasicStroke(8));
         g2d.setColor(Color.RED);
         g2d.drawRect(0, 0, getWidth()-1, getHeight()-1);
 
         // Paint messages
         g.setColor(Color.YELLOW);
         g.setFont(new Font(Font.DIALOG, Font.BOLD, 30));
         FontMetrics fm = g.getFontMetrics();
         String msg = inFullScreenMode ? "In Full-Screen mode" : "In Windowed mode";
         int msgWidth = fm.stringWidth(msg);
         int msgAscent = fm.getAscent();
         int msgX = getWidth() / 2 - msgWidth / 2;
         int msgY = getHeight() / 2 + msgAscent / 2;
         g.drawString(msg, msgX, msgY);
 
         g.setColor(Color.WHITE);
         g.setFont(new Font(Font.DIALOG, Font.PLAIN, 18));
         fm = g.getFontMetrics();
         msg = "Press SPACE to toggle between Full-screen/windowed modes, ESC to quit.";
         msgWidth = fm.stringWidth(msg);
         int msgHeight = fm.getHeight();
         msgX = getWidth() / 2 - msgWidth / 2;
         msgY += msgHeight * 1.5;
         g.drawString(msg, msgX, msgY);
      }
   }
 
   /** The Entry main method */
   public static void main(String[] args) {
      // Run the GUI codes on the Event-Dispatching thread for thread safety
      SwingUtilities.invokeLater(new Runnable() {
         @Override
         public void run() {
            new FullScreenEscDemo();
         }
      });
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

import java.awt.*;
 
/** Splash Screen Demo (with a Progress Bar)
    Run with VM command-line option -splash:splashImageFilename */
public class SplashScreenDemo {
 
   public static void main(String[] args) {
      SplashScreen splash = SplashScreen.getSplashScreen();
      if (splash == null) {
         System.err.println("Splash Screen not available!");
      } else {
         // Okay, Splash screen created
         Dimension splashBounds = splash.getSize();
         Graphics2D g2d = splash.createGraphics();
 
         // Simulate a progress bar
         for (int i = 0; i < 100; i += 5) {
            g2d.setColor(Color.RED);
            g2d.fillRect(0, splashBounds.height / 2,
                  splashBounds.width * i / 100, 20);
            splash.update();
            try {
               Thread.sleep(200); // Some delays
            } catch (Exception e) {}
         }
         g2d.dispose();
         splash.close();
      }
   }
}