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

Last change on this file since 6203 was 6084, checked in by bastiK, 11 years ago

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