Examples with VolatileImage java.awt.image.VolatileImage used on opensource projects

Example 11 with VolatileImage

use of java.awt.image.VolatileImage in project jdk8u_jdk by JetBrains.

the class RepaintManager method getVolatileOffscreenBuffer.

/**
   * Return a volatile offscreen buffer that should be used as a
   * double buffer with the specified component <code>c</code>.
   * The image returned will be an instance of VolatileImage, or null
   * if a VolatileImage object could not be instantiated.
   * This buffer might be smaller than <code>(proposedWidth,proposedHeight)</code>.
   * This happens when the maximum double buffer size has been set for this
   * repaint manager.
   *
   * @see java.awt.image.VolatileImage
   * @since 1.4
   */
public Image getVolatileOffscreenBuffer(Component c, int proposedWidth, int proposedHeight) {
    RepaintManager delegate = getDelegate(c);
    if (delegate != null) {
        return delegate.getVolatileOffscreenBuffer(c, proposedWidth, proposedHeight);
    }
    // If the window is non-opaque, it's double-buffered at peer's level
    Window w = (c instanceof Window) ? (Window) c : SwingUtilities.getWindowAncestor(c);
    if (!w.isOpaque()) {
        Toolkit tk = Toolkit.getDefaultToolkit();
        if ((tk instanceof SunToolkit) && (((SunToolkit) tk).needUpdateWindow())) {
            return null;
        }
    }
    GraphicsConfiguration config = c.getGraphicsConfiguration();
    if (config == null) {
        config = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
    }
    Dimension maxSize = getDoubleBufferMaximumSize();
    int width = proposedWidth < 1 ? 1 : (proposedWidth > maxSize.width ? maxSize.width : proposedWidth);
    int height = proposedHeight < 1 ? 1 : (proposedHeight > maxSize.height ? maxSize.height : proposedHeight);
    VolatileImage image = volatileMap.get(config);
    if (image == null || image.getWidth() < width || image.getHeight() < height) {
        if (image != null) {
            image.flush();
        }
        image = config.createCompatibleVolatileImage(width, height, volatileBufferType);
        volatileMap.put(config, image);
    }
    return image;
}

Example 12 with VolatileImage

use of java.awt.image.VolatileImage in project jdk8u_jdk by JetBrains.

the class SunGraphics2D method drawHiDPIImage.

// end of text rendering methods
private Boolean drawHiDPIImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, Color bgcolor, ImageObserver observer, AffineTransform xform) {
    if (img instanceof VolatileImage) {
        final SurfaceData sd = SurfaceManager.getManager(img).getPrimarySurfaceData();
        final double scaleX = sd.getDefaultScaleX();
        final double scaleY = sd.getDefaultScaleY();
        if (scaleX == 1 && scaleY == 1) {
            return null;
        }
        sx1 = Region.clipScale(sx1, scaleX);
        sx2 = Region.clipScale(sx2, scaleX);
        sy1 = Region.clipScale(sy1, scaleY);
        sy2 = Region.clipScale(sy2, scaleY);
        AffineTransform tx = null;
        if (xform != null) {
            tx = new AffineTransform(transform);
            transform(xform);
        }
        boolean result = scaleImage(img, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, bgcolor, observer);
        if (tx != null) {
            transform.setTransform(tx);
            invalidateTransform();
        }
        return result;
    } else if (resolutionVariantHint != SunHints.INTVAL_RESOLUTION_VARIANT_BASE && (img instanceof MultiResolutionImage)) {
        // get scaled destination image size
        int width = img.getWidth(observer);
        int height = img.getHeight(observer);
        MultiResolutionImage mrImage = (MultiResolutionImage) img;
        Image resolutionVariant = getResolutionVariant(mrImage, width, height, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, xform);
        if (resolutionVariant != img && resolutionVariant != null) {
            // recalculate source region for the resolution variant
            ImageObserver rvObserver = MultiResolutionToolkitImage.getResolutionVariantObserver(img, observer, width, height, -1, -1);
            int rvWidth = resolutionVariant.getWidth(rvObserver);
            int rvHeight = resolutionVariant.getHeight(rvObserver);
            if (0 < width && 0 < height && 0 < rvWidth && 0 < rvHeight) {
                double widthScale = ((double) rvWidth) / width;
                double heightScale = ((double) rvHeight) / height;
                sx1 = Region.clipScale(sx1, widthScale);
                sy1 = Region.clipScale(sy1, heightScale);
                sx2 = Region.clipScale(sx2, widthScale);
                sy2 = Region.clipScale(sy2, heightScale);
                observer = rvObserver;
                img = resolutionVariant;
                if (xform != null) {
                    assert dx1 == 0 && dy1 == 0;
                    assert dx2 == img.getWidth(observer);
                    assert dy2 == img.getHeight(observer);
                    AffineTransform renderTX = new AffineTransform(xform);
                    renderTX.scale(1 / widthScale, 1 / heightScale);
                    return transformImage(img, renderTX, observer);
                }
                return scaleImage(img, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, bgcolor, observer);
            }
        }
    }
    return null;
}

Example 13 with VolatileImage

use of java.awt.image.VolatileImage in project jdk8u_jdk by JetBrains.

the class UnmanagedDrawImagePerformance method main.

public static void main(final String[] args) {
    for (final AffineTransform atfm : TRANSFORMS) {
        for (final int viType : TRANSPARENCIES) {
            for (final int biType : TYPES) {
                final BufferedImage bi = makeUnmanagedBI(biType);
                final VolatileImage vi = makeVI(viType);
                final long time = test(bi, vi, atfm) / 1000000000;
                if (time > 1) {
                    throw new RuntimeException(String.format("drawImage is slow: %d seconds", time));
                }
            }
        }
    }
}

Example 14 with VolatileImage

use of java.awt.image.VolatileImage in project jdk8u_jdk by JetBrains.

the class IncorrectDestinationOffset method main.

public static void main(final String[] args) throws IOException {
    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
    GraphicsConfiguration gc = ge.getDefaultScreenDevice().getDefaultConfiguration();
    VolatileImage vi = gc.createCompatibleVolatileImage(SIZE, SIZE);
    BufferedImage bi = new BufferedImage(SIZE, SIZE, BufferedImage.TYPE_INT_ARGB);
    for (double scale : SCALES) {
        while (true) {
            // initialize Volatile Image
            vi.validate(gc);
            Graphics2D g2d = vi.createGraphics();
            g2d.setColor(Color.green);
            g2d.fillRect(0, 0, SIZE, SIZE);
            g2d.dispose();
            if (vi.validate(gc) != VolatileImage.IMAGE_OK) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException ignored) {
                }
                continue;
            }
            // Draw the VolatileImage to BI with scale and offsets
            Graphics2D g = bi.createGraphics();
            g.setComposite(AlphaComposite.Src);
            g.setColor(Color.RED);
            g.fillRect(0, 0, SIZE / 2, SIZE / 2);
            g.setColor(Color.BLUE);
            g.fillRect(SIZE / 2, 0, SIZE / 2, SIZE / 2);
            g.setColor(Color.ORANGE);
            g.fillRect(0, SIZE / 2, SIZE / 2, SIZE / 2);
            g.setColor(Color.MAGENTA);
            g.fillRect(SIZE / 2, SIZE / 2, SIZE / 2, SIZE / 2);
            int point2draw = (int) (100 * scale);
            int size2draw = (int) (SIZE * scale);
            g.drawImage(vi, point2draw, point2draw, size2draw, size2draw, null);
            g.dispose();
            if (vi.contentsLost()) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException ignored) {
                }
                continue;
            }
            validate(bi, point2draw, size2draw);
            break;
        }
    }
}

Example 15 with VolatileImage

use of java.awt.image.VolatileImage in project jdk8u_jdk by JetBrains.

the class IncorrectOffset method main.

public static void main(final String[] args) {
    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
    GraphicsConfiguration gc = ge.getDefaultScreenDevice().getDefaultConfiguration();
    VolatileImage vi = gc.createCompatibleVolatileImage(width, height);
    BufferedImage bi = new BufferedImage(width / 4, height / 4, BufferedImage.TYPE_INT_ARGB);
    while (true) {
        vi.validate(gc);
        Graphics2D g2d = vi.createGraphics();
        g2d.setColor(Color.black);
        g2d.fillRect(0, 0, width, height);
        g2d.setColor(Color.green);
        g2d.fillRect(width / 4, height / 4, width / 2, height / 2);
        g2d.dispose();
        if (vi.validate(gc) != VolatileImage.IMAGE_OK) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException ignored) {
            }
            continue;
        }
        Graphics2D g = bi.createGraphics();
        g.setComposite(AlphaComposite.Src);
        // Scale part of VI to BI. Only green area should be copied.
        g.drawImage(vi, 0, 0, width / 4, height / 4, width / 4, height / 4, width / 4 + width / 2, height / 4 + height / 2, null);
        g.dispose();
        if (vi.contentsLost()) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException ignored) {
            }
            continue;
        }
        for (int x = 0; x < width / 4; ++x) {
            for (int y = 0; y < height / 4; ++y) {
                if (bi.getRGB(x, y) != Color.green.getRGB()) {
                    throw new RuntimeException("Test failed.");
                }
            }
        }
        break;
    }
}