source: josm/trunk/src/org/openstreetmap/josm/actions/ExtensionFileFilter.java@ 7392

Last change on this file since 7392 was 7369, checked in by Don-vip, 10 years ago

robustness to strange JAI configuration error occuring in unit tests when initializing ExtensionFileFilter
  • Property svn:eol-style set to native
File size: 13.6 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.actions;
3
4import java.io.File;
5import java.util.ArrayList;
6import java.util.Collections;
7import java.util.Comparator;
8import java.util.LinkedList;
9import java.util.List;
10import java.util.ServiceConfigurationError;
11
12import javax.swing.JFileChooser;
13import javax.swing.filechooser.FileFilter;
14
15import org.openstreetmap.josm.Main;
16import org.openstreetmap.josm.gui.MapView;
17import org.openstreetmap.josm.io.AllFormatsImporter;
18import org.openstreetmap.josm.io.FileExporter;
19import org.openstreetmap.josm.io.FileImporter;
20
21/**
22 * A file filter that filters after the extension. Also includes a list of file
23 * filters used in JOSM.
24 * @since 32
25 */
26public class ExtensionFileFilter extends FileFilter implements java.io.FileFilter {
27
28 /**
29 * List of supported formats for import.
30 * @since 4869
31 */
32 public static final ArrayList<FileImporter> importers;
33
34 /**
35 * List of supported formats for export.
36 * @since 4869
37 */
38 public static final ArrayList<FileExporter> exporters;
39
40 // add some file types only if the relevant classes are there.
41 // this gives us the option to painlessly drop them from the .jar
42 // and build JOSM versions without support for these formats
43
44 static {
45
46 importers = new ArrayList<>();
47
48 String[] importerNames = {
49 "org.openstreetmap.josm.io.OsmImporter",
50 "org.openstreetmap.josm.io.OsmGzipImporter",
51 "org.openstreetmap.josm.io.OsmZipImporter",
52 "org.openstreetmap.josm.io.OsmChangeImporter",
53 "org.openstreetmap.josm.io.GpxImporter",
54 "org.openstreetmap.josm.io.NMEAImporter",
55 "org.openstreetmap.josm.io.OsmBzip2Importer",
56 "org.openstreetmap.josm.io.JpgImporter",
57 "org.openstreetmap.josm.io.WMSLayerImporter",
58 "org.openstreetmap.josm.io.AllFormatsImporter",
59 "org.openstreetmap.josm.io.session.SessionImporter"
60 };
61
62 for (String classname : importerNames) {
63 try {
64 FileImporter importer = (FileImporter) Class.forName(classname).newInstance();
65 importers.add(importer);
66 MapView.addLayerChangeListener(importer);
67 } catch (Exception e) {
68 if (Main.isDebugEnabled()) {
69 Main.debug(e.getMessage());
70 }
71 } catch (ServiceConfigurationError e) {
72 // error seen while initializing WMSLayerImporter in plugin unit tests:
73 // -
74 // ServiceConfigurationError: javax.imageio.spi.ImageWriterSpi:
75 // Provider com.sun.media.imageioimpl.plugins.jpeg.CLibJPEGImageWriterSpi could not be instantiated
76 // Caused by: java.lang.IllegalArgumentException: vendorName == null!
77 // at javax.imageio.spi.IIOServiceProvider.<init>(IIOServiceProvider.java:76)
78 // at javax.imageio.spi.ImageReaderWriterSpi.<init>(ImageReaderWriterSpi.java:231)
79 // at javax.imageio.spi.ImageWriterSpi.<init>(ImageWriterSpi.java:213)
80 // at com.sun.media.imageioimpl.plugins.jpeg.CLibJPEGImageWriterSpi.<init>(CLibJPEGImageWriterSpi.java:84)
81 // -
82 // This is a very strange behaviour of JAI:
83 // http://thierrywasyl.wordpress.com/2009/07/24/jai-how-to-solve-vendorname-null-exception/
84 // -
85 // that can lead to various problems, see #8583 comments
86 Main.error(e);
87 }
88 }
89
90 exporters = new ArrayList<>();
91
92 String[] exporterNames = {
93 "org.openstreetmap.josm.io.GpxExporter",
94 "org.openstreetmap.josm.io.OsmExporter",
95 "org.openstreetmap.josm.io.OsmGzipExporter",
96 "org.openstreetmap.josm.io.OsmBzip2Exporter",
97 "org.openstreetmap.josm.io.GeoJSONExporter",
98 "org.openstreetmap.josm.io.WMSLayerExporter"
99 };
100
101 for (String classname : exporterNames) {
102 try {
103 FileExporter exporter = (FileExporter)Class.forName(classname).newInstance();
104 exporters.add(exporter);
105 MapView.addLayerChangeListener(exporter);
106 } catch (Exception e) {
107 if (Main.isDebugEnabled()) {
108 Main.debug(e.getMessage());
109 }
110 } catch (ServiceConfigurationError e) {
111 // see above in importers initialization
112 Main.error(e);
113 }
114 }
115 }
116
117 private final String extensions;
118 private final String description;
119 private final String defaultExtension;
120
121 protected static void sort(List<ExtensionFileFilter> filters) {
122 Collections.sort(
123 filters,
124 new Comparator<ExtensionFileFilter>() {
125 private AllFormatsImporter all = new AllFormatsImporter();
126 @Override
127 public int compare(ExtensionFileFilter o1, ExtensionFileFilter o2) {
128 if (o1.getDescription().equals(all.filter.getDescription())) return 1;
129 if (o2.getDescription().equals(all.filter.getDescription())) return -1;
130 return o1.getDescription().compareTo(o2.getDescription());
131 }
132 }
133 );
134 }
135
136 /**
137 * Updates the {@link AllFormatsImporter} that is contained in the importers list. If
138 * you do not use the importers variable directly, you don’t need to call this.
139 * <p>
140 * Updating the AllFormatsImporter is required when plugins add new importers that
141 * support new file extensions. The old AllFormatsImporter doesn’t include the new
142 * extensions and thus will not display these files.
143 *
144 * @since 5131
145 */
146 public static void updateAllFormatsImporter() {
147 for(int i=0; i < importers.size(); i++) {
148 if(importers.get(i) instanceof AllFormatsImporter) {
149 importers.set(i, new AllFormatsImporter());
150 }
151 }
152 }
153
154 /**
155 * Replies an ordered list of {@link ExtensionFileFilter}s for importing.
156 * The list is ordered according to their description, an {@link AllFormatsImporter}
157 * is append at the end.
158 *
159 * @return an ordered list of {@link ExtensionFileFilter}s for importing.
160 * @since 2029
161 */
162 public static List<ExtensionFileFilter> getImportExtensionFileFilters() {
163 updateAllFormatsImporter();
164 LinkedList<ExtensionFileFilter> filters = new LinkedList<>();
165 for (FileImporter importer : importers) {
166 filters.add(importer.filter);
167 }
168 sort(filters);
169 return filters;
170 }
171
172 /**
173 * Replies an ordered list of enabled {@link ExtensionFileFilter}s for exporting.
174 * The list is ordered according to their description, an {@link AllFormatsImporter}
175 * is append at the end.
176 *
177 * @return an ordered list of enabled {@link ExtensionFileFilter}s for exporting.
178 * @since 2029
179 */
180 public static List<ExtensionFileFilter> getExportExtensionFileFilters() {
181 LinkedList<ExtensionFileFilter> filters = new LinkedList<>();
182 for (FileExporter exporter : exporters) {
183 if (filters.contains(exporter.filter) || !exporter.isEnabled()) {
184 continue;
185 }
186 filters.add(exporter.filter);
187 }
188 sort(filters);
189 return filters;
190 }
191
192 /**
193 * Replies the default {@link ExtensionFileFilter} for a given extension
194 *
195 * @param extension the extension
196 * @return the default {@link ExtensionFileFilter} for a given extension
197 * @since 2029
198 */
199 public static ExtensionFileFilter getDefaultImportExtensionFileFilter(String extension) {
200 if (extension == null) return new AllFormatsImporter().filter;
201 for (FileImporter importer : importers) {
202 if (extension.equals(importer.filter.getDefaultExtension()))
203 return importer.filter;
204 }
205 return new AllFormatsImporter().filter;
206 }
207
208 /**
209 * Replies the default {@link ExtensionFileFilter} for a given extension
210 *
211 * @param extension the extension
212 * @return the default {@link ExtensionFileFilter} for a given extension
213 * @since 2029
214 */
215 public static ExtensionFileFilter getDefaultExportExtensionFileFilter(String extension) {
216 if (extension == null) return new AllFormatsImporter().filter;
217 for (FileExporter exporter : exporters) {
218 if (extension.equals(exporter.filter.getDefaultExtension()))
219 return exporter.filter;
220 }
221 return new AllFormatsImporter().filter;
222 }
223
224 /**
225 * Applies the choosable {@link FileFilter} to a {@link JFileChooser} before using the
226 * file chooser for selecting a file for reading.
227 *
228 * @param fileChooser the file chooser
229 * @param extension the default extension
230 * @param allTypes If true, all the files types known by JOSM will be proposed in the "file type" combobox.
231 * If false, only the file filters that include {@code extension} will be proposed
232 * @since 5438
233 */
234 public static void applyChoosableImportFileFilters(JFileChooser fileChooser, String extension, boolean allTypes) {
235 for (ExtensionFileFilter filter: getImportExtensionFileFilters()) {
236 if (allTypes || filter.acceptName("file."+extension)) {
237 fileChooser.addChoosableFileFilter(filter);
238 }
239 }
240 fileChooser.setFileFilter(getDefaultImportExtensionFileFilter(extension));
241 }
242
243 /**
244 * Applies the choosable {@link FileFilter} to a {@link JFileChooser} before using the
245 * file chooser for selecting a file for writing.
246 *
247 * @param fileChooser the file chooser
248 * @param extension the default extension
249 * @param allTypes If true, all the files types known by JOSM will be proposed in the "file type" combobox.
250 * If false, only the file filters that include {@code extension} will be proposed
251 * @since 5438
252 */
253 public static void applyChoosableExportFileFilters(JFileChooser fileChooser, String extension, boolean allTypes) {
254 for (ExtensionFileFilter filter: getExportExtensionFileFilters()) {
255 if (allTypes || filter.acceptName("file."+extension)) {
256 fileChooser.addChoosableFileFilter(filter);
257 }
258 }
259 fileChooser.setFileFilter(getDefaultExportExtensionFileFilter(extension));
260 }
261
262 /**
263 * Construct an extension file filter by giving the extension to check after.
264 * @param extension The comma-separated list of file extensions
265 * @param defaultExtension The default extension
266 * @param description A short textual description of the file type
267 * @since 1169
268 */
269 public ExtensionFileFilter(String extension, String defaultExtension, String description) {
270 this.extensions = extension;
271 this.defaultExtension = defaultExtension;
272 this.description = description;
273 }
274
275 /**
276 * Returns true if this file filter accepts the given filename.
277 * @param filename The filename to check after
278 * @return true if this file filter accepts the given filename (i.e if this filename ends with one of the extensions)
279 * @since 1169
280 */
281 public boolean acceptName(String filename) {
282 String name = filename.toLowerCase();
283 for (String ext : extensions.split(","))
284 if (name.endsWith("."+ext))
285 return true;
286 return false;
287 }
288
289 @Override
290 public boolean accept(File pathname) {
291 if (pathname.isDirectory())
292 return true;
293 return acceptName(pathname.getName());
294 }
295
296 @Override
297 public String getDescription() {
298 return description;
299 }
300
301 /**
302 * Replies the comma-separated list of file extensions of this file filter.
303 * @return the comma-separated list of file extensions of this file filter, as a String
304 * @since 5131
305 */
306 public String getExtensions() {
307 return extensions;
308 }
309
310 /**
311 * Replies the default file extension of this file filter.
312 * @return the default file extension of this file filter
313 * @since 2029
314 */
315 public String getDefaultExtension() {
316 return defaultExtension;
317 }
318
319 @Override
320 public int hashCode() {
321 final int prime = 31;
322 int result = 1;
323 result = prime * result + ((defaultExtension == null) ? 0 : defaultExtension.hashCode());
324 result = prime * result + ((description == null) ? 0 : description.hashCode());
325 result = prime * result + ((extensions == null) ? 0 : extensions.hashCode());
326 return result;
327 }
328
329 @Override
330 public boolean equals(Object obj) {
331 if (this == obj)
332 return true;
333 if (obj == null)
334 return false;
335 if (getClass() != obj.getClass())
336 return false;
337 ExtensionFileFilter other = (ExtensionFileFilter) obj;
338 if (defaultExtension == null) {
339 if (other.defaultExtension != null)
340 return false;
341 } else if (!defaultExtension.equals(other.defaultExtension))
342 return false;
343 if (description == null) {
344 if (other.description != null)
345 return false;
346 } else if (!description.equals(other.description))
347 return false;
348 if (extensions == null) {
349 if (other.extensions != null)
350 return false;
351 } else if (!extensions.equals(other.extensions))
352 return false;
353 return true;
354 }
355}
Note: See TracBrowser for help on using the repository browser.