Practice It 3G

panel.setWidth(width);panel.setHeight(height);panel.setSize(width, height);

Changes the drawing panel's size to the given value(s).

To create a window(canvas):

DrawingPanel name = new DrawingPanel(width, height); Example: DrawingPanel panel = new DrawingPanel(300, 200);//will create 300 x 200 window

The following code attempts to draw a black rectangle from (10, 20) to (50, 40) with a line across its diagonal: DrawingPanel panel = new DrawingPanel(200, 100); Graphics g = panel.getGraphics(); g.drawRect(10, 20, 50, 40); g.drawLine(10, 20, 50, 40);

DrawingPanel panel = new DrawingPanel(200, 100); Graphics g = panel.getGraphics(); g.drawRect(10, 20, 40, 20); g.drawLine(10, 20, 50, 40);

The following code attempts to draw a filled black outer rectangle with a white filled inner circle inside it: DrawingPanel panel = new DrawingPanel(200, 100); Graphics g = panel.getGraphics(); g.setColor(Color.WHITE); g.fillOval(10, 10, 50, 50); g.setColor(Color.BLACK); g.fillRect(10, 10, 50, 50);

DrawingPanel panel = new DrawingPanel(200, 100); Graphics g = panel.getGraphics(); g.setColor(Color.BLACK); g.fillRect(10, 10, 50, 50); g.setColor(Color.WHITE); g.fillOval(10, 10, 50, 50);

There are three mistakes in the following code, which attempts to draw a line from coordinates (50, 86) to (20, 35): DrawingPanel panel = new DrawingPanel(200, 200); panel.drawLine(50, 20, 86, 35);

DrawingPanel panel = new DrawingPanel(200, 200); Graphics g = panel.getGraphics(); g.drawLine(50, 86, 20, 35);

panel.clear();

Erases any shapes that are drawn on the drawing panel.

"Pen" or "paint brush" objects to draw lines and shapes- Access it by calling getGraphics on your DrawingPanel.

Graphics g = panel.getGraphics();• ex. Draw shapes by calling methods on the Graphics object. g.fillRect(10, 30, 60, 35); g.fillOval(80, 40, 50, 70);

panel.sleep(ms);

Pauses the drawing for the given number of milliseconds.

panel.save(filename);

Saves the image on the panel to the given file (String).

import java.awt.*; ​ public class Draw7 { public static void main(String[] args) { DrawingPanel panel = new DrawingPanel(200, 200); Graphics g = panel.getGraphics(); for (int i = 0; i < 20; i++) { g.drawOval(i * 10, i * 10, 200 - (i * 10), 200 - (i * 10)); } } } What graphical output figure will be drawn by the Draw7 program?

circles facing towards bottom right corner*

g.fillOval(x, y, width, height);

fill largest oval that fits in a box of sizewidth *height with top-left at (x,y)

g.fillRect(x, y, width, height);

fill rectangle of sizewidth *height withtop-left at (x,y)

Which of the following is the correct syntax to draw a rectangle?

g.drawRect(10, 20, 50, 30);

Modify your Stairs program from the previous exercise to make a new class Stairs2 that draws the output shown below. Modify only the body of your loop. (You may want to make a new table to find the expressions for x, y, width, and height for each new output.)

import java.awt.*; public class Stairs2{ public static void main(String[] args) { DrawingPanel panel = new DrawingPanel(110, 110); Graphics g = panel.getGraphics(); for (int i=0; i<10; i++) { g.drawRect(5, 5+i*10, 100-i*10, 10); } } }

g.drawLine(x1, y1, x2, y2);

line between points (x1,y1), (x2,y2)

g.drawOval(x, y, width, height);

outline largest oval that fits in a box of sizewidth *height with top-left at (x,y)

g.drawRect(x, y, width, height);

outline of rectangle of sizewidth *height with top-left at (x,y)

Suppose you have the following existing program called Face that uses the DrawingPanel to draw a face figure. Modify the program to draw the graphical output shown below. Do so by writing a parameterized static method that draws a face at different positions. The window size should be changed to 320 x 180 pixels, and the two faces' top-left corners are at (10, 30) and (150, 50). DrawingPanel

public class Face { public static void main(String[] args) { DrawingPanel panel = new DrawingPanel(320, 180); Graphics g = panel.getGraphics(); drawFace(g, 10, 30); drawFace(g, 150, 50); } public static void drawFace(Graphics g, int x, int y) { g.setColor(Color.BLACK); g.drawOval(x, y, 100, 100); // face outline g.setColor(Color.BLUE); g.fillOval(x + 20, y + 30, 20, 20); // eyes g.fillOval(x + 60, y + 30, 20, 20); g.setColor(Color.RED); // mouth g.drawLine(x + 30, y + 70, x + 70, y + 70); } }

Modify your Face program from the previous exercise into a new class Face2 to draw the new output shown below. The window size should be changed to 520 x 180 pixels, and the faces' top-left corners are at (10, 30), (110, 30), (210, 30), (310, 30), and (410, 30). Draw the figures using a loop to avoid redundancy.

public class Face2 { public static void main(String[] args) { DrawingPanel panel = new DrawingPanel(520, 180); Graphics g = panel.getGraphics(); for(int i = 0; i < 5; i++) drawFace(g, 10 + 100 * i, 30); } public static void drawFace(Graphics g, int x, int y) { g.setColor(Color.BLACK); g.drawOval(x, y, 100, 100); // face outline g.setColor(Color.BLUE); g.fillOval(x + 20, y + 30, 20, 20); // eyes g.fillOval(x + 60, y + 30, 20, 20); g.setColor(Color.RED); // mouth g.drawLine(x + 30, y + 70, x + 70, y + 70); } }

Using the DrawingPanel class, write a Java class named Football that produces the following figure: DrawingPanel (247, 67) Though the figure looks to contain curves, it is made entirely of straight lines. The window is 250 x 250 pixels in size, and there is an outer rectangle from (10, 30) to (210, 230). A set of black lines are drawn around the edges every 10 pixels. For example, along the top-left, there is a line from (10, 220) to (20, 30), a line from (10, 210) to (30, 30), a line from (10, 200) to (40, 30), ... and so on. Along the bottom-right, there is a line from (20, 230) to (210, 220), a line from (30, 230) to (210, 210), and so on.

public class Football { public static void main(String[] args) { DrawingPanel panel = new DrawingPanel(250, 250); Graphics g = panel.getGraphics(); g.setColor(Color.black); g.drawRect(10, 30, 200, 200); for(int i = 0; i < 20; i++) { int x1 = 10; int y1 = 220 - 10 * i; int x2 = 20 + 10 * i; int y2 = 30; g.drawLine(x1, y1, x2, y2); g.drawLine(x2, 230, 210, y1); } } }

Write a complete program in a class named MickeyBox that uses the DrawingPanel to draw the following figure: DrawingPanel (216, 142) The window is 220 pixels wide and 150 pixels tall. The background is yellow. There are two blue ovals of size 40 x 40 pixels. The left oval's top-left corner is located at position (50, 25), and the two ovals' top-left corners are 80 pixels apart horizontally. There is a red square whose top two corners exactly intersect the centers of the two ovals. Lastly, there is a black horizontal line through the center of the square. (You don't need to include any import statements at the top of your program.) (The next exercise is a modified version of this program, so you can use the code you write here as a starting point for that exercise.)

public class MickeyBox { public static void main(String[] args) { DrawingPanel panel = new DrawingPanel(220, 150); Graphics g = panel.getGraphics(); g.setColor(Color.YELLOW); g.fillRect(0, 0, 220, 150); g.setColor(Color.BLUE); g.fillOval(50, 25, 40, 40); g.fillOval(130, 25, 40, 40); g.setColor(Color.RED); g.fillRect(70, 45, 80, 80); g.setColor(Color.BLACK); g.drawLine(70, 85, 150, 85); } }

Modify your MickeyBox program from the previous exercise into a new class MickeyBox2 so that the figure is drawn by a method called drawFigure. The method should accept three parameters: the Graphics g of the DrawingPanel on which to draw, and two ints specifying the (x, y) position of the top-left corner of the figure. Use the following heading for your method public static void drawFigure(Graphics g, int x, int y) Set your DrawingPanel's size to 450 x 150 pixels, and use your drawFigure method to place two figures on it. One figure should be at position (50, 25) and the other should be at position (250, 45).

public class MickeyBox2 { public static void main(String[] args) { DrawingPanel panel = new DrawingPanel(450, 150); Graphics g = panel.getGraphics(); g.setColor(Color.YELLOW); g.fillRect(0, 0, 450, 150); drawFigure(g, 50, 25); drawFigure(g, 250, 45); } public static void drawFigure(Graphics g, int x, int y) { g.setColor(Color.BLUE); g.fillOval(x, y, 40, 40); g.fillOval(x + 80, y, 40, 40); g.setColor(Color.RED); g.fillRect(x + 20, y + 20, 80, 80); g.setColor(Color.BLACK); g.drawLine(x + 20, y + 60, x + 100, y + 60); } }

Write a complete program in a class named ShowDesign that uses the DrawingPanel to draw the following figure: DrawingPanel (181, 92) The window is 200 pixels wide and 200 pixels tall. The background is white and the foreground is black. There are 20 pixels between each of the four rectangles, and the rectangles are concentric (their centers are at the same point). Use a loop to draw the repeated rectangles.

public class ShowDesign { public static void main(String[] args) { DrawingPanel panel = new DrawingPanel(200, 200); Graphics g = panel.getGraphics(); for(int i = 0; i < 4; i++) g.drawRect(20 + 20 * i, 20 + 20 * i, 160 - 40 * i, 160 - 40 * i); } }

Modify your ShowDesign class from the previous exercise into a new class ShowDesign2 that has a method named showDesign that accepts parameters for the window width and height and displays the rectangles at the appropriate sizes. For example, if your showDesign method was called with values of 300 and 100, the window would look like the following figure.

public class ShowDesign2 { public static void main(String[] args) { showDesign(300, 100); } public static void showDesign(int width, int height) { DrawingPanel panel = new DrawingPanel(width, height); Graphics g = panel.getGraphics(); for(int i = 1; i <= 4; i++) g.drawRect(30 * i, 10 * i, width - 60 * i, height - 20 * i); } }

Write a program in a class named Squares that uses the DrawingPanel to draw the following figure: DrawingPanel (299, 53) The drawing panel is 300 pixels wide by 200 pixels high. Its background is cyan. The horizontal and vertical lines are drawn in red and the diagonal line is drawn in black. The upper-left corner of the diagonal line is at (50,50). Successive horizontal and vertical lines are spaced 20 pixels apart. The diagonal line is drawn on top of the horizontal and vertical lines.

public class Squares { public static void main(String[] args) { DrawingPanel panel = new DrawingPanel(300, 200); Graphics g = panel.getGraphics(); g.setColor(Color.CYAN); g.fillRect(0, 0, 300, 200); g.setColor(Color.RED); for(int i = 1; i <= 5; i++) g.drawRect(50, 50, 20 * i, 20 * i); g.setColor(Color.BLACK); g.drawLine(50, 50, 150, 150); } }

Modify your Squares program from the previous exercise into a new class Squares2 that draws the following figures. (Go back to that problem and copy/paste your code here as a starting point.) DrawingPanel (399, 99) The drawing panel is now 400 by 300 pixels in size. The first figure is at the same position, (50,50). The other figures are at positions (250, 10) and (180, 115), respectively. Use one or more parameterized static methods to reduce the redundancy of your solution.

public class Squares2 { public static void main(String[] args) { DrawingPanel panel = new DrawingPanel(400, 300); Graphics g = panel.getGraphics(); g.setColor(Color.CYAN); g.fillRect(0, 0, 400, 300); drawFigure(g, 50, 50); drawFigure(g, 250, 10); drawFigure(g, 180, 115); } public static void drawFigure(Graphics g, int x, int y) { g.setColor(Color.RED); for(int i = 1; i <= 5; i++) g.drawRect(x, y, 20 * i, 20 * i); g.setColor(Color.BLACK); g.drawLine(x, y, x + 100, y + 100); } }

Modify your Squares2 program from the previous exercise into a new class Squares3 that draws the following figures. (Go back to that problem and copy/paste your code here as a starting point.) Parameterize your program so that the figures have the sizes shown below. The top-right figure has size 50, and the bottom-right figure has size 180.

public class Squares3 { public static void main(String[] args) { DrawingPanel panel = new DrawingPanel(400, 300); Graphics g = panel.getGraphics(); g.setColor(Color.CYAN); g.fillRect(0, 0, 400, 300); drawFigure(g, 50, 50, 100); drawFigure(g, 250, 10, 50); drawFigure(g, 180, 115, 180); } public static void drawFigure(Graphics g, int x, int y, int size) { int separation = size / 5; g.setColor(Color.RED); for(int i = 1; i <= 5; i++) g.drawRect(x, y, separation * i, separation * i); g.setColor(Color.BLACK); g.drawLine(x, y, x + size, y + size); } }

Finish the given program called Stairs that uses the DrawingPanel to draw the figure shown below. The window is 110 x 110 px in size. The first stair's top-left corner is at position (5, 5). The first stair is 10 x 10 pixels in size. Each stair is 10 pixels wider than the one above it. (If you're having trouble matching the output, make a table with the (x, y) coordinates and (width x height) sizes of the first five stairs. Note which values change and which ones stay the same.)

public class Stairs { public static void main(String[] args) { DrawingPanel panel = new DrawingPanel(110, 110); Graphics g = panel.getGraphics(); for(int i = 0; i < 10; i++) { g.drawRect(5, 5 + 10 * i, 10 + 10 * i, 10); } } }

Modify your Stairs program from the previous exercise to make a new class Stairs3 that draws the output shown below. Modify only the body of your loop.

public class Stairs3 { public static void main(String[] args) { DrawingPanel panel = new DrawingPanel(110, 110); Graphics g = panel.getGraphics(); for (int i = 1; i <= 10; i++) { g.drawRect(105 - i * 10 , i * 10 - 5,10 * i, 10); } } }

Modify your Stairs program from the previous exercise to make a new class Stairs4 that draws the output shown below. Modify only the body of your loop.

public class Stairs4 { public static void main(String[] args) { DrawingPanel panel = new DrawingPanel(110, 110); Graphics g = panel.getGraphics(); for(int i = 0; i < 10; i++) { g.drawRect(5 + 10 * i, 5 + 10 * i, 100 - 10 * i, 10); } } }

Using the DrawingPanel class, write a Java class named Triangle that produces the following figure: DrawingPanel (593, 191) size: 600x200 background color: yellow line color: blue vertical spacing between lines: 10 px The diagonal lines connect at the bottom in the middle.

public class Triangle { public static void main(String[] args) { DrawingPanel panel = new DrawingPanel(600, 200); Graphics g = panel.getGraphics(); g.setColor(Color.YELLOW); g.fillRect(0, 0, 600, 200); g.setColor(Color.BLUE); for(int y = 10; y < 200; y += 10) { int x1 = 3 * y / 2; int x2 = 3 * (400 - y) / 2; g.drawLine(x1, y, x2, y); } g.drawLine(0, 0, 300, 200); g.drawLine(300, 200, 600, 0); } }

g.setColor(Color);

set Graphics to paint any followingshapes in the given color

g.drawString(text, x, y);

text with bottom-left at(x, y)