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

Last change on this file since 5508 was 5459, checked in by Don-vip, 12 years ago

fix #2961 - Improve usability of WMS Layer Saving/Loading

  • Replaced the unconventional method of creating a blank layer, then loading a .wms file to a standard File->Open approach
  • Fixed memory leaks with some actions registered as listeners but never destroyed
  • Layer interface modified to allow a generic approach of layer saving in SaveActionBase rather than the previous one restricted to OSM and GPX data
  • FileImporters and FileExporters can now be enabled/disabled at runtime, for example when the active layer changes
  • 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 {
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 public int compare(ExtensionFileFilter o1, ExtensionFileFilter o2) {
96 if (o1.getDescription().equals(all.filter.getDescription())) return 1;
97 if (o2.getDescription().equals(all.filter.getDescription())) return -1;
98 return o1.getDescription().compareTo(o2.getDescription());
99 }
100 }
101 );
102 }
103
104 /**
105 * Updates the {@link AllFormatsImporter} that is contained in the importers list. If
106 * you do not use the importers variable directly, you don’t need to call this.
107 * <p>
108 * Updating the AllFormatsImporter is required when plugins add new importers that
109 * support new file extensions. The old AllFormatsImporter doesn’t include the new
110 * extensions and thus will not display these files.
111 *
112 * @since 5131
113 */
114 public static void updateAllFormatsImporter() {
115 for(int i=0; i < importers.size(); i++) {
116 if(importers.get(i) instanceof AllFormatsImporter) {
117 importers.set(i, new AllFormatsImporter());
118 }
119 }
120 }
121
122 /**
123 * Replies an ordered list of {@link ExtensionFileFilter}s for importing.
124 * The list is ordered according to their description, an {@link AllFormatsImporter}
125 * is append at the end.
126 *
127 * @return an ordered list of {@link ExtensionFileFilter}s for importing.
128 * @since 2029
129 */
130 public static List<ExtensionFileFilter> getImportExtensionFileFilters() {
131 updateAllFormatsImporter();
132 LinkedList<ExtensionFileFilter> filters = new LinkedList<ExtensionFileFilter>();
133 for (FileImporter importer : importers) {
134 filters.add(importer.filter);
135 }
136 sort(filters);
137 return filters;
138 }
139
140 /**
141 * Replies an ordered list of enabled {@link ExtensionFileFilter}s for exporting.
142 * The list is ordered according to their description, an {@link AllFormatsImporter}
143 * is append at the end.
144 *
145 * @return an ordered list of enabled {@link ExtensionFileFilter}s for exporting.
146 * @since 2029
147 */
148 public static List<ExtensionFileFilter> getExportExtensionFileFilters() {
149 LinkedList<ExtensionFileFilter> filters = new LinkedList<ExtensionFileFilter>();
150 for (FileExporter exporter : exporters) {
151 if (filters.contains(exporter.filter) || !exporter.isEnabled()) {
152 continue;
153 }
154 filters.add(exporter.filter);
155 }
156 sort(filters);
157 return filters;
158 }
159
160 /**
161 * Replies the default {@link ExtensionFileFilter} for a given extension
162 *
163 * @param extension the extension
164 * @return the default {@link ExtensionFileFilter} for a given extension
165 * @since 2029
166 */
167 public static ExtensionFileFilter getDefaultImportExtensionFileFilter(String extension) {
168 if (extension == null) return new AllFormatsImporter().filter;
169 for (FileImporter importer : importers) {
170 if (extension.equals(importer.filter.getDefaultExtension()))
171 return importer.filter;
172 }
173 return new AllFormatsImporter().filter;
174 }
175
176 /**
177 * Replies the default {@link ExtensionFileFilter} for a given extension
178 *
179 * @param extension the extension
180 * @return the default {@link ExtensionFileFilter} for a given extension
181 * @since 2029
182 */
183 public static ExtensionFileFilter getDefaultExportExtensionFileFilter(String extension) {
184 if (extension == null) return new AllFormatsImporter().filter;
185 for (FileExporter exporter : exporters) {
186 if (extension.equals(exporter.filter.getDefaultExtension()))
187 return exporter.filter;
188 }
189 return new AllFormatsImporter().filter;
190 }
191
192 /**
193 * Applies the choosable {@link FileFilter} to a {@link JFileChooser} before using the
194 * file chooser for selecting a file for reading.
195 *
196 * @param fileChooser the file chooser
197 * @param extension the default extension
198 * @param allTypes If true, all the files types known by JOSM will be proposed in the "file type" combobox.
199 * If false, only the file filters that include {@code extension} will be proposed
200 * @since 5438
201 */
202 public static void applyChoosableImportFileFilters(JFileChooser fileChooser, String extension, boolean allTypes) {
203 for (ExtensionFileFilter filter: getImportExtensionFileFilters()) {
204 if (allTypes || filter.acceptName("file."+extension)) {
205 fileChooser.addChoosableFileFilter(filter);
206 }
207 }
208 fileChooser.setFileFilter(getDefaultImportExtensionFileFilter(extension));
209 }
210
211 /**
212 * Applies the choosable {@link FileFilter} to a {@link JFileChooser} before using the
213 * file chooser for selecting a file for writing.
214 *
215 * @param fileChooser the file chooser
216 * @param extension the default extension
217 * @param allTypes If true, all the files types known by JOSM will be proposed in the "file type" combobox.
218 * If false, only the file filters that include {@code extension} will be proposed
219 * @since 5438
220 */
221 public static void applyChoosableExportFileFilters(JFileChooser fileChooser, String extension, boolean allTypes) {
222 for (ExtensionFileFilter filter: getExportExtensionFileFilters()) {
223 if (allTypes || filter.acceptName("file."+extension)) {
224 fileChooser.addChoosableFileFilter(filter);
225 }
226 }
227 fileChooser.setFileFilter(getDefaultExportExtensionFileFilter(extension));
228 }
229
230 /**
231 * Construct an extension file filter by giving the extension to check after.
232 * @param extension The comma-separated list of file extensions
233 * @param defaultExtension The default extension
234 * @param description A short textual description of the file type
235 * @since 1169
236 */
237 public ExtensionFileFilter(String extension, String defaultExtension, String description) {
238 this.extensions = extension;
239 this.defaultExtension = defaultExtension;
240 this.description = description;
241 }
242
243 /**
244 * Returns true if this file filter accepts the given filename.
245 * @param filename The filename to check after
246 * @return true if this file filter accepts the given filename (i.e if this filename ends with one of the extensions)
247 * @since 1169
248 */
249 public boolean acceptName(String filename) {
250 String name = filename.toLowerCase();
251 for (String ext : extensions.split(","))
252 if (name.endsWith("."+ext))
253 return true;
254 return false;
255 }
256
257 @Override
258 public boolean accept(File pathname) {
259 if (pathname.isDirectory())
260 return true;
261 return acceptName(pathname.getName());
262 }
263
264 @Override
265 public String getDescription() {
266 return description;
267 }
268
269 /**
270 * Replies the comma-separated list of file extensions of this file filter.
271 * @return the comma-separated list of file extensions of this file filter, as a String
272 * @since 5131
273 */
274 public String getExtensions() {
275 return extensions;
276 }
277
278 /**
279 * Replies the default file extension of this file filter.
280 * @return the default file extension of this file filter
281 * @since 2029
282 */
283 public String getDefaultExtension() {
284 return defaultExtension;
285 }
286
287 @Override
288 public int hashCode() {
289 final int prime = 31;
290 int result = 1;
291 result = prime * result + ((defaultExtension == null) ? 0 : defaultExtension.hashCode());
292 result = prime * result + ((description == null) ? 0 : description.hashCode());
293 result = prime * result + ((extensions == null) ? 0 : extensions.hashCode());
294 return result;
295 }
296
297 @Override
298 public boolean equals(Object obj) {
299 if (this == obj)
300 return true;
301 if (obj == null)
302 return false;
303 if (getClass() != obj.getClass())
304 return false;
305 ExtensionFileFilter other = (ExtensionFileFilter) obj;
306 if (defaultExtension == null) {
307 if (other.defaultExtension != null)
308 return false;
309 } else if (!defaultExtension.equals(other.defaultExtension))
310 return false;
311 if (description == null) {
312 if (other.description != null)
313 return false;
314 } else if (!description.equals(other.description))
315 return false;
316 if (extensions == null) {
317 if (other.extensions != null)
318 return false;
319 } else if (!extensions.equals(other.extensions))
320 return false;
321 return true;
322 }
323}
Note: See TracBrowser for help on using the repository browser.