Java 类sun.awt.SubRegionShowable 实例源码

/**
 * Renders the BufferStrategy to the screen.
 *
 * @return true if successful, false otherwise.
 */
private boolean flushAccumulatedRegion() {
    boolean success = true;
    if (accumulatedX != Integer.MAX_VALUE) {
        SubRegionShowable bsSubRegion = (SubRegionShowable)bufferStrategy;
        boolean contentsLost = bufferStrategy.contentsLost();
        if (!contentsLost) {
            bsSubRegion.show(accumulatedX, accumulatedY,
                             accumulatedMaxX, accumulatedMaxY);
            contentsLost = bufferStrategy.contentsLost();
        }
        if (contentsLost) {
            if (LOGGER.isLoggable(PlatformLogger.Level.FINER)) {
                LOGGER.finer("endPaint: contents lost");
            }
            // Shown region was bogus, mark buffer as out of sync.
            bufferInfo.setInSync(false);
            success = false;
        }
    }
    resetAccumulated();
    return success;
}

/**
 * Creates the BufferStrategy.  If the appropriate system property
 * has been set we'll try for flip first and then we'll try for
 * blit.
 */
private BufferStrategy createBufferStrategy() {
    Container root = getRoot();
    if (root == null) {
        return null;
    }
    BufferStrategy bs = null;
    if (SwingUtilities3.isVsyncRequested(root)) {
        bs = createBufferStrategy(root, true);
        if (LOGGER.isLoggable(PlatformLogger.Level.FINER)) {
            LOGGER.finer("createBufferStrategy: using vsynced strategy");
        }
    }
    if (bs == null) {
        bs = createBufferStrategy(root, false);
    }
    if (!(bs instanceof SubRegionShowable)) {
        // We do this for two reasons:
        // 1. So that we know we can cast to SubRegionShowable and
        //    invoke show with the minimal region to update
        // 2. To avoid the possibility of invoking client code
        //    on the toolkit thread.
        bs = null;
    }
    return bs;
}

/**
 * Renders the BufferStrategy to the screen.
 *
 * @return true if successful, false otherwise.
 */
private boolean flushAccumulatedRegion() {
    boolean success = true;
    if (accumulatedX != Integer.MAX_VALUE) {
        SubRegionShowable bsSubRegion = (SubRegionShowable)bufferStrategy;
        boolean contentsLost = bufferStrategy.contentsLost();
        if (!contentsLost) {
            bsSubRegion.show(accumulatedX, accumulatedY,
                             accumulatedMaxX, accumulatedMaxY);
            contentsLost = bufferStrategy.contentsLost();
        }
        if (contentsLost) {
            if (LOGGER.isLoggable(PlatformLogger.Level.FINER)) {
                LOGGER.finer("endPaint: contents lost");
            }
            // Shown region was bogus, mark buffer as out of sync.
            bufferInfo.setInSync(false);
            success = false;
        }
    }
    resetAccumulated();
    return success;
}

/**
 * Creates the BufferStrategy.  If the appropriate system property
 * has been set we'll try for flip first and then we'll try for
 * blit.
 */
private BufferStrategy createBufferStrategy() {
    Container root = getRoot();
    if (root == null) {
        return null;
    }
    BufferStrategy bs = null;
    if (SwingUtilities3.isVsyncRequested(root)) {
        bs = createBufferStrategy(root, true);
        if (LOGGER.isLoggable(PlatformLogger.Level.FINER)) {
            LOGGER.finer("createBufferStrategy: using vsynced strategy");
        }
    }
    if (bs == null) {
        bs = createBufferStrategy(root, false);
    }
    if (!(bs instanceof SubRegionShowable)) {
        // We do this for two reasons:
        // 1. So that we know we can cast to SubRegionShowable and
        //    invoke show with the minimal region to update
        // 2. To avoid the possibility of invoking client code
        //    on the toolkit thread.
        bs = null;
    }
    return bs;
}

/**
 * Renders the BufferStrategy to the screen.
 *
 * @return true if successful, false otherwise.
 */
private boolean flushAccumulatedRegion() {
    boolean success = true;
    if (accumulatedX != Integer.MAX_VALUE) {
        SubRegionShowable bsSubRegion = (SubRegionShowable)bufferStrategy;
        boolean contentsLost = bufferStrategy.contentsLost();
        if (!contentsLost) {
            bsSubRegion.show(accumulatedX, accumulatedY,
                             accumulatedMaxX, accumulatedMaxY);
            contentsLost = bufferStrategy.contentsLost();
        }
        if (contentsLost) {
            if (LOGGER.isLoggable(PlatformLogger.Level.FINER)) {
                LOGGER.finer("endPaint: contents lost");
            }
            // Shown region was bogus, mark buffer as out of sync.
            bufferInfo.setInSync(false);
            success = false;
        }
    }
    resetAccumulated();
    return success;
}

/**
 * Creates the BufferStrategy.  If the appropriate system property
 * has been set we'll try for flip first and then we'll try for
 * blit.
 */
private BufferStrategy createBufferStrategy() {
    Container root = getRoot();
    if (root == null) {
        return null;
    }
    BufferStrategy bs = null;
    if (SwingUtilities3.isVsyncRequested(root)) {
        bs = createBufferStrategy(root, true);
        if (LOGGER.isLoggable(PlatformLogger.Level.FINER)) {
            LOGGER.finer("createBufferStrategy: using vsynced strategy");
        }
    }
    if (bs == null) {
        bs = createBufferStrategy(root, false);
    }
    if (!(bs instanceof SubRegionShowable)) {
        // We do this for two reasons:
        // 1. So that we know we can cast to SubRegionShowable and
        //    invoke show with the minimal region to update
        // 2. To avoid the possibility of invoking client code
        //    on the toolkit thread.
        bs = null;
    }
    return bs;
}

/**
 * Renders the BufferStrategy to the screen.
 *
 * @return true if successful, false otherwise.
 */
private boolean flushAccumulatedRegion() {
    boolean success = true;
    if (accumulatedX != Integer.MAX_VALUE) {
        SubRegionShowable bsSubRegion = (SubRegionShowable)bufferStrategy;
        boolean contentsLost = bufferStrategy.contentsLost();
        if (!contentsLost) {
            bsSubRegion.show(accumulatedX, accumulatedY,
                             accumulatedMaxX, accumulatedMaxY);
            contentsLost = bufferStrategy.contentsLost();
        }
        if (contentsLost) {
            if (LOGGER.isLoggable(PlatformLogger.Level.FINER)) {
                LOGGER.finer("endPaint: contents lost");
            }
            // Shown region was bogus, mark buffer as out of sync.
            bufferInfo.setInSync(false);
            success = false;
        }
    }
    resetAccumulated();
    return success;
}

/**
 * Creates the BufferStrategy.  If the appropriate system property
 * has been set we'll try for flip first and then we'll try for
 * blit.
 */
private BufferStrategy createBufferStrategy() {
    Container root = getRoot();
    if (root == null) {
        return null;
    }
    BufferStrategy bs = null;
    if (SwingUtilities3.isVsyncRequested(root)) {
        bs = createBufferStrategy(root, true);
        if (LOGGER.isLoggable(PlatformLogger.Level.FINER)) {
            LOGGER.finer("createBufferStrategy: using vsynced strategy");
        }
    }
    if (bs == null) {
        bs = createBufferStrategy(root, false);
    }
    if (!(bs instanceof SubRegionShowable)) {
        // We do this for two reasons:
        // 1. So that we know we can cast to SubRegionShowable and
        //    invoke show with the minimal region to update
        // 2. To avoid the possibility of invoking client code
        //    on the toolkit thread.
        bs = null;
    }
    return bs;
}

/**
 * Renders the BufferStrategy to the screen.
 *
 * @return true if successful, false otherwise.
 */
private boolean flushAccumulatedRegion() {
    boolean success = true;
    if (accumulatedX != Integer.MAX_VALUE) {
        SubRegionShowable bsSubRegion = (SubRegionShowable)bufferStrategy;
        boolean contentsLost = bufferStrategy.contentsLost();
        if (!contentsLost) {
            bsSubRegion.show(accumulatedX, accumulatedY,
                             accumulatedMaxX, accumulatedMaxY);
            contentsLost = bufferStrategy.contentsLost();
        }
        if (contentsLost) {
            if (LOGGER.isLoggable(PlatformLogger.Level.FINER)) {
                LOGGER.finer("endPaint: contents lost");
            }
            // Shown region was bogus, mark buffer as out of sync.
            bufferInfo.setInSync(false);
            success = false;
        }
    }
    resetAccumulated();
    return success;
}

/**
 * Creates the BufferStrategy.  If the appropriate system property
 * has been set we'll try for flip first and then we'll try for
 * blit.
 */
private BufferStrategy createBufferStrategy() {
    Container root = getRoot();
    if (root == null) {
        return null;
    }
    BufferStrategy bs = null;
    if (SwingUtilities3.isVsyncRequested(root)) {
        bs = createBufferStrategy(root, true);
        if (LOGGER.isLoggable(PlatformLogger.Level.FINER)) {
            LOGGER.finer("createBufferStrategy: using vsynced strategy");
        }
    }
    if (bs == null) {
        bs = createBufferStrategy(root, false);
    }
    if (!(bs instanceof SubRegionShowable)) {
        // We do this for two reasons:
        // 1. So that we know we can cast to SubRegionShowable and
        //    invoke show with the minimal region to update
        // 2. To avoid the possibility of invoking client code
        //    on the toolkit thread.
        bs = null;
    }
    return bs;
}

/**
 * Renders the BufferStrategy to the screen.
 *
 * @return true if successful, false otherwise.
 */
private boolean flushAccumulatedRegion() {
    boolean success = true;
    if (accumulatedX != Integer.MAX_VALUE) {
        SubRegionShowable bsSubRegion = (SubRegionShowable)bufferStrategy;
        boolean contentsLost = bufferStrategy.contentsLost();
        if (!contentsLost) {
            bsSubRegion.show(accumulatedX, accumulatedY,
                             accumulatedMaxX, accumulatedMaxY);
            contentsLost = bufferStrategy.contentsLost();
        }
        if (contentsLost) {
            if (LOGGER.isLoggable(PlatformLogger.Level.FINER)) {
                LOGGER.finer("endPaint: contents lost");
            }
            // Shown region was bogus, mark buffer as out of sync.
            bufferInfo.setInSync(false);
            success = false;
        }
    }
    resetAccumulated();
    return success;
}

/**
 * Creates the BufferStrategy.  If the appropriate system property
 * has been set we'll try for flip first and then we'll try for
 * blit.
 */
private BufferStrategy createBufferStrategy() {
    Container root = getRoot();
    if (root == null) {
        return null;
    }
    BufferStrategy bs = null;
    if (SwingUtilities3.isVsyncRequested(root)) {
        bs = createBufferStrategy(root, true);
        if (LOGGER.isLoggable(PlatformLogger.Level.FINER)) {
            LOGGER.finer("createBufferStrategy: using vsynced strategy");
        }
    }
    if (bs == null) {
        bs = createBufferStrategy(root, false);
    }
    if (!(bs instanceof SubRegionShowable)) {
        // We do this for two reasons:
        // 1. So that we know we can cast to SubRegionShowable and
        //    invoke show with the minimal region to update
        // 2. To avoid the possibility of invoking client code
        //    on the toolkit thread.
        bs = null;
    }
    return bs;
}

/**
 * Renders the BufferStrategy to the screen.
 *
 * @return true if successful, false otherwise.
 */
private boolean flushAccumulatedRegion() {
    boolean success = true;
    if (accumulatedX != Integer.MAX_VALUE) {
        SubRegionShowable bsSubRegion = (SubRegionShowable)bufferStrategy;
        boolean contentsLost = bufferStrategy.contentsLost();
        if (!contentsLost) {
            bsSubRegion.show(accumulatedX, accumulatedY,
                             accumulatedMaxX, accumulatedMaxY);
            contentsLost = bufferStrategy.contentsLost();
        }
        if (contentsLost) {
            if (LOGGER.isLoggable(PlatformLogger.Level.FINER)) {
                LOGGER.finer("endPaint: contents lost");
            }
            // Shown region was bogus, mark buffer as out of sync.
            bufferInfo.setInSync(false);
            success = false;
        }
    }
    resetAccumulated();
    return success;
}

/**
 * Creates the BufferStrategy.  If the appropriate system property
 * has been set we'll try for flip first and then we'll try for
 * blit.
 */
private BufferStrategy createBufferStrategy() {
    Container root = getRoot();
    if (root == null) {
        return null;
    }
    BufferStrategy bs = null;
    if (SwingUtilities3.isVsyncRequested(root)) {
        bs = createBufferStrategy(root, true);
        if (LOGGER.isLoggable(PlatformLogger.Level.FINER)) {
            LOGGER.finer("createBufferStrategy: using vsynced strategy");
        }
    }
    if (bs == null) {
        bs = createBufferStrategy(root, false);
    }
    if (!(bs instanceof SubRegionShowable)) {
        // We do this for two reasons:
        // 1. So that we know we can cast to SubRegionShowable and
        //    invoke show with the minimal region to update
        // 2. To avoid the possibility of invoking client code
        //    on the toolkit thread.
        bs = null;
    }
    return bs;
}

/**
 * Renders the BufferStrategy to the screen.
 *
 * @return true if successful, false otherwise.
 */
private boolean flushAccumulatedRegion() {
    boolean success = true;
    if (accumulatedX != Integer.MAX_VALUE) {
        SubRegionShowable bsSubRegion = (SubRegionShowable)bufferStrategy;
        boolean contentsLost = bufferStrategy.contentsLost();
        if (!contentsLost) {
            bsSubRegion.show(accumulatedX, accumulatedY,
                             accumulatedMaxX, accumulatedMaxY);
            contentsLost = bufferStrategy.contentsLost();
        }
        if (contentsLost) {
            if (LOGGER.isLoggable(PlatformLogger.Level.FINER)) {
                LOGGER.finer("endPaint: contents lost");
            }
            // Shown region was bogus, mark buffer as out of sync.
            bufferInfo.setInSync(false);
            success = false;
        }
    }
    resetAccumulated();
    return success;
}

/**
 * Creates the BufferStrategy.  If the appropriate system property
 * has been set we'll try for flip first and then we'll try for
 * blit.
 */
private BufferStrategy createBufferStrategy() {
    Container root = getRoot();
    if (root == null) {
        return null;
    }
    BufferStrategy bs = null;
    if (SwingUtilities3.isVsyncRequested(root)) {
        bs = createBufferStrategy(root, true);
        if (LOGGER.isLoggable(PlatformLogger.Level.FINER)) {
            LOGGER.finer("createBufferStrategy: using vsynced strategy");
        }
    }
    if (bs == null) {
        bs = createBufferStrategy(root, false);
    }
    if (!(bs instanceof SubRegionShowable)) {
        // We do this for two reasons:
        // 1. So that we know we can cast to SubRegionShowable and
        //    invoke show with the minimal region to update
        // 2. To avoid the possibility of invoking client code
        //    on the toolkit thread.
        bs = null;
    }
    return bs;
}

/**
 * Renders the BufferStrategy to the screen.
 *
 * @return true if successful, false otherwise.
 */
private boolean flushAccumulatedRegion() {
    boolean success = true;
    if (accumulatedX != Integer.MAX_VALUE) {
        SubRegionShowable bsSubRegion = (SubRegionShowable)bufferStrategy;
        boolean contentsLost = bufferStrategy.contentsLost();
        if (!contentsLost) {
            bsSubRegion.show(accumulatedX, accumulatedY,
                             accumulatedMaxX, accumulatedMaxY);
            contentsLost = bufferStrategy.contentsLost();
        }
        if (contentsLost) {
            if (LOGGER.isLoggable(PlatformLogger.Level.FINER)) {
                LOGGER.finer("endPaint: contents lost");
            }
            // Shown region was bogus, mark buffer as out of sync.
            bufferInfo.setInSync(false);
            success = false;
        }
    }
    resetAccumulated();
    return success;
}

/**
 * Creates the BufferStrategy.  If the appropriate system property
 * has been set we'll try for flip first and then we'll try for
 * blit.
 */
private BufferStrategy createBufferStrategy() {
    Container root = getRoot();
    if (root == null) {
        return null;
    }
    BufferStrategy bs = null;
    if (SwingUtilities3.isVsyncRequested(root)) {
        bs = createBufferStrategy(root, true);
        if (LOGGER.isLoggable(PlatformLogger.Level.FINER)) {
            LOGGER.finer("createBufferStrategy: using vsynced strategy");
        }
    }
    if (bs == null) {
        bs = createBufferStrategy(root, false);
    }
    if (!(bs instanceof SubRegionShowable)) {
        // We do this for two reasons:
        // 1. So that we know we can cast to SubRegionShowable and
        //    invoke show with the minimal region to update
        // 2. To avoid the possibility of invoking client code
        //    on the toolkit thread.
        bs = null;
    }
    return bs;
}

/**
 * Renders the BufferStrategy to the screen.
 *
 * @return true if successful, false otherwise.
 */
private boolean flushAccumulatedRegion() {
    boolean success = true;
    if (accumulatedX != Integer.MAX_VALUE) {
        SubRegionShowable bsSubRegion = (SubRegionShowable)bufferStrategy;
        boolean contentsLost = bufferStrategy.contentsLost();
        if (!contentsLost) {
            bsSubRegion.show(accumulatedX, accumulatedY,
                             accumulatedMaxX, accumulatedMaxY);
            contentsLost = bufferStrategy.contentsLost();
        }
        if (contentsLost) {
            if (LOGGER.isLoggable(PlatformLogger.FINER)) {
                LOGGER.finer("endPaint: contents lost");
            }
            // Shown region was bogus, mark buffer as out of sync.
            bufferInfo.setInSync(false);
            success = false;
        }
    }
    resetAccumulated();
    return success;
}

/**
 * Creates the BufferStrategy.  If the appropriate system property
 * has been set we'll try for flip first and then we'll try for
 * blit.
 */
private BufferStrategy createBufferStrategy() {
    Container root = getRoot();
    if (root == null) {
        return null;
    }
    BufferStrategy bs = null;
    if (SwingUtilities3.isVsyncRequested(root)) {
        bs = createBufferStrategy(root, true);
        if (LOGGER.isLoggable(PlatformLogger.FINER)) {
            LOGGER.finer("createBufferStrategy: using vsynced strategy");
        }
    }
    if (bs == null) {
        bs = createBufferStrategy(root, false);
    }
    if (!(bs instanceof SubRegionShowable)) {
        // We do this for two reasons:
        // 1. So that we know we can cast to SubRegionShowable and
        //    invoke show with the minimal region to update
        // 2. To avoid the possibility of invoking client code
        //    on the toolkit thread.
        bs = null;
    }
    return bs;
}

/**
 * Renders the BufferStrategy to the screen.
 *
 * @return true if successful, false otherwise.
 */
private boolean flushAccumulatedRegion() {
    boolean success = true;
    if (accumulatedX != Integer.MAX_VALUE) {
        SubRegionShowable bsSubRegion = (SubRegionShowable)bufferStrategy;
        boolean contentsLost = bufferStrategy.contentsLost();
        if (!contentsLost) {
            bsSubRegion.show(accumulatedX, accumulatedY,
                             accumulatedMaxX, accumulatedMaxY);
            contentsLost = bufferStrategy.contentsLost();
        }
        if (contentsLost) {
            if (LOGGER.isLoggable(PlatformLogger.FINER)) {
                LOGGER.finer("endPaint: contents lost");
            }
            // Shown region was bogus, mark buffer as out of sync.
            bufferInfo.setInSync(false);
            success = false;
        }
    }
    resetAccumulated();
    return success;
}

/**
 * Creates the BufferStrategy.  If the appropriate system property
 * has been set we'll try for flip first and then we'll try for
 * blit.
 */
private BufferStrategy createBufferStrategy() {
    Container root = getRoot();
    if (root == null) {
        return null;
    }
    BufferStrategy bs = null;
    if (SwingUtilities3.isVsyncRequested(root)) {
        bs = createBufferStrategy(root, true);
        if (LOGGER.isLoggable(PlatformLogger.FINER)) {
            LOGGER.finer("createBufferStrategy: using vsynced strategy");
        }
    }
    if (bs == null) {
        bs = createBufferStrategy(root, false);
    }
    if (!(bs instanceof SubRegionShowable)) {
        // We do this for two reasons:
        // 1. So that we know we can cast to SubRegionShowable and
        //    invoke show with the minimal region to update
        // 2. To avoid the possibility of invoking client code
        //    on the toolkit thread.
        bs = null;
    }
    return bs;
}

/**
 * Renders the BufferStrategy to the screen.
 *
 * @return true if successful, false otherwise.
 */
private boolean flushAccumulatedRegion() {
    boolean success = true;
    if (accumulatedX != Integer.MAX_VALUE) {
        SubRegionShowable bsSubRegion = (SubRegionShowable)bufferStrategy;
        boolean contentsLost = bufferStrategy.contentsLost();
        if (!contentsLost) {
            bsSubRegion.show(accumulatedX, accumulatedY,
                             accumulatedMaxX, accumulatedMaxY);
            contentsLost = bufferStrategy.contentsLost();
        }
        if (contentsLost) {
            if (LOGGER.isLoggable(PlatformLogger.Level.FINER)) {
                LOGGER.finer("endPaint: contents lost");
            }
            // Shown region was bogus, mark buffer as out of sync.
            bufferInfo.setInSync(false);
            success = false;
        }
    }
    resetAccumulated();
    return success;
}

/**
 * Creates the BufferStrategy.  If the appropriate system property
 * has been set we'll try for flip first and then we'll try for
 * blit.
 */
private BufferStrategy createBufferStrategy() {
    Container root = getRoot();
    if (root == null) {
        return null;
    }
    BufferStrategy bs = null;
    if (SwingUtilities3.isVsyncRequested(root)) {
        bs = createBufferStrategy(root, true);
        if (LOGGER.isLoggable(PlatformLogger.Level.FINER)) {
            LOGGER.finer("createBufferStrategy: using vsynced strategy");
        }
    }
    if (bs == null) {
        bs = createBufferStrategy(root, false);
    }
    if (!(bs instanceof SubRegionShowable)) {
        // We do this for two reasons:
        // 1. So that we know we can cast to SubRegionShowable and
        //    invoke show with the minimal region to update
        // 2. To avoid the possibility of invoking client code
        //    on the toolkit thread.
        bs = null;
    }
    return bs;
}

/**
 * Renders the BufferStrategy to the screen.
 *
 * @return true if successful, false otherwise.
 */
private boolean flushAccumulatedRegion() {
    boolean success = true;
    if (accumulatedX != Integer.MAX_VALUE) {
        SubRegionShowable bsSubRegion = (SubRegionShowable)bufferStrategy;
        boolean contentsLost = bufferStrategy.contentsLost();
        if (!contentsLost) {
            bsSubRegion.show(accumulatedX, accumulatedY,
                             accumulatedMaxX, accumulatedMaxY);
            contentsLost = bufferStrategy.contentsLost();
        }
        if (contentsLost) {
            if (LOGGER.isLoggable(PlatformLogger.FINER)) {
                LOGGER.finer("endPaint: contents lost");
            }
            // Shown region was bogus, mark buffer as out of sync.
            bufferInfo.setInSync(false);
            success = false;
        }
    }
    resetAccumulated();
    return success;
}

/**
 * Creates the BufferStrategy.  If the appropriate system property
 * has been set we'll try for flip first and then we'll try for
 * blit.
 */
private BufferStrategy createBufferStrategy() {
    Container root = getRoot();
    if (root == null) {
        return null;
    }
    BufferStrategy bs = null;
    if (SwingUtilities3.isVsyncRequested(root)) {
        bs = createBufferStrategy(root, true);
        if (LOGGER.isLoggable(PlatformLogger.FINER)) {
            LOGGER.finer("createBufferStrategy: using vsynced strategy");
        }
    }
    if (bs == null) {
        bs = createBufferStrategy(root, false);
    }
    if (!(bs instanceof SubRegionShowable)) {
        // We do this for two reasons:
        // 1. So that we know we can cast to SubRegionShowable and
        //    invoke show with the minimal region to update
        // 2. To avoid the possibility of invoking client code
        //    on the toolkit thread.
        bs = null;
    }
    return bs;
}

/**
 * Renders the BufferStrategy to the screen.
 *
 * @return true if successful, false otherwise.
 */
private boolean flushAccumulatedRegion() {
    boolean success = true;
    if (accumulatedX != Integer.MAX_VALUE) {
        SubRegionShowable bsSubRegion = (SubRegionShowable)bufferStrategy;
        boolean contentsLost = bufferStrategy.contentsLost();
        if (!contentsLost) {
            bsSubRegion.show(accumulatedX, accumulatedY,
                             accumulatedMaxX, accumulatedMaxY);
            contentsLost = bufferStrategy.contentsLost();
        }
        if (contentsLost) {
            if (LOGGER.isLoggable(PlatformLogger.FINER)) {
                LOGGER.finer("endPaint: contents lost");
            }
            // Shown region was bogus, mark buffer as out of sync.
            bufferInfo.setInSync(false);
            success = false;
        }
    }
    resetAccumulated();
    return success;
}

/**
 * Creates the BufferStrategy.  If the appropriate system property
 * has been set we'll try for flip first and then we'll try for
 * blit.
 */
private BufferStrategy createBufferStrategy() {
    Container root = getRoot();
    if (root == null) {
        return null;
    }
    BufferStrategy bs = null;
    if (SwingUtilities3.isVsyncRequested(root)) {
        bs = createBufferStrategy(root, true);
        if (LOGGER.isLoggable(PlatformLogger.FINER)) {
            LOGGER.finer("createBufferStrategy: using vsynced strategy");
        }
    }
    if (bs == null) {
        bs = createBufferStrategy(root, false);
    }
    if (!(bs instanceof SubRegionShowable)) {
        // We do this for two reasons:
        // 1. So that we know we can cast to SubRegionShowable and
        //    invoke show with the minimal region to update
        // 2. To avoid the possibility of invoking client code
        //    on the toolkit thread.
        bs = null;
    }
    return bs;
}

/**
 * Shows the specified region of the back buffer.  This will return
 * true if successful, false otherwise.  This is invoked on the
 * toolkit thread in response to an expose event.
 */
public boolean show(Container c, int x, int y, int w, int h) {
    synchronized(this) {
        if (painting) {
            // Don't show from backbuffer while in the process of
            // painting.
            return false;
        }
        showing = true;
    }
    try {
        BufferInfo info = getBufferInfo(c);
        BufferStrategy bufferStrategy;
        if (info != null && info.isInSync() &&
            (bufferStrategy = info.getBufferStrategy(false)) != null) {
            SubRegionShowable bsSubRegion =
                    (SubRegionShowable)bufferStrategy;
            boolean paintAllOnExpose = info.getPaintAllOnExpose();
            info.setPaintAllOnExpose(false);
            if (bsSubRegion.showIfNotLost(x, y, (x + w), (y + h))) {
                return !paintAllOnExpose;
            }
            // Mark the buffer as needing to be repainted.  We don't
            // immediately do a repaint as this method will return false
            // indicating a PaintEvent should be generated which will
            // trigger a complete repaint.
            bufferInfo.setContentsLostDuringExpose(true);
        }
    }
    finally {
        synchronized(this) {
            showing = false;
            notifyAll();
        }
    }
    return false;
}

/**
 * Shows the specified region of the back buffer.  This will return
 * true if successful, false otherwise.  This is invoked on the
 * toolkit thread in response to an expose event.
 */
public boolean show(Container c, int x, int y, int w, int h) {
    synchronized(this) {
        if (painting) {
            // Don't show from backbuffer while in the process of
            // painting.
            return false;
        }
        showing = true;
    }
    try {
        BufferInfo info = getBufferInfo(c);
        BufferStrategy bufferStrategy;
        if (info != null && info.isInSync() &&
            (bufferStrategy = info.getBufferStrategy(false)) != null) {
            SubRegionShowable bsSubRegion =
                    (SubRegionShowable)bufferStrategy;
            boolean paintAllOnExpose = info.getPaintAllOnExpose();
            info.setPaintAllOnExpose(false);
            if (bsSubRegion.showIfNotLost(x, y, (x + w), (y + h))) {
                return !paintAllOnExpose;
            }
            // Mark the buffer as needing to be repainted.  We don't
            // immediately do a repaint as this method will return false
            // indicating a PaintEvent should be generated which will
            // trigger a complete repaint.
            bufferInfo.setContentsLostDuringExpose(true);
        }
    }
    finally {
        synchronized(this) {
            showing = false;
            notifyAll();
        }
    }
    return false;
}

/**
 * Shows the specified region of the back buffer.  This will return
 * true if successful, false otherwise.  This is invoked on the
 * toolkit thread in response to an expose event.
 */
public boolean show(Container c, int x, int y, int w, int h) {
    synchronized(this) {
        if (painting) {
            // Don't show from backbuffer while in the process of
            // painting.
            return false;
        }
        showing = true;
    }
    try {
        BufferInfo info = getBufferInfo(c);
        BufferStrategy bufferStrategy;
        if (info != null && info.isInSync() &&
            (bufferStrategy = info.getBufferStrategy(false)) != null) {
            SubRegionShowable bsSubRegion =
                    (SubRegionShowable)bufferStrategy;
            boolean paintAllOnExpose = info.getPaintAllOnExpose();
            info.setPaintAllOnExpose(false);
            if (bsSubRegion.showIfNotLost(x, y, (x + w), (y + h))) {
                return !paintAllOnExpose;
            }
            // Mark the buffer as needing to be repainted.  We don't
            // immediately do a repaint as this method will return false
            // indicating a PaintEvent should be generated which will
            // trigger a complete repaint.
            bufferInfo.setContentsLostDuringExpose(true);
        }
    }
    finally {
        synchronized(this) {
            showing = false;
            notifyAll();
        }
    }
    return false;
}

/**
 * Shows the specified region of the back buffer.  This will return
 * true if successful, false otherwise.  This is invoked on the
 * toolkit thread in response to an expose event.
 */
public boolean show(Container c, int x, int y, int w, int h) {
    synchronized(this) {
        if (painting) {
            // Don't show from backbuffer while in the process of
            // painting.
            return false;
        }
        showing = true;
    }
    try {
        BufferInfo info = getBufferInfo(c);
        BufferStrategy bufferStrategy;
        if (info != null && info.isInSync() &&
            (bufferStrategy = info.getBufferStrategy(false)) != null) {
            SubRegionShowable bsSubRegion =
                    (SubRegionShowable)bufferStrategy;
            boolean paintAllOnExpose = info.getPaintAllOnExpose();
            info.setPaintAllOnExpose(false);
            if (bsSubRegion.showIfNotLost(x, y, (x + w), (y + h))) {
                return !paintAllOnExpose;
            }
            // Mark the buffer as needing to be repainted.  We don't
            // immediately do a repaint as this method will return false
            // indicating a PaintEvent should be generated which will
            // trigger a complete repaint.
            bufferInfo.setContentsLostDuringExpose(true);
        }
    }
    finally {
        synchronized(this) {
            showing = false;
            notifyAll();
        }
    }
    return false;
}

/**
 * Shows the specified region of the back buffer.  This will return
 * true if successful, false otherwise.  This is invoked on the
 * toolkit thread in response to an expose event.
 */
public boolean show(Container c, int x, int y, int w, int h) {
    synchronized(this) {
        if (painting) {
            // Don't show from backbuffer while in the process of
            // painting.
            return false;
        }
        showing = true;
    }
    try {
        BufferInfo info = getBufferInfo(c);
        BufferStrategy bufferStrategy;
        if (info != null && info.isInSync() &&
            (bufferStrategy = info.getBufferStrategy(false)) != null) {
            SubRegionShowable bsSubRegion =
                    (SubRegionShowable)bufferStrategy;
            boolean paintAllOnExpose = info.getPaintAllOnExpose();
            info.setPaintAllOnExpose(false);
            if (bsSubRegion.showIfNotLost(x, y, (x + w), (y + h))) {
                return !paintAllOnExpose;
            }
            // Mark the buffer as needing to be repainted.  We don't
            // immediately do a repaint as this method will return false
            // indicating a PaintEvent should be generated which will
            // trigger a complete repaint.
            bufferInfo.setContentsLostDuringExpose(true);
        }
    }
    finally {
        synchronized(this) {
            showing = false;
            notifyAll();
        }
    }
    return false;
}

/**
 * Shows the specified region of the back buffer.  This will return
 * true if successful, false otherwise.  This is invoked on the
 * toolkit thread in response to an expose event.
 */
public boolean show(Container c, int x, int y, int w, int h) {
    synchronized(this) {
        if (painting) {
            // Don't show from backbuffer while in the process of
            // painting.
            return false;
        }
        showing = true;
    }
    try {
        BufferInfo info = getBufferInfo(c);
        BufferStrategy bufferStrategy;
        if (info != null && info.isInSync() &&
            (bufferStrategy = info.getBufferStrategy(false)) != null) {
            SubRegionShowable bsSubRegion =
                    (SubRegionShowable)bufferStrategy;
            boolean paintAllOnExpose = info.getPaintAllOnExpose();
            info.setPaintAllOnExpose(false);
            if (bsSubRegion.showIfNotLost(x, y, (x + w), (y + h))) {
                return !paintAllOnExpose;
            }
            // Mark the buffer as needing to be repainted.  We don't
            // immediately do a repaint as this method will return false
            // indicating a PaintEvent should be generated which will
            // trigger a complete repaint.
            bufferInfo.setContentsLostDuringExpose(true);
        }
    }
    finally {
        synchronized(this) {
            showing = false;
            notifyAll();
        }
    }
    return false;
}

/**
 * Shows the specified region of the back buffer.  This will return
 * true if successful, false otherwise.  This is invoked on the
 * toolkit thread in response to an expose event.
 */
public boolean show(Container c, int x, int y, int w, int h) {
    synchronized(this) {
        if (painting) {
            // Don't show from backbuffer while in the process of
            // painting.
            return false;
        }
        showing = true;
    }
    try {
        BufferInfo info = getBufferInfo(c);
        BufferStrategy bufferStrategy;
        if (info != null && info.isInSync() &&
            (bufferStrategy = info.getBufferStrategy(false)) != null) {
            SubRegionShowable bsSubRegion =
                    (SubRegionShowable)bufferStrategy;
            boolean paintAllOnExpose = info.getPaintAllOnExpose();
            info.setPaintAllOnExpose(false);
            if (bsSubRegion.showIfNotLost(x, y, (x + w), (y + h))) {
                return !paintAllOnExpose;
            }
            // Mark the buffer as needing to be repainted.  We don't
            // immediately do a repaint as this method will return false
            // indicating a PaintEvent should be generated which will
            // trigger a complete repaint.
            bufferInfo.setContentsLostDuringExpose(true);
        }
    }
    finally {
        synchronized(this) {
            showing = false;
            notifyAll();
        }
    }
    return false;
}

/**
 * Shows the specified region of the back buffer.  This will return
 * true if successful, false otherwise.  This is invoked on the
 * toolkit thread in response to an expose event.
 */
public boolean show(Container c, int x, int y, int w, int h) {
    synchronized(this) {
        if (painting) {
            // Don't show from backbuffer while in the process of
            // painting.
            return false;
        }
        showing = true;
    }
    try {
        BufferInfo info = getBufferInfo(c);
        BufferStrategy bufferStrategy;
        if (info != null && info.isInSync() &&
            (bufferStrategy = info.getBufferStrategy(false)) != null) {
            SubRegionShowable bsSubRegion =
                    (SubRegionShowable)bufferStrategy;
            boolean paintAllOnExpose = info.getPaintAllOnExpose();
            info.setPaintAllOnExpose(false);
            if (bsSubRegion.showIfNotLost(x, y, (x + w), (y + h))) {
                return !paintAllOnExpose;
            }
            // Mark the buffer as needing to be repainted.  We don't
            // immediately do a repaint as this method will return false
            // indicating a PaintEvent should be generated which will
            // trigger a complete repaint.
            bufferInfo.setContentsLostDuringExpose(true);
        }
    }
    finally {
        synchronized(this) {
            showing = false;
            notifyAll();
        }
    }
    return false;
}

/**
 * Shows the specified region of the back buffer.  This will return
 * true if successful, false otherwise.  This is invoked on the
 * toolkit thread in response to an expose event.
 */
public boolean show(Container c, int x, int y, int w, int h) {
    synchronized(this) {
        if (painting) {
            // Don't show from backbuffer while in the process of
            // painting.
            return false;
        }
        showing = true;
    }
    try {
        BufferInfo info = getBufferInfo(c);
        BufferStrategy bufferStrategy;
        if (info != null && info.isInSync() &&
            (bufferStrategy = info.getBufferStrategy(false)) != null) {
            SubRegionShowable bsSubRegion =
                    (SubRegionShowable)bufferStrategy;
            boolean paintAllOnExpose = info.getPaintAllOnExpose();
            info.setPaintAllOnExpose(false);
            if (bsSubRegion.showIfNotLost(x, y, (x + w), (y + h))) {
                return !paintAllOnExpose;
            }
            // Mark the buffer as needing to be repainted.  We don't
            // immediately do a repaint as this method will return false
            // indicating a PaintEvent should be generated which will
            // trigger a complete repaint.
            bufferInfo.setContentsLostDuringExpose(true);
        }
    }
    finally {
        synchronized(this) {
            showing = false;
            notifyAll();
        }
    }
    return false;
}

/**
 * Shows the specified region of the back buffer.  This will return
 * true if successful, false otherwise.  This is invoked on the
 * toolkit thread in response to an expose event.
 */
public boolean show(Container c, int x, int y, int w, int h) {
    synchronized(this) {
        if (painting) {
            // Don't show from backbuffer while in the process of
            // painting.
            return false;
        }
        showing = true;
    }
    try {
        BufferInfo info = getBufferInfo(c);
        BufferStrategy bufferStrategy;
        if (info != null && info.isInSync() &&
            (bufferStrategy = info.getBufferStrategy(false)) != null) {
            SubRegionShowable bsSubRegion =
                    (SubRegionShowable)bufferStrategy;
            boolean paintAllOnExpose = info.getPaintAllOnExpose();
            info.setPaintAllOnExpose(false);
            if (bsSubRegion.showIfNotLost(x, y, (x + w), (y + h))) {
                return !paintAllOnExpose;
            }
            // Mark the buffer as needing to be repainted.  We don't
            // immediately do a repaint as this method will return false
            // indicating a PaintEvent should be generated which will
            // trigger a complete repaint.
            bufferInfo.setContentsLostDuringExpose(true);
        }
    }
    finally {
        synchronized(this) {
            showing = false;
            notifyAll();
        }
    }
    return false;
}

/**
 * Shows the specified region of the back buffer.  This will return
 * true if successful, false otherwise.  This is invoked on the
 * toolkit thread in response to an expose event.
 */
public boolean show(Container c, int x, int y, int w, int h) {
    synchronized(this) {
        if (painting) {
            // Don't show from backbuffer while in the process of
            // painting.
            return false;
        }
        showing = true;
    }
    try {
        BufferInfo info = getBufferInfo(c);
        BufferStrategy bufferStrategy;
        if (info != null && info.isInSync() &&
            (bufferStrategy = info.getBufferStrategy(false)) != null) {
            SubRegionShowable bsSubRegion =
                    (SubRegionShowable)bufferStrategy;
            boolean paintAllOnExpose = info.getPaintAllOnExpose();
            info.setPaintAllOnExpose(false);
            if (bsSubRegion.showIfNotLost(x, y, (x + w), (y + h))) {
                return !paintAllOnExpose;
            }
            // Mark the buffer as needing to be repainted.  We don't
            // immediately do a repaint as this method will return false
            // indicating a PaintEvent should be generated which will
            // trigger a complete repaint.
            bufferInfo.setContentsLostDuringExpose(true);
        }
    }
    finally {
        synchronized(this) {
            showing = false;
            notifyAll();
        }
    }
    return false;
}

/**
 * Shows the specified region of the back buffer.  This will return
 * true if successful, false otherwise.  This is invoked on the
 * toolkit thread in response to an expose event.
 */
public boolean show(Container c, int x, int y, int w, int h) {
    synchronized(this) {
        if (painting) {
            // Don't show from backbuffer while in the process of
            // painting.
            return false;
        }
        showing = true;
    }
    try {
        BufferInfo info = getBufferInfo(c);
        BufferStrategy bufferStrategy;
        if (info != null && info.isInSync() &&
            (bufferStrategy = info.getBufferStrategy(false)) != null) {
            SubRegionShowable bsSubRegion =
                    (SubRegionShowable)bufferStrategy;
            boolean paintAllOnExpose = info.getPaintAllOnExpose();
            info.setPaintAllOnExpose(false);
            if (bsSubRegion.showIfNotLost(x, y, (x + w), (y + h))) {
                return !paintAllOnExpose;
            }
            // Mark the buffer as needing to be repainted.  We don't
            // immediately do a repaint as this method will return false
            // indicating a PaintEvent should be generated which will
            // trigger a complete repaint.
            bufferInfo.setContentsLostDuringExpose(true);
        }
    }
    finally {
        synchronized(this) {
            showing = false;
            notifyAll();
        }
    }
    return false;
}