Index: /trunk/src/org/openstreetmap/josm/tools/HiDPISupport.java =================================================================== --- /trunk/src/org/openstreetmap/josm/tools/HiDPISupport.java (revision 16945) +++ /trunk/src/org/openstreetmap/josm/tools/HiDPISupport.java (revision 16946) @@ -54,12 +54,13 @@ * @param base the base image * @param ir a corresponding image resource + * @param resizeMode how to size/resize the image * @return multi-resolution image if necessary and possible, the base image otherwise */ - public static Image getMultiResolutionImage(Image base, ImageResource ir) { + public static Image getMultiResolutionImage(Image base, ImageResource ir, ImageResizeMode resizeMode) { double uiScale = getHiDPIScale(); if (uiScale != 1.0 && baseMultiResolutionImageConstructor != null) { ImageIcon zoomed = ir.getImageIconAlreadyScaled(new Dimension( (int) Math.round(base.getWidth(null) * uiScale), - (int) Math.round(base.getHeight(null) * uiScale)), false, true); + (int) Math.round(base.getHeight(null) * uiScale)), false, true, resizeMode); Image mrImg = getMultiResolutionImage(Arrays.asList(base, zoomed.getImage())); if (mrImg != null) return mrImg; Index: /trunk/src/org/openstreetmap/josm/tools/ImageProvider.java =================================================================== --- /trunk/src/org/openstreetmap/josm/tools/ImageProvider.java (revision 16945) +++ /trunk/src/org/openstreetmap/josm/tools/ImageProvider.java (revision 16946) @@ -660,7 +660,7 @@ } if (virtualMaxWidth != -1 || virtualMaxHeight != -1) - return ir.getImageIconBounded(new Dimension(virtualMaxWidth, virtualMaxHeight), multiResolution); + return ir.getImageIcon(new Dimension(virtualMaxWidth, virtualMaxHeight), multiResolution, ImageResizeMode.BOUNDED); else - return ir.getImageIcon(new Dimension(virtualWidth, virtualHeight), multiResolution); + return ir.getImageIcon(new Dimension(virtualWidth, virtualHeight), multiResolution, ImageResizeMode.AUTO); } @@ -1472,41 +1472,12 @@ } - static BufferedImage createPaddedIcon(Image icon, Dimension iconSize) { - int backgroundRealWidth = GuiSizesHelper.getSizeDpiAdjusted(iconSize.width); - int backgroundRealHeight = GuiSizesHelper.getSizeDpiAdjusted(iconSize.height); - int iconRealWidth = icon.getWidth(null); - int iconRealHeight = icon.getHeight(null); - BufferedImage image = new BufferedImage(backgroundRealWidth, backgroundRealHeight, BufferedImage.TYPE_INT_ARGB); - double scaleFactor = Math.min( - backgroundRealWidth / (double) iconRealWidth, - backgroundRealHeight / (double) iconRealHeight); - Image scaledIcon; - final int scaledWidth; - final int scaledHeight; - if (scaleFactor < 1) { - // Scale icon such that it fits on background. - scaledWidth = (int) (iconRealWidth * scaleFactor); - scaledHeight = (int) (iconRealHeight * scaleFactor); - scaledIcon = icon.getScaledInstance(scaledWidth, scaledHeight, Image.SCALE_SMOOTH); - } else { - // Use original size, don't upscale. - scaledWidth = iconRealWidth; - scaledHeight = iconRealHeight; - scaledIcon = icon; - } - image.getGraphics().drawImage(scaledIcon, - (backgroundRealWidth - scaledWidth) / 2, - (backgroundRealHeight - scaledHeight) / 2, null); - - return image; - } - /** * Constructs an image from the given SVG data. * @param svg the SVG data * @param dim the desired image dimension + * @param resizeMode how to size/resize the image * @return an image from the given SVG data at the desired dimension. */ - public static BufferedImage createImageFromSvg(SVGDiagram svg, Dimension dim) { + static BufferedImage createImageFromSvg(SVGDiagram svg, Dimension dim, ImageResizeMode resizeMode) { if (Logging.isTraceEnabled()) { Logging.trace("createImageFromSvg: {0} {1}", svg.getXMLBase(), dim); @@ -1514,42 +1485,17 @@ final float sourceWidth = svg.getWidth(); final float sourceHeight = svg.getHeight(); - final float realWidth; - final float realHeight; - if (dim.width >= 0) { - realWidth = dim.width; - if (dim.height >= 0) { - realHeight = dim.height; - } else { - realHeight = sourceHeight * realWidth / sourceWidth; - } - } else if (dim.height >= 0) { - realHeight = dim.height; - realWidth = sourceWidth * realHeight / sourceHeight; - } else { - realWidth = GuiSizesHelper.getSizeDpiAdjusted(sourceWidth); - realHeight = GuiSizesHelper.getSizeDpiAdjusted(sourceHeight); - } - - int roundedWidth = Math.round(realWidth); - int roundedHeight = Math.round(realHeight); - if (roundedWidth <= 0 || roundedHeight <= 0 || roundedWidth >= Integer.MAX_VALUE || roundedHeight >= Integer.MAX_VALUE) { - Logging.error("createImageFromSvg: {0} {1} realWidth={2} realHeight={3}", - svg.getXMLBase(), dim, Float.toString(realWidth), Float.toString(realHeight)); + if (sourceWidth <= 0 || sourceHeight <= 0) { + Logging.error("createImageFromSvg: {0} {1} sourceWidth={2} sourceHeight={3}", svg.getXMLBase(), dim, sourceWidth, sourceHeight); return null; } - BufferedImage img = new BufferedImage(roundedWidth, roundedHeight, BufferedImage.TYPE_INT_ARGB); - Graphics2D g = img.createGraphics(); - g.setClip(0, 0, img.getWidth(), img.getHeight()); - g.scale(realWidth / sourceWidth, realHeight / sourceHeight); - g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); - try { - synchronized (getSvgUniverse()) { - svg.render(g); - } - } catch (SVGException ex) { - Logging.log(Logging.LEVEL_ERROR, "Unable to load svg:", ex); - return null; - } - return img; + return resizeMode.createBufferedImage(dim, new Dimension((int) sourceWidth, (int) sourceHeight), g -> { + try { + synchronized (getSvgUniverse()) { + svg.render(g); + } + } catch (SVGException ex) { + Logging.log(Logging.LEVEL_ERROR, "Unable to load svg:", ex); + } + }); } Index: /trunk/src/org/openstreetmap/josm/tools/ImageResizeMode.java =================================================================== --- /trunk/src/org/openstreetmap/josm/tools/ImageResizeMode.java (revision 16946) +++ /trunk/src/org/openstreetmap/josm/tools/ImageResizeMode.java (revision 16946) @@ -0,0 +1,111 @@ +// License: GPL. For details, see LICENSE file. +package org.openstreetmap.josm.tools; + +import java.awt.Dimension; +import java.awt.Graphics2D; +import java.awt.RenderingHints; +import java.awt.image.BufferedImage; +import java.util.function.Consumer; + +/** + * Determines how the image is sized/resized in {@link ImageResource#getImageIcon(Dimension, boolean, ImageResizeMode)}. + */ +enum ImageResizeMode { + + AUTO { + @Override + Dimension computeDimension(Dimension dim, Dimension icon) { + CheckParameterUtil.ensureThat((dim.width > 0 || dim.width == -1) && (dim.height > 0 || dim.height == -1), + () -> dim + " is invalid"); + if (dim.width == -1 && dim.height == -1) { + return new Dimension(GuiSizesHelper.getSizeDpiAdjusted(icon.width), GuiSizesHelper.getSizeDpiAdjusted(icon.height)); + } else if (dim.width == -1) { + return new Dimension(Math.max(1, icon.width * dim.height / icon.height), dim.height); + } else if (dim.height == -1) { + return new Dimension(dim.width, Math.max(1, icon.height * dim.width / icon.width)); + } else { + return dim; + } + } + }, + + BOUNDED { + @Override + Dimension computeDimension(Dimension dim, Dimension icon) { + CheckParameterUtil.ensureThat((dim.width > 0 || dim.width == -1) && (dim.height > 0 || dim.height == -1), + () -> dim + " is invalid"); + final Dimension spec; + if (dim.width == -1 || dim.height == -1) { + spec = dim; + } else if (icon.getWidth() / dim.width > icon.getHeight() / dim.height) { + spec = new Dimension(dim.width, -1); + } else { + spec = new Dimension(-1, dim.height); + } + return AUTO.computeDimension(spec, icon); + // TODO disable upscaling non-svg icons? + } + }, + + PADDED { + @Override + Dimension computeDimension(Dimension dim, Dimension icon) { + CheckParameterUtil.ensureThat(dim.width > 0 && dim.height > 0, () -> dim + " is invalid"); + return dim; + } + + @Override + void prepareGraphics(Dimension icon, BufferedImage image, Graphics2D g) { + g.setClip(0, 0, image.getWidth(), image.getHeight()); + final double scale = Math.min(image.getWidth() / icon.getWidth(), image.getHeight() / icon.getHeight()); + g.translate((image.getWidth() - icon.getWidth() * scale) / 2, (image.getHeight() - icon.getHeight() * scale) / 2); + g.scale(scale, scale); + } + }; + + /** + * Computes the dimension for the resulting image + * @param dim the desired image dimension + * @param icon the dimensions of the image to resize + * @return the dimension for the resulting image + */ + abstract Dimension computeDimension(Dimension dim, Dimension icon); + + /** + * Creates a new buffered image and applies the rendering function + * @param dim the desired image dimension + * @param icon the dimensions of the image to resize + * @param renderer the rendering function + * @return a new buffered image + */ + BufferedImage createBufferedImage(Dimension dim, Dimension icon, Consumer renderer) { + final Dimension real = computeDimension(dim, icon); + final BufferedImage bufferedImage = new BufferedImage(real.width, real.height, BufferedImage.TYPE_INT_ARGB); + final Graphics2D g = bufferedImage.createGraphics(); + g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); + prepareGraphics(icon, bufferedImage, g); + renderer.accept(g); + return bufferedImage; + } + + /** + * Prepares the graphics object for rendering the given image + * @param icon the dimensions of the image to resize + * @param image the image to render afterwards + * @param g graphics + */ + void prepareGraphics(Dimension icon, BufferedImage image, Graphics2D g) { + g.setClip(0, 0, image.getWidth(), image.getHeight()); + g.scale(image.getWidth() / icon.getWidth(), image.getHeight() / icon.getHeight()); + } + + /** + * Returns a cache key for this mode and the given dimension + * @param dim the desired image dimension + * @return a cache key + */ + int cacheKey(Dimension dim) { + return (ordinal() << 28) | ((dim.width & 0xfff) << 16) | (dim.height & 0xfff); + } + +} Index: /trunk/src/org/openstreetmap/josm/tools/ImageResource.java =================================================================== --- /trunk/src/org/openstreetmap/josm/tools/ImageResource.java (revision 16945) +++ /trunk/src/org/openstreetmap/josm/tools/ImageResource.java (revision 16946) @@ -29,7 +29,7 @@ /** - * Caches the image data for resized versions of the same image. - */ - private final Map imgCache = new ConcurrentHashMap<>(4); + * Caches the image data for resized versions of the same image. The key is obtained using {@link ImageResizeMode#cacheKey(Dimension)}. + */ + private final Map imgCache = new ConcurrentHashMap<>(4); /** * SVG diagram information in case of SVG vector image. @@ -138,8 +138,8 @@ * to set the width, but otherwise scale the image proportionally. * @return ImageIcon object for the image of this resource, scaled according to dim - * @see #getImageIconBounded(java.awt.Dimension, boolean) + * @see #getImageIconBounded(java.awt.Dimension) */ public ImageIcon getImageIcon(Dimension dim) { - return getImageIcon(dim, true); + return getImageIcon(dim, true, ImageResizeMode.AUTO); } @@ -151,9 +151,10 @@ * (java.awt.image.MultiResolutionImage in Java 9), otherwise a plain {@link BufferedImage}. * When running Java 8, this flag has no effect and a plain image will be returned in any case. + * @param resizeMode how to size/resize the image * @return ImageIcon object for the image of this resource, scaled according to dim * @since 12722 */ - ImageIcon getImageIcon(Dimension dim, boolean multiResolution) { - return getImageIconAlreadyScaled(GuiSizesHelper.getDimensionDpiAdjusted(dim), multiResolution, false); + ImageIcon getImageIcon(Dimension dim, boolean multiResolution, ImageResizeMode resizeMode) { + return getImageIconAlreadyScaled(GuiSizesHelper.getDimensionDpiAdjusted(dim), multiResolution, false, resizeMode); } @@ -167,14 +168,16 @@ * When running Java 8, this flag has no effect and a plain image will be returned in any case. * @param highResolution whether the high resolution variant should be used for overlays + * @param resizeMode how to size/resize the image * @return ImageIcon object for the image of this resource, scaled according to dim */ - ImageIcon getImageIconAlreadyScaled(Dimension dim, boolean multiResolution, boolean highResolution) { + ImageIcon getImageIconAlreadyScaled(Dimension dim, boolean multiResolution, boolean highResolution, ImageResizeMode resizeMode) { CheckParameterUtil.ensureThat((dim.width > 0 || dim.width == -1) && (dim.height > 0 || dim.height == -1), () -> dim + " is invalid"); - BufferedImage img = imgCache.get(dim); + final int cacheKey = resizeMode.cacheKey(dim); + BufferedImage img = imgCache.get(cacheKey); if (img == null) { if (svg != null) { - img = ImageProvider.createImageFromSvg(svg, dim); + img = ImageProvider.createImageFromSvg(svg, dim, resizeMode); if (img == null) { return null; @@ -182,17 +185,7 @@ } else { if (baseImage == null) throw new AssertionError(); - ImageIcon icon = new ImageIcon(baseImage); - if (dim.width == -1 && dim.height == -1) { - dim.width = GuiSizesHelper.getSizeDpiAdjusted(icon.getIconWidth()); - dim.height = GuiSizesHelper.getSizeDpiAdjusted(icon.getIconHeight()); - } else if (dim.width == -1) { - dim.width = Math.max(1, icon.getIconWidth() * dim.height / icon.getIconHeight()); - } else if (dim.height == -1) { - dim.height = Math.max(1, icon.getIconHeight() * dim.width / icon.getIconWidth()); - } - Image i = icon.getImage().getScaledInstance(dim.width, dim.height, Image.SCALE_SMOOTH); - img = new BufferedImage(dim.width, dim.height, BufferedImage.TYPE_INT_ARGB); - img.getGraphics().drawImage(i, 0, 0, null); + img = resizeMode.createBufferedImage(dim, new Dimension(icon.getIconWidth(), icon.getIconHeight()), + g -> g.drawImage(icon.getImage(), 0, 0, null)); } if (overlayInfo != null) { @@ -212,5 +205,5 @@ disabledIcon.paintIcon(new JPanel(), img.getGraphics(), 0, 0); } - imgCache.put(dim, img); + imgCache.put(cacheKey, img); } @@ -219,5 +212,5 @@ else { try { - Image mrImg = HiDPISupport.getMultiResolutionImage(img, this); + Image mrImg = HiDPISupport.getMultiResolutionImage(img, this, resizeMode); return new ImageIcon(mrImg); } catch (NoClassDefFoundError e) { @@ -237,55 +230,7 @@ * which means it is not bounded. * @return ImageIcon object for the image of this resource, scaled down if needed, according to maxSize - * @see #getImageIconBounded(java.awt.Dimension, boolean) */ public ImageIcon getImageIconBounded(Dimension maxSize) { - return getImageIconBounded(maxSize, true); - } - - /** - * Get image icon with a certain maximum size. The image is scaled down - * to fit maximum dimensions. (Keeps aspect ratio) - * - * @param maxSize The maximum size. One of the dimensions (width or height) can be -1, - * which means it is not bounded. - * @param multiResolution If true, return a multi-resolution image - * (java.awt.image.MultiResolutionImage in Java 9), otherwise a plain {@link BufferedImage}. - * When running Java 8, this flag has no effect and a plain image will be returned in any case. - * @return ImageIcon object for the image of this resource, scaled down if needed, according to maxSize - * @since 12722 - */ - public ImageIcon getImageIconBounded(Dimension maxSize, boolean multiResolution) { - CheckParameterUtil.ensureThat((maxSize.width > 0 || maxSize.width == -1) && (maxSize.height > 0 || maxSize.height == -1), - () -> maxSize + " is invalid"); - float sourceWidth; - float sourceHeight; - int maxWidth = maxSize.width; - int maxHeight = maxSize.height; - if (svg != null) { - sourceWidth = svg.getWidth(); - sourceHeight = svg.getHeight(); - } else { - if (baseImage == null) throw new AssertionError(); - ImageIcon icon = new ImageIcon(baseImage); - sourceWidth = icon.getIconWidth(); - sourceHeight = icon.getIconHeight(); - if (sourceWidth <= maxWidth) { - maxWidth = -1; - } - if (sourceHeight <= maxHeight) { - maxHeight = -1; - } - } - - if (maxWidth == -1 && maxHeight == -1) - return getImageIcon(DEFAULT_DIMENSION, multiResolution); - else if (maxWidth == -1) - return getImageIcon(new Dimension(-1, maxHeight), multiResolution); - else if (maxHeight == -1) - return getImageIcon(new Dimension(maxWidth, -1), multiResolution); - else if (sourceWidth / maxWidth > sourceHeight / maxHeight) - return getImageIcon(new Dimension(maxWidth, -1), multiResolution); - else - return getImageIcon(new Dimension(-1, maxHeight), multiResolution); + return getImageIcon(maxSize, true, ImageResizeMode.BOUNDED); } @@ -297,17 +242,5 @@ */ public ImageIcon getPaddedIcon(Dimension iconSize) { - final ImageIcon imageIcon = getImageIcon(iconSize); - if (imageIcon.getIconWidth() == iconSize.width && imageIcon.getIconHeight() == iconSize.height) { - // fast path for square and svg icons - return imageIcon; - } - - final Dimension cacheKey = new Dimension(-iconSize.width, -iconSize.height); // use negative width/height for differentiation - BufferedImage image = imgCache.get(cacheKey); - if (image == null) { - image = ImageProvider.createPaddedIcon(getImageIcon().getImage(), iconSize); - imgCache.put(cacheKey, image); - } - return new ImageIcon(image); + return getImageIcon(iconSize, true, ImageResizeMode.PADDED); } Index: /trunk/test/unit/org/openstreetmap/josm/tools/ImageResizeModeTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/tools/ImageResizeModeTest.java (revision 16946) +++ /trunk/test/unit/org/openstreetmap/josm/tools/ImageResizeModeTest.java (revision 16946) @@ -0,0 +1,59 @@ +// License: GPL. For details, see LICENSE file. + +package org.openstreetmap.josm.tools; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.awt.Dimension; + +import org.junit.Rule; +import org.junit.Test; +import org.openstreetmap.josm.testutils.JOSMTestRules; + +import edu.umd.cs.findbugs.annotations.SuppressFBWarnings; + +public class ImageResizeModeTest { + + /** + * Setup test. + */ + @Rule + @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD") + public JOSMTestRules test = new JOSMTestRules().preferences(); + + @Test + public void testComputeDimension() { + final Dimension image = new Dimension(64, 48); + assertThrows(IllegalArgumentException.class, () -> ImageResizeMode.AUTO.computeDimension(new Dimension(0, 0), image)); + assertEquals(new Dimension(64, 48), ImageResizeMode.AUTO.computeDimension(ImageResource.DEFAULT_DIMENSION, image)); + assertEquals(new Dimension(64, 48), ImageResizeMode.AUTO.computeDimension(new Dimension(-1, -1), image)); + assertEquals(new Dimension(64, 48), ImageResizeMode.AUTO.computeDimension(new Dimension(64, 48), image)); + assertEquals(new Dimension(32, 24), ImageResizeMode.AUTO.computeDimension(new Dimension(32, -1), image)); + assertEquals(new Dimension(21, 16), ImageResizeMode.AUTO.computeDimension(new Dimension(-1, 16), image)); + assertEquals(new Dimension(24, 32), ImageResizeMode.AUTO.computeDimension(new Dimension(24, 32), image)); + assertEquals(new Dimension(64, 48), ImageResizeMode.BOUNDED.computeDimension(ImageResource.DEFAULT_DIMENSION, image)); + assertEquals(new Dimension(64, 48), ImageResizeMode.BOUNDED.computeDimension(new Dimension(-1, -1), image)); + assertEquals(new Dimension(64, 48), ImageResizeMode.BOUNDED.computeDimension(new Dimension(64, 48), image)); + assertEquals(new Dimension(32, 24), ImageResizeMode.BOUNDED.computeDimension(new Dimension(32, -1), image)); + assertEquals(new Dimension(21, 16), ImageResizeMode.BOUNDED.computeDimension(new Dimension(-1, 16), image)); + assertEquals(new Dimension(24, 18), ImageResizeMode.BOUNDED.computeDimension(new Dimension(24, 32), image)); + assertThrows(IllegalArgumentException.class, () -> ImageResizeMode.PADDED.computeDimension(new Dimension(0, 0), image)); + assertThrows(IllegalArgumentException.class, () -> ImageResizeMode.PADDED.computeDimension(ImageResource.DEFAULT_DIMENSION, image)); + assertThrows(IllegalArgumentException.class, () -> ImageResizeMode.PADDED.computeDimension(new Dimension(-1, -1), image)); + assertThrows(IllegalArgumentException.class, () -> ImageResizeMode.PADDED.computeDimension(new Dimension(32, -1), image)); + assertThrows(IllegalArgumentException.class, () -> ImageResizeMode.PADDED.computeDimension(new Dimension(-1, 16), image)); + assertEquals(new Dimension(64, 48), ImageResizeMode.PADDED.computeDimension(new Dimension(64, 48), image)); + assertEquals(new Dimension(24, 32), ImageResizeMode.PADDED.computeDimension(new Dimension(24, 32), image)); + } + + @Test + public void testCacheKey() { + assertEquals(0x00180018, ImageResizeMode.AUTO.cacheKey(ImageProvider.ImageSizes.LARGEICON.getImageDimension())); + assertEquals(0x10180018, ImageResizeMode.BOUNDED.cacheKey(ImageProvider.ImageSizes.LARGEICON.getImageDimension())); + assertEquals(0x20180018, ImageResizeMode.PADDED.cacheKey(ImageProvider.ImageSizes.LARGEICON.getImageDimension())); + assertEquals(0x21000100, ImageResizeMode.PADDED.cacheKey(ImageProvider.ImageSizes.ABOUT_LOGO.getImageDimension())); + assertEquals(0x0fff0fff, ImageResizeMode.AUTO.cacheKey(ImageResource.DEFAULT_DIMENSION)); + assertEquals(0x2fff0fff, ImageResizeMode.PADDED.cacheKey(ImageResource.DEFAULT_DIMENSION)); + } +} Index: /trunk/test/unit/org/openstreetmap/josm/tools/OsmPrimitiveImageProviderTest.java =================================================================== --- /trunk/test/unit/org/openstreetmap/josm/tools/OsmPrimitiveImageProviderTest.java (revision 16945) +++ /trunk/test/unit/org/openstreetmap/josm/tools/OsmPrimitiveImageProviderTest.java (revision 16946) @@ -61,5 +61,11 @@ assertNotNull(OsmPrimitiveImageProvider.getResource(OsmUtils.createPrimitive("way waterway=stream"), noDefault)); assertNotNull(OsmPrimitiveImageProvider.getResource(OsmUtils.createPrimitive("relation type=route route=railway"), noDefault)); - // a non-square svg icon + } + + /** + * Unit test of {@link OsmPrimitiveImageProvider#getResource} for non-square images. + */ + @Test + public void testGetResourceNonSquare() { final ImageIcon bankIcon = OsmPrimitiveImageProvider .getResource(OsmUtils.createPrimitive("node amenity=bank"), Options.DEFAULT) @@ -67,4 +73,9 @@ assertEquals(ImageProvider.ImageSizes.LARGEICON.getVirtualWidth(), bankIcon.getIconWidth()); assertEquals(ImageProvider.ImageSizes.LARGEICON.getVirtualHeight(), bankIcon.getIconHeight()); + final ImageIcon addressIcon = OsmPrimitiveImageProvider + .getResource(OsmUtils.createPrimitive("node \"addr:housenumber\"=123"), Options.DEFAULT) + .getPaddedIcon(ImageProvider.ImageSizes.LARGEICON.getImageDimension()); + assertEquals(ImageProvider.ImageSizes.LARGEICON.getVirtualWidth(), addressIcon.getIconWidth()); + assertEquals(ImageProvider.ImageSizes.LARGEICON.getVirtualHeight(), addressIcon.getIconHeight()); } }