public static ImageResource createImageResource(final String uri, final BufferedImage img) {
if (img == null) {
return new ImageResource(
uri, AWTFSImage.createImage(ImageUtil.createTransparentImage(10, 10)));
} else {
return new ImageResource(uri, AWTFSImage.createImage(ImageUtil.makeCompatible(img)));
}
}
public static ImageResource loadEmbeddedBase64ImageResource(final String uri) {
BufferedImage bufferedImage = ImageUtil.loadEmbeddedBase64Image(uri);
if (bufferedImage != null) {
FSImage image = AWTFSImage.createImage(bufferedImage);
return new ImageResource(null, image);
} else {
return new ImageResource(null, null);
}
}
public synchronized ImageResource get(final String uri, final int width, final int height) {
if (ImageUtil.isEmbeddedBase64Image(uri)) {
ImageResource resource = loadEmbeddedBase64ImageResource(uri);
BufferedImage newImg = ((AWTFSImage) resource.getImage()).getImage();
return new ImageResource(
resource.getImageUri(),
AWTFSImage.createImage(ImageUtils.scaleImage(newImg, width, height)));
} else {
CacheKey key = new CacheKey(uri, width, height);
ImageResource ir = (ImageResource) _imageCache.get(key);
if (ir == null) {
// not loaded, or not loaded at target size
// loaded a base size?
ir = (ImageResource) _imageCache.get(new CacheKey(uri, -1, -1));
// no: loaded
if (ir == null) {
if (isImmediateLoadUri(uri)) {
XRLog.load(Level.FINE, "Load immediate: " + uri);
ir = loadImageResourceFromUri(uri);
FSImage awtfsImage = ir.getImage();
BufferedImage newImg = ((AWTFSImage) awtfsImage).getImage();
loaded(ir, -1, -1);
if (width > -1 && height > -1) {
XRLog.load(Level.FINE, this + ", scaling " + uri + " to " + width + ", " + height);
newImg = ImageUtils.scaleImage(newImg, width, height);
ir = new ImageResource(ir.getImageUri(), AWTFSImage.createImage(newImg));
loaded(ir, width, height);
}
} else {
XRLog.load(Level.FINE, "Image cache miss, URI not yet loaded, queueing: " + uri);
MutableFSImage mfsi = new MutableFSImage(_repaintListener);
ir = new ImageResource(uri, mfsi);
_loadQueue.addToQueue(this, uri, mfsi, width, height);
}
_imageCache.put(key, ir);
} else {
// loaded at base size, need to scale
XRLog.load(Level.FINE, this + ", scaling " + uri + " to " + width + ", " + height);
FSImage awtfsImage = ir.getImage();
BufferedImage newImg = ((AWTFSImage) awtfsImage).getImage();
newImg = ImageUtils.scaleImage(newImg, width, height);
ir = new ImageResource(ir.getImageUri(), AWTFSImage.createImage(newImg));
loaded(ir, width, height);
}
}
return ir;
}
}
/**
* The image we're replacing.
*
* @return see desc
*/
public Image getImage() {
if (!_loaded && _imageResource.isLoaded()) {
Image image = ((AWTFSImage) _imageResource.getImage()).getImage();
if (_doScaleImage && (_targetWidth > 0 || _targetHeight > 0)) {
int w = image.getWidth(null);
int h = image.getHeight(null);
int newW = _targetWidth;
int newH = _targetHeight;
if (newW == -1) {
newW = (int) (w * ((double) newH / h));
}
if (newH == -1) {
newH = (int) (h * ((double) newW / w));
}
if (w != newW || h != newH) {
if (image instanceof BufferedImage) {
image = ImageUtil.getScaledInstance((BufferedImage) image, newW, newH);
} else {
if (true) {
throw new RuntimeException(
"image is not a buffered image! " + _imageResource.getImageUri());
}
String scalingType = Configuration.valueFor("xr.image.scale", "HIGH").trim();
if (scalingType.equalsIgnoreCase("HIGH") || scalingType.equalsIgnoreCase("MID")) {
image = image.getScaledInstance(newW, newH, Image.SCALE_SMOOTH);
} else {
image = image.getScaledInstance(newW, newH, Image.SCALE_FAST);
}
}
}
_image = image;
} else {
_image = image;
}
_loaded = true;
XRLog.load(
Level.FINE,
"Icon: replaced image " + _imageResource.getImageUri() + ", repaint requested");
SwingUtilities.invokeLater(
new Runnable() {
public void run() {
repaintListener.repaintRequested(_doScaleImage);
}
});
}
return _image;
}
/**
* Creates a new ImageReplacedElement and scales it to the size specified if either width or
* height has a valid value (values are > -1), otherwise original size is preserved. The idea is
* that the image was loaded at a certain size (that's the Image instance here) and that at the
* time we create the ImageReplacedElement we have a target W/H we want to use.
*
* @param imageResource
* @param repaintListener
*/
public DeferredImageReplacedElement(
ImageResource imageResource, RepaintListener repaintListener, int w, int h) {
this._imageResource = imageResource;
_loaded = false;
this.repaintListener = repaintListener;
if (w == -1 && h == -1) {
_doScaleImage = false;
_targetHeight = 1;
_targetWidth = 1;
} else {
_doScaleImage = true;
_targetHeight = Math.max(1, h);
_targetWidth = Math.max(1, w);
}
_image = ImageUtil.createCompatibleBufferedImage(_targetWidth, _targetHeight);
}
public static ImageResource loadImageResourceFromUri(final String uri) {
if (ImageUtil.isEmbeddedBase64Image(uri)) {
return loadEmbeddedBase64ImageResource(uri);
} else {
StreamResource sr = new StreamResource(uri);
InputStream is;
ImageResource ir = null;
try {
sr.connect();
is = sr.bufferedStream();
try {
BufferedImage img = ImageIO.read(is);
if (img == null) {
throw new IOException("ImageIO.read() returned null");
}
ir = createImageResource(uri, img);
} catch (FileNotFoundException e) {
XRLog.exception("Can't read image file; image at URI '" + uri + "' not found");
} catch (IOException e) {
XRLog.exception("Can't read image file; unexpected problem for URI '" + uri + "'", e);
} finally {
sr.close();
}
} catch (IOException e) {
// couldnt open stream at URI...
XRLog.exception("Can't open stream for URI '" + uri + "': " + e.getMessage());
}
// When we do this we return null which will raise an exception on layout/render, which
// will allow us to use the fallback discover page in cases when the network/site are
// unavailable
// if (ir == null) {
// ir = createImageResource(uri, null);
// }
return ir;
}
}
