1 /*
2 * Copyright (c) 2003, 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. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package sun.awt.X11;
27
28 import java.awt.Image;
29
30 import java.awt.datatransfer.DataFlavor;
31 import java.awt.datatransfer.Transferable;
32 import java.awt.datatransfer.UnsupportedFlavorException;
33
34 import java.awt.image.BufferedImage;
35 import java.awt.image.ColorModel;
36 import java.awt.image.WritableRaster;
37
38 import java.io.BufferedReader;
39 import java.io.InputStream;
40 import java.io.InputStreamReader;
41 import java.io.IOException;
42
43 import java.net.URI;
44 import java.net.URISyntaxException;
45
46 import java.util.ArrayList;
47 import java.util.Iterator;
48 import java.util.LinkedHashSet;
49 import java.util.List;
50
51 import javax.imageio.ImageIO;
52 import javax.imageio.ImageReader;
53 import javax.imageio.ImageTypeSpecifier;
54 import javax.imageio.ImageWriter;
55 import javax.imageio.spi.ImageWriterSpi;
56
57 import sun.awt.datatransfer.DataTransferer;
58 import sun.awt.datatransfer.ToolkitThreadBlockedHandler;
59
60 import java.io.ByteArrayOutputStream;
61 import java.util.stream.Stream;
62
63 /**
64 * Platform-specific support for the data transfer subsystem.
65 */
66 public class XDataTransferer extends DataTransferer {
67 static final XAtom FILE_NAME_ATOM = XAtom.get("FILE_NAME");
68 static final XAtom DT_NET_FILE_ATOM = XAtom.get("_DT_NETFILE");
69 static final XAtom PNG_ATOM = XAtom.get("PNG");
70 static final XAtom JFIF_ATOM = XAtom.get("JFIF");
71 static final XAtom TARGETS_ATOM = XAtom.get("TARGETS");
72 static final XAtom INCR_ATOM = XAtom.get("INCR");
73 static final XAtom MULTIPLE_ATOM = XAtom.get("MULTIPLE");
74
75 /**
76 * Singleton constructor
77 */
78 private XDataTransferer() {
79 }
80
81 private static XDataTransferer transferer;
82
83 static synchronized XDataTransferer getInstanceImpl() {
84 if (transferer == null) {
85 transferer = new XDataTransferer();
86 }
87 return transferer;
88 }
89
90 public String getDefaultUnicodeEncoding() {
91 return "iso-10646-ucs-2";
92 }
93
94 public boolean isLocaleDependentTextFormat(long format) {
95 return false;
96 }
97
98 public boolean isTextFormat(long format) {
99 return super.isTextFormat(format)
100 || isMimeFormat(format, "text");
101 }
102
103 protected String getCharsetForTextFormat(Long lFormat) {
104 long format = lFormat.longValue();
105 if (isMimeFormat(format, "text")) {
106 String nat = getNativeForFormat(format);
107 DataFlavor df = new DataFlavor(nat, null);
108 // Ignore the charset parameter of the MIME type if the subtype
109 // doesn't support charset.
110 if (!DataTransferer.doesSubtypeSupportCharset(df)) {
111 return null;
112 }
113 String charset = df.getParameter("charset");
114 if (charset != null) {
115 return charset;
116 }
117 }
118 return super.getCharsetForTextFormat(lFormat);
119 }
120
121 protected boolean isURIListFormat(long format) {
122 String nat = getNativeForFormat(format);
123 if (nat == null) {
124 return false;
125 }
126 try {
127 DataFlavor df = new DataFlavor(nat);
128 if (df.getPrimaryType().equals("text") && df.getSubType().equals("uri-list")) {
129 return true;
130 }
131 } catch (Exception e) {
132 // Not a MIME format.
133 }
134 return false;
135 }
136
137 public boolean isFileFormat(long format) {
138 return format == FILE_NAME_ATOM.getAtom() ||
139 format == DT_NET_FILE_ATOM.getAtom();
140 }
141
142 public boolean isImageFormat(long format) {
143 return format == PNG_ATOM.getAtom() ||
144 format == JFIF_ATOM.getAtom() ||
145 isMimeFormat(format, "image");
146 }
147
148 protected Long getFormatForNativeAsLong(String str) {
149 // Just get the atom. If it has already been retrived
150 // once, we'll get a copy so this should be very fast.
151 long atom = XAtom.get(str).getAtom();
152 return Long.valueOf(atom);
153 }
154
155 protected String getNativeForFormat(long format) {
156 return getTargetNameForAtom(format);
157 }
158
159 public ToolkitThreadBlockedHandler getToolkitThreadBlockedHandler() {
160 return XToolkitThreadBlockedHandler.getToolkitThreadBlockedHandler();
161 }
162
163 /**
164 * Gets an format name for a given format (atom)
165 */
166 private String getTargetNameForAtom(long atom) {
167 return XAtom.get(atom).getName();
168 }
169
170 protected byte[] imageToPlatformBytes(Image image, long format)
171 throws IOException {
172 String mimeType = null;
173 if (format == PNG_ATOM.getAtom()) {
174 mimeType = "image/png";
175 } else if (format == JFIF_ATOM.getAtom()) {
176 mimeType = "image/jpeg";
177 } else {
178 // Check if an image MIME format.
179 try {
180 String nat = getNativeForFormat(format);
181 DataFlavor df = new DataFlavor(nat);
182 String primaryType = df.getPrimaryType();
183 if ("image".equals(primaryType)) {
184 mimeType = df.getPrimaryType() + "/" + df.getSubType();
185 }
186 } catch (Exception e) {
187 // Not an image MIME format.
188 }
189 }
190 if (mimeType != null) {
191 return imageToStandardBytes(image, mimeType);
192 } else {
193 String nativeFormat = getNativeForFormat(format);
194 throw new IOException("Translation to " + nativeFormat +
195 " is not supported.");
196 }
197 }
198
199 protected ByteArrayOutputStream convertFileListToBytes(ArrayList<String> fileList)
200 throws IOException
201 {
202 ByteArrayOutputStream bos = new ByteArrayOutputStream();
203 for (int i = 0; i < fileList.size(); i++)
204 {
205 byte[] bytes = fileList.get(i).getBytes();
206 if (i != 0) bos.write(0);
207 bos.write(bytes, 0, bytes.length);
208 }
209 return bos;
210 }
211
212 /**
213 * Translates either a byte array or an input stream which contain
214 * platform-specific image data in the given format into an Image.
215 */
216 protected Image platformImageBytesToImage(
217 byte[] bytes, long format) throws IOException
218 {
219 String mimeType = null;
220 if (format == PNG_ATOM.getAtom()) {
221 mimeType = "image/png";
222 } else if (format == JFIF_ATOM.getAtom()) {
223 mimeType = "image/jpeg";
224 } else {
225 // Check if an image MIME format.
226 try {
227 String nat = getNativeForFormat(format);
228 DataFlavor df = new DataFlavor(nat);
229 String primaryType = df.getPrimaryType();
230 if ("image".equals(primaryType)) {
231 mimeType = df.getPrimaryType() + "/" + df.getSubType();
232 }
233 } catch (Exception e) {
234 // Not an image MIME format.
235 }
236 }
237 if (mimeType != null) {
238 return standardImageBytesToImage(bytes, mimeType);
239 } else {
240 String nativeFormat = getNativeForFormat(format);
241 throw new IOException("Translation from " + nativeFormat +
242 " is not supported.");
243 }
244 }
245
246 @Override
247 protected String[] dragQueryFile(byte[] bytes) {
248 XToolkit.awtLock();
249 try {
250 return XlibWrapper.XTextPropertyToStringList(bytes,
251 XAtom.get("STRING").getAtom());
252 } finally {
253 XToolkit.awtUnlock();
254 }
255 }
256
257 @Override
258 protected URI[] dragQueryURIs(InputStream stream,
259 long format,
260 Transferable localeTransferable)
261 throws IOException {
262
263 String charset = getBestCharsetForTextFormat(format, localeTransferable);
264 try (InputStreamReader isr = new InputStreamReader(stream, charset);
265 BufferedReader reader = new BufferedReader(isr)) {
266 String line;
267 ArrayList<URI> uriList = new ArrayList<>();
268 URI uri;
269 while ((line = reader.readLine()) != null) {
270 try {
271 uri = new URI(line);
272 } catch (URISyntaxException uriSyntaxException) {
273 throw new IOException(uriSyntaxException);
274 }
275 uriList.add(uri);
276 }
277 return uriList.toArray(new URI[uriList.size()]);
278 }
279 }
280
281 /**
282 * Returns true if and only if the name of the specified format Atom
283 * constitutes a valid MIME type with the specified primary type.
284 */
285 private boolean isMimeFormat(long format, String primaryType) {
286 String nat = getNativeForFormat(format);
287
288 if (nat == null) {
289 return false;
290 }
291
292 try {
293 DataFlavor df = new DataFlavor(nat);
294 if (primaryType.equals(df.getPrimaryType())) {
295 return true;
296 }
297 } catch (Exception e) {
298 // Not a MIME format.
299 }
300
301 return false;
302 }
303
304 /*
305 * The XDnD protocol prescribes that the Atoms used as targets for data
306 * transfer should have string names that represent the corresponding MIME
307 * types.
308 * To meet this requirement we check if the passed native format constitutes
309 * a valid MIME and return a list of flavors to which the data in this MIME
310 * type can be translated by the Data Transfer subsystem.
311 */
312 @Override
313 public LinkedHashSet<DataFlavor> getPlatformMappingsForNative(String nat) {
314 LinkedHashSet<DataFlavor> flavors = new LinkedHashSet<>();
315
316 if (nat == null) {
317 return flavors;
318 }
319
320 DataFlavor df = null;
321
322 try {
323 df = new DataFlavor(nat);
324 } catch (Exception e) {
325 // The string doesn't constitute a valid MIME type.
326 return flavors;
327 }
328
329 DataFlavor value = df;
330 final String primaryType = df.getPrimaryType();
331 final String baseType = primaryType + "/" + df.getSubType();
332
333 // For text formats we map natives to MIME strings instead of data
334 // flavors to enable dynamic text native-to-flavor mapping generation.
335 // See SystemFlavorMap.getFlavorsForNative() for details.
336 if ("image".equals(primaryType)) {
337 Iterator<ImageReader> readers = ImageIO.getImageReadersByMIMEType(baseType);
338 if (readers.hasNext()) {
339 flavors.add(DataFlavor.imageFlavor);
340 }
341 }
342
343 flavors.add(value);
344
345 return flavors;
346 }
347
348 private static ImageTypeSpecifier defaultSpecifier = null;
349
350 private ImageTypeSpecifier getDefaultImageTypeSpecifier() {
351 if (defaultSpecifier == null) {
352 ColorModel model = ColorModel.getRGBdefault();
353 WritableRaster raster =
354 model.createCompatibleWritableRaster(10, 10);
355
356 BufferedImage bufferedImage =
357 new BufferedImage(model, raster, model.isAlphaPremultiplied(),
358 null);
359
360 defaultSpecifier = new ImageTypeSpecifier(bufferedImage);
361 }
362
363 return defaultSpecifier;
364 }
365
366 /*
367 * The XDnD protocol prescribes that the Atoms used as targets for data
368 * transfer should have string names that represent the corresponding MIME
369 * types.
370 * To meet this requirement we return a list of formats that represent
371 * MIME types to which the data in this flavor can be translated by the Data
372 * Transfer subsystem.
373 */
374 @Override
375 public LinkedHashSet<String> getPlatformMappingsForFlavor(DataFlavor df) {
376 LinkedHashSet<String> natives = new LinkedHashSet<>(1);
377
378 if (df == null) {
379 return natives;
380 }
381
382 String charset = df.getParameter("charset");
383 String baseType = df.getPrimaryType() + "/" + df.getSubType();
384 String mimeType = baseType;
385
386 if (charset != null && DataTransferer.isFlavorCharsetTextType(df)) {
387 mimeType += ";charset=" + charset;
388 }
389
390 // Add a mapping to the MIME native whenever the representation class
391 // doesn't require translation.
392 if (df.getRepresentationClass() != null &&
393 (df.isRepresentationClassInputStream() ||
394 df.isRepresentationClassByteBuffer() ||
395 byte[].class.equals(df.getRepresentationClass()))) {
396 natives.add(mimeType);
397 }
398
399 if (DataFlavor.imageFlavor.equals(df)) {
400 String[] mimeTypes = ImageIO.getWriterMIMETypes();
401 if (mimeTypes != null) {
402 for (String mime : mimeTypes) {
403 Iterator<ImageWriter> writers = ImageIO.getImageWritersByMIMEType(mime);
404 while (writers.hasNext()) {
405 ImageWriter imageWriter = writers.next();
406 ImageWriterSpi writerSpi = imageWriter.getOriginatingProvider();
407
408 if (writerSpi != null &&
409 writerSpi.canEncodeImage(getDefaultImageTypeSpecifier())) {
410 natives.add(mime);
411 break;
412 }
413 }
414 }
415 }
416 } else if (DataTransferer.isFlavorCharsetTextType(df)) {
417 // stringFlavor is semantically equivalent to the standard
418 // "text/plain" MIME type.
419 if (DataFlavor.stringFlavor.equals(df)) {
420 baseType = "text/plain";
421 }
422
423 for (String encoding : DataTransferer.standardEncodings()) {
424 if (!encoding.equals(charset)) {
425 natives.add(baseType + ";charset=" + encoding);
426 }
427 }
428
429 // Add a MIME format without specified charset.
430 if (!natives.contains(baseType)) {
431 natives.add(baseType);
432 }
433 }
434
435 return natives;
436 }
437 }