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

Last change on this file since 6252 was 6245, checked in by Don-vip, 11 years ago

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