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; } }