CellPanel.
*
* @param width the preferred width of the window
* @param height the preferred height of the window
*/
public CellPanel(final int width, final int height) {
super();
this.synch = new Object();
setBackground(Color.WHITE);
setPreferredSize(new Dimension(width, height));
setSize(width, height);
this.adjBounds = new Rectangle2D.Double();
this.active = null;
this.passive = null;
this.temp = null;
this.width = 0;
this.height = 0;
updateOffscreenImages();
addComponentListener(this);
}
/**
* Tests the current size of the panel against the offscreen image sizes, and if needed,
* creates new offscreen images. This is done in a synchronized block so a completing render
* cannot stomp an image we create, and this method will not stomp the output of a render.
*/
private void updateOffscreenImages() {
int actWidth;
int actHeight;
Graphics grx;
actWidth = getWidth();
actHeight = getHeight();
synchronized (this.synch) {
if ((actWidth != this.width) || (actHeight != this.height)) {
this.active = new BufferedImage(actWidth, actHeight, BufferedImage.TYPE_INT_RGB);
this.passive = new BufferedImage(actWidth, actHeight, BufferedImage.TYPE_INT_RGB);
this.width = actWidth;
this.height = actHeight;
grx = this.active.getGraphics();
grx.setColor(Color.WHITE);
grx.fillRect(0, 0, this.width, this.height);
grx = this.passive.getGraphics();
grx.setColor(Color.WHITE);
grx.fillRect(0, 0, this.width, this.height);
}
}
}
/**
* Draws the panel contents using the most up-to-date rendered image available.
*
* @param grx the graphics to which to draw.
*/
@Override public void paintComponent(final Graphics grx) {
int actWidth;
int actHeight;
double xScale;
double yScale;
double scale;
int scaledWidth;
int scaledHeight;
synchronized (this.synch) {
if (this.temp == null) {
if (this.active != null) {
grx.drawImage(this.active, 0, 0, null);
}
} else {
actWidth = getWidth();
actHeight = getHeight();
xScale = actWidth / this.temp.getWidth();
yScale = actHeight / this.temp.getHeight();
scale = (xScale > yScale) ? xScale : yScale;
scaledWidth = (int) ((this.temp.getWidth() * scale) + 0.5); // at least actWidth
scaledHeight = (int) ((this.temp.getHeight() * scale) + 0.5); // at least actHeight
grx.drawImage(this.temp, (actWidth - scaledWidth) / 2,
(actHeight - scaledHeight) / 2, scaledWidth, scaledHeight, null);
}
}
}
/**
* Handles panel resize events, which require allocation of new offscreen images.
*
* @param evt the component event
*/
public void componentResized(final ComponentEvent evt) {
updateOffscreenImages();
repaint();
}
/**
* Handles panel move events, which we ignore.
*
* @param evt the component event
*/
public void componentMoved(final ComponentEvent evt) {
// No action
}
/**
* Handles panel shown events, which causes a test for actual size against current size of the
* offscreen images, and may result in allocation of new offscreen images.
*
* NOTE: Rendering is done outside the AWT event loop, but writes to the offscreen images.
* At the end of a render process, if the rendered image is not the size specified in
* width and height, we store the image in the temp member
* variable. Otherwise, the end of the render cycle stores the result as the active image, and
* clears the temp member. When a repaint is requested, if the temp
* object has an image, that image is drawn, but scaled to fit the window.
*
* @param evt the component event
*/
public void componentShown(final ComponentEvent evt) {
updateOffscreenImages();
}
/**
* Handles panel hidden events, which we ignore.
*
* @param evt the component event
*/
public void componentHidden(final ComponentEvent evt) {
// No action
}
/**
* Updates the offscreen bitmap.
*
* @param bounds the bounds of model space to render
* @param cells the list of cells to draw
* @param emitters the list of emitters to draw
* @param walls the list of walls to draw
*/
public void render(final Rectangle2D bounds, final ListBufferedImage on which to draw.
* @param cells the list of cells to render
* @param emitters the list of emitters to render
* @param walls the list of walls to render
*/
private void renderScene(final Rectangle2D bounds, final BufferedImage target,
final ListadjBounds.
*
* @param imgWidth the image width
* @param imgHeight the image height
* @param bounds the bounding rectangle
*/
private void adjustBounds(final int imgWidth, final int imgHeight, final Rectangle2D bounds) {
double aspect;
double rectAspect;
double newSize;
double delta;
aspect = (double) imgWidth / (double) imgHeight;
rectAspect = bounds.getWidth() / bounds.getHeight();
if (aspect > rectAspect) {
// Make bounds wider to match aspect ratio
newSize = bounds.getWidth() * (aspect / rectAspect);
delta = (newSize - bounds.getWidth()) / 2;
this.adjBounds.setFrame(bounds.getX() - delta, bounds.getY(), newSize,
bounds.getHeight());
} else {
// Make bounds taller to match aspect ratio
newSize = bounds.getHeight() * (rectAspect / aspect);
delta = (newSize - bounds.getHeight()) / 2;
this.adjBounds.setFrame(bounds.getX(), bounds.getY() - delta, bounds.getWidth(),
newSize);
}
}
/**
* Renders the cells.
*
* @param imgWidth the width of the image to which to render
* @param imgHeight the height of the image to which to render
* @param grx the Graphics2D to which to draw
* @param pixelScale the pixel scale (pixels per unit in model space)
* @param cells the list of cells to render
*/
private void renderCells(final int imgWidth, final int imgHeight, final Graphics2D grx,
final double pixelScale, final ListGraphics2D to which to draw
* @param pixelScale the pixel scale (pixels per unit in model space)
* @param emitters the list of emitters to render
*/
private void renderEmitters(final int imgWidth, final int imgHeight, final Graphics2D grx,
final double pixelScale, final ListGraphics2D to which to draw
* @param pixelScale the pixel scale (pixels per unit in model space)
* @param walls the list of walls to render
*/
private void renderWalls(final int imgWidth, final int imgHeight, final Graphics2D grx,
final double pixelScale, final List