< prev index next >
src/java.desktop/share/classes/sun/awt/SunToolkit.java
Print this page
@@ -35,11 +35,10 @@
import java.awt.image.ImageObserver;
import java.awt.image.ImageProducer;
import java.awt.image.Raster;
import java.awt.peer.FramePeer;
import java.awt.peer.KeyboardFocusManagerPeer;
-import java.awt.peer.MouseInfoPeer;
import java.awt.peer.SystemTrayPeer;
import java.awt.peer.TrayIconPeer;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
@@ -67,12 +66,15 @@
import sun.font.FontDesignMetrics;
import sun.net.util.URLUtil;
import sun.security.action.GetBooleanAction;
import sun.security.action.GetPropertyAction;
import sun.util.logging.PlatformLogger;
+import java.util.List;
+import sun.awt.image.MultiResolutionToolkitImage.ResolutionVariantItem;
import static java.awt.RenderingHints.*;
+import java.util.LinkedList;
public abstract class SunToolkit extends Toolkit
implements ComponentFactory, InputMethodSupport, KeyboardFocusManagerPeerProvider {
// 8014718: logging has been removed from SunToolkit
@@ -687,47 +689,167 @@
}
}
@Override
public Image getImage(String filename) {
- return getImageFromHash(this, filename);
+ return getImageUsingNamingSchemes(filename, getNamingSchemes());
}
+
@Override
public Image getImage(URL url) {
+ return getImageUsingNamingSchemes(url, getNamingSchemes());
+ }
+
+ public Image getResolutionVariant(String filename) {
+ return getImageFromHash(this, filename);
+ }
+
+ public Image getResolutionVariant(URL url) {
return getImageFromHash(this, url);
}
- protected Image getImageWithResolutionVariant(String fileName,
- String resolutionVariantName) {
+ public static Image getImageUsingNamingSchemes(Toolkit toolkit, String fileName,
+ MediaResolutionNamingScheme... namingSchemes) {
+
+ SunToolkit sunToolkit = null;
+ if(toolkit instanceof SunToolkit){
+ sunToolkit = (SunToolkit) toolkit;
+ }
+
synchronized (fileImgCache) {
- Image image = getImageFromHash(this, fileName);
- if (image instanceof MultiResolutionImage) {
- return image;
+ Image baseImage = sunToolkit == null
+ ? toolkit.getImage(fileName)
+ : sunToolkit.getResolutionVariant(fileName);
+
+ if (fileName == null || namingSchemes.length == 0
+ || (baseImage instanceof MultiResolutionImage)) {
+ return baseImage;
+ }
+
+ LinkedList<ResolutionVariantItem> rvItems = new LinkedList<>();
+ String[] rvNames = getRVNames(fileName, namingSchemes);
+
+ for (int i = 0; i < namingSchemes.length; i++) {
+ String rvName = rvNames[i];
+ if (imageExists(rvName)) {
+ Image rvImage = sunToolkit == null
+ ? toolkit.getImage(rvName)
+ : sunToolkit.getResolutionVariant(rvName);
+ float scale = namingSchemes[i].getScale();
+ rvItems.add(new ResolutionVariantItem(rvImage, scale, scale));
+ }
+ }
+
+ if (rvItems.isEmpty()) {
+ return baseImage;
+ }
+
+ rvItems.addFirst(new ResolutionVariantItem(baseImage, 1, 1));
+ Image mrImage = new MultiResolutionToolkitImage(baseImage, rvItems);
+
+ fileImgCache.put(fileName, mrImage);
+ return mrImage;
}
- Image resolutionVariant = getImageFromHash(this, resolutionVariantName);
- image = createImageWithResolutionVariant(image, resolutionVariant);
- fileImgCache.put(fileName, image);
- return image;
}
+
+ public static Image getImageUsingNamingSchemes(Toolkit toolkit, URL url,
+ MediaResolutionNamingScheme... namingSchemes) {
+
+ SunToolkit sunToolkit = null;
+ if(toolkit instanceof SunToolkit){
+ sunToolkit = (SunToolkit) toolkit;
}
- protected Image getImageWithResolutionVariant(URL url,
- URL resolutionVariantURL) {
synchronized (urlImgCache) {
- Image image = getImageFromHash(this, url);
- if (image instanceof MultiResolutionImage) {
- return image;
+ Image baseImage = sunToolkit == null
+ ? toolkit.getImage(url)
+ : sunToolkit.getResolutionVariant(url);
+
+ if (url == null || namingSchemes.length == 0
+ || (baseImage instanceof MultiResolutionImage)) {
+ return baseImage;
}
- Image resolutionVariant = getImageFromHash(this, resolutionVariantURL);
- image = createImageWithResolutionVariant(image, resolutionVariant);
- String key = url.toString();
- urlImgCache.put(key, image);
- return image;
+
+ LinkedList<ResolutionVariantItem> rvItems = new LinkedList<>();
+ String[] rvNames = getRVNames(url.getPath(), namingSchemes);
+
+ for (int i = 0; i < namingSchemes.length; i++) {
+ String rvName = rvNames[i];
+ URL rvURL;
+ try {
+ rvURL = new URL(url.getProtocol(), url.getHost(),
+ url.getPort(), rvName);
+ } catch (Exception e) {
+ continue;
+ }
+ if (imageExists(rvURL)) {
+ Image rvImage = sunToolkit == null
+ ? toolkit.getImage(rvURL)
+ : sunToolkit.getResolutionVariant(rvURL);
+ float scale = namingSchemes[i].getScale();
+ rvItems.add(new ResolutionVariantItem(rvImage, scale, scale));
+ }
+ }
+
+ if (rvItems.isEmpty()) {
+ return baseImage;
+ }
+
+ rvItems.addFirst(new ResolutionVariantItem(baseImage, 1, 1));
+ Image mrImage = new MultiResolutionToolkitImage(baseImage, rvItems);
+
+ urlImgCache.put(url.toString(), mrImage);
+
+ return mrImage;
+ }
+ }
+
+ private static String[] getRVNames(String fileName,
+ MediaResolutionNamingScheme... namingSchemes) {
+
+ if (!isValidPath(fileName)) {
+ return null;
+ }
+
+ int slash = fileName.lastIndexOf('/');
+ String name = (slash < 0) ? fileName : fileName.substring(slash + 1);
+
+ int dot = name.lastIndexOf('.');
+ String ext = (dot < 0) ? "" : name.substring(dot);
+ name = (dot < 0) ? name : name.substring(0, dot);
+ String prefix = (slash < 0) ? name : fileName.substring(0, slash + 1) + name;
+
+ String[] rvNames = new String[namingSchemes.length];
+
+ for (int i = 0; i < namingSchemes.length; i++) {
+ rvNames[i] = prefix + namingSchemes[i].getQualifier() + ext;
+ }
+
+ return rvNames;
}
+
+ private static boolean isValidPath(String path) {
+ return path != null
+ && !path.isEmpty()
+ && !path.endsWith("/")
+ && !path.endsWith(".");
}
+ private static MediaResolutionNamingScheme[] DEFAULT_NAMING_SCHEME = {
+ new MediaResolutionNamingScheme("@125pct", 1.25f),
+ new MediaResolutionNamingScheme("@150pct", 1.5f),
+ new MediaResolutionNamingScheme("@2x", 2f),
+ new MediaResolutionNamingScheme("@200pct", 2f),
+ new MediaResolutionNamingScheme("@250pct", 2.5f),
+ new MediaResolutionNamingScheme("@3x", 3f),
+ new MediaResolutionNamingScheme("@300pct", 3f)
+ };
+
+ protected MediaResolutionNamingScheme[] getNamingSchemes() {
+ return DEFAULT_NAMING_SCHEME;
+ }
@Override
public Image createImage(String filename) {
checkPermissions(filename);
return createImage(new FileImageSource(filename));
@@ -747,15 +869,10 @@
@Override
public Image createImage(ImageProducer producer) {
return new ToolkitImage(producer);
}
- public static Image createImageWithResolutionVariant(Image image,
- Image resolutionVariant) {
- return new MultiResolutionToolkitImage(image, resolutionVariant);
- }
-
@Override
public int checkImage(Image img, int w, int h, ImageObserver o) {
if (!(img instanceof ToolkitImage)) {
return ImageObserver.ALLBITS;
}
@@ -765,11 +882,11 @@
if (w == 0 || h == 0) {
repbits = ImageObserver.ALLBITS;
} else {
repbits = tkimg.getImageRep().check(o);
}
- return (tkimg.check(o) | repbits) & checkResolutionVariant(img, w, h, o);
+ return (tkimg.check(o) | repbits) & checkResolutionVariants(img, w, h, o);
}
@Override
public boolean prepareImage(Image img, int w, int h, ImageObserver o) {
if (w == 0 || h == 0) {
@@ -788,50 +905,57 @@
-1, -1, -1, -1);
}
return false;
}
ImageRepresentation ir = tkimg.getImageRep();
- return ir.prepare(o) & prepareResolutionVariant(img, w, h, o);
+ return ir.prepare(o) & prepareResolutionVariants(img, w, h, o);
}
- private int checkResolutionVariant(Image img, int w, int h, ImageObserver o) {
- ToolkitImage rvImage = getResolutionVariant(img);
- int rvw = getRVSize(w);
- int rvh = getRVSize(h);
- // Ignore the resolution variant in case of error
- return (rvImage == null || rvImage.hasError()) ? 0xFFFF :
- checkImage(rvImage, rvw, rvh, MultiResolutionToolkitImage.
- getResolutionVariantObserver(
- img, o, w, h, rvw, rvh, true));
+ private int checkResolutionVariants(Image img, int w, int h, ImageObserver o) {
+ if (!(img instanceof MultiResolutionToolkitImage)) {
+ return 0xFFFF;
}
- private boolean prepareResolutionVariant(Image img, int w, int h,
- ImageObserver o) {
+ List<ResolutionVariantItem> rvItems
+ = ((MultiResolutionToolkitImage) img).getResolutionVariantItems();
- ToolkitImage rvImage = getResolutionVariant(img);
- int rvw = getRVSize(w);
- int rvh = getRVSize(h);
- // Ignore the resolution variant in case of error
- return rvImage == null || rvImage.hasError() || prepareImage(
- rvImage, rvw, rvh,
+ return rvItems.stream().map(rvItem -> {
+ double scaleX = rvItem.getScaleX();
+ double scaleY = rvItem.getScaleY();
+ return checkImage(
+ rvItem.getImage(),
+ getRVSize(w, scaleX),
+ getRVSize(h, scaleY),
MultiResolutionToolkitImage.getResolutionVariantObserver(
- img, o, w, h, rvw, rvh, true));
+ img, o, scaleX, scaleY, true));
+ }).reduce(0xFFFF , (a, b) -> a & b);
}
- private static int getRVSize(int size){
- return size == -1 ? -1 : 2 * size;
- }
+ private boolean prepareResolutionVariants(Image img, int w, int h,
+ ImageObserver o) {
- private static ToolkitImage getResolutionVariant(Image image) {
- if (image instanceof MultiResolutionToolkitImage) {
- Image resolutionVariant = ((MultiResolutionToolkitImage) image).
- getResolutionVariant();
- if (resolutionVariant instanceof ToolkitImage) {
- return (ToolkitImage) resolutionVariant;
+ if (!(img instanceof MultiResolutionToolkitImage)) {
+ return true;
}
+
+ List<ResolutionVariantItem> rvItems
+ = ((MultiResolutionToolkitImage) img).getResolutionVariantItems();
+
+ return rvItems.stream().map(rvItem -> {
+ double scaleX = rvItem.getScaleX();
+ double scaleY = rvItem.getScaleY();
+ return prepareImage(
+ rvItem.getImage(),
+ getRVSize(w, scaleX),
+ getRVSize(h, scaleY),
+ MultiResolutionToolkitImage.getResolutionVariantObserver(
+ img, o, scaleX, scaleY, true));
+ }).reduce(true, (a, b) -> a && b);
}
- return null;
+
+ private static int getRVSize(int size, double scale) {
+ return (scale == 1 || size == -1) ? size : (int) Math.ceil(scale * size);
}
protected static boolean imageCached(String fileName) {
return fileImgCache.containsKey(fileName);
}
< prev index next >