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

Last change on this file since 10630 was 10619, checked in by Don-vip, 8 years ago

see #11390 - Java 8: use List.sort(Comparator) instead of Collections.sort(list, Comparator)
  • Property svn:eol-style set to native
File size: 18.3 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.Arrays;
7import java.util.Collection;
8import java.util.Collections;
9import java.util.Comparator;
10import java.util.LinkedHashSet;
11import java.util.LinkedList;
12import java.util.List;
13import java.util.Objects;
14import java.util.ServiceConfigurationError;
15
16import javax.swing.filechooser.FileFilter;
17
18import org.openstreetmap.josm.Main;
19import org.openstreetmap.josm.gui.widgets.AbstractFileChooser;
20import org.openstreetmap.josm.io.AllFormatsImporter;
21import org.openstreetmap.josm.io.FileExporter;
22import org.openstreetmap.josm.io.FileImporter;
23import org.openstreetmap.josm.tools.Utils;
24
25/**
26 * A file filter that filters after the extension. Also includes a list of file
27 * filters used in JOSM.
28 * @since 32
29 */
30public class ExtensionFileFilter extends FileFilter implements java.io.FileFilter {
31
32 /**
33 * List of supported formats for import.
34 * @since 4869
35 */
36 private static final ArrayList<FileImporter> importers;
37
38 /**
39 * List of supported formats for export.
40 * @since 4869
41 */
42 private static final ArrayList<FileExporter> exporters;
43
44 // add some file types only if the relevant classes are there.
45 // this gives us the option to painlessly drop them from the .jar
46 // and build JOSM versions without support for these formats
47
48 static {
49
50 importers = new ArrayList<>();
51
52 final List<Class<? extends FileImporter>> importerNames = Arrays.asList(
53 org.openstreetmap.josm.io.OsmImporter.class,
54 org.openstreetmap.josm.io.OsmChangeImporter.class,
55 org.openstreetmap.josm.io.GpxImporter.class,
56 org.openstreetmap.josm.io.NMEAImporter.class,
57 org.openstreetmap.josm.io.NoteImporter.class,
58 org.openstreetmap.josm.io.JpgImporter.class,
59 org.openstreetmap.josm.io.WMSLayerImporter.class,
60 org.openstreetmap.josm.io.AllFormatsImporter.class,
61 org.openstreetmap.josm.io.session.SessionImporter.class
62 );
63
64 for (final Class<? extends FileImporter> importerClass : importerNames) {
65 try {
66 FileImporter importer = importerClass.getConstructor().newInstance();
67 importers.add(importer);
68 } catch (ReflectiveOperationException e) {
69 Main.debug(e);
70 } catch (ServiceConfigurationError e) {
71 // error seen while initializing WMSLayerImporter in plugin unit tests:
72 // -
73 // ServiceConfigurationError: javax.imageio.spi.ImageWriterSpi:
74 // Provider com.sun.media.imageioimpl.plugins.jpeg.CLibJPEGImageWriterSpi could not be instantiated
75 // Caused by: java.lang.IllegalArgumentException: vendorName == null!
76 // at javax.imageio.spi.IIOServiceProvider.<init>(IIOServiceProvider.java:76)
77 // at javax.imageio.spi.ImageReaderWriterSpi.<init>(ImageReaderWriterSpi.java:231)
78 // at javax.imageio.spi.ImageWriterSpi.<init>(ImageWriterSpi.java:213)
79 // at com.sun.media.imageioimpl.plugins.jpeg.CLibJPEGImageWriterSpi.<init>(CLibJPEGImageWriterSpi.java:84)
80 // -
81 // This is a very strange behaviour of JAI:
82 // http://thierrywasyl.wordpress.com/2009/07/24/jai-how-to-solve-vendorname-null-exception/
83 // -
84 // that can lead to various problems, see #8583 comments
85 Main.error(e);
86 }
87 }
88
89 exporters = new ArrayList<>();
90
91 final List<Class<? extends FileExporter>> exporterClasses = Arrays.asList(
92 org.openstreetmap.josm.io.GpxExporter.class,
93 org.openstreetmap.josm.io.OsmExporter.class,
94 org.openstreetmap.josm.io.OsmGzipExporter.class,
95 org.openstreetmap.josm.io.OsmBzip2Exporter.class,
96 org.openstreetmap.josm.io.GeoJSONExporter.CurrentProjection.class, // needs to be considered earlier than GeoJSONExporter
97 org.openstreetmap.josm.io.GeoJSONExporter.class,
98 org.openstreetmap.josm.io.WMSLayerExporter.class,
99 org.openstreetmap.josm.io.NoteExporter.class
100 );
101
102 for (final Class<? extends FileExporter> exporterClass : exporterClasses) {
103 try {
104 FileExporter exporter = exporterClass.getConstructor().newInstance();
105 exporters.add(exporter);
106 Main.getLayerManager().addAndFireActiveLayerChangeListener(exporter);
107 } catch (ReflectiveOperationException e) {
108 Main.debug(e);
109 } catch (ServiceConfigurationError e) {
110 // see above in importers initialization
111 Main.error(e);
112 }
113 }
114 }
115
116 private final String extensions;
117 private final String description;
118 private final String defaultExtension;
119
120 protected static void sort(List<ExtensionFileFilter> filters) {
121 filters.sort(new Comparator<ExtensionFileFilter>() {
122 private AllFormatsImporter all = new AllFormatsImporter();
123 @Override
124 public int compare(ExtensionFileFilter o1, ExtensionFileFilter o2) {
125 if (o1.getDescription().equals(all.filter.getDescription())) return 1;
126 if (o2.getDescription().equals(all.filter.getDescription())) return -1;
127 return o1.getDescription().compareTo(o2.getDescription());
128 }
129 }
130 );
131 }
132
133 public enum AddArchiveExtension { NONE, BASE, ALL }
134
135 /**
136 * Adds a new file importer at the end of the global list. This importer will be evaluated after core ones.
137 * @param importer new file importer
138 * @since 10407
139 */
140 public static void addImporter(FileImporter importer) {
141 if (importer != null) {
142 importers.add(importer);
143 }
144 }
145
146 /**
147 * Adds a new file importer at the beginning of the global list. This importer will be evaluated before core ones.
148 * @param importer new file importer
149 * @since 10407
150 */
151 public static void addImporterFirst(FileImporter importer) {
152 if (importer != null) {
153 importers.add(0, importer);
154 }
155 }
156
157 /**
158 * Adds a new file exporter at the end of the global list. This exporter will be evaluated after core ones.
159 * @param exporter new file exporter
160 * @since 10407
161 */
162 public static void addExporter(FileExporter exporter) {
163 if (exporter != null) {
164 exporters.add(exporter);
165 }
166 }
167
168 /**
169 * Adds a new file exporter at the beginning of the global list. This exporter will be evaluated before core ones.
170 * @param exporter new file exporter
171 * @since 10407
172 */
173 public static void addExporterFirst(FileExporter exporter) {
174 if (exporter != null) {
175 exporters.add(0, exporter);
176 }
177 }
178
179 /**
180 * Returns the list of file importers.
181 * @return unmodifiable list of file importers
182 * @since 10407
183 */
184 public static List<FileImporter> getImporters() {
185 return Collections.unmodifiableList(importers);
186 }
187
188 /**
189 * Returns the list of file exporters.
190 * @return unmodifiable list of file exporters
191 * @since 10407
192 */
193 public static List<FileExporter> getExporters() {
194 return Collections.unmodifiableList(exporters);
195 }
196
197 /**
198 * Updates the {@link AllFormatsImporter} that is contained in the importers list. If
199 * you do not use the importers variable directly, you don’t need to call this.
200 * <p>
201 * Updating the AllFormatsImporter is required when plugins add new importers that
202 * support new file extensions. The old AllFormatsImporter doesn’t include the new
203 * extensions and thus will not display these files.
204 *
205 * @since 5131
206 */
207 public static void updateAllFormatsImporter() {
208 for (int i = 0; i < importers.size(); i++) {
209 if (importers.get(i) instanceof AllFormatsImporter) {
210 importers.set(i, new AllFormatsImporter());
211 }
212 }
213 }
214
215 /**
216 * Replies an ordered list of {@link ExtensionFileFilter}s for importing.
217 * The list is ordered according to their description, an {@link AllFormatsImporter}
218 * is append at the end.
219 *
220 * @return an ordered list of {@link ExtensionFileFilter}s for importing.
221 * @since 2029
222 */
223 public static List<ExtensionFileFilter> getImportExtensionFileFilters() {
224 updateAllFormatsImporter();
225 List<ExtensionFileFilter> filters = new LinkedList<>();
226 for (FileImporter importer : importers) {
227 filters.add(importer.filter);
228 }
229 sort(filters);
230 return filters;
231 }
232
233 /**
234 * Replies an ordered list of enabled {@link ExtensionFileFilter}s for exporting.
235 * The list is ordered according to their description, an {@link AllFormatsImporter}
236 * is append at the end.
237 *
238 * @return an ordered list of enabled {@link ExtensionFileFilter}s for exporting.
239 * @since 2029
240 */
241 public static List<ExtensionFileFilter> getExportExtensionFileFilters() {
242 List<ExtensionFileFilter> filters = new LinkedList<>();
243 for (FileExporter exporter : exporters) {
244 if (filters.contains(exporter.filter) || !exporter.isEnabled()) {
245 continue;
246 }
247 filters.add(exporter.filter);
248 }
249 sort(filters);
250 return filters;
251 }
252
253 /**
254 * Replies the default {@link ExtensionFileFilter} for a given extension
255 *
256 * @param extension the extension
257 * @return the default {@link ExtensionFileFilter} for a given extension
258 * @since 2029
259 */
260 public static ExtensionFileFilter getDefaultImportExtensionFileFilter(String extension) {
261 if (extension == null) return new AllFormatsImporter().filter;
262 for (FileImporter importer : importers) {
263 if (extension.equals(importer.filter.getDefaultExtension()))
264 return importer.filter;
265 }
266 return new AllFormatsImporter().filter;
267 }
268
269 /**
270 * Replies the default {@link ExtensionFileFilter} for a given extension
271 *
272 * @param extension the extension
273 * @return the default {@link ExtensionFileFilter} for a given extension
274 * @since 2029
275 */
276 public static ExtensionFileFilter getDefaultExportExtensionFileFilter(String extension) {
277 if (extension == null) return new AllFormatsImporter().filter;
278 for (FileExporter exporter : exporters) {
279 if (extension.equals(exporter.filter.getDefaultExtension()))
280 return exporter.filter;
281 }
282 // if extension did not match defaultExtension of any exporter,
283 // scan all supported extensions
284 File file = new File("file." + extension);
285 for (FileExporter exporter : exporters) {
286 if (exporter.filter.accept(file))
287 return exporter.filter;
288 }
289 return new AllFormatsImporter().filter;
290 }
291
292 /**
293 * Applies the choosable {@link FileFilter} to a {@link AbstractFileChooser} before using the
294 * file chooser for selecting a file for reading.
295 *
296 * @param fileChooser the file chooser
297 * @param extension the default extension
298 * @param allTypes If true, all the files types known by JOSM will be proposed in the "file type" combobox.
299 * If false, only the file filters that include {@code extension} will be proposed
300 * @since 5438
301 */
302 public static void applyChoosableImportFileFilters(AbstractFileChooser fileChooser, String extension, boolean allTypes) {
303 for (ExtensionFileFilter filter: getImportExtensionFileFilters()) {
304
305 if (allTypes || filter.acceptName("file."+extension)) {
306 fileChooser.addChoosableFileFilter(filter);
307 }
308 }
309 fileChooser.setFileFilter(getDefaultImportExtensionFileFilter(extension));
310 }
311
312 /**
313 * Applies the choosable {@link FileFilter} to a {@link AbstractFileChooser} before using the
314 * file chooser for selecting a file for writing.
315 *
316 * @param fileChooser the file chooser
317 * @param extension the default extension
318 * @param allTypes If true, all the files types known by JOSM will be proposed in the "file type" combobox.
319 * If false, only the file filters that include {@code extension} will be proposed
320 * @since 5438
321 */
322 public static void applyChoosableExportFileFilters(AbstractFileChooser fileChooser, String extension, boolean allTypes) {
323 for (ExtensionFileFilter filter: getExportExtensionFileFilters()) {
324 if (allTypes || filter.acceptName("file."+extension)) {
325 fileChooser.addChoosableFileFilter(filter);
326 }
327 }
328 fileChooser.setFileFilter(getDefaultExportExtensionFileFilter(extension));
329 }
330
331 /**
332 * Construct an extension file filter by giving the extension to check after.
333 * @param extension The comma-separated list of file extensions
334 * @param defaultExtension The default extension
335 * @param description A short textual description of the file type
336 * @since 1169
337 */
338 public ExtensionFileFilter(String extension, String defaultExtension, String description) {
339 this.extensions = extension;
340 this.defaultExtension = defaultExtension;
341 this.description = description;
342 }
343
344 /**
345 * Construct an extension file filter with the extensions supported by {@link org.openstreetmap.josm.io.Compression}
346 * automatically added to the {@code extensions}. The specified {@code extensions} will be added to the description
347 * in the form {@code old-description (*.ext1, *.ext2)}.
348 * @param extensions The comma-separated list of file extensions
349 * @param defaultExtension The default extension
350 * @param description A short textual description of the file type without supported extensions in parentheses
351 * @param addArchiveExtension Whether to also add the archive extensions to the description
352 * @param archiveExtensions List of extensions to be added
353 * @return The constructed filter
354 */
355 public static ExtensionFileFilter newFilterWithArchiveExtensions(String extensions, String defaultExtension,
356 String description, AddArchiveExtension addArchiveExtension, List<String> archiveExtensions) {
357 final Collection<String> extensionsPlusArchive = new LinkedHashSet<>();
358 final Collection<String> extensionsForDescription = new LinkedHashSet<>();
359 for (String e : extensions.split(",")) {
360 extensionsPlusArchive.add(e);
361 if (addArchiveExtension != AddArchiveExtension.NONE) {
362 extensionsForDescription.add("*." + e);
363 }
364 for (String extension : archiveExtensions) {
365 extensionsPlusArchive.add(e + '.' + extension);
366 if (addArchiveExtension == AddArchiveExtension.ALL) {
367 extensionsForDescription.add("*." + e + '.' + extension);
368 }
369 }
370 }
371 return new ExtensionFileFilter(
372 Utils.join(",", extensionsPlusArchive),
373 defaultExtension,
374 description + (!extensionsForDescription.isEmpty()
375 ? (" (" + Utils.join(", ", extensionsForDescription) + ')')
376 : "")
377 );
378 }
379
380 /**
381 * Construct an extension file filter with the extensions supported by {@link org.openstreetmap.josm.io.Compression}
382 * automatically added to the {@code extensions}. The specified {@code extensions} will be added to the description
383 * in the form {@code old-description (*.ext1, *.ext2)}.
384 * @param extensions The comma-separated list of file extensions
385 * @param defaultExtension The default extension
386 * @param description A short textual description of the file type without supported extensions in parentheses
387 * @param addArchiveExtensionsToDescription Whether to also add the archive extensions to the description
388 * @return The constructed filter
389 */
390 public static ExtensionFileFilter newFilterWithArchiveExtensions(
391 String extensions, String defaultExtension, String description, boolean addArchiveExtensionsToDescription) {
392
393 List<String> archiveExtensions = Arrays.asList("gz", "bz2");
394 return newFilterWithArchiveExtensions(
395 extensions,
396 defaultExtension,
397 description,
398 addArchiveExtensionsToDescription ? AddArchiveExtension.ALL : AddArchiveExtension.BASE,
399 archiveExtensions
400 );
401 }
402
403 /**
404 * Returns true if this file filter accepts the given filename.
405 * @param filename The filename to check after
406 * @return true if this file filter accepts the given filename (i.e if this filename ends with one of the extensions)
407 * @since 1169
408 */
409 public boolean acceptName(String filename) {
410 return Utils.hasExtension(filename, extensions.split(","));
411 }
412
413 @Override
414 public boolean accept(File pathname) {
415 if (pathname.isDirectory())
416 return true;
417 return acceptName(pathname.getName());
418 }
419
420 @Override
421 public String getDescription() {
422 return description;
423 }
424
425 /**
426 * Replies the comma-separated list of file extensions of this file filter.
427 * @return the comma-separated list of file extensions of this file filter, as a String
428 * @since 5131
429 */
430 public String getExtensions() {
431 return extensions;
432 }
433
434 /**
435 * Replies the default file extension of this file filter.
436 * @return the default file extension of this file filter
437 * @since 2029
438 */
439 public String getDefaultExtension() {
440 return defaultExtension;
441 }
442
443 @Override
444 public int hashCode() {
445 return Objects.hash(extensions, description, defaultExtension);
446 }
447
448 @Override
449 public boolean equals(Object obj) {
450 if (this == obj) return true;
451 if (obj == null || getClass() != obj.getClass()) return false;
452 ExtensionFileFilter that = (ExtensionFileFilter) obj;
453 return Objects.equals(extensions, that.extensions) &&
454 Objects.equals(description, that.description) &&
455 Objects.equals(defaultExtension, that.defaultExtension);
456 }
457}
Note: See TracBrowser for help on using the repository browser.