Basic Image Manipulation in Java

/*
 * In this project we introduce the awt toolkit:
 *    http://java.sun.com/j2se/1.4.2/docs/api/java/awt/Toolkit.html
 * 
 * 1. We create a frame.
 * 2. We create and load an image in the frame.
 * 3. Eventually the image gets displayed in the frame by a higher power.
 *
 * 
 * Adapted by: nicomp: http://hubpages.com/profile/nicomp
 * 
 * This gets a bit confusing but the bottom line is that you need a graphics context object
 *   in order to draw stuff. You only get that from the JVM. See the paint() method below.
 */

import java.awt.*;
import java.awt.image.*;
import java.net.URL;

/**
 * Image Loader Demo class
 * <br>We are inheriting the properties and methods of the frame class.
 * <br>Since the frame class is our super class, we will have access to a graphics context object.
 * @author: nicomp http://hubpages.com/profile/nicomp
 */
public class ImageLoaderDemo extends Frame {

//  Here is where we will store our image.
    private Image mImage;
//  We would like to do this with a BufferedImage object, but the awt toolkit can't handle buffered image objects
//  static private BufferedImage mImage

//  We will keep track of how many times the image is repainted.
    int imageUpdateCallCount;

    /**
     *   Constructor
     *   <br>url = the Universal Resource Locator (web address) of the image to load.
     *   <br>It would be nice to add a listener. Using the Task Manager to close the window is a drag.
     */
    public ImageLoaderDemo(URL url) {
        super("Image Loader Demo");   // Call the base class constructor (a Frame object)
        imageUpdateCallCount = 0;

//      Built-in methods to manipulate images, and do other stuff.
//      It's called the "Toolkit" and it's part of the awt package.
//      getImage() can also handle file names on the local network.
        mImage = java.awt.Toolkit.getDefaultToolkit().getImage(url);
        rightSize();
    }

    /**
     *   Adjust the image so it will display properly.
     */
    private void rightSize() {
        int width = mImage.getWidth(this);
        int height = mImage.getHeight(this);
        if (width == -1 || height == -1) {
            return;
        }
//      Look up the border size for this image, if any.
        Insets insets = getInsets();
//      Resize the container to handle the borders.
        setSize(width + insets.left + insets.right, height + insets.top + insets.bottom);
//      Make the frame visible.
        setVisible(true);
    }

    /**
     * A call-back method that is referenced by the base class (Frame)
     *  to configure the image. 
     * Note that this method is not called explicitly in this project.
     * The point is that we would never know this was necessary unless we
     *  studied a working example.
     * @param img
     * @param infoflags
     * @param x
     * @param y
     * @param width
     * @param height
     * @return
     */
    public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height) {
//      This gets a little odd: we will see that this method is called quite a few times.
        System.out.println("imageUpdate()" + imageUpdateCallCount++);
        if ((infoflags & ImageObserver.ERROR) != 0) {
            System.out.println("Error loading image!");
            System.exit(-1);
        }
        if ((infoflags & ImageObserver.WIDTH) != 0 && (infoflags & ImageObserver.HEIGHT) != 0) {
            rightSize();
        }
        if ((infoflags & ImageObserver.SOMEBITS) != 0) {
            repaint();  // This triggers a call to paint() (see below)
        }
        if ((infoflags & ImageObserver.ALLBITS) != 0) {
            rightSize();
            repaint();  // This triggers a call to paint() (see below)
            return false;
        }
        return true;
    }

    /**
     * Ditto. See comments for imageUpdate method
     * @param g
     */
//    public void update(Graphics g) {
//        paint(g);
//    }

    /**
     * Called by update() which is called by ... who knows.
     * Whoever calls this will send us a Graphics Context object to draw onto.
     * See comments for imageUpdate method.
     * @param g
     */
    public void paint(Graphics g) {
        Insets insets = getInsets();
        g.drawImage(mImage, insets.left, insets.top, this);
    }
}

/*
 * Entry point for test main.
 * 
 */
import java.net.URL;    // Convert a string object to a URL object

/**
 * Entry Point for ImageLoaderDemo class.
 * @author nicomp: http://hubpages.com/profile/nicomp
 */
public class Main {
//  Entry point for the project.
  public static void main(String[] args) throws Exception {
    String url = "http://s1.hubimg.com/u/2305196_177.jpg";
    if (args.length > 0) url = args[0];

//  Instantiate an object of type ImageLoaderDemo.
//  We don't need a handle on it; we just want the constructor of the ImageLoaderDemo class to be called.
    new ImageLoaderDemo(new URL(url));  // The URL constructor is called too.
//  The frame persists when the main ends.
  }
}