/*

 * Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

import java.awt.Color;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.RenderingHints;

import java.awt.image.BufferedImage;

import sun.awt.SunHints;

import java.awt.geom.AffineTransform;

import java.util.Arrays;

import java.util.List;

import java.awt.image.MultiResolutionImage;

/**

 * @test

 * @bug 8011059

 * @author Alexander Scherbatiy

 * @summary Test MultiResolution image loading and painting with various scaling

 *          combinations

 * @modules java.desktop/sun.awt

 *          java.desktop/sun.awt.image

 */

public class MultiResolutionImageCommonTest {

    private static final int IMAGE_WIDTH = 300;

    private static final int IMAGE_HEIGHT = 200;

    private static final Color COLOR_1X = Color.GREEN;

    private static final Color COLOR_2X = Color.BLUE;

    public static void main(String[] args) throws Exception {

        testCustomMultiResolutionImage();

        System.out.println("Test passed.");

    }

    public static void testCustomMultiResolutionImage() {

        testCustomMultiResolutionImage(false);

        testCustomMultiResolutionImage(true);

    }

    public static void testCustomMultiResolutionImage(

            boolean enableImageScaling) {

        Image image = new MultiResolutionBufferedImage();

        // Same image size

        BufferedImage bufferedImage = new BufferedImage(

                IMAGE_WIDTH, IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

        Graphics2D g2d = (Graphics2D) bufferedImage.getGraphics();

        setImageScalingHint(g2d, enableImageScaling);

        g2d.drawImage(image, 0, 0, null);

        checkColor(bufferedImage.getRGB(

                3 * IMAGE_WIDTH / 4, 3 * IMAGE_HEIGHT / 4), false);

        // Twice image size

        bufferedImage = new BufferedImage(2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT,

                BufferedImage.TYPE_INT_RGB);

        g2d = (Graphics2D) bufferedImage.getGraphics();

        setImageScalingHint(g2d, enableImageScaling);

        g2d.drawImage(image, 0, 0, 2 * IMAGE_WIDTH,

                2 * IMAGE_HEIGHT, 0, 0, IMAGE_WIDTH, IMAGE_HEIGHT, null);

        checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 2,

                3 * IMAGE_HEIGHT / 2), enableImageScaling);

        // Scale 2x

        bufferedImage = new BufferedImage(

                2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

        g2d = (Graphics2D) bufferedImage.getGraphics();

        setImageScalingHint(g2d, enableImageScaling);

        g2d.scale(2, 2);

        g2d.drawImage(image, 0, 0, IMAGE_WIDTH, IMAGE_HEIGHT, null);

        checkColor(bufferedImage.getRGB(

                3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);

        // Rotate

        bufferedImage = new BufferedImage(IMAGE_WIDTH, IMAGE_HEIGHT,

                BufferedImage.TYPE_INT_RGB);

        g2d = (Graphics2D) bufferedImage.getGraphics();

        setImageScalingHint(g2d, enableImageScaling);

        g2d.drawImage(image, 0, 0, null);

        g2d.rotate(Math.PI / 4);

        checkColor(bufferedImage.getRGB(

                3 * IMAGE_WIDTH / 4, 3 * IMAGE_HEIGHT / 4), false);

        // Scale 2x and Rotate

        bufferedImage = new BufferedImage(

                2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

        g2d = (Graphics2D) bufferedImage.getGraphics();

        setImageScalingHint(g2d, enableImageScaling);

        g2d.scale(-2, 2);

        g2d.rotate(-Math.PI / 10);

        g2d.drawImage(image, -IMAGE_WIDTH, 0, IMAGE_WIDTH, IMAGE_HEIGHT, null);

        checkColor(bufferedImage.getRGB(

                3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);

        // General Transform

        bufferedImage = new BufferedImage(

                2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

        g2d = (Graphics2D) bufferedImage.getGraphics();

        setImageScalingHint(g2d, enableImageScaling);

        float delta = 0.05f;

        float cos = 1 - delta * delta / 2;

        float sin = 1 + delta;

        AffineTransform transform

                = new AffineTransform(2 * cos, 0.1, 0.3, -2 * sin, 10, -5);

        g2d.setTransform(transform);

        g2d.drawImage(image, 0, -IMAGE_HEIGHT, IMAGE_WIDTH, IMAGE_HEIGHT, null);

        checkColor(bufferedImage.getRGB(

                3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);

        int D = 10;

        // From Source to small Destination region

        bufferedImage = new BufferedImage(

                IMAGE_WIDTH, IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

        g2d = (Graphics2D) bufferedImage.getGraphics();

        setImageScalingHint(g2d, enableImageScaling);

        g2d.drawImage(image, IMAGE_WIDTH / 2, IMAGE_HEIGHT / 2,

                IMAGE_WIDTH - D, IMAGE_HEIGHT - D,

                D, D, IMAGE_WIDTH - D, IMAGE_HEIGHT - D, null);

        checkColor(bufferedImage.getRGB(

                3 * IMAGE_WIDTH / 4, 3 * IMAGE_HEIGHT / 4), false);

        // From Source to large Destination region

        bufferedImage = new BufferedImage(

                2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

        g2d = (Graphics2D) bufferedImage.getGraphics();

        setImageScalingHint(g2d, enableImageScaling);

        g2d.drawImage(image, D, D, 2 * IMAGE_WIDTH - D, 2 * IMAGE_HEIGHT - D,

                IMAGE_WIDTH / 2, IMAGE_HEIGHT / 2,

                IMAGE_WIDTH - D, IMAGE_HEIGHT - D, null);

        checkColor(bufferedImage.getRGB(

                3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);

    }

    static class MultiResolutionBufferedImage extends BufferedImage

            implements MultiResolutionImage {

        Image highResolutionImage;

        public MultiResolutionBufferedImage() {

            super(IMAGE_WIDTH, IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

            highResolutionImage = new BufferedImage(

                    2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT,

                    BufferedImage.TYPE_INT_RGB);

            draw(getGraphics(), 1);

            draw(highResolutionImage.getGraphics(), 2);

        }

        final void draw(Graphics graphics, float resolution) {

            Graphics2D g2 = (Graphics2D) graphics;

            g2.scale(resolution, resolution);

            g2.setColor((resolution == 1) ? COLOR_1X : COLOR_2X);

            g2.fillRect(0, 0, IMAGE_WIDTH, IMAGE_HEIGHT);

        }

        @Override

        public Image getResolutionVariant(

                double destImageWidth, double destImageHeight) {

            return ((destImageWidth <= getWidth() && destImageHeight <= getHeight()))

                    ? this : highResolutionImage;

        }

        @Override

        public List<Image> getResolutionVariants() {

            return Arrays.asList(this, highResolutionImage);

        }

    }

    static void setImageScalingHint(

            Graphics2D g2d, boolean enableImageScaling) {

        g2d.setRenderingHint(SunHints.KEY_RESOLUTION_VARIANT, enableImageScaling

                ? RenderingHints.VALUE_RESOLUTION_VARIANT_DEFAULT

                : RenderingHints.VALUE_RESOLUTION_VARIANT_BASE);

    }

    static void checkColor(int rgb, boolean isImageScaled) {

        if (!isImageScaled && COLOR_1X.getRGB() != rgb) {

            throw new RuntimeException("Wrong 1x color: " + new Color(rgb));

        }

        if (isImageScaled && COLOR_2X.getRGB() != rgb) {

            throw new RuntimeException("Wrong 2x color" + new Color(rgb));

        }

    }

}