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