src/java/net/sf/jabref/external/ExternalFileType.java

   1 package net.sf.jabref.external;
   2
   3 import javax.swing.*;
   4
   5 import net.sf.jabref.GUIGlobals;
   6
   7 /**
   8  * This class defines a type of external files that can be linked to from JabRef.
   9  * The class contains enough information to provide an icon, a standard extension
  10  * and a link to which application handles files of this type.
  11  */
  12 public class ExternalFileType implements Comparable<ExternalFileType> {
  13
  14     protected String name, extension, openWith, iconName;
  15     protected ImageIcon icon;
  16     protected JLabel label = new JLabel();
  17
  18     public ExternalFileType(String name, String extension, String openWith,
  19                             String iconName) {
  20         label.setText(null);
  21         this.name = name;
  22         label.setToolTipText(this.name);
  23         this.extension = extension;
  24         this.openWith = openWith;
  25         setIconName(iconName);
  26     }
  27
  28     /**
  29      * Construct an ExternalFileType from a String array. This constructor is used when
  30      * reading file type definitions from Preferences, where the available data types are
  31      * limited. We assume that the array contains the same values as the main constructor,
  32      * in the same order.
  33      *
  34      * TODO: The icon argument needs special treatment. At the moment, we assume that the fourth
  35      * element of the array contains the icon keyword to be looked up in the current icon theme.
  36      * To support icons found elsewhere on the file system we simply need to prefix the icon name
  37      * with a marker.
  38      *
  39      * @param val Constructor arguments.
  40      */
  41     public ExternalFileType(String[] val) {
  42         if ((val == null) || (val.length < 4))
  43             throw new IllegalArgumentException("Cannot contruct ExternalFileType without four elements in String[] argument.");
  44         this.name = val[0];
  45         label.setToolTipText(this.name);
  46         this.extension = val[1];
  47         this.openWith = val[2];
  48         label.setText(null);
  49         setIconName(val[3]);
  50     }
  51
  52     /**
  53      * Return a String array representing this file type. This is used for storage into
  54      * Preferences, and the same array can be used to construct the file type later,
  55      * using the String[] constructor.
  56      *
  57      * @return A String[] containing all information about this file type.
  58      */
  59     public String[] getStringArrayRepresentation() {
  60         return new String[] {name, extension, openWith, iconName};
  61     }
  62
  63     public String getName() {
  64         return name;
  65     }
  66
  67     public void setName(String name) {
  68         this.name = name;
  69         label.setToolTipText(this.name);
  70     }
  71
  72     public String getExtension() {
  73         return extension;
  74     }
  75
  76     public void setExtension(String extension) {
  77         this.extension = extension;
  78     }
  79
  80     /**
  81      * Get the bibtex field name used to extension to this file type.
  82      * Currently we assume that field name equals filename extension.
  83      * @return The field name.
  84      */
  85     public String getFieldName() {
  86         return extension;
  87     }
  88
  89     public String getOpenWith() {
  90         return openWith;
  91     }
  92
  93     public void setOpenWith(String openWith) {
  94         this.openWith = openWith;
  95     }
  96
  97     /**
  98      * Set the string associated with this file type's icon. The string is used
  99      * to get the actual icon by the method GUIGlobals.getIcon(String)
 100      * @param name The icon name to use.
 101      */
 102     public void setIconName(String name) {
 103         this.iconName = name;
 104         try {
 105             this.icon = GUIGlobals.getImage(iconName);
 106         } catch (NullPointerException ex) {
 107             // Loading the icon failed. This could be because the icons have not been
 108             // initialized, which will be the case if we are operating from the command
 109             // line and the graphical interface hasn't been initialized. In that case
 110             // we will do without the icon:
 111             this.icon = null;
 112         }
 113         label.setIcon(this.icon);
 114     }
 115
 116     /**
 117      * Obtain a JLabel instance set with this file type's icon. The same JLabel
 118      * is returned from each call of this method.
 119      * @return the label.
 120      */
 121     public JLabel getIconLabel() {
 122         return label;
 123     }
 124
 125     /**
 126      * Get the string associated with this file type's icon. The string is used
 127      * to get the actual icon by the method GUIGlobals.getIcon(String)
 128      * @return The icon name.
 129      */
 130     public String getIconName() {
 131         return iconName;
 132     }
 133
 134     public ImageIcon getIcon() {
 135         return icon;
 136     }
 137
 138     public void setIcon(ImageIcon icon) {
 139         this.icon = icon;
 140     }
 141
 142     public String toString() {
 143         return getName();
 144     }
 145
 146     public int compareTo(ExternalFileType o) {
 147         return getName().compareTo(o.getName());
 148     }
 149
 150     public ExternalFileType copy() {
 151         return new ExternalFileType(name, extension, openWith, iconName);
 152     }
 153
 154
 155     public int hashCode() {
 156         return name.hashCode();
 157     }
 158
 159     /**
 160      * We define two file type objects as equal if their name, extension, openWith and
 161      * iconName are equal.
 162      *
 163      * @param object The file type to compare with.
 164      * @return true if the file types are equal.
 165      */
 166     public boolean equals(Object object) {
 167         ExternalFileType other = (ExternalFileType)object;
 168         if (other == null)
 169             return false;
 170         return (name == null ? other.name == null : name.equals(other.name))
 171                 && (extension == null ? other.extension == null : extension.equals(other.extension))
 172                 && (openWith== null ? other.openWith == null : openWith.equals(other.openWith))
 173                 && (iconName== null ? other.iconName == null : iconName.equals(other.iconName));
 174     }
 175 }