1 /*

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

     8  *

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

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

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

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

    13  * accompanied this code).

    14  *

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

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

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

    18  *

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

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

    21  * questions.

    22  */

    23 

    24 /*

    25   @test

    26   @bug 4397404 4720930

    27   @summary tests that images of all supported native image formats are transfered properly

    28   @library ../../regtesthelpers/process/

    29   @build ProcessResults ProcessCommunicator

    30   @author gas@sparc.spb.su area=Clipboard

    31   @run main ImageTransferTest

    32 */

    33 

    34 import sun.awt.OSInfo;

    35 import sun.awt.SunToolkit;

    36 import test.java.awt.regtesthelpers.process.ProcessCommunicator;

    37 import test.java.awt.regtesthelpers.process.ProcessResults;

    38 

    39 import java.awt.*;

    40 import java.awt.datatransfer.DataFlavor;

    41 import java.awt.datatransfer.SystemFlavorMap;

    42 import java.awt.datatransfer.Transferable;

    43 import java.awt.datatransfer.UnsupportedFlavorException;

    44 import java.awt.dnd.DnDConstants;

    45 import java.awt.dnd.DragSource;

    46 import java.awt.dnd.DragSourceAdapter;

    47 import java.awt.dnd.DragSourceDropEvent;

    48 import java.awt.dnd.DragSourceListener;

    49 import java.awt.dnd.DropTarget;

    50 import java.awt.dnd.DropTargetAdapter;

    51 import java.awt.dnd.DropTargetDropEvent;

    52 import java.awt.event.InputEvent;

    53 import java.awt.image.BufferedImage;

    54 import java.awt.image.MemoryImageSource;

    55 import java.util.stream.Stream;

    56 

    57 public class ImageTransferTest {

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

    59         ImageDragSource ids = new ImageDragSource();

    60         ids.frame.setLocation(100, 100);

    61         ids.frame.setVisible(true);

    62         Util.sync();

    63         String classpath = System.getProperty("java.class.path");

    64         String[] args = new String[ids.formats.length + 4];

    65         args[0] = "200";

    66         args[1] = "100";

    67         args[2] = args[3] = "150";

    68 

    69         System.arraycopy(ids.formats, 0, args, 4, ids.formats.length);

    70         ProcessResults pres = ProcessCommunicator.executeChildProcess(ImageDropTarget.class, classpath, args);

    71 

    72         if (pres.getStdErr() != null && pres.getStdErr().length() > 0) {

    73             System.err.println("========= Child VM System.err ========");

    74             System.err.print(pres.getStdErr());

    75             System.err.println("======================================");

    76         }

    77 

    78         if (pres.getStdOut() != null && pres.getStdOut().length() > 0) {

    79             System.err.println("========= Child VM System.out ========");

    80             System.err.print(pres.getStdOut());

    81             System.err.println("======================================");

    82         }

    83 

    84         boolean failed = false;

    85         String passedFormats = "";

    86         String failedFormats = "";

    87 

    88         for (int i = 0; i < ids.passedArray.length; i++) {

    89             if (ids.passedArray[i]) passedFormats += ids.formats[i] + " ";

    90             else {

    91                 failed = true;

    92                 failedFormats += ids.formats[i] + " ";

    93             }

    94         }

    95 

    96         if (failed) {

    97             throw new RuntimeException("test failed: images in following " +

    98                     "native formats are not transferred properly: " + failedFormats);

    99         } else {

   100             System.err.println("images in following " +

   101                     "native formats are transferred properly: " + passedFormats);

   102         }

   103     }

   104 }

   105 

   106 

   107 class Util {

   108     public static void sync() {

   109         ((SunToolkit) Toolkit.getDefaultToolkit()).realSync();

   110         try {

   111             Thread.sleep(500);

   112         } catch (InterruptedException e) {

   113             throw new RuntimeException(e);

   114         }

   115     }

   116 }

   117 

   118 abstract class ImageTransferer {

   119     Image image;

   120     String[] formats;

   121     int fi; // current format index

   122     Frame frame = new Frame();

   123 

   124 

   125     ImageTransferer() {

   126         image = createImage();

   127         frame.setSize(100, 100);

   128     }

   129 

   130     private static Image createImage() {

   131         int w = 100;

   132         int h = 100;

   133         int[] pix = new int[w * h];

   134 

   135         int index = 0;

   136         for (int y = 0; y < h; y++) {

   137             for (int x = 0; x < w; x++) {

   138                 int red = 127;

   139                 int green = 127;

   140                 int blue = y > h / 2 ? 127 : 0;

   141                 int alpha = 255;

   142                 if (x < w / 4 && y < h / 4) {

   143                     alpha = 0;

   144                     red = 0;

   145                 }

   146                 pix[index++] = (alpha << 24) | (red << 16) | (green << 8) | blue;

   147             }

   148         }

   149         return Toolkit.getDefaultToolkit().createImage(new MemoryImageSource(w, h, pix, 0, w));

   150     }

   151 

   152 

   153     static String[] retrieveFormatsToTest() {

   154         SystemFlavorMap sfm = (SystemFlavorMap) SystemFlavorMap.getDefaultFlavorMap();

   155         java.util.List<String> ln = sfm.getNativesForFlavor(DataFlavor.imageFlavor);

   156         if (OSInfo.OSType.WINDOWS.equals(OSInfo.getOSType()) && !ln.contains("METAFILEPICT")) {

   157             // for test failing on JDK without this fix

   158             ln.add("METAFILEPICT");

   159         }

   160         return ln.toArray(new String[ln.size()]);

   161     }

   162 

   163     static void leaveFormat(String format) {

   164         SystemFlavorMap sfm = (SystemFlavorMap) SystemFlavorMap.getDefaultFlavorMap();

   165         sfm.setFlavorsForNative(format, new DataFlavor[]{DataFlavor.imageFlavor});

   166         sfm.setNativesForFlavor(DataFlavor.imageFlavor, new String[]{format});

   167     }

   168 

   169 

   170     boolean areImagesIdentical(Image im1, Image im2) {

   171         if (formats[fi].equals("JFIF") || formats[fi].equals("image/jpeg") ||

   172                 formats[fi].equals("GIF") || formats[fi].equals("image/gif")) {

   173             // JFIF and GIF are lossy formats

   174             return true;

   175         }

   176         int[] ib1 = getImageData(im1);

   177         int[] ib2 = getImageData(im2);

   178 

   179         if (ib1.length != ib2.length) {

   180             return false;

   181         }

   182 

   183         if (formats[fi].equals("PNG") ||

   184                 formats[fi].equals("image/png") ||

   185                 formats[fi].equals("image/x-png")) {

   186             // check alpha as well

   187             for (int i = 0; i < ib1.length; i++) {

   188                 if (ib1[i] != ib2[i]) {

   189                     System.err.println("different pixels: " +

   190                             Integer.toHexString(ib1[i]) + " " +

   191                             Integer.toHexString(ib2[i]));

   192                     return false;

   193                 }

   194             }

   195         } else {

   196             for (int i = 0; i < ib1.length; i++) {

   197                 if ((ib1[i] & 0x00FFFFFF) != (ib2[i] & 0x00FFFFFF)) {

   198                     System.err.println("different pixels: " +

   199                             Integer.toHexString(ib1[i]) + " " +

   200                             Integer.toHexString(ib2[i]));

   201                     return false;

   202                 }

   203             }

   204         }

   205         return true;

   206     }

   207 

   208     private static int[] getImageData(Image image) {

   209         int width = image.getWidth(null);

   210         int height = image.getHeight(null);

   211         BufferedImage bimage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);

   212         Graphics2D g2d = bimage.createGraphics();

   213         try {

   214             g2d.drawImage(image, 0, 0, width, height, null);

   215         } finally {

   216             g2d.dispose();

   217         }

   218         return bimage.getRGB(0, 0, width, height, null, 0, width);

   219     }

   220 

   221     public static int sign(int n) {

   222         return n < 0 ? -1 : n == 0 ? 0 : 1;

   223     }

   224 

   225 }

   226 

   227 

   228 class ImageDragSource extends ImageTransferer {

   229     boolean[] passedArray;

   230 

   231     ImageDragSource() {

   232         formats = retrieveFormatsToTest();

   233         passedArray = new boolean[formats.length];

   234         final DragSourceListener dsl = new DragSourceAdapter() {

   235             public void dragDropEnd(DragSourceDropEvent e) {

   236                 System.err.println("Drop was successful=" + e.getDropSuccess());

   237                 notifyTransferSuccess(e.getDropSuccess());

   238                 if (++fi < formats.length) {

   239                     leaveFormat(formats[fi]);

   240                 }

   241             }

   242         };

   243 

   244         new DragSource().createDefaultDragGestureRecognizer(frame,

   245                 DnDConstants.ACTION_COPY,

   246                 dge -> dge.startDrag(null, new ImageSelection(image), dsl));

   247         leaveFormat(formats[fi]);

   248     }

   249 

   250 

   251     void notifyTransferSuccess(boolean status) {

   252         passedArray[fi] = status;

   253     }

   254 }

   255 

   256 

   257 class ImageDropTarget extends ImageTransferer {

   258     private final Robot robot;

   259     private static Point startPoint, endPoint = new Point(250, 150);

   260 

   261     ImageDropTarget() throws AWTException {

   262         DropTargetAdapter dropTargetAdapter = new DropTargetAdapter() {

   263             @Override

   264             public void drop(DropTargetDropEvent dtde) {

   265                 checkImage(dtde);

   266                 startImageDrag();

   267             }

   268         };

   269         new DropTarget(frame, dropTargetAdapter);

   270         robot = new Robot();

   271     }

   272 

   273 

   274     void checkImage(DropTargetDropEvent dtde) {

   275         final Transferable t = dtde.getTransferable();

   276         if (t.isDataFlavorSupported(DataFlavor.imageFlavor)) {

   277             dtde.acceptDrop(DnDConstants.ACTION_COPY);

   278             Image im;

   279             try {

   280                 im = (Image) t.getTransferData(DataFlavor.imageFlavor);

   281                 System.err.println("getTransferData was successful");

   282             } catch (Exception e) {

   283                 System.err.println("Can't getTransferData: " + e);

   284                 dtde.dropComplete(false);

   285                 notifyTransferSuccess(false);

   286                 return;

   287             }

   288 

   289             if (im == null) {

   290                 System.err.println("getTransferData returned null");

   291                 dtde.dropComplete(false);

   292                 notifyTransferSuccess(false);

   293             } else if (areImagesIdentical(image, im)) {

   294                 dtde.dropComplete(true);

   295                 notifyTransferSuccess(true);

   296             } else {

   297                 System.err.println("transferred image is different from initial image");

   298                 dtde.dropComplete(false);

   299                 notifyTransferSuccess(false);

   300             }

   301 

   302         } else {

   303             System.err.println("imageFlavor is not supported by Transferable");

   304             dtde.rejectDrop();

   305             notifyTransferSuccess(false);

   306         }

   307     }

   308 

   309     void startImageDrag() {

   310         leaveFormat(formats[fi]);

   311         new Thread(() -> {

   312             try {

   313                 Thread.sleep(1000);

   314             } catch (InterruptedException e) {

   315                 e.printStackTrace();

   316                 // Exit from the child process

   317                 System.exit(1);

   318             }

   319             robot.mouseMove(startPoint.x, startPoint.y);

   320             robot.mousePress(InputEvent.BUTTON1_MASK);

   321             for (Point p = new Point(startPoint); !p.equals(endPoint);

   322                  p.translate(sign(endPoint.x - p.x), sign(endPoint.y - p.y))) {

   323                 robot.mouseMove(p.x, p.y);

   324                 try {

   325                     Thread.sleep(50);

   326                 } catch (InterruptedException e) {

   327                     e.printStackTrace();

   328                 }

   329             }

   330 

   331             robot.mouseRelease(InputEvent.BUTTON1_MASK);

   332         }).start();

   333     }

   334 

   335     void notifyTransferSuccess(boolean status) {

   336         if (status) {

   337             System.err.println("format passed: " + formats[fi]);

   338         } else {

   339             System.err.println("format failed: " + formats[fi]);

   340             System.exit(1);

   341         }

   342         if (fi < formats.length - 1) {

   343             leaveFormat(formats[++fi]);

   344         } else {

   345             new Thread(() -> {

   346                 try {

   347                     Thread.sleep(500);

   348                 } catch (InterruptedException e) {

   349                     e.printStackTrace();

   350                 }

   351                 System.exit(0);

   352             }).start();

   353         }

   354     }

   355 

   356 

   357     public static void main(String[] args) {

   358         try {

   359             ImageDropTarget idt = new ImageDropTarget();

   360 

   361             int x = Integer.parseInt(args[0]);

   362             int y = Integer.parseInt(args[1]);

   363             startPoint = new Point(Integer.parseInt(args[2]), Integer.parseInt(args[3]));

   364 

   365             idt.formats = new String[args.length - 4];

   366             System.arraycopy(args, 4, idt.formats, 0, args.length - 4);

   367             leaveFormat(idt.formats[0]);

   368 

   369             idt.frame.setLocation(x, y);

   370             idt.frame.setVisible(true);

   371             Util.sync();

   372 

   373             idt.startImageDrag();

   374         } catch (Throwable e) {

   375             e.printStackTrace();

   376             System.exit(1);

   377         }

   378     }

   379 

   380 }

   381 

   382 

   383 class ImageSelection implements Transferable {

   384     private static final int IMAGE = 0;

   385     private static final DataFlavor[] flavors = {DataFlavor.imageFlavor};

   386     private Image data;

   387 

   388     public ImageSelection(Image data) {

   389         this.data = data;

   390     }

   391 

   392     @Override

   393     public DataFlavor[] getTransferDataFlavors() {

   394         // returning flavors itself would allow client code to modify

   395         // our internal behavior

   396         return flavors.clone();

   397     }

   398 

   399     @Override

   400     public boolean isDataFlavorSupported(DataFlavor flavor) {

   401         return Stream.of(flavor).anyMatch(flavor::equals);

   402     }

   403 

   404     @Override

   405     public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException {

   406         if (flavor.equals(flavors[IMAGE])) {

   407             return data;

   408         } else {

   409             throw new UnsupportedFlavorException(flavor);

   410         }

   411     }

   412 }