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

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

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