1 /* 2 * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 package java.awt; 26 27 import java.io.IOException; 28 import java.awt.image.*; 29 import java.net.URL; 30 import java.net.URLConnection; 31 import java.io.File; 32 import sun.util.logging.PlatformLogger; 33 import sun.awt.image.SunWritableRaster; 34 35 /** 36 * The splash screen can be displayed at application startup, before the 37 * Java Virtual Machine (JVM) starts. The splash screen is displayed as an 38 * undecorated window containing an image. You can use GIF, JPEG, or PNG files 39 * for the image. Animation is supported for the GIF format, while transparency 40 * is supported both for GIF and PNG. The window is positioned at the center 41 * of the screen. The position on multi-monitor systems is not specified. It is 42 * platform and implementation dependent. The splash screen window is closed 43 * automatically as soon as the first window is displayed by Swing/AWT (may be 44 * also closed manually using the Java API, see below). 45 * <P> 46 * If your application is packaged in a jar file, you can use the 47 * "SplashScreen-Image" option in a manifest file to show a splash screen. 48 * Place the image in the jar archive and specify the path in the option. 49 * The path should not have a leading slash. 50 * <BR> 51 * For example, in the <code>manifest.mf</code> file: 52 * <PRE> 53 * Manifest-Version: 1.0 54 * Main-Class: Test 55 * SplashScreen-Image: filename.gif 56 * </PRE> 57 * <P> 58 * If the Java implementation provides the command-line interface and you run 59 * your application by using the command line or a shortcut, use the Java 60 * application launcher option to show a splash screen. The Oracle reference 61 * implementation allows you to specify the splash screen image location with 62 * the {@code -splash:} option. 63 * <BR> 64 * For example: 65 * <PRE> 66 * java -splash:filename.gif Test 67 * </PRE> 68 * The command line interface has higher precedence over the manifest 69 * setting. 70 * <p> 71 * The splash screen will be displayed as faithfully as possible to present the 72 * whole splash screen image given the limitations of the target platform and 73 * display. 74 * <p> 75 * It is implied that the specified image is presented on the screen "as is", 76 * i.e. preserving the exact color values as specified in the image file. Under 77 * certain circumstances, though, the presented image may differ, e.g. when 78 * applying color dithering to present a 32 bits per pixel (bpp) image on a 16 79 * or 8 bpp screen. The native platform display configuration may also affect 80 * the colors of the displayed image (e.g. color profiles, etc.) 81 * <p> 82 * The {@code SplashScreen} class provides the API for controlling the splash 83 * screen. This class may be used to close the splash screen, change the splash 84 * screen image, get the splash screen native window position/size, and paint 85 * in the splash screen. It cannot be used to create the splash screen. You 86 * should use the options provided by the Java implementation for that. 87 * <p> 88 * This class cannot be instantiated. Only a single instance of this class 89 * can exist, and it may be obtained by using the {@link #getSplashScreen()} 90 * static method. In case the splash screen has not been created at 91 * application startup via the command line or manifest file option, 92 * the <code>getSplashScreen</code> method returns <code>null</code>. 93 * 94 * @author Oleg Semenov 95 * @since 1.6 96 */ 97 public final class SplashScreen { 98 99 SplashScreen(long ptr) { // non-public constructor 100 splashPtr = ptr; 101 } 102 103 /** 104 * Returns the {@code SplashScreen} object used for 105 * Java startup splash screen control on systems that support display. 106 * 107 * @throws UnsupportedOperationException if the splash screen feature is not 108 * supported by the current toolkit 109 * @throws HeadlessException if {@code GraphicsEnvironment.isHeadless()} 110 * returns true 111 * @return the {@link SplashScreen} instance, or <code>null</code> if there is 112 * none or it has already been closed 113 */ 114 public static SplashScreen getSplashScreen() { 115 synchronized (SplashScreen.class) { 116 if (GraphicsEnvironment.isHeadless()) { 117 throw new HeadlessException(); 118 } 119 // SplashScreen class is now a singleton 120 if (!wasClosed && theInstance == null) { 121 java.security.AccessController.doPrivileged( 122 new java.security.PrivilegedAction<Void>() { 123 public Void run() { 124 System.loadLibrary("splashscreen"); 125 return null; 126 } 127 }); 128 long ptr = _getInstance(); 129 if (ptr != 0 && _isVisible(ptr)) { 130 theInstance = new SplashScreen(ptr); 131 } 132 } 133 return theInstance; 134 } 135 } 136 137 /** 138 * Changes the splash screen image. The new image is loaded from the 139 * specified URL; GIF, JPEG and PNG image formats are supported. 140 * The method returns after the image has finished loading and the window 141 * has been updated. 142 * The splash screen window is resized according to the size of 143 * the image and is centered on the screen. 144 * 145 * @param imageURL the non-<code>null</code> URL for the new 146 * splash screen image 147 * @throws NullPointerException if {@code imageURL} is <code>null</code> 148 * @throws IOException if there was an error while loading the image 149 * @throws IllegalStateException if the splash screen has already been 150 * closed 151 */ 152 public void setImageURL(URL imageURL) throws NullPointerException, IOException, IllegalStateException { 153 checkVisible(); 154 URLConnection connection = imageURL.openConnection(); 155 connection.connect(); 156 int length = connection.getContentLength(); 157 java.io.InputStream stream = connection.getInputStream(); 158 byte[] buf = new byte[length]; 159 int off = 0; 160 while(true) { 161 // check for available data 162 int available = stream.available(); 163 if (available <= 0) { 164 // no data available... well, let's try reading one byte 165 // we'll see what happens then 166 available = 1; 167 } 168 // check for enough room in buffer, realloc if needed 169 // the buffer always grows in size 2x minimum 170 if (off + available > length) { 171 length = off*2; 172 if (off + available > length) { 173 length = available+off; 174 } 175 byte[] oldBuf = buf; 176 buf = new byte[length]; 177 System.arraycopy(oldBuf, 0, buf, 0, off); 178 } 179 // now read the data 180 int result = stream.read(buf, off, available); 181 if (result < 0) { 182 break; 183 } 184 off += result; 185 } 186 synchronized(SplashScreen.class) { 187 checkVisible(); 188 if (!_setImageData(splashPtr, buf)) { 189 throw new IOException("Bad image format or i/o error when loading image"); 190 } 191 this.imageURL = imageURL; 192 } 193 } 194 195 private void checkVisible() { 196 if (!isVisible()) { 197 throw new IllegalStateException("no splash screen available"); 198 } 199 } 200 /** 201 * Returns the current splash screen image. 202 * 203 * @return URL for the current splash screen image file 204 * @throws IllegalStateException if the splash screen has already been closed 205 */ 206 public URL getImageURL() throws IllegalStateException { 207 synchronized (SplashScreen.class) { 208 checkVisible(); 209 if (imageURL == null) { 210 try { 211 String fileName = _getImageFileName(splashPtr); 212 String jarName = _getImageJarName(splashPtr); 213 if (fileName != null) { 214 if (jarName != null) { 215 imageURL = new URL("jar:"+(new File(jarName).toURL().toString())+"!/"+fileName); 216 } else { 217 imageURL = new File(fileName).toURL(); 218 } 219 } 220 } 221 catch(java.net.MalformedURLException e) { 222 if (log.isLoggable(PlatformLogger.Level.FINE)) { 223 log.fine("MalformedURLException caught in the getImageURL() method", e); 224 } 225 } 226 } 227 return imageURL; 228 } 229 } 230 231 /** 232 * Returns the bounds of the splash screen window as a {@link Rectangle}. 233 * This may be useful if, for example, you want to replace the splash 234 * screen with your window at the same location. 235 * <p> 236 * You cannot control the size or position of the splash screen. 237 * The splash screen size is adjusted automatically when the image changes. 238 * <p> 239 * The image may contain transparent areas, and thus the reported bounds may 240 * be larger than the visible splash screen image on the screen. 241 * 242 * @return a {@code Rectangle} containing the splash screen bounds 243 * @throws IllegalStateException if the splash screen has already been closed 244 */ 245 public Rectangle getBounds() throws IllegalStateException { 246 synchronized (SplashScreen.class) { 247 checkVisible(); 248 float scale = _getScaleFactor(splashPtr); 249 Rectangle bounds = _getBounds(splashPtr); 250 assert scale > 0; 251 if (scale > 0 && scale != 1) { 252 bounds.setSize((int) (bounds.getWidth() / scale), 253 (int) (bounds.getWidth() / scale)); 254 } 255 return bounds; 256 } 257 } 258 259 /** 260 * Returns the size of the splash screen window as a {@link Dimension}. 261 * This may be useful if, for example, 262 * you want to draw on the splash screen overlay surface. 263 * <p> 264 * You cannot control the size or position of the splash screen. 265 * The splash screen size is adjusted automatically when the image changes. 266 * <p> 267 * The image may contain transparent areas, and thus the reported size may 268 * be larger than the visible splash screen image on the screen. 269 * 270 * @return a {@link Dimension} object indicating the splash screen size 271 * @throws IllegalStateException if the splash screen has already been closed 272 */ 273 public Dimension getSize() throws IllegalStateException { 274 return getBounds().getSize(); 275 } 276 277 /** 278 * Creates a graphics context (as a {@link Graphics2D} object) for the splash 279 * screen overlay image, which allows you to draw over the splash screen. 280 * Note that you do not draw on the main image but on the image that is 281 * displayed over the main image using alpha blending. Also note that drawing 282 * on the overlay image does not necessarily update the contents of splash 283 * screen window. You should call {@code update()} on the 284 * <code>SplashScreen</code> when you want the splash screen to be 285 * updated immediately. 286 * <p> 287 * The pixel (0, 0) in the coordinate space of the graphics context 288 * corresponds to the origin of the splash screen native window bounds (see 289 * {@link #getBounds()}). 290 * 291 * @return graphics context for the splash screen overlay surface 292 * @throws IllegalStateException if the splash screen has already been closed 293 */ 294 public Graphics2D createGraphics() throws IllegalStateException { 295 synchronized (SplashScreen.class) { 296 checkVisible(); 297 if (image==null) { 298 // get unscaled splash image size 299 Dimension dim = _getBounds(splashPtr).getSize(); 300 image = new BufferedImage(dim.width, dim.height, 301 BufferedImage.TYPE_INT_ARGB); 302 } 303 float scale = _getScaleFactor(splashPtr); 304 Graphics2D g = image.createGraphics(); 305 assert (scale > 0); 306 if (scale <= 0) { 307 scale = 1; 308 } 309 g.scale(scale, scale); 310 return g; 311 } 312 } 313 314 /** 315 * Updates the splash window with current contents of the overlay image. 316 * 317 * @throws IllegalStateException if the overlay image does not exist; 318 * for example, if {@code createGraphics} has never been called, 319 * or if the splash screen has already been closed 320 */ 321 public void update() throws IllegalStateException { 322 BufferedImage image; 323 synchronized (SplashScreen.class) { 324 checkVisible(); 325 image = this.image; 326 } 327 if (image == null) { 328 throw new IllegalStateException("no overlay image available"); 329 } 330 DataBuffer buf = image.getRaster().getDataBuffer(); 331 if (!(buf instanceof DataBufferInt)) { 332 throw new AssertionError("Overlay image DataBuffer is of invalid type == "+buf.getClass().getName()); 333 } 334 int numBanks = buf.getNumBanks(); 335 if (numBanks!=1) { 336 throw new AssertionError("Invalid number of banks =="+numBanks+" in overlay image DataBuffer"); 337 } 338 if (!(image.getSampleModel() instanceof SinglePixelPackedSampleModel)) { 339 throw new AssertionError("Overlay image has invalid sample model == "+image.getSampleModel().getClass().getName()); 340 } 341 SinglePixelPackedSampleModel sm = (SinglePixelPackedSampleModel)image.getSampleModel(); 342 int scanlineStride = sm.getScanlineStride(); 343 Rectangle rect = image.getRaster().getBounds(); 344 // Note that we steal the data array here, but just for reading 345 // so we do not need to mark the DataBuffer dirty... 346 int[] data = SunWritableRaster.stealData((DataBufferInt)buf, 0); 347 synchronized(SplashScreen.class) { 348 checkVisible(); 349 _update(splashPtr, data, rect.x, rect.y, rect.width, rect.height, scanlineStride); 350 } 351 } 352 353 /** 354 * Hides the splash screen, closes the window, and releases all associated 355 * resources. 356 * 357 * @throws IllegalStateException if the splash screen has already been closed 358 */ 359 public void close() throws IllegalStateException { 360 synchronized (SplashScreen.class) { 361 checkVisible(); 362 _close(splashPtr); 363 image = null; 364 SplashScreen.markClosed(); 365 } 366 } 367 368 static void markClosed() { 369 synchronized (SplashScreen.class) { 370 wasClosed = true; 371 theInstance = null; 372 } 373 } 374 375 376 /** 377 * Determines whether the splash screen is visible. The splash screen may 378 * be hidden using {@link #close()}, it is also hidden automatically when 379 * the first AWT/Swing window is made visible. 380 * <p> 381 * Note that the native platform may delay presenting the splash screen 382 * native window on the screen. The return value of {@code true} for this 383 * method only guarantees that the conditions to hide the splash screen 384 * window have not occurred yet. 385 * 386 * @return true if the splash screen is visible (has not been closed yet), 387 * false otherwise 388 */ 389 public boolean isVisible() { 390 synchronized (SplashScreen.class) { 391 return !wasClosed && _isVisible(splashPtr); 392 } 393 } 394 395 private BufferedImage image; // overlay image 396 397 private final long splashPtr; // pointer to native Splash structure 398 private static boolean wasClosed = false; 399 400 private URL imageURL; 401 402 /** 403 * The instance reference for the singleton. 404 * (<code>null</code> if no instance exists yet.) 405 * 406 * @see #getSplashScreen 407 * @see #close 408 */ 409 private static SplashScreen theInstance = null; 410 411 private static final PlatformLogger log = PlatformLogger.getLogger("java.awt.SplashScreen"); 412 413 private native static void _update(long splashPtr, int[] data, int x, int y, int width, int height, int scanlineStride); 414 private native static boolean _isVisible(long splashPtr); 415 private native static Rectangle _getBounds(long splashPtr); 416 private native static long _getInstance(); 417 private native static void _close(long splashPtr); 418 private native static String _getImageFileName(long splashPtr); 419 private native static String _getImageJarName(long SplashPtr); 420 private native static boolean _setImageData(long SplashPtr, byte[] data); 421 private native static float _getScaleFactor(long SplashPtr); 422 423 }