public BufferedImage changeColor(BufferedImage inImage, Color oldColor,
                  Color newColor) {
            
            // Get the width and the height of the image we're going to change.
            int imageHeight = inImage.getHeight();
            int imageWidth = inImage.getWidth();
            
            // Get the old color we want to change in the integer (ARGB) form.
            int targetColor = oldColor.getRGB();
            
            // Create a single-dimension array that has enough room to hold all
            // the pixels of the changing image.
            int[] imagePixels = new int[imageWidth * imageHeight];

            // A PixelGrabber simply populates the above array with all the ARGB
            // values of the image we want to change.
            PixelGrabber pixelGrabber = new PixelGrabber(inImage, 0, 0,
                        imageWidth, imageHeight, imagePixels, 0, imageWidth);
            
            try {
                  pixelGrabber.grabPixels();
            }
            catch (InterruptedException iE) {
                  iE.printStackTrace();
                  return inImage;
            }
            
            // Make sure no errors occured.  If they do, just give back the
            // original image.
            if ((pixelGrabber.getStatus() & ImageObserver.ERROR) != 0) {
                  System.err.println("Pixel-grabbing aborted or errored.");
                  return inImage;
            }
            
            // Create another array.  This array will be another array of pixels,
            // but is intended to store the changed values.
            int[] newPixels = new int[imageHeight * imageWidth];
            
            // Create an Image made from a MemoryImageSource.  As we change the
            // values of the pixels, the resultant MemoryImageSource will change
            // thus the Image will change as well.
            Image newImage = thisToolkit.createImage(new MemoryImageSource(
                        imageWidth, imageHeight, ColorModel.getRGBdefault(),
                        newPixels, 0, imageWidth));
            
            // Iterate through our ENTIRE set of old pixels.
            for (int y = 0; y < imageHeight; y++) {
                  for (int x = 0; x < imageWidth; x++) {
                        
                        // Get the current pixel value and compare it against the value
                        // of the color we want to change.  If they're not the same,
                        // don't change the original value.
                        int currentPixel = imagePixels[x + y * imageWidth];
                        if (currentPixel != targetColor) {
                              newPixels[x + y * imageWidth] = currentPixel;
                        }
                        
                        // Otherwise, change the value to the NEW color value.
                        else {
                              newPixels[x + y * imageWidth] = newColor.getRGB();
                        }
                  }
            }
            
            // Flushing the Image in this case flushes any buffered pixel data to
            // ensure all our changes have been applied to the Image.
            if (newImage != null) {
                  newImage.flush();
            }
            
            // Now we want an Image to return to the user.  Of course we want it
            // to be a candidate for hardware-acceleration, so we use another
            // method of this class to ensure that.
            BufferedImage returnImage = createImage(imageWidth, imageHeight,
                        inImage.getColorModel().getTransparency());
            
            // Draw the new Image to our returnImage and, well, return it!
            Graphics2D returnGraphics = returnImage.createGraphics();
            returnGraphics.setComposite(AlphaComposite.Src);
            returnGraphics.drawImage(newImage, 0, 0, imageWidth, imageHeight,
                        0, 0, imageWidth, imageHeight, null);
            returnGraphics.dispose();
            return returnImage;
      }