In the past, you have had experience using Swing components to develop Graphical User Interfaces (GUIs). This lab will expand these skills and give you the ability to create customized graphics by using the Graphics[2D] class. By the end of the lab, you will have created a simple paint program using these new GUI creation skills.

In Java, manipulation of Graphics objects is not a particularly difficult task. Since the Graphics class is abstract, you cannot directly create one by calling its constructor. You must instead obtain them from previously defined Graphics objects or by calling the getGraphics() method on a Component(java.awt.Component) or any of its subclasses. Before you call the getGraphics() method on a component, it must be displayable (i.e. the [J]Frame to which the component is added must be visible - [J]Frame.setVisible(true)). Once you have a Graphics object, you can begin to manipulate it. Graphics objects have methods used to draw basic shapes, such as characters, strings, polygons, but anything more complex will require you to combine shapes to achieve the desired output. Look at the Java API (java.awt.Graphics) for the exact commands necessary to do this. Unfortunately, accessing graphics in this manner causes some problems (mainly every time the window is changed - minimized, resized, overlapped by another window, etc... - the graphic you just made will be erased). To correct this problem, you need to override the paintComponent() method in the Component whose Graphic you wish to access. This method is called every time the window needs to be redrawn, so by doing all of your Graphics changes in this method you will fix the aforementioned problem of losing your Graphic.

The Graphics2D class in Java allows for more flexibility when rendering Graphical Objects (Graphics objects can be cast to Graphics2D objects). Check out this Graphics2D tutorial for more information on this subject. Other sections of the Java tutorial may be of additional assistance.

We've provided a simple Graphics example, BasicGraphics.java, that shows you what can be done with basic calls to a Graphics object.

Although you will not be required to animate anything in this lab, it might be helpful to look over this section for help in future labs (wink, wink).

Making something animated is as simple as creating a Timer that periodically repaints the components to be animated.Java implements a Timer(javax.swing.Timer) to be used in animations. A Timer requires an actionListener and a delay. After you call start() on the Timer, the actionListener will be called every "delay" milliseconds. The actionListener will make the changes necessary to create the next frame and then call repaint on the component, which actually renders it.

Drawing straight to the screen is a bad idea - it looks really bad, since the individual objects will be drawn to the screen in a delayed fashion, instead of all at once. To avoid this problem, a technique called double buffering comes into play. Double buffering is a method that renders the next image to be displayed in an off-screen buffer and then swaps it with the current image (do a search on Google for double buffering in Java for some good examples). However, thanks to the helpful people at sun, if you use Swing Components, double buffering is done for you.

We've also provided you with an Animation example, SimpleAnimation.java.

Since its nearly impossible to get the complete desired graphical effects and animations by simply using Graphics2D, images often need to come into play. While there are numerous image subclasses, and practically infinite combination of ways to load them, for the sake of simplicity and speed its recommended to use BufferedImages. A BufferedImage can be drawn from a Graphics(2D) object's drawImage(...) methods, the tricky part is efficiently loading an image.

To load a BufferedImage from a file, the class you should be interested in is javax.imageio.ImageIO and more specifically the read(URL ...) method You'll notice the method is static, so there is no need to init the class and can simply be used as such below:

BufferedImage toLoad = javax.imageio.ImageIO.read( getClass().getResource("myImage.png"));

The getClass().getResource(...) method calls are simply a way to return a URL from path, referenced from the current classes location. The read(...) method used as such above, well return a fully loaded BufferedImage, meaning that you will NOT have worry about using something such as the MediaTracker to ensure the image is ready to be drawn.

If after using BufferedImages, you find your frame-rate is still being hindered, you can attempt to pass off some of the work to the graphics card by making the images hardware accelerated.

	import java.awt.*;
	import java.awt.image.*;
	public class ImageLoader
	{
	   final GraphicsConfiguration gc;

	   public ImageLoader(GraphicsConfiguration gc)
	   {
	      if(gc==null)
	      {
        	 gc = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
	      }
	      this.gc = gc;
	   }

	   public BufferedImage loadImage(String resource)
	   {
	      try
	      {
	         BufferedImage src = javax.imageio.ImageIO.read(getClass().getResource(resource));
	         BufferedImage dst = gc.createCompatibleImage(src.getWidth(),src.getHeight(),src.getColorModel().getTransparency());
	         Graphics2D g2d = dst.createGraphics();
	         g2d.setComposite(AlphaComposite.Src);
	         g2d.drawImage(src,0,0,null);
	         g2d.dispose();
	         return dst;
	      }
	      catch(java.io.IOException e)
	      {
	         return null;
	      }
	   }
	}
	

With a class similar to above, using the loadImage(...) method will return a fully accelerated BufferedImage ready to be rendered. If you look more carefully at the loadImage(...) method you should already see concepts that are/will be familiar to you. A BufferedImage has Graphics2D object that can be directly drawn upon just like any other rendering surface. The loadImage(...) method simply loads an image through the method explained above, then creates another "blank" BufferedImage with acceleration, and then proceeds to draw the first image onto the second. If desired, you could add further code below the g2d.drawImage(...) to draw lines/text/etc that would be permanently stored upon the image.

Threads allow multiple concurrent paths of execution. In Java, there are different ways to create a new thread:

When running on a machine with multiple processors, multiple threads can actually run at the same time. Under normal circumstances, on uniprocessor machines, the threads are time-shared, rapidly switching back and forth, simulating concurrent execution.

A class which is going to run as its own thread needs to have a method called run declared as public and void, with no arguments. When the thread is started with start(), run will be called and will run separately from the rest of the program.

We've provided an extremely simple threaded example called ThreadExample.java.

If you try this out, you'll see that "String One" and "String Two" will be printed on the console in some random order, since both threads are running at once and sleeping random amounts between messages.

Threads are important in a wide variety of applications. One of their most important applications is networking. Traditional networking makes heavy use of threads, because traditional networking uses blocking I/O. In other words, when you call a function, it doesn't return until it's finished. When you wait for a client to connect, you can't continue until you receive a connection. When you want to read from a connection, you can't continue until you've filled your buffer. When you write to a socket, you can't continue until all of the data has been written. Without threads, it would be nearly impossible to do anything useful since you would always be waiting on one client, unable to handle all the others.

This is where threads come in. On the server end, each client will get its own thread. That way, the blocking operations each block in their own threads, without affecting any of the other threads. On the client end, each client-server and client-client connection gets its own thread. In addition, the user interface gets its own thread, so that the user can interact with the program even when all of the network connections are blocking.