1. /*

  2.  * @(#)SynthTransferable.java	1.2 03/01/23

  3.  *

  4.  * Copyright 2003 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. 

  8. package com.sun.java.swing.plaf.gtk;

  9. 

  10. import java.io.*;

  11. import java.awt.datatransfer.*;

  12. import javax.swing.plaf.UIResource;

  13. 

  14. /**

  15.  * A transferable implementation for the default data transfer of some Swing

  16.  * components.  

  17.  *

  18.  * @author  Shannon Hickey

  19.  * @version 1.2 01/23/03 (based on revision 1.7 of BasicTransferable)

  20.  */

  21. class SynthTransferable implements Transferable, UIResource {

  22.     

  23.     protected String plainData;

  24.     protected String htmlData;

  25. 

  26.     private static DataFlavor[] htmlFlavors;

  27.     private static DataFlavor[] stringFlavors;

  28.     private static DataFlavor[] plainFlavors;

  29. 

  30.     static {

  31. 	try {

  32. 	    htmlFlavors = new DataFlavor[3];

  33. 	    htmlFlavors[0] = new DataFlavor("text/html;class=java.lang.String");

  34. 	    htmlFlavors[1] = new DataFlavor("text/html;class=java.io.Reader");

  35. 	    htmlFlavors[2] = new DataFlavor("text/html;charset=unicode;class=java.io.InputStream");

  36. 

  37. 	    plainFlavors = new DataFlavor[3];

  38. 	    plainFlavors[0] = new DataFlavor("text/plain;class=java.lang.String");

  39. 	    plainFlavors[1] = new DataFlavor("text/plain;class=java.io.Reader");

  40. 	    plainFlavors[2] = new DataFlavor("text/plain;charset=unicode;class=java.io.InputStream");

  41. 

  42. 	    stringFlavors = new DataFlavor[2];

  43.             stringFlavors[0] = new DataFlavor(DataFlavor.javaJVMLocalObjectMimeType+";class=java.lang.String");

  44. 	    stringFlavors[1] = DataFlavor.stringFlavor;

  45.  

  46. 	} catch (ClassNotFoundException cle) {

  47. 	    System.err.println("error initializing javax.swing.plaf.basic.BasicTranserable");

  48. 	}

  49.     }

  50.     

  51.     public SynthTransferable(String plainData, String htmlData) {

  52. 	this.plainData = plainData;

  53. 	this.htmlData = htmlData;

  54.     }

  55. 

  56. 

  57.     /**

  58.      * Returns an array of DataFlavor objects indicating the flavors the data 

  59.      * can be provided in.  The array should be ordered according to preference

  60.      * for providing the data (from most richly descriptive to least descriptive).

  61.      * @return an array of data flavors in which this data can be transferred

  62.      */

  63.     public DataFlavor[] getTransferDataFlavors() {

  64. 	DataFlavor[] richerFlavors = getRicherFlavors();

  65. 	int nRicher = (richerFlavors != null) ? richerFlavors.length : 0;

  66. 	int nHTML = (isHTMLSupported()) ? htmlFlavors.length : 0;

  67. 	int nPlain = (isPlainSupported()) ? plainFlavors.length: 0;

  68. 	int nString = (isPlainSupported()) ? stringFlavors.length : 0;

  69. 	int nFlavors = nRicher + nHTML + nPlain + nString;

  70. 	DataFlavor[] flavors = new DataFlavor[nFlavors];

  71. 	

  72. 	// fill in the array

  73. 	int nDone = 0;

  74. 	if (nRicher > 0) {

  75. 	    System.arraycopy(richerFlavors, 0, flavors, nDone, nRicher);

  76. 	    nDone += nRicher;

  77. 	}

  78. 	if (nHTML > 0) {

  79. 	    System.arraycopy(htmlFlavors, 0, flavors, nDone, nHTML);

  80. 	    nDone += nHTML;

  81. 	}

  82. 	if (nPlain > 0) {

  83. 	    System.arraycopy(plainFlavors, 0, flavors, nDone, nPlain);

  84. 	    nDone += nPlain;

  85. 	}

  86. 	if (nString > 0) {

  87. 	    System.arraycopy(stringFlavors, 0, flavors, nDone, nString);

  88. 	    nDone += nString;

  89. 	}

  90. 	return flavors;

  91.     }

  92. 

  93.     /**

  94.      * Returns whether or not the specified data flavor is supported for

  95.      * this object.

  96.      * @param flavor the requested flavor for the data

  97.      * @return boolean indicating whether or not the data flavor is supported

  98.      */

  99.     public boolean isDataFlavorSupported(DataFlavor flavor) {

  100. 	DataFlavor[] flavors = getTransferDataFlavors();

  101.         for (int i = 0; i < flavors.length; i++) {

  102. 	    if (flavors[i].equals(flavor)) {

  103. 	        return true;

  104. 	    }

  105. 	}

  106. 	return false;

  107.     }

  108. 

  109.     /**

  110.      * Returns an object which represents the data to be transferred.  The class 

  111.      * of the object returned is defined by the representation class of the flavor.

  112.      *

  113.      * @param flavor the requested flavor for the data

  114.      * @see DataFlavor#getRepresentationClass

  115.      * @exception IOException                if the data is no longer available

  116.      *              in the requested flavor.

  117.      * @exception UnsupportedFlavorException if the requested data flavor is

  118.      *              not supported.

  119.      */

  120.     public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {

  121. 	DataFlavor[] richerFlavors = getRicherFlavors();

  122. 	if (isRicherFlavor(flavor)) {

  123. 	    return getRicherData(flavor);

  124. 	} else if (isHTMLFlavor(flavor)) {

  125. 	    String data = getHTMLData();

  126. 	    data = (data == null) ? "" : data;

  127. 	    if (String.class.equals(flavor.getRepresentationClass())) {

  128. 		return data;

  129. 	    } else if (Reader.class.equals(flavor.getRepresentationClass())) {

  130. 		return new StringReader(data);

  131. 	    } else if (InputStream.class.equals(flavor.getRepresentationClass())) {

  132. 		return new StringBufferInputStream(data);

  133. 	    }

  134. 	    // fall through to unsupported

  135. 	} else if (isPlainFlavor(flavor)) {

  136. 	    String data = getPlainData();

  137. 	    data = (data == null) ? "" : data;

  138. 	    if (String.class.equals(flavor.getRepresentationClass())) {

  139. 		return data;

  140. 	    } else if (Reader.class.equals(flavor.getRepresentationClass())) {

  141. 		return new StringReader(data);

  142. 	    } else if (InputStream.class.equals(flavor.getRepresentationClass())) {

  143. 		return new StringBufferInputStream(data);

  144. 	    }

  145. 	    // fall through to unsupported

  146. 

  147. 	} else if (isStringFlavor(flavor)) {

  148. 	    String data = getPlainData();

  149. 	    data = (data == null) ? "" : data;

  150. 	    return data;

  151. 	}

  152. 	throw new UnsupportedFlavorException(flavor);

  153.     }

  154. 

  155.     // --- richer subclass flavors ----------------------------------------------

  156. 

  157.     protected boolean isRicherFlavor(DataFlavor flavor) {

  158. 	DataFlavor[] richerFlavors = getRicherFlavors();

  159. 	int nFlavors = (richerFlavors != null) ? richerFlavors.length : 0;

  160. 	for (int i = 0; i < nFlavors; i++) {

  161. 	    if (richerFlavors[i].equals(flavor)) {

  162. 		return true;

  163. 	    }

  164. 	}

  165. 	return false;

  166.     }

  167. 	

  168.     /** 

  169.      * Some subclasses will have flavors that are more descriptive than HTML

  170.      * or plain text.  If this method returns a non-null value, it will be

  171.      * placed at the start of the array of supported flavors.

  172.      */

  173.     protected DataFlavor[] getRicherFlavors() {

  174. 	return null;

  175.     }

  176. 

  177.     protected Object getRicherData(DataFlavor flavor) throws UnsupportedFlavorException {

  178. 	return null;

  179.     }

  180. 

  181.     // --- html flavors ----------------------------------------------------------

  182. 

  183.     /**

  184.      * Returns whether or not the specified data flavor is an HTML flavor that

  185.      * is supported.

  186.      * @param flavor the requested flavor for the data

  187.      * @return boolean indicating whether or not the data flavor is supported

  188.      */

  189.     protected boolean isHTMLFlavor(DataFlavor flavor) {

  190. 	DataFlavor[] flavors = htmlFlavors;

  191.         for (int i = 0; i < flavors.length; i++) {

  192. 	    if (flavors[i].equals(flavor)) {

  193. 	        return true;

  194. 	    }

  195. 	}

  196. 	return false;

  197.     }

  198. 

  199.     /**

  200.      * Should the HTML flavors be offered?  If so, the method

  201.      * getHTMLData should be implemented to provide something reasonable.

  202.      */

  203.     protected boolean isHTMLSupported() {

  204. 	return htmlData != null;

  205.     }

  206. 

  207.     /**

  208.      * Fetch the data in a text/html format

  209.      */

  210.     protected String getHTMLData() {

  211. 	return htmlData;

  212.     }

  213. 

  214.     // --- plain text flavors ----------------------------------------------------

  215. 

  216.     /**

  217.      * Returns whether or not the specified data flavor is an plain flavor that

  218.      * is supported.

  219.      * @param flavor the requested flavor for the data

  220.      * @return boolean indicating whether or not the data flavor is supported

  221.      */

  222.     protected boolean isPlainFlavor(DataFlavor flavor) {

  223. 	DataFlavor[] flavors = plainFlavors;

  224.         for (int i = 0; i < flavors.length; i++) {

  225. 	    if (flavors[i].equals(flavor)) {

  226. 	        return true;

  227. 	    }

  228. 	}

  229. 	return false;

  230.     }

  231. 

  232.     /**

  233.      * Should the plain text flavors be offered?  If so, the method

  234.      * getPlainData should be implemented to provide something reasonable.

  235.      */

  236.     protected boolean isPlainSupported() {

  237. 	return plainData != null;

  238.     }

  239. 

  240.     /**

  241.      * Fetch the data in a text/plain format.

  242.      */

  243.     protected String getPlainData() {

  244. 	return plainData;

  245.     }

  246. 

  247.     // --- string flavorss --------------------------------------------------------

  248. 

  249.     /**

  250.      * Returns whether or not the specified data flavor is a String flavor that

  251.      * is supported.

  252.      * @param flavor the requested flavor for the data

  253.      * @return boolean indicating whether or not the data flavor is supported

  254.      */

  255.     protected boolean isStringFlavor(DataFlavor flavor) {

  256. 	DataFlavor[] flavors = stringFlavors;

  257.         for (int i = 0; i < flavors.length; i++) {

  258. 	    if (flavors[i].equals(flavor)) {

  259. 	        return true;

  260. 	    }

  261. 	}

  262. 	return false;

  263.     }

  264. 

  265. 

  266. }