/*

 * Copyright (c) 2017, 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.

 */

/*

 * @test

 * @key headful

 * @bug 8159062

 * @summary Tests DnD property with HIDPI scale set to non-interger value 2.5

 * @run main/othervm -Dsun.java2d.uiScale=2.5 DragTestWithHIDPI

 */

import javax.swing.JList;

import javax.swing.TransferHandler;

import javax.swing.JFrame;

import javax.swing.JComponent;

import javax.swing.SwingUtilities;

import java.awt.Robot;

import java.awt.BorderLayout;

import java.awt.Point;

import java.awt.Dimension;

import java.awt.MouseInfo;

import java.awt.event.InputEvent;

public class DragTestWithHIDPI extends TransferHandler {

    private static boolean didDrag = false;

    private static int threshold = 10;

    private static int DEFAULT_DELAY = 550;

    private Robot robot = null;

    private static JList list = null;

    private static Point listLocation = null;

    private static Dimension listSize = null;

    private static JFrame f = null;

    private enum Direction {

        RIGHT, LEFT, BOTTOM, TOP

    }

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

        DragTestWithHIDPI test = new DragTestWithHIDPI();

        // set the mouse move drag threshold

        System.setProperty("awt.dnd.drag.threshold", String.valueOf(threshold));

        test.createGUI();

        test.doTest();

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

        test.disposeGUI();

    }

    public void exportAsDrag(JComponent comp, InputEvent e, int action) {

        didDrag = true;

    }

    public DragTestWithHIDPI() {

        super("foreground");

    }

    private void createGUI() throws Exception{

        SwingUtilities.invokeAndWait(() -> {

            String[] listData =

                    new String[]{"Pacific Ocean", "Atlantic Ocean", "Indian Ocean",

                            "Arctic Ocean"};

            list = new JList(listData);

            list.setDragEnabled(true);

            list.setTransferHandler(new DragTestWithHIDPI());

            f = new JFrame("DragTestWithHIDPI");

            f.getContentPane().add(list, BorderLayout.CENTER);

            f.pack();

            f.toFront();

            f.setVisible(true);

            listLocation = list.getLocationOnScreen();

            listSize = list.getSize();

        });

    }

    private void disposeGUI () throws  Exception {

        SwingUtilities.invokeAndWait(() -> {

            f.dispose();

        });

    }

    private void doTest() throws Exception {

        robot = new Robot();

        robot.waitForIdle();

        for (Direction direction : Direction.values()) {

            //Drag should not start only by moving (threshold - 1) pixels

            didDrag = false;

            test(threshold - 1, direction);

            if (didDrag) {

                disposeGUI();

                throw new RuntimeException(

                        "Shouldn't start drag until > " + threshold +

                                " pixels " + " while moving " + direction);

            }

            // Drag should not start only by moving threshold pixels

            didDrag = false;

            test(threshold, direction);

            if (didDrag) {

                disposeGUI();

                throw new RuntimeException(

                        "Shouldn't start drag until > " + threshold +

                                " pixels" + " while moving " + direction);

            }

            // Drag should start after moving threshold + 1 pixel

            didDrag = false;

            test(threshold + 1, direction);

            if (!didDrag) {

                disposeGUI();

                throw new RuntimeException(

                        "Should start drag after > " + threshold + " pixels" +

                                " while moving " + direction);

            }

        }

    }

    private void test(int threshold, Direction direction) {

        clickMouseOnList(InputEvent.BUTTON1_DOWN_MASK);

        Point p = MouseInfo.getPointerInfo().getLocation();

        robot.mousePress(InputEvent.BUTTON1_DOWN_MASK);

        robot.delay(DEFAULT_DELAY);

        glide(p, direction, threshold);

        robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK);

    }

    private void glide(Point p, Direction direction, int toAdd) {

        switch (direction) {

            case RIGHT:

                // move towards right

                glide(p.x, p.y, p.x + toAdd, p.y);

                break;

            case LEFT:

                // move towards left

                glide(p.x, p.y, p.x - toAdd, p.y);

                break;

            case BOTTOM:

                // move towards bottom

                glide(p.x, p.y, p.x, p.y + toAdd);

                break;

            case TOP:

                // move towards top

                glide(p.x, p.y, p.x, p.y - toAdd);

                break;

        }

    }

    /*

    Some utilities functions from JRobot class.

     */

    private void moveMouseToList() {

        int x = listLocation.x + listSize.width/2;

        int y = listLocation.y + listSize.height/2;

        robot.mouseMove(x, y);

        robot.delay(DEFAULT_DELAY);

    }

    private void clickMouse(int buttons) {

        robot.mousePress(buttons);

        robot.mouseRelease(buttons);

        robot.delay(DEFAULT_DELAY);

    }

    private void clickMouseOnList(int buttons) {

        moveMouseToList();

        clickMouse(buttons);

    }

    private void glide(int x0, int y0, int x1, int y1) {

        float dmax = (float)Math.max(Math.abs(x1 - x0), Math.abs(y1 - y0));

        float dx = (x1 - x0) / dmax;

        float dy = (y1 - y0) / dmax;

        robot.mouseMove(x0, y0);

        for (int i=1; i<=dmax; i++) {

            robot.mouseMove((int)(x0 + dx*i), (int)(y0 + dy*i));

        }

        robot.delay(DEFAULT_DELAY);

    }

}