Showing the changes to java/pkg/javax/swing/BufferStrategyPaintManager.java (1 of 18352 files). Show all
Unified · Split
| @@ -0,0 +1,956 @@ | |||
| 1 | /* | ||
| 2 | * Copyright (c) 2005, 2011, 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 javax.swing; | ||
| 26 | |||
| 27 | import java.applet.Applet; | ||
| 28 | import java.awt.*; | ||
| 29 | import java.awt.event.*; | ||
| 30 | import java.awt.image.*; | ||
| 31 | import java.lang.reflect.*; | ||
| 32 | import java.lang.ref.WeakReference; | ||
| 33 | import java.security.AccessController; | ||
| 34 | import java.util.*; | ||
| 35 | |||
| 36 | import com.sun.java.swing.SwingUtilities3; | ||
| 37 | |||
| 38 | import sun.awt.SubRegionShowable; | ||
| 39 | import sun.java2d.SunGraphics2D; | ||
| 40 | import sun.security.action.GetPropertyAction; | ||
| 41 | import sun.java2d.pipe.hw.ExtendedBufferCapabilities; | ||
| 42 | import sun.awt.SunToolkit; | ||
| 43 | import sun.util.logging.PlatformLogger; | ||
| 44 | |||
| 45 | /** | ||
| 46 | * A PaintManager implementation that uses a BufferStrategy for | ||
| 47 | * rendering. | ||
| 48 | * | ||
| 49 | * @author Scott Violet | ||
| 50 | */ | ||
| 51 | class BufferStrategyPaintManager extends RepaintManager.PaintManager { | ||
| 52 | // | ||
| 53 | // All drawing is done to a BufferStrategy. At the end of painting | ||
| 54 | // (endPaint) the region that was painted is flushed to the screen | ||
| 55 | // (using BufferStrategy.show). | ||
| 56 | // | ||
| 57 | // PaintManager.show is overriden to show directly from the | ||
| 58 | // BufferStrategy (when using blit), if successful true is | ||
| 59 | // returned and a paint event will not be generated. To avoid | ||
| 60 | // showing from the buffer while painting a locking scheme is | ||
| 61 | // implemented. When beginPaint is invoked the field painting is | ||
| 62 | // set to true. If painting is true and show is invoked we | ||
| 63 | // immediately return false. This is done to avoid blocking the | ||
| 64 | // toolkit thread while painting happens. In a similar way when | ||
| 65 | // show is invoked the field showing is set to true, beginPaint | ||
| 66 | // will then block until showing is true. This scheme ensures we | ||
| 67 | // only ever have one thread using the BufferStrategy and it also | ||
| 68 | // ensures the toolkit thread remains as responsive as possible. | ||
| 69 | // | ||
| 70 | // If we're using a flip strategy the contents of the backbuffer may | ||
| 71 | // have changed and so show only attempts to show from the backbuffer | ||
| 72 | // if we get a blit strategy. | ||
| 73 | // | ||
| 74 | |||
| 75 | // | ||
| 76 | // Methods used to create BufferStrategy for Applets. | ||
| 77 | // | ||
| 78 | private static Method COMPONENT_CREATE_BUFFER_STRATEGY_METHOD; | ||
| 79 | private static Method COMPONENT_GET_BUFFER_STRATEGY_METHOD; | ||
| 80 | |||
| 81 | private static final PlatformLogger LOGGER = PlatformLogger.getLogger( | ||
| 82 | "javax.swing.BufferStrategyPaintManager"); | ||
| 83 | |||
| 84 | /** | ||
| 85 | * List of BufferInfos. We don't use a Map primarily because | ||
| 86 | * there are typically only a handful of top level components making | ||
| 87 | * a Map overkill. | ||
| 88 | */ | ||
| 89 | private ArrayList<BufferInfo> bufferInfos; | ||
| 90 | |||
| 91 | /** | ||
| 92 | * Indicates <code>beginPaint</code> has been invoked. This is | ||
| 93 | * set to true for the life of beginPaint/endPaint pair. | ||
| 94 | */ | ||
| 95 | private boolean painting; | ||
| 96 | /** | ||
| 97 | * Indicates we're in the process of showing. All painting, on the EDT, | ||
| 98 | * is blocked while this is true. | ||
| 99 | */ | ||
| 100 | private boolean showing; | ||
| 101 | |||
| 102 | // | ||
| 103 | // Region that we need to flush. When beginPaint is called these are | ||
| 104 | // reset and any subsequent calls to paint/copyArea then update these | ||
| 105 | // fields accordingly. When endPaint is called we then try and show | ||
| 106 | // the accumulated region. | ||
| 107 | // These fields are in the coordinate system of the root. | ||
| 108 | // | ||
| 109 | private int accumulatedX; | ||
| 110 | private int accumulatedY; | ||
| 111 | private int accumulatedMaxX; | ||
| 112 | private int accumulatedMaxY; | ||
| 113 | |||
| 114 | // | ||
| 115 | // The following fields are set by prepare | ||
| 116 | // | ||
| 117 | |||
| 118 | /** | ||
| 119 | * Farthest JComponent ancestor for the current paint/copyArea. | ||
| 120 | */ | ||
| 121 | private JComponent rootJ; | ||
| 122 | /** | ||
| 123 | * Parent Applet/Window for the current paint/copyArea | ||
| 124 | */ | ||
| 125 | private Container root; | ||
| 126 | /** | ||
| 127 | * Location of component being painted relative to root. | ||
| 128 | */ | ||
| 129 | private int xOffset; | ||
| 130 | /** | ||
| 131 | * Location of component being painted relative to root. | ||
| 132 | */ | ||
| 133 | private int yOffset; | ||
| 134 | /** | ||
| 135 | * Graphics from the BufferStrategy. | ||
| 136 | */ | ||
| 137 | private Graphics bsg; | ||
| 138 | /** | ||
| 139 | * BufferStrategy currently being used. | ||
| 140 | */ | ||
| 141 | private BufferStrategy bufferStrategy; | ||
| 142 | /** | ||
| 143 | * BufferInfo corresponding to root. | ||
| 144 | */ | ||
| 145 | private BufferInfo bufferInfo; | ||
| 146 | |||
| 147 | /** | ||
| 148 | * Set to true if the bufferInfo needs to be disposed when current | ||
| 149 | * paint loop is done. | ||
| 150 | */ | ||
| 151 | private boolean disposeBufferOnEnd; | ||
| 152 | |||
| 153 | private static Method getGetBufferStrategyMethod() { | ||
| 154 | if (COMPONENT_GET_BUFFER_STRATEGY_METHOD == null) { | ||
| 155 | getMethods(); | ||
| 156 | } | ||
| 157 | return COMPONENT_GET_BUFFER_STRATEGY_METHOD; | ||
| 158 | } | ||
| 159 | |||
| 160 | private static Method getCreateBufferStrategyMethod() { | ||
| 161 | if (COMPONENT_CREATE_BUFFER_STRATEGY_METHOD == null) { | ||
| 162 | getMethods(); | ||
| 163 | } | ||
| 164 | return COMPONENT_CREATE_BUFFER_STRATEGY_METHOD; | ||
| 165 | } | ||
| 166 | |||
| 167 | private static void getMethods() { | ||
| 168 | java.security.AccessController.doPrivileged( | ||
| 169 | new java.security.PrivilegedAction<Object>() { | ||
| 170 | public Object run() { | ||
| 171 | try { | ||
| 172 | COMPONENT_CREATE_BUFFER_STRATEGY_METHOD = Component.class. | ||
| 173 | getDeclaredMethod("createBufferStrategy", | ||
| 174 | new Class[] { int.class, | ||
| 175 | BufferCapabilities.class }); | ||
| 176 | COMPONENT_CREATE_BUFFER_STRATEGY_METHOD. | ||
| 177 | setAccessible(true); | ||
| 178 | COMPONENT_GET_BUFFER_STRATEGY_METHOD = Component.class. | ||
| 179 | getDeclaredMethod("getBufferStrategy"); | ||
| 180 | COMPONENT_GET_BUFFER_STRATEGY_METHOD.setAccessible(true); | ||
| 181 | } catch (SecurityException e) { | ||
| 182 | assert false; | ||
| 183 | } catch (NoSuchMethodException nsme) { | ||
| 184 | assert false; | ||
| 185 | } | ||
| 186 | return null; | ||
| 187 | } | ||
| 188 | }); | ||
| 189 | } | ||
| 190 | |||
| 191 | BufferStrategyPaintManager() { | ||
| 192 | bufferInfos = new ArrayList<BufferInfo>(1); | ||
| 193 | } | ||
| 194 | |||
| 195 | // | ||
| 196 | // PaintManager methods | ||
| 197 | // | ||
| 198 | |||
| 199 | /** | ||
| 200 | * Cleans up any created BufferStrategies. | ||
| 201 | */ | ||
| 202 | protected void dispose() { | ||
| 203 | // dipose can be invoked at any random time. To avoid | ||
| 204 | // threading dependancies we do the actual diposing via an | ||
| 205 | // invokeLater. | ||
| 206 | SwingUtilities.invokeLater(new Runnable() { | ||
| 207 | public void run() { | ||
| 208 | java.util.List<BufferInfo> bufferInfos; | ||
| 209 | synchronized(BufferStrategyPaintManager.this) { | ||
| 210 | while (showing) { | ||
| 211 | try { | ||
| 212 | BufferStrategyPaintManager.this.wait(); | ||
| 213 | } catch (InterruptedException ie) { | ||
| 214 | } | ||
| 215 | } | ||
| 216 | bufferInfos = BufferStrategyPaintManager.this.bufferInfos; | ||
| 217 | BufferStrategyPaintManager.this.bufferInfos = null; | ||
| 218 | } | ||
| 219 | dispose(bufferInfos); | ||
| 220 | } | ||
| 221 | }); | ||
| 222 | } | ||
| 223 | |||
| 224 | private void dispose(java.util.List<BufferInfo> bufferInfos) { | ||
| 225 | if (LOGGER.isLoggable(PlatformLogger.FINER)) { | ||
| 226 | LOGGER.finer("BufferStrategyPaintManager disposed", | ||
| 227 | new RuntimeException()); | ||
| 228 | } | ||
| 229 | if (bufferInfos != null) { | ||
| 230 | for (BufferInfo bufferInfo : bufferInfos) { | ||
| 231 | bufferInfo.dispose(); | ||
| 232 | } | ||
| 233 | } | ||
| 234 | } | ||
| 235 | |||
| 236 | /** | ||
| 237 | * Shows the specified region of the back buffer. This will return | ||
| 238 | * true if successful, false otherwise. This is invoked on the | ||
| 239 | * toolkit thread in response to an expose event. | ||
| 240 | */ | ||
| 241 | public boolean show(Container c, int x, int y, int w, int h) { | ||
| 242 | synchronized(this) { | ||
| 243 | if (painting) { | ||
| 244 | // Don't show from backbuffer while in the process of | ||
| 245 | // painting. | ||
| 246 | return false; | ||
| 247 | } | ||
| 248 | showing = true; | ||
| 249 | } | ||
| 250 | try { | ||
| 251 | BufferInfo info = getBufferInfo(c); | ||
| 252 | BufferStrategy bufferStrategy; | ||
| 253 | if (info != null && info.isInSync() && | ||
| 254 | (bufferStrategy = info.getBufferStrategy(false)) != null) { | ||
| 255 | SubRegionShowable bsSubRegion = | ||
| 256 | (SubRegionShowable)bufferStrategy; | ||
| 257 | boolean paintAllOnExpose = info.getPaintAllOnExpose(); | ||
| 258 | info.setPaintAllOnExpose(false); | ||
| 259 | if (bsSubRegion.showIfNotLost(x, y, (x + w), (y + h))) { | ||
| 260 | return !paintAllOnExpose; | ||
| 261 | } | ||
| 262 | // Mark the buffer as needing to be repainted. We don't | ||
| 263 | // immediately do a repaint as this method will return false | ||
| 264 | // indicating a PaintEvent should be generated which will | ||
| 265 | // trigger a complete repaint. | ||
| 266 | bufferInfo.setContentsLostDuringExpose(true); | ||
| 267 | } | ||
| 268 | } | ||
| 269 | finally { | ||
| 270 | synchronized(this) { | ||
| 271 | showing = false; | ||
| 272 | notifyAll(); | ||
| 273 | } | ||
| 274 | } | ||
| 275 | return false; | ||
| 276 | } | ||
| 277 | |||
| 278 | public boolean paint(JComponent paintingComponent, | ||
| 279 | JComponent bufferComponent, Graphics g, | ||
| 280 | int x, int y, int w, int h) { | ||
| 281 | if (prepare(paintingComponent, true, x, y, w, h)) { | ||
| 282 | if ((g instanceof SunGraphics2D) && | ||
| 283 | ((SunGraphics2D)g).getDestination() == root) { | ||
| 284 | // BufferStrategy may have already constrained the Graphics. To | ||
| 285 | // account for that we revert the constrain, then apply a | ||
| 286 | // constrain for Swing on top of that. | ||
| 287 | int cx = ((SunGraphics2D)bsg).constrainX; | ||
| 288 | int cy = ((SunGraphics2D)bsg).constrainY; | ||
| 289 | if (cx != 0 || cy != 0) { | ||
| 290 | bsg.translate(-cx, -cy); | ||
| 291 | } | ||
| 292 | ((SunGraphics2D)bsg).constrain(xOffset + cx, yOffset + cy, | ||
| 293 | x + w, y + h); | ||
| 294 | bsg.setClip(x, y, w, h); | ||
| 295 | paintingComponent.paintToOffscreen(bsg, x, y, w, h, | ||
| 296 | x + w, y + h); | ||
| 297 | accumulate(xOffset + x, yOffset + y, w, h); | ||
| 298 | return true; | ||
| 299 | } else { | ||
| 300 | // Assume they are going to eventually render to the screen. | ||
| 301 | // This disables showing from backbuffer until a complete | ||
| 302 | // repaint occurs. | ||
| 303 | bufferInfo.setInSync(false); | ||
| 304 | // Fall through to old rendering. | ||
| 305 | } | ||
| 306 | } | ||
| 307 | // Invalid root, do what Swing has always done. | ||
| 308 | if (LOGGER.isLoggable(PlatformLogger.FINER)) { | ||
| 309 | LOGGER.finer("prepare failed"); | ||
| 310 | } | ||
| 311 | return super.paint(paintingComponent, bufferComponent, g, x, y, w, h); | ||
| 312 | } | ||
| 313 | |||
| 314 | public void copyArea(JComponent c, Graphics g, int x, int y, int w, int h, | ||
| 315 | int deltaX, int deltaY, boolean clip) { | ||
| 316 | // Note: this method is only called internally and we know that | ||
| 317 | // g is from a heavyweight Component, so no check is necessary as | ||
| 318 | // it is in paint() above. | ||
| 319 | // | ||
| 320 | // If the buffer isn't in sync there is no point in doing a copyArea, | ||
| 321 | // it has garbage. | ||
| 322 | if (prepare(c, false, 0, 0, 0, 0) && bufferInfo.isInSync()) { | ||
| 323 | if (clip) { | ||
| 324 | Rectangle cBounds = c.getVisibleRect(); | ||
| 325 | int relX = xOffset + x; | ||
| 326 | int relY = yOffset + y; | ||
| 327 | bsg.clipRect(xOffset + cBounds.x, | ||
| 328 | yOffset + cBounds.y, | ||
| 329 | cBounds.width, cBounds.height); | ||
| 330 | bsg.copyArea(relX, relY, w, h, deltaX, deltaY); | ||
| 331 | } | ||
| 332 | else { | ||
| 333 | bsg.copyArea(xOffset + x, yOffset + y, w, h, deltaX, | ||
| 334 | deltaY); | ||
| 335 | } | ||
| 336 | accumulate(x + xOffset + deltaX, y + yOffset + deltaY, w, h); | ||
| 337 | } else { | ||
| 338 | if (LOGGER.isLoggable(PlatformLogger.FINER)) { | ||
| 339 | LOGGER.finer("copyArea: prepare failed or not in sync"); | ||
| 340 | } | ||
| 341 | // Prepare failed, or not in sync. By calling super.copyArea | ||
| 342 | // we'll copy on screen. We need to flush any pending paint to | ||
| 343 | // the screen otherwise we'll do a copyArea on the wrong thing. | ||
| 344 | if (!flushAccumulatedRegion()) { | ||
| 345 | // Flush failed, copyArea will be copying garbage, | ||
| 346 | // force repaint of all. | ||
| 347 | rootJ.repaint(); | ||
| 348 | } else { | ||
| 349 | super.copyArea(c, g, x, y, w, h, deltaX, deltaY, clip); | ||
| 350 | } | ||
| 351 | } | ||
| 352 | } | ||
| 353 | |||
| 354 | public void beginPaint() { | ||
| 355 | synchronized(this) { | ||
| 356 | painting = true; | ||
| 357 | // Make sure another thread isn't attempting to show from | ||
| 358 | // the back buffer. | ||
| 359 | while(showing) { | ||
| 360 | try { | ||
| 361 | wait(); | ||
| 362 | } catch (InterruptedException ie) { | ||
| 363 | } | ||
| 364 | } | ||
| 365 | } | ||
| 366 | if (LOGGER.isLoggable(PlatformLogger.FINEST)) { | ||
| 367 | LOGGER.finest("beginPaint"); | ||
| 368 | } | ||
| 369 | // Reset the area that needs to be painted. | ||
| 370 | resetAccumulated(); | ||
| 371 | } | ||
| 372 | |||
| 373 | public void endPaint() { | ||
| 374 | if (LOGGER.isLoggable(PlatformLogger.FINEST)) { | ||
| 375 | LOGGER.finest("endPaint: region " + accumulatedX + " " + | ||
| 376 | accumulatedY + " " + accumulatedMaxX + " " + | ||
| 377 | accumulatedMaxY); | ||
| 378 | } | ||
| 379 | if (painting) { | ||
| 380 | if (!flushAccumulatedRegion()) { | ||
| 381 | if (!isRepaintingRoot()) { | ||
| 382 | repaintRoot(rootJ); | ||
| 383 | } | ||
| 384 | else { | ||
| 385 | // Contents lost twice in a row, punt. | ||
| 386 | resetDoubleBufferPerWindow(); | ||
| 387 | // In case we've left junk on the screen, force a repaint. | ||
| 388 | rootJ.repaint(); | ||
| 389 | } | ||
| 390 | } | ||
| 391 | } | ||
| 392 | |||
| 393 | BufferInfo toDispose = null; | ||
| 394 | synchronized(this) { | ||
| 395 | painting = false; | ||
| 396 | if (disposeBufferOnEnd) { | ||
| 397 | disposeBufferOnEnd = false; | ||
| 398 | toDispose = bufferInfo; | ||
| 399 | bufferInfos.remove(toDispose); | ||
| 400 | } | ||
| 401 | } | ||
| 402 | if (toDispose != null) { | ||
| 403 | toDispose.dispose(); | ||
| 404 | } | ||
| 405 | } | ||
| 406 | |||
| 407 | /** | ||
| 408 | * Renders the BufferStrategy to the screen. | ||
| 409 | * | ||
| 410 | * @return true if successful, false otherwise. | ||
| 411 | */ | ||
| 412 | private boolean flushAccumulatedRegion() { | ||
| 413 | boolean success = true; | ||
| 414 | if (accumulatedX != Integer.MAX_VALUE) { | ||
| 415 | SubRegionShowable bsSubRegion = (SubRegionShowable)bufferStrategy; | ||
| 416 | boolean contentsLost = bufferStrategy.contentsLost(); | ||
| 417 | if (!contentsLost) { | ||
| 418 | bsSubRegion.show(accumulatedX, accumulatedY, | ||
| 419 | accumulatedMaxX, accumulatedMaxY); | ||
| 420 | contentsLost = bufferStrategy.contentsLost(); | ||
| 421 | } | ||
| 422 | if (contentsLost) { | ||
| 423 | if (LOGGER.isLoggable(PlatformLogger.FINER)) { | ||
| 424 | LOGGER.finer("endPaint: contents lost"); | ||
| 425 | } | ||
| 426 | // Shown region was bogus, mark buffer as out of sync. | ||
| 427 | bufferInfo.setInSync(false); | ||
| 428 | success = false; | ||
| 429 | } | ||
| 430 | } | ||
| 431 | resetAccumulated(); | ||
| 432 | return success; | ||
| 433 | } | ||
| 434 | |||
| 435 | private void resetAccumulated() { | ||
| 436 | accumulatedX = Integer.MAX_VALUE; | ||
| 437 | accumulatedY = Integer.MAX_VALUE; | ||
| 438 | accumulatedMaxX = 0; | ||
| 439 | accumulatedMaxY = 0; | ||
| 440 | } | ||
| 441 | |||
| 442 | /** | ||
| 443 | * Invoked when the double buffering or useTrueDoubleBuffering | ||
| 444 | * changes for a JRootPane. If the rootpane is not double | ||
| 445 | * buffered, or true double buffering changes we throw out any | ||
| 446 | * cache we may have. | ||
| 447 | */ | ||
| 448 | public void doubleBufferingChanged(final JRootPane rootPane) { | ||
| 449 | if ((!rootPane.isDoubleBuffered() || | ||
| 450 | !rootPane.getUseTrueDoubleBuffering()) && | ||
| 451 | rootPane.getParent() != null) { | ||
| 452 | if (!SwingUtilities.isEventDispatchThread()) { | ||
| 453 | Runnable updater = new Runnable() { | ||
| 454 | public void run() { | ||
| 455 | doubleBufferingChanged0(rootPane); | ||
| 456 | } | ||
| 457 | }; | ||
| 458 | SwingUtilities.invokeLater(updater); | ||
| 459 | } | ||
| 460 | else { | ||
| 461 | doubleBufferingChanged0(rootPane); | ||
| 462 | } | ||
| 463 | } | ||
| 464 | } | ||
| 465 | |||
| 466 | /** | ||
| 467 | * Does the work for doubleBufferingChanged. | ||
| 468 | */ | ||
| 469 | private void doubleBufferingChanged0(JRootPane rootPane) { | ||
| 470 | // This will only happen on the EDT. | ||
| 471 | BufferInfo info; | ||
| 472 | synchronized(this) { | ||
| 473 | // Make sure another thread isn't attempting to show from | ||
| 474 | // the back buffer. | ||
| 475 | while(showing) { | ||
| 476 | try { | ||
| 477 | wait(); | ||
| 478 | } catch (InterruptedException ie) { | ||
| 479 | } | ||
| 480 | } | ||
| 481 | info = getBufferInfo(rootPane.getParent()); | ||
| 482 | if (painting && bufferInfo == info) { | ||
| 483 | // We're in the process of painting and the user grabbed | ||
| 484 | // the Graphics. If we dispose now, endPaint will attempt | ||
| 485 | // to show a bogus BufferStrategy. Set a flag so that | ||
| 486 | // endPaint knows it needs to dispose this buffer. | ||
| 487 | disposeBufferOnEnd = true; | ||
| 488 | info = null; | ||
| 489 | } else if (info != null) { | ||
| 490 | bufferInfos.remove(info); | ||
| 491 | } | ||
| 492 | } | ||
| 493 | if (info != null) { | ||
| 494 | info.dispose(); | ||
| 495 | } | ||
| 496 | } | ||
| 497 | |||
| 498 | /** | ||
| 499 | * Calculates information common to paint/copyArea. | ||
| 500 | * | ||
| 501 | * @return true if should use buffering per window in painting. | ||
| 502 | */ | ||
| 503 | private boolean prepare(JComponent c, boolean isPaint, int x, int y, | ||
| 504 | int w, int h) { | ||
| 505 | if (bsg != null) { | ||
| 506 | bsg.dispose(); | ||
| 507 | bsg = null; | ||
| 508 | } | ||
| 509 | bufferStrategy = null; | ||
| 510 | if (fetchRoot(c)) { | ||
| 511 | boolean contentsLost = false; | ||
| 512 | BufferInfo bufferInfo = getBufferInfo(root); | ||
| 513 | if (bufferInfo == null) { | ||
| 514 | contentsLost = true; | ||
| 515 | bufferInfo = new BufferInfo(root); | ||
| 516 | bufferInfos.add(bufferInfo); | ||
| 517 | if (LOGGER.isLoggable(PlatformLogger.FINER)) { | ||
| 518 | LOGGER.finer("prepare: new BufferInfo: " + root); | ||
| 519 | } | ||
| 520 | } | ||
| 521 | this.bufferInfo = bufferInfo; | ||
| 522 | if (!bufferInfo.hasBufferStrategyChanged()) { | ||
| 523 | bufferStrategy = bufferInfo.getBufferStrategy(true); | ||
| 524 | if (bufferStrategy != null) { | ||
| 525 | bsg = bufferStrategy.getDrawGraphics(); | ||
| 526 | if (bufferStrategy.contentsRestored()) { | ||
| 527 | contentsLost = true; | ||
| 528 | if (LOGGER.isLoggable(PlatformLogger.FINER)) { | ||
| 529 | LOGGER.finer( | ||
| 530 | "prepare: contents restored in prepare"); | ||
| 531 | } | ||
| 532 | } | ||
| 533 | } | ||
| 534 | else { | ||
| 535 | // Couldn't create BufferStrategy, fallback to normal | ||
| 536 | // painting. | ||
| 537 | return false; | ||
| 538 | } | ||
| 539 | if (bufferInfo.getContentsLostDuringExpose()) { | ||
| 540 | contentsLost = true; | ||
| 541 | bufferInfo.setContentsLostDuringExpose(false); | ||
| 542 | if (LOGGER.isLoggable(PlatformLogger.FINER)) { | ||
| 543 | LOGGER.finer("prepare: contents lost on expose"); | ||
| 544 | } | ||
| 545 | } | ||
| 546 | if (isPaint && c == rootJ && x == 0 && y == 0 && | ||
| 547 | c.getWidth() == w && c.getHeight() == h) { | ||
| 548 | bufferInfo.setInSync(true); | ||
| 549 | } | ||
| 550 | else if (contentsLost) { | ||
| 551 | // We either recreated the BufferStrategy, or the contents | ||
| 552 | // of the buffer strategy were restored. We need to | ||
| 553 | // repaint the root pane so that the back buffer is in sync | ||
| 554 | // again. | ||
| 555 | bufferInfo.setInSync(false); | ||
| 556 | if (!isRepaintingRoot()) { | ||
| 557 | repaintRoot(rootJ); | ||
| 558 | } | ||
| 559 | else { | ||
| 560 | // Contents lost twice in a row, punt | ||
| 561 | resetDoubleBufferPerWindow(); | ||
| 562 | } | ||
| 563 | } | ||
| 564 | return (bufferInfos != null); | ||
| 565 | } | ||
| 566 | } | ||
| 567 | return false; | ||
| 568 | } | ||
| 569 | |||
| 570 | private boolean fetchRoot(JComponent c) { | ||
| 571 | boolean encounteredHW = false; | ||
| 572 | rootJ = c; | ||
| 573 | root = c; | ||
| 574 | xOffset = yOffset = 0; | ||
| 575 | while (root != null && | ||
| 576 | (!(root instanceof Window) && | ||
| 577 | !SunToolkit.isInstanceOf(root, "java.applet.Applet"))) { | ||
| 578 | xOffset += root.getX(); | ||
| 579 | yOffset += root.getY(); | ||
| 580 | root = root.getParent(); | ||
| 581 | if (root != null) { | ||
| 582 | if (root instanceof JComponent) { | ||
| 583 | rootJ = (JComponent)root; | ||
| 584 | } | ||
| 585 | else if (!root.isLightweight()) { | ||
| 586 | if (!encounteredHW) { | ||
| 587 | encounteredHW = true; | ||
| 588 | } | ||
| 589 | else { | ||
| 590 | // We've encountered two hws now and may have | ||
| 591 | // a containment hierarchy with lightweights containing | ||
| 592 | // heavyweights containing other lightweights. | ||
| 593 | // Heavyweights poke holes in lightweight | ||
| 594 | // rendering so that if we call show on the BS | ||
| 595 | // (which is associated with the Window) you will | ||
| 596 | // not see the contents over any child | ||
| 597 | // heavyweights. If we didn't do this when we | ||
| 598 | // went to show the descendants of the nested hw | ||
| 599 | // you would see nothing, so, we bail out here. | ||
| 600 | return false; | ||
| 601 | } | ||
| 602 | } | ||
| 603 | } | ||
| 604 | } | ||
| 605 | if ((root instanceof RootPaneContainer) && | ||
| 606 | (rootJ instanceof JRootPane)) { | ||
| 607 | // We're in a Swing heavyeight (JFrame/JWindow...), use double | ||
| 608 | // buffering if double buffering enabled on the JRootPane and | ||
| 609 | // the JRootPane wants true double buffering. | ||
| 610 | if (rootJ.isDoubleBuffered() && | ||
| 611 | ((JRootPane)rootJ).getUseTrueDoubleBuffering()) { | ||
| 612 | // Whether or not a component is double buffered is a | ||
| 613 | // bit tricky with Swing. This gives a good approximation | ||
| 614 | // of the various ways to turn on double buffering for | ||
| 615 | // components. | ||
| 616 | return true; | ||
| 617 | } | ||
| 618 | } | ||
| 619 | // Don't do true double buffering. | ||
| 620 | return false; | ||
| 621 | } | ||
| 622 | |||
| 623 | /** | ||
| 624 | * Turns off double buffering per window. | ||
| 625 | */ | ||
| 626 | private void resetDoubleBufferPerWindow() { | ||
| 627 | if (bufferInfos != null) { | ||
| 628 | dispose(bufferInfos); | ||
| 629 | bufferInfos = null; | ||
| 630 | repaintManager.setPaintManager(null); | ||
| 631 | } | ||
| 632 | } | ||
| 633 | |||
| 634 | /** | ||
| 635 | * Returns the BufferInfo for the specified root or null if one | ||
| 636 | * hasn't been created yet. | ||
| 637 | */ | ||
| 638 | private BufferInfo getBufferInfo(Container root) { | ||
| 639 | for (int counter = bufferInfos.size() - 1; counter >= 0; counter--) { | ||
| 640 | BufferInfo bufferInfo = bufferInfos.get(counter); | ||
| 641 | Container biRoot = bufferInfo.getRoot(); | ||
| 642 | if (biRoot == null) { | ||
| 643 | // Window gc'ed | ||
| 644 | bufferInfos.remove(counter); | ||
| 645 | if (LOGGER.isLoggable(PlatformLogger.FINER)) { | ||
| 646 | LOGGER.finer("BufferInfo pruned, root null"); | ||
| 647 | } | ||
| 648 | } | ||
| 649 | else if (biRoot == root) { | ||
| 650 | return bufferInfo; | ||
| 651 | } | ||
| 652 | } | ||
| 653 | return null; | ||
| 654 | } | ||
| 655 | |||
| 656 | private void accumulate(int x, int y, int w, int h) { | ||
| 657 | accumulatedX = Math.min(x, accumulatedX); | ||
| 658 | accumulatedY = Math.min(y, accumulatedY); | ||
| 659 | accumulatedMaxX = Math.max(accumulatedMaxX, x + w); | ||
| 660 | accumulatedMaxY = Math.max(accumulatedMaxY, y + h); | ||
| 661 | } | ||
| 662 | |||
| 663 | |||
| 664 | |||
| 665 | /** | ||
| 666 | * BufferInfo is used to track the BufferStrategy being used for | ||
| 667 | * a particular Component. In addition to tracking the BufferStrategy | ||
| 668 | * it will install a WindowListener and ComponentListener. When the | ||
| 669 | * component is hidden/iconified the buffer is marked as needing to be | ||
| 670 | * completely repainted. | ||
| 671 | */ | ||
| 672 | private class BufferInfo extends ComponentAdapter implements | ||
| 673 | WindowListener { | ||
| 674 | // NOTE: This class does NOT hold a direct reference to the root, if it | ||
| 675 | // did there would be a cycle between the BufferPerWindowPaintManager | ||
| 676 | // and the Window so that it could never be GC'ed | ||
| 677 | // | ||
| 678 | // Reference to BufferStrategy is referenced via WeakReference for | ||
| 679 | // same reason. | ||
| 680 | private WeakReference<BufferStrategy> weakBS; | ||
| 681 | private WeakReference<Container> root; | ||
| 682 | // Indicates whether or not the backbuffer and display are in sync. | ||
| 683 | // This is set to true when a full repaint on the rootpane is done. | ||
| 684 | private boolean inSync; | ||
| 685 | // Indicates the contents were lost during and expose event. | ||
| 686 | private boolean contentsLostDuringExpose; | ||
| 687 | // Indicates we need to generate a paint event on expose. | ||
| 688 | private boolean paintAllOnExpose; | ||
| 689 | |||
| 690 | |||
| 691 | public BufferInfo(Container root) { | ||
| 692 | this.root = new WeakReference<Container>(root); | ||
| 693 | root.addComponentListener(this); | ||
| 694 | if (root instanceof Window) { | ||
| 695 | ((Window)root).addWindowListener(this); | ||
| 696 | } | ||
| 697 | } | ||
| 698 | |||
| 699 | public void setPaintAllOnExpose(boolean paintAllOnExpose) { | ||
| 700 | this.paintAllOnExpose = paintAllOnExpose; | ||
| 701 | } | ||
| 702 | |||
| 703 | public boolean getPaintAllOnExpose() { | ||
| 704 | return paintAllOnExpose; | ||
| 705 | } | ||
| 706 | |||
| 707 | public void setContentsLostDuringExpose(boolean value) { | ||
| 708 | contentsLostDuringExpose = value; | ||
| 709 | } | ||
| 710 | |||
| 711 | public boolean getContentsLostDuringExpose() { | ||
| 712 | return contentsLostDuringExpose; | ||
| 713 | } | ||
| 714 | |||
| 715 | public void setInSync(boolean inSync) { | ||
| 716 | this.inSync = inSync; | ||
| 717 | } | ||
| 718 | |||
| 719 | /** | ||
| 720 | * Whether or not the contents of the buffer strategy | ||
| 721 | * is in sync with the window. This is set to true when the root | ||
| 722 | * pane paints all, and false when contents are lost/restored. | ||
| 723 | */ | ||
| 724 | public boolean isInSync() { | ||
| 725 | return inSync; | ||
| 726 | } | ||
| 727 | |||
| 728 | /** | ||
| 729 | * Returns the Root (Window or Applet) that this BufferInfo references. | ||
| 730 | */ | ||
| 731 | public Container getRoot() { | ||
| 732 | return (root == null) ? null : root.get(); | ||
| 733 | } | ||
| 734 | |||
| 735 | /** | ||
| 736 | * Returns the BufferStartegy. This will return null if | ||
| 737 | * the BufferStartegy hasn't been created and <code>create</code> is | ||
| 738 | * false, or if there is a problem in creating the | ||
| 739 | * <code>BufferStartegy</code>. | ||
| 740 | * | ||
| 741 | * @param create If true, and the BufferStartegy is currently null, | ||
| 742 | * one will be created. | ||
| 743 | */ | ||
| 744 | public BufferStrategy getBufferStrategy(boolean create) { | ||
| 745 | BufferStrategy bs = (weakBS == null) ? null : weakBS.get(); | ||
| 746 | if (bs == null && create) { | ||
| 747 | bs = createBufferStrategy(); | ||
| 748 | if (bs != null) { | ||
| 749 | weakBS = new WeakReference<BufferStrategy>(bs); | ||
| 750 | } | ||
| 751 | if (LOGGER.isLoggable(PlatformLogger.FINER)) { | ||
| 752 | LOGGER.finer("getBufferStrategy: created bs: " + bs); | ||
| 753 | } | ||
| 754 | } | ||
| 755 | return bs; | ||
| 756 | } | ||
| 757 | |||
| 758 | /** | ||
| 759 | * Returns true if the buffer strategy of the component differs | ||
| 760 | * from current buffer strategy. | ||
| 761 | */ | ||
| 762 | public boolean hasBufferStrategyChanged() { | ||
| 763 | Container root = getRoot(); | ||
| 764 | if (root != null) { | ||
| 765 | BufferStrategy ourBS = null; | ||
| 766 | BufferStrategy componentBS = null; | ||
| 767 | |||
| 768 | ourBS = getBufferStrategy(false); | ||
| 769 | if (root instanceof Window) { | ||
| 770 | componentBS = ((Window)root).getBufferStrategy(); | ||
| 771 | } | ||
| 772 | else { | ||
| 773 | try { | ||
| 774 | componentBS = (BufferStrategy) | ||
| 775 | getGetBufferStrategyMethod().invoke(root); | ||
| 776 | } catch (InvocationTargetException ite) { | ||
| 777 | assert false; | ||
| 778 | } catch (IllegalArgumentException iae) { | ||
| 779 | assert false; | ||
| 780 | } catch (IllegalAccessException iae2) { | ||
| 781 | assert false; | ||
| 782 | } | ||
| 783 | } | ||
| 784 | if (componentBS != ourBS) { | ||
| 785 | // Component has a different BS, dispose ours. | ||
| 786 | if (ourBS != null) { | ||
| 787 | ourBS.dispose(); | ||
| 788 | } | ||
| 789 | weakBS = null; | ||
| 790 | return true; | ||
| 791 | } | ||
| 792 | } | ||
| 793 | return false; | ||
| 794 | } | ||
| 795 | |||
| 796 | /** | ||
| 797 | * Creates the BufferStrategy. If the appropriate system property | ||
| 798 | * has been set we'll try for flip first and then we'll try for | ||
| 799 | * blit. | ||
| 800 | */ | ||
| 801 | private BufferStrategy createBufferStrategy() { | ||
| 802 | Container root = getRoot(); | ||
| 803 | if (root == null) { | ||
| 804 | return null; | ||
| 805 | } | ||
| 806 | BufferStrategy bs = null; | ||
| 807 | if (SwingUtilities3.isVsyncRequested(root)) { | ||
| 808 | bs = createBufferStrategy(root, true); | ||
| 809 | if (LOGGER.isLoggable(PlatformLogger.FINER)) { | ||
| 810 | LOGGER.finer("createBufferStrategy: using vsynced strategy"); | ||
| 811 | } | ||
| 812 | } | ||
| 813 | if (bs == null) { | ||
| 814 | bs = createBufferStrategy(root, false); | ||
| 815 | } | ||
| 816 | if (!(bs instanceof SubRegionShowable)) { | ||
| 817 | // We do this for two reasons: | ||
| 818 | // 1. So that we know we can cast to SubRegionShowable and | ||
| 819 | // invoke show with the minimal region to update | ||
| 820 | // 2. To avoid the possibility of invoking client code | ||
| 821 | // on the toolkit thread. | ||
| 822 | bs = null; | ||
| 823 | } | ||
| 824 | return bs; | ||
| 825 | } | ||
| 826 | |||
| 827 | // Creates and returns a buffer strategy. If | ||
| 828 | // there is a problem creating the buffer strategy this will | ||
| 829 | // eat the exception and return null. | ||
| 830 | private BufferStrategy createBufferStrategy(Container root, | ||
| 831 | boolean isVsynced) { | ||
| 832 | BufferCapabilities caps; | ||
| 833 | if (isVsynced) { | ||
| 834 | caps = new ExtendedBufferCapabilities( | ||
| 835 | new ImageCapabilities(true), new ImageCapabilities(true), | ||
| 836 | BufferCapabilities.FlipContents.COPIED, | ||
| 837 | ExtendedBufferCapabilities.VSyncType.VSYNC_ON); | ||
| 838 | } else { | ||
| 839 | caps = new BufferCapabilities( | ||
| 840 | new ImageCapabilities(true), new ImageCapabilities(true), | ||
| 841 | null); | ||
| 842 | } | ||
| 843 | BufferStrategy bs = null; | ||
| 844 | if (SunToolkit.isInstanceOf(root, "java.applet.Applet")) { | ||
| 845 | try { | ||
| 846 | getCreateBufferStrategyMethod().invoke(root, 2, caps); | ||
| 847 | bs = (BufferStrategy)getGetBufferStrategyMethod(). | ||
| 848 | invoke(root); | ||
| 849 | } catch (InvocationTargetException ite) { | ||
| 850 | // Type is not supported | ||
| 851 | if (LOGGER.isLoggable(PlatformLogger.FINER)) { | ||
| 852 | LOGGER.finer("createBufferStratety failed", | ||
| 853 | ite); | ||
| 854 | } | ||
| 855 | } catch (IllegalArgumentException iae) { | ||
| 856 | assert false; | ||
| 857 | } catch (IllegalAccessException iae2) { | ||
| 858 | assert false; | ||
| 859 | } | ||
| 860 | } | ||
| 861 | else { | ||
| 862 | try { | ||
| 863 | ((Window)root).createBufferStrategy(2, caps); | ||
| 864 | bs = ((Window)root).getBufferStrategy(); | ||
| 865 | } catch (AWTException e) { | ||
| 866 | // Type not supported | ||
| 867 | if (LOGGER.isLoggable(PlatformLogger.FINER)) { | ||
| 868 | LOGGER.finer("createBufferStratety failed", | ||
| 869 | e); | ||
| 870 | } | ||
| 871 | } | ||
| 872 | } | ||
| 873 | return bs; | ||
| 874 | } | ||
| 875 | |||
| 876 | /** | ||
| 877 | * Cleans up and removes any references. | ||
| 878 | */ | ||
| 879 | public void dispose() { | ||
| 880 | Container root = getRoot(); | ||
| 881 | if (LOGGER.isLoggable(PlatformLogger.FINER)) { | ||
| 882 | LOGGER.finer("disposed BufferInfo for: " + root); | ||
| 883 | } | ||
| 884 | if (root != null) { | ||
| 885 | root.removeComponentListener(this); | ||
| 886 | if (root instanceof Window) { | ||
| 887 | ((Window)root).removeWindowListener(this); | ||
| 888 | } | ||
| 889 | BufferStrategy bs = getBufferStrategy(false); | ||
| 890 | if (bs != null) { | ||
| 891 | bs.dispose(); | ||
| 892 | } | ||
| 893 | } | ||
| 894 | this.root = null; | ||
| 895 | weakBS = null; | ||
| 896 | } | ||
| 897 | |||
| 898 | // We mark the buffer as needing to be painted on a hide/iconify | ||
| 899 | // because the developer may have conditionalized painting based on | ||
| 900 | // visibility. | ||
| 901 | // Ideally we would also move to having the BufferStrategy being | ||
| 902 | // a SoftReference in Component here, but that requires changes to | ||
| 903 | // Component and the like. | ||
| 904 | public void componentHidden(ComponentEvent e) { | ||
| 905 | Container root = getRoot(); | ||
| 906 | if (root != null && root.isVisible()) { | ||
| 907 | // This case will only happen if a developer calls | ||
| 908 | // hide immediately followed by show. In this case | ||
| 909 | // the event is delivered after show and the window | ||
| 910 | // will still be visible. If a developer altered the | ||
| 911 | // contents of the window between the hide/show | ||
| 912 | // invocations we won't recognize we need to paint and | ||
| 913 | // the contents would be bogus. Calling repaint here | ||
| 914 | // fixs everything up. | ||
| 915 | root.repaint(); | ||
| 916 | } | ||
| 917 | else { | ||
| 918 | setPaintAllOnExpose(true); | ||
| 919 | } | ||
| 920 | } | ||
| 921 | |||
| 922 | public void windowIconified(WindowEvent e) { | ||
| 923 | setPaintAllOnExpose(true); | ||
| 924 | } | ||
| 925 | |||
| 926 | // On a dispose we chuck everything. | ||
| 927 | public void windowClosed(WindowEvent e) { | ||
| 928 | // Make sure we're not showing. | ||
| 929 | synchronized(BufferStrategyPaintManager.this) { | ||
| 930 | while (showing) { | ||
| 931 | try { | ||
| 932 | BufferStrategyPaintManager.this.wait(); | ||
| 933 | } catch (InterruptedException ie) { | ||
| 934 | } | ||
| 935 | } | ||
| 936 | bufferInfos.remove(this); | ||
| 937 | } | ||
| 938 | dispose(); | ||
| 939 | } | ||
| 940 | |||
| 941 | public void windowOpened(WindowEvent e) { | ||
| 942 | } | ||
| 943 | |||
| 944 | public void windowClosing(WindowEvent e) { | ||
| 945 | } | ||
| 946 | |||
| 947 | public void windowDeiconified(WindowEvent e) { | ||
| 948 | } | ||
| 949 | |||
| 950 | public void windowActivated(WindowEvent e) { | ||
| 951 | } | ||
| 952 | |||
| 953 | public void windowDeactivated(WindowEvent e) { | ||
| 954 | } | ||
| 955 | } | ||
| 956 | } | ||