/** * Look up the external file type registered for this MIME type, if any. * * @param mimeType The MIME type. * @return The ExternalFileType registered, or null if none. */ public ExternalFileType getExternalFileTypeByMimeType(String mimeType) { for (Iterator<ExternalFileType> iterator = externalFileTypes.iterator(); iterator.hasNext(); ) { ExternalFileType type = iterator.next(); if ((type.getMimeType() != null) && type.getMimeType().equals(mimeType)) return type; } return null; }
/** * Look up the external file type registered with this name, if any. * * @param name The file type name. * @return The ExternalFileType registered, or null if none. */ public ExternalFileType getExternalFileTypeByName(String name) { for (Iterator<ExternalFileType> iterator = externalFileTypes.iterator(); iterator.hasNext(); ) { ExternalFileType type = iterator.next(); if (type.getName().equals(name)) return type; } // Return an instance that signifies an unknown file type: return new UnknownExternalFileType(name); }
/** * Look up the external file type registered for this extension, if any. * * @param extension The file extension. * @return The ExternalFileType registered, or null if none. */ public ExternalFileType getExternalFileTypeByExt(String extension) { for (Iterator<ExternalFileType> iterator = externalFileTypes.iterator(); iterator.hasNext(); ) { ExternalFileType type = iterator.next(); if ((type.getExtension() != null) && type.getExtension().equalsIgnoreCase(extension)) return type; } return null; }
/** * Convenience menthod for findPDF. Searches for a file of the given type. * * @param entry The BibtexEntry to search for a link for. * @param fileType The file type to search for. * @return The link to the file found, or null if not found. */ public static String findFile( BibtexEntry entry, ExternalFileType fileType, List<String> extraDirs) { List<String> dirs = new ArrayList<String>(); dirs.addAll(extraDirs); if (Globals.prefs.hasKey(fileType.getExtension() + "Directory")) { dirs.add(Globals.prefs.get(fileType.getExtension() + "Directory")); } String[] directories = dirs.toArray(new String[dirs.size()]); return UtilFindFiles.findPdf(entry, fileType.getExtension(), directories); }
/** * Reset the List of external file types after user customization. * * @param types The new List of external file types. This is the complete list, not just new * entries. */ public void setExternalFileTypes(List<ExternalFileType> types) { // First find a list of the default types: List<ExternalFileType> defTypes = getDefaultExternalFileTypes(); // Make a list of types that are unchanged: List<ExternalFileType> unchanged = new ArrayList<ExternalFileType>(); externalFileTypes.clear(); for (Iterator<ExternalFileType> iterator = types.iterator(); iterator.hasNext(); ) { ExternalFileType type = iterator.next(); externalFileTypes.add(type); // See if we can find a type with matching name in the default type list: ExternalFileType found = null; for (ExternalFileType defType : defTypes) { if (defType.getName().equals(type.getName())) { found = defType; break; } } if (found != null) { // Found it! Check if it is an exact match, or if it has been customized: if (found.equals(type)) unchanged.add(type); else { // It was modified. Remove its entry from the defaults list, since // the type hasn't been removed: defTypes.remove(found); } } } // Go through unchanged types. Remove them from the ones that should be stored, // and from the list of defaults, since we don't need to mention these in prefs: for (ExternalFileType type : unchanged) { defTypes.remove(type); types.remove(type); } // Now set up the array to write to prefs, containing all new types, all modified // types, and a flag denoting each default type that has been removed: String[][] array = new String[types.size() + defTypes.size()][]; int i = 0; for (ExternalFileType type : types) { array[i] = type.getStringArrayRepresentation(); i++; } for (ExternalFileType type : defTypes) { array[i] = new String[] {type.getName(), FILE_TYPE_REMOVED_FLAG}; i++; } // System.out.println("Encoded: '"+Util.encodeStringArray(array)+"'"); put("externalFileTypes", Util.encodeStringArray(array)); }
public List<ExternalFileType> getDefaultExternalFileTypes() { List<ExternalFileType> list = new ArrayList<ExternalFileType>(); list.add(new ExternalFileType("PDF", "pdf", "application/pdf", "evince", "pdfSmall")); list.add( new ExternalFileType("PostScript", "ps", "application/postscript", "evince", "psSmall")); list.add(new ExternalFileType("Word", "doc", "application/msword", "oowriter", "openoffice")); list.add( new ExternalFileType( "OpenDocument text", "odt", "application/vnd.oasis.opendocument.text", "oowriter", "openoffice")); list.add(new ExternalFileType("Excel", "xls", "application/excel", "oocalc", "openoffice")); list.add( new ExternalFileType( "OpenDocument spreadsheet", "ods", "application/vnd.oasis.opendocument.spreadsheet", "oocalc", "openoffice")); list.add(new ExternalFileType("PowerPoint", "ppt", "", "ooimpress", "openoffice")); list.add( new ExternalFileType( "OpenDocument presentation", "odp", "application/vnd.oasis.opendocument.presentation", "ooimpress", "openoffice")); list.add( new ExternalFileType( "Rich Text Format", "rtf", "application/rtf", "oowriter", "openoffice")); list.add(new ExternalFileType("PNG image", "png", "image/png", "gimp", "picture")); list.add(new ExternalFileType("GIF image", "gif", "image/gif", "gimp", "picture")); list.add(new ExternalFileType("JPG image", "jpg", "image/jpeg", "gimp", "picture")); list.add(new ExternalFileType("Djvu", "djvu", "", "evince", "psSmall")); list.add(new ExternalFileType("Text", "txt", "text/plain", "emacs", "emacs")); list.add(new ExternalFileType("LaTeX", "tex", "", "emacs", "emacs")); list.add(new ExternalFileType("CHM", "chm", "", "gnochm", "www")); list.add(new ExternalFileType("TIFF image", "tiff", "image/tiff", "gimp", "picture")); ExternalFileType tp = new ExternalFileType("URL", "html", "text/html", "firefox", "www"); list.add(tp); // On all OSes there is a generic application available to handle file opening, // so we don't need the default application settings anymore: for (Iterator<ExternalFileType> iterator = list.iterator(); iterator.hasNext(); ) { ExternalFileType type = iterator.next(); type.setOpenWith(""); } return list; }
/** * Set up the list of external file types, either from default values, or from values recorded in * Preferences. */ public void updateExternalFileTypes() { // First get a list of the default file types as a starting point: List<ExternalFileType> types = getDefaultExternalFileTypes(); // If no changes have been stored, simply use the defaults: if (prefs.get("externalFileTypes", null) == null) { externalFileTypes.clear(); externalFileTypes.addAll(types); return; } // Read the prefs information for file types: String[][] vals = Util.decodeStringDoubleArray(prefs.get("externalFileTypes", "")); for (int i = 0; i < vals.length; i++) { if ((vals[i].length == 2) && (vals[i][1].equals(FILE_TYPE_REMOVED_FLAG))) { // This entry indicates that a default entry type should be removed: ExternalFileType toRemove = null; for (ExternalFileType type : types) { if (type.getName().equals(vals[i][0])) { toRemove = type; break; } } // If we found it, remove it from the type list: if (toRemove != null) types.remove(toRemove); } else { // A new or modified entry type. Construct it from the string array: ExternalFileType type = new ExternalFileType(vals[i]); // Check if there is a default type with the same name. If so, this is a // modification of that type, so remove the default one: ExternalFileType toRemove = null; for (ExternalFileType defType : types) { if (type.getName().equals(defType.getName())) { toRemove = defType; break; } } // If we found it, remove it from the type list: if (toRemove != null) { types.remove(toRemove); } // Then add the new one: types.add(type); } } // Finally, build the list of types based on the modified defaults list: for (ExternalFileType type : types) { externalFileTypes.add(type); } }