source: josm/trunk/src/org/openstreetmap/josm/io/session/SessionReader.java@ 19050

Last change on this file since 19050 was 19050, checked in by taylor.smock, 15 months ago

Revert most var changes from r19048, fix most new compile warnings and checkstyle issues

Also, document why various ErrorProne checks were originally disabled and fix
generic SonarLint issues.
  • Property svn:eol-style set to native
File size: 32.7 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.io.session;
3
4import static org.openstreetmap.josm.tools.I18n.tr;
5
6import java.awt.GraphicsEnvironment;
7import java.io.BufferedInputStream;
8import java.io.File;
9import java.io.FileNotFoundException;
10import java.io.IOException;
11import java.io.InputStream;
12import java.lang.reflect.InvocationTargetException;
13import java.net.URI;
14import java.net.URISyntaxException;
15import java.nio.charset.StandardCharsets;
16import java.nio.file.Files;
17import java.util.AbstractMap.SimpleEntry;
18import java.util.ArrayList;
19import java.util.Collection;
20import java.util.Collections;
21import java.util.Enumeration;
22import java.util.HashMap;
23import java.util.List;
24import java.util.Map;
25import java.util.Map.Entry;
26import java.util.TreeMap;
27import java.util.stream.Collectors;
28import java.util.stream.IntStream;
29import java.util.zip.ZipEntry;
30import java.util.zip.ZipException;
31import java.util.zip.ZipFile;
32
33import javax.swing.JOptionPane;
34import javax.swing.SwingUtilities;
35import javax.xml.parsers.ParserConfigurationException;
36
37import org.openstreetmap.josm.data.ViewportData;
38import org.openstreetmap.josm.data.coor.EastNorth;
39import org.openstreetmap.josm.data.coor.ILatLon;
40import org.openstreetmap.josm.data.coor.LatLon;
41import org.openstreetmap.josm.data.projection.Projection;
42import org.openstreetmap.josm.gui.ExceptionDialogUtil;
43import org.openstreetmap.josm.gui.ExtendedDialog;
44import org.openstreetmap.josm.gui.MainApplication;
45import org.openstreetmap.josm.gui.layer.Layer;
46import org.openstreetmap.josm.gui.progress.NullProgressMonitor;
47import org.openstreetmap.josm.gui.progress.ProgressMonitor;
48import org.openstreetmap.josm.gui.util.GuiHelper;
49import org.openstreetmap.josm.io.Compression;
50import org.openstreetmap.josm.io.IllegalDataException;
51import org.openstreetmap.josm.plugins.PluginHandler;
52import org.openstreetmap.josm.tools.CheckParameterUtil;
53import org.openstreetmap.josm.tools.JosmRuntimeException;
54import org.openstreetmap.josm.tools.Logging;
55import org.openstreetmap.josm.tools.MultiMap;
56import org.openstreetmap.josm.tools.Utils;
57import org.openstreetmap.josm.tools.XmlUtils;
58import org.w3c.dom.Document;
59import org.w3c.dom.Element;
60import org.w3c.dom.Node;
61import org.w3c.dom.NodeList;
62import org.xml.sax.SAXException;
63
64/**
65 * Reads a .jos session file and loads the layers in the process.
66 * @since 4668
67 */
68public class SessionReader {
69
70 /**
71 * Data class for projection saved in the session file.
72 */
73 public static class SessionProjectionChoiceData {
74 private final String projectionChoiceId;
75 private final Collection<String> subPreferences;
76
77 /**
78 * Construct a new SessionProjectionChoiceData.
79 * @param projectionChoiceId projection choice id
80 * @param subPreferences parameters for the projection choice
81 */
82 public SessionProjectionChoiceData(String projectionChoiceId, Collection<String> subPreferences) {
83 this.projectionChoiceId = projectionChoiceId;
84 this.subPreferences = subPreferences;
85 }
86
87 /**
88 * Get the projection choice id.
89 * @return the projection choice id
90 */
91 public String getProjectionChoiceId() {
92 return projectionChoiceId;
93 }
94
95 /**
96 * Get the parameters for the projection choice
97 * @return parameters for the projection choice
98 */
99 public Collection<String> getSubPreferences() {
100 return subPreferences;
101 }
102 }
103
104 /**
105 * Data class for viewport saved in the session file.
106 */
107 public static class SessionViewportData {
108 private final LatLon center;
109 private final double meterPerPixel;
110
111 /**
112 * Construct a new SessionViewportData.
113 * @param center the lat/lon coordinates of the screen center
114 * @param meterPerPixel scale in meters per pixel
115 */
116 public SessionViewportData(LatLon center, double meterPerPixel) {
117 CheckParameterUtil.ensureParameterNotNull(center);
118 this.center = center;
119 this.meterPerPixel = meterPerPixel;
120 }
121
122 /**
123 * Get the lat/lon coordinates of the screen center.
124 * @return lat/lon coordinates of the screen center
125 */
126 public LatLon getCenter() {
127 return center;
128 }
129
130 /**
131 * Get the scale in meters per pixel.
132 * @return scale in meters per pixel
133 */
134 public double getScale() {
135 return meterPerPixel;
136 }
137
138 /**
139 * Convert this viewport data to a {@link ViewportData} object (with projected coordinates).
140 * @param proj the projection to convert from lat/lon to east/north
141 * @return the corresponding ViewportData object
142 */
143 public ViewportData getEastNorthViewport(Projection proj) {
144 EastNorth centerEN = proj.latlon2eastNorth(center);
145 // Get a "typical" distance in east/north units that
146 // corresponds to a couple of pixels. Shouldn't be too
147 // large, to keep it within projection bounds and
148 // not too small to avoid rounding errors.
149 double dist = 0.01 * proj.getDefaultZoomInPPD();
150 ILatLon ll1 = proj.eastNorth2latlon(new EastNorth(centerEN.east() - dist, centerEN.north()));
151 ILatLon ll2 = proj.eastNorth2latlon(new EastNorth(centerEN.east() + dist, centerEN.north()));
152 double meterPerEasting = ll1.greatCircleDistance(ll2) / dist / 2;
153 double scale = meterPerPixel / meterPerEasting; // unit: easting per pixel
154 return new ViewportData(centerEN, scale);
155 }
156 }
157
158 private static final Map<String, Class<? extends SessionLayerImporter>> sessionLayerImporters = new HashMap<>();
159
160 private URI sessionFileURI;
161 private boolean zip; // true, if session file is a .joz file; false if it is a .jos file
162 private boolean pluginData; // true, if a plugin restored state from a .joz file. False otherwise.
163 private ZipFile zipFile;
164 private List<Layer> layers = new ArrayList<>();
165 private int active = -1;
166 private final List<Runnable> postLoadTasks = new ArrayList<>();
167 private SessionViewportData viewport;
168 private SessionProjectionChoiceData projectionChoice;
169
170 static {
171 registerSessionLayerImporter("osm-data", OsmDataSessionImporter.class);
172 registerSessionLayerImporter("imagery", ImagerySessionImporter.class);
173 registerSessionLayerImporter("tracks", GpxTracksSessionImporter.class);
174 registerSessionLayerImporter("routes", GpxRoutesSessionImporter.class);
175 registerSessionLayerImporter("geoimage", GeoImageSessionImporter.class);
176 registerSessionLayerImporter("markers", MarkerSessionImporter.class);
177 registerSessionLayerImporter("osm-notes", NoteSessionImporter.class);
178 }
179
180 /**
181 * Register a session layer importer.
182 *
183 * @param layerType layer type
184 * @param importer importer for this layer class
185 */
186 public static void registerSessionLayerImporter(String layerType, Class<? extends SessionLayerImporter> importer) {
187 sessionLayerImporters.put(layerType, importer);
188 }
189
190 /**
191 * Returns the session layer importer for the given layer type.
192 * @param layerType layer type to import
193 * @return session layer importer for the given layer
194 */
195 public static SessionLayerImporter getSessionLayerImporter(String layerType) {
196 Class<? extends SessionLayerImporter> importerClass = sessionLayerImporters.get(layerType);
197 if (importerClass == null)
198 return null;
199 SessionLayerImporter importer;
200 try {
201 importer = importerClass.getConstructor().newInstance();
202 } catch (ReflectiveOperationException e) {
203 throw new JosmRuntimeException(e);
204 }
205 return importer;
206 }
207
208 /**
209 * Returns list of layers that are later added to the mapview.
210 * @return list of layers that are later added to the mapview
211 */
212 public List<Layer> getLayers() {
213 return layers;
214 }
215
216 /**
217 * Returns active layer.
218 * @return active layer, or {@code null} if not set
219 * @since 6271
220 */
221 public Layer getActive() {
222 // layers is in reverse order because of the way TreeMap is built
223 return (active >= 0 && active < layers.size()) ? layers.get(layers.size()-1-active) : null;
224 }
225
226 /**
227 * Returns actions executed in EDT after layers have been added.
228 * @return actions executed in EDT after layers have been added (message dialog, etc.)
229 */
230 public List<Runnable> getPostLoadTasks() {
231 return postLoadTasks;
232 }
233
234 /**
235 * Returns the viewport (map position and scale).
236 * @return the viewport; can be null when no viewport info is found in the file
237 */
238 public SessionViewportData getViewport() {
239 return viewport;
240 }
241
242 /**
243 * Returns the projection choice data.
244 * @return the projection; can be null when no projection info is found in the file
245 */
246 public SessionProjectionChoiceData getProjectionChoice() {
247 return projectionChoice;
248 }
249
250 /**
251 * Returns whether plugins loaded additonal data
252 * @return {@code true} if at least one plugin loaded additional data
253 * @since 18833
254 */
255 public boolean loadedPluginData() {
256 return this.pluginData;
257 }
258
259 /**
260 * A class that provides some context for the individual {@link SessionLayerImporter}
261 * when doing the import.
262 */
263 public class ImportSupport {
264
265 private final String layerName;
266 private final int layerIndex;
267 private final List<LayerDependency> layerDependencies;
268 private Map<Integer, Entry<Layer, Element>> subLayers;
269
270 /**
271 * Path of the file inside the zip archive.
272 * Used as alternative return value for getFile method.
273 */
274 private String inZipPath;
275
276 /**
277 * Constructs a new {@code ImportSupport}.
278 * @param layerName layer name
279 * @param layerIndex layer index
280 * @param layerDependencies layer dependencies
281 */
282 public ImportSupport(String layerName, int layerIndex, List<LayerDependency> layerDependencies) {
283 this.layerName = layerName;
284 this.layerIndex = layerIndex;
285 this.layerDependencies = layerDependencies;
286 }
287
288 /**
289 * Add a task, e.g. a message dialog, that should
290 * be executed in EDT after all layers have been added.
291 * @param task task to run in EDT
292 */
293 public void addPostLayersTask(Runnable task) {
294 postLoadTasks.add(task);
295 }
296
297 /**
298 * Add sub layers
299 * @param idx index
300 * @param layer sub layer
301 * @param el The XML element of the sub layer.
302 * Should contain "index" and "name" attributes.
303 * Can contain "opacity" and "visible" attributes
304 * @since 18466
305 */
306 public void addSubLayer(int idx, Layer layer, Element el) {
307 if (subLayers == null) {
308 subLayers = new HashMap<>();
309 }
310 subLayers.put(idx, new SimpleEntry<>(layer, el));
311 }
312
313 /**
314 * Returns the sub layers
315 * @return the sub layers. Can be null.
316 * @since 18466
317 */
318 public Map<Integer, Entry<Layer, Element>> getSubLayers() {
319 return subLayers;
320 }
321
322 /**
323 * Return an InputStream for a URI from a .jos/.joz file.
324 * <p>
325 * The following forms are supported:
326 * <p>
327 * - absolute file (both .jos and .joz):
328 * "file:///home/user/data.osm"
329 * "file:/home/user/data.osm"
330 * "file:///C:/files/data.osm"
331 * "file:/C:/file/data.osm"
332 * "/home/user/data.osm"
333 * "C:\files\data.osm" (not a URI, but recognized by File constructor on Windows systems)
334 * - standalone .jos files:
335 * - relative uri:
336 * "save/data.osm"
337 * "../project2/data.osm"
338 * - for .joz files:
339 * - file inside zip archive:
340 * "layers/01/data.osm"
341 * - relative to the .joz file:
342 * "../save/data.osm" ("../" steps out of the archive)
343 * @param uriStr URI as string
344 * @return the InputStream
345 *
346 * @throws IOException Thrown when no Stream can be opened for the given URI, e.g. when the linked file has been deleted.
347 */
348 public InputStream getInputStream(String uriStr) throws IOException {
349 File file = getFile(uriStr);
350 if (file != null) {
351 try {
352 return new BufferedInputStream(Compression.getUncompressedFileInputStream(file));
353 } catch (FileNotFoundException e) {
354 throw new IOException(tr("File ''{0}'' does not exist.", file.getPath()), e);
355 }
356 } else if (inZipPath != null) {
357 ZipEntry entry = zipFile.getEntry(inZipPath);
358 if (entry != null) {
359 return zipFile.getInputStream(entry);
360 }
361 }
362 throw new IOException(tr("Unable to locate file ''{0}''.", uriStr));
363 }
364
365 /**
366 * Return a File for a URI from a .jos/.joz file.
367 * <p>
368 * Returns null if the URI points to a file inside the zip archive.
369 * In this case, inZipPath will be set to the corresponding path.
370 * @param uriStr the URI as string
371 * @return the resulting File
372 * @throws IOException if any I/O error occurs
373 */
374 public File getFile(String uriStr) throws IOException {
375 inZipPath = null;
376 try {
377 URI uri = new URI(uriStr);
378 if ("file".equals(uri.getScheme()))
379 // absolute path
380 return new File(uri);
381 else if (uri.getScheme() == null) {
382 // Check if this is an absolute path without 'file:' scheme part.
383 // At this point, (as an exception) platform dependent path separator will be recognized.
384 // (This form is discouraged, only for users that like to copy and paste a path manually.)
385 File file = new File(uriStr);
386 if (file.isAbsolute())
387 return file;
388 else {
389 // for relative paths, only forward slashes are permitted
390 if (isZip()) {
391 if (uri.getPath().startsWith("../")) {
392 // relative to session file - "../" step out of the archive
393 String relPath = uri.getPath().substring(3);
394 return new File(sessionFileURI.resolve(relPath));
395 } else {
396 // file inside zip archive
397 inZipPath = uriStr;
398 return null;
399 }
400 } else
401 return new File(sessionFileURI.resolve(uri));
402 }
403 } else
404 throw new IOException(tr("Unsupported scheme ''{0}'' in URI ''{1}''.", uri.getScheme(), uriStr));
405 } catch (URISyntaxException | IllegalArgumentException e) {
406 throw new IOException(e);
407 }
408 }
409
410 /**
411 * Determines if we are reading from a .joz file.
412 * @return {@code true} if we are reading from a .joz file, {@code false} otherwise
413 */
414 public boolean isZip() {
415 return zip;
416 }
417
418 /**
419 * Name of the layer that is currently imported.
420 * @return layer name
421 */
422 public String getLayerName() {
423 return layerName;
424 }
425
426 /**
427 * Index of the layer that is currently imported.
428 * @return layer index
429 */
430 public int getLayerIndex() {
431 return layerIndex;
432 }
433
434 /**
435 * Dependencies - maps the layer index to the importer of the given
436 * layer. All the dependent importers have loaded completely at this point.
437 * @return layer dependencies
438 */
439 public List<LayerDependency> getLayerDependencies() {
440 return layerDependencies;
441 }
442
443 @Override
444 public String toString() {
445 return "ImportSupport [layerName=" + layerName + ", layerIndex=" + layerIndex + ", layerDependencies="
446 + layerDependencies + ", inZipPath=" + inZipPath + ']';
447 }
448 }
449
450 /**
451 * A dependency of another layer
452 */
453 public static class LayerDependency {
454 private final Integer index;
455 private final Layer layer;
456 private final SessionLayerImporter importer;
457
458 public LayerDependency(Integer index, Layer layer, SessionLayerImporter importer) {
459 this.index = index;
460 this.layer = layer;
461 this.importer = importer;
462 }
463
464 public SessionLayerImporter getImporter() {
465 return importer;
466 }
467
468 public Integer getIndex() {
469 return index;
470 }
471
472 public Layer getLayer() {
473 return layer;
474 }
475 }
476
477 private static void error(String msg) throws IllegalDataException {
478 throw new IllegalDataException(msg);
479 }
480
481 private void parseJos(Document doc, ProgressMonitor progressMonitor) throws IllegalDataException {
482 Element root = doc.getDocumentElement();
483 if (!"josm-session".equals(root.getTagName())) {
484 error(tr("Unexpected root element ''{0}'' in session file", root.getTagName()));
485 }
486 String version = root.getAttribute("version");
487 if (!"0.1".equals(version)) {
488 error(tr("Version ''{0}'' of session file is not supported. Expected: 0.1", version));
489 }
490
491 viewport = readViewportData(root);
492 projectionChoice = readProjectionChoiceData(root);
493
494 Element layersEl = getElementByTagName(root, "layers");
495 if (layersEl == null) return;
496
497 String activeAtt = layersEl.getAttribute("active");
498 try {
499 active = !activeAtt.isEmpty() ? (Integer.parseInt(activeAtt)-1) : -1;
500 } catch (NumberFormatException e) {
501 Logging.warn("Unsupported value for 'active' layer attribute. Ignoring it. Error was: "+e.getMessage());
502 active = -1;
503 }
504
505 MultiMap<Integer, Integer> deps = new MultiMap<>();
506 Map<Integer, Element> elems = new HashMap<>();
507
508 NodeList nodes = layersEl.getChildNodes();
509
510 for (int i = 0; i < nodes.getLength(); ++i) {
511 Node node = nodes.item(i);
512 if (node.getNodeType() == Node.ELEMENT_NODE) {
513 Element e = (Element) node;
514 if ("layer".equals(e.getTagName())) {
515 if (!e.hasAttribute("index")) {
516 error(tr("missing mandatory attribute ''index'' for element ''layer''"));
517 }
518 Integer idx = null;
519 try {
520 idx = Integer.valueOf(e.getAttribute("index"));
521 } catch (NumberFormatException ex) {
522 Logging.warn(ex);
523 }
524 if (idx == null) {
525 error(tr("unexpected format of attribute ''index'' for element ''layer''"));
526 } else if (elems.containsKey(idx)) {
527 error(tr("attribute ''index'' ({0}) for element ''layer'' must be unique", Integer.toString(idx)));
528 }
529 elems.put(idx, e);
530
531 deps.putVoid(idx);
532 String depStr = e.getAttribute("depends");
533 if (!depStr.isEmpty()) {
534 for (String sd : depStr.split(",", -1)) {
535 Integer d = null;
536 try {
537 d = Integer.valueOf(sd);
538 } catch (NumberFormatException ex) {
539 Logging.warn(ex);
540 }
541 if (d != null) {
542 deps.put(idx, d);
543 }
544 }
545 }
546 }
547 }
548 }
549
550 List<Integer> sorted = Utils.topologicalSort(deps);
551 final Map<Integer, Layer> layersMap = new TreeMap<>(Collections.reverseOrder());
552 final Map<Integer, SessionLayerImporter> importers = new HashMap<>();
553
554 progressMonitor.setTicksCount(sorted.size());
555 LAYER: for (int idx: sorted) {
556 Element e = elems.get(idx);
557 if (e == null) {
558 error(tr("missing layer with index {0}", idx));
559 return;
560 } else if (!e.hasAttribute("name")) {
561 error(tr("missing mandatory attribute ''name'' for element ''layer''"));
562 return;
563 }
564 String name = e.getAttribute("name");
565 if (!e.hasAttribute("type")) {
566 error(tr("missing mandatory attribute ''type'' for element ''layer''"));
567 return;
568 }
569 String type = e.getAttribute("type");
570 SessionLayerImporter imp = getSessionLayerImporter(type);
571 if (imp == null && !GraphicsEnvironment.isHeadless()) {
572 CancelOrContinueDialog dialog = new CancelOrContinueDialog();
573 dialog.show(
574 tr("Unable to load layer"),
575 tr("Cannot load layer of type ''{0}'' because no suitable importer was found.", type),
576 JOptionPane.WARNING_MESSAGE
577 );
578 if (dialog.isCancel()) {
579 progressMonitor.cancel();
580 return;
581 } else {
582 continue;
583 }
584 } else if (imp != null) {
585 importers.put(idx, imp);
586 List<LayerDependency> depsImp = new ArrayList<>();
587 for (int d : deps.get(idx)) {
588 SessionLayerImporter dImp = importers.get(d);
589 if (dImp == null) {
590 CancelOrContinueDialog dialog = new CancelOrContinueDialog();
591 dialog.show(
592 tr("Unable to load layer"),
593 tr("Cannot load layer {0} because it depends on layer {1} which has been skipped.", idx, d),
594 JOptionPane.WARNING_MESSAGE
595 );
596 if (dialog.isCancel()) {
597 progressMonitor.cancel();
598 return;
599 } else {
600 continue LAYER;
601 }
602 }
603 depsImp.add(new LayerDependency(d, layersMap.get(d), dImp));
604 }
605 ImportSupport support = new ImportSupport(name, idx, depsImp);
606 Layer layer = null;
607 Exception exception = null;
608 try {
609 layer = imp.load(e, support, progressMonitor.createSubTaskMonitor(1, false));
610 if (layer == null) {
611 throw new IllegalStateException("Importer " + imp + " returned null for " + support);
612 }
613 } catch (IllegalDataException | IllegalArgumentException | IllegalStateException | IOException ex) {
614 exception = ex;
615 }
616 if (exception != null) {
617 Logging.error(exception);
618 if (!GraphicsEnvironment.isHeadless()) {
619 CancelOrContinueDialog dialog = new CancelOrContinueDialog();
620 dialog.show(
621 tr("Error loading layer"),
622 tr("<html>Could not load layer {0} ''{1}''.<br>Error is:<br>{2}</html>", idx,
623 Utils.escapeReservedCharactersHTML(name),
624 Utils.escapeReservedCharactersHTML(exception.getMessage())),
625 JOptionPane.ERROR_MESSAGE
626 );
627 if (dialog.isCancel()) {
628 progressMonitor.cancel();
629 return;
630 } else {
631 continue;
632 }
633 }
634 }
635
636 layersMap.put(idx, layer);
637 setLayerAttributes(layer, e);
638
639 if (support.getSubLayers() != null) {
640 support.getSubLayers().forEach((Integer markerIndex, Entry<Layer, Element> entry) -> {
641 Layer subLayer = entry.getKey();
642 Element subElement = entry.getValue();
643
644 layersMap.put(markerIndex, subLayer);
645 setLayerAttributes(subLayer, subElement);
646 });
647 }
648
649 }
650 if (progressMonitor.isCanceled())
651 return;
652 progressMonitor.worked(1);
653 }
654
655
656 layers = new ArrayList<>();
657 for (Entry<Integer, Layer> entry : layersMap.entrySet()) {
658 Layer layer = entry.getValue();
659 if (layer != null) {
660 layers.add(layer);
661 }
662 }
663 }
664
665 private static void setLayerAttributes(Layer layer, Element e) {
666 if (layer == null)
667 return;
668
669 if (e.hasAttribute("name")) {
670 layer.setName(e.getAttribute("name"));
671 }
672 if (e.hasAttribute("visible")) {
673 layer.setVisible(Boolean.parseBoolean(e.getAttribute("visible")));
674 }
675 if (e.hasAttribute("opacity")) {
676 try {
677 double opacity = Double.parseDouble(e.getAttribute("opacity"));
678 layer.setOpacity(opacity);
679 } catch (NumberFormatException ex) {
680 Logging.warn(ex);
681 }
682 }
683 }
684
685 private static SessionViewportData readViewportData(Element root) {
686 Element viewportEl = getElementByTagName(root, "viewport");
687 if (viewportEl == null) return null;
688 LatLon center = null;
689 Element centerEl = getElementByTagName(viewportEl, "center");
690 if (centerEl == null || !centerEl.hasAttribute("lat") || !centerEl.hasAttribute("lon")) return null;
691 try {
692 center = new LatLon(Double.parseDouble(centerEl.getAttribute("lat")),
693 Double.parseDouble(centerEl.getAttribute("lon")));
694 } catch (NumberFormatException ex) {
695 Logging.warn(ex);
696 }
697 if (center == null) return null;
698 Element scaleEl = getElementByTagName(viewportEl, "scale");
699 if (scaleEl == null || !scaleEl.hasAttribute("meter-per-pixel")) return null;
700 try {
701 double scale = Double.parseDouble(scaleEl.getAttribute("meter-per-pixel"));
702 return new SessionViewportData(center, scale);
703 } catch (NumberFormatException ex) {
704 Logging.warn(ex);
705 return null;
706 }
707 }
708
709 private static SessionProjectionChoiceData readProjectionChoiceData(Element root) {
710 Element projectionEl = getElementByTagName(root, "projection");
711 if (projectionEl == null) return null;
712 Element projectionChoiceEl = getElementByTagName(projectionEl, "projection-choice");
713 if (projectionChoiceEl == null) return null;
714 Element idEl = getElementByTagName(projectionChoiceEl, "id");
715 if (idEl == null) return null;
716 String id = idEl.getTextContent();
717 Element parametersEl = getElementByTagName(projectionChoiceEl, "parameters");
718 if (parametersEl == null) return null;
719 NodeList paramNl = parametersEl.getElementsByTagName("param");
720 int length = paramNl.getLength();
721 Collection<String> parameters = IntStream.range(0, length)
722 .mapToObj(i -> (Element) paramNl.item(i)).map(Node::getTextContent)
723 .collect(Collectors.toList());
724 return new SessionProjectionChoiceData(id, parameters);
725 }
726
727 /**
728 * Show Dialog when there is an error for one layer.
729 * Ask the user whether to cancel the complete session loading or just to skip this layer.
730 * <p>
731 * This is expected to run in a worker thread (PleaseWaitRunnable), so invokeAndWait is
732 * needed to block the current thread and wait for the result of the modal dialog from EDT.
733 */
734 private static final class CancelOrContinueDialog {
735
736 private boolean cancel;
737
738 void show(final String title, final String message, final int icon) {
739 try {
740 SwingUtilities.invokeAndWait(() -> {
741 ExtendedDialog dlg = new ExtendedDialog(
742 MainApplication.getMainFrame(),
743 title,
744 tr("Cancel"), tr("Skip layer and continue"))
745 .setButtonIcons("cancel", "dialogs/next")
746 .setIcon(icon)
747 .setContent(message);
748 cancel = dlg.showDialog().getValue() != 2;
749 });
750 } catch (InvocationTargetException | InterruptedException ex) {
751 throw new JosmRuntimeException(ex);
752 }
753 }
754
755 public boolean isCancel() {
756 return cancel;
757 }
758 }
759
760 private void loadPluginData() {
761 if (!zip) {
762 return;
763 }
764 for (PluginSessionImporter importer : PluginHandler.load(PluginSessionImporter.class)) {
765 try {
766 this.pluginData |= importer.readZipFile(zipFile);
767 } catch (IOException ioException) {
768 GuiHelper.runInEDT(() -> ExceptionDialogUtil.explainException(ioException));
769 }
770 }
771 }
772
773 /**
774 * Loads session from the given file.
775 * @param sessionFile session file to load
776 * @param zip {@code true} if it's a zipped session (.joz)
777 * @param progressMonitor progress monitor
778 * @throws IllegalDataException if invalid data is detected
779 * @throws IOException if any I/O error occurs
780 */
781 public void loadSession(File sessionFile, boolean zip, ProgressMonitor progressMonitor) throws IllegalDataException, IOException {
782 try (InputStream josIS = createInputStream(sessionFile, zip)) {
783 loadSession(josIS, sessionFile.toURI(), zip, progressMonitor);
784 this.postLoadTasks.add(this::loadPluginData);
785 }
786 }
787
788 private InputStream createInputStream(File sessionFile, boolean zip) throws IOException, IllegalDataException {
789 if (zip) {
790 try {
791 zipFile = new ZipFile(sessionFile, StandardCharsets.UTF_8);
792 return getZipInputStream(zipFile);
793 } catch (ZipException ex) {
794 throw new IOException(ex);
795 }
796 } else {
797 return Files.newInputStream(sessionFile.toPath());
798 }
799 }
800
801 private static InputStream getZipInputStream(ZipFile zipFile) throws IOException, IllegalDataException {
802 ZipEntry josEntry = null;
803 Enumeration<? extends ZipEntry> entries = zipFile.entries();
804 while (entries.hasMoreElements()) {
805 ZipEntry entry = entries.nextElement();
806 if (Utils.hasExtension(entry.getName(), "jos")) {
807 josEntry = entry;
808 break;
809 }
810 }
811 if (josEntry == null) {
812 error(tr("expected .jos file inside .joz archive"));
813 }
814 return zipFile.getInputStream(josEntry);
815 }
816
817 /**
818 * Loads session from the given input stream.
819 * @param josIS session stream to load
820 * @param zip {@code true} if it's a zipped session (.joz)
821 * @param sessionFileURI URI of the underlying session file
822 * @param progressMonitor progress monitor
823 * @throws IllegalDataException if invalid data is detected
824 * @throws IOException if any I/O error occurs
825 * @since 15070
826 */
827 public void loadSession(InputStream josIS, URI sessionFileURI, boolean zip, ProgressMonitor progressMonitor)
828 throws IOException, IllegalDataException {
829
830 this.sessionFileURI = sessionFileURI;
831 this.zip = zip;
832
833 try {
834 parseJos(XmlUtils.parseSafeDOM(josIS), progressMonitor != null ? progressMonitor : NullProgressMonitor.INSTANCE);
835 } catch (SAXException e) {
836 throw new IllegalDataException(e);
837 } catch (ParserConfigurationException e) {
838 throw new IOException(e);
839 }
840 }
841
842 private static Element getElementByTagName(Element root, String name) {
843 NodeList els = root.getElementsByTagName(name);
844 return els.getLength() > 0 ? (Element) els.item(0) : null;
845 }
846}
Note: See TracBrowser for help on using the repository browser.