user/src/com/google/gwt/user/rebind/ui/ImageBundleBuilder.java - gwt - Git at Google

 /*
  * Copyright 2008 Google Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * License for the specific language governing permissions and limitations under
  * the License.
  */
 package com.google.gwt.user.rebind.ui;

 import com.google.gwt.core.ext.GeneratorContext;
 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.UnableToCompleteException;
 import com.google.gwt.dev.util.Util;
 import com.google.gwt.dev.util.log.speedtracer.CompilerEventType;
 import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger;

 import java.awt.Graphics2D;
 import java.awt.image.BufferedImage;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import javax.imageio.ImageIO;

 /**
  * Accumulates state for the bundled image.
  */
 class ImageBundleBuilder {
   /**
    * The rectangle at which the original image is placed into the composite
    * image.
    */
   public static class ImageRect implements HasRect {

     private final String name;
     private final int height, width;
     private final BufferedImage image;
     private int left, top;

     private boolean hasBeenPositioned;

     public ImageRect(String name, BufferedImage image) {
       this.name = name;
       this.image = image;
       this.width = image.getWidth();
       this.height = image.getHeight();
     }

     public int getHeight() {
       return height;
     }

     public int getLeft() {
       return left;
     }

     public String getName() {
       return name;
     }

     public int getTop() {
       return top;
     }

     public int getWidth() {
       return width;
     }

     public boolean hasBeenPositioned() {
       return hasBeenPositioned;
     }

     public void setPosition(int left, int top) {
       hasBeenPositioned = true;
       this.left = left;
       this.top = top;
     }
   }

   /**
    * A mockable interface to test the image arrangement algorithms.
    */
   interface HasRect {

     String getName();

     int getHeight();

     int getLeft();

     int getTop();

     int getWidth();

     boolean hasBeenPositioned();

     void setPosition(int left, int top);
   }

   /**
    * Used to return the size of the resulting image from the method
    * {@link ImageBundleBuilder#arrangeImages()}.
    */
   private static class Size {
     private final int width, height;

     Size(int width, int height) {
       this.width = width;
       this.height = height;
     }
   }

   private static final Comparator<HasRect> decreasingHeightComparator = new Comparator<HasRect>() {
     public int compare(HasRect a, HasRect b) {
       final int c = b.getHeight() - a.getHeight();
       // If we encounter equal heights, use the name to keep things
       // deterministic.
       return (c != 0) ? c : b.getName().compareTo(a.getName());
     }
   };

   private static final Comparator<HasRect> decreasingWidthComparator = new Comparator<HasRect>() {
     public int compare(HasRect a, HasRect b) {
       final int c = b.getWidth() - a.getWidth();
       // If we encounter equal heights, use the name to keep things
       // deterministic.
       return (c != 0) ? c : b.getName().compareTo(a.getName());
     }
   };

   /*
    * Only PNG is supported right now. In the future, we may be able to infer the
    * best output type, and get rid of this constant.
    */
   private static final String BUNDLE_FILE_TYPE = "png";

   /**
    * Arranges the images to try to decrease the overall area of the resulting
    * bundle. This uses a strategy that is basically Next-Fit Decreasing Height
    * Decreasing Width (NFDHDW). The rectangles to be packed are sorted in
    * decreasing order by height. The tallest rectangle is placed at the far
    * left. We attempt to stack the remaining rectangles on top of one another to
    * construct as many columns as necessary. After finishing each column, we
    * also attempt to do some horizontal packing to fill up the space left due to
    * widths of rectangles differing in the column.
    */
   static Size arrangeImages(Collection<? extends HasRect> rects) {
     if (rects.size() == 0) {
       return new Size(0, 0);
     }

     // Create a list of ImageRects ordered by decreasing height used for
     // constructing columns.
     final ArrayList<HasRect> rectsOrderedByHeight = new ArrayList<HasRect>(
         rects);
     Collections.sort(rectsOrderedByHeight, decreasingHeightComparator);

     // Create a list of ImageRects ordered by decreasing width used for packing
     // individual columns.
     final ArrayList<HasRect> rectsOrderedByWidth = new ArrayList<HasRect>(rects);
     Collections.sort(rectsOrderedByWidth, decreasingWidthComparator);

     // Place the first, tallest image as the first column.
     final HasRect first = rectsOrderedByHeight.get(0);
     first.setPosition(0, 0);

     // Setup state for laying things cumulatively.
     int curX = first.getWidth();
     final int colH = first.getHeight();

     for (int i = 1, n = rectsOrderedByHeight.size(); i < n; i++) {
       // If this ImageRect has been positioned already, move on.
       if (rectsOrderedByHeight.get(i).hasBeenPositioned()) {
         continue;
       }

       int colW = 0;
       int curY = 0;

       final ArrayList<HasRect> rectsInColumn = new ArrayList<HasRect>();
       for (int j = i; j < n; j++) {
         final HasRect current = rectsOrderedByHeight.get(j);
         // Look for rects that have not been positioned with a small enough
         // height to go in this column.
         if (!current.hasBeenPositioned()
             && (curY + current.getHeight()) <= colH) {

           // Set the horizontal position here, the top field will be set in
           // arrangeColumn after we've collected a full set of ImageRects.
           current.setPosition(curX, 0);
           colW = Math.max(colW, current.getWidth());
           curY += current.getHeight();

           // Keep the ImageRects in this column in decreasing order by width.
           final int pos = Collections.binarySearch(rectsInColumn, current,
               decreasingWidthComparator);
           assert pos < 0;
           rectsInColumn.add(-1 - pos, current);
         }
       }

       // Having selected a set of ImageRects that fill out this column vertical,
       // now we'll scan the remaining ImageRects to try to fit some in the
       // horizontal gaps.
       if (!rectsInColumn.isEmpty()) {
         arrangeColumn(rectsInColumn, rectsOrderedByWidth);
       }

       // We're done with that column, so move the horizontal accumulator by the
       // width of the column we just finished.
       curX += colW;
     }

     return new Size(curX, colH);
   }

   /**
    * Companion method to {@link #arrangeImages()}. This method does a best
    * effort horizontal packing of a column after it was packed vertically. This
    * is the Decreasing Width part of Next-Fit Decreasing Height Decreasing
    * Width. The basic strategy is to sort the remaining rectangles by decreasing
    * width and try to fit them to the left of each of the rectangles we've
    * already picked for this column.
    *
    * @param rectsInColumn the ImageRects that were already selected for this
    *          column
    * @param remainingRectsOrderedByWidth the sub list of ImageRects that may not
    *          have been positioned yet
    */
   private static void arrangeColumn(List<HasRect> rectsInColumn,
       List<HasRect> remainingRectsOrderedByWidth) {
     final HasRect first = rectsInColumn.get(0);

     final int columnWidth = first.getWidth();
     int curY = first.getHeight();

     // Skip this first ImageRect because it is guaranteed to consume the full
     // width of the column.
     for (int i = 1, m = rectsInColumn.size(); i < m; i++) {
       final HasRect r = rectsInColumn.get(i);
       // The ImageRect was previously positioned horizontally, now set the top
       // field.
       r.setPosition(r.getLeft(), curY);
       int curX = r.getWidth();

       // Search for ImageRects that are shorter than the left most ImageRect and
       // narrow enough to fit in the column.
       for (int j = 0, n = remainingRectsOrderedByWidth.size(); j < n; j++) {
         final HasRect current = remainingRectsOrderedByWidth.get(j);
         if (!current.hasBeenPositioned()
             && (curX + current.getWidth()) <= columnWidth
             && (current.getHeight() <= r.getHeight())) {
           current.setPosition(r.getLeft() + curX, r.getTop());
           curX += current.getWidth();
         }
       }

       // Update the vertical accumulator so we'll know where to place the next
       // ImageRect.
       curY += r.getHeight();
     }
   }

   private final Map<String, ImageRect> imageNameToImageRectMap = new HashMap<String, ImageRect>();

   /**
    * Assimilates the image associated with a particular image method into the
    * master composite. If the method names an image that has already been
    * assimilated, the existing image rectangle is reused.
    *
    * @param logger a hierarchical logger which logs to the hosted console
    * @param imageName the name of an image that can be found on the classpath
    * @throws UnableToCompleteException if the image with name
    *           <code>imageName</code> cannot be added to the master composite
    *           image
    */
   public void assimilate(TreeLogger logger, String imageName)
       throws UnableToCompleteException {

     /*
      * Decide whether or not we need to add to the composite image. Either way,
      * we associated it with the rectangle of the specified image as it exists
      * within the composite image. Note that the coordinates of the rectangle
      * aren't computed until the composite is written.
      */
     ImageRect rect = getMapping(imageName);
     if (rect == null) {
       // Assimilate the image into the composite.
       rect = addImage(logger, imageName);

       // Map the URL to its image so that even if the same URL is used more than
       // once, we only include the referenced image once in the bundled image.
       putMapping(imageName, rect);
     }
   }

   public ImageRect getMapping(String imageName) {
     return imageNameToImageRectMap.get(imageName);
   }

   public String writeBundledImage(TreeLogger logger, GeneratorContext context)
       throws UnableToCompleteException {

     // Create the bundled image from all of the constituent images.
     BufferedImage bundledImage = drawBundledImage();

     // Write the bundled image into a byte array, so that we can compute
     // its strong name.
     byte[] imageBytes;

     try {
       ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream();
       boolean writerAvailable = ImageIO.write(bundledImage, BUNDLE_FILE_TYPE,
           byteOutputStream);
       if (!writerAvailable) {
         logger.log(TreeLogger.ERROR, "No " + BUNDLE_FILE_TYPE
             + " writer available");
         throw new UnableToCompleteException();
       }
       imageBytes = byteOutputStream.toByteArray();
     } catch (IOException e) {
       logger.log(TreeLogger.ERROR,
           "An error occurred while trying to write the image bundle.", e);
       throw new UnableToCompleteException();
     }

     // Compute the file name. The strong name is generated from the bytes of
     // the bundled image. The '.cache' part indicates that it can be
     // permanently cached.
     String bundleFileName = Util.computeStrongName(imageBytes) + ".cache."
         + BUNDLE_FILE_TYPE;

     // Try and write the file to disk. If a file with bundleFileName already
     // exists, then the file will not be written.
     OutputStream outStream = context.tryCreateResource(logger, bundleFileName);

     if (outStream != null) {
       try {
         // Write the image bytes from the byte array to the pending stream.
         outStream.write(imageBytes);

         // Commit the stream.
         context.commitResource(logger, outStream);

       } catch (IOException e) {
         logger.log(TreeLogger.ERROR, "Failed while writing", e);
         throw new UnableToCompleteException();
       }
     } else {
       logger.log(TreeLogger.TRACE,
           "Generated image bundle file already exists; no need to rewrite it.",
           null);
     }

     return bundleFileName;
   }

   private ImageRect addImage(TreeLogger logger, String imageName)
       throws UnableToCompleteException {

     logger = logger.branch(TreeLogger.TRACE,
         "Adding image '" + imageName + "'", null);

     // Fetch the image.
     try {
       // Could turn this lookup logic into an externally-supplied policy for
       // increased generality.
       URL imageUrl = getClass().getClassLoader().getResource(imageName);
       if (imageUrl == null) {
         // This should never happen, because this check is done right after
         // the image name is retrieved from the metadata or the method name.
         // If there is a failure in obtaining the resource, it will happen
         // before this point.
         logger.log(TreeLogger.ERROR,
             "Resource not found on classpath (is the name specified as "
                 + "Class.getResource() would expect?)", null);
         throw new UnableToCompleteException();
       }

       BufferedImage image;
       // Load the image
       try {
         image = ImageIO.read(imageUrl);
       } catch (IllegalArgumentException iex) {
         if (imageName.toLowerCase().endsWith("png")
             && iex.getMessage() != null
             && iex.getStackTrace()[0].getClassName().equals(
                 "javax.imageio.ImageTypeSpecifier$Indexed")) {
           logger.log(
               TreeLogger.ERROR,
               "Unable to read image. The image may not be in valid PNG format. "
                   + "This problem may also be due to a bug in versions of the "
                   + "JRE prior to 1.6. See "
                   + "http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5098176 "
                   + "for more information. If this bug is the cause of the "
                   + "error, try resaving the image using a different image "
                   + "program, or upgrade to a newer JRE.", null);
           throw new UnableToCompleteException();
         } else {
           throw iex;
         }
       }

       if (image == null) {
         logger.log(TreeLogger.ERROR, "Unrecognized image file format", null);
         throw new UnableToCompleteException();
       }

       return new ImageRect(imageName, image);

     } catch (IOException e) {
       logger.log(TreeLogger.ERROR, "Unable to read image resource", null);
       throw new UnableToCompleteException();
     }
   }

   /**
    * This method creates the bundled image through the composition of the other
    * images.
    *
    * In this particular implementation, we use NFDHDW (see
    * {@link #arrangeImages()}) to get an approximate optimal image packing.
    *
    * The most important aspect of drawing the bundled image is that it be drawn
    * in a deterministic way. The drawing of the image should not rely on
    * implementation details of the Generator system which may be subject to
    * change.
    */
   private BufferedImage drawBundledImage() {

     // There is no need to impose any order here, because arrangeImages
     // will position the ImageRects in a deterministic fashion, even though
     // we might paint them in a non-deterministic order.
     Collection<ImageRect> imageRects = imageNameToImageRectMap.values();

     // Arrange images and determine the size of the resulting bundle.
     final Size size = arrangeImages(imageRects);

     // Create the bundled image.
     BufferedImage bundledImage = new BufferedImage(size.width, size.height,
         BufferedImage.TYPE_INT_ARGB_PRE);
     SpeedTracerLogger.Event createGraphicsEvent =
       SpeedTracerLogger.start(CompilerEventType.GRAPHICS_INIT,
           "java.awt.headless", System.getProperty("java.awt.headless"));
     Graphics2D g2d = bundledImage.createGraphics();
     createGraphicsEvent.end();

     for (ImageRect imageRect : imageRects) {

       // We do not need to pass in an ImageObserver, because we are working
       // with BufferedImages. ImageObservers only need to be used when
       // the image to be drawn is being loaded asynchronously. See
       // http://java.sun.com/docs/books/tutorial/2d/images/drawimage.html
       // for more information.
       g2d.drawImage(imageRect.image, imageRect.left, imageRect.top, null);
     }
     g2d.dispose();

     return bundledImage;
   }

   private void putMapping(String imageName, ImageRect rect) {
     imageNameToImageRectMap.put(imageName, rect);
   }
 }
	/*
	* Copyright 2008 Google Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License"); you may not
	* use this file except in compliance with the License. You may obtain a copy of
	* the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	* License for the specific language governing permissions and limitations under
	* the License.
	*/
	package com.google.gwt.user.rebind.ui;

	import com.google.gwt.core.ext.GeneratorContext;
	import com.google.gwt.core.ext.TreeLogger;
	import com.google.gwt.core.ext.UnableToCompleteException;
	import com.google.gwt.dev.util.Util;
	import com.google.gwt.dev.util.log.speedtracer.CompilerEventType;
	import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger;

	import java.awt.Graphics2D;
	import java.awt.image.BufferedImage;
	import java.io.ByteArrayOutputStream;
	import java.io.IOException;
	import java.io.OutputStream;
	import java.net.URL;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	import javax.imageio.ImageIO;

	/**
	* Accumulates state for the bundled image.
	*/
	class ImageBundleBuilder {
	/**
	* The rectangle at which the original image is placed into the composite
	* image.
	*/
	public static class ImageRect implements HasRect {

	private final String name;
	private final int height, width;
	private final BufferedImage image;
	private int left, top;

	private boolean hasBeenPositioned;

	public ImageRect(String name, BufferedImage image) {
	this.name = name;
	this.image = image;
	this.width = image.getWidth();
	this.height = image.getHeight();
	}

	public int getHeight() {
	return height;
	}

	public int getLeft() {
	return left;
	}

	public String getName() {
	return name;
	}

	public int getTop() {
	return top;
	}

	public int getWidth() {
	return width;
	}

	public boolean hasBeenPositioned() {
	return hasBeenPositioned;
	}

	public void setPosition(int left, int top) {
	hasBeenPositioned = true;
	this.left = left;
	this.top = top;
	}
	}

	/**
	* A mockable interface to test the image arrangement algorithms.
	*/
	interface HasRect {

	String getName();

	int getHeight();

	int getLeft();

	int getTop();

	int getWidth();

	boolean hasBeenPositioned();

	void setPosition(int left, int top);
	}

	/**
	* Used to return the size of the resulting image from the method
	* {@link ImageBundleBuilder#arrangeImages()}.
	*/
	private static class Size {
	private final int width, height;

	Size(int width, int height) {
	this.width = width;
	this.height = height;
	}
	}

	private static final Comparator<HasRect> decreasingHeightComparator = new Comparator<HasRect>() {
	public int compare(HasRect a, HasRect b) {
	final int c = b.getHeight() - a.getHeight();
	// If we encounter equal heights, use the name to keep things
	// deterministic.
	return (c != 0) ? c : b.getName().compareTo(a.getName());
	}
	};

	private static final Comparator<HasRect> decreasingWidthComparator = new Comparator<HasRect>() {
	public int compare(HasRect a, HasRect b) {
	final int c = b.getWidth() - a.getWidth();
	// If we encounter equal heights, use the name to keep things
	// deterministic.
	return (c != 0) ? c : b.getName().compareTo(a.getName());
	}
	};

	/*
	* Only PNG is supported right now. In the future, we may be able to infer the
	* best output type, and get rid of this constant.
	*/
	private static final String BUNDLE_FILE_TYPE = "png";

	/**
	* Arranges the images to try to decrease the overall area of the resulting
	* bundle. This uses a strategy that is basically Next-Fit Decreasing Height
	* Decreasing Width (NFDHDW). The rectangles to be packed are sorted in
	* decreasing order by height. The tallest rectangle is placed at the far
	* left. We attempt to stack the remaining rectangles on top of one another to
	* construct as many columns as necessary. After finishing each column, we
	* also attempt to do some horizontal packing to fill up the space left due to
	* widths of rectangles differing in the column.
	*/
	static Size arrangeImages(Collection<? extends HasRect> rects) {
	if (rects.size() == 0) {
	return new Size(0, 0);
	}

	// Create a list of ImageRects ordered by decreasing height used for
	// constructing columns.
	final ArrayList<HasRect> rectsOrderedByHeight = new ArrayList<HasRect>(
	rects);
	Collections.sort(rectsOrderedByHeight, decreasingHeightComparator);

	// Create a list of ImageRects ordered by decreasing width used for packing
	// individual columns.
	final ArrayList<HasRect> rectsOrderedByWidth = new ArrayList<HasRect>(rects);
	Collections.sort(rectsOrderedByWidth, decreasingWidthComparator);

	// Place the first, tallest image as the first column.
	final HasRect first = rectsOrderedByHeight.get(0);
	first.setPosition(0, 0);

	// Setup state for laying things cumulatively.
	int curX = first.getWidth();
	final int colH = first.getHeight();

	for (int i = 1, n = rectsOrderedByHeight.size(); i < n; i++) {
	// If this ImageRect has been positioned already, move on.
	if (rectsOrderedByHeight.get(i).hasBeenPositioned()) {
	continue;
	}

	int colW = 0;
	int curY = 0;

	final ArrayList<HasRect> rectsInColumn = new ArrayList<HasRect>();
	for (int j = i; j < n; j++) {
	final HasRect current = rectsOrderedByHeight.get(j);
	// Look for rects that have not been positioned with a small enough
	// height to go in this column.
	if (!current.hasBeenPositioned()
	&& (curY + current.getHeight()) <= colH) {

	// Set the horizontal position here, the top field will be set in
	// arrangeColumn after we've collected a full set of ImageRects.
	current.setPosition(curX, 0);
	colW = Math.max(colW, current.getWidth());
	curY += current.getHeight();

	// Keep the ImageRects in this column in decreasing order by width.
	final int pos = Collections.binarySearch(rectsInColumn, current,
	decreasingWidthComparator);
	assert pos < 0;
	rectsInColumn.add(-1 - pos, current);
	}
	}

	// Having selected a set of ImageRects that fill out this column vertical,
	// now we'll scan the remaining ImageRects to try to fit some in the
	// horizontal gaps.
	if (!rectsInColumn.isEmpty()) {
	arrangeColumn(rectsInColumn, rectsOrderedByWidth);
	}

	// We're done with that column, so move the horizontal accumulator by the
	// width of the column we just finished.
	curX += colW;
	}

	return new Size(curX, colH);
	}

	/**
	* Companion method to {@link #arrangeImages()}. This method does a best
	* effort horizontal packing of a column after it was packed vertically. This
	* is the Decreasing Width part of Next-Fit Decreasing Height Decreasing
	* Width. The basic strategy is to sort the remaining rectangles by decreasing
	* width and try to fit them to the left of each of the rectangles we've
	* already picked for this column.
	*
	* @param rectsInColumn the ImageRects that were already selected for this
	* column
	* @param remainingRectsOrderedByWidth the sub list of ImageRects that may not
	* have been positioned yet
	*/
	private static void arrangeColumn(List<HasRect> rectsInColumn,
	List<HasRect> remainingRectsOrderedByWidth) {
	final HasRect first = rectsInColumn.get(0);

	final int columnWidth = first.getWidth();
	int curY = first.getHeight();

	// Skip this first ImageRect because it is guaranteed to consume the full
	// width of the column.
	for (int i = 1, m = rectsInColumn.size(); i < m; i++) {
	final HasRect r = rectsInColumn.get(i);
	// The ImageRect was previously positioned horizontally, now set the top
	// field.
	r.setPosition(r.getLeft(), curY);
	int curX = r.getWidth();

	// Search for ImageRects that are shorter than the left most ImageRect and
	// narrow enough to fit in the column.
	for (int j = 0, n = remainingRectsOrderedByWidth.size(); j < n; j++) {
	final HasRect current = remainingRectsOrderedByWidth.get(j);
	if (!current.hasBeenPositioned()
	&& (curX + current.getWidth()) <= columnWidth
	&& (current.getHeight() <= r.getHeight())) {
	current.setPosition(r.getLeft() + curX, r.getTop());
	curX += current.getWidth();
	}
	}

	// Update the vertical accumulator so we'll know where to place the next
	// ImageRect.
	curY += r.getHeight();
	}
	}

	private final Map<String, ImageRect> imageNameToImageRectMap = new HashMap<String, ImageRect>();

	/**
	* Assimilates the image associated with a particular image method into the
	* master composite. If the method names an image that has already been
	* assimilated, the existing image rectangle is reused.
	*
	* @param logger a hierarchical logger which logs to the hosted console
	* @param imageName the name of an image that can be found on the classpath
	* @throws UnableToCompleteException if the image with name
	* <code>imageName</code> cannot be added to the master composite
	* image
	*/
	public void assimilate(TreeLogger logger, String imageName)
	throws UnableToCompleteException {

	/*
	* Decide whether or not we need to add to the composite image. Either way,
	* we associated it with the rectangle of the specified image as it exists
	* within the composite image. Note that the coordinates of the rectangle
	* aren't computed until the composite is written.
	*/
	ImageRect rect = getMapping(imageName);
	if (rect == null) {
	// Assimilate the image into the composite.
	rect = addImage(logger, imageName);

	// Map the URL to its image so that even if the same URL is used more than
	// once, we only include the referenced image once in the bundled image.
	putMapping(imageName, rect);
	}
	}

	public ImageRect getMapping(String imageName) {
	return imageNameToImageRectMap.get(imageName);
	}

	public String writeBundledImage(TreeLogger logger, GeneratorContext context)
	throws UnableToCompleteException {

	// Create the bundled image from all of the constituent images.
	BufferedImage bundledImage = drawBundledImage();

	// Write the bundled image into a byte array, so that we can compute
	// its strong name.
	byte[] imageBytes;

	try {
	ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream();
	boolean writerAvailable = ImageIO.write(bundledImage, BUNDLE_FILE_TYPE,
	byteOutputStream);
	if (!writerAvailable) {
	logger.log(TreeLogger.ERROR, "No " + BUNDLE_FILE_TYPE
	+ " writer available");
	throw new UnableToCompleteException();
	}
	imageBytes = byteOutputStream.toByteArray();
	} catch (IOException e) {
	logger.log(TreeLogger.ERROR,
	"An error occurred while trying to write the image bundle.", e);
	throw new UnableToCompleteException();
	}

	// Compute the file name. The strong name is generated from the bytes of
	// the bundled image. The '.cache' part indicates that it can be
	// permanently cached.
	String bundleFileName = Util.computeStrongName(imageBytes) + ".cache."
	+ BUNDLE_FILE_TYPE;

	// Try and write the file to disk. If a file with bundleFileName already
	// exists, then the file will not be written.
	OutputStream outStream = context.tryCreateResource(logger, bundleFileName);

	if (outStream != null) {
	try {
	// Write the image bytes from the byte array to the pending stream.
	outStream.write(imageBytes);

	// Commit the stream.
	context.commitResource(logger, outStream);

	} catch (IOException e) {
	logger.log(TreeLogger.ERROR, "Failed while writing", e);
	throw new UnableToCompleteException();
	}
	} else {
	logger.log(TreeLogger.TRACE,
	"Generated image bundle file already exists; no need to rewrite it.",
	null);
	}

	return bundleFileName;
	}

	private ImageRect addImage(TreeLogger logger, String imageName)
	throws UnableToCompleteException {

	logger = logger.branch(TreeLogger.TRACE,
	"Adding image '" + imageName + "'", null);

	// Fetch the image.
	try {
	// Could turn this lookup logic into an externally-supplied policy for
	// increased generality.
	URL imageUrl = getClass().getClassLoader().getResource(imageName);
	if (imageUrl == null) {
	// This should never happen, because this check is done right after
	// the image name is retrieved from the metadata or the method name.
	// If there is a failure in obtaining the resource, it will happen
	// before this point.
	logger.log(TreeLogger.ERROR,
	"Resource not found on classpath (is the name specified as "
	+ "Class.getResource() would expect?)", null);
	throw new UnableToCompleteException();
	}

	BufferedImage image;
	// Load the image
	try {
	image = ImageIO.read(imageUrl);
	} catch (IllegalArgumentException iex) {
	if (imageName.toLowerCase().endsWith("png")
	&& iex.getMessage() != null
	&& iex.getStackTrace()[0].getClassName().equals(
	"javax.imageio.ImageTypeSpecifier$Indexed")) {
	logger.log(
	TreeLogger.ERROR,
	"Unable to read image. The image may not be in valid PNG format. "
	+ "This problem may also be due to a bug in versions of the "
	+ "JRE prior to 1.6. See "
	+ "http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5098176 "
	+ "for more information. If this bug is the cause of the "
	+ "error, try resaving the image using a different image "
	+ "program, or upgrade to a newer JRE.", null);
	throw new UnableToCompleteException();
	} else {
	throw iex;
	}
	}

	if (image == null) {
	logger.log(TreeLogger.ERROR, "Unrecognized image file format", null);
	throw new UnableToCompleteException();
	}

	return new ImageRect(imageName, image);

	} catch (IOException e) {
	logger.log(TreeLogger.ERROR, "Unable to read image resource", null);
	throw new UnableToCompleteException();
	}
	}

	/**
	* This method creates the bundled image through the composition of the other
	* images.
	*
	* In this particular implementation, we use NFDHDW (see
	* {@link #arrangeImages()}) to get an approximate optimal image packing.
	*
	* The most important aspect of drawing the bundled image is that it be drawn
	* in a deterministic way. The drawing of the image should not rely on
	* implementation details of the Generator system which may be subject to
	* change.
	*/
	private BufferedImage drawBundledImage() {

	// There is no need to impose any order here, because arrangeImages
	// will position the ImageRects in a deterministic fashion, even though
	// we might paint them in a non-deterministic order.
	Collection<ImageRect> imageRects = imageNameToImageRectMap.values();

	// Arrange images and determine the size of the resulting bundle.
	final Size size = arrangeImages(imageRects);

	// Create the bundled image.
	BufferedImage bundledImage = new BufferedImage(size.width, size.height,
	BufferedImage.TYPE_INT_ARGB_PRE);
	SpeedTracerLogger.Event createGraphicsEvent =
	SpeedTracerLogger.start(CompilerEventType.GRAPHICS_INIT,
	"java.awt.headless", System.getProperty("java.awt.headless"));
	Graphics2D g2d = bundledImage.createGraphics();
	createGraphicsEvent.end();

	for (ImageRect imageRect : imageRects) {

	// We do not need to pass in an ImageObserver, because we are working
	// with BufferedImages. ImageObservers only need to be used when
	// the image to be drawn is being loaded asynchronously. See
	// http://java.sun.com/docs/books/tutorial/2d/images/drawimage.html
	// for more information.
	g2d.drawImage(imageRect.image, imageRect.left, imageRect.top, null);
	}
	g2d.dispose();

	return bundledImage;
	}

	private void putMapping(String imageName, ImageRect rect) {
	imageNameToImageRectMap.put(imageName, rect);
	}
	}