libjava/java/awt/datatransfer/DataFlavor.java

   1 /* DataFlavor.java -- A type of data to transfer via the clipboard.
   2    Copyright (C) 1999, 2001 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package java.awt.datatransfer;
  40
  41 import java.io.ByteArrayInputStream;
  42 import java.io.InputStream;
  43 import java.io.InputStreamReader;
  44 import java.io.IOException;
  45 import java.io.ObjectOutput;
  46 import java.io.ObjectInput;
  47 import java.io.Reader;
  48 import java.io.StringReader;
  49 import java.io.UnsupportedEncodingException;
  50 import java.nio.ByteBuffer;
  51 import java.nio.CharBuffer;
  52
  53 /**
  54  * This class represents a particular data format used for transferring
  55  * data via the clipboard.
  56  *
  57  * @author Aaron M. Renn (arenn@urbanophile.com)
  58  */
  59 public class DataFlavor implements java.io.Externalizable, Cloneable
  60 {
  61   static final long serialVersionUID = 8367026044764648243L;
  62
  63 // FIXME: Serialization: Need to write methods for.
  64
  65 /*
  66  * Static Variables
  67  */
  68
  69 /**
  70  * This is the data flavor used for tranferring plain text.  The MIME
  71  * type is "text/plain; charset=unicode".  The representation class
  72  * is <code>java.io.InputStream</code>.
  73  *
  74  * @deprecated The charset unicode is platform specific and InputStream
  75  * deals with bytes not chars. Use <code>getRederForText()</code>.
  76  */
  77 public static final DataFlavor plainTextFlavor;
  78
  79 /**
  80  * This is the data flavor used for transferring Java strings.  The
  81  * MIME type is "application/x-java-serialized-object" and the
  82  * representation class is <code>java.lang.String</code>.
  83  */
  84 public static final DataFlavor stringFlavor;
  85
  86 /**
  87  * This is a data flavor used for transferring lists of files.  The
  88  * representation type is a <code>java.util.List</code>, with each element of
  89  * the list being a <code>java.io.File</code>.
  90  */
  91 public static final DataFlavor javaFileListFlavor;
  92
  93 public static final DataFlavor imageFlavor;
  94
  95 /**
  96  * This is the MIME type used for transferring a serialized object.
  97  * The representation class is the type of object be deserialized.
  98  */
  99 public static final String javaSerializedObjectMimeType =
 100   "application/x-java-serialized-object";
 101
 102 /**
 103  * This is the MIME type used to transfer a Java object reference within
 104  * the same JVM.  The representation class is the class of the object
 105  * being transferred.
 106  */
 107 public static final String javaJVMLocalObjectMimeType =
 108   "application/x-java-jvm-local-object";
 109
 110 /**
 111  * This is the MIME type used to transfer a link to a remote object.
 112  * The representation class is the type of object being linked to.
 113  */
 114 public static final String javaRemoteObjectMimeType =
 115   "application/x-java-remote-object";
 116
 117 static
 118 {
 119   plainTextFlavor
 120       = new DataFlavor(java.io.InputStream.class,
 121                        "text/plain; charset=unicode",
 122                        "plain unicode text");
 123
 124   stringFlavor
 125       = new DataFlavor(java.lang.String.class,
 126                        "Java Unicode String");
 127
 128   javaFileListFlavor
 129       = new DataFlavor(java.util.List.class,
 130                        "Java File List");
 131
 132   // javaFileListFlavor.mimeType = "application/x-java-file-list";
 133
 134   imageFlavor
 135       = new DataFlavor(java.awt.Image.class,
 136                        "Java Image");
 137 }
 138
 139 /*************************************************************************/
 140
 141 /*
 142  * Instance Variables
 143  */
 144
 145 // The MIME type for this flavor
 146 private final String mimeType;
 147
 148 // The representation class for this flavor
 149 private final Class representationClass;
 150
 151 // The human readable name of this flavor
 152 private String humanPresentableName;
 153
 154 /*************************************************************************/
 155
 156 /*
 157  * Static Methods
 158  */
 159
 160 /**
 161  * This method attempts to load the named class.  The following class
 162  * loaders are searched in order: the bootstrap class loader, the
 163  * system class loader, the context class loader (if it exists), and
 164  * the specified fallback class loader.
 165  *
 166  * @param className The name of the class to load.
 167  * @param classLoader The class loader to use if all others fail, which
 168  * may be <code>null</code>.
 169  *
 170  * @exception ClassNotFoundException If the class cannot be loaded.
 171  */
 172 protected static final Class
 173 tryToLoadClass(String className, ClassLoader classLoader)
 174                throws ClassNotFoundException
 175 {
 176   try
 177     {
 178       return(Class.forName(className));
 179     }
 180   catch(Exception e) { ; }
 181   // Commented out for Java 1.1
 182   /*
 183   try
 184     {
 185       return(className.getClass().getClassLoader().findClass(className));
 186     }
 187   catch(Exception e) { ; }
 188
 189   try
 190     {
 191       return(ClassLoader.getSystemClassLoader().findClass(className));
 192     }
 193   catch(Exception e) { ; }
 194   */
 195
 196   // FIXME: What is the context class loader?
 197   /*
 198   try
 199     {
 200     }
 201   catch(Exception e) { ; }
 202   */
 203
 204   if (classLoader != null)
 205     return(classLoader.loadClass(className));
 206   else
 207     throw new ClassNotFoundException(className);
 208 }
 209
 210 /*************************************************************************/
 211
 212 /*
 213  * Constructors
 214  */
 215
 216 /**
 217  * Empty public constructor needed for externalization.
 218  * Should not be used for normal instantiation.
 219  */
 220 public
 221 DataFlavor()
 222 {
 223     mimeType = null;
 224     representationClass = null;
 225     humanPresentableName = null;
 226 }
 227
 228 /*************************************************************************/
 229
 230 /**
 231  * Private constructor.
 232  */
 233 private
 234 DataFlavor(Class representationClass,
 235            String mimeType,
 236            String humanPresentableName)
 237 {
 238     this.representationClass = representationClass;
 239     this.mimeType = mimeType;
 240     if (humanPresentableName != null)
 241         this.humanPresentableName = humanPresentableName;
 242     else
 243         this.humanPresentableName = mimeType;
 244 }
 245
 246 /*************************************************************************/
 247
 248 /**
 249  * Initializes a new instance of <code>DataFlavor</code>.  The class
 250  * and human readable name are specified, the MIME type will be
 251  * "application/x-java-serialized-object". If the human readable name
 252  * is not specified (<code>null</code>) then the human readable name
 253  * will be the same as the MIME type.
 254  *
 255  * @param representationClass The representation class for this object.
 256  * @param humanPresentableName The display name of the object.
 257  */
 258 public
 259 DataFlavor(Class representationClass, String humanPresentableName)
 260 {
 261     this(representationClass,
 262        "application/x-java-serialized-object"
 263        + "; class="
 264        + representationClass.getName(),
 265        humanPresentableName);
 266 }
 267
 268 /*************************************************************************/
 269
 270 /**
 271  * Initializes a new instance of <code>DataFlavor</code> with the
 272  * specified MIME type and description.  If the MIME type has a
 273  * "class=<rep class>" parameter then the representation class will
 274  * be the class name specified. Otherwise the class defaults to
 275  * <code>java.io.InputStream</code>. If the human readable name
 276  * is not specified (<code>null</code>) then the human readable name
 277  * will be the same as the MIME type.
 278  *
 279  * @param mimeType The MIME type for this flavor.
 280  * @param humanPresentableName The display name of this flavor.
 281  * @param classLoader The class loader for finding classes if the default
 282  * class loaders do not work.
 283  *
 284  * @exception IllegalArgumentException If the representation class
 285  * specified cannot be loaded.
 286  * @exception ClassNotFoundException If the class is not loaded.
 287  */
 288 public
 289 DataFlavor(String mimeType, String humanPresentableName,
 290            ClassLoader classLoader) throws ClassNotFoundException
 291 {
 292   this(getRepresentationClassFromMime(mimeType, classLoader),
 293        mimeType, humanPresentableName);
 294 }
 295
 296 private static Class
 297 getRepresentationClassFromMime(String mimeString, ClassLoader classLoader)
 298 {
 299   String classname = getParameter("class", mimeString);
 300   if (classname != null)
 301     {
 302       try
 303         {
 304           return tryToLoadClass(classname, classLoader);
 305         }
 306       catch(Exception e)
 307         {
 308           throw new IllegalArgumentException("classname: " + e.getMessage());
 309         }
 310     }
 311   else
 312     {
 313       return java.io.InputStream.class;
 314     }
 315 }
 316
 317 /*************************************************************************/
 318
 319 /**
 320  * Initializes a new instance of <code>DataFlavor</code> with the
 321  * specified MIME type and description.  If the MIME type has a
 322  * "class=<rep class>" parameter then the representation class will
 323  * be the class name specified. Otherwise the class defaults to
 324  * <code>java.io.InputStream</code>. If the human readable name
 325  * is not specified (<code>null</code>) then the human readable name
 326  * will be the same as the MIME type. This is the same as calling
 327  * <code>new DataFlavor(mimeType, humanPresentableName, null)</code>.
 328  *
 329  * @param mimeType The MIME type for this flavor.
 330  * @param humanPresentableName The display name of this flavor.
 331  * @param classLoader The class loader for finding classes.
 332  *
 333  * @exception IllegalArgumentException If the representation class
 334  * specified cannot be loaded.
 335  */
 336 public
 337 DataFlavor(String mimeType, String humanPresentableName)
 338 {
 339   this (getRepresentationClassFromMime (mimeType, null), humanPresentableName);
 340 }
 341
 342 /*************************************************************************/
 343
 344 /**
 345  * Initializes a new instance of <code>DataFlavor</code> with the specified
 346  * MIME type.  This type can have a "class=" parameter to specify the
 347  * representation class, and then the class must exist or an exception will
 348  * be thrown. If there is no "class=" parameter then the representation class
 349  * will be <code>java.io.InputStream</code>. This is the same as calling
 350  * <code>new DataFlavor(mimeType, null)</code>.
 351  *
 352  * @param mimeType The MIME type for this flavor.
 353  *
 354  * @exception IllegalArgumentException If a class is not specified in
 355  * the MIME type.
 356  * @exception ClassNotFoundException If the class cannot be loaded.
 357  */
 358 public
 359 DataFlavor(String mimeType) throws ClassNotFoundException
 360 {
 361   this(mimeType, null);
 362 }
 363
 364 /*************************************************************************/
 365
 366 /**
 367  * Returns the MIME type of this flavor.
 368  *
 369  * @return The MIME type for this flavor.
 370  */
 371 public String
 372 getMimeType()
 373 {
 374   return(mimeType);
 375 }
 376
 377 /*************************************************************************/
 378
 379 /**
 380  * Returns the representation class for this flavor.
 381  *
 382  * @return The representation class for this flavor.
 383  */
 384 public Class
 385 getRepresentationClass()
 386 {
 387   return(representationClass);
 388 }
 389
 390 /*************************************************************************/
 391
 392 /**
 393  * Returns the human presentable name for this flavor.
 394  *
 395  * @return The human presentable name for this flavor.
 396  */
 397 public String
 398 getHumanPresentableName()
 399 {
 400   return(humanPresentableName);
 401 }
 402
 403 /*************************************************************************/
 404
 405 /**
 406  * Returns the primary MIME type for this flavor.
 407  *
 408  * @return The primary MIME type for this flavor.
 409  */
 410 public String
 411 getPrimaryType()
 412 {
 413   int idx = mimeType.indexOf("/");
 414   if (idx == -1)
 415     return(mimeType);
 416
 417   return(mimeType.substring(0, idx));
 418 }
 419
 420 /*************************************************************************/
 421
 422 /**
 423  * Returns the MIME subtype for this flavor.
 424  *
 425  * @return The MIME subtype for this flavor.
 426  */
 427 public String
 428 getSubType()
 429 {
 430   int idx = mimeType.indexOf("/");
 431   if (idx == -1)
 432     return("");
 433
 434   String subtype = mimeType.substring(idx + 1);
 435
 436   idx = subtype.indexOf(" ");
 437   if (idx == -1)
 438     return(subtype);
 439   else
 440     return(subtype.substring(0, idx));
 441 }
 442
 443 /*************************************************************************/
 444
 445 /**
 446  * Returns the value of the named MIME type parameter, or <code>null</code>
 447  * if the parameter does not exist. Given the parameter name and the mime
 448  * string.
 449  *
 450  * @param paramName The name of the parameter.
 451  * @param mimeString The mime string from where the name should be found.
 452  *
 453  * @return The value of the parameter or null.
 454  */
 455 private static String
 456 getParameter(String paramName, String mimeString)
 457 {
 458   int idx = mimeString.indexOf(paramName + "=");
 459   if (idx == -1)
 460     return(null);
 461
 462   String value = mimeString.substring(idx + paramName.length() + 1);
 463
 464   idx = value.indexOf(" ");
 465   if (idx == -1)
 466     return(value);
 467   else
 468     return(value.substring(0, idx));
 469 }
 470
 471 /*************************************************************************/
 472
 473 /**
 474  * Returns the value of the named MIME type parameter, or <code>null</code>
 475  * if the parameter does not exist.
 476  *
 477  * @param paramName The name of the paramter.
 478  *
 479  * @return The value of the parameter.
 480  */
 481 public String
 482 getParameter(String paramName)
 483 {
 484   return getParameter(paramName, mimeType);
 485 }
 486
 487 /*************************************************************************/
 488
 489 /**
 490  * Sets the human presentable name to the specified value.
 491  *
 492  * @param humanPresentableName The new display name.
 493  */
 494 public void
 495 setHumanPresentableName(String humanPresentableName)
 496 {
 497   this.humanPresentableName = humanPresentableName;
 498 }
 499
 500 /*************************************************************************/
 501
 502 /**
 503  * Tests the MIME type of this object for equality against the specified
 504  * MIME type.
 505  *
 506  * @param mimeType The MIME type to test against.
 507  *
 508  * @return <code>true</code> if the MIME type is equal to this object's
 509  * MIME type, <code>false</code> otherwise.
 510  *
 511  * @exception NullPointerException If mimeType is null.
 512  */
 513 public boolean
 514 isMimeTypeEqual(String mimeType)
 515 {
 516   // FIXME: Need to handle default attributes and parameters
 517
 518   return(this.mimeType.equals(mimeType));
 519 }
 520
 521 /*************************************************************************/
 522
 523 /**
 524  * Tests the MIME type of this object for equality against the specified
 525  * data flavor's MIME type
 526  *
 527  * @param flavor The flavor to test against.
 528  *
 529  * @return <code>true</code> if the flavor's MIME type is equal to this
 530  * object's MIME type, <code>false</code> otherwise.
 531  */
 532 public boolean
 533 isMimeTypeEqual(DataFlavor flavor)
 534 {
 535   return(isMimeTypeEqual(flavor.getMimeType()));
 536 }
 537
 538 /*************************************************************************/
 539
 540 /**
 541  * Tests whether or not this flavor represents a serialized object.
 542  *
 543  * @return <code>true</code> if this flavor represents a serialized
 544  * object, <code>false</code> otherwise.
 545  */
 546 public boolean
 547 isMimeTypeSerializedObject()
 548 {
 549   return(mimeType.startsWith(javaSerializedObjectMimeType));
 550 }
 551
 552 /*************************************************************************/
 553
 554 /**
 555  * Tests whether or not this flavor has a representation class of
 556  * <code>java.io.InputStream</code>.
 557  *
 558  * @param <code>true</code> if the representation class of this flavor
 559  * is <code>java.io.InputStream</code>, <code>false</code> otherwise.
 560  */
 561 public boolean
 562 isRepresentationClassInputStream()
 563 {
 564   return(representationClass.getName().equals("java.io.InputStream"));
 565 }
 566
 567 /*************************************************************************/
 568
 569 /**
 570  * Tests whether the representation class for this flavor is
 571  * serializable.
 572  *
 573  * @param <code>true</code> if the representation class is serializable,
 574  * <code>false</code> otherwise.
 575  */
 576 public boolean
 577 isRepresentationClassSerializable()
 578 {
 579   Class[] interfaces = representationClass.getInterfaces();
 580
 581   int i = 0;
 582   while (i < interfaces.length)
 583     {
 584       if (interfaces[i].getName().equals("java.io.Serializable"))
 585         return(true);
 586       ++i;
 587     }
 588
 589   return(false);
 590 }
 591
 592 /*************************************************************************/
 593
 594 /**
 595  * Tests whether the representation class for his flavor is remote.
 596  *
 597  * @return <code>true</code> if the representation class is remote,
 598  * <code>false</code> otherwise.
 599  */
 600 public boolean
 601 isRepresentationClassRemote()
 602 {
 603   // FIXME: Implement
 604   throw new RuntimeException("Not implemented");
 605 }
 606
 607 /*************************************************************************/
 608
 609 /**
 610  * Tests whether or not this flavor represents a serialized object.
 611  *
 612  * @return <code>true</code> if this flavor represents a serialized
 613  * object, <code>false</code> otherwise.
 614  */
 615 public boolean
 616 isFlavorSerializedObjectType()
 617 {
 618   // FIXME: What is the diff between this and isMimeTypeSerializedObject?
 619   return(mimeType.startsWith(javaSerializedObjectMimeType));
 620 }
 621
 622 /*************************************************************************/
 623
 624 /**
 625  * Tests whether or not this flavor represents a remote object.
 626  *
 627  * @return <code>true</code> if this flavor represents a remote object,
 628  * <code>false</code> otherwise.
 629  */
 630 public boolean
 631 isFlavorRemoteObjectType()
 632 {
 633   return(mimeType.startsWith(javaRemoteObjectMimeType));
 634 }
 635
 636 /*************************************************************************/
 637
 638 /**
 639  * Tests whether or not this flavor represents a list of files.
 640  *
 641  * @return <code>true</code> if this flavor represents a list of files,
 642  * <code>false</code> otherwise.
 643  */
 644 public boolean
 645 isFlavorJavaFileListType()
 646 {
 647   if (this.mimeType.equals(javaFileListFlavor.mimeType) &&
 648       this.representationClass.equals(javaFileListFlavor.representationClass))
 649     return(true);
 650
 651   return(false);
 652 }
 653
 654 /*************************************************************************/
 655
 656 /**
 657  * Returns a copy of this object.
 658  *
 659  * @return A copy of this object.
 660  *
 661  * @exception CloneNotSupportedException If the object's class does not support
 662  * the Cloneable interface. Subclasses that override the clone method can also
 663  * throw this exception to indicate that an instance cannot be cloned.
 664  */
 665 public Object clone () throws CloneNotSupportedException
 666 {
 667   try
 668     {
 669       return(super.clone());
 670     }
 671   catch(Exception e)
 672     {
 673       return(null);
 674     }
 675 }
 676
 677 /*************************************************************************/
 678
 679 /**
 680  * This method test the specified <code>DataFlavor</code> for equality
 681  * against this object.  This will be true if the MIME type and
 682  * representation type are the equal.
 683  *
 684  * @param flavor The <code>DataFlavor</code> to test against.
 685  *
 686  * @return <code>true</code> if the flavor is equal to this object,
 687  * <code>false</code> otherwise.
 688  */
 689 public boolean
 690 equals(DataFlavor flavor)
 691 {
 692   if (flavor == null)
 693     return(false);
 694
 695   if (!this.mimeType.toLowerCase().equals(flavor.mimeType.toLowerCase()))
 696     return(false);
 697
 698   if (!this.representationClass.equals(flavor.representationClass))
 699     return(false);
 700
 701   return(true);
 702 }
 703
 704 /*************************************************************************/
 705
 706 /**
 707  * This method test the specified <code>Object</code> for equality
 708  * against this object.  This will be true if the following conditions
 709  * are met:
 710  * <p>
 711  * <ul>
 712  * <li>The object is not <code>null</code>.
 713  * <li>The object is an instance of <code>DataFlavor</code>.
 714  * <li>The object's MIME type and representation class are equal to
 715  * this object's.
 716  * </ul>
 717  *
 718  * @param obj The <code>Object</code> to test against.
 719  *
 720  * @return <code>true</code> if the flavor is equal to this object,
 721  * <code>false</code> otherwise.
 722  */
 723 public boolean
 724 equals(Object obj)
 725 {
 726   if (!(obj instanceof DataFlavor))
 727     return(false);
 728
 729   return(equals((DataFlavor)obj));
 730 }
 731
 732 /*************************************************************************/
 733
 734 /**
 735  * Tests whether or not the specified string is equal to the MIME type
 736  * of this object.
 737  *
 738  * @param str The string to test against.
 739  *
 740  * @return <code>true</code> if the string is equal to this object's MIME
 741  * type, <code>false</code> otherwise.
 742  *
 743  * @deprecated Not compatible with <code>hashCode()</code>.
 744  *             Use <code>isMimeTypeEqual()</code>
 745  */
 746 public boolean
 747 equals(String str)
 748 {
 749   return(isMimeTypeEqual(str));
 750 }
 751
 752 /*************************************************************************/
 753
 754 /**
 755  * Returns the hash code for this data flavor.
 756  * The hash code is based on the (lower case) mime type and the
 757  * representation class.
 758  */
 759 public int
 760 hashCode()
 761 {
 762   return(mimeType.toLowerCase().hashCode()^representationClass.hashCode());
 763 }
 764
 765 /*************************************************************************/
 766
 767 /**
 768  * Returns <code>true</code> when the given <code>DataFlavor</code>
 769  * matches this one.
 770  */
 771 public boolean
 772 match(DataFlavor dataFlavor)
 773 {
 774   // XXX - How is this different from equals?
 775   return(equals(dataFlavor));
 776 }
 777
 778 /*************************************************************************/
 779
 780 /**
 781  * This method exists for backward compatibility.  It simply returns
 782  * the same name/value pair passed in.
 783  *
 784  * @param name The parameter name.
 785  * @param value The parameter value.
 786  *
 787  * @return The name/value pair.
 788  *
 789  * @deprecated
 790  */
 791 protected String
 792 normalizeMimeTypeParameter(String name, String value)
 793 {
 794   return(name + "=" + value);
 795 }
 796
 797 /*************************************************************************/
 798
 799 /**
 800  * This method exists for backward compatibility.  It simply returns
 801  * the MIME type string unchanged.
 802  *
 803  * @param type The MIME type.
 804  *
 805  * @return The MIME type.
 806  *
 807  * @deprecated
 808  */
 809 protected String
 810 normalizeMimeType(String type)
 811 {
 812   return(type);
 813 }
 814
 815 /*************************************************************************/
 816
 817 /**
 818  * Serialize this class.
 819  *
 820  * @param stream The <code>ObjectOutput</code> stream to serialize to.
 821  *
 822  * @exception IOException If an error occurs.
 823  */
 824 public void
 825 writeExternal(ObjectOutput stream) throws IOException
 826 {
 827   // FIXME: Implement me
 828 }
 829
 830 /*************************************************************************/
 831
 832 /**
 833  * De-serialize this class.
 834  *
 835  * @param stream The <code>ObjectInput</code> stream to deserialize from.
 836  *
 837  * @exception IOException If an error ocurs.
 838  * @exception ClassNotFoundException If the class for an object being restored
 839  * cannot be found.
 840  */
 841 public void
 842 readExternal(ObjectInput stream) throws IOException, ClassNotFoundException
 843 {
 844   // FIXME: Implement me
 845 }
 846
 847 /*************************************************************************/
 848
 849 /**
 850  * Returns a string representation of this DataFlavor. Including the
 851  * representation class name, MIME type and human presentable name.
 852  */
 853 public String
 854 toString()
 855 {
 856   return("DataFlavor[representationClass="
 857          + representationClass.getName()
 858          + ",mimeType="
 859          + mimeType
 860          + "humanPresentableName="
 861          + humanPresentableName);
 862 }
 863
 864 /*************************************************************************/
 865
 866 /**
 867  * XXX - Currently returns <code>plainTextFlavor</code>.
 868  */
 869 public static final DataFlavor
 870 getTextPlainUnicodeFlavor()
 871 {
 872   return(plainTextFlavor);
 873 }
 874
 875 /*************************************************************************/
 876
 877 /**
 878  * XXX - Currently returns <code>java.io.InputStream</code>.
 879  *
 880  * @since 1.3
 881  */
 882 public final Class
 883 getDefaultRepresentationClass()
 884 {
 885   return(java.io.InputStream.class);
 886 }
 887 /*************************************************************************/
 888
 889 /**
 890  * XXX - Currently returns <code>java.io.InputStream</code>.
 891  */
 892 public final String
 893 getDefaultRepresentationClassAsString()
 894 {
 895   return(getDefaultRepresentationClass().getName());
 896 }
 897
 898 /*************************************************************************/
 899
 900 /**
 901  * Selects the best supported text flavor on this implementation.
 902  * Returns <code>null</code> when none of the given flavors is liked.
 903  *
 904  * The <code>DataFlavor</code> returned the first data flavor in the
 905  * array that has either a representation class which is (a subclass of)
 906  * <code>Reader</code> or <code>String</code>, or has a representation
 907  * class which is (a subclass of) <code>InputStream</code> and has a
 908  * primary MIME type of "text" and has an supported encoding.
 909  */
 910 public static final DataFlavor
 911 selectBestTextFlavor(DataFlavor[] availableFlavors)
 912 {
 913   for(int i=0; i<availableFlavors.length; i++)
 914     {
 915       DataFlavor df = availableFlavors[i];
 916       Class c = df.representationClass;
 917
 918       // A Reader or String is good.
 919       if ((Reader.class.isAssignableFrom(c))
 920           || (String.class.isAssignableFrom(c)))
 921         {
 922           return df;
 923         }
 924
 925       // A InputStream is good if the mime primary type is "text"
 926       if ((InputStream.class.isAssignableFrom(c))
 927           && ("text".equals(df.getPrimaryType())))
 928         {
 929           String encoding = availableFlavors[i].getParameter("charset");
 930           if (encoding == null)
 931             encoding = "us-ascii";
 932           Reader r = null;
 933           try
 934             {
 935               // Try to construct a dummy reader with the found encoding
 936               r = new InputStreamReader
 937                     (new ByteArrayInputStream(new byte[0]), encoding);
 938             }
 939           catch(UnsupportedEncodingException uee) { /* ignore */ }
 940           if (r != null)
 941             return df;
 942         }
 943     }
 944
 945   // Nothing found
 946   return(null);
 947 }
 948
 949 /*************************************************************************/
 950
 951 /**
 952  * Creates a <code>Reader</code> for a given <code>Transferable</code>.
 953  *
 954  * If the representation class is a (subclass of) <code>Reader</code>
 955  * then an instance of the representation class is returned. If the
 956  * representatation class is a <code>String</code> then a
 957  * <code>StringReader</code> is returned. And if the representation class
 958  * is a (subclass of) <code>InputStream</code> and the primary MIME type
 959  * is "text" then a <code>InputStreamReader</code> for the correct charset
 960  * encoding is returned.
 961  *
 962  * @param transferable The <code>Transferable</code> for which a text
 963  *                     <code>Reader</code> is requested.
 964  *
 965  * @exception IllegalArgumentException If the representation class is not one
 966  * of the seven listed above or the Transferable has null data.
 967  * @exception NullPointerException If the Transferable is null.
 968  * @exception UnsupportedFlavorException when the transferable doesn't
 969  * support this <code>DataFlavor</code>. Or if the representable class
 970  * isn't a (subclass of) <code>Reader</code>, <code>String</code>,
 971  * <code>InputStream</code> and/or the primary MIME type isn't "text".
 972  * @exception IOException when any IOException occurs.
 973  * @exception UnsupportedEncodingException if the "charset" isn't supported
 974  * on this platform.
 975  */
 976 public Reader getReaderForText(Transferable transferable)
 977   throws UnsupportedFlavorException, IOException
 978 {
 979     if (!transferable.isDataFlavorSupported(this))
 980         throw new UnsupportedFlavorException(this);
 981
 982     if (Reader.class.isAssignableFrom(representationClass))
 983         return((Reader)transferable.getTransferData(this));
 984
 985     if (String.class.isAssignableFrom(representationClass))
 986         return(new StringReader((String)transferable.getTransferData(this)));
 987
 988     if (InputStream.class.isAssignableFrom(representationClass)
 989         && "text".equals(getPrimaryType()))
 990       {
 991         InputStream in = (InputStream)transferable.getTransferData(this);
 992         String encoding = getParameter("charset");
 993         if (encoding == null)
 994             encoding = "us-ascii";
 995         return(new InputStreamReader(in, encoding));
 996       }
 997
 998     throw new UnsupportedFlavorException(this);
 999 }
1000
1001   /**
1002    * Returns whether the representation class for this DataFlavor is
1003    * @see java.nio.ByteBuffer or a subclass thereof.
1004    *
1005    * @since 1.4
1006    */
1007   public boolean isRepresentationClassByteBuffer ()
1008   {
1009     return ByteBuffer.class.isAssignableFrom (representationClass);
1010   }
1011
1012   /**
1013    * Returns whether the representation class for this DataFlavor is
1014    * @see java.nio.CharBuffer or a subclass thereof.
1015    *
1016    * @since 1.4
1017    */
1018   public boolean isRepresentationClassCharBuffer ()
1019   {
1020     return CharBuffer.class.isAssignableFrom (representationClass);
1021   }
1022
1023   /**
1024    * Returns whether the representation class for this DataFlavor is
1025    * @see java.io.Reader or a subclass thereof.
1026    *
1027    * @since 1.4
1028    */
1029   public boolean isRepresentationClassReader ()
1030   {
1031     return Reader.class.isAssignableFrom (representationClass);
1032   }
1033
1034 } // class DataFlavor
1035