├── .gitignore
├── src
    ├── PlayerSkeleton.java
    ├── TFrame.java
    ├── State.java
    └── TLabel.java
└── readme.txt


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled class file
 2 | *.class
 3 | 
 4 | # Log file
 5 | *.log
 6 | 
 7 | # BlueJ files
 8 | *.ctxt
 9 | 
10 | # Mobile Tools for Java (J2ME)
11 | .mtj.tmp/
12 | 
13 | # Package Files #
14 | *.jar
15 | *.war
16 | *.ear
17 | *.zip
18 | *.tar.gz
19 | *.rar
20 | 
21 | # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
22 | hs_err_pid*
23 | 


--------------------------------------------------------------------------------
/src/PlayerSkeleton.java:
--------------------------------------------------------------------------------
 1 | 
 2 | public class PlayerSkeleton {
 3 | 
 4 | 	//implement this function to have a working system
 5 | 	public int pickMove(State s, int[][] legalMoves) {
 6 | 		
 7 | 		return 0;
 8 | 	}
 9 | 	
10 | 	public static void main(String[] args) {
11 | 		State s = new State();
12 | 		new TFrame(s);
13 | 		PlayerSkeleton p = new PlayerSkeleton();
14 | 		while(!s.hasLost()) {
15 | 			s.makeMove(p.pickMove(s,s.legalMoves()));
16 | 			s.draw();
17 | 			s.drawNext(0,0);
18 | 			try {
19 | 				Thread.sleep(300);
20 | 			} catch (InterruptedException e) {
21 | 				e.printStackTrace();
22 | 			}
23 | 		}
24 | 		System.out.println("You have completed "+s.getRowsCleared()+" rows.");
25 | 	}
26 | 	
27 | }
28 | 


--------------------------------------------------------------------------------
/readme.txt:
--------------------------------------------------------------------------------
 1 | This is a basic Tetris simulation.
 2 | 
 3 | Files:
 4 | 	State - tetris simulation
 5 | 	TFrame - frame that draws the board
 6 | 	TLabel - drawing library
 7 | 	PlayerSkeleton - setup for implementing a player
 8 | 	
 9 | 	
10 | State:
11 | This is the tetris simulation.  It keeps track of the state and allows you to 
12 | make moves.  The board state is stored in field (a double array of integers) and
13 | is accessed by getField().  Zeros denote an empty square.  Other values denote
14 | the turn on which that square was placed.  NextPiece (accessed by getNextPiece)
15 | contains the ID (0-6) of the piece you are about to play.
16 | 
17 | Moves are defined by two numbers: the SLOT, the leftmost column of the piece and
18 | the ORIENT, the orientation of the piece.  Legalmoves gives an nx2 int array
19 | containing the n legal moves.  A move can be made by specifying the two
20 | parameters as either 2 ints, an int array of length 2, or a single int
21 | specifying the row in the legalMoves array corresponding to the appropriate move.
22 | 
23 | It also keeps track of the number of lines cleared - accessed by getRowsCleared().
24 | 
25 | draw() draws the board.
26 | drawNext() draws the next piece above the board
27 | clearNext() clears the drawing of the next piece so it can be drawn in a different
28 | 	slot/orientation
29 | 
30 | 
31 | 
32 | 
33 | TFrame:
34 | This extends JFrame and is instantiated to draw a state.
35 | It can save the current drawing to a .png file.
36 | The main function allows you to play a game manually using the arrow keys.
37 | 
38 | 
39 | 
40 | TLabel:
41 | This is a drawing library.
42 | 
43 | 
44 | 
45 | PlayerSkeleton:
46 | An example of how to implement a player.
47 | The main function plays a game automatically (with visualization).
48 | 
49 | 
50 |  xx
51 |  xx
52 | 
53 | 
54 | xxxx
55 | 
56 |   X
57 | XXX
58 | 
59 | X
60 | XXX
61 | 
62 |  x
63 | xxx
64 | 
65 |  xx
66 | xx
67 | 
68 | xx
69 |  xx
70 | 


--------------------------------------------------------------------------------
/src/TFrame.java:
--------------------------------------------------------------------------------
  1 | import java.awt.Graphics2D;
  2 | import java.awt.event.KeyEvent;
  3 | import java.awt.event.KeyListener;
  4 | import java.awt.image.BufferedImage;
  5 | import java.io.File;
  6 | import java.io.IOException;
  7 | 
  8 | import javax.imageio.ImageIO;
  9 | import javax.swing.JFrame;
 10 | 
 11 | 
 12 | 
 13 | public class TFrame extends JFrame implements KeyListener{
 14 | 	private static final long serialVersionUID = 1L;
 15 | 	public TLabel label = new TLabel(300,700);
 16 | 	public State s;
 17 | 	
 18 | 	public int orient, slot;
 19 | 	
 20 | 	public static final int MANUAL = 0;
 21 | 	public static final int NONE = 1;
 22 | 	
 23 | 	public int mode = MANUAL;
 24 | 	
 25 | 	//constructor
 26 | 	public TFrame (State s){
 27 | 		this.s = s;
 28 | 		s.label = label;
 29 | 		setResizable(false);
 30 | 		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);            // closes all windows when this is closed
 31 | 		setTitle("Tetris BKW");
 32 | 		setContentPane(label.draw);
 33 | 		pack();
 34 | 		label.BORDER = .05;
 35 | 		label.setXscale(0, State.COLS);
 36 | 		label.setYscale(0, State.ROWS+5);
 37 | 		this.addKeyListener(this);  //may be unnecessary (not certain)
 38 | 		setVisible(true);
 39 | 	}
 40 | 	
 41 | 	//switches which state is attached to this TFrame
 42 | 	public void bindState(State s) {
 43 | 		if(s!= null)	s.label = null;
 44 | 		this.s = s;
 45 | 		s.label = label;
 46 | 	}
 47 | 	
 48 | 	///
 49 | 	/// ADDED BY DON (AKA Pimp Masta) 1/22/09
 50 | 	///
 51 | 	public TFrame (){
 52 | 		s.label = label;
 53 | 		setResizable(false);
 54 | 		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);            // closes all windows when this is closed
 55 | 		setTitle("Eric Whitman's Tetris Simulator");
 56 | 		setContentPane(label.draw);
 57 | 		pack();
 58 | 		label.BORDER = .05;
 59 | 		label.setXscale(0, State.COLS);
 60 | 		label.setYscale(0, State.ROWS+5);
 61 | 		this.addKeyListener(this);  //may be unnecessary (not certain)
 62 | 		setVisible(true);
 63 | 	}
 64 | 
 65 | 	public void keyPressed(KeyEvent e) {
 66 | 		switch(mode) {
 67 | 			case(MANUAL): {
 68 | 				switch(e.getKeyCode()) {
 69 | 					case(KeyEvent.VK_RIGHT): {
 70 | 						if(slot < State.COLS-State.pWidth[s.nextPiece][orient])	slot++;
 71 | 						s.clearNext();
 72 | 						s.drawNext(slot, orient);
 73 | 						break;
 74 | 					}
 75 | 					case(KeyEvent.VK_LEFT): {
 76 | 						if(slot > 0)	slot--;
 77 | 						s.clearNext();
 78 | 						s.drawNext(slot, orient);
 79 | 						break;
 80 | 					}
 81 | 					case(KeyEvent.VK_UP): {
 82 | 						orient++;
 83 | 						if(orient%State.pOrients[s.nextPiece]==0)	orient = 0;
 84 | 						if(slot > State.COLS-State.pWidth[s.nextPiece][orient])
 85 | 							slot = State.COLS-State.pWidth[s.nextPiece][orient];
 86 | 						s.clearNext();
 87 | 						s.drawNext(slot, orient);
 88 | 						break;
 89 | 					}
 90 | 					case(KeyEvent.VK_DOWN): {
 91 | 						if(!s.makeMove(orient, slot))	mode = NONE;
 92 | 						if(orient >= State.pOrients[s.nextPiece])	orient = 0;
 93 | 						if(slot > State.COLS-State.pWidth[s.nextPiece][orient])
 94 | 							slot = State.COLS-State.pWidth[s.nextPiece][orient];
 95 | 						
 96 | 						s.draw();
 97 | 						if(mode == NONE)	{
 98 | 							label.text(State.COLS/2.0, State.ROWS/2.0, "You Lose");
 99 | 						}
100 | 						s.clearNext();
101 | 						s.drawNext(slot, orient);
102 | 						break;
103 | 					}
104 | 					default:
105 | 						break;
106 | 				}
107 | 			}
108 | 			case(NONE):	break;
109 | 			default:
110 | 				System.out.println("unknown mode");
111 | 				break;
112 | 		}
113 | 		
114 | 		
115 | 		
116 | 		
117 | 	}
118 | 
119 | 
120 | 	public void keyReleased(KeyEvent e) {
121 | 	}
122 | 
123 | 
124 | 	public void keyTyped(KeyEvent e) {
125 | 
126 | 	}
127 | 	
128 |     public void save(String filename) {
129 |         File file = new File(filename);
130 |         String suffix = filename.substring(filename.lastIndexOf('.') + 1);
131 | 
132 | 
133 |         BufferedImage bImage = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_ARGB);
134 |         Graphics2D graphic = (Graphics2D)bImage.getGraphics();
135 |         paint(graphic);
136 |         graphic.drawImage(bImage, 0, 0, null);
137 | //         png files
138 |         if (suffix.toLowerCase().equals("png")) {
139 |             try { ImageIO.write(bImage, suffix, file); }
140 |             catch (IOException e) { e.printStackTrace(); }
141 |         }
142 |         else System.out.println("unknown extension");
143 |     }
144 | 	
145 | 	public static void main(String[] args) {
146 | 		State s = new State();
147 | 		TFrame t = new TFrame(s);
148 | 		s.draw();
149 | 		s.drawNext(0,0);
150 | 		//t.save("picture.png");
151 | 		
152 | 	}
153 | }
154 | 


--------------------------------------------------------------------------------
/src/State.java:
--------------------------------------------------------------------------------
  1 | import java.awt.Color;
  2 | 
  3 | 
  4 | 
  5 | 
  6 | public class State {
  7 | 	public static final int COLS = 10;
  8 | 	public static final int ROWS = 21;
  9 | 	public static final int N_PIECES = 7;
 10 | 
 11 | 	
 12 | 
 13 | 	public boolean lost = false;
 14 | 	
 15 | 	
 16 | 	
 17 | 
 18 | 	
 19 | 	public TLabel label;
 20 | 	
 21 | 	//current turn
 22 | 	private int turn = 0;
 23 | 	private int cleared = 0;
 24 | 	
 25 | 	//each square in the grid - int means empty - other values mean the turn it was placed
 26 | 	private int[][] field = new int[ROWS][COLS];
 27 | 	//top row+1 of each column
 28 | 	//0 means empty
 29 | 	private int[] top = new int[COLS];
 30 | 	
 31 | 	
 32 | 	//number of next piece
 33 | 	protected int nextPiece;
 34 | 	
 35 | 	
 36 | 	
 37 | 	//all legal moves - first index is piece type - then a list of 2-length arrays
 38 | 	protected static int[][][] legalMoves = new int[N_PIECES][][];
 39 | 	
 40 | 	//indices for legalMoves
 41 | 	public static final int ORIENT = 0;
 42 | 	public static final int SLOT = 1;
 43 | 	
 44 | 	//possible orientations for a given piece type
 45 | 	protected static int[] pOrients = {1,2,4,4,4,2,2};
 46 | 	
 47 | 	//the next several arrays define the piece vocabulary in detail
 48 | 	//width of the pieces [piece ID][orientation]
 49 | 	protected static int[][] pWidth = {
 50 | 			{2},
 51 | 			{1,4},
 52 | 			{2,3,2,3},
 53 | 			{2,3,2,3},
 54 | 			{2,3,2,3},
 55 | 			{3,2},
 56 | 			{3,2}
 57 | 	};
 58 | 	//height of the pieces [piece ID][orientation]
 59 | 	private static int[][] pHeight = {
 60 | 			{2},
 61 | 			{4,1},
 62 | 			{3,2,3,2},
 63 | 			{3,2,3,2},
 64 | 			{3,2,3,2},
 65 | 			{2,3},
 66 | 			{2,3}
 67 | 	};
 68 | 	private static int[][][] pBottom = {
 69 | 		{{0,0}},
 70 | 		{{0},{0,0,0,0}},
 71 | 		{{0,0},{0,1,1},{2,0},{0,0,0}},
 72 | 		{{0,0},{0,0,0},{0,2},{1,1,0}},
 73 | 		{{0,1},{1,0,1},{1,0},{0,0,0}},
 74 | 		{{0,0,1},{1,0}},
 75 | 		{{1,0,0},{0,1}}
 76 | 	};
 77 | 	private static int[][][] pTop = {
 78 | 		{{2,2}},
 79 | 		{{4},{1,1,1,1}},
 80 | 		{{3,1},{2,2,2},{3,3},{1,1,2}},
 81 | 		{{1,3},{2,1,1},{3,3},{2,2,2}},
 82 | 		{{3,2},{2,2,2},{2,3},{1,2,1}},
 83 | 		{{1,2,2},{3,2}},
 84 | 		{{2,2,1},{2,3}}
 85 | 	};
 86 | 	
 87 | 	//initialize legalMoves
 88 | 	{
 89 | 		//for each piece type
 90 | 		for(int i = 0; i < N_PIECES; i++) {
 91 | 			//figure number of legal moves
 92 | 			int n = 0;
 93 | 			for(int j = 0; j < pOrients[i]; j++) {
 94 | 				//number of locations in this orientation
 95 | 				n += COLS+1-pWidth[i][j];
 96 | 			}
 97 | 			//allocate space
 98 | 			legalMoves[i] = new int[n][2];
 99 | 			//for each orientation
100 | 			n = 0;
101 | 			for(int j = 0; j < pOrients[i]; j++) {
102 | 				//for each slot
103 | 				for(int k = 0; k < COLS+1-pWidth[i][j];k++) {
104 | 					legalMoves[i][n][ORIENT] = j;
105 | 					legalMoves[i][n][SLOT] = k;
106 | 					n++;
107 | 				}
108 | 			}
109 | 		}
110 | 	
111 | 	}
112 | 	
113 | 	
114 | 	public int[][] getField() {
115 | 		return field;
116 | 	}
117 | 
118 | 	public int[] getTop() {
119 | 		return top;
120 | 	}
121 | 
122 |     public static int[] getpOrients() {
123 |         return pOrients;
124 |     }
125 |     
126 |     public static int[][] getpWidth() {
127 |         return pWidth;
128 |     }
129 | 
130 |     public static int[][] getpHeight() {
131 |         return pHeight;
132 |     }
133 | 
134 |     public static int[][][] getpBottom() {
135 |         return pBottom;
136 |     }
137 | 
138 |     public static int[][][] getpTop() {
139 |         return pTop;
140 |     }
141 | 
142 | 
143 | 	public int getNextPiece() {
144 | 		return nextPiece;
145 | 	}
146 | 	
147 | 	public boolean hasLost() {
148 | 		return lost;
149 | 	}
150 | 	
151 | 	public int getRowsCleared() {
152 | 		return cleared;
153 | 	}
154 | 	
155 | 	public int getTurnNumber() {
156 | 		return turn;
157 | 	}
158 | 	
159 | 	
160 | 	
161 | 	//constructor
162 | 	public State() {
163 | 		nextPiece = randomPiece();
164 | 
165 | 	}
166 | 	
167 | 	//random integer, returns 0-6
168 | 	private int randomPiece() {
169 | 		return (int)(Math.random()*N_PIECES);
170 | 	}
171 | 	
172 | 
173 | 
174 | 	
175 | 	//gives legal moves for 
176 | 	public int[][] legalMoves() {
177 | 		return legalMoves[nextPiece];
178 | 	}
179 | 	
180 | 	//make a move based on the move index - its order in the legalMoves list
181 | 	public void makeMove(int move) {
182 | 		makeMove(legalMoves[nextPiece][move]);
183 | 	}
184 | 	
185 | 	//make a move based on an array of orient and slot
186 | 	public void makeMove(int[] move) {
187 | 		makeMove(move[ORIENT],move[SLOT]);
188 | 	}
189 | 	
190 | 	//returns false if you lose - true otherwise
191 | 	public boolean makeMove(int orient, int slot) {
192 | 		turn++;
193 | 		//height if the first column makes contact
194 | 		int height = top[slot]-pBottom[nextPiece][orient][0];
195 | 		//for each column beyond the first in the piece
196 | 		for(int c = 1; c < pWidth[nextPiece][orient];c++) {
197 | 			height = Math.max(height,top[slot+c]-pBottom[nextPiece][orient][c]);
198 | 		}
199 | 		
200 | 		//check if game ended
201 | 		if(height+pHeight[nextPiece][orient] >= ROWS) {
202 | 			lost = true;
203 | 			return false;
204 | 		}
205 | 
206 | 		
207 | 		//for each column in the piece - fill in the appropriate blocks
208 | 		for(int i = 0; i < pWidth[nextPiece][orient]; i++) {
209 | 			
210 | 			//from bottom to top of brick
211 | 			for(int h = height+pBottom[nextPiece][orient][i]; h < height+pTop[nextPiece][orient][i]; h++) {
212 | 				field[h][i+slot] = turn;
213 | 			}
214 | 		}
215 | 		
216 | 		//adjust top
217 | 		for(int c = 0; c < pWidth[nextPiece][orient]; c++) {
218 | 			top[slot+c]=height+pTop[nextPiece][orient][c];
219 | 		}
220 | 		
221 | 		int rowsCleared = 0;
222 | 		
223 | 		//check for full rows - starting at the top
224 | 		for(int r = height+pHeight[nextPiece][orient]-1; r >= height; r--) {
225 | 			//check all columns in the row
226 | 			boolean full = true;
227 | 			for(int c = 0; c < COLS; c++) {
228 | 				if(field[r][c] == 0) {
229 | 					full = false;
230 | 					break;
231 | 				}
232 | 			}
233 | 			//if the row was full - remove it and slide above stuff down
234 | 			if(full) {
235 | 				rowsCleared++;
236 | 				cleared++;
237 | 				//for each column
238 | 				for(int c = 0; c < COLS; c++) {
239 | 
240 | 					//slide down all bricks
241 | 					for(int i = r; i < top[c]; i++) {
242 | 						field[i][c] = field[i+1][c];
243 | 					}
244 | 					//lower the top
245 | 					top[c]--;
246 | 					while(top[c]>=1 && field[top[c]-1][c]==0)	top[c]--;
247 | 				}
248 | 			}
249 | 		}
250 | 	
251 | 
252 | 		//pick a new piece
253 | 		nextPiece = randomPiece();
254 | 		
255 | 
256 | 		
257 | 		return true;
258 | 	}
259 | 	
260 | 	public void draw() {
261 | 		label.clear();
262 | 		label.setPenRadius();
263 | 		//outline board
264 | 		label.line(0, 0, 0, ROWS+5);
265 | 		label.line(COLS, 0, COLS, ROWS+5);
266 | 		label.line(0, 0, COLS, 0);
267 | 		label.line(0, ROWS-1, COLS, ROWS-1);
268 | 		
269 | 		//show bricks
270 | 				
271 | 		for(int c = 0; c < COLS; c++) {
272 | 			for(int r = 0; r < top[c]; r++) {
273 | 				if(field[r][c] != 0) {
274 | 					drawBrick(c,r);
275 | 				}
276 | 			}
277 | 		}
278 | 		
279 | 		for(int i = 0; i < COLS; i++) {
280 | 			label.setPenColor(Color.red);
281 | 			label.line(i, top[i], i+1, top[i]);
282 | 			label.setPenColor();
283 | 		}
284 | 		
285 | 		label.show();
286 | 		
287 | 		
288 | 	}
289 | 	
290 | 	public static final Color brickCol = Color.gray; 
291 | 	
292 | 	private void drawBrick(int c, int r) {
293 | 		label.filledRectangleLL(c, r, 1, 1, brickCol);
294 | 		label.rectangleLL(c, r, 1, 1);
295 | 	}
296 | 	
297 | 	public void drawNext(int slot, int orient) {
298 | 		for(int i = 0; i < pWidth[nextPiece][orient]; i++) {
299 | 			for(int j = pBottom[nextPiece][orient][i]; j <pTop[nextPiece][orient][i]; j++) {
300 | 				drawBrick(i+slot, j+ROWS+1);
301 | 			}
302 | 		}
303 | 		label.show();
304 | 	}
305 | 	
306 | 	//visualization
307 | 	//clears the area where the next piece is shown (top)
308 | 	public void clearNext() {
309 | 		label.filledRectangleLL(0, ROWS+.9, COLS, 4.2, TLabel.DEFAULT_CLEAR_COLOR);
310 | 		label.line(0, 0, 0, ROWS+5);
311 | 		label.line(COLS, 0, COLS, ROWS+5);
312 | 	}
313 | 	
314 | 
315 | 	
316 | 
317 | }
318 | 
319 | 
320 | 


--------------------------------------------------------------------------------
/src/TLabel.java:
--------------------------------------------------------------------------------
  1 | 
  2 | 
  3 | 
  4 | 
  5 | 
  6 | import java.awt.BasicStroke;
  7 | import java.awt.Color;
  8 | import java.awt.Container;
  9 | import java.awt.Font;
 10 | import java.awt.FontMetrics;
 11 | import java.awt.Graphics;
 12 | import java.awt.Graphics2D;
 13 | import java.awt.Image;
 14 | import java.awt.RenderingHints;
 15 | import java.awt.Toolkit;
 16 | import java.awt.event.KeyListener;
 17 | import java.awt.event.MouseListener;
 18 | import java.awt.event.MouseMotionListener;
 19 | import java.awt.event.MouseWheelListener;
 20 | import java.awt.geom.Arc2D;
 21 | import java.awt.geom.Ellipse2D;
 22 | import java.awt.geom.GeneralPath;
 23 | import java.awt.geom.Line2D;
 24 | import java.awt.geom.Rectangle2D;
 25 | import java.awt.image.BufferedImage;
 26 | import java.awt.image.DataBuffer;
 27 | 
 28 | import javax.swing.*;
 29 | 
 30 | 
 31 | 
 32 | public class TLabel{
 33 | 	private static final long serialVersionUID = 1L;
 34 | 	
 35 | 	public JLabel draw;
 36 | 	
 37 | 	// pre-defined colors
 38 | 	public static final Color BLACK      = Color.BLACK;
 39 | 	public static final Color BLUE       = Color.BLUE;
 40 | 	public static final Color CYAN       = Color.CYAN;
 41 | 	public static final Color DARK_GRAY  = Color.DARK_GRAY;
 42 | 	public static final Color GRAY       = Color.GRAY;
 43 | 	public static final Color GREEN      = Color.GREEN;
 44 | 	public static final Color LIGHT_GRAY = Color.LIGHT_GRAY;
 45 | 	public static final Color MAGENTA    = Color.MAGENTA;
 46 | 	public static final Color ORANGE     = Color.ORANGE;
 47 | 	public static final Color PINK       = Color.PINK;
 48 | 	public static final Color RED        = Color.RED;
 49 | 	public static final Color WHITE      = Color.WHITE;
 50 | 	public static final Color YELLOW     = Color.YELLOW;
 51 | 	public static final Color NICEGREEN = new Color(0,153,0);
 52 | 	// default colors
 53 | 	public static final Color DEFAULT_PEN_COLOR   = BLACK;
 54 | 	public static final Color DEFAULT_CLEAR_COLOR = WHITE;
 55 | 
 56 | 	// current pen color
 57 | 	private static Color penColor;
 58 | 
 59 | 	// default canvas size is SIZE-by-SIZE
 60 | 	static final int SIZE = 512;
 61 | 	public int width  = SIZE;
 62 | 	private int height = SIZE;
 63 | 
 64 | 	// default pen radius
 65 | 	private static final double DEFAULT_PEN_RADIUS = 0.002;
 66 | 
 67 | 	// current pen radius
 68 | 	private static double penRadius;
 69 | 
 70 | 	// boundary of drawing canvas, 0% border
 71 | 	public double BORDER = 0.00;
 72 | 	private static final double DEFAULT_XMIN = 0.0;
 73 | 	private static final double DEFAULT_XMAX = 1.0;
 74 | 	private static final double DEFAULT_YMIN = 0.0;
 75 | 	private static final double DEFAULT_YMAX = 1.0;
 76 | 	public double xmin, ymin, xmax, ymax;
 77 | 
 78 | 	// default font
 79 | 	private final Font DEFAULT_FONT = new Font("Serif", Font.PLAIN, 16);
 80 | 
 81 | 	// current font
 82 | 	private static Font font;
 83 | 
 84 | 	// double buffered graphics
 85 | 	private BufferedImage offscreenImage, onscreenImage;
 86 | 	protected Graphics2D offscreen, onscreen;
 87 | 	
 88 | 	// change the user coordinate system
 89 | 	public void setXscale() { setXscale(DEFAULT_XMIN, DEFAULT_XMAX); }
 90 | 	public void setYscale() { setYscale(DEFAULT_YMIN, DEFAULT_YMAX); }
 91 | 	public void setXscale(double min, double max) {
 92 | 		double size = max - min;
 93 | 		xmin = min - BORDER * size;
 94 | 		xmax = max + BORDER * size;
 95 | 	}
 96 | 
 97 | 	public void setYscale(double min, double max) {
 98 | 		double size = max - min;
 99 | 		ymin = min - BORDER * size;
100 | 		ymax = max + BORDER * size;
101 | 	}
102 | 
103 | 
104 | 	// helper functions that scale from user coordinates to screen coordinates and back
105 | 	protected double scaleX (double x) { return width  * (x - xmin) / (xmax - xmin); }
106 | 	protected double scaleY (double y) { return height * (ymax - y) / (ymax - ymin); }
107 | 	public double factorX(double w) { return w * width  / Math.abs(xmax - xmin);  }
108 | 	public double factorY(double h) { return h * height / Math.abs(ymax - ymin);  }
109 | 	public double userX  (double x) { return xmin + x * (xmax - xmin) / width;    }
110 | 	public double userY  (double y) { return ymax - y * (ymax - ymin) / height;   }
111 | 
112 | 
113 | 	//create a frame, insert self in frame, then show self
114 | 	public void showInFrame() {
115 | 		JFrame j = new JFrame();
116 | 		j.setTitle("Configuration");
117 | 		j.setContentPane(this.draw);
118 | 		j.setVisible(true);
119 | 		j.pack();
120 | 		show();
121 | 	}
122 | 	
123 | 	
124 | 	// clear the screen with given color
125 | 	public void clear() { clear(DEFAULT_CLEAR_COLOR); }
126 | 	public void clear(Color color) {
127 | 		offscreen.setColor(color);
128 | 		offscreen.fillRect(0, 0, width, height);
129 | 		offscreen.setColor(penColor);
130 | 	}
131 | 
132 | 	public void clear(double x1, double x2, double y1, double y2)
133 | 	{ clear(DEFAULT_CLEAR_COLOR, x1, x2, y1, y2);  }
134 | 	public void clear(Color color, double x1, double x2, double y1, double y2) {
135 | 
136 | 		int ix1, ix2, iy1, iy2;
137 | 		ix1 = (int) scaleX(x1);
138 | 		ix2 = (int) scaleX(x2);
139 | 		iy1 = (int) scaleY(y1);
140 | 		iy2 = (int) scaleY(y2);
141 | 
142 | 		offscreen.setColor(color);
143 | 		offscreen.fillRect(ix1, iy1, ix2, iy2);
144 | 		offscreen.setColor(penColor);
145 | 		//show();
146 | 	}
147 | 
148 | 	// set the pen size
149 | 	public void setPenRadius() { setPenRadius(DEFAULT_PEN_RADIUS); }
150 | 	public void setPenRadius(double r) {
151 | 		penRadius = r * SIZE;
152 | 		BasicStroke stroke = new BasicStroke((float) penRadius);
153 | 		offscreen.setStroke(stroke);
154 | 	}
155 | 
156 | 
157 | 
158 | 	// set the pen color
159 | 	public void setPenColor() { setPenColor(DEFAULT_PEN_COLOR); }
160 | 	public void setPenColor(Color color) {
161 | 		penColor = color;
162 | 		offscreen.setColor(penColor);
163 | 	}
164 | 
165 | 	// write the given string in the current font
166 | 	public void setFont() { setFont(DEFAULT_FONT); }
167 | 	public void setFont(Font f) { 
168 | 		Toolkit toolkit = java . awt . Toolkit . getDefaultToolkit ();
169 | 		double x = toolkit.getScreenSize().getWidth();
170 | 		double y = toolkit.getScreenSize().getHeight();
171 | 		double xscale = x/1400.0;
172 | 		double yscale = y/1050.0;
173 | 		double scale = Math.sqrt((xscale*xscale+yscale*yscale)/2);
174 | 
175 | 		font = f.deriveFont((float) (f.getSize()*scale));
176 | 	}
177 | 	
178 | 	public TLabel(int w, int h){
179 | 		width = w;
180 | 		height = h;
181 | 		offscreenImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
182 | 		onscreenImage  = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
183 | 		offscreen = offscreenImage.createGraphics();
184 | 		onscreen  = onscreenImage.createGraphics();
185 | 		setXscale();
186 | 		setYscale();
187 | 		offscreen.setColor(DEFAULT_CLEAR_COLOR);
188 | 		offscreen.fillRect(0, 0, width, height);
189 | 		setPenColor();
190 | 		setPenRadius();
191 | 		setFont();
192 | 		clear();
193 | 
194 | 		// add antialiasing
195 | 		RenderingHints hints = new RenderingHints(RenderingHints.KEY_ANTIALIASING,
196 | 				RenderingHints.VALUE_ANTIALIAS_ON);
197 | 		hints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
198 | 		offscreen.addRenderingHints(hints);
199 | 
200 | 		// frame stuff
201 | 		ImageIcon icon = new ImageIcon(onscreenImage);
202 | 		draw = new JLabel(icon);
203 | 	}
204 | 	
205 | 	public void add(Container frame, String spot){
206 | 		frame.add(draw, spot);
207 | 	}
208 | 	
209 | 
210 | 	
211 | 	public void addML(MouseListener frame){
212 | 		draw.addMouseListener(frame);
213 | 	}
214 | 	
215 | 	public void addMML(MouseMotionListener frame){
216 | 		draw.addMouseMotionListener(frame);
217 | 	}
218 | 	
219 | 	public void addKL(KeyListener frame){
220 | 		draw.addKeyListener(frame);
221 | 	}
222 | 	
223 | 	public void addMWL(MouseWheelListener frame) {
224 | 		draw.addMouseWheelListener(frame);
225 | 	}
226 | 	
227 | 	public void remML(MouseListener frame){
228 | 		draw.removeMouseListener(frame);
229 | 	}
230 | 	
231 | 	public void remMML(MouseMotionListener frame){
232 | 		draw.removeMouseMotionListener(frame);
233 | 	}
234 | 	
235 | 	public void remKL(KeyListener frame){
236 | 		draw.removeKeyListener(frame);
237 | 	}
238 | 	
239 | 	public void remMWL(MouseWheelListener frame){
240 | 		draw.removeMouseWheelListener(frame);
241 | 	}
242 | 	
243 | 	// draw a line from (x0, y0) to (x1, y1)
244 | 	public void line(double x0, double y0, double x1, double y1) {
245 | //		System.out.println("drawing a line from " + new Point(x0, y0).toString()+ " to " + new Point(x1,y1).toString());
246 | 		offscreen.draw(new Line2D.Double(scaleX(x0), scaleY(y0), scaleX(x1), scaleY(y1)));
247 | 	}
248 | 
249 | 
250 | 
251 | 	// draw one pixel at (x, y)
252 | 	public void pixel(double x, double y) {
253 | 		offscreen.fillRect((int) Math.round(scaleX(x)), (int) Math.round(scaleY(y)), 1, 1);
254 | 	}
255 | 	
256 | 	// draw one pixel at (x, y)
257 | 	public void pixelP(double x, double y) {
258 | 		offscreen.fillRect((int) Math.round(x), (int) Math.round(y), 1, 1);
259 | 	}
260 | 	
261 | 	// draw one pixel at (x, y)
262 | 	public void pixelP(double x, double y, Color c) {
263 | 		setPenColor(c);
264 | 		offscreen.fillRect((int) Math.round(x), (int) Math.round(y), 1, 1);
265 | 	}
266 | 
267 | 	// draw point at (x, y)
268 | 	public void point(double x, double y) {
269 | 		double xs = scaleX(x);
270 | 		double ys = scaleY(y);
271 | 		double r = penRadius;
272 | 		// double ws = factorX(2*r);
273 | 		// double hs = factorY(2*r);
274 | 		// if (ws <= 1 && hs <= 1) pixel(x, y);
275 | 		if (r <= 1) pixel(x, y);
276 | 		else offscreen.fill(new Ellipse2D.Double(xs - r/2, ys - r/2, r, r));
277 | 	}
278 | 
279 | 	public void arc(double x, double y, double r, double startAngle, double arcRange) {
280 | 		double xs = scaleX(x);
281 | 		double ys = scaleY(y);
282 | 		double ws = factorX(2*r);
283 | 		double hs = factorY(2*r);
284 | 		if (ws <= 1 && hs <= 1) pixel(x, y);
285 | 		else offscreen.draw(new Arc2D.Double(xs - ws/2, ys - hs/2, ws, hs,startAngle, arcRange, Arc2D.OPEN));
286 | 
287 | 	}
288 | 	
289 | 	// draw circle of radius r, centered on (x, y); degenerate to pixel if small
290 | 	public void circle(double x, double y, double r) {
291 | 		double xs = scaleX(x);
292 | 		double ys = scaleY(y);
293 | 		double ws = factorX(2*r);
294 | 		double hs = factorY(2*r);
295 | 		if (ws <= 1 && hs <= 1) pixel(x, y);
296 | 		else offscreen.draw(new Ellipse2D.Double(xs - ws/2, ys - hs/2, ws, hs));
297 | 	}
298 | 	
299 | 	public void circleP(double x, double y, double r, Color col) {
300 | 		setPenColor(col);
301 | 		circleP(x,y,r);
302 | 	}
303 | 	
304 | 	public void circleP(double x, double y, double r) {
305 | 		double ws = 2*r;
306 | 		double hs = 2*r;
307 | 		double xs = scaleX(x);
308 | 		double ys = scaleY(y);
309 | 		if (ws <= 1 && hs <= 1) pixel(x, y);
310 | 		else offscreen.draw(new Ellipse2D.Double(xs - ws/2, ys - hs/2, ws, hs));
311 | 	}
312 | 
313 | 
314 | 	
315 | 	public void circle(double x, double y, double r, Color color) {
316 | 		setPenColor(color);
317 | 		circle(x,y,r);
318 | 	}
319 | 	
320 | 	
321 | 	// draw filled circle of radius r, centered on (x, y); degenerate to pixel if small
322 | 	public void filledCircle(double x, double y, double r) {
323 | 		double xs = scaleX(x);
324 | 		double ys = scaleY(y);
325 | 		double ws = factorX(2*r);
326 | 		double hs = factorY(2*r);
327 | 		if (ws <= 1 && hs <= 1) pixel(x, y);
328 | 		else offscreen.fill(new Ellipse2D.Double(xs - ws/2, ys - hs/2, ws, hs));
329 | 	}
330 | 
331 | 
332 | 	
333 | 	public void filledCircleP(double x, double y, double r) {
334 | 		double ws = 2*r;
335 | 		double hs = 2*r;
336 | 		if (ws <= 1 && hs <= 1) pixel(x, y);
337 | 		else offscreen.fill(new Ellipse2D.Double(x - ws/2, y - hs/2, ws, hs));
338 | 	}
339 | 
340 | 	// draw squared of side length 2r, centered on (x, y); degenerate to pixel if small
341 | 	public void square(double x, double y, double r) {
342 | 		// screen coordinates
343 | 		double xs = scaleX(x);
344 | 		double ys = scaleY(y);
345 | 		double ws = factorX(2*r);
346 | 		double hs = factorY(2*r);
347 | 		if (ws <= 1 && hs <= 1) pixel(x, y);
348 | 		else offscreen.draw(new Rectangle2D.Double(xs - ws/2, ys - hs/2, ws, hs));
349 | 	}
350 | 
351 | 	// draw squared of side length 2r, centered on (x, y); degenerate to pixel if small
352 | 	public void filledSquare(double x, double y, double r) {
353 | 		// screen coordinates
354 | 		double xs = scaleX(x);
355 | 		double ys = scaleY(y);
356 | 		double ws = factorX(2*r);
357 | 		double hs = factorY(2*r);
358 | 		if (ws <= 1 && hs <= 1) pixel(x, y);
359 | 		else offscreen.fill(new Rectangle2D.Double(xs - ws/2, ys - hs/2, ws, hs));
360 | 	}
361 | 
362 | 
363 | 	//Draw an arrow of the appropriate scale, color, position
364 | 	public void Arrow(double x, double y, double w, double h, double Scale, Color Color) {
365 | 		rectangle(x, y, w, h, Color);
366 | 		double[] xarray = {x+w/2-w/10+Scale*1/10*Math.sqrt(h*h*25+w*w)*Math.sqrt(3)/3,x+w/2-w/10,x+w/2-w/10};
367 | 		double[] yarray = {y,y+Scale*1/10*Math.sqrt(h*h*25+w*w)*Math.sqrt(2)/2,y-Scale*1/10*Math.sqrt(h*h*25+w*w)*Math.sqrt(2)/2};
368 | 		setPenColor(Color);
369 | 		filledPolygon(xarray, yarray);
370 | 		setPenColor();
371 | 	}
372 | 
373 | 	// draw a polygon with the given (x[i], y[i]) coordinates
374 | 	public void polygon(double[] x, double[] y) {
375 | 		int N = x.length;
376 | 		GeneralPath path = new GeneralPath();
377 | 		path.moveTo((float) scaleX(x[0]), (float) scaleY(y[0]));
378 | 		for (int i = 0; i < N; i++)
379 | 			path.lineTo((float) scaleX(x[i]), (float) scaleY(y[i]));
380 | 		path.closePath();
381 | 		offscreen.draw(path);
382 | 	}
383 | 
384 | 
385 | 
386 | //	draw a polygon with the given (x[i], y[i]) coordinates
387 | 	public void polygonP(double[] x, double[] y) {
388 | 		int N = x.length;
389 | 		GeneralPath path = new GeneralPath();
390 | 		path.moveTo((float) x[0], (float) y[0]);
391 | 		for (int i = 0; i < N; i++)
392 | 			path.lineTo((float) x[i], (float) y[i]);
393 | 		path.closePath();
394 | 		offscreen.draw(path);
395 | 	}
396 | 
397 | 	// draw a filled polygon with the given (x[i], y[i]) coordinates
398 | 	public void filledPolygon(double[] x, double[] y) {
399 | 		int N = x.length;
400 | 		GeneralPath path = new GeneralPath();
401 | 		path.moveTo((float) scaleX(x[0]), (float) scaleY(y[0]));
402 | 		for (int i = 0; i < N; i++)
403 | 			path.lineTo((float) scaleX(x[i]), (float) scaleY(y[i]));
404 | 		path.closePath();
405 | 		offscreen.fill(path);
406 | 	}
407 | 
408 | //	draw a filled polygon with the given (x[i], y[i]) coordinates
409 | 	public void filledPolygonP(double[] x, double[] y) {
410 | 		int N = x.length;
411 | 		GeneralPath path = new GeneralPath();
412 | 		path.moveTo((float) x[0], (float) y[0]);
413 | 		for (int i = 0; i < N; i++)
414 | 			path.lineTo((float) x[i], (float) y[i]);
415 | 		path.closePath();
416 | 		offscreen.fill(path);
417 | 	}
418 | 
419 | 	//Draw rectangle at the given coordinates
420 | 	public void rectangle(double x, double y, double w, double h) {
421 | 		double[] xarray = {x-w/2,x-w/2,x+w/2,x+w/2};
422 | 		double[] yarray = {y-h/2,y+h/2,y+h/2,y-h/2};
423 | 		polygon(xarray,yarray);
424 | 	}
425 | 	
426 | 	public void rectangleLL(double x, double y, double w, double h) {
427 | 		double[] xarray = {x,x,x+w,x+w};
428 | 		double[] yarray = {y,y+h,y+h,y};
429 | 		polygon(xarray,yarray);
430 | 	}
431 | 	
432 | 	public void rectangleP(double x, double y, double w, double h) {
433 | 		double[] xarray = {x,x,x+w,x+w};
434 | 		double[] yarray = {y,y+h,y+h,y};
435 | 		polygonP(xarray,yarray);
436 | 	}
437 | 
438 | 	public void rectangle(double x, double y, double w, double h, Color c) {
439 | 		double[] xarray = {x-w/2,x-w/2,x+w/2,x+w/2};
440 | 		double[] yarray = {y-h/2,y+h/2,y+h/2,y-h/2};
441 | 		setPenColor(c);
442 | 		filledPolygon(xarray,yarray);
443 | 		setPenColor(DEFAULT_PEN_COLOR);
444 | 	}
445 | 	
446 | 	public void rectangleC(double x, double y, double w, double h, Color c) {
447 | 		double[] xarray = {x,x,x+w,x+w};
448 | 		double[] yarray = {y,y+h,y+h,y};
449 | 		setPenColor(c);
450 | 		filledPolygon(xarray,yarray);
451 | 		setPenColor(DEFAULT_PEN_COLOR);
452 | 	}
453 | 
454 | 	public void filledRectangleP(double x, double y, double w, double h, Color c) {
455 | 		double[] xarray = {x,x,x+w,x+w};
456 | 		double[] yarray = {y,y+h,y+h,y};
457 | 		setPenColor(c);
458 | 		filledPolygonP(xarray,yarray);
459 | 		setPenColor(DEFAULT_PEN_COLOR);
460 | 	}
461 | 	
462 | 	public void filledRectangleLL(double x, double y, double w, double h, Color c) {
463 | 		double[] xarray = {x,x,x+w,x+w};
464 | 		double[] yarray = {y,y+h,y+h,y};
465 | 		setPenColor(c);
466 | 		filledPolygon(xarray,yarray);
467 | 		setPenColor(DEFAULT_PEN_COLOR);
468 | 	}
469 | 
470 | 	public void rectangle(double x, double y, double w, double h, Color c,boolean Border, Color BorderColor) {
471 | 
472 | 		double[] xarray = {x-w/2,x-w/2,x+w/2,x+w/2};
473 | 		double[] yarray = {y-h/2,y+h/2,y+h/2,y-h/2};
474 | 		if (c!=null) {
475 | 			setPenColor(c);
476 | 			filledPolygon(xarray,yarray);
477 | 		}
478 | 		setPenColor(BorderColor);
479 | 		if (Border) polygon(xarray, yarray);
480 | 		setPenColor();
481 | 	}
482 | 	
483 | 
484 | 	
485 | 	// draw picture (gif, jpg, or png) upperLeft on (x, y), rescaled to w-by-h
486 | 	public void image(double x, double y, Image image, double w, double h) {
487 | 
488 | 		double xs = scaleX(x);
489 | 		double ys = scaleY(y);
490 | 		double ws = factorX(w);
491 | 		double hs = factorY(h);
492 | 		if (ws <= 1 && hs <= 1) pixel(x, y);
493 | 		else {
494 | 			offscreen.drawImage(image, (int) Math.round(xs),
495 | 					(int) Math.round(ys),
496 | 					(int) Math.round(ws),
497 | 					(int) Math.round(hs), null);
498 | 		}
499 | 	}
500 | 	
501 | 	// draw picture (gif, jpg, or png) upperLeft on (x, y), rescaled to w-by-h
502 | 	public void imageP(double x, double y, Image image) {
503 | 
504 | 		//if (ws <= 1 && hs <= 1) pixel(x, y);
505 | 
506 | 		offscreen.drawImage(image, (int) Math.round(x),(int) Math.round(y), null);
507 | 		
508 | 	}
509 | 	
510 | 
511 | 
512 | 	//Invert an image
513 | 	public BufferedImage invert(Image image) {
514 | 		BufferedImage b1 = new BufferedImage(image.getWidth(null),image.getHeight(null),BufferedImage.TYPE_INT_RGB);
515 | 		Graphics bg = b1.getGraphics();
516 | 		bg.drawImage(image, 0, 0, null);
517 | 		bg.dispose();
518 | 
519 | 		BufferedImage b2 = new BufferedImage(image.getWidth(null),image.getHeight(null),BufferedImage.TYPE_INT_RGB);
520 | 		DataBuffer db1 = b1.getRaster().getDataBuffer();
521 | 		DataBuffer db2 = b2.getRaster().getDataBuffer();
522 | 
523 | 		for (int i = db1.getSize() - 1, j = 0; i >= 0; --i, j++) {
524 | 			db2.setElem(j, db1.getElem(i));
525 | 
526 | 		}
527 | 		for (int i = db1.getSize() - 1, j = 0; i >= 0; --i, j++) {
528 | 			db1.setElem(i, db1.getElem(i));
529 | 
530 | 		}
531 | 		return b2;	  
532 | 	}
533 | 
534 | 
535 | 
536 | 
537 | 	// write the given text string in the current font, center on (x, y)
538 | 	public void text(double x, double y, String s) {
539 | 		offscreen.setFont(font);
540 | 		FontMetrics metrics = offscreen.getFontMetrics();
541 | 		double xs = scaleX(x);
542 | 		double ys = scaleY(y);
543 | 		int ws = metrics.stringWidth(s);
544 | 		int hs = metrics.getDescent();
545 | 		offscreen.drawString(s, (float) (xs - ws/2.0), (float) (ys + hs));
546 | 	}
547 | 	
548 | 	public void textTop(double x, double y, String s) {
549 | 		offscreen.setFont(font);
550 | 		FontMetrics metrics = offscreen.getFontMetrics();
551 | 		double xs = scaleX(x);
552 | 		double ys = scaleY(y);
553 | 		int ws = metrics.stringWidth(s);
554 | 		int hs = metrics.getDescent();
555 | 		offscreen.drawString(s, (float) (xs - ws/2.0), (float) (ys + hs*3));
556 | 	}
557 | 
558 | 	public void textLeft(double x, double y, String s,Color c) {
559 | 		setPenColor(c);
560 | 		offscreen.setFont(font);
561 | 		FontMetrics metrics = offscreen.getFontMetrics();
562 | 		double xs = scaleX(x);
563 | 		double ys = scaleY(y);
564 | 		//int ws = metrics.stringWidth(s);
565 | 		int hs = metrics.getDescent();
566 | 		offscreen.drawString(s, (float) (xs), (float) (ys + hs));
567 | 		setPenColor();
568 | 	}
569 | 
570 | 
571 | 	//Draw text at the appropriate point and color
572 | 	public void text(double x, double y, String s,Color c) {
573 | 		setPenColor(c);
574 | 		offscreen.setFont(font);
575 | 		FontMetrics metrics = offscreen.getFontMetrics();
576 | 		double xs = scaleX(x);
577 | 		double ys = scaleY(y);
578 | 		int ws = metrics.stringWidth(s);
579 | 		int hs = metrics.getDescent();
580 | 		offscreen.drawString(s, (float) (xs - ws/2.0), (float) (ys + hs));
581 | 		setPenColor();
582 | 	}
583 | 
584 | //	write the given text string in the current font, center on (x, y) sized to w, h
585 | 	public void text(double x, double y, String s, double w, double h) {
586 | 		offscreen.setFont(font);
587 | 		//FontMetrics metrics = offscreen.getFontMetrics();
588 | 		double xs = scaleX(x);
589 | 		double ys = scaleY(y);
590 | 		double ws = factorX(w);
591 | 		double hs = factorY(h);
592 | 		offscreen.drawString(s, (float) (xs - ws/2.0), (float) (ys + hs));
593 | 	}
594 | 
595 | 	public void absText(String s, int x, int y) {
596 | 		offscreen.drawString(s, (float) (x), (float) (y));
597 | 	}
598 | 	
599 | 	public void textinvert(double x, double y, String s) {
600 | 		offscreen.setFont(font);
601 | 		FontMetrics metrics = offscreen.getFontMetrics();
602 | 		double xs = scaleX(x);
603 | 		double ys = scaleY(y);
604 | 		int ws = metrics.stringWidth(s);
605 | 		int hs = metrics.getDescent();
606 | 		BufferedImage bimage = new BufferedImage(ws, hs,BufferedImage.TYPE_INT_ARGB);
607 | 		Graphics2D bimagegraphics = bimage.createGraphics();
608 | 		bimagegraphics.drawString(s, (float) (xs - ws/2.0), (float) (ys + hs));
609 | 		BufferedImage bimage2 = invert(bimage);
610 | 		offscreen.drawImage(bimage2, (int) Math.round(xs - ws/2.0),
611 | 				(int) Math.round(ys + hs), null);
612 | 	}
613 | 	
614 | 	
615 | 
616 | 	
617 | 	// view on-screen, creating new frame if necessary
618 | 	public void show() {
619 | 		onscreen.drawImage(offscreenImage, 0, 0, null);
620 | 		try{
621 | 			draw.repaint();
622 | 			//frame.paint(frame.getGraphics());
623 | 		}
624 | 		catch(NullPointerException e){
625 | 			System.out.println("Null Pointer Exception in showatonce");
626 | 		}
627 | 
628 | 	}
629 | 
630 | 	
631 | 
632 | 
633 | 	
634 | 
635 | 	
636 | 	
637 | 
638 | 	
639 | }
640 | 


--------------------------------------------------------------------------------