home *** CD-ROM | disk | FTP | other *** search
/ S283 Planetary Science &n…he Search for Life DVD 2 / DVD-ROM.iso / install / jre1_3 / lib / rt.jar / java / awt / datatransfer / DataFlavor.class (.txt) < prev    next >
Encoding:
Java Class File  |  1979-12-31  |  10.0 KB  |  553 lines
  1. package java.awt.datatransfer;
  2.  
  3. import java.awt.Toolkit;
  4. import java.io.ByteArrayInputStream;
  5. import java.io.Externalizable;
  6. import java.io.IOException;
  7. import java.io.InputStream;
  8. import java.io.InputStreamReader;
  9. import java.io.ObjectInput;
  10. import java.io.ObjectOutput;
  11. import java.io.Reader;
  12. import java.io.UnsupportedEncodingException;
  13. import java.security.AccessController;
  14. import sun.awt.SunToolkit;
  15.  
  16. public class DataFlavor implements Externalizable, Cloneable {
  17.    static final long serialVersionUID = 8367026044764648243L;
  18.    static final Class ioInputStreamClass;
  19.    public static final DataFlavor stringFlavor;
  20.    public static final DataFlavor plainTextFlavor;
  21.    public static final String javaSerializedObjectMimeType = "application/x-java-serialized-object";
  22.    public static final DataFlavor javaFileListFlavor;
  23.    public static final String javaJVMLocalObjectMimeType = "application/x-java-jvm-local-objectref";
  24.    public static final String javaRemoteObjectMimeType = "application/x-java-remote-object";
  25.    transient int atom;
  26.    MimeType mimeType;
  27.    private static String[] knownEncodings;
  28.    private String humanPresentableName;
  29.    private Class representationClass;
  30.    // $FF: synthetic field
  31.    static Class class$java$io$InputStream;
  32.    // $FF: synthetic field
  33.    static Class class$java$lang$String;
  34.    // $FF: synthetic field
  35.    static Class class$java$io$Serializable;
  36.    // $FF: synthetic field
  37.    static Class class$java$rmi$Remote;
  38.    // $FF: synthetic field
  39.    static Class class$java$util$List;
  40.  
  41.    protected static final Class tryToLoadClass(String var0, ClassLoader var1) throws ClassNotFoundException {
  42.       ClassLoader var2 = (ClassLoader)AccessController.doPrivileged(new 1());
  43.  
  44.       try {
  45.          return Class.forName(var0, true, var2);
  46.       } catch (ClassNotFoundException var4) {
  47.          if (var1 != null) {
  48.             return Class.forName(var0, true, var1);
  49.          } else {
  50.             throw new ClassNotFoundException(var0);
  51.          }
  52.       }
  53.    }
  54.  
  55.    private static DataFlavor createConstant(Class var0, String var1) {
  56.       try {
  57.          return new DataFlavor(var0, var1);
  58.       } catch (Exception var3) {
  59.          return null;
  60.       }
  61.    }
  62.  
  63.    private static DataFlavor createConstant(String var0, String var1) {
  64.       try {
  65.          return new DataFlavor(var0, var1);
  66.       } catch (Exception var3) {
  67.          return null;
  68.       }
  69.    }
  70.  
  71.    public DataFlavor() {
  72.    }
  73.  
  74.    DataFlavor(DataFlavor var1) {
  75.       this.mimeType = null;
  76.       if (var1.mimeType != null) {
  77.          try {
  78.             this.mimeType = (MimeType)var1.mimeType.clone();
  79.          } catch (CloneNotSupportedException var3) {
  80.          }
  81.       }
  82.  
  83.       this.representationClass = var1.representationClass;
  84.       this.humanPresentableName = var1.humanPresentableName;
  85.       this.atom = var1.atom;
  86.    }
  87.  
  88.    private DataFlavor(String var1, String var2, MimeTypeParameterList var3, Class var4, String var5) {
  89.       if (var3 == null) {
  90.          var3 = new MimeTypeParameterList();
  91.       }
  92.  
  93.       var3.set("class", var4.getName());
  94.       if (var5 == null) {
  95.          var5 = var3.get("humanPresentableName");
  96.          if (var5 == null) {
  97.             var5 = var1 + "/" + var2;
  98.          }
  99.       }
  100.  
  101.       try {
  102.          this.mimeType = new MimeType(var1, var2, var3);
  103.       } catch (MimeTypeParseException var7) {
  104.          throw new IllegalArgumentException("MimeType Parse Exception: " + ((Throwable)var7).getMessage());
  105.       }
  106.  
  107.       this.representationClass = var4;
  108.       this.humanPresentableName = var5;
  109.       this.mimeType.removeParameter("humanPresentableName");
  110.    }
  111.  
  112.    public DataFlavor(Class var1, String var2) {
  113.       this("application", "x-java-serialized-object", (MimeTypeParameterList)null, var1, var2);
  114.    }
  115.  
  116.    public DataFlavor(String var1, String var2) {
  117.       try {
  118.          this.initialize(var1, var2, this.getClass().getClassLoader());
  119.       } catch (MimeTypeParseException var5) {
  120.          throw new IllegalArgumentException("failed to parse:" + var1);
  121.       } catch (ClassNotFoundException var6) {
  122.          throw new IllegalArgumentException("cant find specified class: " + ((Throwable)var6).getMessage());
  123.       }
  124.    }
  125.  
  126.    public DataFlavor(String var1, String var2, ClassLoader var3) throws ClassNotFoundException {
  127.       try {
  128.          this.initialize(var1, var2, var3);
  129.       } catch (MimeTypeParseException var5) {
  130.          throw new IllegalArgumentException("failed to parse:" + var1);
  131.       }
  132.    }
  133.  
  134.    public DataFlavor(String var1) throws ClassNotFoundException {
  135.       try {
  136.          this.initialize(var1, (String)null, this.getClass().getClassLoader());
  137.       } catch (MimeTypeParseException var3) {
  138.          throw new IllegalArgumentException("failed to parse:" + var1);
  139.       }
  140.    }
  141.  
  142.    private void initialize(String var1, String var2, ClassLoader var3) throws MimeTypeParseException, ClassNotFoundException {
  143.       this.mimeType = new MimeType(var1);
  144.       String var4 = this.getParameter("class");
  145.       if (var4 == null) {
  146.          if ("application/x-java-serialized-object".equals(this.mimeType.getBaseType())) {
  147.             throw new IllegalArgumentException("no representation class specified for:" + var1);
  148.          }
  149.  
  150.          this.representationClass = class$java$io$InputStream == null ? (class$java$io$InputStream = class$("java.io.InputStream")) : class$java$io$InputStream;
  151.       } else {
  152.          this.representationClass = tryToLoadClass(var4, var3);
  153.       }
  154.  
  155.       this.mimeType.setParameter("class", this.representationClass.getName());
  156.       if (var2 == null) {
  157.          var2 = this.mimeType.getParameter("humanPresentableName");
  158.          if (var2 == null) {
  159.             var2 = this.mimeType.getPrimaryType() + "/" + this.mimeType.getSubType();
  160.          }
  161.       }
  162.  
  163.       this.humanPresentableName = var2;
  164.       this.mimeType.removeParameter("humanPresentableName");
  165.    }
  166.  
  167.    private DataFlavor(MimeType var1, Class var2, String var3, int var4) {
  168.       this.mimeType = var1;
  169.       this.representationClass = var2;
  170.       this.humanPresentableName = var3;
  171.       this.atom = var4;
  172.    }
  173.  
  174.    public String toString() {
  175.       String var1 = this.getClass().getName();
  176.       var1 = var1 + "[" + this.paramString() + "]";
  177.       return var1;
  178.    }
  179.  
  180.    private String paramString() {
  181.       String var1 = "";
  182.       var1 = var1 + "representationclass=";
  183.       if (this.representationClass == null) {
  184.          var1 = var1 + "null";
  185.       } else {
  186.          var1 = var1 + this.representationClass.getName();
  187.       }
  188.  
  189.       var1 = var1 + ";mimetype=";
  190.       if (this.mimeType == null) {
  191.          var1 = var1 + "null";
  192.       } else {
  193.          var1 = var1 + this.mimeType.getBaseType();
  194.       }
  195.  
  196.       return var1;
  197.    }
  198.  
  199.    public static final DataFlavor getTextPlainUnicodeFlavor() {
  200.       Toolkit var0 = Toolkit.getDefaultToolkit();
  201.       Object var1 = null;
  202.       String var2 = null;
  203.       if (var0 instanceof SunToolkit) {
  204.          var2 = ((SunToolkit)var0).getDefaultUnicodeEncoding();
  205.       }
  206.  
  207.       return new DataFlavor("text/plain; charset=" + var2 + "; class=java.io.InputStream", "Plain Text");
  208.    }
  209.  
  210.    public static final DataFlavor selectBestTextFlavor(DataFlavor[] var0) {
  211.       if (var0 == null) {
  212.          return null;
  213.       } else {
  214.          DataFlavor var1 = null;
  215.  
  216.          for(int var2 = 0; var1 == null && var2 < var0.length; ++var2) {
  217.             DataFlavor var3 = var0[var2];
  218.             if (var3.match(stringFlavor)) {
  219.                var1 = var3;
  220.             } else {
  221.                String var4 = var3.getPrimaryType();
  222.                if (var4 != null && "text".equals(var4)) {
  223.                   String var5 = var3.getParameter("charset");
  224.                   if (var5 == null) {
  225.                      var1 = var3;
  226.                   } else if (encodingIsSupported(var5)) {
  227.                      var1 = var3;
  228.                   }
  229.                }
  230.             }
  231.          }
  232.  
  233.          return var1;
  234.       }
  235.    }
  236.  
  237.    public Reader getReaderForText(Transferable var1) throws UnsupportedFlavorException, IOException {
  238.       Object var2 = var1.getTransferData(this);
  239.       if (var2 == null) {
  240.          throw new IllegalArgumentException("getTransferData() returned null");
  241.       } else {
  242.          boolean var3 = var2 instanceof String;
  243.          boolean var4 = var2 instanceof InputStream;
  244.          boolean var5 = var2 instanceof Reader;
  245.          if (!var3 && !var4 && !var5) {
  246.             throw new IllegalArgumentException("transfer data is not InputStream or String or Reader");
  247.          } else {
  248.             String var6 = this.getParameter("charset");
  249.             Object var7 = null;
  250.             if (var4) {
  251.                var7 = (InputStream)var2;
  252.             } else if (var3) {
  253.                if (var6 == null) {
  254.                   var7 = new ByteArrayInputStream(((String)var2).getBytes());
  255.                } else {
  256.                   var7 = new ByteArrayInputStream(((String)var2).getBytes(var6));
  257.                }
  258.             }
  259.  
  260.             Object var8 = null;
  261.             if (var5) {
  262.                var8 = (Reader)var2;
  263.             } else if (var6 == null) {
  264.                var8 = new InputStreamReader((InputStream)var7);
  265.             } else {
  266.                var8 = new InputStreamReader((InputStream)var7, var6);
  267.             }
  268.  
  269.             return (Reader)var8;
  270.          }
  271.       }
  272.    }
  273.  
  274.    public String getMimeType() {
  275.       return this.mimeType.toString();
  276.    }
  277.  
  278.    public Class getRepresentationClass() {
  279.       return this.representationClass;
  280.    }
  281.  
  282.    public String getHumanPresentableName() {
  283.       return this.humanPresentableName;
  284.    }
  285.  
  286.    public String getPrimaryType() {
  287.       return this.mimeType.getPrimaryType();
  288.    }
  289.  
  290.    public String getSubType() {
  291.       return this.mimeType.getSubType();
  292.    }
  293.  
  294.    public String getParameter(String var1) {
  295.       return var1.equals("humanPresentableName") ? this.humanPresentableName : this.mimeType.getParameter(var1);
  296.    }
  297.  
  298.    public void setHumanPresentableName(String var1) {
  299.       this.humanPresentableName = var1;
  300.    }
  301.  
  302.    public boolean equals(Object var1) {
  303.       return var1 instanceof DataFlavor && this.equals((DataFlavor)var1);
  304.    }
  305.  
  306.    public boolean equals(DataFlavor var1) {
  307.       if (var1 == null) {
  308.          return false;
  309.       } else if (this == var1) {
  310.          return true;
  311.       } else {
  312.          if (this.representationClass == null) {
  313.             if (var1.getRepresentationClass() != null) {
  314.                return false;
  315.             }
  316.          } else if (!this.representationClass.equals(var1.getRepresentationClass())) {
  317.             return false;
  318.          }
  319.  
  320.          if (this.mimeType == null) {
  321.             if (var1.mimeType != null) {
  322.                return false;
  323.             }
  324.          } else if (!this.mimeType.match(var1.mimeType)) {
  325.             return false;
  326.          }
  327.  
  328.          if ("text".equals(this.getPrimaryType())) {
  329.             String var2 = this.getTextCharset();
  330.             String var3 = var1.getTextCharset();
  331.             if (var2 == null) {
  332.                if (var3 != null) {
  333.                   return false;
  334.                }
  335.             } else if (!var2.equals(var3)) {
  336.                return false;
  337.             }
  338.          }
  339.  
  340.          return true;
  341.       }
  342.    }
  343.  
  344.    public boolean equals(String var1) {
  345.       return var1 != null && this.mimeType != null ? this.isMimeTypeEqual(var1) : false;
  346.    }
  347.  
  348.    public int hashCode() {
  349.       int var1 = 0;
  350.       int var2 = 0;
  351.       int var3 = 0;
  352.       if (this.representationClass != null) {
  353.          var1 = this.representationClass.hashCode();
  354.       }
  355.  
  356.       if (this.mimeType != null) {
  357.          String var4 = this.mimeType.getPrimaryType();
  358.          if (var4 != null) {
  359.             var2 = var4.hashCode();
  360.             if ("text".equals(var4)) {
  361.                String var5 = this.getTextCharset();
  362.                if (var5 != null) {
  363.                   var3 = var5.hashCode();
  364.                }
  365.             }
  366.          }
  367.       }
  368.  
  369.       int var6 = var1 + var2 + var3;
  370.       return var6 != 0 ? var6 : 25431009;
  371.    }
  372.  
  373.    public boolean match(DataFlavor var1) {
  374.       if (var1 == null) {
  375.          return false;
  376.       } else if (this.mimeType != null && var1.mimeType != null) {
  377.          String var2 = this.getPrimaryType();
  378.          String var3 = var1.getPrimaryType();
  379.          if (var2 != null && var3 != null && var2.equals(var3)) {
  380.             String var4 = this.getSubType();
  381.             String var5 = var1.getSubType();
  382.             if (var4 != null && var5 != null && var4.equals(var5)) {
  383.                Class var6 = this.getRepresentationClass();
  384.                Class var7 = var1.getRepresentationClass();
  385.                if (var6 != null && var7 != null && var6.equals(var7)) {
  386.                   if (var2.equals("text")) {
  387.                      String var8 = this.getTextCharset();
  388.                      String var9 = var1.getTextCharset();
  389.                      if (var8 == null || var9 == null || !var8.equals(var9)) {
  390.                         return false;
  391.                      }
  392.                   }
  393.  
  394.                   return true;
  395.                } else {
  396.                   return false;
  397.                }
  398.             } else {
  399.                return false;
  400.             }
  401.          } else {
  402.             return false;
  403.          }
  404.       } else {
  405.          return false;
  406.       }
  407.    }
  408.  
  409.    public boolean isMimeTypeEqual(String var1) {
  410.       if (this.mimeType != null && var1 != null) {
  411.          try {
  412.             return this.mimeType.match(new MimeType(var1));
  413.          } catch (MimeTypeParseException var3) {
  414.             return false;
  415.          }
  416.       } else {
  417.          return false;
  418.       }
  419.    }
  420.  
  421.    public final boolean isMimeTypeEqual(DataFlavor var1) {
  422.       return this.isMimeTypeEqual(var1.mimeType);
  423.    }
  424.  
  425.    private boolean isMimeTypeEqual(MimeType var1) {
  426.       return this.mimeType.match(var1);
  427.    }
  428.  
  429.    public boolean isMimeTypeSerializedObject() {
  430.       return this.isMimeTypeEqual("application/x-java-serialized-object");
  431.    }
  432.  
  433.    public final Class getDefaultRepresentationClass() {
  434.       return ioInputStreamClass;
  435.    }
  436.  
  437.    public final String getDefaultRepresentationClassAsString() {
  438.       return this.getDefaultRepresentationClass().getName();
  439.    }
  440.  
  441.    public boolean isRepresentationClassInputStream() {
  442.       return ioInputStreamClass.isAssignableFrom(this.representationClass);
  443.    }
  444.  
  445.    public boolean isRepresentationClassSerializable() {
  446.       return (class$java$io$Serializable == null ? (class$java$io$Serializable = class$("java.io.Serializable")) : class$java$io$Serializable).isAssignableFrom(this.representationClass);
  447.    }
  448.  
  449.    public boolean isRepresentationClassRemote() {
  450.       return (class$java$rmi$Remote == null ? (class$java$rmi$Remote = class$("java.rmi.Remote")) : class$java$rmi$Remote).isAssignableFrom(this.representationClass);
  451.    }
  452.  
  453.    public boolean isFlavorSerializedObjectType() {
  454.       return this.isRepresentationClassSerializable() && this.isMimeTypeEqual("application/x-java-serialized-object");
  455.    }
  456.  
  457.    public boolean isFlavorRemoteObjectType() {
  458.       return this.isRepresentationClassRemote() && this.isRepresentationClassSerializable() && this.isMimeTypeEqual("application/x-java-remote-object");
  459.    }
  460.  
  461.    public boolean isFlavorJavaFileListType() {
  462.       if (this.mimeType != null && this.representationClass != null) {
  463.          return (class$java$util$List == null ? (class$java$util$List = class$("java.util.List")) : class$java$util$List).isAssignableFrom(this.representationClass) && this.mimeType.match(javaFileListFlavor.mimeType);
  464.       } else {
  465.          return false;
  466.       }
  467.    }
  468.  
  469.    public synchronized void writeExternal(ObjectOutput var1) throws IOException {
  470.       this.mimeType.setParameter("humanPresentableName", this.humanPresentableName);
  471.       var1.writeObject(this.mimeType);
  472.       this.mimeType.removeParameter("humanPresentableName");
  473.    }
  474.  
  475.    public synchronized void readExternal(ObjectInput var1) throws IOException, ClassNotFoundException {
  476.       this.mimeType = (MimeType)var1.readObject();
  477.       this.humanPresentableName = this.mimeType.getParameter("humanPresentableName");
  478.       this.mimeType.removeParameter("humanPresentableName");
  479.       String var2 = this.mimeType.getParameter("class");
  480.       if (var2 == null) {
  481.          throw new IOException("no class parameter specified in: " + this.mimeType);
  482.       } else {
  483.          this.representationClass = tryToLoadClass(var2, this.getClass().getClassLoader());
  484.       }
  485.    }
  486.  
  487.    public Object clone() throws CloneNotSupportedException {
  488.       DataFlavor var1 = new DataFlavor(this);
  489.       return var1;
  490.    }
  491.  
  492.    protected String normalizeMimeTypeParameter(String var1, String var2) {
  493.       return var2;
  494.    }
  495.  
  496.    protected String normalizeMimeType(String var1) {
  497.       return var1;
  498.    }
  499.  
  500.    private String getTextCharset() {
  501.       String var1 = null;
  502.       if ("text".equals(this.getPrimaryType())) {
  503.          var1 = this.getParameter("charset");
  504.          if (var1 == null) {
  505.             Toolkit var2 = Toolkit.getDefaultToolkit();
  506.             if (var2 instanceof SunToolkit) {
  507.                var1 = ((SunToolkit)var2).getDefaultCharacterEncoding();
  508.             }
  509.          }
  510.       }
  511.  
  512.       return var1;
  513.    }
  514.  
  515.    private static boolean encodingIsSupported(String var0) {
  516.       boolean var1 = false;
  517.       boolean var2 = false;
  518.  
  519.       for(int var5 = 0; !var1 && var5 < knownEncodings.length; ++var5) {
  520.          if (knownEncodings[var5].equals(var0)) {
  521.             var1 = true;
  522.          }
  523.       }
  524.  
  525.       if (!var1) {
  526.          try {
  527.             "abc".getBytes(var0);
  528.             var1 = true;
  529.          } catch (UnsupportedEncodingException var4) {
  530.          }
  531.       }
  532.  
  533.       return var1;
  534.    }
  535.  
  536.    // $FF: synthetic method
  537.    static Class class$(String var0) {
  538.       try {
  539.          return Class.forName(var0);
  540.       } catch (ClassNotFoundException var2) {
  541.          throw new NoClassDefFoundError(((Throwable)var2).getMessage());
  542.       }
  543.    }
  544.  
  545.    static {
  546.       ioInputStreamClass = class$java$io$InputStream == null ? (class$java$io$InputStream = class$("java.io.InputStream")) : class$java$io$InputStream;
  547.       stringFlavor = createConstant(class$java$lang$String == null ? (class$java$lang$String = class$("java.lang.String")) : class$java$lang$String, "Unicode String");
  548.       plainTextFlavor = createConstant("text/plain; charset=unicode; class=java.io.InputStream", "Plain Text");
  549.       javaFileListFlavor = createConstant((String)"application/x-java-file-list;class=java.util.List", (String)null);
  550.       knownEncodings = new String[]{"iso8859-1", "us-ascii"};
  551.    }
  552. }
  553.